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