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