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 if (wValue >= 32)
400 goto error;
401 vhci_hcd->port_status[rhport] &= ~(1 << wValue);
402 break;
403 }
404 break;
405 case GetHubDescriptor:
406 usbip_dbg_vhci_rh(" GetHubDescriptor\n");
407 if (hcd->speed == HCD_USB3 &&
408 (wLength < USB_DT_SS_HUB_SIZE ||
409 wValue != (USB_DT_SS_HUB << 8))) {
410 pr_err("Wrong hub descriptor type for USB 3.0 roothub.\n");
411 goto error;
412 }
413 if (hcd->speed == HCD_USB3)
414 ss_hub_descriptor((struct usb_hub_descriptor *) buf);
415 else
416 hub_descriptor((struct usb_hub_descriptor *) buf);
417 break;
418 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
419 if (hcd->speed != HCD_USB3)
420 goto error;
421
422 if ((wValue >> 8) != USB_DT_BOS)
423 goto error;
424
425 memcpy(buf, &usb3_bos_desc, sizeof(usb3_bos_desc));
426 retval = sizeof(usb3_bos_desc);
427 break;
428 case GetHubStatus:
429 usbip_dbg_vhci_rh(" GetHubStatus\n");
430 *(__le32 *) buf = cpu_to_le32(0);
431 break;
432 case GetPortStatus:
433 usbip_dbg_vhci_rh(" GetPortStatus port %x\n", wIndex);
434 if (invalid_rhport) {
435 pr_err("invalid port number %d\n", wIndex);
436 retval = -EPIPE;
437 goto error;
438 }
439
440
441
442
443
444
445 if (vhci_hcd->resuming && time_after(jiffies, vhci_hcd->re_timeout)) {
446 vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_SUSPEND);
447 vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_SUSPEND);
448 vhci_hcd->resuming = 0;
449 vhci_hcd->re_timeout = 0;
450 }
451
452 if ((vhci_hcd->port_status[rhport] & (1 << USB_PORT_FEAT_RESET)) !=
453 0 && time_after(jiffies, vhci_hcd->re_timeout)) {
454 vhci_hcd->port_status[rhport] |= (1 << USB_PORT_FEAT_C_RESET);
455 vhci_hcd->port_status[rhport] &= ~(1 << USB_PORT_FEAT_RESET);
456 vhci_hcd->re_timeout = 0;
457
458
459
460
461
462 if (vhci_hcd->vdev[rhport].ud.status ==
463 VDEV_ST_NOTASSIGNED ||
464 vhci_hcd->vdev[rhport].ud.status ==
465 VDEV_ST_USED) {
466 usbip_dbg_vhci_rh(
467 " enable rhport %d (status %u)\n",
468 rhport,
469 vhci_hcd->vdev[rhport].ud.status);
470 vhci_hcd->port_status[rhport] |=
471 USB_PORT_STAT_ENABLE;
472 }
473
474 if (hcd->speed < HCD_USB3) {
475 switch (vhci_hcd->vdev[rhport].speed) {
476 case USB_SPEED_HIGH:
477 vhci_hcd->port_status[rhport] |=
478 USB_PORT_STAT_HIGH_SPEED;
479 break;
480 case USB_SPEED_LOW:
481 vhci_hcd->port_status[rhport] |=
482 USB_PORT_STAT_LOW_SPEED;
483 break;
484 default:
485 pr_err("vhci_device speed not set\n");
486 break;
487 }
488 }
489 }
490 ((__le16 *) buf)[0] = cpu_to_le16(vhci_hcd->port_status[rhport]);
491 ((__le16 *) buf)[1] =
492 cpu_to_le16(vhci_hcd->port_status[rhport] >> 16);
493
494 usbip_dbg_vhci_rh(" GetPortStatus bye %x %x\n", ((u16 *)buf)[0],
495 ((u16 *)buf)[1]);
496 break;
497 case SetHubFeature:
498 usbip_dbg_vhci_rh(" SetHubFeature\n");
499 retval = -EPIPE;
500 break;
501 case SetPortFeature:
502 switch (wValue) {
503 case USB_PORT_FEAT_LINK_STATE:
504 usbip_dbg_vhci_rh(
505 " SetPortFeature: USB_PORT_FEAT_LINK_STATE\n");
506 if (hcd->speed != HCD_USB3) {
507 pr_err("USB_PORT_FEAT_LINK_STATE req not "
508 "supported for USB 2.0 roothub\n");
509 goto error;
510 }
511
512
513
514
515 break;
516 case USB_PORT_FEAT_U1_TIMEOUT:
517 usbip_dbg_vhci_rh(
518 " SetPortFeature: USB_PORT_FEAT_U1_TIMEOUT\n");
519 fallthrough;
520 case USB_PORT_FEAT_U2_TIMEOUT:
521 usbip_dbg_vhci_rh(
522 " SetPortFeature: USB_PORT_FEAT_U2_TIMEOUT\n");
523
524 if (hcd->speed != HCD_USB3) {
525 pr_err("USB_PORT_FEAT_U1/2_TIMEOUT req not "
526 "supported for USB 2.0 roothub\n");
527 goto error;
528 }
529 break;
530 case USB_PORT_FEAT_SUSPEND:
531 usbip_dbg_vhci_rh(
532 " SetPortFeature: USB_PORT_FEAT_SUSPEND\n");
533
534 if (hcd->speed == HCD_USB3) {
535 pr_err("USB_PORT_FEAT_SUSPEND req not "
536 "supported for USB 3.0 roothub\n");
537 goto error;
538 }
539
540 if (invalid_rhport) {
541 pr_err("invalid port number %d\n", wIndex);
542 goto error;
543 }
544
545 vhci_hcd->port_status[rhport] |= USB_PORT_STAT_SUSPEND;
546 break;
547 case USB_PORT_FEAT_POWER:
548 usbip_dbg_vhci_rh(
549 " SetPortFeature: USB_PORT_FEAT_POWER\n");
550 if (invalid_rhport) {
551 pr_err("invalid port number %d\n", wIndex);
552 goto error;
553 }
554 if (hcd->speed == HCD_USB3)
555 vhci_hcd->port_status[rhport] |= USB_SS_PORT_STAT_POWER;
556 else
557 vhci_hcd->port_status[rhport] |= USB_PORT_STAT_POWER;
558 break;
559 case USB_PORT_FEAT_BH_PORT_RESET:
560 usbip_dbg_vhci_rh(
561 " SetPortFeature: USB_PORT_FEAT_BH_PORT_RESET\n");
562 if (invalid_rhport) {
563 pr_err("invalid port number %d\n", wIndex);
564 goto error;
565 }
566
567 if (hcd->speed != HCD_USB3) {
568 pr_err("USB_PORT_FEAT_BH_PORT_RESET req not "
569 "supported for USB 2.0 roothub\n");
570 goto error;
571 }
572 fallthrough;
573 case USB_PORT_FEAT_RESET:
574 usbip_dbg_vhci_rh(
575 " SetPortFeature: USB_PORT_FEAT_RESET\n");
576 if (invalid_rhport) {
577 pr_err("invalid port number %d\n", wIndex);
578 goto error;
579 }
580
581 if (hcd->speed == HCD_USB3) {
582 vhci_hcd->port_status[rhport] = 0;
583 vhci_hcd->port_status[rhport] =
584 (USB_SS_PORT_STAT_POWER |
585 USB_PORT_STAT_CONNECTION |
586 USB_PORT_STAT_RESET);
587 } else if (vhci_hcd->port_status[rhport] & USB_PORT_STAT_ENABLE) {
588 vhci_hcd->port_status[rhport] &= ~(USB_PORT_STAT_ENABLE
589 | USB_PORT_STAT_LOW_SPEED
590 | USB_PORT_STAT_HIGH_SPEED);
591 }
592
593
594 vhci_hcd->re_timeout = jiffies + msecs_to_jiffies(50);
595 fallthrough;
596 default:
597 usbip_dbg_vhci_rh(" SetPortFeature: default %d\n",
598 wValue);
599 if (invalid_rhport) {
600 pr_err("invalid port number %d\n", wIndex);
601 goto error;
602 }
603 if (wValue >= 32)
604 goto error;
605 if (hcd->speed == HCD_USB3) {
606 if ((vhci_hcd->port_status[rhport] &
607 USB_SS_PORT_STAT_POWER) != 0) {
608 vhci_hcd->port_status[rhport] |= (1 << wValue);
609 }
610 } else
611 if ((vhci_hcd->port_status[rhport] &
612 USB_PORT_STAT_POWER) != 0) {
613 vhci_hcd->port_status[rhport] |= (1 << wValue);
614 }
615 }
616 break;
617 case GetPortErrorCount:
618 usbip_dbg_vhci_rh(" GetPortErrorCount\n");
619 if (hcd->speed != HCD_USB3) {
620 pr_err("GetPortErrorCount req not "
621 "supported for USB 2.0 roothub\n");
622 goto error;
623 }
624
625 *(__le32 *) buf = cpu_to_le32(0);
626 break;
627 case SetHubDepth:
628 usbip_dbg_vhci_rh(" SetHubDepth\n");
629 if (hcd->speed != HCD_USB3) {
630 pr_err("SetHubDepth req not supported for "
631 "USB 2.0 roothub\n");
632 goto error;
633 }
634 break;
635 default:
636 pr_err("default hub control req: %04x v%04x i%04x l%d\n",
637 typeReq, wValue, wIndex, wLength);
638error:
639
640 retval = -EPIPE;
641 }
642
643 if (usbip_dbg_flag_vhci_rh) {
644 pr_debug("port %d\n", rhport);
645
646 if (!invalid_rhport) {
647 dump_port_status_diff(prev_port_status[rhport],
648 vhci_hcd->port_status[rhport],
649 hcd->speed == HCD_USB3);
650 }
651 }
652 usbip_dbg_vhci_rh(" bye\n");
653
654 spin_unlock_irqrestore(&vhci->lock, flags);
655
656 if (!invalid_rhport &&
657 (vhci_hcd->port_status[rhport] & PORT_C_MASK) != 0) {
658 usb_hcd_poll_rh_status(hcd);
659 }
660
661 return retval;
662}
663
664static void vhci_tx_urb(struct urb *urb, struct vhci_device *vdev)
665{
666 struct vhci_priv *priv;
667 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev);
668 unsigned long flags;
669
670 priv = kzalloc(sizeof(struct vhci_priv), GFP_ATOMIC);
671 if (!priv) {
672 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
673 return;
674 }
675
676 spin_lock_irqsave(&vdev->priv_lock, flags);
677
678 priv->seqnum = atomic_inc_return(&vhci_hcd->seqnum);
679 if (priv->seqnum == 0xffff)
680 dev_info(&urb->dev->dev, "seqnum max\n");
681
682 priv->vdev = vdev;
683 priv->urb = urb;
684
685 urb->hcpriv = (void *) priv;
686
687 list_add_tail(&priv->list, &vdev->priv_tx);
688
689 wake_up(&vdev->waitq_tx);
690 spin_unlock_irqrestore(&vdev->priv_lock, flags);
691}
692
693static int vhci_urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
694{
695 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
696 struct vhci *vhci = vhci_hcd->vhci;
697 struct device *dev = &urb->dev->dev;
698 u8 portnum = urb->dev->portnum;
699 int ret = 0;
700 struct vhci_device *vdev;
701 unsigned long flags;
702
703 if (portnum > VHCI_HC_PORTS) {
704 pr_err("invalid port number %d\n", portnum);
705 return -ENODEV;
706 }
707 vdev = &vhci_hcd->vdev[portnum-1];
708
709 if (!urb->transfer_buffer && !urb->num_sgs &&
710 urb->transfer_buffer_length) {
711 dev_dbg(dev, "Null URB transfer buffer\n");
712 return -EINVAL;
713 }
714
715 spin_lock_irqsave(&vhci->lock, flags);
716
717 if (urb->status != -EINPROGRESS) {
718 dev_err(dev, "URB already unlinked!, status %d\n", urb->status);
719 spin_unlock_irqrestore(&vhci->lock, flags);
720 return urb->status;
721 }
722
723
724 spin_lock(&vdev->ud.lock);
725 if (vdev->ud.status == VDEV_ST_NULL ||
726 vdev->ud.status == VDEV_ST_ERROR) {
727 dev_err(dev, "enqueue for inactive port %d\n", vdev->rhport);
728 spin_unlock(&vdev->ud.lock);
729 spin_unlock_irqrestore(&vhci->lock, flags);
730 return -ENODEV;
731 }
732 spin_unlock(&vdev->ud.lock);
733
734 ret = usb_hcd_link_urb_to_ep(hcd, urb);
735 if (ret)
736 goto no_need_unlink;
737
738
739
740
741
742
743
744
745
746
747 if (usb_pipedevice(urb->pipe) == 0) {
748 __u8 type = usb_pipetype(urb->pipe);
749 struct usb_ctrlrequest *ctrlreq =
750 (struct usb_ctrlrequest *) urb->setup_packet;
751
752 if (type != PIPE_CONTROL || !ctrlreq) {
753 dev_err(dev, "invalid request to devnum 0\n");
754 ret = -EINVAL;
755 goto no_need_xmit;
756 }
757
758 switch (ctrlreq->bRequest) {
759 case USB_REQ_SET_ADDRESS:
760
761 dev_info(dev, "SetAddress Request (%d) to port %d\n",
762 ctrlreq->wValue, vdev->rhport);
763
764 usb_put_dev(vdev->udev);
765 vdev->udev = usb_get_dev(urb->dev);
766
767 spin_lock(&vdev->ud.lock);
768 vdev->ud.status = VDEV_ST_USED;
769 spin_unlock(&vdev->ud.lock);
770
771 if (urb->status == -EINPROGRESS) {
772
773
774 urb->status = 0;
775 }
776
777 goto no_need_xmit;
778
779 case USB_REQ_GET_DESCRIPTOR:
780 if (ctrlreq->wValue == cpu_to_le16(USB_DT_DEVICE << 8))
781 usbip_dbg_vhci_hc(
782 "Not yet?:Get_Descriptor to device 0 (get max pipe size)\n");
783
784 usb_put_dev(vdev->udev);
785 vdev->udev = usb_get_dev(urb->dev);
786 goto out;
787
788 default:
789
790 dev_err(dev,
791 "invalid request to devnum 0 bRequest %u, wValue %u\n",
792 ctrlreq->bRequest,
793 ctrlreq->wValue);
794 ret = -EINVAL;
795 goto no_need_xmit;
796 }
797
798 }
799
800out:
801 vhci_tx_urb(urb, vdev);
802 spin_unlock_irqrestore(&vhci->lock, flags);
803
804 return 0;
805
806no_need_xmit:
807 usb_hcd_unlink_urb_from_ep(hcd, urb);
808no_need_unlink:
809 spin_unlock_irqrestore(&vhci->lock, flags);
810 if (!ret) {
811
812
813
814 local_irq_disable();
815 usb_hcd_giveback_urb(hcd, urb, urb->status);
816 local_irq_enable();
817 }
818 return ret;
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
854
855
856
857
858
859
860
861
862
863
864
865
866
867static int vhci_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
868{
869 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
870 struct vhci *vhci = vhci_hcd->vhci;
871 struct vhci_priv *priv;
872 struct vhci_device *vdev;
873 unsigned long flags;
874
875 spin_lock_irqsave(&vhci->lock, flags);
876
877 priv = urb->hcpriv;
878 if (!priv) {
879
880
881 spin_unlock_irqrestore(&vhci->lock, flags);
882 return -EIDRM;
883 }
884
885 {
886 int ret = 0;
887
888 ret = usb_hcd_check_unlink_urb(hcd, urb, status);
889 if (ret) {
890 spin_unlock_irqrestore(&vhci->lock, flags);
891 return ret;
892 }
893 }
894
895
896 vdev = priv->vdev;
897
898 if (!vdev->ud.tcp_socket) {
899
900 spin_lock(&vdev->priv_lock);
901
902 list_del(&priv->list);
903 kfree(priv);
904 urb->hcpriv = NULL;
905
906 spin_unlock(&vdev->priv_lock);
907
908
909
910
911
912
913 usb_hcd_unlink_urb_from_ep(hcd, urb);
914
915 spin_unlock_irqrestore(&vhci->lock, flags);
916 usb_hcd_giveback_urb(hcd, urb, urb->status);
917 spin_lock_irqsave(&vhci->lock, flags);
918
919 } else {
920
921 struct vhci_unlink *unlink;
922
923 spin_lock(&vdev->priv_lock);
924
925
926 unlink = kzalloc(sizeof(struct vhci_unlink), GFP_ATOMIC);
927 if (!unlink) {
928 spin_unlock(&vdev->priv_lock);
929 spin_unlock_irqrestore(&vhci->lock, flags);
930 usbip_event_add(&vdev->ud, VDEV_EVENT_ERROR_MALLOC);
931 return -ENOMEM;
932 }
933
934 unlink->seqnum = atomic_inc_return(&vhci_hcd->seqnum);
935 if (unlink->seqnum == 0xffff)
936 pr_info("seqnum max\n");
937
938 unlink->unlink_seqnum = priv->seqnum;
939
940
941
942 list_add_tail(&unlink->list, &vdev->unlink_tx);
943 wake_up(&vdev->waitq_tx);
944
945 spin_unlock(&vdev->priv_lock);
946 }
947
948 spin_unlock_irqrestore(&vhci->lock, flags);
949
950 usbip_dbg_vhci_hc("leave\n");
951 return 0;
952}
953
954static void vhci_cleanup_unlink_list(struct vhci_device *vdev,
955 struct list_head *unlink_list)
956{
957 struct vhci_hcd *vhci_hcd = vdev_to_vhci_hcd(vdev);
958 struct usb_hcd *hcd = vhci_hcd_to_hcd(vhci_hcd);
959 struct vhci *vhci = vhci_hcd->vhci;
960 struct vhci_unlink *unlink, *tmp;
961 unsigned long flags;
962
963 spin_lock_irqsave(&vhci->lock, flags);
964 spin_lock(&vdev->priv_lock);
965
966 list_for_each_entry_safe(unlink, tmp, unlink_list, list) {
967 struct urb *urb;
968
969 urb = pickup_urb_and_free_priv(vdev, unlink->unlink_seqnum);
970 if (!urb) {
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
997static void vhci_device_unlink_cleanup(struct vhci_device *vdev)
998{
999
1000 vhci_cleanup_unlink_list(vdev, &vdev->unlink_tx);
1001
1002
1003 vhci_cleanup_unlink_list(vdev, &vdev->unlink_rx);
1004}
1005
1006
1007
1008
1009
1010
1011static void vhci_shutdown_connection(struct usbip_device *ud)
1012{
1013 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
1014
1015
1016 if (ud->tcp_socket) {
1017 pr_debug("shutdown tcp_socket %d\n", ud->sockfd);
1018 kernel_sock_shutdown(ud->tcp_socket, SHUT_RDWR);
1019 }
1020
1021
1022 if (vdev->ud.tcp_rx) {
1023 kthread_stop_put(vdev->ud.tcp_rx);
1024 vdev->ud.tcp_rx = NULL;
1025 }
1026 if (vdev->ud.tcp_tx) {
1027 kthread_stop_put(vdev->ud.tcp_tx);
1028 vdev->ud.tcp_tx = NULL;
1029 }
1030 pr_info("stop threads\n");
1031
1032
1033 if (vdev->ud.tcp_socket) {
1034 sockfd_put(vdev->ud.tcp_socket);
1035 vdev->ud.tcp_socket = NULL;
1036 vdev->ud.sockfd = -1;
1037 }
1038 pr_info("release socket\n");
1039
1040 vhci_device_unlink_cleanup(vdev);
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062 rh_port_disconnect(vdev);
1063
1064 pr_info("disconnect device\n");
1065}
1066
1067static void vhci_device_reset(struct usbip_device *ud)
1068{
1069 struct vhci_device *vdev = container_of(ud, struct vhci_device, ud);
1070 unsigned long flags;
1071
1072 spin_lock_irqsave(&ud->lock, flags);
1073
1074 vdev->speed = 0;
1075 vdev->devid = 0;
1076
1077 usb_put_dev(vdev->udev);
1078 vdev->udev = NULL;
1079
1080 if (ud->tcp_socket) {
1081 sockfd_put(ud->tcp_socket);
1082 ud->tcp_socket = NULL;
1083 ud->sockfd = -1;
1084 }
1085 ud->status = VDEV_ST_NULL;
1086
1087 spin_unlock_irqrestore(&ud->lock, flags);
1088}
1089
1090static void vhci_device_unusable(struct usbip_device *ud)
1091{
1092 unsigned long flags;
1093
1094 spin_lock_irqsave(&ud->lock, flags);
1095 ud->status = VDEV_ST_ERROR;
1096 spin_unlock_irqrestore(&ud->lock, flags);
1097}
1098
1099static void vhci_device_init(struct vhci_device *vdev)
1100{
1101 memset(vdev, 0, sizeof(struct vhci_device));
1102
1103 vdev->ud.side = USBIP_VHCI;
1104 vdev->ud.status = VDEV_ST_NULL;
1105 spin_lock_init(&vdev->ud.lock);
1106 mutex_init(&vdev->ud.sysfs_lock);
1107
1108 INIT_LIST_HEAD(&vdev->priv_rx);
1109 INIT_LIST_HEAD(&vdev->priv_tx);
1110 INIT_LIST_HEAD(&vdev->unlink_tx);
1111 INIT_LIST_HEAD(&vdev->unlink_rx);
1112 spin_lock_init(&vdev->priv_lock);
1113
1114 init_waitqueue_head(&vdev->waitq_tx);
1115
1116 vdev->ud.eh_ops.shutdown = vhci_shutdown_connection;
1117 vdev->ud.eh_ops.reset = vhci_device_reset;
1118 vdev->ud.eh_ops.unusable = vhci_device_unusable;
1119
1120 usbip_start_eh(&vdev->ud);
1121}
1122
1123static int hcd_name_to_id(const char *name)
1124{
1125 char *c;
1126 long val;
1127 int ret;
1128
1129 c = strchr(name, '.');
1130 if (c == NULL)
1131 return 0;
1132
1133 ret = kstrtol(c+1, 10, &val);
1134 if (ret < 0)
1135 return ret;
1136
1137 return val;
1138}
1139
1140static int vhci_setup(struct usb_hcd *hcd)
1141{
1142 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1143 if (usb_hcd_is_primary_hcd(hcd)) {
1144 vhci->vhci_hcd_hs = hcd_to_vhci_hcd(hcd);
1145 vhci->vhci_hcd_hs->vhci = vhci;
1146
1147
1148
1149
1150
1151 hcd->speed = HCD_USB2;
1152 hcd->self.root_hub->speed = USB_SPEED_HIGH;
1153 } else {
1154 vhci->vhci_hcd_ss = hcd_to_vhci_hcd(hcd);
1155 vhci->vhci_hcd_ss->vhci = vhci;
1156 hcd->speed = HCD_USB3;
1157 hcd->self.root_hub->speed = USB_SPEED_SUPER;
1158 }
1159
1160
1161
1162
1163
1164
1165 hcd->self.sg_tablesize = 32;
1166 hcd->self.no_sg_constraint = 1;
1167
1168 return 0;
1169}
1170
1171static int vhci_start(struct usb_hcd *hcd)
1172{
1173 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
1174 int id, rhport;
1175 int err;
1176
1177 usbip_dbg_vhci_hc("enter vhci_start\n");
1178
1179 if (usb_hcd_is_primary_hcd(hcd))
1180 spin_lock_init(&vhci_hcd->vhci->lock);
1181
1182
1183
1184 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1185 struct vhci_device *vdev = &vhci_hcd->vdev[rhport];
1186
1187 vhci_device_init(vdev);
1188 vdev->rhport = rhport;
1189 }
1190
1191 atomic_set(&vhci_hcd->seqnum, 0);
1192
1193 hcd->power_budget = 0;
1194 hcd->uses_new_polling = 1;
1195
1196#ifdef CONFIG_USB_OTG
1197 hcd->self.otg_port = 1;
1198#endif
1199
1200 id = hcd_name_to_id(hcd_name(hcd));
1201 if (id < 0) {
1202 pr_err("invalid vhci name %s\n", hcd_name(hcd));
1203 return -EINVAL;
1204 }
1205
1206
1207 if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1208 err = vhci_init_attr_group();
1209 if (err) {
1210 dev_err(hcd_dev(hcd), "init attr group failed, err = %d\n", err);
1211 return err;
1212 }
1213 err = sysfs_create_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1214 if (err) {
1215 dev_err(hcd_dev(hcd), "create sysfs files failed, err = %d\n", err);
1216 vhci_finish_attr_group();
1217 return err;
1218 }
1219 pr_info("created sysfs %s\n", hcd_name(hcd));
1220 }
1221
1222 return 0;
1223}
1224
1225static void vhci_stop(struct usb_hcd *hcd)
1226{
1227 struct vhci_hcd *vhci_hcd = hcd_to_vhci_hcd(hcd);
1228 int id, rhport;
1229
1230 usbip_dbg_vhci_hc("stop VHCI controller\n");
1231
1232
1233 id = hcd_name_to_id(hcd_name(hcd));
1234 if (id == 0 && usb_hcd_is_primary_hcd(hcd)) {
1235 sysfs_remove_group(&hcd_dev(hcd)->kobj, &vhci_attr_group);
1236 vhci_finish_attr_group();
1237 }
1238
1239
1240 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1241 struct vhci_device *vdev = &vhci_hcd->vdev[rhport];
1242
1243 usbip_event_add(&vdev->ud, VDEV_EVENT_REMOVED);
1244 usbip_stop_eh(&vdev->ud);
1245 }
1246}
1247
1248static int vhci_get_frame_number(struct usb_hcd *hcd)
1249{
1250 dev_err_ratelimited(&hcd->self.root_hub->dev, "Not yet implemented\n");
1251 return 0;
1252}
1253
1254#ifdef CONFIG_PM
1255
1256
1257static int vhci_bus_suspend(struct usb_hcd *hcd)
1258{
1259 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1260 unsigned long flags;
1261
1262 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
1263
1264 spin_lock_irqsave(&vhci->lock, flags);
1265 hcd->state = HC_STATE_SUSPENDED;
1266 spin_unlock_irqrestore(&vhci->lock, flags);
1267
1268 return 0;
1269}
1270
1271static int vhci_bus_resume(struct usb_hcd *hcd)
1272{
1273 struct vhci *vhci = *((void **)dev_get_platdata(hcd->self.controller));
1274 int rc = 0;
1275 unsigned long flags;
1276
1277 dev_dbg(&hcd->self.root_hub->dev, "%s\n", __func__);
1278
1279 spin_lock_irqsave(&vhci->lock, flags);
1280 if (!HCD_HW_ACCESSIBLE(hcd))
1281 rc = -ESHUTDOWN;
1282 else
1283 hcd->state = HC_STATE_RUNNING;
1284 spin_unlock_irqrestore(&vhci->lock, flags);
1285
1286 return rc;
1287}
1288
1289#else
1290
1291#define vhci_bus_suspend NULL
1292#define vhci_bus_resume NULL
1293#endif
1294
1295
1296static int vhci_alloc_streams(struct usb_hcd *hcd, struct usb_device *udev,
1297 struct usb_host_endpoint **eps, unsigned int num_eps,
1298 unsigned int num_streams, gfp_t mem_flags)
1299{
1300 dev_dbg(&hcd->self.root_hub->dev, "vhci_alloc_streams not implemented\n");
1301 return 0;
1302}
1303
1304
1305static int vhci_free_streams(struct usb_hcd *hcd, struct usb_device *udev,
1306 struct usb_host_endpoint **eps, unsigned int num_eps,
1307 gfp_t mem_flags)
1308{
1309 dev_dbg(&hcd->self.root_hub->dev, "vhci_free_streams not implemented\n");
1310 return 0;
1311}
1312
1313static const struct hc_driver vhci_hc_driver = {
1314 .description = driver_name,
1315 .product_desc = driver_desc,
1316 .hcd_priv_size = sizeof(struct vhci_hcd),
1317
1318 .flags = HCD_USB3 | HCD_SHARED,
1319
1320 .reset = vhci_setup,
1321 .start = vhci_start,
1322 .stop = vhci_stop,
1323
1324 .urb_enqueue = vhci_urb_enqueue,
1325 .urb_dequeue = vhci_urb_dequeue,
1326
1327 .get_frame_number = vhci_get_frame_number,
1328
1329 .hub_status_data = vhci_hub_status,
1330 .hub_control = vhci_hub_control,
1331 .bus_suspend = vhci_bus_suspend,
1332 .bus_resume = vhci_bus_resume,
1333
1334 .alloc_streams = vhci_alloc_streams,
1335 .free_streams = vhci_free_streams,
1336};
1337
1338static int vhci_hcd_probe(struct platform_device *pdev)
1339{
1340 struct vhci *vhci = *((void **)dev_get_platdata(&pdev->dev));
1341 struct usb_hcd *hcd_hs;
1342 struct usb_hcd *hcd_ss;
1343 int ret;
1344
1345 usbip_dbg_vhci_hc("name %s id %d\n", pdev->name, pdev->id);
1346
1347
1348
1349
1350
1351 hcd_hs = usb_create_hcd(&vhci_hc_driver, &pdev->dev, dev_name(&pdev->dev));
1352 if (!hcd_hs) {
1353 pr_err("create primary hcd failed\n");
1354 return -ENOMEM;
1355 }
1356 hcd_hs->has_tt = 1;
1357
1358
1359
1360
1361
1362 ret = usb_add_hcd(hcd_hs, 0, 0);
1363 if (ret != 0) {
1364 pr_err("usb_add_hcd hs failed %d\n", ret);
1365 goto put_usb2_hcd;
1366 }
1367
1368 hcd_ss = usb_create_shared_hcd(&vhci_hc_driver, &pdev->dev,
1369 dev_name(&pdev->dev), hcd_hs);
1370 if (!hcd_ss) {
1371 ret = -ENOMEM;
1372 pr_err("create shared hcd failed\n");
1373 goto remove_usb2_hcd;
1374 }
1375
1376 ret = usb_add_hcd(hcd_ss, 0, 0);
1377 if (ret) {
1378 pr_err("usb_add_hcd ss failed %d\n", ret);
1379 goto put_usb3_hcd;
1380 }
1381
1382 usbip_dbg_vhci_hc("bye\n");
1383 return 0;
1384
1385put_usb3_hcd:
1386 usb_put_hcd(hcd_ss);
1387remove_usb2_hcd:
1388 usb_remove_hcd(hcd_hs);
1389put_usb2_hcd:
1390 usb_put_hcd(hcd_hs);
1391 vhci->vhci_hcd_hs = NULL;
1392 vhci->vhci_hcd_ss = NULL;
1393 return ret;
1394}
1395
1396static int vhci_hcd_remove(struct platform_device *pdev)
1397{
1398 struct vhci *vhci = *((void **)dev_get_platdata(&pdev->dev));
1399
1400
1401
1402
1403
1404
1405 usb_remove_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_ss));
1406 usb_put_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_ss));
1407
1408 usb_remove_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_hs));
1409 usb_put_hcd(vhci_hcd_to_hcd(vhci->vhci_hcd_hs));
1410
1411 vhci->vhci_hcd_hs = NULL;
1412 vhci->vhci_hcd_ss = NULL;
1413
1414 return 0;
1415}
1416
1417#ifdef CONFIG_PM
1418
1419
1420static int vhci_hcd_suspend(struct platform_device *pdev, pm_message_t state)
1421{
1422 struct usb_hcd *hcd;
1423 struct vhci *vhci;
1424 int rhport;
1425 int connected = 0;
1426 int ret = 0;
1427 unsigned long flags;
1428
1429 dev_dbg(&pdev->dev, "%s\n", __func__);
1430
1431 hcd = platform_get_drvdata(pdev);
1432 if (!hcd)
1433 return 0;
1434
1435 vhci = *((void **)dev_get_platdata(hcd->self.controller));
1436
1437 spin_lock_irqsave(&vhci->lock, flags);
1438
1439 for (rhport = 0; rhport < VHCI_HC_PORTS; rhport++) {
1440 if (vhci->vhci_hcd_hs->port_status[rhport] &
1441 USB_PORT_STAT_CONNECTION)
1442 connected += 1;
1443
1444 if (vhci->vhci_hcd_ss->port_status[rhport] &
1445 USB_PORT_STAT_CONNECTION)
1446 connected += 1;
1447 }
1448
1449 spin_unlock_irqrestore(&vhci->lock, flags);
1450
1451 if (connected > 0) {
1452 dev_info(&pdev->dev,
1453 "We have %d active connection%s. Do not suspend.\n",
1454 connected, (connected == 1 ? "" : "s"));
1455 ret = -EBUSY;
1456 } else {
1457 dev_info(&pdev->dev, "suspend vhci_hcd");
1458 clear_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1459 }
1460
1461 return ret;
1462}
1463
1464static int vhci_hcd_resume(struct platform_device *pdev)
1465{
1466 struct usb_hcd *hcd;
1467
1468 dev_dbg(&pdev->dev, "%s\n", __func__);
1469
1470 hcd = platform_get_drvdata(pdev);
1471 if (!hcd)
1472 return 0;
1473 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
1474 usb_hcd_poll_rh_status(hcd);
1475
1476 return 0;
1477}
1478
1479#else
1480
1481#define vhci_hcd_suspend NULL
1482#define vhci_hcd_resume NULL
1483
1484#endif
1485
1486static struct platform_driver vhci_driver = {
1487 .probe = vhci_hcd_probe,
1488 .remove = vhci_hcd_remove,
1489 .suspend = vhci_hcd_suspend,
1490 .resume = vhci_hcd_resume,
1491 .driver = {
1492 .name = driver_name,
1493 },
1494};
1495
1496static void del_platform_devices(void)
1497{
1498 struct platform_device *pdev;
1499 int i;
1500
1501 for (i = 0; i < vhci_num_controllers; i++) {
1502 pdev = vhcis[i].pdev;
1503 if (pdev != NULL)
1504 platform_device_unregister(pdev);
1505 vhcis[i].pdev = NULL;
1506 }
1507 sysfs_remove_link(&platform_bus.kobj, driver_name);
1508}
1509
1510static int __init vhci_hcd_init(void)
1511{
1512 int i, ret;
1513
1514 if (usb_disabled())
1515 return -ENODEV;
1516
1517 if (vhci_num_controllers < 1)
1518 vhci_num_controllers = 1;
1519
1520 vhcis = kcalloc(vhci_num_controllers, sizeof(struct vhci), GFP_KERNEL);
1521 if (vhcis == NULL)
1522 return -ENOMEM;
1523
1524 for (i = 0; i < vhci_num_controllers; i++) {
1525 vhcis[i].pdev = platform_device_alloc(driver_name, i);
1526 if (!vhcis[i].pdev) {
1527 i--;
1528 while (i >= 0)
1529 platform_device_put(vhcis[i--].pdev);
1530 ret = -ENOMEM;
1531 goto err_device_alloc;
1532 }
1533 }
1534 for (i = 0; i < vhci_num_controllers; i++) {
1535 void *vhci = &vhcis[i];
1536 ret = platform_device_add_data(vhcis[i].pdev, &vhci, sizeof(void *));
1537 if (ret)
1538 goto err_driver_register;
1539 }
1540
1541 ret = platform_driver_register(&vhci_driver);
1542 if (ret)
1543 goto err_driver_register;
1544
1545 for (i = 0; i < vhci_num_controllers; i++) {
1546 ret = platform_device_add(vhcis[i].pdev);
1547 if (ret < 0) {
1548 i--;
1549 while (i >= 0)
1550 platform_device_del(vhcis[i--].pdev);
1551 goto err_add_hcd;
1552 }
1553 }
1554
1555 return ret;
1556
1557err_add_hcd:
1558 platform_driver_unregister(&vhci_driver);
1559err_driver_register:
1560 for (i = 0; i < vhci_num_controllers; i++)
1561 platform_device_put(vhcis[i].pdev);
1562err_device_alloc:
1563 kfree(vhcis);
1564 return ret;
1565}
1566
1567static void __exit vhci_hcd_exit(void)
1568{
1569 del_platform_devices();
1570 platform_driver_unregister(&vhci_driver);
1571 kfree(vhcis);
1572}
1573
1574module_init(vhci_hcd_init);
1575module_exit(vhci_hcd_exit);
1576
1577MODULE_AUTHOR(DRIVER_AUTHOR);
1578MODULE_DESCRIPTION(DRIVER_DESC);
1579MODULE_LICENSE("GPL");
1580