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 "usb.h"
50
51
52const char *usbcore_name = "usbcore";
53
54static bool nousb;
55
56module_param(nousb, bool, 0444);
57
58
59
60
61int usb_disabled(void)
62{
63 return nousb;
64}
65EXPORT_SYMBOL_GPL(usb_disabled);
66
67#ifdef CONFIG_PM
68static int usb_autosuspend_delay = 2;
69
70module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
71MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
72
73#else
74#define usb_autosuspend_delay 0
75#endif
76
77static bool match_endpoint(struct usb_endpoint_descriptor *epd,
78 struct usb_endpoint_descriptor **bulk_in,
79 struct usb_endpoint_descriptor **bulk_out,
80 struct usb_endpoint_descriptor **int_in,
81 struct usb_endpoint_descriptor **int_out)
82{
83 switch (usb_endpoint_type(epd)) {
84 case USB_ENDPOINT_XFER_BULK:
85 if (usb_endpoint_dir_in(epd)) {
86 if (bulk_in && !*bulk_in) {
87 *bulk_in = epd;
88 break;
89 }
90 } else {
91 if (bulk_out && !*bulk_out) {
92 *bulk_out = epd;
93 break;
94 }
95 }
96
97 return false;
98 case USB_ENDPOINT_XFER_INT:
99 if (usb_endpoint_dir_in(epd)) {
100 if (int_in && !*int_in) {
101 *int_in = epd;
102 break;
103 }
104 } else {
105 if (int_out && !*int_out) {
106 *int_out = epd;
107 break;
108 }
109 }
110
111 return false;
112 default:
113 return false;
114 }
115
116 return (!bulk_in || *bulk_in) && (!bulk_out || *bulk_out) &&
117 (!int_in || *int_in) && (!int_out || *int_out);
118}
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137int usb_find_common_endpoints(struct usb_host_interface *alt,
138 struct usb_endpoint_descriptor **bulk_in,
139 struct usb_endpoint_descriptor **bulk_out,
140 struct usb_endpoint_descriptor **int_in,
141 struct usb_endpoint_descriptor **int_out)
142{
143 struct usb_endpoint_descriptor *epd;
144 int i;
145
146 if (bulk_in)
147 *bulk_in = NULL;
148 if (bulk_out)
149 *bulk_out = NULL;
150 if (int_in)
151 *int_in = NULL;
152 if (int_out)
153 *int_out = NULL;
154
155 for (i = 0; i < alt->desc.bNumEndpoints; ++i) {
156 epd = &alt->endpoint[i].desc;
157
158 if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
159 return 0;
160 }
161
162 return -ENXIO;
163}
164EXPORT_SYMBOL_GPL(usb_find_common_endpoints);
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183int usb_find_common_endpoints_reverse(struct usb_host_interface *alt,
184 struct usb_endpoint_descriptor **bulk_in,
185 struct usb_endpoint_descriptor **bulk_out,
186 struct usb_endpoint_descriptor **int_in,
187 struct usb_endpoint_descriptor **int_out)
188{
189 struct usb_endpoint_descriptor *epd;
190 int i;
191
192 if (bulk_in)
193 *bulk_in = NULL;
194 if (bulk_out)
195 *bulk_out = NULL;
196 if (int_in)
197 *int_in = NULL;
198 if (int_out)
199 *int_out = NULL;
200
201 for (i = alt->desc.bNumEndpoints - 1; i >= 0; --i) {
202 epd = &alt->endpoint[i].desc;
203
204 if (match_endpoint(epd, bulk_in, bulk_out, int_in, int_out))
205 return 0;
206 }
207
208 return -ENXIO;
209}
210EXPORT_SYMBOL_GPL(usb_find_common_endpoints_reverse);
211
212
213
214
215
216
217
218
219
220
221
222
223struct usb_host_interface *usb_find_alt_setting(
224 struct usb_host_config *config,
225 unsigned int iface_num,
226 unsigned int alt_num)
227{
228 struct usb_interface_cache *intf_cache = NULL;
229 int i;
230
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, void *data)
328{
329 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 usb_put_hcd(hcd);
420 kfree(udev->product);
421 kfree(udev->manufacturer);
422 kfree(udev->serial);
423 kfree(udev);
424}
425
426static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
427{
428 struct usb_device *usb_dev;
429
430 usb_dev = to_usb_device(dev);
431
432 if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
433 return -ENOMEM;
434
435 if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
436 return -ENOMEM;
437
438 return 0;
439}
440
441#ifdef CONFIG_PM
442
443
444
445
446
447
448
449
450static int usb_dev_prepare(struct device *dev)
451{
452 return 0;
453}
454
455static void usb_dev_complete(struct device *dev)
456{
457
458 usb_resume_complete(dev);
459}
460
461static int usb_dev_suspend(struct device *dev)
462{
463 return usb_suspend(dev, PMSG_SUSPEND);
464}
465
466static int usb_dev_resume(struct device *dev)
467{
468 return usb_resume(dev, PMSG_RESUME);
469}
470
471static int usb_dev_freeze(struct device *dev)
472{
473 return usb_suspend(dev, PMSG_FREEZE);
474}
475
476static int usb_dev_thaw(struct device *dev)
477{
478 return usb_resume(dev, PMSG_THAW);
479}
480
481static int usb_dev_poweroff(struct device *dev)
482{
483 return usb_suspend(dev, PMSG_HIBERNATE);
484}
485
486static int usb_dev_restore(struct device *dev)
487{
488 return usb_resume(dev, PMSG_RESTORE);
489}
490
491static const struct dev_pm_ops usb_device_pm_ops = {
492 .prepare = usb_dev_prepare,
493 .complete = usb_dev_complete,
494 .suspend = usb_dev_suspend,
495 .resume = usb_dev_resume,
496 .freeze = usb_dev_freeze,
497 .thaw = usb_dev_thaw,
498 .poweroff = usb_dev_poweroff,
499 .restore = usb_dev_restore,
500 .runtime_suspend = usb_runtime_suspend,
501 .runtime_resume = usb_runtime_resume,
502 .runtime_idle = usb_runtime_idle,
503};
504
505#endif
506
507
508static char *usb_devnode(struct device *dev,
509 umode_t *mode, kuid_t *uid, kgid_t *gid)
510{
511 struct usb_device *usb_dev;
512
513 usb_dev = to_usb_device(dev);
514 return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
515 usb_dev->bus->busnum, usb_dev->devnum);
516}
517
518struct device_type usb_device_type = {
519 .name = "usb_device",
520 .release = usb_release_dev,
521 .uevent = usb_dev_uevent,
522 .devnode = usb_devnode,
523#ifdef CONFIG_PM
524 .pm = &usb_device_pm_ops,
525#endif
526};
527
528
529
530static unsigned usb_bus_is_wusb(struct usb_bus *bus)
531{
532 struct usb_hcd *hcd = bus_to_hcd(bus);
533 return hcd->wireless;
534}
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552struct usb_device *usb_alloc_dev(struct usb_device *parent,
553 struct usb_bus *bus, unsigned port1)
554{
555 struct usb_device *dev;
556 struct usb_hcd *usb_hcd = bus_to_hcd(bus);
557 unsigned root_hub = 0;
558 unsigned raw_port = port1;
559
560 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
561 if (!dev)
562 return NULL;
563
564 if (!usb_get_hcd(usb_hcd)) {
565 kfree(dev);
566 return NULL;
567 }
568
569 if (usb_hcd->driver->alloc_dev && parent &&
570 !usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
571 usb_put_hcd(bus_to_hcd(bus));
572 kfree(dev);
573 return NULL;
574 }
575
576 device_initialize(&dev->dev);
577 dev->dev.bus = &usb_bus_type;
578 dev->dev.type = &usb_device_type;
579 dev->dev.groups = usb_device_groups;
580
581
582
583
584
585
586
587
588
589
590 dev->dev.dma_mask = bus->sysdev->dma_mask;
591 dev->dev.dma_pfn_offset = bus->sysdev->dma_pfn_offset;
592 set_dev_node(&dev->dev, dev_to_node(bus->sysdev));
593 dev->state = USB_STATE_ATTACHED;
594 dev->lpm_disable_count = 1;
595 atomic_set(&dev->urbnum, 0);
596
597 INIT_LIST_HEAD(&dev->ep0.urb_list);
598 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
599 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
600
601 usb_enable_endpoint(dev, &dev->ep0, false);
602 dev->can_submit = 1;
603
604
605
606
607
608
609
610
611
612 if (unlikely(!parent)) {
613 dev->devpath[0] = '0';
614 dev->route = 0;
615
616 dev->dev.parent = bus->controller;
617 dev_set_name(&dev->dev, "usb%d", bus->busnum);
618 root_hub = 1;
619 } else {
620
621 if (parent->devpath[0] == '0') {
622 snprintf(dev->devpath, sizeof dev->devpath,
623 "%d", port1);
624
625 dev->route = 0;
626 } else {
627 snprintf(dev->devpath, sizeof dev->devpath,
628 "%s.%d", parent->devpath, port1);
629
630 if (port1 < 15)
631 dev->route = parent->route +
632 (port1 << ((parent->level - 1)*4));
633 else
634 dev->route = parent->route +
635 (15 << ((parent->level - 1)*4));
636 }
637
638 dev->dev.parent = &parent->dev;
639 dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
640
641 if (!parent->parent) {
642
643 raw_port = usb_hcd_find_raw_port_number(usb_hcd,
644 port1);
645 }
646 dev->dev.of_node = usb_of_get_child_node(parent->dev.of_node,
647 raw_port);
648
649
650 }
651
652 dev->portnum = port1;
653 dev->bus = bus;
654 dev->parent = parent;
655 INIT_LIST_HEAD(&dev->filelist);
656
657#ifdef CONFIG_PM
658 pm_runtime_set_autosuspend_delay(&dev->dev,
659 usb_autosuspend_delay * 1000);
660 dev->connect_time = jiffies;
661 dev->active_duration = -jiffies;
662#endif
663 if (root_hub)
664 dev->authorized = 1;
665 else {
666 dev->authorized = !!HCD_DEV_AUTHORIZED(usb_hcd);
667 dev->wusb = usb_bus_is_wusb(bus) ? 1 : 0;
668 }
669 return dev;
670}
671EXPORT_SYMBOL_GPL(usb_alloc_dev);
672
673
674
675
676
677
678
679
680
681
682
683
684
685struct usb_device *usb_get_dev(struct usb_device *dev)
686{
687 if (dev)
688 get_device(&dev->dev);
689 return dev;
690}
691EXPORT_SYMBOL_GPL(usb_get_dev);
692
693
694
695
696
697
698
699
700void usb_put_dev(struct usb_device *dev)
701{
702 if (dev)
703 put_device(&dev->dev);
704}
705EXPORT_SYMBOL_GPL(usb_put_dev);
706
707
708
709
710
711
712
713
714
715
716
717
718
719struct usb_interface *usb_get_intf(struct usb_interface *intf)
720{
721 if (intf)
722 get_device(&intf->dev);
723 return intf;
724}
725EXPORT_SYMBOL_GPL(usb_get_intf);
726
727
728
729
730
731
732
733
734
735void usb_put_intf(struct usb_interface *intf)
736{
737 if (intf)
738 put_device(&intf->dev);
739}
740EXPORT_SYMBOL_GPL(usb_put_intf);
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772int usb_lock_device_for_reset(struct usb_device *udev,
773 const struct usb_interface *iface)
774{
775 unsigned long jiffies_expire = jiffies + HZ;
776
777 if (udev->state == USB_STATE_NOTATTACHED)
778 return -ENODEV;
779 if (udev->state == USB_STATE_SUSPENDED)
780 return -EHOSTUNREACH;
781 if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
782 iface->condition == USB_INTERFACE_UNBOUND))
783 return -EINTR;
784
785 while (!usb_trylock_device(udev)) {
786
787
788
789 if (time_after(jiffies, jiffies_expire))
790 return -EBUSY;
791
792 msleep(15);
793 if (udev->state == USB_STATE_NOTATTACHED)
794 return -ENODEV;
795 if (udev->state == USB_STATE_SUSPENDED)
796 return -EHOSTUNREACH;
797 if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
798 iface->condition == USB_INTERFACE_UNBOUND))
799 return -EINTR;
800 }
801 return 0;
802}
803EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819int usb_get_current_frame_number(struct usb_device *dev)
820{
821 return usb_hcd_get_frame_number(dev);
822}
823EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
824
825
826
827
828
829
830
831int __usb_get_extra_descriptor(char *buffer, unsigned size,
832 unsigned char type, void **ptr)
833{
834 struct usb_descriptor_header *header;
835
836 while (size >= sizeof(struct usb_descriptor_header)) {
837 header = (struct usb_descriptor_header *)buffer;
838
839 if (header->bLength < 2) {
840 printk(KERN_ERR
841 "%s: bogus descriptor, type %d length %d\n",
842 usbcore_name,
843 header->bDescriptorType,
844 header->bLength);
845 return -1;
846 }
847
848 if (header->bDescriptorType == type) {
849 *ptr = header;
850 return 0;
851 }
852
853 buffer += header->bLength;
854 size -= header->bLength;
855 }
856 return -1;
857}
858EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor);
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
884 dma_addr_t *dma)
885{
886 if (!dev || !dev->bus)
887 return NULL;
888 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
889}
890EXPORT_SYMBOL_GPL(usb_alloc_coherent);
891
892
893
894
895
896
897
898
899
900
901
902
903void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
904 dma_addr_t dma)
905{
906 if (!dev || !dev->bus)
907 return;
908 if (!addr)
909 return;
910 hcd_buffer_free(dev->bus, size, addr, dma);
911}
912EXPORT_SYMBOL_GPL(usb_free_coherent);
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931#if 0
932struct urb *usb_buffer_map(struct urb *urb)
933{
934 struct usb_bus *bus;
935 struct device *controller;
936
937 if (!urb
938 || !urb->dev
939 || !(bus = urb->dev->bus)
940 || !(controller = bus->sysdev))
941 return NULL;
942
943 if (controller->dma_mask) {
944 urb->transfer_dma = dma_map_single(controller,
945 urb->transfer_buffer, urb->transfer_buffer_length,
946 usb_pipein(urb->pipe)
947 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
948
949
950 } else
951 urb->transfer_dma = ~0;
952 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
953 return urb;
954}
955EXPORT_SYMBOL_GPL(usb_buffer_map);
956#endif
957
958
959
960
961
962
963#if 0
964
965
966
967
968
969void usb_buffer_dmasync(struct urb *urb)
970{
971 struct usb_bus *bus;
972 struct device *controller;
973
974 if (!urb
975 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
976 || !urb->dev
977 || !(bus = urb->dev->bus)
978 || !(controller = bus->sysdev))
979 return;
980
981 if (controller->dma_mask) {
982 dma_sync_single_for_cpu(controller,
983 urb->transfer_dma, urb->transfer_buffer_length,
984 usb_pipein(urb->pipe)
985 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
986 if (usb_pipecontrol(urb->pipe))
987 dma_sync_single_for_cpu(controller,
988 urb->setup_dma,
989 sizeof(struct usb_ctrlrequest),
990 DMA_TO_DEVICE);
991 }
992}
993EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
994#endif
995
996
997
998
999
1000
1001
1002#if 0
1003void usb_buffer_unmap(struct urb *urb)
1004{
1005 struct usb_bus *bus;
1006 struct device *controller;
1007
1008 if (!urb
1009 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
1010 || !urb->dev
1011 || !(bus = urb->dev->bus)
1012 || !(controller = bus->sysdev))
1013 return;
1014
1015 if (controller->dma_mask) {
1016 dma_unmap_single(controller,
1017 urb->transfer_dma, urb->transfer_buffer_length,
1018 usb_pipein(urb->pipe)
1019 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1020 }
1021 urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
1022}
1023EXPORT_SYMBOL_GPL(usb_buffer_unmap);
1024#endif
1025
1026#if 0
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
1055 struct scatterlist *sg, int nents)
1056{
1057 struct usb_bus *bus;
1058 struct device *controller;
1059
1060 if (!dev
1061 || !(bus = dev->bus)
1062 || !(controller = bus->sysdev)
1063 || !controller->dma_mask)
1064 return -EINVAL;
1065
1066
1067 return dma_map_sg(controller, sg, nents,
1068 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
1069}
1070EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
1071#endif
1072
1073
1074
1075
1076
1077
1078#if 0
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
1091 struct scatterlist *sg, int n_hw_ents)
1092{
1093 struct usb_bus *bus;
1094 struct device *controller;
1095
1096 if (!dev
1097 || !(bus = dev->bus)
1098 || !(controller = bus->sysdev)
1099 || !controller->dma_mask)
1100 return;
1101
1102 dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
1103 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1104}
1105EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
1106#endif
1107
1108#if 0
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
1119 struct scatterlist *sg, int n_hw_ents)
1120{
1121 struct usb_bus *bus;
1122 struct device *controller;
1123
1124 if (!dev
1125 || !(bus = dev->bus)
1126 || !(controller = bus->sysdev)
1127 || !controller->dma_mask)
1128 return;
1129
1130 dma_unmap_sg(controller, sg, n_hw_ents,
1131 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1132}
1133EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
1134#endif
1135
1136
1137
1138
1139static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
1140 void *data)
1141{
1142 struct device *dev = data;
1143
1144 switch (action) {
1145 case BUS_NOTIFY_ADD_DEVICE:
1146 if (dev->type == &usb_device_type)
1147 (void) usb_create_sysfs_dev_files(to_usb_device(dev));
1148 else if (dev->type == &usb_if_device_type)
1149 usb_create_sysfs_intf_files(to_usb_interface(dev));
1150 break;
1151
1152 case BUS_NOTIFY_DEL_DEVICE:
1153 if (dev->type == &usb_device_type)
1154 usb_remove_sysfs_dev_files(to_usb_device(dev));
1155 else if (dev->type == &usb_if_device_type)
1156 usb_remove_sysfs_intf_files(to_usb_interface(dev));
1157 break;
1158 }
1159 return 0;
1160}
1161
1162static struct notifier_block usb_bus_nb = {
1163 .notifier_call = usb_bus_notify,
1164};
1165
1166struct dentry *usb_debug_root;
1167EXPORT_SYMBOL_GPL(usb_debug_root);
1168
1169static struct dentry *usb_debug_devices;
1170
1171static int usb_debugfs_init(void)
1172{
1173 usb_debug_root = debugfs_create_dir("usb", NULL);
1174 if (!usb_debug_root)
1175 return -ENOENT;
1176
1177 usb_debug_devices = debugfs_create_file("devices", 0444,
1178 usb_debug_root, NULL,
1179 &usbfs_devices_fops);
1180 if (!usb_debug_devices) {
1181 debugfs_remove(usb_debug_root);
1182 usb_debug_root = NULL;
1183 return -ENOENT;
1184 }
1185
1186 return 0;
1187}
1188
1189static void usb_debugfs_cleanup(void)
1190{
1191 debugfs_remove(usb_debug_devices);
1192 debugfs_remove(usb_debug_root);
1193}
1194
1195
1196
1197
1198static int __init usb_init(void)
1199{
1200 int retval;
1201 if (usb_disabled()) {
1202 pr_info("%s: USB support disabled\n", usbcore_name);
1203 return 0;
1204 }
1205 usb_init_pool_max();
1206
1207 retval = usb_debugfs_init();
1208 if (retval)
1209 goto out;
1210
1211 usb_acpi_register();
1212 retval = bus_register(&usb_bus_type);
1213 if (retval)
1214 goto bus_register_failed;
1215 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
1216 if (retval)
1217 goto bus_notifier_failed;
1218 retval = usb_major_init();
1219 if (retval)
1220 goto major_init_failed;
1221 retval = usb_register(&usbfs_driver);
1222 if (retval)
1223 goto driver_register_failed;
1224 retval = usb_devio_init();
1225 if (retval)
1226 goto usb_devio_init_failed;
1227 retval = usb_hub_init();
1228 if (retval)
1229 goto hub_init_failed;
1230 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1231 if (!retval)
1232 goto out;
1233
1234 usb_hub_cleanup();
1235hub_init_failed:
1236 usb_devio_cleanup();
1237usb_devio_init_failed:
1238 usb_deregister(&usbfs_driver);
1239driver_register_failed:
1240 usb_major_cleanup();
1241major_init_failed:
1242 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1243bus_notifier_failed:
1244 bus_unregister(&usb_bus_type);
1245bus_register_failed:
1246 usb_acpi_unregister();
1247 usb_debugfs_cleanup();
1248out:
1249 return retval;
1250}
1251
1252
1253
1254
1255static void __exit usb_exit(void)
1256{
1257
1258 if (usb_disabled())
1259 return;
1260
1261 usb_deregister_device_driver(&usb_generic_driver);
1262 usb_major_cleanup();
1263 usb_deregister(&usbfs_driver);
1264 usb_devio_cleanup();
1265 usb_hub_cleanup();
1266 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1267 bus_unregister(&usb_bus_type);
1268 usb_acpi_unregister();
1269 usb_debugfs_cleanup();
1270 idr_destroy(&usb_bus_idr);
1271}
1272
1273subsys_initcall(usb_init);
1274module_exit(usb_exit);
1275MODULE_LICENSE("GPL");
1276