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 48const char *usbcore_name = "usbcore"; 49 50static int nousb; /* Disable USB when built into kernel image */ 51 52#ifdef CONFIG_USB_SUSPEND 53static int usb_autosuspend_delay = 2; /* Default delay value, 54 * in seconds */ 55module_param_named(autosuspend, usb_autosuspend_delay, int, 0644); 56MODULE_PARM_DESC(autosuspend, "default autosuspend delay"); 57 58#else 59#define usb_autosuspend_delay 0 60#endif 61 62 63/** 64 * usb_find_alt_setting() - Given a configuration, find the alternate setting 65 * for the given interface. 66 * @config: the configuration to search (not necessarily the current config). 67 * @iface_num: interface number to search in 68 * @alt_num: alternate interface setting number to search for. 69 * 70 * Search the configuration's interface cache for the given alt setting. 71 */ 72struct 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} 98EXPORT_SYMBOL_GPL(usb_find_alt_setting); 99 100/** 101 * usb_ifnum_to_if - get the interface object with a given interface number 102 * @dev: the device whose current configuration is considered 103 * @ifnum: the desired interface 104 * 105 * This walks the device descriptor for the currently active configuration 106 * and returns a pointer to the interface with that particular interface 107 * number, or null. 108 * 109 * Note that configuration descriptors are not required to assign interface 110 * numbers sequentially, so that it would be incorrect to assume that 111 * the first interface in that descriptor corresponds to interface zero. 112 * This routine helps device drivers avoid such mistakes. 113 * However, you should make sure that you do the right thing with any 114 * alternate settings available for this interfaces. 115 * 116 * Don't call this function unless you are bound to one of the interfaces 117 * on this device or you have locked the device! 118 */ 119struct 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} 134EXPORT_SYMBOL_GPL(usb_ifnum_to_if); 135 136/** 137 * usb_altnum_to_altsetting - get the altsetting structure with a given alternate setting number. 138 * @intf: the interface containing the altsetting in question 139 * @altnum: the desired alternate setting number 140 * 141 * This searches the altsetting array of the specified interface for 142 * an entry with the correct bAlternateSetting value and returns a pointer 143 * to that entry, or null. 144 * 145 * Note that altsettings need not be stored sequentially by number, so 146 * it would be incorrect to assume that the first altsetting entry in 147 * the array corresponds to altsetting zero. This routine helps device 148 * drivers avoid such mistakes. 149 * 150 * Don't call this function unless you are bound to the intf interface 151 * or you have locked the device! 152 */ 153struct 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} 165EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting); 166 167struct find_interface_arg { 168 int minor; 169 struct device_driver *drv; 170}; 171 172static 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 186/** 187 * usb_find_interface - find usb_interface pointer for driver and device 188 * @drv: the driver whose current configuration is considered 189 * @minor: the minor number of the desired device 190 * 191 * This walks the bus device list and returns a pointer to the interface 192 * with the matching minor and driver. Note, this only works for devices 193 * that share the USB major number. 194 */ 195struct 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} 210EXPORT_SYMBOL_GPL(usb_find_interface); 211 212/** 213 * usb_release_dev - free a usb device structure when all users of it are finished. 214 * @dev: device that's been disconnected 215 * 216 * Will be called only by the device core when all users of this usb device are 217 * done. 218 */ 219static 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 227 usb_destroy_configuration(udev); 228 usb_put_hcd(hcd); 229 kfree(udev->product); 230 kfree(udev->manufacturer); 231 kfree(udev->serial); 232 kfree(udev); 233} 234 235#ifdef CONFIG_HOTPLUG 236static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env) 237{ 238 struct usb_device *usb_dev; 239 240 usb_dev = to_usb_device(dev); 241 242 if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum)) 243 return -ENOMEM; 244 245 if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum)) 246 return -ENOMEM; 247 248 return 0; 249} 250 251#else 252 253static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env) 254{ 255 return -ENODEV; 256} 257#endif /* CONFIG_HOTPLUG */ 258 259#ifdef CONFIG_PM 260 261/* USB device Power-Management thunks. 262 * There's no need to distinguish here between quiescing a USB device 263 * and powering it down; the generic_suspend() routine takes care of 264 * it by skipping the usb_port_suspend() call for a quiesce. And for 265 * USB interfaces there's no difference at all. 266 */ 267 268static int usb_dev_prepare(struct device *dev) 269{ 270 return 0; /* Implement eventually? */ 271} 272 273static void usb_dev_complete(struct device *dev) 274{ 275 /* Currently used only for rebinding interfaces */ 276 usb_resume(dev, PMSG_ON); 277} 278 279static int usb_dev_suspend(struct device *dev) 280{ 281 return usb_suspend(dev, PMSG_SUSPEND); 282} 283 284static int usb_dev_resume(struct device *dev) 285{ 286 return usb_resume(dev, PMSG_RESUME); 287} 288 289static int usb_dev_freeze(struct device *dev) 290{ 291 return usb_suspend(dev, PMSG_FREEZE); 292} 293 294static int usb_dev_thaw(struct device *dev) 295{ 296 return usb_resume(dev, PMSG_THAW); 297} 298 299static int usb_dev_poweroff(struct device *dev) 300{ 301 return usb_suspend(dev, PMSG_HIBERNATE); 302} 303 304static int usb_dev_restore(struct device *dev) 305{ 306 return usb_resume(dev, PMSG_RESTORE); 307} 308 309static const struct dev_pm_ops usb_device_pm_ops = { 310 .prepare = usb_dev_prepare, 311 .complete = usb_dev_complete, 312 .suspend = usb_dev_suspend, 313 .resume = usb_dev_resume, 314 .freeze = usb_dev_freeze, 315 .thaw = usb_dev_thaw, 316 .poweroff = usb_dev_poweroff, 317 .restore = usb_dev_restore, 318}; 319 320#endif /* CONFIG_PM */ 321 322 323static char *usb_devnode(struct device *dev, mode_t *mode) 324{ 325 struct usb_device *usb_dev; 326 327 usb_dev = to_usb_device(dev); 328 return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d", 329 usb_dev->bus->busnum, usb_dev->devnum); 330} 331 332struct device_type usb_device_type = { 333 .name = "usb_device", 334 .release = usb_release_dev, 335 .uevent = usb_dev_uevent, 336 .devnode = usb_devnode, 337#ifdef CONFIG_PM 338 .pm = &usb_device_pm_ops, 339#endif 340}; 341 342 343/* Returns 1 if @usb_bus is WUSB, 0 otherwise */ 344static unsigned usb_bus_is_wusb(struct usb_bus *bus) 345{ 346 struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self); 347 return hcd->wireless; 348} 349 350 351/** 352 * usb_alloc_dev - usb device constructor (usbcore-internal) 353 * @parent: hub to which device is connected; null to allocate a root hub 354 * @bus: bus used to access the device 355 * @port1: one-based index of port; ignored for root hubs 356 * Context: !in_interrupt() 357 * 358 * Only hub drivers (including virtual root hub drivers for host 359 * controllers) should ever call this. 360 * 361 * This call may not be used in a non-sleeping context. 362 */ 363struct usb_device *usb_alloc_dev(struct usb_device *parent, 364 struct usb_bus *bus, unsigned port1) 365{ 366 struct usb_device *dev; 367 struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self); 368 unsigned root_hub = 0; 369 370 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 371 if (!dev) 372 return NULL; 373 374 if (!usb_get_hcd(bus_to_hcd(bus))) { 375 kfree(dev); 376 return NULL; 377 } 378 /* Root hubs aren't true devices, so don't allocate HCD resources */ 379 if (usb_hcd->driver->alloc_dev && parent && 380 !usb_hcd->driver->alloc_dev(usb_hcd, dev)) { 381 usb_put_hcd(bus_to_hcd(bus)); 382 kfree(dev); 383 return NULL; 384 } 385 386 device_initialize(&dev->dev); 387 dev->dev.bus = &usb_bus_type; 388 dev->dev.type = &usb_device_type; 389 dev->dev.groups = usb_device_groups; 390 dev->dev.dma_mask = bus->controller->dma_mask; 391 set_dev_node(&dev->dev, dev_to_node(bus->controller)); 392 dev->state = USB_STATE_ATTACHED; 393 atomic_set(&dev->urbnum, 0); 394 395 INIT_LIST_HEAD(&dev->ep0.urb_list); 396 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 397 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 398 /* ep0 maxpacket comes later, from device descriptor */ 399 usb_enable_endpoint(dev, &dev->ep0, false); 400 dev->can_submit = 1; 401 402 /* Save readable and stable topology id, distinguishing devices 403 * by location for diagnostics, tools, driver model, etc. The 404 * string is a path along hub ports, from the root. Each device's 405 * dev->devpath will be stable until USB is re-cabled, and hubs 406 * are often labeled with these port numbers. The name isn't 407 * as stable: bus->busnum changes easily from modprobe order, 408 * cardbus or pci hotplugging, and so on. 409 */ 410 if (unlikely(!parent)) { 411 dev->devpath[0] = '0'; 412 dev->route = 0; 413 414 dev->dev.parent = bus->controller; 415 dev_set_name(&dev->dev, "usb%d", bus->busnum); 416 root_hub = 1; 417 } else { 418 /* match any labeling on the hubs; it's one-based */ 419 if (parent->devpath[0] == '0') { 420 snprintf(dev->devpath, sizeof dev->devpath, 421 "%d", port1); 422 /* Root ports are not counted in route string */ 423 dev->route = 0; 424 } else { 425 snprintf(dev->devpath, sizeof dev->devpath, 426 "%s.%d", parent->devpath, port1); 427 /* Route string assumes hubs have less than 16 ports */ 428 if (port1 < 15) 429 dev->route = parent->route + 430 (port1 << ((parent->level - 1)*4)); 431 else 432 dev->route = parent->route + 433 (15 << ((parent->level - 1)*4)); 434 } 435 436 dev->dev.parent = &parent->dev; 437 dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); 438 439 /* hub driver sets up TT records */ 440 } 441 442 dev->portnum = port1; 443 dev->bus = bus; 444 dev->parent = parent; 445 INIT_LIST_HEAD(&dev->filelist); 446 447#ifdef CONFIG_PM 448 dev->autosuspend_delay = usb_autosuspend_delay * HZ; 449 dev->connect_time = jiffies; 450 dev->active_duration = -jiffies; 451#endif 452 if (root_hub) /* Root hub always ok [and always wired] */ 453 dev->authorized = 1; 454 else { 455 dev->authorized = usb_hcd->authorized_default; 456 dev->wusb = usb_bus_is_wusb(bus)? 1 : 0; 457 } 458 return dev; 459} 460 461/** 462 * usb_get_dev - increments the reference count of the usb device structure 463 * @dev: the device being referenced 464 * 465 * Each live reference to a device should be refcounted. 466 * 467 * Drivers for USB interfaces should normally record such references in 468 * their probe() methods, when they bind to an interface, and release 469 * them by calling usb_put_dev(), in their disconnect() methods. 470 * 471 * A pointer to the device with the incremented reference counter is returned. 472 */ 473struct usb_device *usb_get_dev(struct usb_device *dev) 474{ 475 if (dev) 476 get_device(&dev->dev); 477 return dev; 478} 479EXPORT_SYMBOL_GPL(usb_get_dev); 480 481/** 482 * usb_put_dev - release a use of the usb device structure 483 * @dev: device that's been disconnected 484 * 485 * Must be called when a user of a device is finished with it. When the last 486 * user of the device calls this function, the memory of the device is freed. 487 */ 488void usb_put_dev(struct usb_device *dev) 489{ 490 if (dev) 491 put_device(&dev->dev); 492} 493EXPORT_SYMBOL_GPL(usb_put_dev); 494 495/** 496 * usb_get_intf - increments the reference count of the usb interface structure 497 * @intf: the interface being referenced 498 * 499 * Each live reference to a interface must be refcounted. 500 * 501 * Drivers for USB interfaces should normally record such references in 502 * their probe() methods, when they bind to an interface, and release 503 * them by calling usb_put_intf(), in their disconnect() methods. 504 * 505 * A pointer to the interface with the incremented reference counter is 506 * returned. 507 */ 508struct usb_interface *usb_get_intf(struct usb_interface *intf) 509{ 510 if (intf) 511 get_device(&intf->dev); 512 return intf; 513} 514EXPORT_SYMBOL_GPL(usb_get_intf); 515 516/** 517 * usb_put_intf - release a use of the usb interface structure 518 * @intf: interface that's been decremented 519 * 520 * Must be called when a user of an interface is finished with it. When the 521 * last user of the interface calls this function, the memory of the interface 522 * is freed. 523 */ 524void usb_put_intf(struct usb_interface *intf) 525{ 526 if (intf) 527 put_device(&intf->dev); 528} 529EXPORT_SYMBOL_GPL(usb_put_intf); 530 531/* USB device locking 532 * 533 * USB devices and interfaces are locked using the semaphore in their 534 * embedded struct device. The hub driver guarantees that whenever a 535 * device is connected or disconnected, drivers are called with the 536 * USB device locked as well as their particular interface. 537 * 538 * Complications arise when several devices are to be locked at the same 539 * time. Only hub-aware drivers that are part of usbcore ever have to 540 * do this; nobody else needs to worry about it. The rule for locking 541 * is simple: 542 * 543 * When locking both a device and its parent, always lock the 544 * the parent first. 545 */ 546 547/** 548 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure 549 * @udev: device that's being locked 550 * @iface: interface bound to the driver making the request (optional) 551 * 552 * Attempts to acquire the device lock, but fails if the device is 553 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface 554 * is neither BINDING nor BOUND. Rather than sleeping to wait for the 555 * lock, the routine polls repeatedly. This is to prevent deadlock with 556 * disconnect; in some drivers (such as usb-storage) the disconnect() 557 * or suspend() method will block waiting for a device reset to complete. 558 * 559 * Returns a negative error code for failure, otherwise 0. 560 */ 561int usb_lock_device_for_reset(struct usb_device *udev, 562 const struct usb_interface *iface) 563{ 564 unsigned long jiffies_expire = jiffies + HZ; 565 566 if (udev->state == USB_STATE_NOTATTACHED) 567 return -ENODEV; 568 if (udev->state == USB_STATE_SUSPENDED) 569 return -EHOSTUNREACH; 570 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 571 iface->condition == USB_INTERFACE_UNBOUND)) 572 return -EINTR; 573 574 while (!usb_trylock_device(udev)) { 575 576 /* If we can't acquire the lock after waiting one second, 577 * we're probably deadlocked */ 578 if (time_after(jiffies, jiffies_expire)) 579 return -EBUSY; 580 581 msleep(15); 582 if (udev->state == USB_STATE_NOTATTACHED) 583 return -ENODEV; 584 if (udev->state == USB_STATE_SUSPENDED) 585 return -EHOSTUNREACH; 586 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 587 iface->condition == USB_INTERFACE_UNBOUND)) 588 return -EINTR; 589 } 590 return 0; 591} 592EXPORT_SYMBOL_GPL(usb_lock_device_for_reset); 593 594/** 595 * usb_get_current_frame_number - return current bus frame number 596 * @dev: the device whose bus is being queried 597 * 598 * Returns the current frame number for the USB host controller 599 * used with the given USB device. This can be used when scheduling 600 * isochronous requests. 601 * 602 * Note that different kinds of host controller have different 603 * "scheduling horizons". While one type might support scheduling only 604 * 32 frames into the future, others could support scheduling up to 605 * 1024 frames into the future. 606 */ 607int usb_get_current_frame_number(struct usb_device *dev) 608{ 609 return usb_hcd_get_frame_number(dev); 610} 611EXPORT_SYMBOL_GPL(usb_get_current_frame_number); 612 613/*-------------------------------------------------------------------*/ 614/* 615 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 616 * extra field of the interface and endpoint descriptor structs. 617 */ 618 619int __usb_get_extra_descriptor(char *buffer, unsigned size, 620 unsigned char type, void **ptr) 621{ 622 struct usb_descriptor_header *header; 623 624 while (size >= sizeof(struct usb_descriptor_header)) { 625 header = (struct usb_descriptor_header *)buffer; 626 627 if (header->bLength < 2) { 628 printk(KERN_ERR 629 "%s: bogus descriptor, type %d length %d\n", 630 usbcore_name, 631 header->bDescriptorType, 632 header->bLength); 633 return -1; 634 } 635 636 if (header->bDescriptorType == type) { 637 *ptr = header; 638 return 0; 639 } 640 641 buffer += header->bLength; 642 size -= header->bLength; 643 } 644 return -1; 645} 646EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); 647 648/** 649 * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 650 * @dev: device the buffer will be used with 651 * @size: requested buffer size 652 * @mem_flags: affect whether allocation may block 653 * @dma: used to return DMA address of buffer 654 * 655 * Return value is either null (indicating no buffer could be allocated), or 656 * the cpu-space pointer to a buffer that may be used to perform DMA to the 657 * specified device. Such cpu-space buffers are returned along with the DMA 658 * address (through the pointer provided). 659 * 660 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags 661 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU 662 * hardware during URB completion/resubmit. The implementation varies between 663 * platforms, depending on details of how DMA will work to this device. 664 * Using these buffers also eliminates cacheline sharing problems on 665 * architectures where CPU caches are not DMA-coherent. On systems without 666 * bus-snooping caches, these buffers are uncached. 667 * 668 * When the buffer is no longer used, free it with usb_free_coherent(). 669 */ 670void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags, 671 dma_addr_t *dma) 672{ 673 if (!dev || !dev->bus) 674 return NULL; 675 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 676} 677EXPORT_SYMBOL_GPL(usb_alloc_coherent); 678 679/** 680 * usb_free_coherent - free memory allocated with usb_alloc_coherent() 681 * @dev: device the buffer was used with 682 * @size: requested buffer size 683 * @addr: CPU address of buffer 684 * @dma: DMA address of buffer 685 * 686 * This reclaims an I/O buffer, letting it be reused. The memory must have 687 * been allocated using usb_alloc_coherent(), and the parameters must match 688 * those provided in that allocation request. 689 */ 690void usb_free_coherent(struct usb_device *dev, size_t size, void *addr, 691 dma_addr_t dma) 692{ 693 if (!dev || !dev->bus) 694 return; 695 if (!addr) 696 return; 697 hcd_buffer_free(dev->bus, size, addr, dma); 698} 699EXPORT_SYMBOL_GPL(usb_free_coherent); 700 701/** 702 * usb_buffer_map - create DMA mapping(s) for an urb 703 * @urb: urb whose transfer_buffer/setup_packet will be mapped 704 * 705 * Return value is either null (indicating no buffer could be mapped), or 706 * the parameter. URB_NO_TRANSFER_DMA_MAP is 707 * added to urb->transfer_flags if the operation succeeds. If the device 708 * is connected to this system through a non-DMA controller, this operation 709 * always succeeds. 710 * 711 * This call would normally be used for an urb which is reused, perhaps 712 * as the target of a large periodic transfer, with usb_buffer_dmasync() 713 * calls to synchronize memory and dma state. 714 * 715 * Reverse the effect of this call with usb_buffer_unmap(). 716 */ 717 718 719/** 720 * usb_buffer_unmap - free DMA mapping(s) for an urb 721 * @urb: urb whose transfer_buffer will be unmapped 722 * 723 * Reverses the effect of usb_buffer_map(). 724 */ 725 726 727 728 729/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */ 730#ifdef MODULE 731module_param(nousb, bool, 0444); 732#else 733core_param(nousb, nousb, bool, 0444); 734#endif 735 736/* 737 * for external read access to <nousb> 738 */ 739int usb_disabled(void) 740{ 741 return nousb; 742} 743EXPORT_SYMBOL_GPL(usb_disabled); 744 745/* 746 * Notifications of device and interface registration 747 */ 748static int usb_bus_notify(struct notifier_block *nb, unsigned long action, 749 void *data) 750{ 751 struct device *dev = data; 752 753 switch (action) { 754 case BUS_NOTIFY_ADD_DEVICE: 755 if (dev->type == &usb_device_type) 756 (void) usb_create_sysfs_dev_files(to_usb_device(dev)); 757 else if (dev->type == &usb_if_device_type) 758 (void) usb_create_sysfs_intf_files( 759 to_usb_interface(dev)); 760 break; 761 762 case BUS_NOTIFY_DEL_DEVICE: 763 if (dev->type == &usb_device_type) 764 usb_remove_sysfs_dev_files(to_usb_device(dev)); 765 else if (dev->type == &usb_if_device_type) 766 usb_remove_sysfs_intf_files(to_usb_interface(dev)); 767 break; 768 } 769 return 0; 770} 771 772static struct notifier_block usb_bus_nb = { 773 .notifier_call = usb_bus_notify, 774}; 775 776struct dentry *usb_debug_root; 777EXPORT_SYMBOL_GPL(usb_debug_root); 778 779static struct dentry *usb_debug_devices; 780 781static int usb_debugfs_init(void) 782{ 783 usb_debug_root = debugfs_create_dir("usb", NULL); 784 if (!usb_debug_root) 785 return -ENOENT; 786 787 usb_debug_devices = debugfs_create_file("devices", 0444, 788 usb_debug_root, NULL, 789 &usbfs_devices_fops); 790 if (!usb_debug_devices) { 791 debugfs_remove(usb_debug_root); 792 usb_debug_root = NULL; 793 return -ENOENT; 794 } 795 796 return 0; 797} 798 799static void usb_debugfs_cleanup(void) 800{ 801 debugfs_remove(usb_debug_devices); 802 debugfs_remove(usb_debug_root); 803} 804 805/* 806 * Init 807 */ 808static int __init usb_init(void) 809{ 810 int retval; 811 if (nousb) { 812 pr_info("%s: USB support disabled\n", usbcore_name); 813 return 0; 814 } 815 816 retval = usb_debugfs_init(); 817 if (retval) 818 goto out; 819 820 retval = bus_register(&usb_bus_type); 821 if (retval) 822 goto bus_register_failed; 823 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); 824 if (retval) 825 goto bus_notifier_failed; 826 retval = usb_major_init(); 827 if (retval) 828 goto major_init_failed; 829 retval = usb_register(&usbfs_driver); 830 if (retval) 831 goto driver_register_failed; 832 retval = usb_devio_init(); 833 if (retval) 834 goto usb_devio_init_failed; 835 retval = usbfs_init(); 836 if (retval) 837 goto fs_init_failed; 838 retval = usb_hub_init(); 839 if (retval) 840 goto hub_init_failed; 841 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); 842 if (!retval) 843 goto out; 844 845 usb_hub_cleanup(); 846hub_init_failed: 847 usbfs_cleanup(); 848fs_init_failed: 849 usb_devio_cleanup(); 850usb_devio_init_failed: 851 usb_deregister(&usbfs_driver); 852driver_register_failed: 853 usb_major_cleanup(); 854major_init_failed: 855 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 856bus_notifier_failed: 857 bus_unregister(&usb_bus_type); 858bus_register_failed: 859 usb_debugfs_cleanup(); 860out: 861 return retval; 862} 863 864/* 865 * Cleanup 866 */ 867static void __exit usb_exit(void) 868{ 869 /* This will matter if shutdown/reboot does exitcalls. */ 870 if (nousb) 871 return; 872 873 usb_deregister_device_driver(&usb_generic_driver); 874 usb_major_cleanup(); 875 usbfs_cleanup(); 876 usb_deregister(&usbfs_driver); 877 usb_devio_cleanup(); 878 usb_hub_cleanup(); 879 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 880 bus_unregister(&usb_bus_type); 881 usb_debugfs_cleanup(); 882} 883 884subsys_initcall(usb_init); 885module_exit(usb_exit); 886MODULE_LICENSE("GPL"); 887