1 /* 2 * drivers/usb/core/usb.c 3 * 4 * (C) Copyright Linus Torvalds 1999 5 * (C) Copyright Johannes Erdfelt 1999-2001 6 * (C) Copyright Andreas Gal 1999 7 * (C) Copyright Gregory P. Smith 1999 8 * (C) Copyright Deti Fliegl 1999 (new USB architecture) 9 * (C) Copyright Randy Dunlap 2000 10 * (C) Copyright David Brownell 2000-2004 11 * (C) Copyright Yggdrasil Computing, Inc. 2000 12 * (usb_device_id matching changes by Adam J. Richter) 13 * (C) Copyright Greg Kroah-Hartman 2002-2003 14 * 15 * NOTE! This is not actually a driver at all, rather this is 16 * just a collection of helper routines that implement the 17 * generic USB things that the real drivers can use.. 18 * 19 * Think of this as a "USB library" rather than anything else. 20 * It should be considered a slave, with no callbacks. Callbacks 21 * are evil. 22 */ 23 24 #include <linux/module.h> 25 #include <linux/moduleparam.h> 26 #include <linux/string.h> 27 #include <linux/bitops.h> 28 #include <linux/slab.h> 29 #include <linux/interrupt.h> /* for in_interrupt() */ 30 #include <linux/kmod.h> 31 #include <linux/init.h> 32 #include <linux/spinlock.h> 33 #include <linux/errno.h> 34 #include <linux/usb.h> 35 #include <linux/usb/hcd.h> 36 #include <linux/mutex.h> 37 #include <linux/workqueue.h> 38 #include <linux/debugfs.h> 39 40 #include <asm/io.h> 41 #include <linux/scatterlist.h> 42 #include <linux/mm.h> 43 #include <linux/dma-mapping.h> 44 45 #include "usb.h" 46 47 48 const char *usbcore_name = "usbcore"; 49 50 static bool nousb; /* Disable USB when built into kernel image */ 51 52 #ifdef CONFIG_USB_SUSPEND 53 static int usb_autosuspend_delay = 2; /* Default delay value, 54 * in seconds */ 55 module_param_named(autosuspend, usb_autosuspend_delay, int, 0644); 56 MODULE_PARM_DESC(autosuspend, "default autosuspend delay"); 57 58 #else 59 #define usb_autosuspend_delay 0 60 #endif 61 62 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 */ 72 struct usb_host_interface *usb_find_alt_setting( 73 struct usb_host_config *config, 74 unsigned int iface_num, 75 unsigned int alt_num) 76 { 77 struct usb_interface_cache *intf_cache = NULL; 78 int i; 79 80 for (i = 0; i < config->desc.bNumInterfaces; i++) { 81 if (config->intf_cache[i]->altsetting[0].desc.bInterfaceNumber 82 == iface_num) { 83 intf_cache = config->intf_cache[i]; 84 break; 85 } 86 } 87 if (!intf_cache) 88 return NULL; 89 for (i = 0; i < intf_cache->num_altsetting; i++) 90 if (intf_cache->altsetting[i].desc.bAlternateSetting == alt_num) 91 return &intf_cache->altsetting[i]; 92 93 printk(KERN_DEBUG "Did not find alt setting %u for intf %u, " 94 "config %u\n", alt_num, iface_num, 95 config->desc.bConfigurationValue); 96 return NULL; 97 } 98 EXPORT_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 */ 119 struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev, 120 unsigned ifnum) 121 { 122 struct usb_host_config *config = dev->actconfig; 123 int i; 124 125 if (!config) 126 return NULL; 127 for (i = 0; i < config->desc.bNumInterfaces; i++) 128 if (config->interface[i]->altsetting[0] 129 .desc.bInterfaceNumber == ifnum) 130 return config->interface[i]; 131 132 return NULL; 133 } 134 EXPORT_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 */ 153 struct usb_host_interface *usb_altnum_to_altsetting( 154 const struct usb_interface *intf, 155 unsigned int altnum) 156 { 157 int i; 158 159 for (i = 0; i < intf->num_altsetting; i++) { 160 if (intf->altsetting[i].desc.bAlternateSetting == altnum) 161 return &intf->altsetting[i]; 162 } 163 return NULL; 164 } 165 EXPORT_SYMBOL_GPL(usb_altnum_to_altsetting); 166 167 struct find_interface_arg { 168 int minor; 169 struct device_driver *drv; 170 }; 171 172 static int __find_interface(struct device *dev, void *data) 173 { 174 struct find_interface_arg *arg = data; 175 struct usb_interface *intf; 176 177 if (!is_usb_interface(dev)) 178 return 0; 179 180 if (dev->driver != arg->drv) 181 return 0; 182 intf = to_usb_interface(dev); 183 return intf->minor == arg->minor; 184 } 185 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 */ 195 struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor) 196 { 197 struct find_interface_arg argb; 198 struct device *dev; 199 200 argb.minor = minor; 201 argb.drv = &drv->drvwrap.driver; 202 203 dev = bus_find_device(&usb_bus_type, NULL, &argb, __find_interface); 204 205 /* Drop reference count from bus_find_device */ 206 put_device(dev); 207 208 return dev ? to_usb_interface(dev) : NULL; 209 } 210 EXPORT_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 */ 219 static void usb_release_dev(struct device *dev) 220 { 221 struct usb_device *udev; 222 struct usb_hcd *hcd; 223 224 udev = to_usb_device(dev); 225 hcd = bus_to_hcd(udev->bus); 226 227 usb_destroy_configuration(udev); 228 usb_release_bos_descriptor(udev); 229 usb_put_hcd(hcd); 230 kfree(udev->product); 231 kfree(udev->manufacturer); 232 kfree(udev->serial); 233 kfree(udev); 234 } 235 236 static 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 #ifdef CONFIG_PM 252 253 /* USB device Power-Management thunks. 254 * There's no need to distinguish here between quiescing a USB device 255 * and powering it down; the generic_suspend() routine takes care of 256 * it by skipping the usb_port_suspend() call for a quiesce. And for 257 * USB interfaces there's no difference at all. 258 */ 259 260 static int usb_dev_prepare(struct device *dev) 261 { 262 return 0; /* Implement eventually? */ 263 } 264 265 static void usb_dev_complete(struct device *dev) 266 { 267 /* Currently used only for rebinding interfaces */ 268 usb_resume_complete(dev); 269 } 270 271 static int usb_dev_suspend(struct device *dev) 272 { 273 return usb_suspend(dev, PMSG_SUSPEND); 274 } 275 276 static int usb_dev_resume(struct device *dev) 277 { 278 return usb_resume(dev, PMSG_RESUME); 279 } 280 281 static int usb_dev_freeze(struct device *dev) 282 { 283 return usb_suspend(dev, PMSG_FREEZE); 284 } 285 286 static int usb_dev_thaw(struct device *dev) 287 { 288 return usb_resume(dev, PMSG_THAW); 289 } 290 291 static int usb_dev_poweroff(struct device *dev) 292 { 293 return usb_suspend(dev, PMSG_HIBERNATE); 294 } 295 296 static int usb_dev_restore(struct device *dev) 297 { 298 return usb_resume(dev, PMSG_RESTORE); 299 } 300 301 static const struct dev_pm_ops usb_device_pm_ops = { 302 .prepare = usb_dev_prepare, 303 .complete = usb_dev_complete, 304 .suspend = usb_dev_suspend, 305 .resume = usb_dev_resume, 306 .freeze = usb_dev_freeze, 307 .thaw = usb_dev_thaw, 308 .poweroff = usb_dev_poweroff, 309 .restore = usb_dev_restore, 310 #ifdef CONFIG_USB_SUSPEND 311 .runtime_suspend = usb_runtime_suspend, 312 .runtime_resume = usb_runtime_resume, 313 .runtime_idle = usb_runtime_idle, 314 #endif 315 }; 316 317 #endif /* CONFIG_PM */ 318 319 320 static char *usb_devnode(struct device *dev, umode_t *mode) 321 { 322 struct usb_device *usb_dev; 323 324 usb_dev = to_usb_device(dev); 325 return kasprintf(GFP_KERNEL, "bus/usb/%03d/%03d", 326 usb_dev->bus->busnum, usb_dev->devnum); 327 } 328 329 struct device_type usb_device_type = { 330 .name = "usb_device", 331 .release = usb_release_dev, 332 .uevent = usb_dev_uevent, 333 .devnode = usb_devnode, 334 #ifdef CONFIG_PM 335 .pm = &usb_device_pm_ops, 336 #endif 337 }; 338 339 340 /* Returns 1 if @usb_bus is WUSB, 0 otherwise */ 341 static unsigned usb_bus_is_wusb(struct usb_bus *bus) 342 { 343 struct usb_hcd *hcd = container_of(bus, struct usb_hcd, self); 344 return hcd->wireless; 345 } 346 347 348 /** 349 * usb_alloc_dev - usb device constructor (usbcore-internal) 350 * @parent: hub to which device is connected; null to allocate a root hub 351 * @bus: bus used to access the device 352 * @port1: one-based index of port; ignored for root hubs 353 * Context: !in_interrupt() 354 * 355 * Only hub drivers (including virtual root hub drivers for host 356 * controllers) should ever call this. 357 * 358 * This call may not be used in a non-sleeping context. 359 */ 360 struct usb_device *usb_alloc_dev(struct usb_device *parent, 361 struct usb_bus *bus, unsigned port1) 362 { 363 struct usb_device *dev; 364 struct usb_hcd *usb_hcd = bus_to_hcd(bus); 365 unsigned root_hub = 0; 366 367 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 368 if (!dev) 369 return NULL; 370 371 if (!usb_get_hcd(usb_hcd)) { 372 kfree(dev); 373 return NULL; 374 } 375 /* Root hubs aren't true devices, so don't allocate HCD resources */ 376 if (usb_hcd->driver->alloc_dev && parent && 377 !usb_hcd->driver->alloc_dev(usb_hcd, dev)) { 378 usb_put_hcd(bus_to_hcd(bus)); 379 kfree(dev); 380 return NULL; 381 } 382 383 device_initialize(&dev->dev); 384 dev->dev.bus = &usb_bus_type; 385 dev->dev.type = &usb_device_type; 386 dev->dev.groups = usb_device_groups; 387 dev->dev.dma_mask = bus->controller->dma_mask; 388 set_dev_node(&dev->dev, dev_to_node(bus->controller)); 389 dev->state = USB_STATE_ATTACHED; 390 dev->lpm_disable_count = 1; 391 atomic_set(&dev->urbnum, 0); 392 393 INIT_LIST_HEAD(&dev->ep0.urb_list); 394 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 395 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 396 /* ep0 maxpacket comes later, from device descriptor */ 397 usb_enable_endpoint(dev, &dev->ep0, false); 398 dev->can_submit = 1; 399 400 /* Save readable and stable topology id, distinguishing devices 401 * by location for diagnostics, tools, driver model, etc. The 402 * string is a path along hub ports, from the root. Each device's 403 * dev->devpath will be stable until USB is re-cabled, and hubs 404 * are often labeled with these port numbers. The name isn't 405 * as stable: bus->busnum changes easily from modprobe order, 406 * cardbus or pci hotplugging, and so on. 407 */ 408 if (unlikely(!parent)) { 409 dev->devpath[0] = '0'; 410 dev->route = 0; 411 412 dev->dev.parent = bus->controller; 413 dev_set_name(&dev->dev, "usb%d", bus->busnum); 414 root_hub = 1; 415 } else { 416 /* match any labeling on the hubs; it's one-based */ 417 if (parent->devpath[0] == '0') { 418 snprintf(dev->devpath, sizeof dev->devpath, 419 "%d", port1); 420 /* Root ports are not counted in route string */ 421 dev->route = 0; 422 } else { 423 snprintf(dev->devpath, sizeof dev->devpath, 424 "%s.%d", parent->devpath, port1); 425 /* Route string assumes hubs have less than 16 ports */ 426 if (port1 < 15) 427 dev->route = parent->route + 428 (port1 << ((parent->level - 1)*4)); 429 else 430 dev->route = parent->route + 431 (15 << ((parent->level - 1)*4)); 432 } 433 434 dev->dev.parent = &parent->dev; 435 dev_set_name(&dev->dev, "%d-%s", bus->busnum, dev->devpath); 436 437 /* hub driver sets up TT records */ 438 } 439 440 dev->portnum = port1; 441 dev->bus = bus; 442 dev->parent = parent; 443 INIT_LIST_HEAD(&dev->filelist); 444 445 #ifdef CONFIG_PM 446 pm_runtime_set_autosuspend_delay(&dev->dev, 447 usb_autosuspend_delay * 1000); 448 dev->connect_time = jiffies; 449 dev->active_duration = -jiffies; 450 #endif 451 if (root_hub) /* Root hub always ok [and always wired] */ 452 dev->authorized = 1; 453 else { 454 dev->authorized = usb_hcd->authorized_default; 455 dev->wusb = usb_bus_is_wusb(bus)? 1 : 0; 456 } 457 return dev; 458 } 459 460 /** 461 * usb_get_dev - increments the reference count of the usb device structure 462 * @dev: the device being referenced 463 * 464 * Each live reference to a device should be refcounted. 465 * 466 * Drivers for USB interfaces should normally record such references in 467 * their probe() methods, when they bind to an interface, and release 468 * them by calling usb_put_dev(), in their disconnect() methods. 469 * 470 * A pointer to the device with the incremented reference counter is returned. 471 */ 472 struct usb_device *usb_get_dev(struct usb_device *dev) 473 { 474 if (dev) 475 get_device(&dev->dev); 476 return dev; 477 } 478 EXPORT_SYMBOL_GPL(usb_get_dev); 479 480 /** 481 * usb_put_dev - release a use of the usb device structure 482 * @dev: device that's been disconnected 483 * 484 * Must be called when a user of a device is finished with it. When the last 485 * user of the device calls this function, the memory of the device is freed. 486 */ 487 void usb_put_dev(struct usb_device *dev) 488 { 489 if (dev) 490 put_device(&dev->dev); 491 } 492 EXPORT_SYMBOL_GPL(usb_put_dev); 493 494 /** 495 * usb_get_intf - increments the reference count of the usb interface structure 496 * @intf: the interface being referenced 497 * 498 * Each live reference to a interface must be refcounted. 499 * 500 * Drivers for USB interfaces should normally record such references in 501 * their probe() methods, when they bind to an interface, and release 502 * them by calling usb_put_intf(), in their disconnect() methods. 503 * 504 * A pointer to the interface with the incremented reference counter is 505 * returned. 506 */ 507 struct usb_interface *usb_get_intf(struct usb_interface *intf) 508 { 509 if (intf) 510 get_device(&intf->dev); 511 return intf; 512 } 513 EXPORT_SYMBOL_GPL(usb_get_intf); 514 515 /** 516 * usb_put_intf - release a use of the usb interface structure 517 * @intf: interface that's been decremented 518 * 519 * Must be called when a user of an interface is finished with it. When the 520 * last user of the interface calls this function, the memory of the interface 521 * is freed. 522 */ 523 void usb_put_intf(struct usb_interface *intf) 524 { 525 if (intf) 526 put_device(&intf->dev); 527 } 528 EXPORT_SYMBOL_GPL(usb_put_intf); 529 530 /* USB device locking 531 * 532 * USB devices and interfaces are locked using the semaphore in their 533 * embedded struct device. The hub driver guarantees that whenever a 534 * device is connected or disconnected, drivers are called with the 535 * USB device locked as well as their particular interface. 536 * 537 * Complications arise when several devices are to be locked at the same 538 * time. Only hub-aware drivers that are part of usbcore ever have to 539 * do this; nobody else needs to worry about it. The rule for locking 540 * is simple: 541 * 542 * When locking both a device and its parent, always lock the 543 * the parent first. 544 */ 545 546 /** 547 * usb_lock_device_for_reset - cautiously acquire the lock for a usb device structure 548 * @udev: device that's being locked 549 * @iface: interface bound to the driver making the request (optional) 550 * 551 * Attempts to acquire the device lock, but fails if the device is 552 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface 553 * is neither BINDING nor BOUND. Rather than sleeping to wait for the 554 * lock, the routine polls repeatedly. This is to prevent deadlock with 555 * disconnect; in some drivers (such as usb-storage) the disconnect() 556 * or suspend() method will block waiting for a device reset to complete. 557 * 558 * Returns a negative error code for failure, otherwise 0. 559 */ 560 int usb_lock_device_for_reset(struct usb_device *udev, 561 const struct usb_interface *iface) 562 { 563 unsigned long jiffies_expire = jiffies + HZ; 564 565 if (udev->state == USB_STATE_NOTATTACHED) 566 return -ENODEV; 567 if (udev->state == USB_STATE_SUSPENDED) 568 return -EHOSTUNREACH; 569 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 570 iface->condition == USB_INTERFACE_UNBOUND)) 571 return -EINTR; 572 573 while (!usb_trylock_device(udev)) { 574 575 /* If we can't acquire the lock after waiting one second, 576 * we're probably deadlocked */ 577 if (time_after(jiffies, jiffies_expire)) 578 return -EBUSY; 579 580 msleep(15); 581 if (udev->state == USB_STATE_NOTATTACHED) 582 return -ENODEV; 583 if (udev->state == USB_STATE_SUSPENDED) 584 return -EHOSTUNREACH; 585 if (iface && (iface->condition == USB_INTERFACE_UNBINDING || 586 iface->condition == USB_INTERFACE_UNBOUND)) 587 return -EINTR; 588 } 589 return 0; 590 } 591 EXPORT_SYMBOL_GPL(usb_lock_device_for_reset); 592 593 /** 594 * usb_get_current_frame_number - return current bus frame number 595 * @dev: the device whose bus is being queried 596 * 597 * Returns the current frame number for the USB host controller 598 * used with the given USB device. This can be used when scheduling 599 * isochronous requests. 600 * 601 * Note that different kinds of host controller have different 602 * "scheduling horizons". While one type might support scheduling only 603 * 32 frames into the future, others could support scheduling up to 604 * 1024 frames into the future. 605 */ 606 int usb_get_current_frame_number(struct usb_device *dev) 607 { 608 return usb_hcd_get_frame_number(dev); 609 } 610 EXPORT_SYMBOL_GPL(usb_get_current_frame_number); 611 612 /*-------------------------------------------------------------------*/ 613 /* 614 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 615 * extra field of the interface and endpoint descriptor structs. 616 */ 617 618 int __usb_get_extra_descriptor(char *buffer, unsigned size, 619 unsigned char type, void **ptr) 620 { 621 struct usb_descriptor_header *header; 622 623 while (size >= sizeof(struct usb_descriptor_header)) { 624 header = (struct usb_descriptor_header *)buffer; 625 626 if (header->bLength < 2) { 627 printk(KERN_ERR 628 "%s: bogus descriptor, type %d length %d\n", 629 usbcore_name, 630 header->bDescriptorType, 631 header->bLength); 632 return -1; 633 } 634 635 if (header->bDescriptorType == type) { 636 *ptr = header; 637 return 0; 638 } 639 640 buffer += header->bLength; 641 size -= header->bLength; 642 } 643 return -1; 644 } 645 EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); 646 647 /** 648 * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 649 * @dev: device the buffer will be used with 650 * @size: requested buffer size 651 * @mem_flags: affect whether allocation may block 652 * @dma: used to return DMA address of buffer 653 * 654 * Return value is either null (indicating no buffer could be allocated), or 655 * the cpu-space pointer to a buffer that may be used to perform DMA to the 656 * specified device. Such cpu-space buffers are returned along with the DMA 657 * address (through the pointer provided). 658 * 659 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags 660 * to avoid behaviors like using "DMA bounce buffers", or thrashing IOMMU 661 * hardware during URB completion/resubmit. The implementation varies between 662 * platforms, depending on details of how DMA will work to this device. 663 * Using these buffers also eliminates cacheline sharing problems on 664 * architectures where CPU caches are not DMA-coherent. On systems without 665 * bus-snooping caches, these buffers are uncached. 666 * 667 * When the buffer is no longer used, free it with usb_free_coherent(). 668 */ 669 void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags, 670 dma_addr_t *dma) 671 { 672 if (!dev || !dev->bus) 673 return NULL; 674 return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); 675 } 676 EXPORT_SYMBOL_GPL(usb_alloc_coherent); 677 678 /** 679 * usb_free_coherent - free memory allocated with usb_alloc_coherent() 680 * @dev: device the buffer was used with 681 * @size: requested buffer size 682 * @addr: CPU address of buffer 683 * @dma: DMA address of buffer 684 * 685 * This reclaims an I/O buffer, letting it be reused. The memory must have 686 * been allocated using usb_alloc_coherent(), and the parameters must match 687 * those provided in that allocation request. 688 */ 689 void usb_free_coherent(struct usb_device *dev, size_t size, void *addr, 690 dma_addr_t dma) 691 { 692 if (!dev || !dev->bus) 693 return; 694 if (!addr) 695 return; 696 hcd_buffer_free(dev->bus, size, addr, dma); 697 } 698 EXPORT_SYMBOL_GPL(usb_free_coherent); 699 700 /** 701 * usb_buffer_map - create DMA mapping(s) for an urb 702 * @urb: urb whose transfer_buffer/setup_packet will be mapped 703 * 704 * Return value is either null (indicating no buffer could be mapped), or 705 * the parameter. URB_NO_TRANSFER_DMA_MAP is 706 * added to urb->transfer_flags if the operation succeeds. If the device 707 * is connected to this system through a non-DMA controller, this operation 708 * always succeeds. 709 * 710 * This call would normally be used for an urb which is reused, perhaps 711 * as the target of a large periodic transfer, with usb_buffer_dmasync() 712 * calls to synchronize memory and dma state. 713 * 714 * Reverse the effect of this call with usb_buffer_unmap(). 715 */ 716 #if 0 717 struct urb *usb_buffer_map(struct urb *urb) 718 { 719 struct usb_bus *bus; 720 struct device *controller; 721 722 if (!urb 723 || !urb->dev 724 || !(bus = urb->dev->bus) 725 || !(controller = bus->controller)) 726 return NULL; 727 728 if (controller->dma_mask) { 729 urb->transfer_dma = dma_map_single(controller, 730 urb->transfer_buffer, urb->transfer_buffer_length, 731 usb_pipein(urb->pipe) 732 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 733 /* FIXME generic api broken like pci, can't report errors */ 734 /* if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; */ 735 } else 736 urb->transfer_dma = ~0; 737 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 738 return urb; 739 } 740 EXPORT_SYMBOL_GPL(usb_buffer_map); 741 #endif /* 0 */ 742 743 /* XXX DISABLED, no users currently. If you wish to re-enable this 744 * XXX please determine whether the sync is to transfer ownership of 745 * XXX the buffer from device to cpu or vice verse, and thusly use the 746 * XXX appropriate _for_{cpu,device}() method. -DaveM 747 */ 748 #if 0 749 750 /** 751 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s) 752 * @urb: urb whose transfer_buffer/setup_packet will be synchronized 753 */ 754 void usb_buffer_dmasync(struct urb *urb) 755 { 756 struct usb_bus *bus; 757 struct device *controller; 758 759 if (!urb 760 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 761 || !urb->dev 762 || !(bus = urb->dev->bus) 763 || !(controller = bus->controller)) 764 return; 765 766 if (controller->dma_mask) { 767 dma_sync_single_for_cpu(controller, 768 urb->transfer_dma, urb->transfer_buffer_length, 769 usb_pipein(urb->pipe) 770 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 771 if (usb_pipecontrol(urb->pipe)) 772 dma_sync_single_for_cpu(controller, 773 urb->setup_dma, 774 sizeof(struct usb_ctrlrequest), 775 DMA_TO_DEVICE); 776 } 777 } 778 EXPORT_SYMBOL_GPL(usb_buffer_dmasync); 779 #endif 780 781 /** 782 * usb_buffer_unmap - free DMA mapping(s) for an urb 783 * @urb: urb whose transfer_buffer will be unmapped 784 * 785 * Reverses the effect of usb_buffer_map(). 786 */ 787 #if 0 788 void usb_buffer_unmap(struct urb *urb) 789 { 790 struct usb_bus *bus; 791 struct device *controller; 792 793 if (!urb 794 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 795 || !urb->dev 796 || !(bus = urb->dev->bus) 797 || !(controller = bus->controller)) 798 return; 799 800 if (controller->dma_mask) { 801 dma_unmap_single(controller, 802 urb->transfer_dma, urb->transfer_buffer_length, 803 usb_pipein(urb->pipe) 804 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 805 } 806 urb->transfer_flags &= ~URB_NO_TRANSFER_DMA_MAP; 807 } 808 EXPORT_SYMBOL_GPL(usb_buffer_unmap); 809 #endif /* 0 */ 810 811 #if 0 812 /** 813 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 814 * @dev: device to which the scatterlist will be mapped 815 * @is_in: mapping transfer direction 816 * @sg: the scatterlist to map 817 * @nents: the number of entries in the scatterlist 818 * 819 * Return value is either < 0 (indicating no buffers could be mapped), or 820 * the number of DMA mapping array entries in the scatterlist. 821 * 822 * The caller is responsible for placing the resulting DMA addresses from 823 * the scatterlist into URB transfer buffer pointers, and for setting the 824 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs. 825 * 826 * Top I/O rates come from queuing URBs, instead of waiting for each one 827 * to complete before starting the next I/O. This is particularly easy 828 * to do with scatterlists. Just allocate and submit one URB for each DMA 829 * mapping entry returned, stopping on the first error or when all succeed. 830 * Better yet, use the usb_sg_*() calls, which do that (and more) for you. 831 * 832 * This call would normally be used when translating scatterlist requests, 833 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it 834 * may be able to coalesce mappings for improved I/O efficiency. 835 * 836 * Reverse the effect of this call with usb_buffer_unmap_sg(). 837 */ 838 int usb_buffer_map_sg(const struct usb_device *dev, int is_in, 839 struct scatterlist *sg, int nents) 840 { 841 struct usb_bus *bus; 842 struct device *controller; 843 844 if (!dev 845 || !(bus = dev->bus) 846 || !(controller = bus->controller) 847 || !controller->dma_mask) 848 return -EINVAL; 849 850 /* FIXME generic api broken like pci, can't report errors */ 851 return dma_map_sg(controller, sg, nents, 852 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE) ? : -ENOMEM; 853 } 854 EXPORT_SYMBOL_GPL(usb_buffer_map_sg); 855 #endif 856 857 /* XXX DISABLED, no users currently. If you wish to re-enable this 858 * XXX please determine whether the sync is to transfer ownership of 859 * XXX the buffer from device to cpu or vice verse, and thusly use the 860 * XXX appropriate _for_{cpu,device}() method. -DaveM 861 */ 862 #if 0 863 864 /** 865 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s) 866 * @dev: device to which the scatterlist will be mapped 867 * @is_in: mapping transfer direction 868 * @sg: the scatterlist to synchronize 869 * @n_hw_ents: the positive return value from usb_buffer_map_sg 870 * 871 * Use this when you are re-using a scatterlist's data buffers for 872 * another USB request. 873 */ 874 void usb_buffer_dmasync_sg(const struct usb_device *dev, int is_in, 875 struct scatterlist *sg, int n_hw_ents) 876 { 877 struct usb_bus *bus; 878 struct device *controller; 879 880 if (!dev 881 || !(bus = dev->bus) 882 || !(controller = bus->controller) 883 || !controller->dma_mask) 884 return; 885 886 dma_sync_sg_for_cpu(controller, sg, n_hw_ents, 887 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 888 } 889 EXPORT_SYMBOL_GPL(usb_buffer_dmasync_sg); 890 #endif 891 892 #if 0 893 /** 894 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 895 * @dev: device to which the scatterlist will be mapped 896 * @is_in: mapping transfer direction 897 * @sg: the scatterlist to unmap 898 * @n_hw_ents: the positive return value from usb_buffer_map_sg 899 * 900 * Reverses the effect of usb_buffer_map_sg(). 901 */ 902 void usb_buffer_unmap_sg(const struct usb_device *dev, int is_in, 903 struct scatterlist *sg, int n_hw_ents) 904 { 905 struct usb_bus *bus; 906 struct device *controller; 907 908 if (!dev 909 || !(bus = dev->bus) 910 || !(controller = bus->controller) 911 || !controller->dma_mask) 912 return; 913 914 dma_unmap_sg(controller, sg, n_hw_ents, 915 is_in ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 916 } 917 EXPORT_SYMBOL_GPL(usb_buffer_unmap_sg); 918 #endif 919 920 /* To disable USB, kernel command line is 'nousb' not 'usbcore.nousb' */ 921 #ifdef MODULE 922 module_param(nousb, bool, 0444); 923 #else 924 core_param(nousb, nousb, bool, 0444); 925 #endif 926 927 /* 928 * for external read access to <nousb> 929 */ 930 int usb_disabled(void) 931 { 932 return nousb; 933 } 934 EXPORT_SYMBOL_GPL(usb_disabled); 935 936 /* 937 * Notifications of device and interface registration 938 */ 939 static int usb_bus_notify(struct notifier_block *nb, unsigned long action, 940 void *data) 941 { 942 struct device *dev = data; 943 944 switch (action) { 945 case BUS_NOTIFY_ADD_DEVICE: 946 if (dev->type == &usb_device_type) 947 (void) usb_create_sysfs_dev_files(to_usb_device(dev)); 948 else if (dev->type == &usb_if_device_type) 949 usb_create_sysfs_intf_files(to_usb_interface(dev)); 950 break; 951 952 case BUS_NOTIFY_DEL_DEVICE: 953 if (dev->type == &usb_device_type) 954 usb_remove_sysfs_dev_files(to_usb_device(dev)); 955 else if (dev->type == &usb_if_device_type) 956 usb_remove_sysfs_intf_files(to_usb_interface(dev)); 957 break; 958 } 959 return 0; 960 } 961 962 static struct notifier_block usb_bus_nb = { 963 .notifier_call = usb_bus_notify, 964 }; 965 966 struct dentry *usb_debug_root; 967 EXPORT_SYMBOL_GPL(usb_debug_root); 968 969 static struct dentry *usb_debug_devices; 970 971 static int usb_debugfs_init(void) 972 { 973 usb_debug_root = debugfs_create_dir("usb", NULL); 974 if (!usb_debug_root) 975 return -ENOENT; 976 977 usb_debug_devices = debugfs_create_file("devices", 0444, 978 usb_debug_root, NULL, 979 &usbfs_devices_fops); 980 if (!usb_debug_devices) { 981 debugfs_remove(usb_debug_root); 982 usb_debug_root = NULL; 983 return -ENOENT; 984 } 985 986 return 0; 987 } 988 989 static void usb_debugfs_cleanup(void) 990 { 991 debugfs_remove(usb_debug_devices); 992 debugfs_remove(usb_debug_root); 993 } 994 995 /* 996 * Init 997 */ 998 static int __init usb_init(void) 999 { 1000 int retval; 1001 if (nousb) { 1002 pr_info("%s: USB support disabled\n", usbcore_name); 1003 return 0; 1004 } 1005 1006 retval = usb_debugfs_init(); 1007 if (retval) 1008 goto out; 1009 1010 usb_acpi_register(); 1011 retval = bus_register(&usb_bus_type); 1012 if (retval) 1013 goto bus_register_failed; 1014 retval = bus_register_notifier(&usb_bus_type, &usb_bus_nb); 1015 if (retval) 1016 goto bus_notifier_failed; 1017 retval = usb_major_init(); 1018 if (retval) 1019 goto major_init_failed; 1020 retval = usb_register(&usbfs_driver); 1021 if (retval) 1022 goto driver_register_failed; 1023 retval = usb_devio_init(); 1024 if (retval) 1025 goto usb_devio_init_failed; 1026 retval = usb_hub_init(); 1027 if (retval) 1028 goto hub_init_failed; 1029 retval = usb_register_device_driver(&usb_generic_driver, THIS_MODULE); 1030 if (!retval) 1031 goto out; 1032 1033 usb_hub_cleanup(); 1034 hub_init_failed: 1035 usb_devio_cleanup(); 1036 usb_devio_init_failed: 1037 usb_deregister(&usbfs_driver); 1038 driver_register_failed: 1039 usb_major_cleanup(); 1040 major_init_failed: 1041 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 1042 bus_notifier_failed: 1043 bus_unregister(&usb_bus_type); 1044 bus_register_failed: 1045 usb_acpi_unregister(); 1046 usb_debugfs_cleanup(); 1047 out: 1048 return retval; 1049 } 1050 1051 /* 1052 * Cleanup 1053 */ 1054 static void __exit usb_exit(void) 1055 { 1056 /* This will matter if shutdown/reboot does exitcalls. */ 1057 if (nousb) 1058 return; 1059 1060 usb_deregister_device_driver(&usb_generic_driver); 1061 usb_major_cleanup(); 1062 usb_deregister(&usbfs_driver); 1063 usb_devio_cleanup(); 1064 usb_hub_cleanup(); 1065 bus_unregister_notifier(&usb_bus_type, &usb_bus_nb); 1066 bus_unregister(&usb_bus_type); 1067 usb_acpi_unregister(); 1068 usb_debugfs_cleanup(); 1069 } 1070 1071 subsys_initcall(usb_init); 1072 module_exit(usb_exit); 1073 MODULE_LICENSE("GPL"); 1074