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
51const char *usbcore_name = "usbcore";
52
53static bool nousb;
54
55module_param(nousb, bool, 0444);
56
57
58
59
60int usb_disabled(void)
61{
62 return nousb;
63}
64EXPORT_SYMBOL_GPL(usb_disabled);
65
66#ifdef CONFIG_PM
67
68static int usb_autosuspend_delay = CONFIG_USB_AUTOSUSPEND_DELAY;
69module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
70MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
71
72#else
73#define usb_autosuspend_delay 0
74#endif
75
76static 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
136int 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}
163EXPORT_SYMBOL_GPL(usb_find_common_endpoints);
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182int 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}
209EXPORT_SYMBOL_GPL(usb_find_common_endpoints_reverse);
210
211
212
213
214
215
216
217
218
219
220
221
222struct 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}
250EXPORT_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
273struct 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}
288EXPORT_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
309struct 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}
321EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting);
322
323struct find_interface_arg {
324 int minor;
325 struct device_driver *drv;
326};
327
328static 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
353struct 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}
368EXPORT_SYMBOL_GPL(usb_find_interface);
369
370struct each_dev_arg {
371 void *data;
372 int (*fn)(struct usb_device *, void *);
373};
374
375static 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
395int 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}
401EXPORT_SYMBOL_GPL(usb_for_each_dev);
402
403
404
405
406
407
408
409
410static 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
428static 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
452static int usb_dev_prepare(struct device *dev)
453{
454 return 0;
455}
456
457static void usb_dev_complete(struct device *dev)
458{
459
460 usb_resume_complete(dev);
461}
462
463static int usb_dev_suspend(struct device *dev)
464{
465 return usb_suspend(dev, PMSG_SUSPEND);
466}
467
468static int usb_dev_resume(struct device *dev)
469{
470 return usb_resume(dev, PMSG_RESUME);
471}
472
473static int usb_dev_freeze(struct device *dev)
474{
475 return usb_suspend(dev, PMSG_FREEZE);
476}
477
478static int usb_dev_thaw(struct device *dev)
479{
480 return usb_resume(dev, PMSG_THAW);
481}
482
483static int usb_dev_poweroff(struct device *dev)
484{
485 return usb_suspend(dev, PMSG_HIBERNATE);
486}
487
488static int usb_dev_restore(struct device *dev)
489{
490 return usb_resume(dev, PMSG_RESTORE);
491}
492
493static 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
510static 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
520struct 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
532static 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
538static 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
575struct 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}
693EXPORT_SYMBOL_GPL(usb_alloc_dev);
694
695
696
697
698
699
700
701
702
703
704
705
706
707struct usb_device *usb_get_dev(struct usb_device *dev)
708{
709 if (dev)
710 get_device(&dev->dev);
711 return dev;
712}
713EXPORT_SYMBOL_GPL(usb_get_dev);
714
715
716
717
718
719
720
721
722void usb_put_dev(struct usb_device *dev)
723{
724 if (dev)
725 put_device(&dev->dev);
726}
727EXPORT_SYMBOL_GPL(usb_put_dev);
728
729
730
731
732
733
734
735
736
737
738
739
740
741struct usb_interface *usb_get_intf(struct usb_interface *intf)
742{
743 if (intf)
744 get_device(&intf->dev);
745 return intf;
746}
747EXPORT_SYMBOL_GPL(usb_get_intf);
748
749
750
751
752
753
754
755
756
757void usb_put_intf(struct usb_interface *intf)
758{
759 if (intf)
760 put_device(&intf->dev);
761}
762EXPORT_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
794int 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}
825EXPORT_SYMBOL_GPL(usb_lock_device_for_reset);
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841int usb_get_current_frame_number(struct usb_device *dev)
842{
843 return usb_hcd_get_frame_number(dev);
844}
845EXPORT_SYMBOL_GPL(usb_get_current_frame_number);
846
847
848
849
850
851
852
853int __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}
880EXPORT_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
905void *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}
912EXPORT_SYMBOL_GPL(usb_alloc_coherent);
913
914
915
916
917
918
919
920
921
922
923
924
925void 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}
934EXPORT_SYMBOL_GPL(usb_free_coherent);
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953#if 0
954struct urb *usb_buffer_map(struct urb *urb)
955{
956 struct usb_bus *bus;
957 struct device *controller;
958
959 if (!urb
960 || !urb->dev
961 || !(bus = urb->dev->bus)
962 || !(controller = bus->sysdev))
963 return NULL;
964
965 if (controller->dma_mask) {
966 urb->transfer_dma = dma_map_single(controller,
967 urb->transfer_buffer, urb->transfer_buffer_length,
968 usb_pipein(urb->pipe)
969 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
970
971
972 } else
973 urb->transfer_dma = ~0;
974 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
975 return urb;
976}
977EXPORT_SYMBOL_GPL(usb_buffer_map);
978#endif
979
980
981
982
983
984
985#if 0
986
987
988
989
990
991void usb_buffer_dmasync(struct urb *urb)
992{
993 struct usb_bus *bus;
994 struct device *controller;
995
996 if (!urb
997 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
998 || !urb->dev
999 || !(bus = urb->dev->bus)
1000 || !(controller = bus->sysdev))
1001 return;
1002
1003 if (controller->dma_mask) {
1004 dma_sync_single_for_cpu(controller,
1005 urb->transfer_dma, urb->transfer_buffer_length,
1006 usb_pipein(urb->pipe)
1007 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1008 if (usb_pipecontrol(urb->pipe))
1009 dma_sync_single_for_cpu(controller,
1010 urb->setup_dma,
1011 sizeof(struct usb_ctrlrequest),
1012 DMA_TO_DEVICE);
1013 }
1014}
1015EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
1016#endif
1017
1018
1019
1020
1021
1022
1023
1024#if 0
1025void usb_buffer_unmap(struct urb *urb)
1026{
1027 struct usb_bus *bus;
1028 struct device *controller;
1029
1030 if (!urb
1031 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
1032 || !urb->dev
1033 || !(bus = urb->dev->bus)
1034 || !(controller = bus->sysdev))
1035 return;
1036
1037 if (controller->dma_mask) {
1038 dma_unmap_single(controller,
1039 urb->transfer_dma, urb->transfer_buffer_length,
1040 usb_pipein(urb->pipe)
1041 ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1042 }
1043 urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
1044}
1045EXPORT_SYMBOL_GPL(usb_buffer_unmap);
1046#endif
1047
1048#if 0
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
1077 struct scatterlist *sg, int nents)
1078{
1079 struct usb_bus *bus;
1080 struct device *controller;
1081
1082 if (!dev
1083 || !(bus = dev->bus)
1084 || !(controller = bus->sysdev)
1085 || !controller->dma_mask)
1086 return -EINVAL;
1087
1088
1089 return dma_map_sg(controller, sg, nents,
1090 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
1091}
1092EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
1093#endif
1094
1095
1096
1097
1098
1099
1100#if 0
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
1113 struct scatterlist *sg, int n_hw_ents)
1114{
1115 struct usb_bus *bus;
1116 struct device *controller;
1117
1118 if (!dev
1119 || !(bus = dev->bus)
1120 || !(controller = bus->sysdev)
1121 || !controller->dma_mask)
1122 return;
1123
1124 dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
1125 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1126}
1127EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
1128#endif
1129
1130#if 0
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
1141 struct scatterlist *sg, int n_hw_ents)
1142{
1143 struct usb_bus *bus;
1144 struct device *controller;
1145
1146 if (!dev
1147 || !(bus = dev->bus)
1148 || !(controller = bus->sysdev)
1149 || !controller->dma_mask)
1150 return;
1151
1152 dma_unmap_sg(controller, sg, n_hw_ents,
1153 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
1154}
1155EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
1156#endif
1157
1158
1159
1160
1161static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
1162 void *data)
1163{
1164 struct device *dev = data;
1165
1166 switch (action) {
1167 case BUS_NOTIFY_ADD_DEVICE:
1168 if (dev->type == &usb_device_type)
1169 (void) usb_create_sysfs_dev_files(to_usb_device(dev));
1170 else if (dev->type == &usb_if_device_type)
1171 usb_create_sysfs_intf_files(to_usb_interface(dev));
1172 break;
1173
1174 case BUS_NOTIFY_DEL_DEVICE:
1175 if (dev->type == &usb_device_type)
1176 usb_remove_sysfs_dev_files(to_usb_device(dev));
1177 else if (dev->type == &usb_if_device_type)
1178 usb_remove_sysfs_intf_files(to_usb_interface(dev));
1179 break;
1180 }
1181 return 0;
1182}
1183
1184static struct notifier_block usb_bus_nb = {
1185 .notifier_call = usb_bus_notify,
1186};
1187
1188static struct dentry *usb_devices_root;
1189
1190static void usb_debugfs_init(void)
1191{
1192 usb_devices_root = debugfs_create_file("devices", 0444, usb_debug_root,
1193 NULL, &usbfs_devices_fops);
1194}
1195
1196static void usb_debugfs_cleanup(void)
1197{
1198 debugfs_remove(usb_devices_root);
1199}
1200
1201
1202
1203
1204static int __init usb_init(void)
1205{
1206 int retval;
1207 if (usb_disabled()) {
1208 pr_info("%s: USB support disabled\n", usbcore_name);
1209 return 0;
1210 }
1211 usb_init_pool_max();
1212
1213 usb_debugfs_init();
1214
1215 usb_acpi_register();
1216 retval = bus_register(&usb_bus_type);
1217 if (retval)
1218 goto bus_register_failed;
1219 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
1220 if (retval)
1221 goto bus_notifier_failed;
1222 retval = usb_major_init();
1223 if (retval)
1224 goto major_init_failed;
1225 retval = usb_register(&usbfs_driver);
1226 if (retval)
1227 goto driver_register_failed;
1228 retval = usb_devio_init();
1229 if (retval)
1230 goto usb_devio_init_failed;
1231 retval = usb_hub_init();
1232 if (retval)
1233 goto hub_init_failed;
1234 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE);
1235 if (!retval)
1236 goto out;
1237
1238 usb_hub_cleanup();
1239hub_init_failed:
1240 usb_devio_cleanup();
1241usb_devio_init_failed:
1242 usb_deregister(&usbfs_driver);
1243driver_register_failed:
1244 usb_major_cleanup();
1245major_init_failed:
1246 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1247bus_notifier_failed:
1248 bus_unregister(&usb_bus_type);
1249bus_register_failed:
1250 usb_acpi_unregister();
1251 usb_debugfs_cleanup();
1252out:
1253 return retval;
1254}
1255
1256
1257
1258
1259static void __exit usb_exit(void)
1260{
1261
1262 if (usb_disabled())
1263 return;
1264
1265 usb_release_quirk_list();
1266 usb_deregister_device_driver(&usb_generic_driver);
1267 usb_major_cleanup();
1268 usb_deregister(&usbfs_driver);
1269 usb_devio_cleanup();
1270 usb_hub_cleanup();
1271 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1272 bus_unregister(&usb_bus_type);
1273 usb_acpi_unregister();
1274 usb_debugfs_cleanup();
1275 idr_destroy(&usb_bus_idr);
1276}
1277
1278subsys_initcall(usb_init);
1279module_exit(usb_exit);
1280MODULE_LICENSE("GPL");
1281