usb.c revision eaafbc3a8adab16babe2c20e54ad3ba40d1fbbc9
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/smp_lock.h> 35#include <linux/usb.h> 36#include <linux/mutex.h> 37#include <linux/workqueue.h> 38 39#include <asm/io.h> 40#include <asm/scatterlist.h> 41#include <linux/mm.h> 42#include <linux/dma-mapping.h> 43 44#include "hcd.h" 45#include "usb.h" 46 47 48const char *usbcore_name = "usbcore"; 49 50static int nousb; /* Disable USB when built into kernel image */ 51 52/* Workqueue for autosuspend and for remote wakeup of root hubs */ 53struct workqueue_struct *ksuspend_usb_wq; 54 55#ifdef CONFIG_USB_SUSPEND 56static int usb_autosuspend_delay = 2; /* Default delay value, 57 * in seconds */ 58module_param_named(autosuspend, usb_autosuspend_delay, int, 0644); 59MODULE_PARM_DESC(autosuspend, "default autosuspend delay"); 60 61#else 62#define usb_autosuspend_delay 0 63#endif 64 65 66/** 67 * usb_ifnum_to_if - get the interface object with a given interface number 68 * @dev: the device whose current configuration is considered 69 * @ifnum: the desired interface 70 * 71 * This walks the device descriptor for the currently active configuration 72 * and returns a pointer to the interface with that particular interface 73 * number, or null. 74 * 75 * Note that configuration descriptors are not required to assign interface 76 * numbers sequentially, so that it would be incorrect to assume that 77 * the first interface in that descriptor corresponds to interface zero. 78 * This routine helps device drivers avoid such mistakes. 79 * However, you should make sure that you do the right thing with any 80 * alternate settings available for this interfaces. 81 * 82 * Don't call this function unless you are bound to one of the interfaces 83 * on this device or you have locked the device! 84 */ 85struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev, 86 unsigned ifnum) 87{ 88 struct usb_host_config *config = dev->actconfig; 89 int i; 90 91 if (!config) 92 return NULL; 93 for (i = 0; i < config->desc.bNumInterfaces; i++) 94 if (config->interface[i]->altsetting[0] 95 .desc.bInterfaceNumber == ifnum) 96 return config->interface[i]; 97 98 return NULL; 99} 100 101/** 102 * usb_altnum_to_altsetting - get the altsetting structure with a given 103 * alternate setting number. 104 * @intf: the interface containing the altsetting in question 105 * @altnum: the desired alternate setting number 106 * 107 * This searches the altsetting array of the specified interface for 108 * an entry with the correct bAlternateSetting value and returns a pointer 109 * to that entry, or null. 110 * 111 * Note that altsettings need not be stored sequentially by number, so 112 * it would be incorrect to assume that the first altsetting entry in 113 * the array corresponds to altsetting zero. This routine helps device 114 * drivers avoid such mistakes. 115 * 116 * Don't call this function unless you are bound to the intf interface 117 * or you have locked the device! 118 */ 119struct usb_host_interface *usb_altnum_to_altsetting(const struct usb_interface *intf, 120 unsigned int altnum) 121{ 122 int i; 123 124 for (i = 0; i < intf->num_altsetting; i++) { 125 if (intf->altsetting[i].desc.bAlternateSetting == altnum) 126 return &intf->altsetting[i]; 127 } 128 return NULL; 129} 130 131struct find_interface_arg { 132 int minor; 133 struct usb_interface *interface; 134}; 135 136static int __find_interface(struct device * dev, void * data) 137{ 138 struct find_interface_arg *arg = data; 139 struct usb_interface *intf; 140 141 /* can't look at usb devices, only interfaces */ 142 if (is_usb_device(dev)) 143 return 0; 144 145 intf = to_usb_interface(dev); 146 if (intf->minor != -1 && intf->minor == arg->minor) { 147 arg->interface = intf; 148 return 1; 149 } 150 return 0; 151} 152 153/** 154 * usb_find_interface - find usb_interface pointer for driver and device 155 * @drv: the driver whose current configuration is considered 156 * @minor: the minor number of the desired device 157 * 158 * This walks the driver device list and returns a pointer to the interface 159 * with the matching minor. Note, this only works for devices that share the 160 * USB major number. 161 */ 162struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor) 163{ 164 struct find_interface_arg argb; 165 int retval; 166 167 argb.minor = minor; 168 argb.interface = NULL; 169 /* eat the error, it will be in argb.interface */ 170 retval = driver_for_each_device(&drv->drvwrap.driver, NULL, &argb, 171 __find_interface); 172 return argb.interface; 173} 174 175/** 176 * usb_release_dev - free a usb device structure when all users of it are finished. 177 * @dev: device that's been disconnected 178 * 179 * Will be called only by the device core when all users of this usb device are 180 * done. 181 */ 182static void usb_release_dev(struct device *dev) 183{ 184 struct usb_device *udev; 185 186 udev = to_usb_device(dev); 187 188#ifdef CONFIG_USB_SUSPEND 189 cancel_delayed_work(&udev->autosuspend); 190 flush_workqueue(ksuspend_usb_wq); 191#endif 192 usb_destroy_configuration(udev); 193 usb_put_hcd(bus_to_hcd(udev->bus)); 194 kfree(udev->product); 195 kfree(udev->manufacturer); 196 kfree(udev->serial); 197 kfree(udev); 198} 199 200#ifdef CONFIG_PM 201 202static int ksuspend_usb_init(void) 203{ 204 ksuspend_usb_wq = create_singlethread_workqueue("ksuspend_usbd"); 205 if (!ksuspend_usb_wq) 206 return -ENOMEM; 207 return 0; 208} 209 210static void ksuspend_usb_cleanup(void) 211{ 212 destroy_workqueue(ksuspend_usb_wq); 213} 214 215#else 216 217#define ksuspend_usb_init() 0 218#define ksuspend_usb_cleanup() do {} while (0) 219 220#endif /* CONFIG_PM */ 221 222/** 223 * usb_alloc_dev - usb device constructor (usbcore-internal) 224 * @parent: hub to which device is connected; null to allocate a root hub 225 * @bus: bus used to access the device 226 * @port1: one-based index of port; ignored for root hubs 227 * Context: !in_interrupt() 228 * 229 * Only hub drivers (including virtual root hub drivers for host 230 * controllers) should ever call this. 231 * 232 * This call may not be used in a non-sleeping context. 233 */ 234struct usb_device * 235usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1) 236{ 237 struct usb_device *dev; 238 239 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 240 if (!dev) 241 return NULL; 242 243 if (!usb_get_hcd(bus_to_hcd(bus))) { 244 kfree(dev); 245 return NULL; 246 } 247 248 device_initialize(&dev->dev); 249 dev->dev.bus = &usb_bus_type; 250 dev->dev.dma_mask = bus->controller->dma_mask; 251 dev->dev.release = usb_release_dev; 252 dev->state = USB_STATE_ATTACHED; 253 254 /* This magic assignment distinguishes devices from interfaces */ 255 dev->dev.platform_data = &usb_generic_driver; 256 257 INIT_LIST_HEAD(&dev->ep0.urb_list); 258 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 259 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 260 /* ep0 maxpacket comes later, from device descriptor */ 261 dev->ep_in[0] = dev->ep_out[0] = &dev->ep0; 262 263 /* Save readable and stable topology id, distinguishing devices 264 * by location for diagnostics, tools, driver model, etc. The 265 * string is a path along hub ports, from the root. Each device's 266 * dev->devpath will be stable until USB is re-cabled, and hubs 267 * are often labeled with these port numbers. The bus_id isn't 268 * as stable: bus->busnum changes easily from modprobe order, 269 * cardbus or pci hotplugging, and so on. 270 */ 271 if (unlikely(!parent)) { 272 dev->devpath[0] = '0'; 273 274 dev->dev.parent = bus->controller; 275 sprintf(&dev->dev.bus_id[0], "usb%d", bus->busnum); 276 } else { 277 /* match any labeling on the hubs; it's one-based */ 278 if (parent->devpath[0] == '0') 279 snprintf(dev->devpath, sizeof dev->devpath, 280 "%d", port1); 281 else 282 snprintf(dev->devpath, sizeof dev->devpath, 283 "%s.%d", parent->devpath, port1); 284 285 dev->dev.parent = &parent->dev; 286 sprintf(&dev->dev.bus_id[0], "%d-%s", 287 bus->busnum, dev->devpath); 288 289 /* hub driver sets up TT records */ 290 } 291 292 dev->portnum = port1; 293 dev->bus = bus; 294 dev->parent = parent; 295 INIT_LIST_HEAD(&dev->filelist); 296 297#ifdef CONFIG_PM 298 mutex_init(&dev->pm_mutex); 299 INIT_DELAYED_WORK(&dev->autosuspend, usb_autosuspend_work); 300 dev->autosuspend_delay = usb_autosuspend_delay * HZ; 301#endif 302 return dev; 303} 304 305/** 306 * usb_get_dev - increments the reference count of the usb device structure 307 * @dev: the device being referenced 308 * 309 * Each live reference to a device should be refcounted. 310 * 311 * Drivers for USB interfaces should normally record such references in 312 * their probe() methods, when they bind to an interface, and release 313 * them by calling usb_put_dev(), in their disconnect() methods. 314 * 315 * A pointer to the device with the incremented reference counter is returned. 316 */ 317struct usb_device *usb_get_dev(struct usb_device *dev) 318{ 319 if (dev) 320 get_device(&dev->dev); 321 return dev; 322} 323 324/** 325 * usb_put_dev - release a use of the usb device structure 326 * @dev: device that's been disconnected 327 * 328 * Must be called when a user of a device is finished with it. When the last 329 * user of the device calls this function, the memory of the device is freed. 330 */ 331void usb_put_dev(struct usb_device *dev) 332{ 333 if (dev) 334 put_device(&dev->dev); 335} 336 337/** 338 * usb_get_intf - increments the reference count of the usb interface structure 339 * @intf: the interface being referenced 340 * 341 * Each live reference to a interface must be refcounted. 342 * 343 * Drivers for USB interfaces should normally record such references in 344 * their probe() methods, when they bind to an interface, and release 345 * them by calling usb_put_intf(), in their disconnect() methods. 346 * 347 * A pointer to the interface with the incremented reference counter is 348 * returned. 349 */ 350struct usb_interface *usb_get_intf(struct usb_interface *intf) 351{ 352 if (intf) 353 get_device(&intf->dev); 354 return intf; 355} 356 357/** 358 * usb_put_intf - release a use of the usb interface structure 359 * @intf: interface that's been decremented 360 * 361 * Must be called when a user of an interface is finished with it. When the 362 * last user of the interface calls this function, the memory of the interface 363 * is freed. 364 */ 365void usb_put_intf(struct usb_interface *intf) 366{ 367 if (intf) 368 put_device(&intf->dev); 369} 370 371 372/* USB device locking 373 * 374 * USB devices and interfaces are locked using the semaphore in their 375 * embedded struct device. The hub driver guarantees that whenever a 376 * device is connected or disconnected, drivers are called with the 377 * USB device locked as well as their particular interface. 378 * 379 * Complications arise when several devices are to be locked at the same 380 * time. Only hub-aware drivers that are part of usbcore ever have to 381 * do this; nobody else needs to worry about it. The rule for locking 382 * is simple: 383 * 384 * When locking both a device and its parent, always lock the 385 * the parent first. 386 */ 387 388/** 389 * usb_lock_device_for_reset - cautiously acquire the lock for a 390 * usb device structure 391 * @udev: device that's being locked 392 * @iface: interface bound to the driver making the request (optional) 393 * 394 * Attempts to acquire the device lock, but fails if the device is 395 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface 396 * is neither BINDING nor BOUND. Rather than sleeping to wait for the 397 * lock, the routine polls repeatedly. This is to prevent deadlock with 398 * disconnect; in some drivers (such as usb-storage) the disconnect() 399 * or suspend() method will block waiting for a device reset to complete. 400 * 401 * Returns a negative error code for failure, otherwise 1 or 0 to indicate 402 * that the device will or will not have to be unlocked. (0 can be 403 * returned when an interface is given and is BINDING, because in that 404 * case the driver already owns the device lock.) 405 */ 406int usb_lock_device_for_reset(struct usb_device *udev, 407 const struct usb_interface *iface) 408{ 409 unsigned long jiffies_expire = jiffies + HZ; 410 411 if (udev->state == USB_STATE_NOTATTACHED) 412 return -ENODEV; 413 if (udev->state == USB_STATE_SUSPENDED) 414 return -EHOSTUNREACH; 415 if (iface) { 416 switch (iface->condition) { 417 case USB_INTERFACE_BINDING: 418 return 0; 419 case USB_INTERFACE_BOUND: 420 break; 421 default: 422 return -EINTR; 423 } 424 } 425 426 while (usb_trylock_device(udev) != 0) { 427 428 /* If we can't acquire the lock after waiting one second, 429 * we're probably deadlocked */ 430 if (time_after(jiffies, jiffies_expire)) 431 return -EBUSY; 432 433 msleep(15); 434 if (udev->state == USB_STATE_NOTATTACHED) 435 return -ENODEV; 436 if (udev->state == USB_STATE_SUSPENDED) 437 return -EHOSTUNREACH; 438 if (iface && iface->condition != USB_INTERFACE_BOUND) 439 return -EINTR; 440 } 441 return 1; 442} 443 444 445static struct usb_device *match_device(struct usb_device *dev, 446 u16 vendor_id, u16 product_id) 447{ 448 struct usb_device *ret_dev = NULL; 449 int child; 450 451 dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", 452 le16_to_cpu(dev->descriptor.idVendor), 453 le16_to_cpu(dev->descriptor.idProduct)); 454 455 /* see if this device matches */ 456 if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) && 457 (product_id == le16_to_cpu(dev->descriptor.idProduct))) { 458 dev_dbg(&dev->dev, "matched this device!\n"); 459 ret_dev = usb_get_dev(dev); 460 goto exit; 461 } 462 463 /* look through all of the children of this device */ 464 for (child = 0; child < dev->maxchild; ++child) { 465 if (dev->children[child]) { 466 usb_lock_device(dev->children[child]); 467 ret_dev = match_device(dev->children[child], 468 vendor_id, product_id); 469 usb_unlock_device(dev->children[child]); 470 if (ret_dev) 471 goto exit; 472 } 473 } 474exit: 475 return ret_dev; 476} 477 478/** 479 * usb_find_device - find a specific usb device in the system 480 * @vendor_id: the vendor id of the device to find 481 * @product_id: the product id of the device to find 482 * 483 * Returns a pointer to a struct usb_device if such a specified usb 484 * device is present in the system currently. The usage count of the 485 * device will be incremented if a device is found. Make sure to call 486 * usb_put_dev() when the caller is finished with the device. 487 * 488 * If a device with the specified vendor and product id is not found, 489 * NULL is returned. 490 */ 491struct usb_device *usb_find_device(u16 vendor_id, u16 product_id) 492{ 493 struct list_head *buslist; 494 struct usb_bus *bus; 495 struct usb_device *dev = NULL; 496 497 mutex_lock(&usb_bus_list_lock); 498 for (buslist = usb_bus_list.next; 499 buslist != &usb_bus_list; 500 buslist = buslist->next) { 501 bus = container_of(buslist, struct usb_bus, bus_list); 502 if (!bus->root_hub) 503 continue; 504 usb_lock_device(bus->root_hub); 505 dev = match_device(bus->root_hub, vendor_id, product_id); 506 usb_unlock_device(bus->root_hub); 507 if (dev) 508 goto exit; 509 } 510exit: 511 mutex_unlock(&usb_bus_list_lock); 512 return dev; 513} 514 515/** 516 * usb_get_current_frame_number - return current bus frame number 517 * @dev: the device whose bus is being queried 518 * 519 * Returns the current frame number for the USB host controller 520 * used with the given USB device. This can be used when scheduling 521 * isochronous requests. 522 * 523 * Note that different kinds of host controller have different 524 * "scheduling horizons". While one type might support scheduling only 525 * 32 frames into the future, others could support scheduling up to 526 * 1024 frames into the future. 527 */ 528int usb_get_current_frame_number(struct usb_device *dev) 529{ 530 return usb_hcd_get_frame_number(dev); 531} 532 533/*-------------------------------------------------------------------*/ 534/* 535 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 536 * extra field of the interface and endpoint descriptor structs. 537 */ 538 539int __usb_get_extra_descriptor(char *buffer, unsigned size, 540 unsigned char type, void **ptr) 541{ 542 struct usb_descriptor_header *header; 543 544 while (size >= sizeof(struct usb_descriptor_header)) { 545 header = (struct usb_descriptor_header *)buffer; 546 547 if (header->bLength < 2) { 548 printk(KERN_ERR 549 "%s: bogus descriptor, type %d length %d\n", 550 usbcore_name, 551 header->bDescriptorType, 552 header->bLength); 553 return -1; 554 } 555 556 if (header->bDescriptorType == type) { 557 *ptr = header; 558 return 0; 559 } 560 561 buffer += header->bLength; 562 size -= header->bLength; 563 } 564 return -1; 565} 566 567/** 568 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 569 * @dev: device the buffer will be used with 570 * @size: requested buffer size 571 * @mem_flags: affect whether allocation may block 572 * @dma: used to return DMA address of buffer 573 * 574 * Return value is either null (indicating no buffer could be allocated), or 575 * the cpu-space pointer to a buffer that may be used to perform DMA to the 576 * specified device. Such cpu-space buffers are returned along with the DMA 577 * address (through the pointer provided). 578 * 579 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags 580 * to avoid behaviors like using "DMA bounce buffers", or tying down I/O 581 * mapping hardware for long idle periods. The implementation varies between 582 * platforms, depending on details of how DMA will work to this device. 583 * Using these buffers also helps prevent cacheline sharing problems on 584 * architectures where CPU caches are not DMA-coherent. 585 * 586 * When the buffer is no longer used, free it with usb_buffer_free(). 587 */ 588void *usb_buffer_alloc( 589 struct usb_device *dev, 590 size_t size, 591 gfp_t mem_flags, 592 dma_addr_t *dma 593) 594{ 595 if (!dev || !dev->bus) 596 return NULL; 597 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 598} 599 600/** 601 * usb_buffer_free - free memory allocated with usb_buffer_alloc() 602 * @dev: device the buffer was used with 603 * @size: requested buffer size 604 * @addr: CPU address of buffer 605 * @dma: DMA address of buffer 606 * 607 * This reclaims an I/O buffer, letting it be reused. The memory must have 608 * been allocated using usb_buffer_alloc(), and the parameters must match 609 * those provided in that allocation request. 610 */ 611void usb_buffer_free( 612 struct usb_device *dev, 613 size_t size, 614 void *addr, 615 dma_addr_t dma 616) 617{ 618 if (!dev || !dev->bus) 619 return; 620 if (!addr) 621 return; 622 hcd_buffer_free(dev->bus, size, addr, dma); 623} 624 625/** 626 * usb_buffer_map - create DMA mapping(s) for an urb 627 * @urb: urb whose transfer_buffer/setup_packet will be mapped 628 * 629 * Return value is either null (indicating no buffer could be mapped), or 630 * the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are 631 * added to urb->transfer_flags if the operation succeeds. If the device 632 * is connected to this system through a non-DMA controller, this operation 633 * always succeeds. 634 * 635 * This call would normally be used for an urb which is reused, perhaps 636 * as the target of a large periodic transfer, with usb_buffer_dmasync() 637 * calls to synchronize memory and dma state. 638 * 639 * Reverse the effect of this call with usb_buffer_unmap(). 640 */ 641#if 0 642struct urb *usb_buffer_map(struct urb *urb) 643{ 644 struct usb_bus *bus; 645 struct device *controller; 646 647 if (!urb 648 || !urb->dev 649 || !(bus = urb->dev->bus) 650 || !(controller = bus->controller)) 651 return NULL; 652 653 if (controller->dma_mask) { 654 urb->transfer_dma = dma_map_single(controller, 655 urb->transfer_buffer, urb->transfer_buffer_length, 656 usb_pipein(urb->pipe) 657 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 658 if (usb_pipecontrol(urb->pipe)) 659 urb->setup_dma = dma_map_single(controller, 660 urb->setup_packet, 661 sizeof(struct usb_ctrlrequest), 662 DMA_TO_DEVICE); 663 // FIXME generic api broken like pci, can't report errors 664 // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; 665 } else 666 urb->transfer_dma = ~0; 667 urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP 668 | URB_NO_SETUP_DMA_MAP); 669 return urb; 670} 671#endif /* 0 */ 672 673/* XXX DISABLED, no users currently. If you wish to re-enable this 674 * XXX please determine whether the sync is to transfer ownership of 675 * XXX the buffer from device to cpu or vice verse, and thusly use the 676 * XXX appropriate _for_{cpu,device}() method. -DaveM 677 */ 678#if 0 679 680/** 681 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s) 682 * @urb: urb whose transfer_buffer/setup_packet will be synchronized 683 */ 684void usb_buffer_dmasync(struct urb *urb) 685{ 686 struct usb_bus *bus; 687 struct device *controller; 688 689 if (!urb 690 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 691 || !urb->dev 692 || !(bus = urb->dev->bus) 693 || !(controller = bus->controller)) 694 return; 695 696 if (controller->dma_mask) { 697 dma_sync_single(controller, 698 urb->transfer_dma, urb->transfer_buffer_length, 699 usb_pipein(urb->pipe) 700 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 701 if (usb_pipecontrol(urb->pipe)) 702 dma_sync_single(controller, 703 urb->setup_dma, 704 sizeof(struct usb_ctrlrequest), 705 DMA_TO_DEVICE); 706 } 707} 708#endif 709 710/** 711 * usb_buffer_unmap - free DMA mapping(s) for an urb 712 * @urb: urb whose transfer_buffer will be unmapped 713 * 714 * Reverses the effect of usb_buffer_map(). 715 */ 716#if 0 717void usb_buffer_unmap(struct urb *urb) 718{ 719 struct usb_bus *bus; 720 struct device *controller; 721 722 if (!urb 723 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 724 || !urb->dev 725 || !(bus = urb->dev->bus) 726 || !(controller = bus->controller)) 727 return; 728 729 if (controller->dma_mask) { 730 dma_unmap_single(controller, 731 urb->transfer_dma, urb->transfer_buffer_length, 732 usb_pipein(urb->pipe) 733 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 734 if (usb_pipecontrol(urb->pipe)) 735 dma_unmap_single(controller, 736 urb->setup_dma, 737 sizeof(struct usb_ctrlrequest), 738 DMA_TO_DEVICE); 739 } 740 urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP 741 | URB_NO_SETUP_DMA_MAP); 742} 743#endif /* 0 */ 744 745/** 746 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 747 * @dev: device to which the scatterlist will be mapped 748 * @pipe: endpoint defining the mapping direction 749 * @sg: the scatterlist to map 750 * @nents: the number of entries in the scatterlist 751 * 752 * Return value is either < 0 (indicating no buffers could be mapped), or 753 * the number of DMA mapping array entries in the scatterlist. 754 * 755 * The caller is responsible for placing the resulting DMA addresses from 756 * the scatterlist into URB transfer buffer pointers, and for setting the 757 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs. 758 * 759 * Top I/O rates come from queuing URBs, instead of waiting for each one 760 * to complete before starting the next I/O. This is particularly easy 761 * to do with scatterlists. Just allocate and submit one URB for each DMA 762 * mapping entry returned, stopping on the first error or when all succeed. 763 * Better yet, use the usb_sg_*() calls, which do that (and more) for you. 764 * 765 * This call would normally be used when translating scatterlist requests, 766 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it 767 * may be able to coalesce mappings for improved I/O efficiency. 768 * 769 * Reverse the effect of this call with usb_buffer_unmap_sg(). 770 */ 771int usb_buffer_map_sg(const struct usb_device *dev, unsigned pipe, 772 struct scatterlist *sg, int nents) 773{ 774 struct usb_bus *bus; 775 struct device *controller; 776 777 if (!dev 778 || usb_pipecontrol(pipe) 779 || !(bus = dev->bus) 780 || !(controller = bus->controller) 781 || !controller->dma_mask) 782 return -1; 783 784 // FIXME generic api broken like pci, can't report errors 785 return dma_map_sg(controller, sg, nents, 786 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 787} 788 789/* XXX DISABLED, no users currently. If you wish to re-enable this 790 * XXX please determine whether the sync is to transfer ownership of 791 * XXX the buffer from device to cpu or vice verse, and thusly use the 792 * XXX appropriate _for_{cpu,device}() method. -DaveM 793 */ 794#if 0 795 796/** 797 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s) 798 * @dev: device to which the scatterlist will be mapped 799 * @pipe: endpoint defining the mapping direction 800 * @sg: the scatterlist to synchronize 801 * @n_hw_ents: the positive return value from usb_buffer_map_sg 802 * 803 * Use this when you are re-using a scatterlist's data buffers for 804 * another USB request. 805 */ 806void usb_buffer_dmasync_sg(const struct usb_device *dev, unsigned pipe, 807 struct scatterlist *sg, int n_hw_ents) 808{ 809 struct usb_bus *bus; 810 struct device *controller; 811 812 if (!dev 813 || !(bus = dev->bus) 814 || !(controller = bus->controller) 815 || !controller->dma_mask) 816 return; 817 818 dma_sync_sg(controller, sg, n_hw_ents, 819 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 820} 821#endif 822 823/** 824 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 825 * @dev: device to which the scatterlist will be mapped 826 * @pipe: endpoint defining the mapping direction 827 * @sg: the scatterlist to unmap 828 * @n_hw_ents: the positive return value from usb_buffer_map_sg 829 * 830 * Reverses the effect of usb_buffer_map_sg(). 831 */ 832void usb_buffer_unmap_sg(const struct usb_device *dev, unsigned pipe, 833 struct scatterlist *sg, int n_hw_ents) 834{ 835 struct usb_bus *bus; 836 struct device *controller; 837 838 if (!dev 839 || !(bus = dev->bus) 840 || !(controller = bus->controller) 841 || !controller->dma_mask) 842 return; 843 844 dma_unmap_sg(controller, sg, n_hw_ents, 845 usb_pipein(pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 846} 847 848/* format to disable USB on kernel command line is: nousb */ 849__module_param_call("", nousb, param_set_bool, param_get_bool, &nousb, 0444); 850 851/* 852 * for external read access to <nousb> 853 */ 854int usb_disabled(void) 855{ 856 return nousb; 857} 858 859/* 860 * Init 861 */ 862static int __init usb_init(void) 863{ 864 int retval; 865 if (nousb) { 866 pr_info("%s: USB support disabled\n", usbcore_name); 867 return 0; 868 } 869 870 retval = ksuspend_usb_init(); 871 if (retval) 872 goto out; 873 retval = bus_register(&usb_bus_type); 874 if (retval) 875 goto bus_register_failed; 876 retval = usb_host_init(); 877 if (retval) 878 goto host_init_failed; 879 retval = usb_major_init(); 880 if (retval) 881 goto major_init_failed; 882 retval = usb_register(&usbfs_driver); 883 if (retval) 884 goto driver_register_failed; 885 retval = usbdev_init(); 886 if (retval) 887 goto usbdevice_init_failed; 888 retval = usbfs_init(); 889 if (retval) 890 goto fs_init_failed; 891 retval = usb_hub_init(); 892 if (retval) 893 goto hub_init_failed; 894 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); 895 if (!retval) 896 goto out; 897 898 usb_hub_cleanup(); 899hub_init_failed: 900 usbfs_cleanup(); 901fs_init_failed: 902 usbdev_cleanup(); 903usbdevice_init_failed: 904 usb_deregister(&usbfs_driver); 905driver_register_failed: 906 usb_major_cleanup(); 907major_init_failed: 908 usb_host_cleanup(); 909host_init_failed: 910 bus_unregister(&usb_bus_type); 911bus_register_failed: 912 ksuspend_usb_cleanup(); 913out: 914 return retval; 915} 916 917/* 918 * Cleanup 919 */ 920static void __exit usb_exit(void) 921{ 922 /* This will matter if shutdown/reboot does exitcalls. */ 923 if (nousb) 924 return; 925 926 usb_deregister_device_driver(&usb_generic_driver); 927 usb_major_cleanup(); 928 usbfs_cleanup(); 929 usb_deregister(&usbfs_driver); 930 usbdev_cleanup(); 931 usb_hub_cleanup(); 932 usb_host_cleanup(); 933 bus_unregister(&usb_bus_type); 934 ksuspend_usb_cleanup(); 935} 936 937subsys_initcall(usb_init); 938module_exit(usb_exit); 939 940/* 941 * USB may be built into the kernel or be built as modules. 942 * These symbols are exported for device (or host controller) 943 * driver modules to use. 944 */ 945 946EXPORT_SYMBOL(usb_disabled); 947 948EXPORT_SYMBOL_GPL(usb_get_intf); 949EXPORT_SYMBOL_GPL(usb_put_intf); 950 951EXPORT_SYMBOL(usb_put_dev); 952EXPORT_SYMBOL(usb_get_dev); 953EXPORT_SYMBOL(usb_hub_tt_clear_buffer); 954 955EXPORT_SYMBOL(usb_lock_device_for_reset); 956 957EXPORT_SYMBOL(usb_find_interface); 958EXPORT_SYMBOL(usb_ifnum_to_if); 959EXPORT_SYMBOL(usb_altnum_to_altsetting); 960 961EXPORT_SYMBOL(__usb_get_extra_descriptor); 962 963EXPORT_SYMBOL(usb_find_device); 964EXPORT_SYMBOL(usb_get_current_frame_number); 965 966EXPORT_SYMBOL(usb_buffer_alloc); 967EXPORT_SYMBOL(usb_buffer_free); 968 969#if 0 970EXPORT_SYMBOL(usb_buffer_map); 971EXPORT_SYMBOL(usb_buffer_dmasync); 972EXPORT_SYMBOL(usb_buffer_unmap); 973#endif 974 975EXPORT_SYMBOL(usb_buffer_map_sg); 976#if 0 977EXPORT_SYMBOL(usb_buffer_dmasync_sg); 978#endif 979EXPORT_SYMBOL(usb_buffer_unmap_sg); 980 981MODULE_LICENSE("GPL"); 982