1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/init.h>
21#include <linux/file.h>
22#include <linux/kernel.h>
23#include <linux/kthread.h>
24#include <linux/module.h>
25#include <linux/platform_device.h>
26#include <linux/slab.h>
27
28#include "usbip_common.h"
29#include "vhci.h"
30
31#define DRIVER_AUTHOR "Takahiro Hirofuchi"
32#define DRIVER_DESC "USB/IP 'Virtual' Host Controller (VHCI) Driver"
33
34
35
36
37
38
39
40
41
42
43
44
45
46static int vhci_hub_status(struct usb_hcd *hcd, char *buff);
47static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
48 u16 wIndex, char *buff, u16 wLength);
49static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
50 gfp_t mem_flags);
51static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
52static int vhci_start(struct usb_hcd *vhci_hcd);
53static void vhci_stop(struct usb_hcd *hcd);
54static int vhci_get_frame_number(struct usb_hcd *hcd);
55
56static const char driver_name[] = "vhci_hcd";
57static const char driver_desc[] = "USB/IP Virtual Host Controller";
58
59struct vhci_hcd *the_controller;
60
61static const char * const bit_desc[] = {
62 "CONNECTION",
63 "ENABLE",
64 "SUSPEND",
65 "OVER_CURRENT",
66 "RESET",
67 "R5",
68 "R6",
69 "R7",
70 "POWER",
71 "LOWSPEED",
72 "HIGHSPEED",
73 "PORT_TEST",
74 "INDICATOR",
75 "R13",
76 "R14",
77 "R15",
78 "C_CONNECTION",
79 "C_ENABLE",
80 "C_SUSPEND",
81 "C_OVER_CURRENT",
82 "C_RESET",
83 "R21",
84 "R22",
85 "R23",
86 "R24",
87 "R25",
88 "R26",
89 "R27",
90 "R28",
91 "R29",
92 "R30",
93 "R31",
94};
95
96static void dump_port_status_diff(u32 prev_status, u32 new_status)
97{
98 int i = 0;
99 u32 bit = 1;
100
101 pr_debug("status prev -> new: %08x -> %08x\n", prev_status, new_status);
102 while (bit) {
103 u32 prev = prev_status & bit;
104 u32 new = new_status & bit;
105 char change;
106
107 if (!prev && new)
108 change = '+';
109 else if (prev && !new)
110 change = '-';
111 else
112 change = ' ';
113
114 if (prev || new)
115 pr_debug(" %c%s\n", change, bit_desc[i]);
116 bit <<= 1;
117 i++;
118 }
119 pr_debug("\n");
120}
121
122void rh_port_connect(int rhport, enum usb_device_speed speed)
123{
124 usbip_dbg_vhci_rh("rh_port_connect %d\n", rhport);
125
126 spin_lock(&the_controller->lock);
127
128 the_controller->port_status[rhport] |= USB_PORT_STAT_CONNECTION
129 | (1 << USB_PORT_FEAT_C_CONNECTION);
130
131 switch (speed) {
132 case USB_SPEED_HIGH:
133 the_controller->port_status[rhport] |= USB_PORT_STAT_HIGH_SPEED;
134 break;
135 case USB_SPEED_LOW:
136 the_controller->port_status[rhport] |= USB_PORT_STAT_LOW_SPEED;
137 break;
138 default:
139 break;
140 }
141
142 spin_unlock(&the_controller->lock);
143
144 usb_hcd_poll_rh_status(vhci_to_hcd(the_controller));
145}
146
147static void rh_port_disconnect(int rhport)
148{
149 usbip_dbg_vhci_rh("rh_port_disconnect %d\n", rhport);
150
151 spin_lock(&the_controller->lock);
152
153 the_controller->port_status[rhport] &= ~USB_PORT_STAT_CONNECTION;
154 the_controller->port_status[rhport] |=
155 (1 << USB_PORT_FEAT_C_CONNECTION);
156
157 spin_unlock(&the_controller->lock);
158 usb_hcd_poll_rh_status(vhci_to_hcd(the_controller));
159}
160
161#define PORT_C_MASK \
162 ((USB_PORT_STAT_C_CONNECTION \
163 | USB_PORT_STAT_C_ENABLE \
164 | USB_PORT_STAT_C_SUSPEND \
165 | USB_PORT_STAT_C_OVERCURRENT \
166 | USB_PORT_STAT_C_RESET) << 16)
167
168
169
170
171
172
173
174
175
176
177
178
179static int vhci_hub_status(struct usb_hcd *hcd, char *buf)
180{
181 struct vhci_hcd *vhci;
182 int retval;
183 int rhport;
184 int changed = 0;
185
186 retval = DIV_ROUND_UP(VHCI_NPORTS + 1, 8);
187 memset(buf, 0, retval);
188
189 vhci = hcd_to_vhci(hcd);
190
191 spin_lock(&vhci->lock);
192 if (!HCD_HW_ACCESSIBLE(hcd)) {
193 usbip_dbg_vhci_rh("hw accessible flag not on?\n");
194 goto done;
195 }
196
197
198 for (rhport = 0; rhport < VHCI_NPORTS; rhport++) {
199 if ((vhci->port_status[rhport] & PORT_C_MASK)) {
200
201 usbip_dbg_vhci_rh("port %d status changed\n", rhport);
202
203 buf[(rhport + 1) / 8] |= 1 << (rhport + 1) % 8;
204 changed = 1;
205 }
206 }
207
208 if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1))
209 usb_hcd_resume_root_hub(hcd);
210
211done:
212 spin_unlock(&vhci->lock);
213 return changed ? retval : 0;
214}
215
216static inline void hub_descriptor(struct usb_hub_descriptor *desc)
217{
218 memset(desc, 0, sizeof(*desc));
219 desc->bDescriptorType = 0x29;
220 desc->bDescLength = 9;
221 desc->wHubCharacteristics = (__constant_cpu_to_le16(0x0001));
222 desc->bNbrPorts = VHCI_NPORTS;
223 desc->u.hs.DeviceRemovable[0] = 0xff;
224 desc->u.hs.DeviceRemovable[1] = 0xff;
225}
226
227static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
228 u16 wIndex, char *buf, u16 wLength)
229{
230 struct vhci_hcd *dum;
231 int retval = 0;
232 int rhport;
233
234 u32 prev_port_status[VHCI_NPORTS];
235
236 if (!HCD_HW_ACCESSIBLE(hcd))
237 return -ETIMEDOUT;
238
239
240
241
242
243 usbip_dbg_vhci_rh("typeReq %x wValue %x wIndex %x\n", typeReq, wValue,
244 wIndex);
245 if (wIndex > VHCI_NPORTS)
246 pr_err("invalid port number %d\n", wIndex);
247 rhport = ((__u8)(wIndex & 0x00ff)) - 1;
248
249 dum = hcd_to_vhci(hcd);
250
251 spin_lock(&dum->lock);
252
253
254 if (usbip_dbg_flag_vhci_rh) {
255 memcpy(prev_port_status, dum->port_status,
256 sizeof(prev_port_status));
257 }
258
259 switch (typeReq) {
260 case ClearHubFeature:
261 usbip_dbg_vhci_rh(" ClearHubFeature\n");
262 break;
263 case ClearPortFeature:
264 switch (wValue) {
265 case USB_PORT_FEAT_SUSPEND:
266 if (dum->port_status[rhport] & USB_PORT_STAT_SUSPEND) {
267
268 dum->resuming = 1;
269 dum->re_timeout =
270 jiffies + msecs_to_jiffies(20);
271 }
272 break;
273 case USB_PORT_FEAT_POWER:
274 usbip_dbg_vhci_rh(
275 " ClearPortFeature: USB_PORT_FEAT_POWER\n");
276 dum->port_status[rhport] = 0;
277 dum->resuming = 0;
278 break;
279 case USB_PORT_FEAT_C_RESET:
280 usbip_dbg_vhci_rh(
281 " ClearPortFeature: USB_PORT_FEAT_C_RESET\n");
282 switch (dum->vdev[rhport].speed) {
283 case USB_SPEED_HIGH:
284 dum->port_status[rhport] |=
285 USB_PORT_STAT_HIGH_SPEED;
286 break;
287 case USB_SPEED_LOW:
288 dum->port_status[rhport] |=
289 USB_PORT_STAT_LOW_SPEED;
290 break;
291 default:
292 break;
293 }
294 default:
295 usbip_dbg_vhci_rh(" ClearPortFeature: default %x\n",
296 wValue);
297 dum->port_status[rhport] &= ~(1 << wValue);
298 break;
299 }
300 break;
301 case GetHubDescriptor:
302 usbip_dbg_vhci_rh(" GetHubDescriptor\n");
303 hub_descriptor((struct usb_hub_descriptor *) buf);
304 break;
305 case GetHubStatus:
306 usbip_dbg_vhci_rh(" GetHubStatus\n");
307 *(__le32 *) buf = cpu_to_le32(0);
308 break;
309 case GetPortStatus:
310 usbip_dbg_vhci_rh(" GetPortStatus port %x\n", wIndex);
311 if (wIndex > VHCI_NPORTS || wIndex < 1) {
312 pr_err("invalid port number %d\n", wIndex);
313 retval = -EPIPE;
314 }
315
316
317
318
319
320
321 if (dum->resuming && time_after(jiffies, dum->re_timeout)) {
322 dum->port_status[rhport] |=
323 (1 << USB_PORT_FEAT_C_SUSPEND);
324 dum->port_status[rhport] &=
325 ~(1 << USB_PORT_FEAT_SUSPEND);
326 dum->resuming = 0;
327 dum->re_timeout = 0;
328 }
329
330 if ((dum->port_status[rhport] & (1 << USB_PORT_FEAT_RESET)) !=
331 0 && time_after(jiffies, dum->re_timeout)) {
332 dum->port_status[rhport] |=
333 (1 << USB_PORT_FEAT_C_RESET);
334 dum->port_status[rhport] &=
335 ~(1 << USB_PORT_FEAT_RESET);
336 dum->re_timeout = 0;
337
338 if (dum->vdev[rhport].ud.status ==
339 VDEV_ST_NOTASSIGNED) {
340 usbip_dbg_vhci_rh(
341 " enable rhport %d (status %u)\n",
342 rhport,
343 dum->vdev[rhport].ud.status);
344 dum->port_status[rhport] |=
345 USB_PORT_STAT_ENABLE;
346 }
347 }
348 ((__le16 *) buf)[0] = cpu_to_le16(dum->port_status[rhport]);
349 ((__le16 *) buf)[1] =
350 cpu_to_le16(dum->port_status[rhport] >> 16);
351
352 usbip_dbg_vhci_rh(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
353 ((u16 *)buf)[1]);
354 break;
355 case SetHubFeature:
356 usbip_dbg_vhci_rh(" SetHubFeature\n");
357 retval = -EPIPE;
358 break;
359 case SetPortFeature:
360 switch (wValue) {
361 case USB_PORT_FEAT_SUSPEND:
362 usbip_dbg_vhci_rh(
363 " SetPortFeature: USB_PORT_FEAT_SUSPEND\n");
364 break;
365 case USB_PORT_FEAT_RESET:
366 usbip_dbg_vhci_rh(
367 " SetPortFeature: USB_PORT_FEAT_RESET\n");
368
369 if (dum->port_status[rhport] & USB_PORT_STAT_ENABLE) {
370 dum->port_status[rhport] &=
371 ~(USB_PORT_STAT_ENABLE |
372 USB_PORT_STAT_LOW_SPEED |
373 USB_PORT_STAT_HIGH_SPEED);
374
375 }
376
377 dum->re_timeout = jiffies + msecs_to_jiffies(50);
378
379
380 default:
381 usbip_dbg_vhci_rh(" SetPortFeature: default %d\n",
382 wValue);
383 dum->port_status[rhport] |= (1 << wValue);
384 break;
385 }
386 break;
387
388 default:
389 pr_err("default: no such request\n");
390
391
392 retval = -EPIPE;
393 }
394
395 if (usbip_dbg_flag_vhci_rh) {
396 pr_debug("port %d\n", rhport);
397
398 if (rhport >= 0) {
399 dump_port_status_diff(prev_port_status[rhport],
400 dum->port_status[rhport]);
401 }
402 }
403 usbip_dbg_vhci_rh(" bye\n");
404
405 spin_unlock(&dum->lock);
406
407 return retval;
408}
409
410static struct vhci_device *get_vdev(struct usb_device *udev)
411{
412 int i;
413
414 if (!udev)
415 return NULL;
416
417 for (i = 0; i < VHCI_NPORTS; i++)
418 if (the_controller->vdev[i].udev == udev)
419 return port_to_vdev(i);
420
421 return NULL;
422}
423
424static void vhci_tx_urb(struct urb *urb)
425{
426 struct vhci_device *vdev = get_vdev(urb->dev);
427 struct vhci_priv *priv;
428
429 if (!vdev) {
430 pr_err("could not get virtual device");
431 return;
432 }
433
434 priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
435 if (!priv) {
436 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
437 return;
438 }
439
440 spin_lock(&vdev->priv_lock);
441
442 priv->seqnum = atomic_inc_return(&the_controller->seqnum);
443 if (priv->seqnum == 0xffff)
444 dev_info(&urb->dev->dev, "seqnum max\n");
445
446 priv->vdev = vdev;
447 priv->urb = urb;
448
449 urb->hcpriv = (void *) priv;
450
451 list_add_tail(&priv->list, &vdev->priv_tx);
452
453 wake_up(&vdev->waitq_tx);
454 spin_unlock(&vdev->priv_lock);
455}
456
457static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
458 gfp_t mem_flags)
459{
460 struct device *dev = &urb->dev->dev;
461 int ret = 0;
462 struct vhci_device *vdev;
463
464 usbip_dbg_vhci_hc("enter, usb_hcd %p urb %p mem_flags %d\n",
465 hcd, urb, mem_flags);
466
467
468 BUG_ON(!urb->transfer_buffer && urb->transfer_buffer_length);
469
470 spin_lock(&the_controller->lock);
471
472 if (urb->status != -EINPROGRESS) {
473 dev_err(dev, "URB already unlinked!, status %d\n", urb->status);
474 spin_unlock(&the_controller->lock);
475 return urb->status;
476 }
477
478 vdev = port_to_vdev(urb->dev->portnum-1);
479
480
481 spin_lock(&vdev->ud.lock);
482 if (vdev->ud.status == VDEV_ST_NULL ||
483 vdev->ud.status == VDEV_ST_ERROR) {
484 dev_err(dev, "enqueue for inactive port %d\n", vdev->rhport);
485 spin_unlock(&vdev->ud.lock);
486 spin_unlock(&the_controller->lock);
487 return -ENODEV;
488 }
489 spin_unlock(&vdev->ud.lock);
490
491 ret = usb_hcd_link_urb_to_ep(hcd, urb);
492 if (ret)
493 goto no_need_unlink;
494
495
496
497
498
499
500
501
502
503
504 if (usb_pipedevice(urb->pipe) == 0) {
505 __u8 type = usb_pipetype(urb->pipe);
506 struct usb_ctrlrequest *ctrlreq =
507 (struct usb_ctrlrequest *) urb->setup_packet;
508
509 if (type != PIPE_CONTROL || !ctrlreq) {
510 dev_err(dev, "invalid request to devnum 0\n");
511 ret = -EINVAL;
512 goto no_need_xmit;
513 }
514
515 switch (ctrlreq->bRequest) {
516 case USB_REQ_SET_ADDRESS:
517
518 dev_info(dev, "SetAddress Request (%d) to port %d\n",
519 ctrlreq->wValue, vdev->rhport);
520
521 usb_put_dev(vdev->udev);
522 vdev->udev = usb_get_dev(urb->dev);
523
524 spin_lock(&vdev->ud.lock);
525 vdev->ud.status = VDEV_ST_USED;
526 spin_unlock(&vdev->ud.lock);
527
528 if (urb->status == -EINPROGRESS) {
529
530
531 urb->status = 0;
532 }
533
534 goto no_need_xmit;
535
536 case USB_REQ_GET_DESCRIPTOR:
537 if (ctrlreq->wValue == cpu_to_le16(USB_DT_DEVICE << 8))
538 usbip_dbg_vhci_hc(
539 "Not yet?:Get_Descriptor to device 0 (get max pipe size)\n");
540
541 usb_put_dev(vdev->udev);
542 vdev->udev = usb_get_dev(urb->dev);
543 goto out;
544
545 default:
546
547 dev_err(dev,
548 "invalid request to devnum 0 bRequest %u, wValue %u\n",
549 ctrlreq->bRequest,
550 ctrlreq->wValue);
551 ret = -EINVAL;
552 goto no_need_xmit;
553 }
554
555 }
556
557out:
558 vhci_tx_urb(urb);
559 spin_unlock(&the_controller->lock);
560
561 return 0;
562
563no_need_xmit:
564 usb_hcd_unlink_urb_from_ep(hcd, urb);
565no_need_unlink:
566 spin_unlock(&the_controller->lock);
567 usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb, urb->status);
568 return ret;
569}
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
618{
619 struct vhci_priv *priv;
620 struct vhci_device *vdev;
621
622 pr_info("dequeue a urb %p\n", urb);
623
624 spin_lock(&the_controller->lock);
625
626 priv = urb->hcpriv;
627 if (!priv) {
628
629
630 spin_unlock(&the_controller->lock);
631 return 0;
632 }
633
634 {
635 int ret = 0;
636
637 ret = usb_hcd_check_unlink_urb(hcd, urb, status);
638 if (ret) {
639 spin_unlock(&the_controller->lock);
640 return ret;
641 }
642 }
643
644
645 vdev = priv->vdev;
646
647 if (!vdev->ud.tcp_socket) {
648
649 spin_lock(&vdev->priv_lock);
650
651 pr_info("device %p seems to be disconnected\n", vdev);
652 list_del(&priv->list);
653 kfree(priv);
654 urb->hcpriv = NULL;
655
656 spin_unlock(&vdev->priv_lock);
657
658
659
660
661
662
663 pr_info("gives back urb %p\n", urb);
664
665 usb_hcd_unlink_urb_from_ep(hcd, urb);
666
667 spin_unlock(&the_controller->lock);
668 usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb,
669 urb->status);
670 spin_lock(&the_controller->lock);
671
672 } else {
673
674 struct vhci_unlink *unlink;
675
676 spin_lock(&vdev->priv_lock);
677
678
679 unlink = kzalloc(sizeof(struct vhci_unlink), GFP_ATOMIC);
680 if (!unlink) {
681 spin_unlock(&vdev->priv_lock);
682 spin_unlock(&the_controller->lock);
683 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
684 return -ENOMEM;
685 }
686
687 unlink->seqnum = atomic_inc_return(&the_controller->seqnum);
688 if (unlink->seqnum == 0xffff)
689 pr_info("seqnum max\n");
690
691 unlink->unlink_seqnum = priv->seqnum;
692
693 pr_info("device %p seems to be still connected\n", vdev);
694
695
696
697 list_add_tail(&unlink->list, &vdev->unlink_tx);
698 wake_up(&vdev->waitq_tx);
699
700 spin_unlock(&vdev->priv_lock);
701 }
702
703 spin_unlock(&the_controller->lock);
704
705 usbip_dbg_vhci_hc("leave\n");
706 return 0;
707}
708
709static void vhci_device_unlink_cleanup(struct vhci_device *vdev)
710{
711 struct vhci_unlink *unlink, *tmp;
712
713 spin_lock(&the_controller->lock);
714 spin_lock(&vdev->priv_lock);
715
716 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) {
717 pr_info("unlink cleanup tx %lu\n", unlink->unlink_seqnum);
718 list_del(&unlink->list);
719 kfree(unlink);
720 }
721
722 while (!list_empty(&vdev->unlink_rx)) {
723 struct urb *urb;
724
725 unlink = list_first_entry(&vdev->unlink_rx, struct vhci_unlink,
726 list);
727
728
729 pr_info("unlink cleanup rx %lu\n", unlink->unlink_seqnum);
730
731 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum);
732 if (!urb) {
733 pr_info("the urb (seqnum %lu) was already given back\n",
734 unlink->unlink_seqnum);
735 list_del(&unlink->list);
736 kfree(unlink);
737 continue;
738 }
739
740 urb->status = -ENODEV;
741
742 usb_hcd_unlink_urb_from_ep(vhci_to_hcd(the_controller), urb);
743
744 list_del(&unlink->list);
745
746 spin_unlock(&vdev->priv_lock);
747 spin_unlock(&the_controller->lock);
748
749 usb_hcd_giveback_urb(vhci_to_hcd(the_controller), urb,
750 urb->status);
751
752 spin_lock(&the_controller->lock);
753 spin_lock(&vdev->priv_lock);
754
755 kfree(unlink);
756 }
757
758 spin_unlock(&vdev->priv_lock);
759 spin_unlock(&the_controller->lock);
760}
761
762
763
764
765
766
767static void vhci_shutdown_connection(struct usbip_device *ud)
768{
769 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
770
771
772 if (ud->tcp_socket) {
773 pr_debug("shutdown tcp_socket %p\n", ud->tcp_socket);
774 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
775 }
776
777
778 if (vdev->ud.tcp_rx) {
779 kthread_stop_put(vdev->ud.tcp_rx);
780 vdev->ud.tcp_rx = NULL;
781 }
782 if (vdev->ud.tcp_tx) {
783 kthread_stop_put(vdev->ud.tcp_tx);
784 vdev->ud.tcp_tx = NULL;
785 }
786 pr_info("stop threads\n");
787
788
789 if (vdev->ud.tcp_socket) {
790 sockfd_put(vdev->ud.tcp_socket);
791 vdev->ud.tcp_socket = NULL;
792 }
793 pr_info("release socket\n");
794
795 vhci_device_unlink_cleanup(vdev);
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817 rh_port_disconnect(vdev->rhport);
818
819 pr_info("disconnect device\n");
820}
821
822
823static void vhci_device_reset(struct usbip_device *ud)
824{
825 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
826
827 spin_lock(&ud->lock);
828
829 vdev->speed = 0;
830 vdev->devid = 0;
831
832 usb_put_dev(vdev->udev);
833 vdev->udev = NULL;
834
835 if (ud->tcp_socket) {
836 sockfd_put(ud->tcp_socket);
837 ud->tcp_socket = NULL;
838 }
839 ud->status = VDEV_ST_NULL;
840
841 spin_unlock(&ud->lock);
842}
843
844static void vhci_device_unusable(struct usbip_device *ud)
845{
846 spin_lock(&ud->lock);
847 ud->status = VDEV_ST_ERROR;
848 spin_unlock(&ud->lock);
849}
850
851static void vhci_device_init(struct vhci_device *vdev)
852{
853 memset(vdev, 0, sizeof(*vdev));
854
855 vdev->ud.side = USBIP_VHCI;
856 vdev->ud.status = VDEV_ST_NULL;
857 spin_lock_init(&vdev->ud.lock);
858
859 INIT_LIST_HEAD(&vdev->priv_rx);
860 INIT_LIST_HEAD(&vdev->priv_tx);
861 INIT_LIST_HEAD(&vdev->unlink_tx);
862 INIT_LIST_HEAD(&vdev->unlink_rx);
863 spin_lock_init(&vdev->priv_lock);
864
865 init_waitqueue_head(&vdev->waitq_tx);
866
867 vdev->ud.eh_ops.shutdown = vhci_shutdown_connection;
868 vdev->ud.eh_ops.reset = vhci_device_reset;
869 vdev->ud.eh_ops.unusable = vhci_device_unusable;
870
871 usbip_start_eh(&vdev->ud);
872}
873
874static int vhci_start(struct usb_hcd *hcd)
875{
876 struct vhci_hcd *vhci = hcd_to_vhci(hcd);
877 int rhport;
878 int err = 0;
879
880 usbip_dbg_vhci_hc("enter vhci_start\n");
881
882
883
884 for (rhport = 0; rhport < VHCI_NPORTS; rhport++) {
885 struct vhci_device *vdev = &vhci->vdev[rhport];
886
887 vhci_device_init(vdev);
888 vdev->rhport = rhport;
889 }
890
891 atomic_set(&vhci->seqnum, 0);
892 spin_lock_init(&vhci->lock);
893
894 hcd->power_budget = 0;
895 hcd->uses_new_polling = 1;
896
897
898 err = sysfs_create_group(&vhci_dev(vhci)->kobj, &dev_attr_group);
899 if (err) {
900 pr_err("create sysfs files\n");
901 return err;
902 }
903
904 return 0;
905}
906
907static void vhci_stop(struct usb_hcd *hcd)
908{
909 struct vhci_hcd *vhci = hcd_to_vhci(hcd);
910 int rhport = 0;
911
912 usbip_dbg_vhci_hc("stop VHCI controller\n");
913
914
915 sysfs_remove_group(&vhci_dev(vhci)->kobj, &dev_attr_group);
916
917
918 for (rhport = 0; rhport < VHCI_NPORTS; rhport++) {
919 struct vhci_device *vdev = &vhci->vdev[rhport];
920
921 usbip_event_add(&vdev->ud, VDEV_EVENT_REMOVED);
922 usbip_stop_eh(&vdev->ud);
923 }
924}
925
926static int vhci_get_frame_number(struct usb_hcd *hcd)
927{
928 pr_err("Not yet implemented\n");
929 return 0;
930}
931
932#ifdef CONFIG_PM
933
934
935static int vhci_bus_suspend(struct usb_hcd *hcd)
936{
937 struct vhci_hcd *vhci = hcd_to_vhci(hcd);
938
939 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
940
941 spin_lock(&vhci->lock);
942 hcd->state = HC_STATE_SUSPENDED;
943 spin_unlock(&vhci->lock);
944
945 return 0;
946}
947
948static int vhci_bus_resume(struct usb_hcd *hcd)
949{
950 struct vhci_hcd *vhci = hcd_to_vhci(hcd);
951 int rc = 0;
952
953 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
954
955 spin_lock(&vhci->lock);
956 if (!HCD_HW_ACCESSIBLE(hcd))
957 rc = -ESHUTDOWN;
958 else
959 hcd->state = HC_STATE_RUNNING;
960 spin_unlock(&vhci->lock);
961
962 return rc;
963}
964
965#else
966
967#define vhci_bus_suspend NULL
968#define vhci_bus_resume NULL
969#endif
970
971static struct hc_driver vhci_hc_driver = {
972 .description = driver_name,
973 .product_desc = driver_desc,
974 .hcd_priv_size = sizeof(struct vhci_hcd),
975
976 .flags = HCD_USB2,
977
978 .start = vhci_start,
979 .stop = vhci_stop,
980
981 .urb_enqueue = vhci_urb_enqueue,
982 .urb_dequeue = vhci_urb_dequeue,
983
984 .get_frame_number = vhci_get_frame_number,
985
986 .hub_status_data = vhci_hub_status,
987 .hub_control = vhci_hub_control,
988 .bus_suspend = vhci_bus_suspend,
989 .bus_resume = vhci_bus_resume,
990};
991
992static int vhci_hcd_probe(struct platform_device *pdev)
993{
994 struct usb_hcd *hcd;
995 int ret;
996
997 usbip_dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);
998
999
1000
1001
1002
1003 hcd = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1004 if (!hcd) {
1005 pr_err("create hcd failed\n");
1006 return -ENOMEM;
1007 }
1008 hcd->has_tt = 1;
1009
1010
1011 the_controller = hcd_to_vhci(hcd);
1012
1013
1014
1015
1016
1017 ret = usb_add_hcd(hcd, 0, 0);
1018 if (ret != 0) {
1019 pr_err("usb_add_hcd failed %d\n", ret);
1020 usb_put_hcd(hcd);
1021 the_controller = NULL;
1022 return ret;
1023 }
1024
1025 usbip_dbg_vhci_hc("bye\n");
1026 return 0;
1027}
1028
1029static int vhci_hcd_remove(struct platform_device *pdev)
1030{
1031 struct usb_hcd *hcd;
1032
1033 hcd = platform_get_drvdata(pdev);
1034 if (!hcd)
1035 return 0;
1036
1037
1038
1039
1040
1041
1042 usb_remove_hcd(hcd);
1043 usb_put_hcd(hcd);
1044 the_controller = NULL;
1045
1046 return 0;
1047}
1048
1049#ifdef CONFIG_PM
1050
1051
1052static int vhci_hcd_suspend(struct platform_device *pdev, pm_message_t state)
1053{
1054 struct usb_hcd *hcd;
1055 int rhport = 0;
1056 int connected = 0;
1057 int ret = 0;
1058
1059 hcd = platform_get_drvdata(pdev);
1060
1061 spin_lock(&the_controller->lock);
1062
1063 for (rhport = 0; rhport < VHCI_NPORTS; rhport++)
1064 if (the_controller->port_status[rhport] &
1065 USB_PORT_STAT_CONNECTION)
1066 connected += 1;
1067
1068 spin_unlock(&the_controller->lock);
1069
1070 if (connected > 0) {
1071 dev_info(&pdev->dev,
1072 "We have %d active connection%s. Do not suspend.\n",
1073 connected, (connected == 1 ? "" : "s"));
1074 ret = -EBUSY;
1075 } else {
1076 dev_info(&pdev->dev, "suspend vhci_hcd");
1077 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1078 }
1079
1080 return ret;
1081}
1082
1083static int vhci_hcd_resume(struct platform_device *pdev)
1084{
1085 struct usb_hcd *hcd;
1086
1087 dev_dbg(&pdev->dev, "%s\n", __func__);
1088
1089 hcd = platform_get_drvdata(pdev);
1090 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1091 usb_hcd_poll_rh_status(hcd);
1092
1093 return 0;
1094}
1095
1096#else
1097
1098#define vhci_hcd_suspend NULL
1099#define vhci_hcd_resume NULL
1100
1101#endif
1102
1103static struct platform_driver vhci_driver = {
1104 .probe = vhci_hcd_probe,
1105 .remove = vhci_hcd_remove,
1106 .suspend = vhci_hcd_suspend,
1107 .resume = vhci_hcd_resume,
1108 .driver = {
1109 .name = driver_name,
1110 },
1111};
1112
1113
1114
1115
1116
1117
1118static void the_pdev_release(struct device *dev)
1119{
1120}
1121
1122static struct platform_device the_pdev = {
1123
1124 .name = driver_name,
1125 .id = -1,
1126 .dev = {
1127 .release = the_pdev_release,
1128 },
1129};
1130
1131static int __init vhci_hcd_init(void)
1132{
1133 int ret;
1134
1135 if (usb_disabled())
1136 return -ENODEV;
1137
1138 ret = platform_driver_register(&vhci_driver);
1139 if (ret)
1140 goto err_driver_register;
1141
1142 ret = platform_device_register(&the_pdev);
1143 if (ret)
1144 goto err_platform_device_register;
1145
1146 pr_info(DRIVER_DESC " v" USBIP_VERSION "\n");
1147 return ret;
1148
1149err_platform_device_register:
1150 platform_driver_unregister(&vhci_driver);
1151err_driver_register:
1152 return ret;
1153}
1154
1155static void __exit vhci_hcd_exit(void)
1156{
1157 platform_device_unregister(&the_pdev);
1158 platform_driver_unregister(&vhci_driver);
1159}
1160
1161module_init(vhci_hcd_init);
1162module_exit(vhci_hcd_exit);
1163
1164MODULE_AUTHOR(DRIVER_AUTHOR);
1165MODULE_DESCRIPTION(DRIVER_DESC);
1166MODULE_LICENSE("GPL");
1167MODULE_VERSION(USBIP_VERSION);
1168