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