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
26#include <linux/module.h>
27#include <linux/moduleparam.h>
28#include <linux/string.h>
29#include <linux/bitops.h>
30#include <linux/slab.h>
31#include <linux/interrupt.h>
32#include <linux/kmod.h>
33#include <linux/init.h>
34#include <linux/spinlock.h>
35#include <linux/errno.h>
36#include <linux/usb.h>
37#include <linux/usb/hcd.h>
38#include <linux/mutex.h>
39#include <linux/workqueue.h>
40#include <linux/debugfs.h>
41#include <linux/usb/of.h>
42
43#include <asm/io.h>
44#include <linux/scatterlist.h>
45#include <linux/mm.h>
46#include <linux/dma-mapping.h>
47
48#include "hub.h"
49
50const char *usbcore_name = "usbcore";
51
52static bool nousb;
53
54module_param(nousb, bool, 0444);
55
56
57
58
59int usb_disabled(void)
60{
61 return nousb;
62}
63EXPORT_SYMBOL_GPL(usb_disabled);
64
65#ifdef CONFIG_PM
66
67static int usb_autosuspend_delay = CONFIG_USB_AUTOSUSPEND_DELAY;
68module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
69MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
70
71#else
72#define usb_autosuspend_delay 0
73#endif
74
75static bool match_endpoint(struct usb_endpoint_descriptor *epd,
76 struct usb_endpoint_descriptor **bulk_in,
77 struct usb_endpoint_descriptor **bulk_out,
78 struct usb_endpoint_descriptor **int_in,
79 struct usb_endpoint_descriptor **int_out)
80{
81 switch (usb_endpoint_type(epd)) {
82 case USB_ENDPOINT_XFER_BULK:
83 if (usb_endpoint_dir_in(epd)) {
84 if (bulk_in && !*bulk_in) {
85 *bulk_in = epd;
86 break;
87 }
88 } else {
89 if (bulk_out && !*bulk_out) {
90 *bulk_out = epd;
91 break;
92 }
93 }
94
95 return false;
96 case USB_ENDPOINT_XFER_INT:
97 if (usb_endpoint_dir_in(epd)) {
98 if (int_in && !*int_in) {
99 *int_in = epd;
100 break;
101 }
102 } else {
103 if (int_out && !*int_out) {
104 *int_out = epd;
105 break;
106 }
107 }
108
109 return false;
110 default:
111 return false;
112 }
113
114 return (!bulk_in || *bulk_in) && (!bulk_out || *bulk_out) &&
115 (!int_in || *int_in) && (!int_out || *int_out);
116}
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135int usb_find_common_endpoints(struct usb_host_interface *alt,
136 struct usb_endpoint_descriptor **bulk_in,
137 struct usb_endpoint_descriptor **bulk_out,
138 struct usb_endpoint_descriptor **int_in,
139 struct usb_endpoint_descriptor **int_out)
140{
141 struct usb_endpoint_descriptor *epd;
142 int i;
143
144 if (bulk_in)
145 *bulk_in = NULL;
146 if (bulk_out)
147 *bulk_out = NULL;
148 if (int_in)
149 *int_in = NULL;
150 if (int_out)
151 *int_out = NULL;
152
153 for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
154 epd = &alt->endpoint[i].desc;
155
156 if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
157 return 0;
158 }
159
160 return -ENXIO;
161}
162EXPORT_SYMBOL_GPL(usb_find_common_endpoints);
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181int usb_find_common_endpoints_reverse(struct usb_host_interface *alt,
182 struct usb_endpoint_descriptor **bulk_in,
183 struct usb_endpoint_descriptor **bulk_out,
184 struct usb_endpoint_descriptor **int_in,
185 struct usb_endpoint_descriptor **int_out)
186{
187 struct usb_endpoint_descriptor *epd;
188 int i;
189
190 if (bulk_in)
191 *bulk_in = NULL;
192 if (bulk_out)
193 *bulk_out = NULL;
194 if (int_in)
195 *int_in = NULL;
196 if (int_out)
197 *int_out = NULL;
198
199 for (i = alt->desc.bNumEndpoints - 1; i >= 0; --i) {
200 epd = &alt->endpoint[i].desc;
201
202 if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
203 return 0;
204 }
205
206 return -ENXIO;
207}
208EXPORT_SYMBOL_GPL(usb_find_common_endpoints_reverse);
209
210
211
212
213
214
215
216
217
218
219
220
221struct usb_host_interface *usb_find_alt_setting(
222 struct usb_host_config *config,
223 unsigned int iface_num,
224 unsigned int alt_num)
225{
226 struct usb_interface_cache *intf_cache = NULL;
227 int i;
228
229 if (!config)
230 return NULL;
231 for (i = 0; i < config->desc.bNumInterfaces; i++) {
232 if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
233 == iface_num) {
234 intf_cache = config->intf_cache[i];
235 break;
236 }
237 }
238 if (!intf_cache)
239 return NULL;
240 for (i = 0; i < intf_cache->num_altsetting; i++)
241 if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
242 return &intf_cache->altsetting[i];
243
244 printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
245 "config %u\n", alt_num, iface_num,
246 config->desc.bConfigurationValue);
247 return NULL;
248}
249EXPORT_SYMBOL_GPL(usb_find_alt_setting);
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
273 unsigned ifnum)
274{
275 struct usb_host_config *config = dev->actconfig;
276 int i;
277
278 if (!config)
279 return NULL;
280 for (i = 0; i < config->desc.bNumInterfaces; i++)
281 if (config->interface[i]->altsetting[0]
282 .desc.bInterfaceNumber == ifnum)
283 return config->interface[i];
284
285 return NULL;
286}
287EXPORT_SYMBOL_GPL(usb_ifnum_to_if);
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308struct usb_host_interface *usb_altnum_to_altsetting(
309 const struct usb_interface *intf,
310 unsigned int altnum)
311{
312 int i;
313
314 for (i = 0; i < intf->num_altsetting; i++) {
315 if (intf->altsetting[i].desc.bAlternateSetting == altnum)
316 return &intf->altsetting[i];
317 }
318 return NULL;
319}
320EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
321
322struct find_interface_arg {
323 int minor;
324 struct device_driver *drv;
325};
326
327static int __find_interface(struct device *dev, const void *data)
328{
329 const struct find_interface_arg *arg = data;
330 struct usb_interface *intf;
331
332 if (!is_usb_interface(dev))
333 return 0;
334
335 if (dev->driver != arg->drv)
336 return 0;
337 intf = to_usb_interface(dev);
338 return intf->minor == arg->minor;
339}
340
341
342
343
344
345
346
347
348
349
350
351
352struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
353{
354 struct find_interface_arg argb;
355 struct device *dev;
356
357 argb.minor = minor;
358 argb.drv = &drv->drvwrap.driver;
359
360 dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
361
362
363 put_device(dev);
364
365 return dev ? to_usb_interface(dev) : NULL;
366}
367EXPORT_SYMBOL_GPL(usb_find_interface);
368
369struct each_dev_arg {
370 void *data;
371 int (*fn)(struct usb_device *, void *);
372};
373
374static int __each_dev(struct device *dev, void *data)
375{
376 struct each_dev_arg *arg = (struct each_dev_arg *)data;
377
378
379 if (!is_usb_device(dev))
380 return 0;
381
382 return arg->fn(to_usb_device(dev), arg->data);
383}
384
385
386
387
388
389
390
391
392
393
394int usb_for_each_dev(void *data, int (*fn)(struct usb_device *, void *))
395{
396 struct each_dev_arg arg = {data, fn};
397
398 return bus_for_each_dev(&usb_bus_type, NULL, &arg, __each_dev);
399}
400EXPORT_SYMBOL_GPL(usb_for_each_dev);
401
402
403
404
405
406
407
408
409static void usb_release_dev(struct device *dev)
410{
411 struct usb_device *udev;
412 struct usb_hcd *hcd;
413
414 udev = to_usb_device(dev);
415 hcd = bus_to_hcd(udev->bus);
416
417 usb_destroy_configuration(udev);
418 usb_release_bos_descriptor(udev);
419 of_node_put(dev->of_node);
420 usb_put_hcd(hcd);
421 kfree(udev->product);
422 kfree(udev->manufacturer);
423 kfree(udev->serial);
424 kfree(udev);
425}
426
427static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
428{
429 struct usb_device *usb_dev;
430
431 usb_dev = to_usb_device(dev);
432
433 if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
434 return -ENOMEM;
435
436 if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
437 return -ENOMEM;
438
439 return 0;
440}
441
442#ifdef CONFIG_PM
443
444
445
446
447
448
449
450
451static int usb_dev_prepare(struct device *dev)
452{
453 return 0;
454}
455
456static void usb_dev_complete(struct device *dev)
457{
458
459 usb_resume_complete(dev);
460}
461
462static int usb_dev_suspend(struct device *dev)
463{
464 return usb_suspend(dev, PMSG_SUSPEND);
465}
466
467static int usb_dev_resume(struct device *dev)
468{
469 return usb_resume(dev, PMSG_RESUME);
470}
471
472static int usb_dev_freeze(struct device *dev)
473{
474 return usb_suspend(dev, PMSG_FREEZE);
475}
476
477static int usb_dev_thaw(struct device *dev)
478{
479 return usb_resume(dev, PMSG_THAW);
480}
481
482static int usb_dev_poweroff(struct device *dev)
483{
484 return usb_suspend(dev, PMSG_HIBERNATE);
485}
486
487static int usb_dev_restore(struct device *dev)
488{
489 return usb_resume(dev, PMSG_RESTORE);
490}
491
492static const struct dev_pm_ops usb_device_pm_ops = {
493 .prepare = usb_dev_prepare,
494 .complete = usb_dev_complete,
495 .suspend = usb_dev_suspend,
496 .resume = usb_dev_resume,
497 .freeze = usb_dev_freeze,
498 .thaw = usb_dev_thaw,
499 .poweroff = usb_dev_poweroff,
500 .restore = usb_dev_restore,
501 .runtime_suspend = usb_runtime_suspend,
502 .runtime_resume = usb_runtime_resume,
503 .runtime_idle = usb_runtime_idle,
504};
505
506#endif
507
508
509static char *usb_devnode(struct device *dev,
510 umode_t *mode, kuid_t *uid, kgid_t *gid)
511{
512 struct usb_device *usb_dev;
513
514 usb_dev = to_usb_device(dev);
515 return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
516 usb_dev->bus->busnum, usb_dev->devnum);
517}
518
519struct device_type usb_device_type = {
520 .name = "usb_device",
521 .release = usb_release_dev,
522 .uevent = usb_dev_uevent,
523 .devnode = usb_devnode,
524#ifdef CONFIG_PM
525 .pm = &usb_device_pm_ops,
526#endif
527};
528
529
530
531static unsigned usb_bus_is_wusb(struct usb_bus *bus)
532{
533 struct usb_hcd *hcd = bus_to_hcd(bus);
534 return hcd->wireless;
535}
536
537static bool usb_dev_authorized(struct usb_device *dev, struct usb_hcd *hcd)
538{
539 struct usb_hub *hub;
540
541 if (!dev->parent)
542 return true;
543
544 switch (hcd->dev_policy) {
545 case USB_DEVICE_AUTHORIZE_NONE:
546 default:
547 return false;
548
549 case USB_DEVICE_AUTHORIZE_ALL:
550 return true;
551
552 case USB_DEVICE_AUTHORIZE_INTERNAL:
553 hub = usb_hub_to_struct_hub(dev->parent);
554 return hub->ports[dev->portnum - 1]->connect_type ==
555 USB_PORT_CONNECT_TYPE_HARD_WIRED;
556 }
557}
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574struct usb_device *usb_alloc_dev(struct usb_device *parent,
575 struct usb_bus *bus, unsigned port1)
576{
577 struct usb_device *dev;
578 struct usb_hcd *usb_hcd = bus_to_hcd(bus);
579 unsigned root_hub = 0;
580 unsigned raw_port = port1;
581
582 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
583 if (!dev)
584 return NULL;
585
586 if (!usb_get_hcd(usb_hcd)) {
587 kfree(dev);
588 return NULL;
589 }
590
591 if (usb_hcd->driver->alloc_dev && parent &&
592 !usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
593 usb_put_hcd(bus_to_hcd(bus));
594 kfree(dev);
595 return NULL;
596 }
597
598 device_initialize(&dev->dev);
599 dev->dev.bus = &usb_bus_type;
600 dev->dev.type = &usb_device_type;
601 dev->dev.groups = usb_device_groups;
602
603
604
605
606
607
608
609
610
611
612 dev->dev.dma_mask = bus->sysdev->dma_mask;
613 dev->dev.dma_pfn_offset = bus->sysdev->dma_pfn_offset;
614 set_dev_node(&dev->dev, dev_to_node(bus->sysdev));
615 dev->state = USB_STATE_ATTACHED;
616 dev->lpm_disable_count = 1;
617 atomic_set(&dev->urbnum, 0);
618
619 INIT_LIST_HEAD(&dev->ep0.urb_list);
620 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
621 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
622
623 usb_enable_endpoint(dev, &dev->ep0, false);
624 dev->can_submit = 1;
625
626
627
628
629
630
631
632
633
634 if (unlikely(!parent)) {
635 dev->devpath[0] = '0';
636 dev->route = 0;
637
638 dev->dev.parent = bus->controller;
639 device_set_of_node_from_dev(&dev->dev, bus->sysdev);
640 dev_set_name(&dev->dev, "usb%d", bus->busnum);
641 root_hub = 1;
642 } else {
643
644 if (parent->devpath[0] == '0') {
645 snprintf(dev->devpath, sizeof dev->devpath,
646 "%d", port1);
647
648 dev->route = 0;
649 } else {
650 snprintf(dev->devpath, sizeof dev->devpath,
651 "%s.%d", parent->devpath, port1);
652
653 if (port1 < 15)
654 dev->route = parent->route +
655 (port1 << ((parent->level - 1)*4));
656 else
657 dev->route = parent->route +
658 (15 << ((parent->level - 1)*4));
659 }
660
661 dev->dev.parent = &parent->dev;
662 dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
663
664 if (!parent->parent) {
665
666 raw_port = usb_hcd_find_raw_port_number(usb_hcd,
667 port1);
668 }
669 dev->dev.of_node = usb_of_get_device_node(parent, raw_port);
670
671
672 }
673
674 dev->portnum = port1;
675 dev->bus = bus;
676 dev->parent = parent;
677 INIT_LIST_HEAD(&dev->filelist);
678
679#ifdef CONFIG_PM
680 pm_runtime_set_autosuspend_delay(&dev->dev,
681 usb_autosuspend_delay * 1000);
682 dev->connect_time = jiffies;
683 dev->active_duration = -jiffies;
684#endif
685
686 dev->authorized = usb_dev_authorized(dev, usb_hcd);
687 if (!root_hub)
688 dev->wusb = usb_bus_is_wusb(bus) ? 1 : 0;
689
690 return dev;
691}
692EXPORT_SYMBOL_GPL(usb_alloc_dev);
693
694
695
696
697
698
699
700
701
702
703
704
705
706struct usb_device *usb_get_dev(struct usb_device *dev)
707{
708 if (dev)
709 get_device(&dev->dev);
710 return dev;
711}
712EXPORT_SYMBOL_GPL(usb_get_dev);
713
714
715
716
717
718
719
720
721void usb_put_dev(struct usb_device *dev)
722{
723 if (dev)
724 put_device(&dev->dev);
725}
726EXPORT_SYMBOL_GPL(usb_put_dev);
727
728
729
730
731
732
733
734
735
736
737
738
739
740struct usb_interface *usb_get_intf(struct usb_interface *intf)
741{
742 if (intf)
743 get_device(&intf->dev);
744 return intf;
745}
746EXPORT_SYMBOL_GPL(usb_get_intf);
747
748
749
750
751
752
753
754
755
756void usb_put_intf(struct usb_interface *intf)
757{
758 if (intf)
759 put_device(&intf->dev);
760}
761EXPORT_SYMBOL_GPL(usb_put_intf);
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793int usb_lock_device_for_reset(struct usb_device *udev,
794 const struct usb_interface *iface)
795{
796 unsigned long jiffies_expire = jiffies + HZ;
797
798 if (udev->state == USB_STATE_NOTATTACHED)
799 return -ENODEV;
800 if (udev->state == USB_STATE_SUSPENDED)
801 return -EHOSTUNREACH;
802 if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
803 iface->condition == USB_INTERFACE_UNBOUND))
804 return -EINTR;
805
806 while (!usb_trylock_device(udev)) {
807
808
809
810 if (time_after(jiffies, jiffies_expire))
811 return -EBUSY;
812
813 msleep(15);
814 if (udev->state == USB_STATE_NOTATTACHED)
815 return -ENODEV;
816 if (udev->state == USB_STATE_SUSPENDED)
817 return -EHOSTUNREACH;
818 if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
819 iface->condition == USB_INTERFACE_UNBOUND))
820 return -EINTR;
821 }
822 return 0;
823}
824EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840int usb_get_current_frame_number(struct usb_device *dev)
841{
842 return usb_hcd_get_frame_number(dev);
843}
844EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
845
846
847
848
849
850
851
852int __usb_get_extra_descriptor(char *buffer, unsigned size,
853 unsigned char type, void **ptr, size_t minsize)
854{
855 struct usb_descriptor_header *header;
856
857 while (size >= sizeof(struct usb_descriptor_header)) {
858 header = (struct usb_descriptor_header *)buffer;
859
860 if (header->bLength < 2 || header->bLength > size) {
861 printk(KERN_ERR
862 "%s: bogus descriptor, type %d length %d\n",
863 usbcore_name,
864 header->bDescriptorType,
865 header->bLength);
866 return -1;
867 }
868
869 if (header->bDescriptorType == type && header->bLength >= minsize) {
870 *ptr = header;
871 return 0;
872 }
873
874 buffer += header->bLength;
875 size -= header->bLength;
876 }
877 return -1;
878}
879EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
905 dma_addr_t *dma)
906{
907 if (!dev || !dev->bus)
908 return NULL;
909 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
910}
911EXPORT_SYMBOL_GPL(usb_alloc_coherent);
912
913
914
915
916
917
918
919
920
921
922
923
924void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
925 dma_addr_t dma)
926{
927 if (!dev || !dev->bus)
928 return;
929 if (!addr)
930 return;
931 hcd_buffer_free(dev->bus, size, addr, dma);
932}
933EXPORT_SYMBOL_GPL(usb_free_coherent);
934
935
936
937
938static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
939 void *data)
940{
941 struct device *dev = data;
942
943 switch (action) {
944 case BUS_NOTIFY_ADD_DEVICE:
945 if (dev->type == &usb_device_type)
946 (void) usb_create_sysfs_dev_files(to_usb_device(dev));
947 else if (dev->type == &usb_if_device_type)
948 usb_create_sysfs_intf_files(to_usb_interface(dev));
949 break;
950
951 case BUS_NOTIFY_DEL_DEVICE:
952 if (dev->type == &usb_device_type)
953 usb_remove_sysfs_dev_files(to_usb_device(dev));
954 else if (dev->type == &usb_if_device_type)
955 usb_remove_sysfs_intf_files(to_usb_interface(dev));
956 break;
957 }
958 return 0;
959}
960
961static struct notifier_block usb_bus_nb = {
962 .notifier_call = usb_bus_notify,
963};
964
965static struct dentry *usb_devices_root;
966
967static void usb_debugfs_init(void)
968{
969 usb_devices_root = debugfs_create_file("devices", 0444, usb_debug_root,
970 NULL, &usbfs_devices_fops);
971}
972
973static void usb_debugfs_cleanup(void)
974{
975 debugfs_remove(usb_devices_root);
976}
977
978
979
980
981static int __init usb_init(void)
982{
983 int retval;
984 if (usb_disabled()) {
985 pr_info("%s: USB support disabled\n", usbcore_name);
986 return 0;
987 }
988 usb_init_pool_max();
989
990 usb_debugfs_init();
991
992 usb_acpi_register();
993 retval = bus_register(&usb_bus_type);
994 if (retval)
995 goto bus_register_failed;
996 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
997 if (retval)
998 goto bus_notifier_failed;
999 retval = usb_major_init();
1000 if (retval)
1001 goto major_init_failed;
1002 retval = usb_register(&usbfs_driver);
1003 if (retval)
1004 goto driver_register_failed;
1005 retval = usb_devio_init();
1006 if (retval)
1007 goto usb_devio_init_failed;
1008 retval = usb_hub_init();
1009 if (retval)
1010 goto hub_init_failed;
1011 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1012 if (!retval)
1013 goto out;
1014
1015 usb_hub_cleanup();
1016hub_init_failed:
1017 usb_devio_cleanup();
1018usb_devio_init_failed:
1019 usb_deregister(&usbfs_driver);
1020driver_register_failed:
1021 usb_major_cleanup();
1022major_init_failed:
1023 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1024bus_notifier_failed:
1025 bus_unregister(&usb_bus_type);
1026bus_register_failed:
1027 usb_acpi_unregister();
1028 usb_debugfs_cleanup();
1029out:
1030 return retval;
1031}
1032
1033
1034
1035
1036static void __exit usb_exit(void)
1037{
1038
1039 if (usb_disabled())
1040 return;
1041
1042 usb_release_quirk_list();
1043 usb_deregister_device_driver(&usb_generic_driver);
1044 usb_major_cleanup();
1045 usb_deregister(&usbfs_driver);
1046 usb_devio_cleanup();
1047 usb_hub_cleanup();
1048 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1049 bus_unregister(&usb_bus_type);
1050 usb_acpi_unregister();
1051 usb_debugfs_cleanup();
1052 idr_destroy(&usb_bus_idr);
1053}
1054
1055subsys_initcall(usb_init);
1056module_exit(usb_exit);
1057MODULE_LICENSE("GPL");
1058