usb.c revision 0ede76fcec5415ef82a423a95120286895822e2d
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); /* FIXME: change to PMSG_COMPLETE */ 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#else 321 322#define usb_device_pm_ops (*(struct dev_pm_ops *) NULL) 323 324#endif /* CONFIG_PM */ 325 326 327static char *usb_devnode(struct device *dev, mode_t *mode) 328{ 329 struct usb_device *usb_dev; 330 331 usb_dev = to_usb_device(dev); 332 return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d", 333 usb_dev->bus->busnum, usb_dev->devnum); 334} 335 336struct device_type usb_device_type = { 337 .name = "usb_device", 338 .release = usb_release_dev, 339 .uevent = usb_dev_uevent, 340 .devnode = usb_devnode, 341 .pm = &usb_device_pm_ops, 342}; 343 344 345/* Returns 1 if @usb_bus is WUSB, 0 otherwise */ 346static unsigned usb_bus_is_wusb(struct usb_bus *bus) 347{ 348 struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self); 349 return hcd->wireless; 350} 351 352 353/** 354 * usb_alloc_dev - usb device constructor (usbcore-internal) 355 * @parent: hub to which device is connected; null to allocate a root hub 356 * @bus: bus used to access the device 357 * @port1: one-based index of port; ignored for root hubs 358 * Context: !in_interrupt() 359 * 360 * Only hub drivers (including virtual root hub drivers for host 361 * controllers) should ever call this. 362 * 363 * This call may not be used in a non-sleeping context. 364 */ 365struct usb_device *usb_alloc_dev(struct usb_device *parent, 366 struct usb_bus *bus, unsigned port1) 367{ 368 struct usb_device *dev; 369 struct usb_hcd *usb_hcd = container_of(bus, struct usb_hcd, self); 370 unsigned root_hub = 0; 371 372 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 373 if (!dev) 374 return NULL; 375 376 if (!usb_get_hcd(bus_to_hcd(bus))) { 377 kfree(dev); 378 return NULL; 379 } 380 /* Root hubs aren't true devices, so don't allocate HCD resources */ 381 if (usb_hcd->driver->alloc_dev && parent && 382 !usb_hcd->driver->alloc_dev(usb_hcd, dev)) { 383 usb_put_hcd(bus_to_hcd(bus)); 384 kfree(dev); 385 return NULL; 386 } 387 388 device_initialize(&dev->dev); 389 dev->dev.bus = &usb_bus_type; 390 dev->dev.type = &usb_device_type; 391 dev->dev.groups = usb_device_groups; 392 dev->dev.dma_mask = bus->controller->dma_mask; 393 set_dev_node(&dev->dev, dev_to_node(bus->controller)); 394 dev->state = USB_STATE_ATTACHED; 395 atomic_set(&dev->urbnum, 0); 396 397 INIT_LIST_HEAD(&dev->ep0.urb_list); 398 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 399 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 400 /* ep0 maxpacket comes later, from device descriptor */ 401 usb_enable_endpoint(dev, &dev->ep0, false); 402 dev->can_submit = 1; 403 404 /* Save readable and stable topology id, distinguishing devices 405 * by location for diagnostics, tools, driver model, etc. The 406 * string is a path along hub ports, from the root. Each device's 407 * dev->devpath will be stable until USB is re-cabled, and hubs 408 * are often labeled with these port numbers. The name isn't 409 * as stable: bus->busnum changes easily from modprobe order, 410 * cardbus or pci hotplugging, and so on. 411 */ 412 if (unlikely(!parent)) { 413 dev->devpath[0] = '0'; 414 dev->route = 0; 415 416 dev->dev.parent = bus->controller; 417 dev_set_name(&dev->dev, "usb%d", bus->busnum); 418 root_hub = 1; 419 } else { 420 /* match any labeling on the hubs; it's one-based */ 421 if (parent->devpath[0] == '0') { 422 snprintf(dev->devpath, sizeof dev->devpath, 423 "%d", port1); 424 /* Root ports are not counted in route string */ 425 dev->route = 0; 426 } else { 427 snprintf(dev->devpath, sizeof dev->devpath, 428 "%s.%d", parent->devpath, port1); 429 /* Route string assumes hubs have less than 16 ports */ 430 if (port1 < 15) 431 dev->route = parent->route + 432 (port1 << ((parent->level - 1)*4)); 433 else 434 dev->route = parent->route + 435 (15 << ((parent->level - 1)*4)); 436 } 437 438 dev->dev.parent = &parent->dev; 439 dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); 440 441 /* hub driver sets up TT records */ 442 } 443 444 dev->portnum = port1; 445 dev->bus = bus; 446 dev->parent = parent; 447 INIT_LIST_HEAD(&dev->filelist); 448 449#ifdef CONFIG_PM 450 dev->autosuspend_delay = usb_autosuspend_delay * HZ; 451 dev->connect_time = jiffies; 452 dev->active_duration = -jiffies; 453#endif 454 if (root_hub) /* Root hub always ok [and always wired] */ 455 dev->authorized = 1; 456 else { 457 dev->authorized = usb_hcd->authorized_default; 458 dev->wusb = usb_bus_is_wusb(bus)? 1 : 0; 459 } 460 return dev; 461} 462 463/** 464 * usb_get_dev - increments the reference count of the usb device structure 465 * @dev: the device being referenced 466 * 467 * Each live reference to a device should be refcounted. 468 * 469 * Drivers for USB interfaces should normally record such references in 470 * their probe() methods, when they bind to an interface, and release 471 * them by calling usb_put_dev(), in their disconnect() methods. 472 * 473 * A pointer to the device with the incremented reference counter is returned. 474 */ 475struct usb_device *usb_get_dev(struct usb_device *dev) 476{ 477 if (dev) 478 get_device(&dev->dev); 479 return dev; 480} 481EXPORT_SYMBOL_GPL(usb_get_dev); 482 483/** 484 * usb_put_dev - release a use of the usb device structure 485 * @dev: device that's been disconnected 486 * 487 * Must be called when a user of a device is finished with it. When the last 488 * user of the device calls this function, the memory of the device is freed. 489 */ 490void usb_put_dev(struct usb_device *dev) 491{ 492 if (dev) 493 put_device(&dev->dev); 494} 495EXPORT_SYMBOL_GPL(usb_put_dev); 496 497/** 498 * usb_get_intf - increments the reference count of the usb interface structure 499 * @intf: the interface being referenced 500 * 501 * Each live reference to a interface must be refcounted. 502 * 503 * Drivers for USB interfaces should normally record such references in 504 * their probe() methods, when they bind to an interface, and release 505 * them by calling usb_put_intf(), in their disconnect() methods. 506 * 507 * A pointer to the interface with the incremented reference counter is 508 * returned. 509 */ 510struct usb_interface *usb_get_intf(struct usb_interface *intf) 511{ 512 if (intf) 513 get_device(&intf->dev); 514 return intf; 515} 516EXPORT_SYMBOL_GPL(usb_get_intf); 517 518/** 519 * usb_put_intf - release a use of the usb interface structure 520 * @intf: interface that's been decremented 521 * 522 * Must be called when a user of an interface is finished with it. When the 523 * last user of the interface calls this function, the memory of the interface 524 * is freed. 525 */ 526void usb_put_intf(struct usb_interface *intf) 527{ 528 if (intf) 529 put_device(&intf->dev); 530} 531EXPORT_SYMBOL_GPL(usb_put_intf); 532 533/* USB device locking 534 * 535 * USB devices and interfaces are locked using the semaphore in their 536 * embedded struct device. The hub driver guarantees that whenever a 537 * device is connected or disconnected, drivers are called with the 538 * USB device locked as well as their particular interface. 539 * 540 * Complications arise when several devices are to be locked at the same 541 * time. Only hub-aware drivers that are part of usbcore ever have to 542 * do this; nobody else needs to worry about it. The rule for locking 543 * is simple: 544 * 545 * When locking both a device and its parent, always lock the 546 * the parent first. 547 */ 548 549/** 550 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure 551 * @udev: device that's being locked 552 * @iface: interface bound to the driver making the request (optional) 553 * 554 * Attempts to acquire the device lock, but fails if the device is 555 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface 556 * is neither BINDING nor BOUND. Rather than sleeping to wait for the 557 * lock, the routine polls repeatedly. This is to prevent deadlock with 558 * disconnect; in some drivers (such as usb-storage) the disconnect() 559 * or suspend() method will block waiting for a device reset to complete. 560 * 561 * Returns a negative error code for failure, otherwise 0. 562 */ 563int usb_lock_device_for_reset(struct usb_device *udev, 564 const struct usb_interface *iface) 565{ 566 unsigned long jiffies_expire = jiffies + HZ; 567 568 if (udev->state == USB_STATE_NOTATTACHED) 569 return -ENODEV; 570 if (udev->state == USB_STATE_SUSPENDED) 571 return -EHOSTUNREACH; 572 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 573 iface->condition == USB_INTERFACE_UNBOUND)) 574 return -EINTR; 575 576 while (usb_trylock_device(udev) != 0) { 577 578 /* If we can't acquire the lock after waiting one second, 579 * we're probably deadlocked */ 580 if (time_after(jiffies, jiffies_expire)) 581 return -EBUSY; 582 583 msleep(15); 584 if (udev->state == USB_STATE_NOTATTACHED) 585 return -ENODEV; 586 if (udev->state == USB_STATE_SUSPENDED) 587 return -EHOSTUNREACH; 588 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 589 iface->condition == USB_INTERFACE_UNBOUND)) 590 return -EINTR; 591 } 592 return 0; 593} 594EXPORT_SYMBOL_GPL(usb_lock_device_for_reset); 595 596static struct usb_device *match_device(struct usb_device *dev, 597 u16 vendor_id, u16 product_id) 598{ 599 struct usb_device *ret_dev = NULL; 600 int child; 601 602 dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", 603 le16_to_cpu(dev->descriptor.idVendor), 604 le16_to_cpu(dev->descriptor.idProduct)); 605 606 /* see if this device matches */ 607 if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) && 608 (product_id == le16_to_cpu(dev->descriptor.idProduct))) { 609 dev_dbg(&dev->dev, "matched this device!\n"); 610 ret_dev = usb_get_dev(dev); 611 goto exit; 612 } 613 614 /* look through all of the children of this device */ 615 for (child = 0; child < dev->maxchild; ++child) { 616 if (dev->children[child]) { 617 usb_lock_device(dev->children[child]); 618 ret_dev = match_device(dev->children[child], 619 vendor_id, product_id); 620 usb_unlock_device(dev->children[child]); 621 if (ret_dev) 622 goto exit; 623 } 624 } 625exit: 626 return ret_dev; 627} 628 629/** 630 * usb_find_device - find a specific usb device in the system 631 * @vendor_id: the vendor id of the device to find 632 * @product_id: the product id of the device to find 633 * 634 * Returns a pointer to a struct usb_device if such a specified usb 635 * device is present in the system currently. The usage count of the 636 * device will be incremented if a device is found. Make sure to call 637 * usb_put_dev() when the caller is finished with the device. 638 * 639 * If a device with the specified vendor and product id is not found, 640 * NULL is returned. 641 */ 642struct usb_device *usb_find_device(u16 vendor_id, u16 product_id) 643{ 644 struct list_head *buslist; 645 struct usb_bus *bus; 646 struct usb_device *dev = NULL; 647 648 mutex_lock(&usb_bus_list_lock); 649 for (buslist = usb_bus_list.next; 650 buslist != &usb_bus_list; 651 buslist = buslist->next) { 652 bus = container_of(buslist, struct usb_bus, bus_list); 653 if (!bus->root_hub) 654 continue; 655 usb_lock_device(bus->root_hub); 656 dev = match_device(bus->root_hub, vendor_id, product_id); 657 usb_unlock_device(bus->root_hub); 658 if (dev) 659 goto exit; 660 } 661exit: 662 mutex_unlock(&usb_bus_list_lock); 663 return dev; 664} 665 666/** 667 * usb_get_current_frame_number - return current bus frame number 668 * @dev: the device whose bus is being queried 669 * 670 * Returns the current frame number for the USB host controller 671 * used with the given USB device. This can be used when scheduling 672 * isochronous requests. 673 * 674 * Note that different kinds of host controller have different 675 * "scheduling horizons". While one type might support scheduling only 676 * 32 frames into the future, others could support scheduling up to 677 * 1024 frames into the future. 678 */ 679int usb_get_current_frame_number(struct usb_device *dev) 680{ 681 return usb_hcd_get_frame_number(dev); 682} 683EXPORT_SYMBOL_GPL(usb_get_current_frame_number); 684 685/*-------------------------------------------------------------------*/ 686/* 687 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 688 * extra field of the interface and endpoint descriptor structs. 689 */ 690 691int __usb_get_extra_descriptor(char *buffer, unsigned size, 692 unsigned char type, void **ptr) 693{ 694 struct usb_descriptor_header *header; 695 696 while (size >= sizeof(struct usb_descriptor_header)) { 697 header = (struct usb_descriptor_header *)buffer; 698 699 if (header->bLength < 2) { 700 printk(KERN_ERR 701 "%s: bogus descriptor, type %d length %d\n", 702 usbcore_name, 703 header->bDescriptorType, 704 header->bLength); 705 return -1; 706 } 707 708 if (header->bDescriptorType == type) { 709 *ptr = header; 710 return 0; 711 } 712 713 buffer += header->bLength; 714 size -= header->bLength; 715 } 716 return -1; 717} 718EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); 719 720/** 721 * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 722 * @dev: device the buffer will be used with 723 * @size: requested buffer size 724 * @mem_flags: affect whether allocation may block 725 * @dma: used to return DMA address of buffer 726 * 727 * Return value is either null (indicating no buffer could be allocated), or 728 * the cpu-space pointer to a buffer that may be used to perform DMA to the 729 * specified device. Such cpu-space buffers are returned along with the DMA 730 * address (through the pointer provided). 731 * 732 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags 733 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU 734 * hardware during URB completion/resubmit. The implementation varies between 735 * platforms, depending on details of how DMA will work to this device. 736 * Using these buffers also eliminates cacheline sharing problems on 737 * architectures where CPU caches are not DMA-coherent. On systems without 738 * bus-snooping caches, these buffers are uncached. 739 * 740 * When the buffer is no longer used, free it with usb_free_coherent(). 741 */ 742void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags, 743 dma_addr_t *dma) 744{ 745 if (!dev || !dev->bus) 746 return NULL; 747 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 748} 749EXPORT_SYMBOL_GPL(usb_alloc_coherent); 750 751/** 752 * usb_free_coherent - free memory allocated with usb_alloc_coherent() 753 * @dev: device the buffer was used with 754 * @size: requested buffer size 755 * @addr: CPU address of buffer 756 * @dma: DMA address of buffer 757 * 758 * This reclaims an I/O buffer, letting it be reused. The memory must have 759 * been allocated using usb_alloc_coherent(), and the parameters must match 760 * those provided in that allocation request. 761 */ 762void usb_free_coherent(struct usb_device *dev, size_t size, void *addr, 763 dma_addr_t dma) 764{ 765 if (!dev || !dev->bus) 766 return; 767 if (!addr) 768 return; 769 hcd_buffer_free(dev->bus, size, addr, dma); 770} 771EXPORT_SYMBOL_GPL(usb_free_coherent); 772 773/** 774 * usb_buffer_map - create DMA mapping(s) for an urb 775 * @urb: urb whose transfer_buffer/setup_packet will be mapped 776 * 777 * Return value is either null (indicating no buffer could be mapped), or 778 * the parameter. URB_NO_TRANSFER_DMA_MAP is 779 * added to urb->transfer_flags if the operation succeeds. If the device 780 * is connected to this system through a non-DMA controller, this operation 781 * always succeeds. 782 * 783 * This call would normally be used for an urb which is reused, perhaps 784 * as the target of a large periodic transfer, with usb_buffer_dmasync() 785 * calls to synchronize memory and dma state. 786 * 787 * Reverse the effect of this call with usb_buffer_unmap(). 788 */ 789#if 0 790struct urb *usb_buffer_map(struct urb *urb) 791{ 792 struct usb_bus *bus; 793 struct device *controller; 794 795 if (!urb 796 || !urb->dev 797 || !(bus = urb->dev->bus) 798 || !(controller = bus->controller)) 799 return NULL; 800 801 if (controller->dma_mask) { 802 urb->transfer_dma = dma_map_single(controller, 803 urb->transfer_buffer, urb->transfer_buffer_length, 804 usb_pipein(urb->pipe) 805 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 806 /* FIXME generic api broken like pci, can't report errors */ 807 /* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */ 808 } else 809 urb->transfer_dma = ~0; 810 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 811 return urb; 812} 813EXPORT_SYMBOL_GPL(usb_buffer_map); 814#endif /* 0 */ 815 816/* XXX DISABLED, no users currently. If you wish to re-enable this 817 * XXX please determine whether the sync is to transfer ownership of 818 * XXX the buffer from device to cpu or vice verse, and thusly use the 819 * XXX appropriate _for_{cpu,device}() method. -DaveM 820 */ 821#if 0 822 823/** 824 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s) 825 * @urb: urb whose transfer_buffer/setup_packet will be synchronized 826 */ 827void usb_buffer_dmasync(struct urb *urb) 828{ 829 struct usb_bus *bus; 830 struct device *controller; 831 832 if (!urb 833 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 834 || !urb->dev 835 || !(bus = urb->dev->bus) 836 || !(controller = bus->controller)) 837 return; 838 839 if (controller->dma_mask) { 840 dma_sync_single_for_cpu(controller, 841 urb->transfer_dma, urb->transfer_buffer_length, 842 usb_pipein(urb->pipe) 843 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 844 if (usb_pipecontrol(urb->pipe)) 845 dma_sync_single_for_cpu(controller, 846 urb->setup_dma, 847 sizeof(struct usb_ctrlrequest), 848 DMA_TO_DEVICE); 849 } 850} 851EXPORT_SYMBOL_GPL(usb_buffer_dmasync); 852#endif 853 854/** 855 * usb_buffer_unmap - free DMA mapping(s) for an urb 856 * @urb: urb whose transfer_buffer will be unmapped 857 * 858 * Reverses the effect of usb_buffer_map(). 859 */ 860#if 0 861void usb_buffer_unmap(struct urb *urb) 862{ 863 struct usb_bus *bus; 864 struct device *controller; 865 866 if (!urb 867 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 868 || !urb->dev 869 || !(bus = urb->dev->bus) 870 || !(controller = bus->controller)) 871 return; 872 873 if (controller->dma_mask) { 874 dma_unmap_single(controller, 875 urb->transfer_dma, urb->transfer_buffer_length, 876 usb_pipein(urb->pipe) 877 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 878 } 879 urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP; 880} 881EXPORT_SYMBOL_GPL(usb_buffer_unmap); 882#endif /* 0 */ 883 884/** 885 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 886 * @dev: device to which the scatterlist will be mapped 887 * @is_in: mapping transfer direction 888 * @sg: the scatterlist to map 889 * @nents: the number of entries in the scatterlist 890 * 891 * Return value is either < 0 (indicating no buffers could be mapped), or 892 * the number of DMA mapping array entries in the scatterlist. 893 * 894 * The caller is responsible for placing the resulting DMA addresses from 895 * the scatterlist into URB transfer buffer pointers, and for setting the 896 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs. 897 * 898 * Top I/O rates come from queuing URBs, instead of waiting for each one 899 * to complete before starting the next I/O. This is particularly easy 900 * to do with scatterlists. Just allocate and submit one URB for each DMA 901 * mapping entry returned, stopping on the first error or when all succeed. 902 * Better yet, use the usb_sg_*() calls, which do that (and more) for you. 903 * 904 * This call would normally be used when translating scatterlist requests, 905 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it 906 * may be able to coalesce mappings for improved I/O efficiency. 907 * 908 * Reverse the effect of this call with usb_buffer_unmap_sg(). 909 */ 910int usb_buffer_map_sg(const struct usb_device *dev, int is_in, 911 struct scatterlist *sg, int nents) 912{ 913 struct usb_bus *bus; 914 struct device *controller; 915 916 if (!dev 917 || !(bus = dev->bus) 918 || !(controller = bus->controller) 919 || !controller->dma_mask) 920 return -EINVAL; 921 922 /* FIXME generic api broken like pci, can't report errors */ 923 return dma_map_sg(controller, sg, nents, 924 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM; 925} 926EXPORT_SYMBOL_GPL(usb_buffer_map_sg); 927 928/* XXX DISABLED, no users currently. If you wish to re-enable this 929 * XXX please determine whether the sync is to transfer ownership of 930 * XXX the buffer from device to cpu or vice verse, and thusly use the 931 * XXX appropriate _for_{cpu,device}() method. -DaveM 932 */ 933#if 0 934 935/** 936 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s) 937 * @dev: device to which the scatterlist will be mapped 938 * @is_in: mapping transfer direction 939 * @sg: the scatterlist to synchronize 940 * @n_hw_ents: the positive return value from usb_buffer_map_sg 941 * 942 * Use this when you are re-using a scatterlist's data buffers for 943 * another USB request. 944 */ 945void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in, 946 struct scatterlist *sg, int n_hw_ents) 947{ 948 struct usb_bus *bus; 949 struct device *controller; 950 951 if (!dev 952 || !(bus = dev->bus) 953 || !(controller = bus->controller) 954 || !controller->dma_mask) 955 return; 956 957 dma_sync_sg_for_cpu(controller, sg, n_hw_ents, 958 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 959} 960EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg); 961#endif 962 963/** 964 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 965 * @dev: device to which the scatterlist will be mapped 966 * @is_in: mapping transfer direction 967 * @sg: the scatterlist to unmap 968 * @n_hw_ents: the positive return value from usb_buffer_map_sg 969 * 970 * Reverses the effect of usb_buffer_map_sg(). 971 */ 972void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in, 973 struct scatterlist *sg, int n_hw_ents) 974{ 975 struct usb_bus *bus; 976 struct device *controller; 977 978 if (!dev 979 || !(bus = dev->bus) 980 || !(controller = bus->controller) 981 || !controller->dma_mask) 982 return; 983 984 dma_unmap_sg(controller, sg, n_hw_ents, 985 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 986} 987EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg); 988 989/* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */ 990#ifdef MODULE 991module_param(nousb, bool, 0444); 992#else 993core_param(nousb, nousb, bool, 0444); 994#endif 995 996/* 997 * for external read access to <nousb> 998 */ 999int usb_disabled(void) 1000{ 1001 return nousb; 1002} 1003EXPORT_SYMBOL_GPL(usb_disabled); 1004 1005/* 1006 * Notifications of device and interface registration 1007 */ 1008static int usb_bus_notify(struct notifier_block *nb, unsigned long action, 1009 void *data) 1010{ 1011 struct device *dev = data; 1012 1013 switch (action) { 1014 case BUS_NOTIFY_ADD_DEVICE: 1015 if (dev->type == &usb_device_type) 1016 (void) usb_create_sysfs_dev_files(to_usb_device(dev)); 1017 else if (dev->type == &usb_if_device_type) 1018 (void) usb_create_sysfs_intf_files( 1019 to_usb_interface(dev)); 1020 break; 1021 1022 case BUS_NOTIFY_DEL_DEVICE: 1023 if (dev->type == &usb_device_type) 1024 usb_remove_sysfs_dev_files(to_usb_device(dev)); 1025 else if (dev->type == &usb_if_device_type) 1026 usb_remove_sysfs_intf_files(to_usb_interface(dev)); 1027 break; 1028 } 1029 return 0; 1030} 1031 1032static struct notifier_block usb_bus_nb = { 1033 .notifier_call = usb_bus_notify, 1034}; 1035 1036struct dentry *usb_debug_root; 1037EXPORT_SYMBOL_GPL(usb_debug_root); 1038 1039static struct dentry *usb_debug_devices; 1040 1041static int usb_debugfs_init(void) 1042{ 1043 usb_debug_root = debugfs_create_dir("usb", NULL); 1044 if (!usb_debug_root) 1045 return -ENOENT; 1046 1047 usb_debug_devices = debugfs_create_file("devices", 0444, 1048 usb_debug_root, NULL, 1049 &usbfs_devices_fops); 1050 if (!usb_debug_devices) { 1051 debugfs_remove(usb_debug_root); 1052 usb_debug_root = NULL; 1053 return -ENOENT; 1054 } 1055 1056 return 0; 1057} 1058 1059static void usb_debugfs_cleanup(void) 1060{ 1061 debugfs_remove(usb_debug_devices); 1062 debugfs_remove(usb_debug_root); 1063} 1064 1065/* 1066 * Init 1067 */ 1068static int __init usb_init(void) 1069{ 1070 int retval; 1071 if (nousb) { 1072 pr_info("%s: USB support disabled\n", usbcore_name); 1073 return 0; 1074 } 1075 1076 retval = usb_debugfs_init(); 1077 if (retval) 1078 goto out; 1079 1080 retval = bus_register(&usb_bus_type); 1081 if (retval) 1082 goto bus_register_failed; 1083 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); 1084 if (retval) 1085 goto bus_notifier_failed; 1086 retval = usb_major_init(); 1087 if (retval) 1088 goto major_init_failed; 1089 retval = usb_register(&usbfs_driver); 1090 if (retval) 1091 goto driver_register_failed; 1092 retval = usb_devio_init(); 1093 if (retval) 1094 goto usb_devio_init_failed; 1095 retval = usbfs_init(); 1096 if (retval) 1097 goto fs_init_failed; 1098 retval = usb_hub_init(); 1099 if (retval) 1100 goto hub_init_failed; 1101 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); 1102 if (!retval) 1103 goto out; 1104 1105 usb_hub_cleanup(); 1106hub_init_failed: 1107 usbfs_cleanup(); 1108fs_init_failed: 1109 usb_devio_cleanup(); 1110usb_devio_init_failed: 1111 usb_deregister(&usbfs_driver); 1112driver_register_failed: 1113 usb_major_cleanup(); 1114major_init_failed: 1115 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 1116bus_notifier_failed: 1117 bus_unregister(&usb_bus_type); 1118bus_register_failed: 1119 usb_debugfs_cleanup(); 1120out: 1121 return retval; 1122} 1123 1124/* 1125 * Cleanup 1126 */ 1127static void __exit usb_exit(void) 1128{ 1129 /* This will matter if shutdown/reboot does exitcalls. */ 1130 if (nousb) 1131 return; 1132 1133 usb_deregister_device_driver(&usb_generic_driver); 1134 usb_major_cleanup(); 1135 usbfs_cleanup(); 1136 usb_deregister(&usbfs_driver); 1137 usb_devio_cleanup(); 1138 usb_hub_cleanup(); 1139 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 1140 bus_unregister(&usb_bus_type); 1141 usb_debugfs_cleanup(); 1142} 1143 1144subsys_initcall(usb_init); 1145module_exit(usb_exit); 1146MODULE_LICENSE("GPL"); 1147