1
2
3
4
5
6
7#include <linux/init.h>
8#include <linux/file.h>
9#include <linux/kernel.h>
10#include <linux/kthread.h>
11#include <linux/module.h>
12#include <linux/platform_device.h>
13#include <linux/slab.h>
14
15#include "usbip_common.h"
16#include "vhci.h"
17
18#define DRIVER_AUTHOR "Takahiro Hirofuchi"
19#define DRIVER_DESC "USB/IP 'Virtual' Host Controller (VHCI) Driver"
20
21
22
23
24
25
26
27
28
29
30
31
32
33static int vhci_hub_status(struct usb_hcd *hcd, char *buff);
34static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
35 u16 wIndex, char *buff, u16 wLength);
36static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb,
37 gfp_t mem_flags);
38static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status);
39static int vhci_start(struct usb_hcd *vhci_hcd);
40static void vhci_stop(struct usb_hcd *hcd);
41static int vhci_get_frame_number(struct usb_hcd *hcd);
42
43static const char driver_name[] = "vhci_hcd";
44static const char driver_desc[] = "USB/IP Virtual Host Controller";
45
46int vhci_num_controllers = VHCI_NR_HCS;
47struct vhci *vhcis;
48
49static const char * const bit_desc[] = {
50 "CONNECTION",
51 "ENABLE",
52 "SUSPEND",
53 "OVER_CURRENT",
54 "RESET",
55 "L1",
56 "R6",
57 "R7",
58 "POWER",
59 "LOWSPEED",
60 "HIGHSPEED",
61 "PORT_TEST",
62 "INDICATOR",
63 "R13",
64 "R14",
65 "R15",
66 "C_CONNECTION",
67 "C_ENABLE",
68 "C_SUSPEND",
69 "C_OVER_CURRENT",
70 "C_RESET",
71 "C_L1",
72 "R22",
73 "R23",
74 "R24",
75 "R25",
76 "R26",
77 "R27",
78 "R28",
79 "R29",
80 "R30",
81 "R31",
82};
83
84static const char * const bit_desc_ss[] = {
85 "CONNECTION",
86 "ENABLE",
87 "SUSPEND",
88 "OVER_CURRENT",
89 "RESET",
90 "L1",
91 "R6",
92 "R7",
93 "R8",
94 "POWER",
95 "HIGHSPEED",
96 "PORT_TEST",
97 "INDICATOR",
98 "R13",
99 "R14",
100 "R15",
101 "C_CONNECTION",
102 "C_ENABLE",
103 "C_SUSPEND",
104 "C_OVER_CURRENT",
105 "C_RESET",
106 "C_BH_RESET",
107 "C_LINK_STATE",
108 "C_CONFIG_ERROR",
109 "R24",
110 "R25",
111 "R26",
112 "R27",
113 "R28",
114 "R29",
115 "R30",
116 "R31",
117};
118
119static void dump_port_status_diff(u32 prev_status, u32 new_status, bool usb3)
120{
121 int i = 0;
122 u32 bit = 1;
123 const char * const *desc = bit_desc;
124
125 if (usb3)
126 desc = bit_desc_ss;
127
128 pr_debug("status prev -> new: %08x -> %08x\n", prev_status, new_status);
129 while (bit) {
130 u32 prev = prev_status & bit;
131 u32 new = new_status & bit;
132 char change;
133
134 if (!prev && new)
135 change = '+';
136 else if (prev && !new)
137 change = '-';
138 else
139 change = ' ';
140
141 if (prev || new) {
142 pr_debug(" %c%s\n", change, desc[i]);
143
144 if (bit == 1)
145 pr_debug(" %c%s\n", change, "USB_PORT_STAT_SPEED_5GBPS");
146 }
147 bit <<= 1;
148 i++;
149 }
150 pr_debug("\n");
151}
152
153void rh_port_connect(struct vhci_device *vdev, enum usb_device_speed speed)
154{
155 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev);
156 struct vhci *vhci = vhci_hcd->vhci;
157 int rhport = vdev->rhport;
158 u32 status;
159 unsigned long flags;
160
161 usbip_dbg_vhci_rh("rh_port_connect %d\n", rhport);
162
163 spin_lock_irqsave(&vhci->lock, flags);
164
165 status = vhci_hcd->port_status[rhport];
166
167 status |= USB_PORT_STAT_CONNECTION | (1 << USB_PORT_FEAT_C_CONNECTION);
168
169 switch (speed) {
170 case USB_SPEED_HIGH:
171 status |= USB_PORT_STAT_HIGH_SPEED;
172 break;
173 case USB_SPEED_LOW:
174 status |= USB_PORT_STAT_LOW_SPEED;
175 break;
176 default:
177 break;
178 }
179
180 vhci_hcd->port_status[rhport] = status;
181
182 spin_unlock_irqrestore(&vhci->lock, flags);
183
184 usb_hcd_poll_rh_status(vhci_hcd_to_hcd(vhci_hcd));
185}
186
187static void rh_port_disconnect(struct vhci_device *vdev)
188{
189 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev);
190 struct vhci *vhci = vhci_hcd->vhci;
191 int rhport = vdev->rhport;
192 u32 status;
193 unsigned long flags;
194
195 usbip_dbg_vhci_rh("rh_port_disconnect %d\n", rhport);
196
197 spin_lock_irqsave(&vhci->lock, flags);
198
199 status = vhci_hcd->port_status[rhport];
200
201 status &= ~USB_PORT_STAT_CONNECTION;
202 status |= (1 << USB_PORT_FEAT_C_CONNECTION);
203
204 vhci_hcd->port_status[rhport] = status;
205
206 spin_unlock_irqrestore(&vhci->lock, flags);
207 usb_hcd_poll_rh_status(vhci_hcd_to_hcd(vhci_hcd));
208}
209
210#define PORT_C_MASK \
211 ((USB_PORT_STAT_C_CONNECTION \
212 | USB_PORT_STAT_C_ENABLE \
213 | USB_PORT_STAT_C_SUSPEND \
214 | USB_PORT_STAT_C_OVERCURRENT \
215 | USB_PORT_STAT_C_RESET) << 16)
216
217
218
219
220
221
222
223
224
225
226
227
228static int vhci_hub_status(struct usb_hcd *hcd, char *buf)
229{
230 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
231 struct vhci *vhci = vhci_hcd->vhci;
232 int retval = DIV_ROUND_UP(VHCI_HC_PORTS + 1, 8);
233 int rhport;
234 int changed = 0;
235 unsigned long flags;
236
237 memset(buf, 0, retval);
238
239 spin_lock_irqsave(&vhci->lock, flags);
240 if (!HCD_HW_ACCESSIBLE(hcd)) {
241 usbip_dbg_vhci_rh("hw accessible flag not on?\n");
242 goto done;
243 }
244
245
246 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
247 if ((vhci_hcd->port_status[rhport] & PORT_C_MASK)) {
248
249 usbip_dbg_vhci_rh("port %d status changed\n", rhport);
250
251 buf[(rhport + 1) / 8] |= 1 << (rhport + 1) % 8;
252 changed = 1;
253 }
254 }
255
256 if ((hcd->state == HC_STATE_SUSPENDED) && (changed == 1))
257 usb_hcd_resume_root_hub(hcd);
258
259done:
260 spin_unlock_irqrestore(&vhci->lock, flags);
261 return changed ? retval : 0;
262}
263
264
265static struct {
266 struct usb_bos_descriptor bos;
267 struct usb_ss_cap_descriptor ss_cap;
268} __packed usb3_bos_desc = {
269
270 .bos = {
271 .bLength = USB_DT_BOS_SIZE,
272 .bDescriptorType = USB_DT_BOS,
273 .wTotalLength = cpu_to_le16(sizeof(usb3_bos_desc)),
274 .bNumDeviceCaps = 1,
275 },
276 .ss_cap = {
277 .bLength = USB_DT_USB_SS_CAP_SIZE,
278 .bDescriptorType = USB_DT_DEVICE_CAPABILITY,
279 .bDevCapabilityType = USB_SS_CAP_TYPE,
280 .wSpeedSupported = cpu_to_le16(USB_5GBPS_OPERATION),
281 .bFunctionalitySupport = ilog2(USB_5GBPS_OPERATION),
282 },
283};
284
285static inline void
286ss_hub_descriptor(struct usb_hub_descriptor *desc)
287{
288 memset(desc, 0, sizeof *desc);
289 desc->bDescriptorType = USB_DT_SS_HUB;
290 desc->bDescLength = 12;
291 desc->wHubCharacteristics = cpu_to_le16(
292 HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM);
293 desc->bNbrPorts = VHCI_HC_PORTS;
294 desc->u.ss.bHubHdrDecLat = 0x04;
295 desc->u.ss.DeviceRemovable = 0xffff;
296}
297
298static inline void hub_descriptor(struct usb_hub_descriptor *desc)
299{
300 int width;
301
302 memset(desc, 0, sizeof(*desc));
303 desc->bDescriptorType = USB_DT_HUB;
304 desc->wHubCharacteristics = cpu_to_le16(
305 HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_COMMON_OCPM);
306
307 desc->bNbrPorts = VHCI_HC_PORTS;
308 BUILD_BUG_ON(VHCI_HC_PORTS > USB_MAXCHILDREN);
309 width = desc->bNbrPorts / 8 + 1;
310 desc->bDescLength = USB_DT_HUB_NONVAR_SIZE + 2 * width;
311 memset(&desc->u.hs.DeviceRemovable[0], 0, width);
312 memset(&desc->u.hs.DeviceRemovable[width], 0xff, width);
313}
314
315static int vhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
316 u16 wIndex, char *buf, u16 wLength)
317{
318 struct vhci_hcd *vhci_hcd;
319 struct vhci *vhci;
320 int retval = 0;
321 int rhport = -1;
322 unsigned long flags;
323 bool invalid_rhport = false;
324
325 u32 prev_port_status[VHCI_HC_PORTS];
326
327 if (!HCD_HW_ACCESSIBLE(hcd))
328 return -ETIMEDOUT;
329
330
331
332
333
334 wIndex = ((__u8)(wIndex & 0x00ff));
335 usbip_dbg_vhci_rh("typeReq %x wValue %x wIndex %x\n", typeReq, wValue,
336 wIndex);
337
338
339
340
341
342
343
344
345 if (wIndex < 1 || wIndex > VHCI_HC_PORTS) {
346 invalid_rhport = true;
347 if (wIndex > VHCI_HC_PORTS)
348 pr_err("invalid port number %d\n", wIndex);
349 } else
350 rhport = wIndex - 1;
351
352 vhci_hcd = hcd_to_vhci_hcd(hcd);
353 vhci = vhci_hcd->vhci;
354
355 spin_lock_irqsave(&vhci->lock, flags);
356
357
358 if (usbip_dbg_flag_vhci_rh) {
359 if (!invalid_rhport)
360 memcpy(prev_port_status, vhci_hcd->port_status,
361 sizeof(prev_port_status));
362 }
363
364 switch (typeReq) {
365 case ClearHubFeature:
366 usbip_dbg_vhci_rh(" ClearHubFeature\n");
367 break;
368 case ClearPortFeature:
369 if (invalid_rhport) {
370 pr_err("invalid port number %d\n", wIndex);
371 goto error;
372 }
373 switch (wValue) {
374 case USB_PORT_FEAT_SUSPEND:
375 if (hcd->speed == HCD_USB3) {
376 pr_err(" ClearPortFeature: USB_PORT_FEAT_SUSPEND req not "
377 "supported for USB 3.0 roothub\n");
378 goto error;
379 }
380 usbip_dbg_vhci_rh(
381 " ClearPortFeature: USB_PORT_FEAT_SUSPEND\n");
382 if (vhci_hcd->port_status[rhport] & USB_PORT_STAT_SUSPEND) {
383
384 vhci_hcd->resuming = 1;
385 vhci_hcd->re_timeout = jiffies + msecs_to_jiffies(20);
386 }
387 break;
388 case USB_PORT_FEAT_POWER:
389 usbip_dbg_vhci_rh(
390 " ClearPortFeature: USB_PORT_FEAT_POWER\n");
391 if (hcd->speed == HCD_USB3)
392 vhci_hcd->port_status[rhport] &= ~USB_SS_PORT_STAT_POWER;
393 else
394 vhci_hcd->port_status[rhport] &= ~USB_PORT_STAT_POWER;
395 break;
396 default:
397 usbip_dbg_vhci_rh(" ClearPortFeature: default %x\n",
398 wValue);
399 vhci_hcd->port_status[rhport] &= ~(1 << wValue);
400 break;
401 }
402 break;
403 case GetHubDescriptor:
404 usbip_dbg_vhci_rh(" GetHubDescriptor\n");
405 if (hcd->speed == HCD_USB3 &&
406 (wLength < USB_DT_SS_HUB_SIZE ||
407 wValue != (USB_DT_SS_HUB << 8))) {
408 pr_err("Wrong hub descriptor type for USB 3.0 roothub.\n");
409 goto error;
410 }
411 if (hcd->speed == HCD_USB3)
412 ss_hub_descriptor((struct usb_hub_descriptor *) buf);
413 else
414 hub_descriptor((struct usb_hub_descriptor *) buf);
415 break;
416 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
417 if (hcd->speed != HCD_USB3)
418 goto error;
419
420 if ((wValue >> 8) != USB_DT_BOS)
421 goto error;
422
423 memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc));
424 retval = sizeof(usb3_bos_desc);
425 break;
426 case GetHubStatus:
427 usbip_dbg_vhci_rh(" GetHubStatus\n");
428 *(__le32 *) buf = cpu_to_le32(0);
429 break;
430 case GetPortStatus:
431 usbip_dbg_vhci_rh(" GetPortStatus port %x\n", wIndex);
432 if (invalid_rhport) {
433 pr_err("invalid port number %d\n", wIndex);
434 retval = -EPIPE;
435 goto error;
436 }
437
438
439
440
441
442
443 if (vhci_hcd->resuming && time_after(jiffies, vhci_hcd->re_timeout)) {
444 vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_SUSPEND);
445 vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_SUSPEND);
446 vhci_hcd->resuming = 0;
447 vhci_hcd->re_timeout = 0;
448 }
449
450 if ((vhci_hcd->port_status[rhport] & (1 << USB_PORT_FEAT_RESET)) !=
451 0 && time_after(jiffies, vhci_hcd->re_timeout)) {
452 vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_RESET);
453 vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_RESET);
454 vhci_hcd->re_timeout = 0;
455
456 if (vhci_hcd->vdev[rhport].ud.status ==
457 VDEV_ST_NOTASSIGNED) {
458 usbip_dbg_vhci_rh(
459 " enable rhport %d (status %u)\n",
460 rhport,
461 vhci_hcd->vdev[rhport].ud.status);
462 vhci_hcd->port_status[rhport] |=
463 USB_PORT_STAT_ENABLE;
464 }
465
466 if (hcd->speed < HCD_USB3) {
467 switch (vhci_hcd->vdev[rhport].speed) {
468 case USB_SPEED_HIGH:
469 vhci_hcd->port_status[rhport] |=
470 USB_PORT_STAT_HIGH_SPEED;
471 break;
472 case USB_SPEED_LOW:
473 vhci_hcd->port_status[rhport] |=
474 USB_PORT_STAT_LOW_SPEED;
475 break;
476 default:
477 pr_err("vhci_device speed not set\n");
478 break;
479 }
480 }
481 }
482 ((__le16 *) buf)[0] = cpu_to_le16(vhci_hcd->port_status[rhport]);
483 ((__le16 *) buf)[1] =
484 cpu_to_le16(vhci_hcd->port_status[rhport] >> 16);
485
486 usbip_dbg_vhci_rh(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
487 ((u16 *)buf)[1]);
488 break;
489 case SetHubFeature:
490 usbip_dbg_vhci_rh(" SetHubFeature\n");
491 retval = -EPIPE;
492 break;
493 case SetPortFeature:
494 switch (wValue) {
495 case USB_PORT_FEAT_LINK_STATE:
496 usbip_dbg_vhci_rh(
497 " SetPortFeature: USB_PORT_FEAT_LINK_STATE\n");
498 if (hcd->speed != HCD_USB3) {
499 pr_err("USB_PORT_FEAT_LINK_STATE req not "
500 "supported for USB 2.0 roothub\n");
501 goto error;
502 }
503
504
505
506
507 break;
508 case USB_PORT_FEAT_U1_TIMEOUT:
509 usbip_dbg_vhci_rh(
510 " SetPortFeature: USB_PORT_FEAT_U1_TIMEOUT\n");
511 case USB_PORT_FEAT_U2_TIMEOUT:
512 usbip_dbg_vhci_rh(
513 " SetPortFeature: USB_PORT_FEAT_U2_TIMEOUT\n");
514
515 if (hcd->speed != HCD_USB3) {
516 pr_err("USB_PORT_FEAT_U1/2_TIMEOUT req not "
517 "supported for USB 2.0 roothub\n");
518 goto error;
519 }
520 break;
521 case USB_PORT_FEAT_SUSPEND:
522 usbip_dbg_vhci_rh(
523 " SetPortFeature: USB_PORT_FEAT_SUSPEND\n");
524
525 if (hcd->speed == HCD_USB3) {
526 pr_err("USB_PORT_FEAT_SUSPEND req not "
527 "supported for USB 3.0 roothub\n");
528 goto error;
529 }
530
531 if (invalid_rhport) {
532 pr_err("invalid port number %d\n", wIndex);
533 goto error;
534 }
535
536 vhci_hcd->port_status[rhport] |= USB_PORT_STAT_SUSPEND;
537 break;
538 case USB_PORT_FEAT_POWER:
539 usbip_dbg_vhci_rh(
540 " SetPortFeature: USB_PORT_FEAT_POWER\n");
541 if (invalid_rhport) {
542 pr_err("invalid port number %d\n", wIndex);
543 goto error;
544 }
545 if (hcd->speed == HCD_USB3)
546 vhci_hcd->port_status[rhport] |= USB_SS_PORT_STAT_POWER;
547 else
548 vhci_hcd->port_status[rhport] |= USB_PORT_STAT_POWER;
549 break;
550 case USB_PORT_FEAT_BH_PORT_RESET:
551 usbip_dbg_vhci_rh(
552 " SetPortFeature: USB_PORT_FEAT_BH_PORT_RESET\n");
553 if (invalid_rhport) {
554 pr_err("invalid port number %d\n", wIndex);
555 goto error;
556 }
557
558 if (hcd->speed != HCD_USB3) {
559 pr_err("USB_PORT_FEAT_BH_PORT_RESET req not "
560 "supported for USB 2.0 roothub\n");
561 goto error;
562 }
563
564 case USB_PORT_FEAT_RESET:
565 usbip_dbg_vhci_rh(
566 " SetPortFeature: USB_PORT_FEAT_RESET\n");
567 if (invalid_rhport) {
568 pr_err("invalid port number %d\n", wIndex);
569 goto error;
570 }
571
572 if (hcd->speed == HCD_USB3) {
573 vhci_hcd->port_status[rhport] = 0;
574 vhci_hcd->port_status[rhport] =
575 (USB_SS_PORT_STAT_POWER |
576 USB_PORT_STAT_CONNECTION |
577 USB_PORT_STAT_RESET);
578 } else if (vhci_hcd->port_status[rhport] & USB_PORT_STAT_ENABLE) {
579 vhci_hcd->port_status[rhport] &= ~(USB_PORT_STAT_ENABLE
580 | USB_PORT_STAT_LOW_SPEED
581 | USB_PORT_STAT_HIGH_SPEED);
582 }
583
584
585 vhci_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
586
587
588 default:
589 usbip_dbg_vhci_rh(" SetPortFeature: default %d\n",
590 wValue);
591 if (invalid_rhport) {
592 pr_err("invalid port number %d\n", wIndex);
593 goto error;
594 }
595 if (hcd->speed == HCD_USB3) {
596 if ((vhci_hcd->port_status[rhport] &
597 USB_SS_PORT_STAT_POWER) != 0) {
598 vhci_hcd->port_status[rhport] |= (1 << wValue);
599 }
600 } else
601 if ((vhci_hcd->port_status[rhport] &
602 USB_PORT_STAT_POWER) != 0) {
603 vhci_hcd->port_status[rhport] |= (1 << wValue);
604 }
605 }
606 break;
607 case GetPortErrorCount:
608 usbip_dbg_vhci_rh(" GetPortErrorCount\n");
609 if (hcd->speed != HCD_USB3) {
610 pr_err("GetPortErrorCount req not "
611 "supported for USB 2.0 roothub\n");
612 goto error;
613 }
614
615 *(__le32 *) buf = cpu_to_le32(0);
616 break;
617 case SetHubDepth:
618 usbip_dbg_vhci_rh(" SetHubDepth\n");
619 if (hcd->speed != HCD_USB3) {
620 pr_err("SetHubDepth req not supported for "
621 "USB 2.0 roothub\n");
622 goto error;
623 }
624 break;
625 default:
626 pr_err("default hub control req: %04x v%04x i%04x l%d\n",
627 typeReq, wValue, wIndex, wLength);
628error:
629
630 retval = -EPIPE;
631 }
632
633 if (usbip_dbg_flag_vhci_rh) {
634 pr_debug("port %d\n", rhport);
635
636 if (!invalid_rhport) {
637 dump_port_status_diff(prev_port_status[rhport],
638 vhci_hcd->port_status[rhport],
639 hcd->speed == HCD_USB3);
640 }
641 }
642 usbip_dbg_vhci_rh(" bye\n");
643
644 spin_unlock_irqrestore(&vhci->lock, flags);
645
646 if (!invalid_rhport &&
647 (vhci_hcd->port_status[rhport] & PORT_C_MASK) != 0) {
648 usb_hcd_poll_rh_status(hcd);
649 }
650
651 return retval;
652}
653
654static void vhci_tx_urb(struct urb *urb, struct vhci_device *vdev)
655{
656 struct vhci_priv *priv;
657 struct vhci_hcd *vhci_hcd;
658 unsigned long flags;
659
660 if (!vdev) {
661 pr_err("could not get virtual device");
662 return;
663 }
664 vhci_hcd = vdev_to_vhci_hcd(vdev);
665
666 priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
667 if (!priv) {
668 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
669 return;
670 }
671
672 spin_lock_irqsave(&vdev->priv_lock, flags);
673
674 priv->seqnum = atomic_inc_return(&vhci_hcd->seqnum);
675 if (priv->seqnum == 0xffff)
676 dev_info(&urb->dev->dev, "seqnum max\n");
677
678 priv->vdev = vdev;
679 priv->urb = urb;
680
681 urb->hcpriv = (void *) priv;
682
683 list_add_tail(&priv->list, &vdev->priv_tx);
684
685 wake_up(&vdev->waitq_tx);
686 spin_unlock_irqrestore(&vdev->priv_lock, flags);
687}
688
689static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
690{
691 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
692 struct vhci *vhci = vhci_hcd->vhci;
693 struct device *dev = &urb->dev->dev;
694 u8 portnum = urb->dev->portnum;
695 int ret = 0;
696 struct vhci_device *vdev;
697 unsigned long flags;
698
699 if (portnum > VHCI_HC_PORTS) {
700 pr_err("invalid port number %d\n", portnum);
701 return -ENODEV;
702 }
703 vdev = &vhci_hcd->vdev[portnum-1];
704
705
706 BUG_ON(!urb->transfer_buffer && urb->transfer_buffer_length);
707
708 spin_lock_irqsave(&vhci->lock, flags);
709
710 if (urb->status != -EINPROGRESS) {
711 dev_err(dev, "URB already unlinked!, status %d\n", urb->status);
712 spin_unlock_irqrestore(&vhci->lock, flags);
713 return urb->status;
714 }
715
716
717 spin_lock(&vdev->ud.lock);
718 if (vdev->ud.status == VDEV_ST_NULL ||
719 vdev->ud.status == VDEV_ST_ERROR) {
720 dev_err(dev, "enqueue for inactive port %d\n", vdev->rhport);
721 spin_unlock(&vdev->ud.lock);
722 spin_unlock_irqrestore(&vhci->lock, flags);
723 return -ENODEV;
724 }
725 spin_unlock(&vdev->ud.lock);
726
727 ret = usb_hcd_link_urb_to_ep(hcd, urb);
728 if (ret)
729 goto no_need_unlink;
730
731
732
733
734
735
736
737
738
739
740 if (usb_pipedevice(urb->pipe) == 0) {
741 __u8 type = usb_pipetype(urb->pipe);
742 struct usb_ctrlrequest *ctrlreq =
743 (struct usb_ctrlrequest *) urb->setup_packet;
744
745 if (type != PIPE_CONTROL || !ctrlreq) {
746 dev_err(dev, "invalid request to devnum 0\n");
747 ret = -EINVAL;
748 goto no_need_xmit;
749 }
750
751 switch (ctrlreq->bRequest) {
752 case USB_REQ_SET_ADDRESS:
753
754 dev_info(dev, "SetAddress Request (%d) to port %d\n",
755 ctrlreq->wValue, vdev->rhport);
756
757 usb_put_dev(vdev->udev);
758 vdev->udev = usb_get_dev(urb->dev);
759
760 spin_lock(&vdev->ud.lock);
761 vdev->ud.status = VDEV_ST_USED;
762 spin_unlock(&vdev->ud.lock);
763
764 if (urb->status == -EINPROGRESS) {
765
766
767 urb->status = 0;
768 }
769
770 goto no_need_xmit;
771
772 case USB_REQ_GET_DESCRIPTOR:
773 if (ctrlreq->wValue == cpu_to_le16(USB_DT_DEVICE << 8))
774 usbip_dbg_vhci_hc(
775 "Not yet?:Get_Descriptor to device 0 (get max pipe size)\n");
776
777 usb_put_dev(vdev->udev);
778 vdev->udev = usb_get_dev(urb->dev);
779 goto out;
780
781 default:
782
783 dev_err(dev,
784 "invalid request to devnum 0 bRequest %u, wValue %u\n",
785 ctrlreq->bRequest,
786 ctrlreq->wValue);
787 ret = -EINVAL;
788 goto no_need_xmit;
789 }
790
791 }
792
793out:
794 vhci_tx_urb(urb, vdev);
795 spin_unlock_irqrestore(&vhci->lock, flags);
796
797 return 0;
798
799no_need_xmit:
800 usb_hcd_unlink_urb_from_ep(hcd, urb);
801no_need_unlink:
802 spin_unlock_irqrestore(&vhci->lock, flags);
803 if (!ret)
804 usb_hcd_giveback_urb(hcd, urb, urb->status);
805 return ret;
806}
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
855{
856 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
857 struct vhci *vhci = vhci_hcd->vhci;
858 struct vhci_priv *priv;
859 struct vhci_device *vdev;
860 unsigned long flags;
861
862 spin_lock_irqsave(&vhci->lock, flags);
863
864 priv = urb->hcpriv;
865 if (!priv) {
866
867
868 spin_unlock_irqrestore(&vhci->lock, flags);
869 return -EIDRM;
870 }
871
872 {
873 int ret = 0;
874
875 ret = usb_hcd_check_unlink_urb(hcd, urb, status);
876 if (ret) {
877 spin_unlock_irqrestore(&vhci->lock, flags);
878 return ret;
879 }
880 }
881
882
883 vdev = priv->vdev;
884
885 if (!vdev->ud.tcp_socket) {
886
887 spin_lock(&vdev->priv_lock);
888
889 list_del(&priv->list);
890 kfree(priv);
891 urb->hcpriv = NULL;
892
893 spin_unlock(&vdev->priv_lock);
894
895
896
897
898
899
900 usb_hcd_unlink_urb_from_ep(hcd, urb);
901
902 spin_unlock_irqrestore(&vhci->lock, flags);
903 usb_hcd_giveback_urb(hcd, urb, urb->status);
904 spin_lock_irqsave(&vhci->lock, flags);
905
906 } else {
907
908 struct vhci_unlink *unlink;
909
910 spin_lock(&vdev->priv_lock);
911
912
913 unlink = kzalloc(sizeof(struct vhci_unlink), GFP_ATOMIC);
914 if (!unlink) {
915 spin_unlock(&vdev->priv_lock);
916 spin_unlock_irqrestore(&vhci->lock, flags);
917 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
918 return -ENOMEM;
919 }
920
921 unlink->seqnum = atomic_inc_return(&vhci_hcd->seqnum);
922 if (unlink->seqnum == 0xffff)
923 pr_info("seqnum max\n");
924
925 unlink->unlink_seqnum = priv->seqnum;
926
927
928
929 list_add_tail(&unlink->list, &vdev->unlink_tx);
930 wake_up(&vdev->waitq_tx);
931
932 spin_unlock(&vdev->priv_lock);
933 }
934
935 spin_unlock_irqrestore(&vhci->lock, flags);
936
937 usbip_dbg_vhci_hc("leave\n");
938 return 0;
939}
940
941static void vhci_device_unlink_cleanup(struct vhci_device *vdev)
942{
943 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev);
944 struct usb_hcd *hcd = vhci_hcd_to_hcd(vhci_hcd);
945 struct vhci *vhci = vhci_hcd->vhci;
946 struct vhci_unlink *unlink, *tmp;
947 unsigned long flags;
948
949 spin_lock_irqsave(&vhci->lock, flags);
950 spin_lock(&vdev->priv_lock);
951
952 list_for_each_entry_safe(unlink, tmp, &vdev->unlink_tx, list) {
953 pr_info("unlink cleanup tx %lu\n", unlink->unlink_seqnum);
954 list_del(&unlink->list);
955 kfree(unlink);
956 }
957
958 while (!list_empty(&vdev->unlink_rx)) {
959 struct urb *urb;
960
961 unlink = list_first_entry(&vdev->unlink_rx, struct vhci_unlink,
962 list);
963
964
965 pr_info("unlink cleanup rx %lu\n", unlink->unlink_seqnum);
966
967 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum);
968 if (!urb) {
969 pr_info("the urb (seqnum %lu) was already given back\n",
970 unlink->unlink_seqnum);
971 list_del(&unlink->list);
972 kfree(unlink);
973 continue;
974 }
975
976 urb->status = -ENODEV;
977
978 usb_hcd_unlink_urb_from_ep(hcd, urb);
979
980 list_del(&unlink->list);
981
982 spin_unlock(&vdev->priv_lock);
983 spin_unlock_irqrestore(&vhci->lock, flags);
984
985 usb_hcd_giveback_urb(hcd, urb, urb->status);
986
987 spin_lock_irqsave(&vhci->lock, flags);
988 spin_lock(&vdev->priv_lock);
989
990 kfree(unlink);
991 }
992
993 spin_unlock(&vdev->priv_lock);
994 spin_unlock_irqrestore(&vhci->lock, flags);
995}
996
997
998
999
1000
1001
1002static void vhci_shutdown_connection(struct usbip_device *ud)
1003{
1004 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
1005
1006
1007 if (ud->tcp_socket) {
1008 pr_debug("shutdown tcp_socket %d\n", ud->sockfd);
1009 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
1010 }
1011
1012
1013 if (vdev->ud.tcp_rx) {
1014 kthread_stop_put(vdev->ud.tcp_rx);
1015 vdev->ud.tcp_rx = NULL;
1016 }
1017 if (vdev->ud.tcp_tx) {
1018 kthread_stop_put(vdev->ud.tcp_tx);
1019 vdev->ud.tcp_tx = NULL;
1020 }
1021 pr_info("stop threads\n");
1022
1023
1024 if (vdev->ud.tcp_socket) {
1025 sockfd_put(vdev->ud.tcp_socket);
1026 vdev->ud.tcp_socket = NULL;
1027 vdev->ud.sockfd = -1;
1028 }
1029 pr_info("release socket\n");
1030
1031 vhci_device_unlink_cleanup(vdev);
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053 rh_port_disconnect(vdev);
1054
1055 pr_info("disconnect device\n");
1056}
1057
1058static void vhci_device_reset(struct usbip_device *ud)
1059{
1060 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
1061 unsigned long flags;
1062
1063 spin_lock_irqsave(&ud->lock, flags);
1064
1065 vdev->speed = 0;
1066 vdev->devid = 0;
1067
1068 usb_put_dev(vdev->udev);
1069 vdev->udev = NULL;
1070
1071 if (ud->tcp_socket) {
1072 sockfd_put(ud->tcp_socket);
1073 ud->tcp_socket = NULL;
1074 ud->sockfd = -1;
1075 }
1076 ud->status = VDEV_ST_NULL;
1077
1078 spin_unlock_irqrestore(&ud->lock, flags);
1079}
1080
1081static void vhci_device_unusable(struct usbip_device *ud)
1082{
1083 unsigned long flags;
1084
1085 spin_lock_irqsave(&ud->lock, flags);
1086 ud->status = VDEV_ST_ERROR;
1087 spin_unlock_irqrestore(&ud->lock, flags);
1088}
1089
1090static void vhci_device_init(struct vhci_device *vdev)
1091{
1092 memset(vdev, 0, sizeof(struct vhci_device));
1093
1094 vdev->ud.side = USBIP_VHCI;
1095 vdev->ud.status = VDEV_ST_NULL;
1096 spin_lock_init(&vdev->ud.lock);
1097
1098 INIT_LIST_HEAD(&vdev->priv_rx);
1099 INIT_LIST_HEAD(&vdev->priv_tx);
1100 INIT_LIST_HEAD(&vdev->unlink_tx);
1101 INIT_LIST_HEAD(&vdev->unlink_rx);
1102 spin_lock_init(&vdev->priv_lock);
1103
1104 init_waitqueue_head(&vdev->waitq_tx);
1105
1106 vdev->ud.eh_ops.shutdown = vhci_shutdown_connection;
1107 vdev->ud.eh_ops.reset = vhci_device_reset;
1108 vdev->ud.eh_ops.unusable = vhci_device_unusable;
1109
1110 usbip_start_eh(&vdev->ud);
1111}
1112
1113static int hcd_name_to_id(const char *name)
1114{
1115 char *c;
1116 long val;
1117 int ret;
1118
1119 c = strchr(name, '.');
1120 if (c == NULL)
1121 return 0;
1122
1123 ret = kstrtol(c+1, 10, &val);
1124 if (ret < 0)
1125 return ret;
1126
1127 return val;
1128}
1129
1130static int vhci_setup(struct usb_hcd *hcd)
1131{
1132 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1133 if (usb_hcd_is_primary_hcd(hcd)) {
1134 vhci->vhci_hcd_hs = hcd_to_vhci_hcd(hcd);
1135 vhci->vhci_hcd_hs->vhci = vhci;
1136
1137
1138
1139
1140
1141 hcd->speed = HCD_USB2;
1142 hcd->self.root_hub->speed = USB_SPEED_HIGH;
1143 } else {
1144 vhci->vhci_hcd_ss = hcd_to_vhci_hcd(hcd);
1145 vhci->vhci_hcd_ss->vhci = vhci;
1146 hcd->speed = HCD_USB3;
1147 hcd->self.root_hub->speed = USB_SPEED_SUPER;
1148 }
1149 return 0;
1150}
1151
1152static int vhci_start(struct usb_hcd *hcd)
1153{
1154 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
1155 int id, rhport;
1156 int err;
1157
1158 usbip_dbg_vhci_hc("enter vhci_start\n");
1159
1160 if (usb_hcd_is_primary_hcd(hcd))
1161 spin_lock_init(&vhci_hcd->vhci->lock);
1162
1163
1164
1165 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1166 struct vhci_device *vdev = &vhci_hcd->vdev[rhport];
1167
1168 vhci_device_init(vdev);
1169 vdev->rhport = rhport;
1170 }
1171
1172 atomic_set(&vhci_hcd->seqnum, 0);
1173
1174 hcd->power_budget = 0;
1175 hcd->uses_new_polling = 1;
1176
1177#ifdef CONFIG_USB_OTG
1178 hcd->self.otg_port = 1;
1179#endif
1180
1181 id = hcd_name_to_id(hcd_name(hcd));
1182 if (id < 0) {
1183 pr_err("invalid vhci name %s\n", hcd_name(hcd));
1184 return -EINVAL;
1185 }
1186
1187
1188 if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1189 err = vhci_init_attr_group();
1190 if (err) {
1191 pr_err("init attr group\n");
1192 return err;
1193 }
1194 err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1195 if (err) {
1196 pr_err("create sysfs files\n");
1197 vhci_finish_attr_group();
1198 return err;
1199 }
1200 pr_info("created sysfs %s\n", hcd_name(hcd));
1201 }
1202
1203 return 0;
1204}
1205
1206static void vhci_stop(struct usb_hcd *hcd)
1207{
1208 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
1209 int id, rhport;
1210
1211 usbip_dbg_vhci_hc("stop VHCI controller\n");
1212
1213
1214 id = hcd_name_to_id(hcd_name(hcd));
1215 if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1216 sysfs_remove_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1217 vhci_finish_attr_group();
1218 }
1219
1220
1221 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1222 struct vhci_device *vdev = &vhci_hcd->vdev[rhport];
1223
1224 usbip_event_add(&vdev->ud, VDEV_EVENT_REMOVED);
1225 usbip_stop_eh(&vdev->ud);
1226 }
1227}
1228
1229static int vhci_get_frame_number(struct usb_hcd *hcd)
1230{
1231 dev_err_ratelimited(&hcd->self.root_hub->dev, "Not yet implemented\n");
1232 return 0;
1233}
1234
1235#ifdef CONFIG_PM
1236
1237
1238static int vhci_bus_suspend(struct usb_hcd *hcd)
1239{
1240 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1241 unsigned long flags;
1242
1243 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
1244
1245 spin_lock_irqsave(&vhci->lock, flags);
1246 hcd->state = HC_STATE_SUSPENDED;
1247 spin_unlock_irqrestore(&vhci->lock, flags);
1248
1249 return 0;
1250}
1251
1252static int vhci_bus_resume(struct usb_hcd *hcd)
1253{
1254 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1255 int rc = 0;
1256 unsigned long flags;
1257
1258 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
1259
1260 spin_lock_irqsave(&vhci->lock, flags);
1261 if (!HCD_HW_ACCESSIBLE(hcd))
1262 rc = -ESHUTDOWN;
1263 else
1264 hcd->state = HC_STATE_RUNNING;
1265 spin_unlock_irqrestore(&vhci->lock, flags);
1266
1267 return rc;
1268}
1269
1270#else
1271
1272#define vhci_bus_suspend NULL
1273#define vhci_bus_resume NULL
1274#endif
1275
1276
1277static int vhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
1278 struct usb_host_endpoint **eps, unsigned int num_eps,
1279 unsigned int num_streams, gfp_t mem_flags)
1280{
1281 dev_dbg(&hcd->self.root_hub->dev, "vhci_alloc_streams not implemented\n");
1282 return 0;
1283}
1284
1285
1286static int vhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
1287 struct usb_host_endpoint **eps, unsigned int num_eps,
1288 gfp_t mem_flags)
1289{
1290 dev_dbg(&hcd->self.root_hub->dev, "vhci_free_streams not implemented\n");
1291 return 0;
1292}
1293
1294static const struct hc_driver vhci_hc_driver = {
1295 .description = driver_name,
1296 .product_desc = driver_desc,
1297 .hcd_priv_size = sizeof(struct vhci_hcd),
1298
1299 .flags = HCD_USB3 | HCD_SHARED,
1300
1301 .reset = vhci_setup,
1302 .start = vhci_start,
1303 .stop = vhci_stop,
1304
1305 .urb_enqueue = vhci_urb_enqueue,
1306 .urb_dequeue = vhci_urb_dequeue,
1307
1308 .get_frame_number = vhci_get_frame_number,
1309
1310 .hub_status_data = vhci_hub_status,
1311 .hub_control = vhci_hub_control,
1312 .bus_suspend = vhci_bus_suspend,
1313 .bus_resume = vhci_bus_resume,
1314
1315 .alloc_streams = vhci_alloc_streams,
1316 .free_streams = vhci_free_streams,
1317};
1318
1319static int vhci_hcd_probe(struct platform_device *pdev)
1320{
1321 struct vhci *vhci = *((void **)dev_get_platdata(&pdev->dev));
1322 struct usb_hcd *hcd_hs;
1323 struct usb_hcd *hcd_ss;
1324 int ret;
1325
1326 usbip_dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);
1327
1328
1329
1330
1331
1332 hcd_hs = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1333 if (!hcd_hs) {
1334 pr_err("create primary hcd failed\n");
1335 return -ENOMEM;
1336 }
1337 hcd_hs->has_tt = 1;
1338
1339
1340
1341
1342
1343 ret = usb_add_hcd(hcd_hs, 0, 0);
1344 if (ret != 0) {
1345 pr_err("usb_add_hcd hs failed %d\n", ret);
1346 goto put_usb2_hcd;
1347 }
1348
1349 hcd_ss = usb_create_shared_hcd(&vhci_hc_driver, &pdev->dev,
1350 dev_name(&pdev->dev), hcd_hs);
1351 if (!hcd_ss) {
1352 ret = -ENOMEM;
1353 pr_err("create shared hcd failed\n");
1354 goto remove_usb2_hcd;
1355 }
1356
1357 ret = usb_add_hcd(hcd_ss, 0, 0);
1358 if (ret) {
1359 pr_err("usb_add_hcd ss failed %d\n", ret);
1360 goto put_usb3_hcd;
1361 }
1362
1363 usbip_dbg_vhci_hc("bye\n");
1364 return 0;
1365
1366put_usb3_hcd:
1367 usb_put_hcd(hcd_ss);
1368remove_usb2_hcd:
1369 usb_remove_hcd(hcd_hs);
1370put_usb2_hcd:
1371 usb_put_hcd(hcd_hs);
1372 vhci->vhci_hcd_hs = NULL;
1373 vhci->vhci_hcd_ss = NULL;
1374 return ret;
1375}
1376
1377static int vhci_hcd_remove(struct platform_device *pdev)
1378{
1379 struct vhci *vhci = *((void **)dev_get_platdata(&pdev->dev));
1380
1381
1382
1383
1384
1385
1386 usb_remove_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_ss));
1387 usb_put_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_ss));
1388
1389 usb_remove_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_hs));
1390 usb_put_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_hs));
1391
1392 vhci->vhci_hcd_hs = NULL;
1393 vhci->vhci_hcd_ss = NULL;
1394
1395 return 0;
1396}
1397
1398#ifdef CONFIG_PM
1399
1400
1401static int vhci_hcd_suspend(struct platform_device *pdev, pm_message_t state)
1402{
1403 struct usb_hcd *hcd;
1404 struct vhci *vhci;
1405 int rhport;
1406 int connected = 0;
1407 int ret = 0;
1408 unsigned long flags;
1409
1410 dev_dbg(&pdev->dev, "%s\n", __func__);
1411
1412 hcd = platform_get_drvdata(pdev);
1413 if (!hcd)
1414 return 0;
1415
1416 vhci = *((void **)dev_get_platdata(hcd->self.controller));
1417
1418 spin_lock_irqsave(&vhci->lock, flags);
1419
1420 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1421 if (vhci->vhci_hcd_hs->port_status[rhport] &
1422 USB_PORT_STAT_CONNECTION)
1423 connected += 1;
1424
1425 if (vhci->vhci_hcd_ss->port_status[rhport] &
1426 USB_PORT_STAT_CONNECTION)
1427 connected += 1;
1428 }
1429
1430 spin_unlock_irqrestore(&vhci->lock, flags);
1431
1432 if (connected > 0) {
1433 dev_info(&pdev->dev,
1434 "We have %d active connection%s. Do not suspend.\n",
1435 connected, (connected == 1 ? "" : "s"));
1436 ret = -EBUSY;
1437 } else {
1438 dev_info(&pdev->dev, "suspend vhci_hcd");
1439 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1440 }
1441
1442 return ret;
1443}
1444
1445static int vhci_hcd_resume(struct platform_device *pdev)
1446{
1447 struct usb_hcd *hcd;
1448
1449 dev_dbg(&pdev->dev, "%s\n", __func__);
1450
1451 hcd = platform_get_drvdata(pdev);
1452 if (!hcd)
1453 return 0;
1454 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1455 usb_hcd_poll_rh_status(hcd);
1456
1457 return 0;
1458}
1459
1460#else
1461
1462#define vhci_hcd_suspend NULL
1463#define vhci_hcd_resume NULL
1464
1465#endif
1466
1467static struct platform_driver vhci_driver = {
1468 .probe = vhci_hcd_probe,
1469 .remove = vhci_hcd_remove,
1470 .suspend = vhci_hcd_suspend,
1471 .resume = vhci_hcd_resume,
1472 .driver = {
1473 .name = driver_name,
1474 },
1475};
1476
1477static void del_platform_devices(void)
1478{
1479 struct platform_device *pdev;
1480 int i;
1481
1482 for (i = 0; i < vhci_num_controllers; i++) {
1483 pdev = vhcis[i].pdev;
1484 if (pdev != NULL)
1485 platform_device_unregister(pdev);
1486 vhcis[i].pdev = NULL;
1487 }
1488 sysfs_remove_link(&platform_bus.kobj, driver_name);
1489}
1490
1491static int __init vhci_hcd_init(void)
1492{
1493 int i, ret;
1494
1495 if (usb_disabled())
1496 return -ENODEV;
1497
1498 if (vhci_num_controllers < 1)
1499 vhci_num_controllers = 1;
1500
1501 vhcis = kcalloc(vhci_num_controllers, sizeof(struct vhci), GFP_KERNEL);
1502 if (vhcis == NULL)
1503 return -ENOMEM;
1504
1505 for (i = 0; i < vhci_num_controllers; i++) {
1506 vhcis[i].pdev = platform_device_alloc(driver_name, i);
1507 if (!vhcis[i].pdev) {
1508 i--;
1509 while (i >= 0)
1510 platform_device_put(vhcis[i--].pdev);
1511 ret = -ENOMEM;
1512 goto err_device_alloc;
1513 }
1514 }
1515 for (i = 0; i < vhci_num_controllers; i++) {
1516 void *vhci = &vhcis[i];
1517 ret = platform_device_add_data(vhcis[i].pdev, &vhci, sizeof(void *));
1518 if (ret)
1519 goto err_driver_register;
1520 }
1521
1522 ret = platform_driver_register(&vhci_driver);
1523 if (ret)
1524 goto err_driver_register;
1525
1526 for (i = 0; i < vhci_num_controllers; i++) {
1527 ret = platform_device_add(vhcis[i].pdev);
1528 if (ret < 0) {
1529 i--;
1530 while (i >= 0)
1531 platform_device_del(vhcis[i--].pdev);
1532 goto err_add_hcd;
1533 }
1534 }
1535
1536 return ret;
1537
1538err_add_hcd:
1539 platform_driver_unregister(&vhci_driver);
1540err_driver_register:
1541 for (i = 0; i < vhci_num_controllers; i++)
1542 platform_device_put(vhcis[i].pdev);
1543err_device_alloc:
1544 kfree(vhcis);
1545 return ret;
1546}
1547
1548static void __exit vhci_hcd_exit(void)
1549{
1550 del_platform_devices();
1551 platform_driver_unregister(&vhci_driver);
1552 kfree(vhcis);
1553}
1554
1555module_init(vhci_hcd_init);
1556module_exit(vhci_hcd_exit);
1557
1558MODULE_AUTHOR(DRIVER_AUTHOR);
1559MODULE_DESCRIPTION(DRIVER_DESC);
1560MODULE_LICENSE("GPL");
1561