1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25#include <linux/bcd.h>
26#include <linux/module.h>
27#include <linux/version.h>
28#include <linux/kernel.h>
29#include <linux/slab.h>
30#include <linux/completion.h>
31#include <linux/utsname.h>
32#include <linux/mm.h>
33#include <asm/io.h>
34#include <linux/device.h>
35#include <linux/dma-mapping.h>
36#include <linux/mutex.h>
37#include <asm/irq.h>
38#include <asm/byteorder.h>
39#include <asm/unaligned.h>
40#include <linux/platform_device.h>
41#include <linux/workqueue.h>
42#include <linux/pm_runtime.h>
43#include <linux/types.h>
44
45#include <linux/phy/phy.h>
46#include <linux/usb.h>
47#include <linux/usb/hcd.h>
48#include <linux/usb/phy.h>
49
50#include "usb.h"
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89unsigned long usb_hcds_loaded;
90EXPORT_SYMBOL_GPL(usb_hcds_loaded);
91
92
93LIST_HEAD (usb_bus_list);
94EXPORT_SYMBOL_GPL (usb_bus_list);
95
96
97#define USB_MAXBUS 64
98static DECLARE_BITMAP(busmap, USB_MAXBUS);
99
100
101DEFINE_MUTEX(usb_bus_list_lock);
102EXPORT_SYMBOL_GPL (usb_bus_list_lock);
103
104
105static DEFINE_SPINLOCK(hcd_root_hub_lock);
106
107
108static DEFINE_SPINLOCK(hcd_urb_list_lock);
109
110
111static DEFINE_SPINLOCK(hcd_urb_unlink_lock);
112
113
114DECLARE_WAIT_QUEUE_HEAD(usb_kill_urb_queue);
115
116static inline int is_root_hub(struct usb_device *udev)
117{
118 return (udev->parent == NULL);
119}
120
121
122
123
124
125
126
127
128#define KERNEL_REL bin2bcd(((LINUX_VERSION_CODE >> 16) & 0x0ff))
129#define KERNEL_VER bin2bcd(((LINUX_VERSION_CODE >> 8) & 0x0ff))
130
131
132static const u8 usb3_rh_dev_descriptor[18] = {
133 0x12,
134 USB_DT_DEVICE,
135 0x00, 0x03,
136
137 0x09,
138 0x00,
139 0x03,
140 0x09,
141
142 0x6b, 0x1d,
143 0x03, 0x00,
144 KERNEL_VER, KERNEL_REL,
145
146 0x03,
147 0x02,
148 0x01,
149 0x01
150};
151
152
153static const u8 usb25_rh_dev_descriptor[18] = {
154 0x12,
155 USB_DT_DEVICE,
156 0x50, 0x02,
157
158 0x09,
159 0x00,
160 0x00,
161 0xFF,
162
163 0x6b, 0x1d,
164 0x02, 0x00,
165 KERNEL_VER, KERNEL_REL,
166
167 0x03,
168 0x02,
169 0x01,
170 0x01
171};
172
173
174static const u8 usb2_rh_dev_descriptor[18] = {
175 0x12,
176 USB_DT_DEVICE,
177 0x00, 0x02,
178
179 0x09,
180 0x00,
181 0x00,
182 0x40,
183
184 0x6b, 0x1d,
185 0x02, 0x00,
186 KERNEL_VER, KERNEL_REL,
187
188 0x03,
189 0x02,
190 0x01,
191 0x01
192};
193
194
195
196
197static const u8 usb11_rh_dev_descriptor[18] = {
198 0x12,
199 USB_DT_DEVICE,
200 0x10, 0x01,
201
202 0x09,
203 0x00,
204 0x00,
205 0x40,
206
207 0x6b, 0x1d,
208 0x01, 0x00,
209 KERNEL_VER, KERNEL_REL,
210
211 0x03,
212 0x02,
213 0x01,
214 0x01
215};
216
217
218
219
220
221
222static const u8 fs_rh_config_descriptor[] = {
223
224
225 0x09,
226 USB_DT_CONFIG,
227 0x19, 0x00,
228 0x01,
229 0x01,
230 0x00,
231 0xc0,
232
233
234
235
236 0x00,
237
238
239
240
241
242
243
244
245
246
247
248
249
250 0x09,
251 USB_DT_INTERFACE,
252 0x00,
253 0x00,
254 0x01,
255 0x09,
256 0x00,
257 0x00,
258 0x00,
259
260
261 0x07,
262 USB_DT_ENDPOINT,
263 0x81,
264 0x03,
265 0x02, 0x00,
266 0xff
267};
268
269static const u8 hs_rh_config_descriptor[] = {
270
271
272 0x09,
273 USB_DT_CONFIG,
274 0x19, 0x00,
275 0x01,
276 0x01,
277 0x00,
278 0xc0,
279
280
281
282
283 0x00,
284
285
286
287
288
289
290
291
292
293
294
295
296
297 0x09,
298 USB_DT_INTERFACE,
299 0x00,
300 0x00,
301 0x01,
302 0x09,
303 0x00,
304 0x00,
305 0x00,
306
307
308 0x07,
309 USB_DT_ENDPOINT,
310 0x81,
311 0x03,
312
313
314 (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
315 0x0c
316};
317
318static const u8 ss_rh_config_descriptor[] = {
319
320 0x09,
321 USB_DT_CONFIG,
322 0x1f, 0x00,
323 0x01,
324 0x01,
325 0x00,
326 0xc0,
327
328
329
330
331 0x00,
332
333
334 0x09,
335 USB_DT_INTERFACE,
336 0x00,
337 0x00,
338 0x01,
339 0x09,
340 0x00,
341 0x00,
342 0x00,
343
344
345 0x07,
346 USB_DT_ENDPOINT,
347 0x81,
348 0x03,
349
350
351 (USB_MAXCHILDREN + 1 + 7) / 8, 0x00,
352 0x0c,
353
354
355 0x06,
356 USB_DT_SS_ENDPOINT_COMP,
357
358 0x00,
359 0x00,
360 0x02, 0x00
361};
362
363
364
365
366
367
368static int authorized_default = -1;
369module_param(authorized_default, int, S_IRUGO|S_IWUSR);
370MODULE_PARM_DESC(authorized_default,
371 "Default USB device authorization: 0 is not authorized, 1 is "
372 "authorized, -1 is authorized except for wireless USB (default, "
373 "old behaviour");
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389static unsigned
390ascii2desc(char const *s, u8 *buf, unsigned len)
391{
392 unsigned n, t = 2 + 2*strlen(s);
393
394 if (t > 254)
395 t = 254;
396 if (len > t)
397 len = t;
398
399 t += USB_DT_STRING << 8;
400
401 n = len;
402 while (n--) {
403 *buf++ = t;
404 if (!n--)
405 break;
406 *buf++ = t >> 8;
407 t = (unsigned char)*s++;
408 }
409 return len;
410}
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425static unsigned
426rh_string(int id, struct usb_hcd const *hcd, u8 *data, unsigned len)
427{
428 char buf[100];
429 char const *s;
430 static char const langids[4] = {4, USB_DT_STRING, 0x09, 0x04};
431
432
433 switch (id) {
434 case 0:
435
436
437 if (len > 4)
438 len = 4;
439 memcpy(data, langids, len);
440 return len;
441 case 1:
442
443 s = hcd->self.bus_name;
444 break;
445 case 2:
446
447 s = hcd->product_desc;
448 break;
449 case 3:
450
451 snprintf (buf, sizeof buf, "%s %s %s", init_utsname()->sysname,
452 init_utsname()->release, hcd->driver->description);
453 s = buf;
454 break;
455 default:
456
457 return 0;
458 }
459
460 return ascii2desc(s, data, len);
461}
462
463
464
465static int rh_call_control (struct usb_hcd *hcd, struct urb *urb)
466{
467 struct usb_ctrlrequest *cmd;
468 u16 typeReq, wValue, wIndex, wLength;
469 u8 *ubuf = urb->transfer_buffer;
470 unsigned len = 0;
471 int status;
472 u8 patch_wakeup = 0;
473 u8 patch_protocol = 0;
474 u16 tbuf_size;
475 u8 *tbuf = NULL;
476 const u8 *bufp;
477
478 might_sleep();
479
480 spin_lock_irq(&hcd_root_hub_lock);
481 status = usb_hcd_link_urb_to_ep(hcd, urb);
482 spin_unlock_irq(&hcd_root_hub_lock);
483 if (status)
484 return status;
485 urb->hcpriv = hcd;
486
487 cmd = (struct usb_ctrlrequest *) urb->setup_packet;
488 typeReq = (cmd->bRequestType << 8) | cmd->bRequest;
489 wValue = le16_to_cpu (cmd->wValue);
490 wIndex = le16_to_cpu (cmd->wIndex);
491 wLength = le16_to_cpu (cmd->wLength);
492
493 if (wLength > urb->transfer_buffer_length)
494 goto error;
495
496
497
498
499
500 tbuf_size = max_t(u16, sizeof(struct usb_hub_descriptor), wLength);
501 tbuf = kzalloc(tbuf_size, GFP_KERNEL);
502 if (!tbuf)
503 return -ENOMEM;
504
505 bufp = tbuf;
506
507
508 urb->actual_length = 0;
509 switch (typeReq) {
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529 case DeviceRequest | USB_REQ_GET_STATUS:
530 tbuf[0] = (device_may_wakeup(&hcd->self.root_hub->dev)
531 << USB_DEVICE_REMOTE_WAKEUP)
532 | (1 << USB_DEVICE_SELF_POWERED);
533 tbuf[1] = 0;
534 len = 2;
535 break;
536 case DeviceOutRequest | USB_REQ_CLEAR_FEATURE:
537 if (wValue == USB_DEVICE_REMOTE_WAKEUP)
538 device_set_wakeup_enable(&hcd->self.root_hub->dev, 0);
539 else
540 goto error;
541 break;
542 case DeviceOutRequest | USB_REQ_SET_FEATURE:
543 if (device_can_wakeup(&hcd->self.root_hub->dev)
544 && wValue == USB_DEVICE_REMOTE_WAKEUP)
545 device_set_wakeup_enable(&hcd->self.root_hub->dev, 1);
546 else
547 goto error;
548 break;
549 case DeviceRequest | USB_REQ_GET_CONFIGURATION:
550 tbuf[0] = 1;
551 len = 1;
552
553 case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
554 break;
555 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
556 switch (wValue & 0xff00) {
557 case USB_DT_DEVICE << 8:
558 switch (hcd->speed) {
559 case HCD_USB31:
560 case HCD_USB3:
561 bufp = usb3_rh_dev_descriptor;
562 break;
563 case HCD_USB25:
564 bufp = usb25_rh_dev_descriptor;
565 break;
566 case HCD_USB2:
567 bufp = usb2_rh_dev_descriptor;
568 break;
569 case HCD_USB11:
570 bufp = usb11_rh_dev_descriptor;
571 break;
572 default:
573 goto error;
574 }
575 len = 18;
576 if (hcd->has_tt)
577 patch_protocol = 1;
578 break;
579 case USB_DT_CONFIG << 8:
580 switch (hcd->speed) {
581 case HCD_USB31:
582 case HCD_USB3:
583 bufp = ss_rh_config_descriptor;
584 len = sizeof ss_rh_config_descriptor;
585 break;
586 case HCD_USB25:
587 case HCD_USB2:
588 bufp = hs_rh_config_descriptor;
589 len = sizeof hs_rh_config_descriptor;
590 break;
591 case HCD_USB11:
592 bufp = fs_rh_config_descriptor;
593 len = sizeof fs_rh_config_descriptor;
594 break;
595 default:
596 goto error;
597 }
598 if (device_can_wakeup(&hcd->self.root_hub->dev))
599 patch_wakeup = 1;
600 break;
601 case USB_DT_STRING << 8:
602 if ((wValue & 0xff) < 4)
603 urb->actual_length = rh_string(wValue & 0xff,
604 hcd, ubuf, wLength);
605 else
606 goto error;
607 break;
608 case USB_DT_BOS << 8:
609 goto nongeneric;
610 default:
611 goto error;
612 }
613 break;
614 case DeviceRequest | USB_REQ_GET_INTERFACE:
615 tbuf[0] = 0;
616 len = 1;
617
618 case DeviceOutRequest | USB_REQ_SET_INTERFACE:
619 break;
620 case DeviceOutRequest | USB_REQ_SET_ADDRESS:
621
622 dev_dbg (hcd->self.controller, "root hub device address %d\n",
623 wValue);
624 break;
625
626
627
628
629
630 case EndpointRequest | USB_REQ_GET_STATUS:
631
632 tbuf[0] = 0;
633 tbuf[1] = 0;
634 len = 2;
635
636 case EndpointOutRequest | USB_REQ_CLEAR_FEATURE:
637 case EndpointOutRequest | USB_REQ_SET_FEATURE:
638 dev_dbg (hcd->self.controller, "no endpoint features yet\n");
639 break;
640
641
642
643 default:
644nongeneric:
645
646 switch (typeReq) {
647 case GetHubStatus:
648 case GetPortStatus:
649 len = 4;
650 break;
651 case GetHubDescriptor:
652 len = sizeof (struct usb_hub_descriptor);
653 break;
654 case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
655
656 break;
657 }
658 status = hcd->driver->hub_control (hcd,
659 typeReq, wValue, wIndex,
660 tbuf, wLength);
661
662 if (typeReq == GetHubDescriptor)
663 usb_hub_adjust_deviceremovable(hcd->self.root_hub,
664 (struct usb_hub_descriptor *)tbuf);
665 break;
666error:
667
668 status = -EPIPE;
669 }
670
671 if (status < 0) {
672 len = 0;
673 if (status != -EPIPE) {
674 dev_dbg (hcd->self.controller,
675 "CTRL: TypeReq=0x%x val=0x%x "
676 "idx=0x%x len=%d ==> %d\n",
677 typeReq, wValue, wIndex,
678 wLength, status);
679 }
680 } else if (status > 0) {
681
682 len = status;
683 status = 0;
684 }
685 if (len) {
686 if (urb->transfer_buffer_length < len)
687 len = urb->transfer_buffer_length;
688 urb->actual_length = len;
689
690 memcpy (ubuf, bufp, len);
691
692
693 if (patch_wakeup &&
694 len > offsetof (struct usb_config_descriptor,
695 bmAttributes))
696 ((struct usb_config_descriptor *)ubuf)->bmAttributes
697 |= USB_CONFIG_ATT_WAKEUP;
698
699
700 if (patch_protocol &&
701 len > offsetof(struct usb_device_descriptor,
702 bDeviceProtocol))
703 ((struct usb_device_descriptor *) ubuf)->
704 bDeviceProtocol = USB_HUB_PR_HS_SINGLE_TT;
705 }
706
707 kfree(tbuf);
708
709
710 spin_lock_irq(&hcd_root_hub_lock);
711 usb_hcd_unlink_urb_from_ep(hcd, urb);
712 usb_hcd_giveback_urb(hcd, urb, status);
713 spin_unlock_irq(&hcd_root_hub_lock);
714 return 0;
715}
716
717
718
719
720
721
722
723
724
725
726
727void usb_hcd_poll_rh_status(struct usb_hcd *hcd)
728{
729 struct urb *urb;
730 int length;
731 unsigned long flags;
732 char buffer[6];
733
734 if (unlikely(!hcd->rh_pollable))
735 return;
736 if (!hcd->uses_new_polling && !hcd->status_urb)
737 return;
738
739 length = hcd->driver->hub_status_data(hcd, buffer);
740 if (length > 0) {
741
742
743 spin_lock_irqsave(&hcd_root_hub_lock, flags);
744 urb = hcd->status_urb;
745 if (urb) {
746 clear_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
747 hcd->status_urb = NULL;
748 urb->actual_length = length;
749 memcpy(urb->transfer_buffer, buffer, length);
750
751 usb_hcd_unlink_urb_from_ep(hcd, urb);
752 usb_hcd_giveback_urb(hcd, urb, 0);
753 } else {
754 length = 0;
755 set_bit(HCD_FLAG_POLL_PENDING, &hcd->flags);
756 }
757 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
758 }
759
760
761
762
763
764 if (hcd->uses_new_polling ? HCD_POLL_RH(hcd) :
765 (length == 0 && hcd->status_urb != NULL))
766 mod_timer (&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
767}
768EXPORT_SYMBOL_GPL(usb_hcd_poll_rh_status);
769
770
771static void rh_timer_func (unsigned long _hcd)
772{
773 usb_hcd_poll_rh_status((struct usb_hcd *) _hcd);
774}
775
776
777
778static int rh_queue_status (struct usb_hcd *hcd, struct urb *urb)
779{
780 int retval;
781 unsigned long flags;
782 unsigned len = 1 + (urb->dev->maxchild / 8);
783
784 spin_lock_irqsave (&hcd_root_hub_lock, flags);
785 if (hcd->status_urb || urb->transfer_buffer_length < len) {
786 dev_dbg (hcd->self.controller, "not queuing rh status urb\n");
787 retval = -EINVAL;
788 goto done;
789 }
790
791 retval = usb_hcd_link_urb_to_ep(hcd, urb);
792 if (retval)
793 goto done;
794
795 hcd->status_urb = urb;
796 urb->hcpriv = hcd;
797 if (!hcd->uses_new_polling)
798 mod_timer(&hcd->rh_timer, (jiffies/(HZ/4) + 1) * (HZ/4));
799
800
801 else if (HCD_POLL_PENDING(hcd))
802 mod_timer(&hcd->rh_timer, jiffies);
803 retval = 0;
804 done:
805 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
806 return retval;
807}
808
809static int rh_urb_enqueue (struct usb_hcd *hcd, struct urb *urb)
810{
811 if (usb_endpoint_xfer_int(&urb->ep->desc))
812 return rh_queue_status (hcd, urb);
813 if (usb_endpoint_xfer_control(&urb->ep->desc))
814 return rh_call_control (hcd, urb);
815 return -EINVAL;
816}
817
818
819
820
821
822
823static int usb_rh_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
824{
825 unsigned long flags;
826 int rc;
827
828 spin_lock_irqsave(&hcd_root_hub_lock, flags);
829 rc = usb_hcd_check_unlink_urb(hcd, urb, status);
830 if (rc)
831 goto done;
832
833 if (usb_endpoint_num(&urb->ep->desc) == 0) {
834 ;
835
836 } else {
837 if (!hcd->uses_new_polling)
838 del_timer (&hcd->rh_timer);
839 if (urb == hcd->status_urb) {
840 hcd->status_urb = NULL;
841 usb_hcd_unlink_urb_from_ep(hcd, urb);
842 usb_hcd_giveback_urb(hcd, urb, status);
843 }
844 }
845 done:
846 spin_unlock_irqrestore(&hcd_root_hub_lock, flags);
847 return rc;
848}
849
850
851
852
853
854
855static ssize_t authorized_default_show(struct device *dev,
856 struct device_attribute *attr, char *buf)
857{
858 struct usb_device *rh_usb_dev = to_usb_device(dev);
859 struct usb_bus *usb_bus = rh_usb_dev->bus;
860 struct usb_hcd *hcd;
861
862 hcd = bus_to_hcd(usb_bus);
863 return snprintf(buf, PAGE_SIZE, "%u\n", !!HCD_DEV_AUTHORIZED(hcd));
864}
865
866static ssize_t authorized_default_store(struct device *dev,
867 struct device_attribute *attr,
868 const char *buf, size_t size)
869{
870 ssize_t result;
871 unsigned val;
872 struct usb_device *rh_usb_dev = to_usb_device(dev);
873 struct usb_bus *usb_bus = rh_usb_dev->bus;
874 struct usb_hcd *hcd;
875
876 hcd = bus_to_hcd(usb_bus);
877 result = sscanf(buf, "%u\n", &val);
878 if (result == 1) {
879 if (val)
880 set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
881 else
882 clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
883
884 result = size;
885 } else {
886 result = -EINVAL;
887 }
888 return result;
889}
890static DEVICE_ATTR_RW(authorized_default);
891
892
893
894
895
896
897
898
899static ssize_t interface_authorized_default_show(struct device *dev,
900 struct device_attribute *attr, char *buf)
901{
902 struct usb_device *usb_dev = to_usb_device(dev);
903 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
904
905 return sprintf(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
906}
907
908
909
910
911
912
913
914
915static ssize_t interface_authorized_default_store(struct device *dev,
916 struct device_attribute *attr, const char *buf, size_t count)
917{
918 struct usb_device *usb_dev = to_usb_device(dev);
919 struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
920 int rc = count;
921 bool val;
922
923 if (strtobool(buf, &val) != 0)
924 return -EINVAL;
925
926 if (val)
927 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
928 else
929 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
930
931 return rc;
932}
933static DEVICE_ATTR_RW(interface_authorized_default);
934
935
936static struct attribute *usb_bus_attrs[] = {
937 &dev_attr_authorized_default.attr,
938 &dev_attr_interface_authorized_default.attr,
939 NULL,
940};
941
942static struct attribute_group usb_bus_attr_group = {
943 .name = NULL,
944 .attrs = usb_bus_attrs,
945};
946
947
948
949
950
951
952
953
954
955
956
957
958static void usb_bus_init (struct usb_bus *bus)
959{
960 memset (&bus->devmap, 0, sizeof(struct usb_devmap));
961
962 bus->devnum_next = 1;
963
964 bus->root_hub = NULL;
965 bus->busnum = -1;
966 bus->bandwidth_allocated = 0;
967 bus->bandwidth_int_reqs = 0;
968 bus->bandwidth_isoc_reqs = 0;
969 mutex_init(&bus->usb_address0_mutex);
970
971 INIT_LIST_HEAD (&bus->bus_list);
972}
973
974
975
976
977
978
979
980
981
982
983
984
985
986static int usb_register_bus(struct usb_bus *bus)
987{
988 int result = -E2BIG;
989 int busnum;
990
991 mutex_lock(&usb_bus_list_lock);
992 busnum = find_next_zero_bit(busmap, USB_MAXBUS, 1);
993 if (busnum >= USB_MAXBUS) {
994 printk (KERN_ERR "%s: too many buses\n", usbcore_name);
995 goto error_find_busnum;
996 }
997 set_bit(busnum, busmap);
998 bus->busnum = busnum;
999
1000
1001 list_add (&bus->bus_list, &usb_bus_list);
1002 mutex_unlock(&usb_bus_list_lock);
1003
1004 usb_notify_add_bus(bus);
1005
1006 dev_info (bus->controller, "new USB bus registered, assigned bus "
1007 "number %d\n", bus->busnum);
1008 return 0;
1009
1010error_find_busnum:
1011 mutex_unlock(&usb_bus_list_lock);
1012 return result;
1013}
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023static void usb_deregister_bus (struct usb_bus *bus)
1024{
1025 dev_info (bus->controller, "USB bus %d deregistered\n", bus->busnum);
1026
1027
1028
1029
1030
1031
1032 mutex_lock(&usb_bus_list_lock);
1033 list_del (&bus->bus_list);
1034 mutex_unlock(&usb_bus_list_lock);
1035
1036 usb_notify_remove_bus(bus);
1037
1038 clear_bit(bus->busnum, busmap);
1039}
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052static int register_root_hub(struct usb_hcd *hcd)
1053{
1054 struct device *parent_dev = hcd->self.controller;
1055 struct usb_device *usb_dev = hcd->self.root_hub;
1056 const int devnum = 1;
1057 int retval;
1058
1059 usb_dev->devnum = devnum;
1060 usb_dev->bus->devnum_next = devnum + 1;
1061 memset (&usb_dev->bus->devmap.devicemap, 0,
1062 sizeof usb_dev->bus->devmap.devicemap);
1063 set_bit (devnum, usb_dev->bus->devmap.devicemap);
1064 usb_set_device_state(usb_dev, USB_STATE_ADDRESS);
1065
1066 mutex_lock(&usb_bus_list_lock);
1067
1068 usb_dev->ep0.desc.wMaxPacketSize = cpu_to_le16(64);
1069 retval = usb_get_device_descriptor(usb_dev, USB_DT_DEVICE_SIZE);
1070 if (retval != sizeof usb_dev->descriptor) {
1071 mutex_unlock(&usb_bus_list_lock);
1072 dev_dbg (parent_dev, "can't read %s device descriptor %d\n",
1073 dev_name(&usb_dev->dev), retval);
1074 return (retval < 0) ? retval : -EMSGSIZE;
1075 }
1076
1077 if (le16_to_cpu(usb_dev->descriptor.bcdUSB) >= 0x0201) {
1078 retval = usb_get_bos_descriptor(usb_dev);
1079 if (!retval) {
1080 usb_dev->lpm_capable = usb_device_supports_lpm(usb_dev);
1081 } else if (usb_dev->speed == USB_SPEED_SUPER) {
1082 mutex_unlock(&usb_bus_list_lock);
1083 dev_dbg(parent_dev, "can't read %s bos descriptor %d\n",
1084 dev_name(&usb_dev->dev), retval);
1085 return retval;
1086 }
1087 }
1088
1089 retval = usb_new_device (usb_dev);
1090 if (retval) {
1091 dev_err (parent_dev, "can't register root hub for %s, %d\n",
1092 dev_name(&usb_dev->dev), retval);
1093 } else {
1094 spin_lock_irq (&hcd_root_hub_lock);
1095 hcd->rh_registered = 1;
1096 spin_unlock_irq (&hcd_root_hub_lock);
1097
1098
1099 if (HCD_DEAD(hcd))
1100 usb_hc_died (hcd);
1101 }
1102 mutex_unlock(&usb_bus_list_lock);
1103
1104 return retval;
1105}
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118void usb_hcd_start_port_resume(struct usb_bus *bus, int portnum)
1119{
1120 unsigned bit = 1 << portnum;
1121
1122 if (!(bus->resuming_ports & bit)) {
1123 bus->resuming_ports |= bit;
1124 pm_runtime_get_noresume(&bus->root_hub->dev);
1125 }
1126}
1127EXPORT_SYMBOL_GPL(usb_hcd_start_port_resume);
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140void usb_hcd_end_port_resume(struct usb_bus *bus, int portnum)
1141{
1142 unsigned bit = 1 << portnum;
1143
1144 if (bus->resuming_ports & bit) {
1145 bus->resuming_ports &= ~bit;
1146 pm_runtime_put_noidle(&bus->root_hub->dev);
1147 }
1148}
1149EXPORT_SYMBOL_GPL(usb_hcd_end_port_resume);
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166long usb_calc_bus_time (int speed, int is_input, int isoc, int bytecount)
1167{
1168 unsigned long tmp;
1169
1170 switch (speed) {
1171 case USB_SPEED_LOW:
1172 if (is_input) {
1173 tmp = (67667L * (31L + 10L * BitTime (bytecount))) / 1000L;
1174 return 64060L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp;
1175 } else {
1176 tmp = (66700L * (31L + 10L * BitTime (bytecount))) / 1000L;
1177 return 64107L + (2 * BW_HUB_LS_SETUP) + BW_HOST_DELAY + tmp;
1178 }
1179 case USB_SPEED_FULL:
1180 if (isoc) {
1181 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1182 return ((is_input) ? 7268L : 6265L) + BW_HOST_DELAY + tmp;
1183 } else {
1184 tmp = (8354L * (31L + 10L * BitTime (bytecount))) / 1000L;
1185 return 9107L + BW_HOST_DELAY + tmp;
1186 }
1187 case USB_SPEED_HIGH:
1188
1189 if (isoc)
1190 tmp = HS_NSECS_ISO (bytecount);
1191 else
1192 tmp = HS_NSECS (bytecount);
1193 return tmp;
1194 default:
1195 pr_debug ("%s: bogus device speed!\n", usbcore_name);
1196 return -1;
1197 }
1198}
1199EXPORT_SYMBOL_GPL(usb_calc_bus_time);
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225int usb_hcd_link_urb_to_ep(struct usb_hcd *hcd, struct urb *urb)
1226{
1227 int rc = 0;
1228
1229 spin_lock(&hcd_urb_list_lock);
1230
1231
1232 if (unlikely(atomic_read(&urb->reject))) {
1233 rc = -EPERM;
1234 goto done;
1235 }
1236
1237 if (unlikely(!urb->ep->enabled)) {
1238 rc = -ENOENT;
1239 goto done;
1240 }
1241
1242 if (unlikely(!urb->dev->can_submit)) {
1243 rc = -EHOSTUNREACH;
1244 goto done;
1245 }
1246
1247
1248
1249
1250
1251 if (HCD_RH_RUNNING(hcd)) {
1252 urb->unlinked = 0;
1253 list_add_tail(&urb->urb_list, &urb->ep->urb_list);
1254 } else {
1255 rc = -ESHUTDOWN;
1256 goto done;
1257 }
1258 done:
1259 spin_unlock(&hcd_urb_list_lock);
1260 return rc;
1261}
1262EXPORT_SYMBOL_GPL(usb_hcd_link_urb_to_ep);
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283int usb_hcd_check_unlink_urb(struct usb_hcd *hcd, struct urb *urb,
1284 int status)
1285{
1286 struct list_head *tmp;
1287
1288
1289 list_for_each(tmp, &urb->ep->urb_list) {
1290 if (tmp == &urb->urb_list)
1291 break;
1292 }
1293 if (tmp != &urb->urb_list)
1294 return -EIDRM;
1295
1296
1297
1298
1299 if (urb->unlinked)
1300 return -EBUSY;
1301 urb->unlinked = status;
1302 return 0;
1303}
1304EXPORT_SYMBOL_GPL(usb_hcd_check_unlink_urb);
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316void usb_hcd_unlink_urb_from_ep(struct usb_hcd *hcd, struct urb *urb)
1317{
1318
1319 spin_lock(&hcd_urb_list_lock);
1320 list_del_init(&urb->urb_list);
1321 spin_unlock(&hcd_urb_list_lock);
1322}
1323EXPORT_SYMBOL_GPL(usb_hcd_unlink_urb_from_ep);
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357static int hcd_alloc_coherent(struct usb_bus *bus,
1358 gfp_t mem_flags, dma_addr_t *dma_handle,
1359 void **vaddr_handle, size_t size,
1360 enum dma_data_direction dir)
1361{
1362 unsigned char *vaddr;
1363
1364 if (*vaddr_handle == NULL) {
1365 WARN_ON_ONCE(1);
1366 return -EFAULT;
1367 }
1368
1369 vaddr = hcd_buffer_alloc(bus, size + sizeof(vaddr),
1370 mem_flags, dma_handle);
1371 if (!vaddr)
1372 return -ENOMEM;
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382 put_unaligned((unsigned long)*vaddr_handle,
1383 (unsigned long *)(vaddr + size));
1384
1385 if (dir == DMA_TO_DEVICE)
1386 memcpy(vaddr, *vaddr_handle, size);
1387
1388 *vaddr_handle = vaddr;
1389 return 0;
1390}
1391
1392static void hcd_free_coherent(struct usb_bus *bus, dma_addr_t *dma_handle,
1393 void **vaddr_handle, size_t size,
1394 enum dma_data_direction dir)
1395{
1396 unsigned char *vaddr = *vaddr_handle;
1397
1398 vaddr = (void *)get_unaligned((unsigned long *)(vaddr + size));
1399
1400 if (dir == DMA_FROM_DEVICE)
1401 memcpy(vaddr, *vaddr_handle, size);
1402
1403 hcd_buffer_free(bus, size + sizeof(vaddr), *vaddr_handle, *dma_handle);
1404
1405 *vaddr_handle = vaddr;
1406 *dma_handle = 0;
1407}
1408
1409void usb_hcd_unmap_urb_setup_for_dma(struct usb_hcd *hcd, struct urb *urb)
1410{
1411 if (urb->transfer_flags & URB_SETUP_MAP_SINGLE)
1412 dma_unmap_single(hcd->self.controller,
1413 urb->setup_dma,
1414 sizeof(struct usb_ctrlrequest),
1415 DMA_TO_DEVICE);
1416 else if (urb->transfer_flags & URB_SETUP_MAP_LOCAL)
1417 hcd_free_coherent(urb->dev->bus,
1418 &urb->setup_dma,
1419 (void **) &urb->setup_packet,
1420 sizeof(struct usb_ctrlrequest),
1421 DMA_TO_DEVICE);
1422
1423
1424 urb->transfer_flags &= ~(URB_SETUP_MAP_SINGLE | URB_SETUP_MAP_LOCAL);
1425}
1426EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_setup_for_dma);
1427
1428static void unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1429{
1430 if (hcd->driver->unmap_urb_for_dma)
1431 hcd->driver->unmap_urb_for_dma(hcd, urb);
1432 else
1433 usb_hcd_unmap_urb_for_dma(hcd, urb);
1434}
1435
1436void usb_hcd_unmap_urb_for_dma(struct usb_hcd *hcd, struct urb *urb)
1437{
1438 enum dma_data_direction dir;
1439
1440 usb_hcd_unmap_urb_setup_for_dma(hcd, urb);
1441
1442 dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1443 if (urb->transfer_flags & URB_DMA_MAP_SG)
1444 dma_unmap_sg(hcd->self.controller,
1445 urb->sg,
1446 urb->num_sgs,
1447 dir);
1448 else if (urb->transfer_flags & URB_DMA_MAP_PAGE)
1449 dma_unmap_page(hcd->self.controller,
1450 urb->transfer_dma,
1451 urb->transfer_buffer_length,
1452 dir);
1453 else if (urb->transfer_flags & URB_DMA_MAP_SINGLE)
1454 dma_unmap_single(hcd->self.controller,
1455 urb->transfer_dma,
1456 urb->transfer_buffer_length,
1457 dir);
1458 else if (urb->transfer_flags & URB_MAP_LOCAL)
1459 hcd_free_coherent(urb->dev->bus,
1460 &urb->transfer_dma,
1461 &urb->transfer_buffer,
1462 urb->transfer_buffer_length,
1463 dir);
1464
1465
1466 urb->transfer_flags &= ~(URB_DMA_MAP_SG | URB_DMA_MAP_PAGE |
1467 URB_DMA_MAP_SINGLE | URB_MAP_LOCAL);
1468}
1469EXPORT_SYMBOL_GPL(usb_hcd_unmap_urb_for_dma);
1470
1471static int map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1472 gfp_t mem_flags)
1473{
1474 if (hcd->driver->map_urb_for_dma)
1475 return hcd->driver->map_urb_for_dma(hcd, urb, mem_flags);
1476 else
1477 return usb_hcd_map_urb_for_dma(hcd, urb, mem_flags);
1478}
1479
1480int usb_hcd_map_urb_for_dma(struct usb_hcd *hcd, struct urb *urb,
1481 gfp_t mem_flags)
1482{
1483 enum dma_data_direction dir;
1484 int ret = 0;
1485
1486
1487
1488
1489
1490
1491
1492 if (usb_endpoint_xfer_control(&urb->ep->desc)) {
1493 if (hcd->self.uses_pio_for_control)
1494 return ret;
1495 if (hcd->self.uses_dma) {
1496 urb->setup_dma = dma_map_single(
1497 hcd->self.controller,
1498 urb->setup_packet,
1499 sizeof(struct usb_ctrlrequest),
1500 DMA_TO_DEVICE);
1501 if (dma_mapping_error(hcd->self.controller,
1502 urb->setup_dma))
1503 return -EAGAIN;
1504 urb->transfer_flags |= URB_SETUP_MAP_SINGLE;
1505 } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
1506 ret = hcd_alloc_coherent(
1507 urb->dev->bus, mem_flags,
1508 &urb->setup_dma,
1509 (void **)&urb->setup_packet,
1510 sizeof(struct usb_ctrlrequest),
1511 DMA_TO_DEVICE);
1512 if (ret)
1513 return ret;
1514 urb->transfer_flags |= URB_SETUP_MAP_LOCAL;
1515 }
1516 }
1517
1518 dir = usb_urb_dir_in(urb) ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
1519 if (urb->transfer_buffer_length != 0
1520 && !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)) {
1521 if (hcd->self.uses_dma) {
1522 if (urb->num_sgs) {
1523 int n;
1524
1525
1526 if (usb_endpoint_xfer_isoc(&urb->ep->desc)) {
1527 WARN_ON(1);
1528 return -EINVAL;
1529 }
1530
1531 n = dma_map_sg(
1532 hcd->self.controller,
1533 urb->sg,
1534 urb->num_sgs,
1535 dir);
1536 if (n <= 0)
1537 ret = -EAGAIN;
1538 else
1539 urb->transfer_flags |= URB_DMA_MAP_SG;
1540 urb->num_mapped_sgs = n;
1541 if (n != urb->num_sgs)
1542 urb->transfer_flags |=
1543 URB_DMA_SG_COMBINED;
1544 } else if (urb->sg) {
1545 struct scatterlist *sg = urb->sg;
1546 urb->transfer_dma = dma_map_page(
1547 hcd->self.controller,
1548 sg_page(sg),
1549 sg->offset,
1550 urb->transfer_buffer_length,
1551 dir);
1552 if (dma_mapping_error(hcd->self.controller,
1553 urb->transfer_dma))
1554 ret = -EAGAIN;
1555 else
1556 urb->transfer_flags |= URB_DMA_MAP_PAGE;
1557 } else if (is_vmalloc_addr(urb->transfer_buffer)) {
1558 WARN_ONCE(1, "transfer buffer not dma capable\n");
1559 ret = -EAGAIN;
1560 } else {
1561 urb->transfer_dma = dma_map_single(
1562 hcd->self.controller,
1563 urb->transfer_buffer,
1564 urb->transfer_buffer_length,
1565 dir);
1566 if (dma_mapping_error(hcd->self.controller,
1567 urb->transfer_dma))
1568 ret = -EAGAIN;
1569 else
1570 urb->transfer_flags |= URB_DMA_MAP_SINGLE;
1571 }
1572 } else if (hcd->driver->flags & HCD_LOCAL_MEM) {
1573 ret = hcd_alloc_coherent(
1574 urb->dev->bus, mem_flags,
1575 &urb->transfer_dma,
1576 &urb->transfer_buffer,
1577 urb->transfer_buffer_length,
1578 dir);
1579 if (ret == 0)
1580 urb->transfer_flags |= URB_MAP_LOCAL;
1581 }
1582 if (ret && (urb->transfer_flags & (URB_SETUP_MAP_SINGLE |
1583 URB_SETUP_MAP_LOCAL)))
1584 usb_hcd_unmap_urb_for_dma(hcd, urb);
1585 }
1586 return ret;
1587}
1588EXPORT_SYMBOL_GPL(usb_hcd_map_urb_for_dma);
1589
1590
1591
1592
1593
1594
1595
1596
1597int usb_hcd_submit_urb (struct urb *urb, gfp_t mem_flags)
1598{
1599 int status;
1600 struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
1601
1602
1603
1604
1605
1606 usb_get_urb(urb);
1607 atomic_inc(&urb->use_count);
1608 atomic_inc(&urb->dev->urbnum);
1609 usbmon_urb_submit(&hcd->self, urb);
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619 if (is_root_hub(urb->dev)) {
1620 status = rh_urb_enqueue(hcd, urb);
1621 } else {
1622 status = map_urb_for_dma(hcd, urb, mem_flags);
1623 if (likely(status == 0)) {
1624 status = hcd->driver->urb_enqueue(hcd, urb, mem_flags);
1625 if (unlikely(status))
1626 unmap_urb_for_dma(hcd, urb);
1627 }
1628 }
1629
1630 if (unlikely(status)) {
1631 usbmon_urb_submit_error(&hcd->self, urb, status);
1632 urb->hcpriv = NULL;
1633 INIT_LIST_HEAD(&urb->urb_list);
1634 atomic_dec(&urb->use_count);
1635 atomic_dec(&urb->dev->urbnum);
1636 if (atomic_read(&urb->reject))
1637 wake_up(&usb_kill_urb_queue);
1638 usb_put_urb(urb);
1639 }
1640 return status;
1641}
1642
1643
1644
1645
1646
1647
1648
1649
1650static int unlink1(struct usb_hcd *hcd, struct urb *urb, int status)
1651{
1652 int value;
1653
1654 if (is_root_hub(urb->dev))
1655 value = usb_rh_urb_dequeue(hcd, urb, status);
1656 else {
1657
1658
1659
1660
1661 value = hcd->driver->urb_dequeue(hcd, urb, status);
1662 }
1663 return value;
1664}
1665
1666
1667
1668
1669
1670
1671
1672int usb_hcd_unlink_urb (struct urb *urb, int status)
1673{
1674 struct usb_hcd *hcd;
1675 struct usb_device *udev = urb->dev;
1676 int retval = -EIDRM;
1677 unsigned long flags;
1678
1679
1680
1681
1682
1683
1684 spin_lock_irqsave(&hcd_urb_unlink_lock, flags);
1685 if (atomic_read(&urb->use_count) > 0) {
1686 retval = 0;
1687 usb_get_dev(udev);
1688 }
1689 spin_unlock_irqrestore(&hcd_urb_unlink_lock, flags);
1690 if (retval == 0) {
1691 hcd = bus_to_hcd(urb->dev->bus);
1692 retval = unlink1(hcd, urb, status);
1693 if (retval == 0)
1694 retval = -EINPROGRESS;
1695 else if (retval != -EIDRM && retval != -EBUSY)
1696 dev_dbg(&udev->dev, "hcd_unlink_urb %p fail %d\n",
1697 urb, retval);
1698 usb_put_dev(udev);
1699 }
1700 return retval;
1701}
1702
1703
1704
1705static void __usb_hcd_giveback_urb(struct urb *urb)
1706{
1707 struct usb_hcd *hcd = bus_to_hcd(urb->dev->bus);
1708 struct usb_anchor *anchor = urb->anchor;
1709 int status = urb->unlinked;
1710 unsigned long flags;
1711
1712 urb->hcpriv = NULL;
1713 if (unlikely((urb->transfer_flags & URB_SHORT_NOT_OK) &&
1714 urb->actual_length < urb->transfer_buffer_length &&
1715 !status))
1716 status = -EREMOTEIO;
1717
1718 unmap_urb_for_dma(hcd, urb);
1719 usbmon_urb_complete(&hcd->self, urb, status);
1720 usb_anchor_suspend_wakeups(anchor);
1721 usb_unanchor_urb(urb);
1722 if (likely(status == 0))
1723 usb_led_activity(USB_LED_EVENT_HOST);
1724
1725
1726 urb->status = status;
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738 local_irq_save(flags);
1739 urb->complete(urb);
1740 local_irq_restore(flags);
1741
1742 usb_anchor_resume_wakeups(anchor);
1743 atomic_dec(&urb->use_count);
1744 if (unlikely(atomic_read(&urb->reject)))
1745 wake_up(&usb_kill_urb_queue);
1746 usb_put_urb(urb);
1747}
1748
1749static void usb_giveback_urb_bh(unsigned long param)
1750{
1751 struct giveback_urb_bh *bh = (struct giveback_urb_bh *)param;
1752 struct list_head local_list;
1753
1754 spin_lock_irq(&bh->lock);
1755 bh->running = true;
1756 restart:
1757 list_replace_init(&bh->head, &local_list);
1758 spin_unlock_irq(&bh->lock);
1759
1760 while (!list_empty(&local_list)) {
1761 struct urb *urb;
1762
1763 urb = list_entry(local_list.next, struct urb, urb_list);
1764 list_del_init(&urb->urb_list);
1765 bh->completing_ep = urb->ep;
1766 __usb_hcd_giveback_urb(urb);
1767 bh->completing_ep = NULL;
1768 }
1769
1770
1771 spin_lock_irq(&bh->lock);
1772 if (!list_empty(&bh->head))
1773 goto restart;
1774 bh->running = false;
1775 spin_unlock_irq(&bh->lock);
1776}
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795void usb_hcd_giveback_urb(struct usb_hcd *hcd, struct urb *urb, int status)
1796{
1797 struct giveback_urb_bh *bh;
1798 bool running, high_prio_bh;
1799
1800
1801 if (likely(!urb->unlinked))
1802 urb->unlinked = status;
1803
1804 if (!hcd_giveback_urb_in_bh(hcd) && !is_root_hub(urb->dev)) {
1805 __usb_hcd_giveback_urb(urb);
1806 return;
1807 }
1808
1809 if (usb_pipeisoc(urb->pipe) || usb_pipeint(urb->pipe)) {
1810 bh = &hcd->high_prio_bh;
1811 high_prio_bh = true;
1812 } else {
1813 bh = &hcd->low_prio_bh;
1814 high_prio_bh = false;
1815 }
1816
1817 spin_lock(&bh->lock);
1818 list_add_tail(&urb->urb_list, &bh->head);
1819 running = bh->running;
1820 spin_unlock(&bh->lock);
1821
1822 if (running)
1823 ;
1824 else if (high_prio_bh)
1825 tasklet_hi_schedule(&bh->bh);
1826 else
1827 tasklet_schedule(&bh->bh);
1828}
1829EXPORT_SYMBOL_GPL(usb_hcd_giveback_urb);
1830
1831
1832
1833
1834
1835
1836
1837void usb_hcd_flush_endpoint(struct usb_device *udev,
1838 struct usb_host_endpoint *ep)
1839{
1840 struct usb_hcd *hcd;
1841 struct urb *urb;
1842
1843 if (!ep)
1844 return;
1845 might_sleep();
1846 hcd = bus_to_hcd(udev->bus);
1847
1848
1849 spin_lock_irq(&hcd_urb_list_lock);
1850rescan:
1851 list_for_each_entry (urb, &ep->urb_list, urb_list) {
1852 int is_in;
1853
1854 if (urb->unlinked)
1855 continue;
1856 usb_get_urb (urb);
1857 is_in = usb_urb_dir_in(urb);
1858 spin_unlock(&hcd_urb_list_lock);
1859
1860
1861 unlink1(hcd, urb, -ESHUTDOWN);
1862 dev_dbg (hcd->self.controller,
1863 "shutdown urb %p ep%d%s%s\n",
1864 urb, usb_endpoint_num(&ep->desc),
1865 is_in ? "in" : "out",
1866 ({ char *s;
1867
1868 switch (usb_endpoint_type(&ep->desc)) {
1869 case USB_ENDPOINT_XFER_CONTROL:
1870 s = ""; break;
1871 case USB_ENDPOINT_XFER_BULK:
1872 s = "-bulk"; break;
1873 case USB_ENDPOINT_XFER_INT:
1874 s = "-intr"; break;
1875 default:
1876 s = "-iso"; break;
1877 };
1878 s;
1879 }));
1880 usb_put_urb (urb);
1881
1882
1883 spin_lock(&hcd_urb_list_lock);
1884 goto rescan;
1885 }
1886 spin_unlock_irq(&hcd_urb_list_lock);
1887
1888
1889 while (!list_empty (&ep->urb_list)) {
1890 spin_lock_irq(&hcd_urb_list_lock);
1891
1892
1893 urb = NULL;
1894 if (!list_empty (&ep->urb_list)) {
1895 urb = list_entry (ep->urb_list.prev, struct urb,
1896 urb_list);
1897 usb_get_urb (urb);
1898 }
1899 spin_unlock_irq(&hcd_urb_list_lock);
1900
1901 if (urb) {
1902 usb_kill_urb (urb);
1903 usb_put_urb (urb);
1904 }
1905 }
1906}
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929int usb_hcd_alloc_bandwidth(struct usb_device *udev,
1930 struct usb_host_config *new_config,
1931 struct usb_host_interface *cur_alt,
1932 struct usb_host_interface *new_alt)
1933{
1934 int num_intfs, i, j;
1935 struct usb_host_interface *alt = NULL;
1936 int ret = 0;
1937 struct usb_hcd *hcd;
1938 struct usb_host_endpoint *ep;
1939
1940 hcd = bus_to_hcd(udev->bus);
1941 if (!hcd->driver->check_bandwidth)
1942 return 0;
1943
1944
1945 if (!new_config && !cur_alt) {
1946 for (i = 1; i < 16; ++i) {
1947 ep = udev->ep_out[i];
1948 if (ep)
1949 hcd->driver->drop_endpoint(hcd, udev, ep);
1950 ep = udev->ep_in[i];
1951 if (ep)
1952 hcd->driver->drop_endpoint(hcd, udev, ep);
1953 }
1954 hcd->driver->check_bandwidth(hcd, udev);
1955 return 0;
1956 }
1957
1958
1959
1960
1961
1962 if (new_config) {
1963 num_intfs = new_config->desc.bNumInterfaces;
1964
1965
1966
1967 for (i = 1; i < 16; ++i) {
1968 ep = udev->ep_out[i];
1969 if (ep) {
1970 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1971 if (ret < 0)
1972 goto reset;
1973 }
1974 ep = udev->ep_in[i];
1975 if (ep) {
1976 ret = hcd->driver->drop_endpoint(hcd, udev, ep);
1977 if (ret < 0)
1978 goto reset;
1979 }
1980 }
1981 for (i = 0; i < num_intfs; ++i) {
1982 struct usb_host_interface *first_alt;
1983 int iface_num;
1984
1985 first_alt = &new_config->intf_cache[i]->altsetting[0];
1986 iface_num = first_alt->desc.bInterfaceNumber;
1987
1988 alt = usb_find_alt_setting(new_config, iface_num, 0);
1989 if (!alt)
1990
1991 alt = first_alt;
1992
1993 for (j = 0; j < alt->desc.bNumEndpoints; j++) {
1994 ret = hcd->driver->add_endpoint(hcd, udev, &alt->endpoint[j]);
1995 if (ret < 0)
1996 goto reset;
1997 }
1998 }
1999 }
2000 if (cur_alt && new_alt) {
2001 struct usb_interface *iface = usb_ifnum_to_if(udev,
2002 cur_alt->desc.bInterfaceNumber);
2003
2004 if (!iface)
2005 return -EINVAL;
2006 if (iface->resetting_device) {
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016 cur_alt = usb_altnum_to_altsetting(iface, 0);
2017 if (!cur_alt)
2018 cur_alt = &iface->altsetting[0];
2019 }
2020
2021
2022 for (i = 0; i < cur_alt->desc.bNumEndpoints; i++) {
2023 ret = hcd->driver->drop_endpoint(hcd, udev,
2024 &cur_alt->endpoint[i]);
2025 if (ret < 0)
2026 goto reset;
2027 }
2028
2029 for (i = 0; i < new_alt->desc.bNumEndpoints; i++) {
2030 ret = hcd->driver->add_endpoint(hcd, udev,
2031 &new_alt->endpoint[i]);
2032 if (ret < 0)
2033 goto reset;
2034 }
2035 }
2036 ret = hcd->driver->check_bandwidth(hcd, udev);
2037reset:
2038 if (ret < 0)
2039 hcd->driver->reset_bandwidth(hcd, udev);
2040 return ret;
2041}
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051void usb_hcd_disable_endpoint(struct usb_device *udev,
2052 struct usb_host_endpoint *ep)
2053{
2054 struct usb_hcd *hcd;
2055
2056 might_sleep();
2057 hcd = bus_to_hcd(udev->bus);
2058 if (hcd->driver->endpoint_disable)
2059 hcd->driver->endpoint_disable(hcd, ep);
2060}
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070void usb_hcd_reset_endpoint(struct usb_device *udev,
2071 struct usb_host_endpoint *ep)
2072{
2073 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2074
2075 if (hcd->driver->endpoint_reset)
2076 hcd->driver->endpoint_reset(hcd, ep);
2077 else {
2078 int epnum = usb_endpoint_num(&ep->desc);
2079 int is_out = usb_endpoint_dir_out(&ep->desc);
2080 int is_control = usb_endpoint_xfer_control(&ep->desc);
2081
2082 usb_settoggle(udev, epnum, is_out, 0);
2083 if (is_control)
2084 usb_settoggle(udev, epnum, !is_out, 0);
2085 }
2086}
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103int usb_alloc_streams(struct usb_interface *interface,
2104 struct usb_host_endpoint **eps, unsigned int num_eps,
2105 unsigned int num_streams, gfp_t mem_flags)
2106{
2107 struct usb_hcd *hcd;
2108 struct usb_device *dev;
2109 int i, ret;
2110
2111 dev = interface_to_usbdev(interface);
2112 hcd = bus_to_hcd(dev->bus);
2113 if (!hcd->driver->alloc_streams || !hcd->driver->free_streams)
2114 return -EINVAL;
2115 if (dev->speed != USB_SPEED_SUPER)
2116 return -EINVAL;
2117 if (dev->state < USB_STATE_CONFIGURED)
2118 return -ENODEV;
2119
2120 for (i = 0; i < num_eps; i++) {
2121
2122 if (!usb_endpoint_xfer_bulk(&eps[i]->desc))
2123 return -EINVAL;
2124
2125 if (eps[i]->streams)
2126 return -EINVAL;
2127 }
2128
2129 ret = hcd->driver->alloc_streams(hcd, dev, eps, num_eps,
2130 num_streams, mem_flags);
2131 if (ret < 0)
2132 return ret;
2133
2134 for (i = 0; i < num_eps; i++)
2135 eps[i]->streams = ret;
2136
2137 return ret;
2138}
2139EXPORT_SYMBOL_GPL(usb_alloc_streams);
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153int usb_free_streams(struct usb_interface *interface,
2154 struct usb_host_endpoint **eps, unsigned int num_eps,
2155 gfp_t mem_flags)
2156{
2157 struct usb_hcd *hcd;
2158 struct usb_device *dev;
2159 int i, ret;
2160
2161 dev = interface_to_usbdev(interface);
2162 hcd = bus_to_hcd(dev->bus);
2163 if (dev->speed != USB_SPEED_SUPER)
2164 return -EINVAL;
2165
2166
2167 for (i = 0; i < num_eps; i++)
2168 if (!eps[i] || !eps[i]->streams)
2169 return -EINVAL;
2170
2171 ret = hcd->driver->free_streams(hcd, dev, eps, num_eps, mem_flags);
2172 if (ret < 0)
2173 return ret;
2174
2175 for (i = 0; i < num_eps; i++)
2176 eps[i]->streams = 0;
2177
2178 return ret;
2179}
2180EXPORT_SYMBOL_GPL(usb_free_streams);
2181
2182
2183
2184
2185
2186
2187void usb_hcd_synchronize_unlinks(struct usb_device *udev)
2188{
2189 spin_lock_irq(&hcd_urb_unlink_lock);
2190 spin_unlock_irq(&hcd_urb_unlink_lock);
2191}
2192
2193
2194
2195
2196int usb_hcd_get_frame_number (struct usb_device *udev)
2197{
2198 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
2199
2200 if (!HCD_RH_RUNNING(hcd))
2201 return -ESHUTDOWN;
2202 return hcd->driver->get_frame_number (hcd);
2203}
2204
2205
2206
2207#ifdef CONFIG_PM
2208
2209int hcd_bus_suspend(struct usb_device *rhdev, pm_message_t msg)
2210{
2211 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
2212 int status;
2213 int old_state = hcd->state;
2214
2215 dev_dbg(&rhdev->dev, "bus %ssuspend, wakeup %d\n",
2216 (PMSG_IS_AUTO(msg) ? "auto-" : ""),
2217 rhdev->do_remote_wakeup);
2218 if (HCD_DEAD(hcd)) {
2219 dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "suspend");
2220 return 0;
2221 }
2222
2223 if (!hcd->driver->bus_suspend) {
2224 status = -ENOENT;
2225 } else {
2226 clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2227 hcd->state = HC_STATE_QUIESCING;
2228 status = hcd->driver->bus_suspend(hcd);
2229 }
2230 if (status == 0) {
2231 usb_set_device_state(rhdev, USB_STATE_SUSPENDED);
2232 hcd->state = HC_STATE_SUSPENDED;
2233
2234
2235 if (rhdev->do_remote_wakeup) {
2236 char buffer[6];
2237
2238 status = hcd->driver->hub_status_data(hcd, buffer);
2239 if (status != 0) {
2240 dev_dbg(&rhdev->dev, "suspend raced with wakeup event\n");
2241 hcd_bus_resume(rhdev, PMSG_AUTO_RESUME);
2242 status = -EBUSY;
2243 }
2244 }
2245 } else {
2246 spin_lock_irq(&hcd_root_hub_lock);
2247 if (!HCD_DEAD(hcd)) {
2248 set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2249 hcd->state = old_state;
2250 }
2251 spin_unlock_irq(&hcd_root_hub_lock);
2252 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
2253 "suspend", status);
2254 }
2255 return status;
2256}
2257
2258int hcd_bus_resume(struct usb_device *rhdev, pm_message_t msg)
2259{
2260 struct usb_hcd *hcd = container_of(rhdev->bus, struct usb_hcd, self);
2261 int status;
2262 int old_state = hcd->state;
2263
2264 dev_dbg(&rhdev->dev, "usb %sresume\n",
2265 (PMSG_IS_AUTO(msg) ? "auto-" : ""));
2266 if (HCD_DEAD(hcd)) {
2267 dev_dbg(&rhdev->dev, "skipped %s of dead bus\n", "resume");
2268 return 0;
2269 }
2270 if (!hcd->driver->bus_resume)
2271 return -ENOENT;
2272 if (HCD_RH_RUNNING(hcd))
2273 return 0;
2274
2275 hcd->state = HC_STATE_RESUMING;
2276 status = hcd->driver->bus_resume(hcd);
2277 clear_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
2278 if (status == 0) {
2279 struct usb_device *udev;
2280 int port1;
2281
2282 spin_lock_irq(&hcd_root_hub_lock);
2283 if (!HCD_DEAD(hcd)) {
2284 usb_set_device_state(rhdev, rhdev->actconfig
2285 ? USB_STATE_CONFIGURED
2286 : USB_STATE_ADDRESS);
2287 set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2288 hcd->state = HC_STATE_RUNNING;
2289 }
2290 spin_unlock_irq(&hcd_root_hub_lock);
2291
2292
2293
2294
2295
2296
2297
2298 usb_hub_for_each_child(rhdev, port1, udev) {
2299 if (udev->state != USB_STATE_NOTATTACHED &&
2300 !udev->port_is_suspended) {
2301 usleep_range(10000, 11000);
2302 break;
2303 }
2304 }
2305 } else {
2306 hcd->state = old_state;
2307 dev_dbg(&rhdev->dev, "bus %s fail, err %d\n",
2308 "resume", status);
2309 if (status != -ESHUTDOWN)
2310 usb_hc_died(hcd);
2311 }
2312 return status;
2313}
2314
2315
2316static void hcd_resume_work(struct work_struct *work)
2317{
2318 struct usb_hcd *hcd = container_of(work, struct usb_hcd, wakeup_work);
2319 struct usb_device *udev = hcd->self.root_hub;
2320
2321 usb_remote_wakeup(udev);
2322}
2323
2324
2325
2326
2327
2328
2329
2330
2331
2332
2333void usb_hcd_resume_root_hub (struct usb_hcd *hcd)
2334{
2335 unsigned long flags;
2336
2337 spin_lock_irqsave (&hcd_root_hub_lock, flags);
2338 if (hcd->rh_registered) {
2339 set_bit(HCD_FLAG_WAKEUP_PENDING, &hcd->flags);
2340 queue_work(pm_wq, &hcd->wakeup_work);
2341 }
2342 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2343}
2344EXPORT_SYMBOL_GPL(usb_hcd_resume_root_hub);
2345
2346#endif
2347
2348
2349
2350#ifdef CONFIG_USB_OTG
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num)
2366{
2367 struct usb_hcd *hcd;
2368 int status = -EOPNOTSUPP;
2369
2370
2371
2372
2373
2374 hcd = container_of (bus, struct usb_hcd, self);
2375 if (port_num && hcd->driver->start_port_reset)
2376 status = hcd->driver->start_port_reset(hcd, port_num);
2377
2378
2379
2380
2381 if (status == 0)
2382 mod_timer(&hcd->rh_timer, jiffies + msecs_to_jiffies(10));
2383 return status;
2384}
2385EXPORT_SYMBOL_GPL(usb_bus_start_enum);
2386
2387#endif
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400
2401irqreturn_t usb_hcd_irq (int irq, void *__hcd)
2402{
2403 struct usb_hcd *hcd = __hcd;
2404 irqreturn_t rc;
2405
2406 if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd)))
2407 rc = IRQ_NONE;
2408 else if (hcd->driver->irq(hcd) == IRQ_NONE)
2409 rc = IRQ_NONE;
2410 else
2411 rc = IRQ_HANDLED;
2412
2413 return rc;
2414}
2415EXPORT_SYMBOL_GPL(usb_hcd_irq);
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429void usb_hc_died (struct usb_hcd *hcd)
2430{
2431 unsigned long flags;
2432
2433 dev_err (hcd->self.controller, "HC died; cleaning up\n");
2434
2435 spin_lock_irqsave (&hcd_root_hub_lock, flags);
2436 clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2437 set_bit(HCD_FLAG_DEAD, &hcd->flags);
2438 if (hcd->rh_registered) {
2439 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2440
2441
2442 usb_set_device_state (hcd->self.root_hub,
2443 USB_STATE_NOTATTACHED);
2444 usb_kick_hub_wq(hcd->self.root_hub);
2445 }
2446 if (usb_hcd_is_primary_hcd(hcd) && hcd->shared_hcd) {
2447 hcd = hcd->shared_hcd;
2448 if (hcd->rh_registered) {
2449 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2450
2451
2452 usb_set_device_state(hcd->self.root_hub,
2453 USB_STATE_NOTATTACHED);
2454 usb_kick_hub_wq(hcd->self.root_hub);
2455 }
2456 }
2457 spin_unlock_irqrestore (&hcd_root_hub_lock, flags);
2458
2459}
2460EXPORT_SYMBOL_GPL (usb_hc_died);
2461
2462
2463
2464static void init_giveback_urb_bh(struct giveback_urb_bh *bh)
2465{
2466
2467 spin_lock_init(&bh->lock);
2468 INIT_LIST_HEAD(&bh->head);
2469 tasklet_init(&bh->bh, usb_giveback_urb_bh, (unsigned long)bh);
2470}
2471
2472
2473
2474
2475
2476
2477
2478
2479
2480
2481
2482
2483
2484
2485
2486
2487
2488struct usb_hcd *usb_create_shared_hcd(const struct hc_driver *driver,
2489 struct device *dev, const char *bus_name,
2490 struct usb_hcd *primary_hcd)
2491{
2492 struct usb_hcd *hcd;
2493
2494 hcd = kzalloc(sizeof(*hcd) + driver->hcd_priv_size, GFP_KERNEL);
2495 if (!hcd) {
2496 dev_dbg (dev, "hcd alloc failed\n");
2497 return NULL;
2498 }
2499 if (primary_hcd == NULL) {
2500 hcd->bandwidth_mutex = kmalloc(sizeof(*hcd->bandwidth_mutex),
2501 GFP_KERNEL);
2502 if (!hcd->bandwidth_mutex) {
2503 kfree(hcd);
2504 dev_dbg(dev, "hcd bandwidth mutex alloc failed\n");
2505 return NULL;
2506 }
2507 mutex_init(hcd->bandwidth_mutex);
2508 dev_set_drvdata(dev, hcd);
2509 } else {
2510 mutex_lock(&usb_port_peer_mutex);
2511 hcd->bandwidth_mutex = primary_hcd->bandwidth_mutex;
2512 hcd->primary_hcd = primary_hcd;
2513 primary_hcd->primary_hcd = primary_hcd;
2514 hcd->shared_hcd = primary_hcd;
2515 primary_hcd->shared_hcd = hcd;
2516 mutex_unlock(&usb_port_peer_mutex);
2517 }
2518
2519 kref_init(&hcd->kref);
2520
2521 usb_bus_init(&hcd->self);
2522 hcd->self.controller = dev;
2523 hcd->self.bus_name = bus_name;
2524 hcd->self.uses_dma = (dev->dma_mask != NULL);
2525
2526 init_timer(&hcd->rh_timer);
2527 hcd->rh_timer.function = rh_timer_func;
2528 hcd->rh_timer.data = (unsigned long) hcd;
2529#ifdef CONFIG_PM
2530 INIT_WORK(&hcd->wakeup_work, hcd_resume_work);
2531#endif
2532
2533 hcd->driver = driver;
2534 hcd->speed = driver->flags & HCD_MASK;
2535 hcd->product_desc = (driver->product_desc) ? driver->product_desc :
2536 "USB Host Controller";
2537 return hcd;
2538}
2539EXPORT_SYMBOL_GPL(usb_create_shared_hcd);
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555struct usb_hcd *usb_create_hcd(const struct hc_driver *driver,
2556 struct device *dev, const char *bus_name)
2557{
2558 return usb_create_shared_hcd(driver, dev, bus_name, NULL);
2559}
2560EXPORT_SYMBOL_GPL(usb_create_hcd);
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572static void hcd_release(struct kref *kref)
2573{
2574 struct usb_hcd *hcd = container_of (kref, struct usb_hcd, kref);
2575
2576 mutex_lock(&usb_port_peer_mutex);
2577 if (usb_hcd_is_primary_hcd(hcd))
2578 kfree(hcd->bandwidth_mutex);
2579 if (hcd->shared_hcd) {
2580 struct usb_hcd *peer = hcd->shared_hcd;
2581
2582 peer->shared_hcd = NULL;
2583 if (peer->primary_hcd == hcd)
2584 peer->primary_hcd = NULL;
2585 }
2586 mutex_unlock(&usb_port_peer_mutex);
2587 kfree(hcd);
2588}
2589
2590struct usb_hcd *usb_get_hcd (struct usb_hcd *hcd)
2591{
2592 if (hcd)
2593 kref_get (&hcd->kref);
2594 return hcd;
2595}
2596EXPORT_SYMBOL_GPL(usb_get_hcd);
2597
2598void usb_put_hcd (struct usb_hcd *hcd)
2599{
2600 if (hcd)
2601 kref_put (&hcd->kref, hcd_release);
2602}
2603EXPORT_SYMBOL_GPL(usb_put_hcd);
2604
2605int usb_hcd_is_primary_hcd(struct usb_hcd *hcd)
2606{
2607 if (!hcd->primary_hcd)
2608 return 1;
2609 return hcd == hcd->primary_hcd;
2610}
2611EXPORT_SYMBOL_GPL(usb_hcd_is_primary_hcd);
2612
2613int usb_hcd_find_raw_port_number(struct usb_hcd *hcd, int port1)
2614{
2615 if (!hcd->driver->find_raw_port_number)
2616 return port1;
2617
2618 return hcd->driver->find_raw_port_number(hcd, port1);
2619}
2620
2621static int usb_hcd_request_irqs(struct usb_hcd *hcd,
2622 unsigned int irqnum, unsigned long irqflags)
2623{
2624 int retval;
2625
2626 if (hcd->driver->irq) {
2627
2628 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
2629 hcd->driver->description, hcd->self.busnum);
2630 retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
2631 hcd->irq_descr, hcd);
2632 if (retval != 0) {
2633 dev_err(hcd->self.controller,
2634 "request interrupt %d failed\n",
2635 irqnum);
2636 return retval;
2637 }
2638 hcd->irq = irqnum;
2639 dev_info(hcd->self.controller, "irq %d, %s 0x%08llx\n", irqnum,
2640 (hcd->driver->flags & HCD_MEMORY) ?
2641 "io mem" : "io base",
2642 (unsigned long long)hcd->rsrc_start);
2643 } else {
2644 hcd->irq = 0;
2645 if (hcd->rsrc_start)
2646 dev_info(hcd->self.controller, "%s 0x%08llx\n",
2647 (hcd->driver->flags & HCD_MEMORY) ?
2648 "io mem" : "io base",
2649 (unsigned long long)hcd->rsrc_start);
2650 }
2651 return 0;
2652}
2653
2654
2655
2656
2657
2658static void usb_put_invalidate_rhdev(struct usb_hcd *hcd)
2659{
2660 struct usb_device *rhdev;
2661
2662 mutex_lock(&usb_port_peer_mutex);
2663 rhdev = hcd->self.root_hub;
2664 hcd->self.root_hub = NULL;
2665 mutex_unlock(&usb_port_peer_mutex);
2666 usb_put_dev(rhdev);
2667}
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679int usb_add_hcd(struct usb_hcd *hcd,
2680 unsigned int irqnum, unsigned long irqflags)
2681{
2682 int retval;
2683 struct usb_device *rhdev;
2684
2685 if (IS_ENABLED(CONFIG_USB_PHY) && !hcd->usb_phy) {
2686 struct usb_phy *phy = usb_get_phy_dev(hcd->self.controller, 0);
2687
2688 if (IS_ERR(phy)) {
2689 retval = PTR_ERR(phy);
2690 if (retval == -EPROBE_DEFER)
2691 return retval;
2692 } else {
2693 retval = usb_phy_init(phy);
2694 if (retval) {
2695 usb_put_phy(phy);
2696 return retval;
2697 }
2698 hcd->usb_phy = phy;
2699 hcd->remove_phy = 1;
2700 }
2701 }
2702
2703 if (IS_ENABLED(CONFIG_GENERIC_PHY) && !hcd->phy) {
2704 struct phy *phy = phy_get(hcd->self.controller, "usb");
2705
2706 if (IS_ERR(phy)) {
2707 retval = PTR_ERR(phy);
2708 if (retval == -EPROBE_DEFER)
2709 goto err_phy;
2710 } else {
2711 retval = phy_init(phy);
2712 if (retval) {
2713 phy_put(phy);
2714 goto err_phy;
2715 }
2716 retval = phy_power_on(phy);
2717 if (retval) {
2718 phy_exit(phy);
2719 phy_put(phy);
2720 goto err_phy;
2721 }
2722 hcd->phy = phy;
2723 hcd->remove_phy = 1;
2724 }
2725 }
2726
2727 dev_info(hcd->self.controller, "%s\n", hcd->product_desc);
2728
2729
2730 if (authorized_default < 0 || authorized_default > 1) {
2731 if (hcd->wireless)
2732 clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
2733 else
2734 set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
2735 } else {
2736 if (authorized_default)
2737 set_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
2738 else
2739 clear_bit(HCD_FLAG_DEV_AUTHORIZED, &hcd->flags);
2740 }
2741 set_bit(HCD_FLAG_HW_ACCESSIBLE, &hcd->flags);
2742
2743
2744 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
2745
2746
2747
2748
2749
2750 retval = hcd_buffer_create(hcd);
2751 if (retval != 0) {
2752 dev_dbg(hcd->self.controller, "pool alloc failed\n");
2753 goto err_create_buf;
2754 }
2755
2756 retval = usb_register_bus(&hcd->self);
2757 if (retval < 0)
2758 goto err_register_bus;
2759
2760 rhdev = usb_alloc_dev(NULL, &hcd->self, 0);
2761 if (rhdev == NULL) {
2762 dev_err(hcd->self.controller, "unable to allocate root hub\n");
2763 retval = -ENOMEM;
2764 goto err_allocate_root_hub;
2765 }
2766 mutex_lock(&usb_port_peer_mutex);
2767 hcd->self.root_hub = rhdev;
2768 mutex_unlock(&usb_port_peer_mutex);
2769
2770 switch (hcd->speed) {
2771 case HCD_USB11:
2772 rhdev->speed = USB_SPEED_FULL;
2773 break;
2774 case HCD_USB2:
2775 rhdev->speed = USB_SPEED_HIGH;
2776 break;
2777 case HCD_USB25:
2778 rhdev->speed = USB_SPEED_WIRELESS;
2779 break;
2780 case HCD_USB3:
2781 case HCD_USB31:
2782 rhdev->speed = USB_SPEED_SUPER;
2783 break;
2784 default:
2785 retval = -EINVAL;
2786 goto err_set_rh_speed;
2787 }
2788
2789
2790
2791
2792
2793 device_set_wakeup_capable(&rhdev->dev, 1);
2794
2795
2796
2797
2798
2799 set_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2800
2801
2802
2803
2804 if (hcd->driver->reset) {
2805 retval = hcd->driver->reset(hcd);
2806 if (retval < 0) {
2807 dev_err(hcd->self.controller, "can't setup: %d\n",
2808 retval);
2809 goto err_hcd_driver_setup;
2810 }
2811 }
2812 hcd->rh_pollable = 1;
2813
2814
2815 if (device_can_wakeup(hcd->self.controller)
2816 && device_can_wakeup(&hcd->self.root_hub->dev))
2817 dev_dbg(hcd->self.controller, "supports USB remote wakeup\n");
2818
2819
2820 init_giveback_urb_bh(&hcd->high_prio_bh);
2821 init_giveback_urb_bh(&hcd->low_prio_bh);
2822
2823
2824
2825
2826 if (usb_hcd_is_primary_hcd(hcd) && irqnum) {
2827 retval = usb_hcd_request_irqs(hcd, irqnum, irqflags);
2828 if (retval)
2829 goto err_request_irq;
2830 }
2831
2832 hcd->state = HC_STATE_RUNNING;
2833 retval = hcd->driver->start(hcd);
2834 if (retval < 0) {
2835 dev_err(hcd->self.controller, "startup error %d\n", retval);
2836 goto err_hcd_driver_start;
2837 }
2838
2839
2840 retval = register_root_hub(hcd);
2841 if (retval != 0)
2842 goto err_register_root_hub;
2843
2844 retval = sysfs_create_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2845 if (retval < 0) {
2846 printk(KERN_ERR "Cannot register USB bus sysfs attributes: %d\n",
2847 retval);
2848 goto error_create_attr_group;
2849 }
2850 if (hcd->uses_new_polling && HCD_POLL_RH(hcd))
2851 usb_hcd_poll_rh_status(hcd);
2852
2853 return retval;
2854
2855error_create_attr_group:
2856 clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2857 if (HC_IS_RUNNING(hcd->state))
2858 hcd->state = HC_STATE_QUIESCING;
2859 spin_lock_irq(&hcd_root_hub_lock);
2860 hcd->rh_registered = 0;
2861 spin_unlock_irq(&hcd_root_hub_lock);
2862
2863#ifdef CONFIG_PM
2864 cancel_work_sync(&hcd->wakeup_work);
2865#endif
2866 mutex_lock(&usb_bus_list_lock);
2867 usb_disconnect(&rhdev);
2868 mutex_unlock(&usb_bus_list_lock);
2869err_register_root_hub:
2870 hcd->rh_pollable = 0;
2871 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2872 del_timer_sync(&hcd->rh_timer);
2873 hcd->driver->stop(hcd);
2874 hcd->state = HC_STATE_HALT;
2875 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2876 del_timer_sync(&hcd->rh_timer);
2877err_hcd_driver_start:
2878 if (usb_hcd_is_primary_hcd(hcd) && hcd->irq > 0)
2879 free_irq(irqnum, hcd);
2880err_request_irq:
2881err_hcd_driver_setup:
2882err_set_rh_speed:
2883 usb_put_invalidate_rhdev(hcd);
2884err_allocate_root_hub:
2885 usb_deregister_bus(&hcd->self);
2886err_register_bus:
2887 hcd_buffer_destroy(hcd);
2888err_create_buf:
2889 if (IS_ENABLED(CONFIG_GENERIC_PHY) && hcd->remove_phy && hcd->phy) {
2890 phy_power_off(hcd->phy);
2891 phy_exit(hcd->phy);
2892 phy_put(hcd->phy);
2893 hcd->phy = NULL;
2894 }
2895err_phy:
2896 if (hcd->remove_phy && hcd->usb_phy) {
2897 usb_phy_shutdown(hcd->usb_phy);
2898 usb_put_phy(hcd->usb_phy);
2899 hcd->usb_phy = NULL;
2900 }
2901 return retval;
2902}
2903EXPORT_SYMBOL_GPL(usb_add_hcd);
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913void usb_remove_hcd(struct usb_hcd *hcd)
2914{
2915 struct usb_device *rhdev = hcd->self.root_hub;
2916
2917 dev_info(hcd->self.controller, "remove, state %x\n", hcd->state);
2918
2919 usb_get_dev(rhdev);
2920 sysfs_remove_group(&rhdev->dev.kobj, &usb_bus_attr_group);
2921
2922 clear_bit(HCD_FLAG_RH_RUNNING, &hcd->flags);
2923 if (HC_IS_RUNNING (hcd->state))
2924 hcd->state = HC_STATE_QUIESCING;
2925
2926 dev_dbg(hcd->self.controller, "roothub graceful disconnect\n");
2927 spin_lock_irq (&hcd_root_hub_lock);
2928 hcd->rh_registered = 0;
2929 spin_unlock_irq (&hcd_root_hub_lock);
2930
2931#ifdef CONFIG_PM
2932 cancel_work_sync(&hcd->wakeup_work);
2933#endif
2934
2935 mutex_lock(&usb_bus_list_lock);
2936 usb_disconnect(&rhdev);
2937 mutex_unlock(&usb_bus_list_lock);
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
2954 hcd->rh_pollable = 0;
2955 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2956 del_timer_sync(&hcd->rh_timer);
2957
2958 hcd->driver->stop(hcd);
2959 hcd->state = HC_STATE_HALT;
2960
2961
2962 clear_bit(HCD_FLAG_POLL_RH, &hcd->flags);
2963 del_timer_sync(&hcd->rh_timer);
2964
2965 if (usb_hcd_is_primary_hcd(hcd)) {
2966 if (hcd->irq > 0)
2967 free_irq(hcd->irq, hcd);
2968 }
2969
2970 usb_deregister_bus(&hcd->self);
2971 hcd_buffer_destroy(hcd);
2972
2973 if (IS_ENABLED(CONFIG_GENERIC_PHY) && hcd->remove_phy && hcd->phy) {
2974 phy_power_off(hcd->phy);
2975 phy_exit(hcd->phy);
2976 phy_put(hcd->phy);
2977 hcd->phy = NULL;
2978 }
2979 if (hcd->remove_phy && hcd->usb_phy) {
2980 usb_phy_shutdown(hcd->usb_phy);
2981 usb_put_phy(hcd->usb_phy);
2982 hcd->usb_phy = NULL;
2983 }
2984
2985 usb_put_invalidate_rhdev(hcd);
2986}
2987EXPORT_SYMBOL_GPL(usb_remove_hcd);
2988
2989void
2990usb_hcd_platform_shutdown(struct platform_device *dev)
2991{
2992 struct usb_hcd *hcd = platform_get_drvdata(dev);
2993
2994 if (hcd->driver->shutdown)
2995 hcd->driver->shutdown(hcd);
2996}
2997EXPORT_SYMBOL_GPL(usb_hcd_platform_shutdown);
2998
2999
3000
3001#if defined(CONFIG_USB_MON) || defined(CONFIG_USB_MON_MODULE)
3002
3003const struct usb_mon_operations *mon_ops;
3004
3005
3006
3007
3008
3009
3010
3011
3012
3013int usb_mon_register(const struct usb_mon_operations *ops)
3014{
3015
3016 if (mon_ops)
3017 return -EBUSY;
3018
3019 mon_ops = ops;
3020 mb();
3021 return 0;
3022}
3023EXPORT_SYMBOL_GPL (usb_mon_register);
3024
3025void usb_mon_deregister (void)
3026{
3027
3028 if (mon_ops == NULL) {
3029 printk(KERN_ERR "USB: monitor was not registered\n");
3030 return;
3031 }
3032 mon_ops = NULL;
3033 mb();
3034}
3035EXPORT_SYMBOL_GPL (usb_mon_deregister);
3036
3037#endif
3038