1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Copyright (C) 2015 Karol Kosik <karo9@interia.eu> |
4 | * Copyright (C) 2015-2016 Samsung Electronics |
5 | * Igor Kotrasinski <i.kotrasinsk@samsung.com> |
6 | * Krzysztof Opasiak <k.opasiak@samsung.com> |
7 | */ |
8 | |
9 | #include <linux/device.h> |
10 | #include <linux/kernel.h> |
11 | #include <linux/list.h> |
12 | #include <linux/platform_device.h> |
13 | #include <linux/usb.h> |
14 | #include <linux/usb/gadget.h> |
15 | #include <linux/usb/hcd.h> |
16 | #include <linux/kthread.h> |
17 | #include <linux/file.h> |
18 | #include <linux/byteorder/generic.h> |
19 | |
20 | #include "usbip_common.h" |
21 | #include "vudc.h" |
22 | |
23 | #define VIRTUAL_ENDPOINTS (1 /* ep0 */ + 15 /* in eps */ + 15 /* out eps */) |
24 | |
25 | /* urb-related structures alloc / free */ |
26 | |
27 | |
28 | static void free_urb(struct urb *urb) |
29 | { |
30 | if (!urb) |
31 | return; |
32 | |
33 | kfree(objp: urb->setup_packet); |
34 | urb->setup_packet = NULL; |
35 | |
36 | kfree(objp: urb->transfer_buffer); |
37 | urb->transfer_buffer = NULL; |
38 | |
39 | usb_free_urb(urb); |
40 | } |
41 | |
42 | struct urbp *alloc_urbp(void) |
43 | { |
44 | struct urbp *urb_p; |
45 | |
46 | urb_p = kzalloc(size: sizeof(*urb_p), GFP_KERNEL); |
47 | if (!urb_p) |
48 | return urb_p; |
49 | |
50 | urb_p->urb = NULL; |
51 | urb_p->ep = NULL; |
52 | INIT_LIST_HEAD(list: &urb_p->urb_entry); |
53 | return urb_p; |
54 | } |
55 | |
56 | static void free_urbp(struct urbp *urb_p) |
57 | { |
58 | kfree(objp: urb_p); |
59 | } |
60 | |
61 | void free_urbp_and_urb(struct urbp *urb_p) |
62 | { |
63 | if (!urb_p) |
64 | return; |
65 | free_urb(urb: urb_p->urb); |
66 | free_urbp(urb_p); |
67 | } |
68 | |
69 | |
70 | /* utilities ; almost verbatim from dummy_hcd.c */ |
71 | |
72 | /* called with spinlock held */ |
73 | static void nuke(struct vudc *udc, struct vep *ep) |
74 | { |
75 | struct vrequest *req; |
76 | |
77 | while (!list_empty(head: &ep->req_queue)) { |
78 | req = list_first_entry(&ep->req_queue, struct vrequest, |
79 | req_entry); |
80 | list_del_init(entry: &req->req_entry); |
81 | req->req.status = -ESHUTDOWN; |
82 | |
83 | spin_unlock(lock: &udc->lock); |
84 | usb_gadget_giveback_request(ep: &ep->ep, req: &req->req); |
85 | spin_lock(lock: &udc->lock); |
86 | } |
87 | } |
88 | |
89 | /* caller must hold lock */ |
90 | static void stop_activity(struct vudc *udc) |
91 | { |
92 | int i; |
93 | struct urbp *urb_p, *tmp; |
94 | |
95 | udc->address = 0; |
96 | |
97 | for (i = 0; i < VIRTUAL_ENDPOINTS; i++) |
98 | nuke(udc, ep: &udc->ep[i]); |
99 | |
100 | list_for_each_entry_safe(urb_p, tmp, &udc->urb_queue, urb_entry) { |
101 | list_del(entry: &urb_p->urb_entry); |
102 | free_urbp_and_urb(urb_p); |
103 | } |
104 | } |
105 | |
106 | struct vep *vudc_find_endpoint(struct vudc *udc, u8 address) |
107 | { |
108 | int i; |
109 | |
110 | if ((address & ~USB_DIR_IN) == 0) |
111 | return &udc->ep[0]; |
112 | |
113 | for (i = 1; i < VIRTUAL_ENDPOINTS; i++) { |
114 | struct vep *ep = &udc->ep[i]; |
115 | |
116 | if (!ep->desc) |
117 | continue; |
118 | if (ep->desc->bEndpointAddress == address) |
119 | return ep; |
120 | } |
121 | return NULL; |
122 | } |
123 | |
124 | /* gadget ops */ |
125 | |
126 | static int vgadget_get_frame(struct usb_gadget *_gadget) |
127 | { |
128 | struct timespec64 now; |
129 | struct vudc *udc = usb_gadget_to_vudc(_gadget); |
130 | |
131 | ktime_get_ts64(ts: &now); |
132 | return ((now.tv_sec - udc->start_time.tv_sec) * 1000 + |
133 | (now.tv_nsec - udc->start_time.tv_nsec) / NSEC_PER_MSEC) |
134 | & 0x7FF; |
135 | } |
136 | |
137 | static int vgadget_set_selfpowered(struct usb_gadget *_gadget, int value) |
138 | { |
139 | struct vudc *udc = usb_gadget_to_vudc(_gadget); |
140 | |
141 | if (value) |
142 | udc->devstatus |= (1 << USB_DEVICE_SELF_POWERED); |
143 | else |
144 | udc->devstatus &= ~(1 << USB_DEVICE_SELF_POWERED); |
145 | return 0; |
146 | } |
147 | |
148 | static int vgadget_pullup(struct usb_gadget *_gadget, int value) |
149 | { |
150 | struct vudc *udc = usb_gadget_to_vudc(_gadget); |
151 | unsigned long flags; |
152 | int ret; |
153 | |
154 | |
155 | spin_lock_irqsave(&udc->lock, flags); |
156 | value = !!value; |
157 | if (value == udc->pullup) |
158 | goto unlock; |
159 | |
160 | udc->pullup = value; |
161 | if (value) { |
162 | udc->gadget.speed = min_t(u8, USB_SPEED_HIGH, |
163 | udc->driver->max_speed); |
164 | udc->ep[0].ep.maxpacket = 64; |
165 | /* |
166 | * This is the first place where we can ask our |
167 | * gadget driver for descriptors. |
168 | */ |
169 | ret = get_gadget_descs(udc); |
170 | if (ret) { |
171 | dev_err(&udc->gadget.dev, "Unable go get desc: %d" , ret); |
172 | goto unlock; |
173 | } |
174 | |
175 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
176 | usbip_start_eh(ud: &udc->ud); |
177 | } else { |
178 | /* Invalidate descriptors */ |
179 | udc->desc_cached = 0; |
180 | |
181 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
182 | usbip_event_add(ud: &udc->ud, VUDC_EVENT_REMOVED); |
183 | usbip_stop_eh(ud: &udc->ud); /* Wait for eh completion */ |
184 | } |
185 | |
186 | return 0; |
187 | |
188 | unlock: |
189 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
190 | return 0; |
191 | } |
192 | |
193 | static int vgadget_udc_start(struct usb_gadget *g, |
194 | struct usb_gadget_driver *driver) |
195 | { |
196 | struct vudc *udc = usb_gadget_to_vudc(gadget: g); |
197 | unsigned long flags; |
198 | |
199 | spin_lock_irqsave(&udc->lock, flags); |
200 | udc->driver = driver; |
201 | udc->pullup = udc->connected = udc->desc_cached = 0; |
202 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
203 | |
204 | return 0; |
205 | } |
206 | |
207 | static int vgadget_udc_stop(struct usb_gadget *g) |
208 | { |
209 | struct vudc *udc = usb_gadget_to_vudc(gadget: g); |
210 | unsigned long flags; |
211 | |
212 | spin_lock_irqsave(&udc->lock, flags); |
213 | udc->driver = NULL; |
214 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
215 | return 0; |
216 | } |
217 | |
218 | static const struct usb_gadget_ops vgadget_ops = { |
219 | .get_frame = vgadget_get_frame, |
220 | .set_selfpowered = vgadget_set_selfpowered, |
221 | .pullup = vgadget_pullup, |
222 | .udc_start = vgadget_udc_start, |
223 | .udc_stop = vgadget_udc_stop, |
224 | }; |
225 | |
226 | |
227 | /* endpoint ops */ |
228 | |
229 | static int vep_enable(struct usb_ep *_ep, |
230 | const struct usb_endpoint_descriptor *desc) |
231 | { |
232 | struct vep *ep; |
233 | struct vudc *udc; |
234 | unsigned int maxp; |
235 | unsigned long flags; |
236 | |
237 | ep = to_vep(_ep); |
238 | udc = ep_to_vudc(ep); |
239 | |
240 | if (!_ep || !desc || ep->desc || _ep->caps.type_control |
241 | || desc->bDescriptorType != USB_DT_ENDPOINT) |
242 | return -EINVAL; |
243 | |
244 | if (!udc->driver) |
245 | return -ESHUTDOWN; |
246 | |
247 | spin_lock_irqsave(&udc->lock, flags); |
248 | |
249 | maxp = usb_endpoint_maxp(epd: desc); |
250 | _ep->maxpacket = maxp; |
251 | ep->desc = desc; |
252 | ep->type = usb_endpoint_type(epd: desc); |
253 | ep->halted = ep->wedged = 0; |
254 | |
255 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
256 | |
257 | return 0; |
258 | } |
259 | |
260 | static int vep_disable(struct usb_ep *_ep) |
261 | { |
262 | struct vep *ep; |
263 | struct vudc *udc; |
264 | unsigned long flags; |
265 | |
266 | ep = to_vep(_ep); |
267 | udc = ep_to_vudc(ep); |
268 | if (!_ep || !ep->desc || _ep->caps.type_control) |
269 | return -EINVAL; |
270 | |
271 | spin_lock_irqsave(&udc->lock, flags); |
272 | ep->desc = NULL; |
273 | nuke(udc, ep); |
274 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
275 | |
276 | return 0; |
277 | } |
278 | |
279 | static struct usb_request *vep_alloc_request(struct usb_ep *_ep, |
280 | gfp_t mem_flags) |
281 | { |
282 | struct vrequest *req; |
283 | |
284 | if (!_ep) |
285 | return NULL; |
286 | |
287 | req = kzalloc(size: sizeof(*req), flags: mem_flags); |
288 | if (!req) |
289 | return NULL; |
290 | |
291 | INIT_LIST_HEAD(list: &req->req_entry); |
292 | |
293 | return &req->req; |
294 | } |
295 | |
296 | static void vep_free_request(struct usb_ep *_ep, struct usb_request *_req) |
297 | { |
298 | struct vrequest *req; |
299 | |
300 | /* ep is always valid here - see usb_ep_free_request() */ |
301 | if (!_req) |
302 | return; |
303 | |
304 | req = to_vrequest(_req); |
305 | kfree(objp: req); |
306 | } |
307 | |
308 | static int vep_queue(struct usb_ep *_ep, struct usb_request *_req, |
309 | gfp_t mem_flags) |
310 | { |
311 | struct vep *ep; |
312 | struct vrequest *req; |
313 | struct vudc *udc; |
314 | unsigned long flags; |
315 | |
316 | if (!_ep || !_req) |
317 | return -EINVAL; |
318 | |
319 | ep = to_vep(_ep); |
320 | req = to_vrequest(_req); |
321 | udc = ep_to_vudc(ep); |
322 | |
323 | spin_lock_irqsave(&udc->lock, flags); |
324 | _req->actual = 0; |
325 | _req->status = -EINPROGRESS; |
326 | |
327 | list_add_tail(new: &req->req_entry, head: &ep->req_queue); |
328 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
329 | |
330 | return 0; |
331 | } |
332 | |
333 | static int vep_dequeue(struct usb_ep *_ep, struct usb_request *_req) |
334 | { |
335 | struct vep *ep; |
336 | struct vrequest *req; |
337 | struct vudc *udc; |
338 | struct vrequest *lst; |
339 | unsigned long flags; |
340 | int ret = -EINVAL; |
341 | |
342 | if (!_ep || !_req) |
343 | return ret; |
344 | |
345 | ep = to_vep(_ep); |
346 | req = to_vrequest(_req); |
347 | udc = req->udc; |
348 | |
349 | if (!udc->driver) |
350 | return -ESHUTDOWN; |
351 | |
352 | spin_lock_irqsave(&udc->lock, flags); |
353 | list_for_each_entry(lst, &ep->req_queue, req_entry) { |
354 | if (&lst->req == _req) { |
355 | list_del_init(entry: &lst->req_entry); |
356 | _req->status = -ECONNRESET; |
357 | ret = 0; |
358 | break; |
359 | } |
360 | } |
361 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
362 | |
363 | if (ret == 0) |
364 | usb_gadget_giveback_request(ep: _ep, req: _req); |
365 | |
366 | return ret; |
367 | } |
368 | |
369 | static int |
370 | vep_set_halt_and_wedge(struct usb_ep *_ep, int value, int wedged) |
371 | { |
372 | struct vep *ep; |
373 | struct vudc *udc; |
374 | unsigned long flags; |
375 | int ret = 0; |
376 | |
377 | ep = to_vep(_ep); |
378 | if (!_ep) |
379 | return -EINVAL; |
380 | |
381 | udc = ep_to_vudc(ep); |
382 | if (!udc->driver) |
383 | return -ESHUTDOWN; |
384 | |
385 | spin_lock_irqsave(&udc->lock, flags); |
386 | if (!value) |
387 | ep->halted = ep->wedged = 0; |
388 | else if (ep->desc && (ep->desc->bEndpointAddress & USB_DIR_IN) && |
389 | !list_empty(head: &ep->req_queue)) |
390 | ret = -EAGAIN; |
391 | else { |
392 | ep->halted = 1; |
393 | if (wedged) |
394 | ep->wedged = 1; |
395 | } |
396 | |
397 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
398 | return ret; |
399 | } |
400 | |
401 | static int |
402 | vep_set_halt(struct usb_ep *_ep, int value) |
403 | { |
404 | return vep_set_halt_and_wedge(_ep, value, wedged: 0); |
405 | } |
406 | |
407 | static int vep_set_wedge(struct usb_ep *_ep) |
408 | { |
409 | return vep_set_halt_and_wedge(_ep, value: 1, wedged: 1); |
410 | } |
411 | |
412 | static const struct usb_ep_ops vep_ops = { |
413 | .enable = vep_enable, |
414 | .disable = vep_disable, |
415 | |
416 | .alloc_request = vep_alloc_request, |
417 | .free_request = vep_free_request, |
418 | |
419 | .queue = vep_queue, |
420 | .dequeue = vep_dequeue, |
421 | |
422 | .set_halt = vep_set_halt, |
423 | .set_wedge = vep_set_wedge, |
424 | }; |
425 | |
426 | |
427 | /* shutdown / reset / error handlers */ |
428 | |
429 | static void vudc_shutdown(struct usbip_device *ud) |
430 | { |
431 | struct vudc *udc = container_of(ud, struct vudc, ud); |
432 | int call_disconnect = 0; |
433 | unsigned long flags; |
434 | |
435 | dev_dbg(&udc->pdev->dev, "device shutdown" ); |
436 | if (ud->tcp_socket) |
437 | kernel_sock_shutdown(sock: ud->tcp_socket, how: SHUT_RDWR); |
438 | |
439 | if (ud->tcp_rx) { |
440 | kthread_stop_put(k: ud->tcp_rx); |
441 | ud->tcp_rx = NULL; |
442 | } |
443 | if (ud->tcp_tx) { |
444 | kthread_stop_put(k: ud->tcp_tx); |
445 | ud->tcp_tx = NULL; |
446 | } |
447 | |
448 | if (ud->tcp_socket) { |
449 | sockfd_put(ud->tcp_socket); |
450 | ud->tcp_socket = NULL; |
451 | } |
452 | |
453 | spin_lock_irqsave(&udc->lock, flags); |
454 | stop_activity(udc); |
455 | if (udc->connected && udc->driver->disconnect) |
456 | call_disconnect = 1; |
457 | udc->connected = 0; |
458 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
459 | if (call_disconnect) |
460 | udc->driver->disconnect(&udc->gadget); |
461 | } |
462 | |
463 | static void vudc_device_reset(struct usbip_device *ud) |
464 | { |
465 | struct vudc *udc = container_of(ud, struct vudc, ud); |
466 | unsigned long flags; |
467 | |
468 | dev_dbg(&udc->pdev->dev, "device reset" ); |
469 | spin_lock_irqsave(&udc->lock, flags); |
470 | stop_activity(udc); |
471 | spin_unlock_irqrestore(lock: &udc->lock, flags); |
472 | if (udc->driver) |
473 | usb_gadget_udc_reset(gadget: &udc->gadget, driver: udc->driver); |
474 | spin_lock_irqsave(&ud->lock, flags); |
475 | ud->status = SDEV_ST_AVAILABLE; |
476 | spin_unlock_irqrestore(lock: &ud->lock, flags); |
477 | } |
478 | |
479 | static void vudc_device_unusable(struct usbip_device *ud) |
480 | { |
481 | unsigned long flags; |
482 | |
483 | spin_lock_irqsave(&ud->lock, flags); |
484 | ud->status = SDEV_ST_ERROR; |
485 | spin_unlock_irqrestore(lock: &ud->lock, flags); |
486 | } |
487 | |
488 | /* device setup / cleanup */ |
489 | |
490 | struct vudc_device *alloc_vudc_device(int devid) |
491 | { |
492 | struct vudc_device *udc_dev; |
493 | |
494 | udc_dev = kzalloc(size: sizeof(*udc_dev), GFP_KERNEL); |
495 | if (!udc_dev) |
496 | return NULL; |
497 | |
498 | INIT_LIST_HEAD(list: &udc_dev->dev_entry); |
499 | |
500 | udc_dev->pdev = platform_device_alloc(GADGET_NAME, id: devid); |
501 | if (!udc_dev->pdev) { |
502 | kfree(objp: udc_dev); |
503 | udc_dev = NULL; |
504 | } |
505 | |
506 | return udc_dev; |
507 | } |
508 | |
509 | void put_vudc_device(struct vudc_device *udc_dev) |
510 | { |
511 | platform_device_put(pdev: udc_dev->pdev); |
512 | kfree(objp: udc_dev); |
513 | } |
514 | |
515 | static int init_vudc_hw(struct vudc *udc) |
516 | { |
517 | int i; |
518 | struct usbip_device *ud = &udc->ud; |
519 | struct vep *ep; |
520 | |
521 | udc->ep = kcalloc(VIRTUAL_ENDPOINTS, size: sizeof(*udc->ep), GFP_KERNEL); |
522 | if (!udc->ep) |
523 | goto nomem_ep; |
524 | |
525 | INIT_LIST_HEAD(list: &udc->gadget.ep_list); |
526 | |
527 | /* create ep0 and 15 in, 15 out general purpose eps */ |
528 | for (i = 0; i < VIRTUAL_ENDPOINTS; ++i) { |
529 | int is_out = i % 2; |
530 | int num = (i + 1) / 2; |
531 | |
532 | ep = &udc->ep[i]; |
533 | |
534 | sprintf(buf: ep->name, fmt: "ep%d%s" , num, |
535 | i ? (is_out ? "out" : "in" ) : "" ); |
536 | ep->ep.name = ep->name; |
537 | |
538 | ep->ep.ops = &vep_ops; |
539 | |
540 | usb_ep_set_maxpacket_limit(ep: &ep->ep, maxpacket_limit: ~0); |
541 | ep->ep.max_streams = 16; |
542 | ep->gadget = &udc->gadget; |
543 | INIT_LIST_HEAD(list: &ep->req_queue); |
544 | |
545 | if (i == 0) { |
546 | /* ep0 */ |
547 | ep->ep.caps.type_control = true; |
548 | ep->ep.caps.dir_out = true; |
549 | ep->ep.caps.dir_in = true; |
550 | |
551 | udc->gadget.ep0 = &ep->ep; |
552 | } else { |
553 | /* All other eps */ |
554 | ep->ep.caps.type_iso = true; |
555 | ep->ep.caps.type_int = true; |
556 | ep->ep.caps.type_bulk = true; |
557 | |
558 | if (is_out) |
559 | ep->ep.caps.dir_out = true; |
560 | else |
561 | ep->ep.caps.dir_in = true; |
562 | |
563 | list_add_tail(new: &ep->ep.ep_list, head: &udc->gadget.ep_list); |
564 | } |
565 | } |
566 | |
567 | spin_lock_init(&udc->lock); |
568 | spin_lock_init(&udc->lock_tx); |
569 | INIT_LIST_HEAD(list: &udc->urb_queue); |
570 | INIT_LIST_HEAD(list: &udc->tx_queue); |
571 | init_waitqueue_head(&udc->tx_waitq); |
572 | |
573 | spin_lock_init(&ud->lock); |
574 | mutex_init(&ud->sysfs_lock); |
575 | ud->status = SDEV_ST_AVAILABLE; |
576 | ud->side = USBIP_VUDC; |
577 | |
578 | ud->eh_ops.shutdown = vudc_shutdown; |
579 | ud->eh_ops.reset = vudc_device_reset; |
580 | ud->eh_ops.unusable = vudc_device_unusable; |
581 | |
582 | v_init_timer(udc); |
583 | return 0; |
584 | |
585 | nomem_ep: |
586 | return -ENOMEM; |
587 | } |
588 | |
589 | static void cleanup_vudc_hw(struct vudc *udc) |
590 | { |
591 | kfree(objp: udc->ep); |
592 | } |
593 | |
594 | /* platform driver ops */ |
595 | |
596 | int vudc_probe(struct platform_device *pdev) |
597 | { |
598 | struct vudc *udc; |
599 | int ret = -ENOMEM; |
600 | |
601 | udc = kzalloc(size: sizeof(*udc), GFP_KERNEL); |
602 | if (!udc) |
603 | goto out; |
604 | |
605 | udc->gadget.name = GADGET_NAME; |
606 | udc->gadget.ops = &vgadget_ops; |
607 | udc->gadget.max_speed = USB_SPEED_HIGH; |
608 | udc->gadget.dev.parent = &pdev->dev; |
609 | udc->pdev = pdev; |
610 | |
611 | ret = init_vudc_hw(udc); |
612 | if (ret) |
613 | goto err_init_vudc_hw; |
614 | |
615 | ret = usb_add_gadget_udc(parent: &pdev->dev, gadget: &udc->gadget); |
616 | if (ret < 0) |
617 | goto err_add_udc; |
618 | |
619 | platform_set_drvdata(pdev, data: udc); |
620 | |
621 | return ret; |
622 | |
623 | err_add_udc: |
624 | cleanup_vudc_hw(udc); |
625 | err_init_vudc_hw: |
626 | kfree(objp: udc); |
627 | out: |
628 | return ret; |
629 | } |
630 | |
631 | int vudc_remove(struct platform_device *pdev) |
632 | { |
633 | struct vudc *udc = platform_get_drvdata(pdev); |
634 | |
635 | usb_del_gadget_udc(gadget: &udc->gadget); |
636 | cleanup_vudc_hw(udc); |
637 | kfree(objp: udc); |
638 | return 0; |
639 | } |
640 | |