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