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