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