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