Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
usb.c
Go to the documentation of this file.
1 /*
2  * drivers/usb/core/usb.c
3  *
4  * (C) Copyright Linus Torvalds 1999
5  * (C) Copyright Johannes Erdfelt 1999-2001
6  * (C) Copyright Andreas Gal 1999
7  * (C) Copyright Gregory P. Smith 1999
8  * (C) Copyright Deti Fliegl 1999 (new USB architecture)
9  * (C) Copyright Randy Dunlap 2000
10  * (C) Copyright David Brownell 2000-2004
11  * (C) Copyright Yggdrasil Computing, Inc. 2000
12  * (usb_device_id matching changes by Adam J. Richter)
13  * (C) Copyright Greg Kroah-Hartman 2002-2003
14  *
15  * NOTE! This is not actually a driver at all, rather this is
16  * just a collection of helper routines that implement the
17  * generic USB things that the real drivers can use..
18  *
19  * Think of this as a "USB library" rather than anything else.
20  * It should be considered a slave, with no callbacks. Callbacks
21  * are evil.
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> /* for in_interrupt() */
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 
40 #include <asm/io.h>
41 #include <linux/scatterlist.h>
42 #include <linux/mm.h>
43 #include <linux/dma-mapping.h>
44 
45 #include "usb.h"
46 
47 
48 const char *usbcore_name = "usbcore";
49 
50 static bool nousb; /* Disable USB when built into kernel image */
51 
52 #ifdef CONFIG_USB_SUSPEND
53 static int usb_autosuspend_delay = 2; /* Default delay value,
54  * in seconds */
55 module_param_named(autosuspend, usb_autosuspend_delay, int, 0644);
56 MODULE_PARM_DESC(autosuspend, "default autosuspend delay");
57 
58 #else
59 #define usb_autosuspend_delay 0
60 #endif
61 
62 
72 struct usb_host_interface *usb_find_alt_setting(
73  struct usb_host_config *config,
74  unsigned int iface_num,
75  unsigned int alt_num)
76 {
77  struct usb_interface_cache *intf_cache = NULL;
78  int i;
79 
80  for (i = 0; i < config->desc.bNumInterfaces; i++) {
81  if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber
82  == iface_num) {
83  intf_cache = config->intf_cache[i];
84  break;
85  }
86  }
87  if (!intf_cache)
88  return NULL;
89  for (i = 0; i < intf_cache->num_altsetting; i++)
90  if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num)
91  return &intf_cache->altsetting[i];
92 
93  printk(KERN_DEBUG "Did not find alt setting %u for intf %u, "
94  "config %u\n", alt_num, iface_num,
95  config->desc.bConfigurationValue);
96  return NULL;
97 }
99 
119 struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
120  unsigned ifnum)
121 {
122  struct usb_host_config *config = dev->actconfig;
123  int i;
124 
125  if (!config)
126  return NULL;
127  for (i = 0; i < config->desc.bNumInterfaces; i++)
128  if (config->interface[i]->altsetting[0]
129  .desc.bInterfaceNumber == ifnum)
130  return config->interface[i];
131 
132  return NULL;
133 }
135 
153 struct usb_host_interface *usb_altnum_to_altsetting(
154  const struct usb_interface *intf,
155  unsigned int altnum)
156 {
157  int i;
158 
159  for (i = 0; i < intf->num_altsetting; i++) {
160  if (intf->altsetting[i].desc.bAlternateSetting == altnum)
161  return &intf->altsetting[i];
162  }
163  return NULL;
164 }
166 
168  int minor;
170 };
171 
172 static int __find_interface(struct device *dev, void *data)
173 {
174  struct find_interface_arg *arg = data;
175  struct usb_interface *intf;
176 
177  if (!is_usb_interface(dev))
178  return 0;
179 
180  if (dev->driver != arg->drv)
181  return 0;
182  intf = to_usb_interface(dev);
183  return intf->minor == arg->minor;
184 }
185 
195 struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor)
196 {
197  struct find_interface_arg argb;
198  struct device *dev;
199 
200  argb.minor = minor;
201  argb.drv = &drv->drvwrap.driver;
202 
203  dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface);
204 
205  /* Drop reference count from bus_find_device */
206  put_device(dev);
207 
208  return dev ? to_usb_interface(dev) : NULL;
209 }
211 
219 static void usb_release_dev(struct device *dev)
220 {
221  struct usb_device *udev;
222  struct usb_hcd *hcd;
223 
224  udev = to_usb_device(dev);
225  hcd = bus_to_hcd(udev->bus);
226 
229  usb_put_hcd(hcd);
230  kfree(udev->product);
231  kfree(udev->manufacturer);
232  kfree(udev->serial);
233  kfree(udev);
234 }
235 
236 #ifdef CONFIG_HOTPLUG
237 static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
238 {
239  struct usb_device *usb_dev;
240 
241  usb_dev = to_usb_device(dev);
242 
243  if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum))
244  return -ENOMEM;
245 
246  if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum))
247  return -ENOMEM;
248 
249  return 0;
250 }
251 
252 #else
253 
254 static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
255 {
256  return -ENODEV;
257 }
258 #endif /* CONFIG_HOTPLUG */
259 
260 #ifdef CONFIG_PM
261 
262 /* USB device Power-Management thunks.
263  * There's no need to distinguish here between quiescing a USB device
264  * and powering it down; the generic_suspend() routine takes care of
265  * it by skipping the usb_port_suspend() call for a quiesce. And for
266  * USB interfaces there's no difference at all.
267  */
268 
269 static int usb_dev_prepare(struct device *dev)
270 {
271  return 0; /* Implement eventually? */
272 }
273 
274 static void usb_dev_complete(struct device *dev)
275 {
276  /* Currently used only for rebinding interfaces */
277  usb_resume_complete(dev);
278 }
279 
280 static int usb_dev_suspend(struct device *dev)
281 {
282  return usb_suspend(dev, PMSG_SUSPEND);
283 }
284 
285 static int usb_dev_resume(struct device *dev)
286 {
287  return usb_resume(dev, PMSG_RESUME);
288 }
289 
290 static int usb_dev_freeze(struct device *dev)
291 {
292  return usb_suspend(dev, PMSG_FREEZE);
293 }
294 
295 static int usb_dev_thaw(struct device *dev)
296 {
297  return usb_resume(dev, PMSG_THAW);
298 }
299 
300 static int usb_dev_poweroff(struct device *dev)
301 {
302  return usb_suspend(dev, PMSG_HIBERNATE);
303 }
304 
305 static int usb_dev_restore(struct device *dev)
306 {
307  return usb_resume(dev, PMSG_RESTORE);
308 }
309 
310 static const struct dev_pm_ops usb_device_pm_ops = {
311  .prepare = usb_dev_prepare,
312  .complete = usb_dev_complete,
313  .suspend = usb_dev_suspend,
314  .resume = usb_dev_resume,
315  .freeze = usb_dev_freeze,
316  .thaw = usb_dev_thaw,
317  .poweroff = usb_dev_poweroff,
318  .restore = usb_dev_restore,
319 #ifdef CONFIG_USB_SUSPEND
320  .runtime_suspend = usb_runtime_suspend,
321  .runtime_resume = usb_runtime_resume,
322  .runtime_idle = usb_runtime_idle,
323 #endif
324 };
325 
326 #endif /* CONFIG_PM */
327 
328 
329 static char *usb_devnode(struct device *dev, umode_t *mode)
330 {
331  struct usb_device *usb_dev;
332 
333  usb_dev = to_usb_device(dev);
334  return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d",
335  usb_dev->bus->busnum, usb_dev->devnum);
336 }
337 
339  .name = "usb_device",
340  .release = usb_release_dev,
341  .uevent = usb_dev_uevent,
342  .devnode = usb_devnode,
343 #ifdef CONFIG_PM
344  .pm = &usb_device_pm_ops,
345 #endif
346 };
347 
348 
349 /* Returns 1 if @usb_bus is WUSB, 0 otherwise */
350 static unsigned usb_bus_is_wusb(struct usb_bus *bus)
351 {
352  struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self);
353  return hcd->wireless;
354 }
355 
356 
369 struct usb_device *usb_alloc_dev(struct usb_device *parent,
370  struct usb_bus *bus, unsigned port1)
371 {
372  struct usb_device *dev;
373  struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self);
374  unsigned root_hub = 0;
375 
376  dev = kzalloc(sizeof(*dev), GFP_KERNEL);
377  if (!dev)
378  return NULL;
379 
380  if (!usb_get_hcd(bus_to_hcd(bus))) {
381  kfree(dev);
382  return NULL;
383  }
384  /* Root hubs aren't true devices, so don't allocate HCD resources */
385  if (usb_hcd->driver->alloc_dev && parent &&
386  !usb_hcd->driver->alloc_dev(usb_hcd, dev)) {
387  usb_put_hcd(bus_to_hcd(bus));
388  kfree(dev);
389  return NULL;
390  }
391 
392  device_initialize(&dev->dev);
393  dev->dev.bus = &usb_bus_type;
394  dev->dev.type = &usb_device_type;
395  dev->dev.groups = usb_device_groups;
396  dev->dev.dma_mask = bus->controller->dma_mask;
397  set_dev_node(&dev->dev, dev_to_node(bus->controller));
398  dev->state = USB_STATE_ATTACHED;
399  dev->lpm_disable_count = 1;
400  atomic_set(&dev->urbnum, 0);
401 
402  INIT_LIST_HEAD(&dev->ep0.urb_list);
403  dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE;
404  dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT;
405  /* ep0 maxpacket comes later, from device descriptor */
406  usb_enable_endpoint(dev, &dev->ep0, false);
407  dev->can_submit = 1;
408 
409  /* Save readable and stable topology id, distinguishing devices
410  * by location for diagnostics, tools, driver model, etc. The
411  * string is a path along hub ports, from the root. Each device's
412  * dev->devpath will be stable until USB is re-cabled, and hubs
413  * are often labeled with these port numbers. The name isn't
414  * as stable: bus->busnum changes easily from modprobe order,
415  * cardbus or pci hotplugging, and so on.
416  */
417  if (unlikely(!parent)) {
418  dev->devpath[0] = '0';
419  dev->route = 0;
420 
421  dev->dev.parent = bus->controller;
422  dev_set_name(&dev->dev, "usb%d", bus->busnum);
423  root_hub = 1;
424  } else {
425  /* match any labeling on the hubs; it's one-based */
426  if (parent->devpath[0] == '0') {
427  snprintf(dev->devpath, sizeof dev->devpath,
428  "%d", port1);
429  /* Root ports are not counted in route string */
430  dev->route = 0;
431  } else {
432  snprintf(dev->devpath, sizeof dev->devpath,
433  "%s.%d", parent->devpath, port1);
434  /* Route string assumes hubs have less than 16 ports */
435  if (port1 < 15)
436  dev->route = parent->route +
437  (port1 << ((parent->level - 1)*4));
438  else
439  dev->route = parent->route +
440  (15 << ((parent->level - 1)*4));
441  }
442 
443  dev->dev.parent = &parent->dev;
444  dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath);
445 
446  /* hub driver sets up TT records */
447  }
448 
449  dev->portnum = port1;
450  dev->bus = bus;
451  dev->parent = parent;
452  INIT_LIST_HEAD(&dev->filelist);
453 
454 #ifdef CONFIG_PM
456  usb_autosuspend_delay * 1000);
457  dev->connect_time = jiffies;
458  dev->active_duration = -jiffies;
459 #endif
460  if (root_hub) /* Root hub always ok [and always wired] */
461  dev->authorized = 1;
462  else {
463  dev->authorized = usb_hcd->authorized_default;
464  dev->wusb = usb_bus_is_wusb(bus)? 1 : 0;
465  }
466  return dev;
467 }
468 
481 struct usb_device *usb_get_dev(struct usb_device *dev)
482 {
483  if (dev)
484  get_device(&dev->dev);
485  return dev;
486 }
488 
496 void usb_put_dev(struct usb_device *dev)
497 {
498  if (dev)
499  put_device(&dev->dev);
500 }
502 
517 {
518  if (intf)
519  get_device(&intf->dev);
520  return intf;
521 }
523 
533 {
534  if (intf)
535  put_device(&intf->dev);
536 }
538 
539 /* USB device locking
540  *
541  * USB devices and interfaces are locked using the semaphore in their
542  * embedded struct device. The hub driver guarantees that whenever a
543  * device is connected or disconnected, drivers are called with the
544  * USB device locked as well as their particular interface.
545  *
546  * Complications arise when several devices are to be locked at the same
547  * time. Only hub-aware drivers that are part of usbcore ever have to
548  * do this; nobody else needs to worry about it. The rule for locking
549  * is simple:
550  *
551  * When locking both a device and its parent, always lock the
552  * the parent first.
553  */
554 
569 int usb_lock_device_for_reset(struct usb_device *udev,
570  const struct usb_interface *iface)
571 {
572  unsigned long jiffies_expire = jiffies + HZ;
573 
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  while (!usb_trylock_device(udev)) {
583 
584  /* If we can't acquire the lock after waiting one second,
585  * we're probably deadlocked */
586  if (time_after(jiffies, jiffies_expire))
587  return -EBUSY;
588 
589  msleep(15);
590  if (udev->state == USB_STATE_NOTATTACHED)
591  return -ENODEV;
592  if (udev->state == USB_STATE_SUSPENDED)
593  return -EHOSTUNREACH;
594  if (iface && (iface->condition == USB_INTERFACE_UNBINDING ||
595  iface->condition == USB_INTERFACE_UNBOUND))
596  return -EINTR;
597  }
598  return 0;
599 }
601 
615 int usb_get_current_frame_number(struct usb_device *dev)
616 {
617  return usb_hcd_get_frame_number(dev);
618 }
620 
621 /*-------------------------------------------------------------------*/
622 /*
623  * __usb_get_extra_descriptor() finds a descriptor of specific type in the
624  * extra field of the interface and endpoint descriptor structs.
625  */
626 
628  unsigned char type, void **ptr)
629 {
631 
632  while (size >= sizeof(struct usb_descriptor_header)) {
633  header = (struct usb_descriptor_header *)buffer;
634 
635  if (header->bLength < 2) {
637  "%s: bogus descriptor, type %d length %d\n",
638  usbcore_name,
639  header->bDescriptorType,
640  header->bLength);
641  return -1;
642  }
643 
644  if (header->bDescriptorType == type) {
645  *ptr = header;
646  return 0;
647  }
648 
649  buffer += header->bLength;
650  size -= header->bLength;
651  }
652  return -1;
653 }
655 
678 void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags,
679  dma_addr_t *dma)
680 {
681  if (!dev || !dev->bus)
682  return NULL;
683  return hcd_buffer_alloc(dev->bus, size, mem_flags, dma);
684 }
686 
698 void usb_free_coherent(struct usb_device *dev, size_t size, void *addr,
699  dma_addr_t dma)
700 {
701  if (!dev || !dev->bus)
702  return;
703  if (!addr)
704  return;
705  hcd_buffer_free(dev->bus, size, addr, dma);
706 }
708 
725 #if 0
726 struct urb *usb_buffer_map(struct urb *urb)
727 {
728  struct usb_bus *bus;
729  struct device *controller;
730 
731  if (!urb
732  || !urb->dev
733  || !(bus = urb->dev->bus)
734  || !(controller = bus->controller))
735  return NULL;
736 
737  if (controller->dma_mask) {
738  urb->transfer_dma = dma_map_single(controller,
739  urb->transfer_buffer, urb->transfer_buffer_length,
740  usb_pipein(urb->pipe)
742  /* FIXME generic api broken like pci, can't report errors */
743  /* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */
744  } else
745  urb->transfer_dma = ~0;
746  urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
747  return urb;
748 }
749 EXPORT_SYMBOL_GPL(usb_buffer_map);
750 #endif /* 0 */
751 
752 /* XXX DISABLED, no users currently. If you wish to re-enable this
753  * XXX please determine whether the sync is to transfer ownership of
754  * XXX the buffer from device to cpu or vice verse, and thusly use the
755  * XXX appropriate _for_{cpu,device}() method. -DaveM
756  */
757 #if 0
758 
763 void usb_buffer_dmasync(struct urb *urb)
764 {
765  struct usb_bus *bus;
766  struct device *controller;
767 
768  if (!urb
769  || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
770  || !urb->dev
771  || !(bus = urb->dev->bus)
772  || !(controller = bus->controller))
773  return;
774 
775  if (controller->dma_mask) {
776  dma_sync_single_for_cpu(controller,
777  urb->transfer_dma, urb->transfer_buffer_length,
778  usb_pipein(urb->pipe)
780  if (usb_pipecontrol(urb->pipe))
781  dma_sync_single_for_cpu(controller,
782  urb->setup_dma,
783  sizeof(struct usb_ctrlrequest),
784  DMA_TO_DEVICE);
785  }
786 }
787 EXPORT_SYMBOL_GPL(usb_buffer_dmasync);
788 #endif
789 
796 #if 0
797 void usb_buffer_unmap(struct urb *urb)
798 {
799  struct usb_bus *bus;
800  struct device *controller;
801 
802  if (!urb
803  || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP)
804  || !urb->dev
805  || !(bus = urb->dev->bus)
806  || !(controller = bus->controller))
807  return;
808 
809  if (controller->dma_mask) {
810  dma_unmap_single(controller,
811  urb->transfer_dma, urb->transfer_buffer_length,
812  usb_pipein(urb->pipe)
814  }
815  urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP;
816 }
817 EXPORT_SYMBOL_GPL(usb_buffer_unmap);
818 #endif /* 0 */
819 
820 #if 0
821 
847 int usb_buffer_map_sg(const struct usb_device *dev, int is_in,
848  struct scatterlist *sg, int nents)
849 {
850  struct usb_bus *bus;
851  struct device *controller;
852 
853  if (!dev
854  || !(bus = dev->bus)
855  || !(controller = bus->controller)
856  || !controller->dma_mask)
857  return -EINVAL;
858 
859  /* FIXME generic api broken like pci, can't report errors */
860  return dma_map_sg(controller, sg, nents,
861  is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM;
862 }
863 EXPORT_SYMBOL_GPL(usb_buffer_map_sg);
864 #endif
865 
866 /* XXX DISABLED, no users currently. If you wish to re-enable this
867  * XXX please determine whether the sync is to transfer ownership of
868  * XXX the buffer from device to cpu or vice verse, and thusly use the
869  * XXX appropriate _for_{cpu,device}() method. -DaveM
870  */
871 #if 0
872 
883 void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in,
884  struct scatterlist *sg, int n_hw_ents)
885 {
886  struct usb_bus *bus;
887  struct device *controller;
888 
889  if (!dev
890  || !(bus = dev->bus)
891  || !(controller = bus->controller)
892  || !controller->dma_mask)
893  return;
894 
895  dma_sync_sg_for_cpu(controller, sg, n_hw_ents,
896  is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
897 }
898 EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg);
899 #endif
900 
901 #if 0
902 
911 void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in,
912  struct scatterlist *sg, int n_hw_ents)
913 {
914  struct usb_bus *bus;
915  struct device *controller;
916 
917  if (!dev
918  || !(bus = dev->bus)
919  || !(controller = bus->controller)
920  || !controller->dma_mask)
921  return;
922 
923  dma_unmap_sg(controller, sg, n_hw_ents,
924  is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
925 }
926 EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg);
927 #endif
928 
929 /* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */
930 #ifdef MODULE
931 module_param(nousb, bool, 0444);
932 #else
933 core_param(nousb, nousb, bool, 0444);
934 #endif
935 
936 /*
937  * for external read access to <nousb>
938  */
939 int usb_disabled(void)
940 {
941  return nousb;
942 }
944 
945 /*
946  * Notifications of device and interface registration
947  */
948 static int usb_bus_notify(struct notifier_block *nb, unsigned long action,
949  void *data)
950 {
951  struct device *dev = data;
952 
953  switch (action) {
955  if (dev->type == &usb_device_type)
956  (void) usb_create_sysfs_dev_files(to_usb_device(dev));
957  else if (dev->type == &usb_if_device_type)
958  usb_create_sysfs_intf_files(to_usb_interface(dev));
959  break;
960 
962  if (dev->type == &usb_device_type)
963  usb_remove_sysfs_dev_files(to_usb_device(dev));
964  else if (dev->type == &usb_if_device_type)
965  usb_remove_sysfs_intf_files(to_usb_interface(dev));
966  break;
967  }
968  return 0;
969 }
970 
971 static struct notifier_block usb_bus_nb = {
972  .notifier_call = usb_bus_notify,
973 };
974 
976 EXPORT_SYMBOL_GPL(usb_debug_root);
977 
978 static struct dentry *usb_debug_devices;
979 
980 static int usb_debugfs_init(void)
981 {
982  usb_debug_root = debugfs_create_dir("usb", NULL);
983  if (!usb_debug_root)
984  return -ENOENT;
985 
986  usb_debug_devices = debugfs_create_file("devices", 0444,
987  usb_debug_root, NULL,
989  if (!usb_debug_devices) {
990  debugfs_remove(usb_debug_root);
991  usb_debug_root = NULL;
992  return -ENOENT;
993  }
994 
995  return 0;
996 }
997 
998 static void usb_debugfs_cleanup(void)
999 {
1000  debugfs_remove(usb_debug_devices);
1001  debugfs_remove(usb_debug_root);
1002 }
1003 
1004 /*
1005  * Init
1006  */
1007 static int __init usb_init(void)
1008 {
1009  int retval;
1010  if (nousb) {
1011  pr_info("%s: USB support disabled\n", usbcore_name);
1012  return 0;
1013  }
1014 
1015  retval = usb_debugfs_init();
1016  if (retval)
1017  goto out;
1018 
1020  retval = bus_register(&usb_bus_type);
1021  if (retval)
1022  goto bus_register_failed;
1023  retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb);
1024  if (retval)
1025  goto bus_notifier_failed;
1026  retval = usb_major_init();
1027  if (retval)
1028  goto major_init_failed;
1029  retval = usb_register(&usbfs_driver);
1030  if (retval)
1031  goto driver_register_failed;
1032  retval = usb_devio_init();
1033  if (retval)
1034  goto usb_devio_init_failed;
1035  retval = usb_hub_init();
1036  if (retval)
1037  goto hub_init_failed;
1039  if (!retval)
1040  goto out;
1041 
1042  usb_hub_cleanup();
1043 hub_init_failed:
1045 usb_devio_init_failed:
1047 driver_register_failed:
1049 major_init_failed:
1050  bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1051 bus_notifier_failed:
1053 bus_register_failed:
1055  usb_debugfs_cleanup();
1056 out:
1057  return retval;
1058 }
1059 
1060 /*
1061  * Cleanup
1062  */
1063 static void __exit usb_exit(void)
1064 {
1065  /* This will matter if shutdown/reboot does exitcalls. */
1066  if (nousb)
1067  return;
1068 
1073  usb_hub_cleanup();
1074  bus_unregister_notifier(&usb_bus_type, &usb_bus_nb);
1077  usb_debugfs_cleanup();
1078 }
1079 
1080 subsys_initcall(usb_init);
1081 module_exit(usb_exit);
1082 MODULE_LICENSE("GPL");