usb.c revision 3b4d7f79164853e10342d707e32307e0c8054982
1/* 2 * drivers/usb/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/config.h> 25 26#ifdef CONFIG_USB_DEBUG 27 #define DEBUG 28#else 29 #undef DEBUG 30#endif 31 32#include <linux/module.h> 33#include <linux/string.h> 34#include <linux/bitops.h> 35#include <linux/slab.h> 36#include <linux/interrupt.h> /* for in_interrupt() */ 37#include <linux/kmod.h> 38#include <linux/init.h> 39#include <linux/spinlock.h> 40#include <linux/errno.h> 41#include <linux/smp_lock.h> 42#include <linux/rwsem.h> 43#include <linux/usb.h> 44 45#include <asm/io.h> 46#include <asm/scatterlist.h> 47#include <linux/mm.h> 48#include <linux/dma-mapping.h> 49 50#include "hcd.h" 51#include "usb.h" 52 53 54const char *usbcore_name = "usbcore"; 55 56static int nousb; /* Disable USB when built into kernel image */ 57 /* Not honored on modular build */ 58 59static DECLARE_RWSEM(usb_all_devices_rwsem); 60 61 62static int generic_probe (struct device *dev) 63{ 64 return 0; 65} 66static int generic_remove (struct device *dev) 67{ 68 struct usb_device *udev = to_usb_device(dev); 69 70 /* if this is only an unbind, not a physical disconnect, then 71 * unconfigure the device */ 72 if (udev->state == USB_STATE_CONFIGURED) 73 usb_set_configuration(udev, 0); 74 75 /* in case the call failed or the device was suspended */ 76 if (udev->state >= USB_STATE_CONFIGURED) 77 usb_disable_device(udev, 0); 78 return 0; 79} 80 81static struct device_driver usb_generic_driver = { 82 .owner = THIS_MODULE, 83 .name = "usb", 84 .bus = &usb_bus_type, 85 .probe = generic_probe, 86 .remove = generic_remove, 87}; 88 89static int usb_generic_driver_data; 90 91/* called from driver core with usb_bus_type.subsys writelock */ 92static int usb_probe_interface(struct device *dev) 93{ 94 struct usb_interface * intf = to_usb_interface(dev); 95 struct usb_driver * driver = to_usb_driver(dev->driver); 96 const struct usb_device_id *id; 97 int error = -ENODEV; 98 99 dev_dbg(dev, "%s\n", __FUNCTION__); 100 101 if (!driver->probe) 102 return error; 103 /* FIXME we'd much prefer to just resume it ... */ 104 if (interface_to_usbdev(intf)->state == USB_STATE_SUSPENDED) 105 return -EHOSTUNREACH; 106 107 id = usb_match_id (intf, driver->id_table); 108 if (id) { 109 dev_dbg (dev, "%s - got id\n", __FUNCTION__); 110 intf->condition = USB_INTERFACE_BINDING; 111 error = driver->probe (intf, id); 112 intf->condition = error ? USB_INTERFACE_UNBOUND : 113 USB_INTERFACE_BOUND; 114 } 115 116 return error; 117} 118 119/* called from driver core with usb_bus_type.subsys writelock */ 120static int usb_unbind_interface(struct device *dev) 121{ 122 struct usb_interface *intf = to_usb_interface(dev); 123 struct usb_driver *driver = to_usb_driver(intf->dev.driver); 124 125 intf->condition = USB_INTERFACE_UNBINDING; 126 127 /* release all urbs for this interface */ 128 usb_disable_interface(interface_to_usbdev(intf), intf); 129 130 if (driver && driver->disconnect) 131 driver->disconnect(intf); 132 133 /* reset other interface state */ 134 usb_set_interface(interface_to_usbdev(intf), 135 intf->altsetting[0].desc.bInterfaceNumber, 136 0); 137 usb_set_intfdata(intf, NULL); 138 intf->condition = USB_INTERFACE_UNBOUND; 139 140 return 0; 141} 142 143/** 144 * usb_register - register a USB driver 145 * @new_driver: USB operations for the driver 146 * 147 * Registers a USB driver with the USB core. The list of unattached 148 * interfaces will be rescanned whenever a new driver is added, allowing 149 * the new driver to attach to any recognized devices. 150 * Returns a negative error code on failure and 0 on success. 151 * 152 * NOTE: if you want your driver to use the USB major number, you must call 153 * usb_register_dev() to enable that functionality. This function no longer 154 * takes care of that. 155 */ 156int usb_register(struct usb_driver *new_driver) 157{ 158 int retval = 0; 159 160 if (nousb) 161 return -ENODEV; 162 163 new_driver->driver.name = (char *)new_driver->name; 164 new_driver->driver.bus = &usb_bus_type; 165 new_driver->driver.probe = usb_probe_interface; 166 new_driver->driver.remove = usb_unbind_interface; 167 new_driver->driver.owner = new_driver->owner; 168 169 usb_lock_all_devices(); 170 retval = driver_register(&new_driver->driver); 171 usb_unlock_all_devices(); 172 173 if (!retval) { 174 pr_info("%s: registered new driver %s\n", 175 usbcore_name, new_driver->name); 176 usbfs_update_special(); 177 } else { 178 printk(KERN_ERR "%s: error %d registering driver %s\n", 179 usbcore_name, retval, new_driver->name); 180 } 181 182 return retval; 183} 184 185/** 186 * usb_deregister - unregister a USB driver 187 * @driver: USB operations of the driver to unregister 188 * Context: must be able to sleep 189 * 190 * Unlinks the specified driver from the internal USB driver list. 191 * 192 * NOTE: If you called usb_register_dev(), you still need to call 193 * usb_deregister_dev() to clean up your driver's allocated minor numbers, 194 * this * call will no longer do it for you. 195 */ 196void usb_deregister(struct usb_driver *driver) 197{ 198 pr_info("%s: deregistering driver %s\n", usbcore_name, driver->name); 199 200 usb_lock_all_devices(); 201 driver_unregister (&driver->driver); 202 usb_unlock_all_devices(); 203 204 usbfs_update_special(); 205} 206 207/** 208 * usb_ifnum_to_if - get the interface object with a given interface number 209 * @dev: the device whose current configuration is considered 210 * @ifnum: the desired interface 211 * 212 * This walks the device descriptor for the currently active configuration 213 * and returns a pointer to the interface with that particular interface 214 * number, or null. 215 * 216 * Note that configuration descriptors are not required to assign interface 217 * numbers sequentially, so that it would be incorrect to assume that 218 * the first interface in that descriptor corresponds to interface zero. 219 * This routine helps device drivers avoid such mistakes. 220 * However, you should make sure that you do the right thing with any 221 * alternate settings available for this interfaces. 222 * 223 * Don't call this function unless you are bound to one of the interfaces 224 * on this device or you have locked the device! 225 */ 226struct usb_interface *usb_ifnum_to_if(struct usb_device *dev, unsigned ifnum) 227{ 228 struct usb_host_config *config = dev->actconfig; 229 int i; 230 231 if (!config) 232 return NULL; 233 for (i = 0; i < config->desc.bNumInterfaces; i++) 234 if (config->interface[i]->altsetting[0] 235 .desc.bInterfaceNumber == ifnum) 236 return config->interface[i]; 237 238 return NULL; 239} 240 241/** 242 * usb_altnum_to_altsetting - get the altsetting structure with a given 243 * alternate setting number. 244 * @intf: the interface containing the altsetting in question 245 * @altnum: the desired alternate setting number 246 * 247 * This searches the altsetting array of the specified interface for 248 * an entry with the correct bAlternateSetting value and returns a pointer 249 * to that entry, or null. 250 * 251 * Note that altsettings need not be stored sequentially by number, so 252 * it would be incorrect to assume that the first altsetting entry in 253 * the array corresponds to altsetting zero. This routine helps device 254 * drivers avoid such mistakes. 255 * 256 * Don't call this function unless you are bound to the intf interface 257 * or you have locked the device! 258 */ 259struct usb_host_interface *usb_altnum_to_altsetting(struct usb_interface *intf, 260 unsigned int altnum) 261{ 262 int i; 263 264 for (i = 0; i < intf->num_altsetting; i++) { 265 if (intf->altsetting[i].desc.bAlternateSetting == altnum) 266 return &intf->altsetting[i]; 267 } 268 return NULL; 269} 270 271/** 272 * usb_driver_claim_interface - bind a driver to an interface 273 * @driver: the driver to be bound 274 * @iface: the interface to which it will be bound; must be in the 275 * usb device's active configuration 276 * @priv: driver data associated with that interface 277 * 278 * This is used by usb device drivers that need to claim more than one 279 * interface on a device when probing (audio and acm are current examples). 280 * No device driver should directly modify internal usb_interface or 281 * usb_device structure members. 282 * 283 * Few drivers should need to use this routine, since the most natural 284 * way to bind to an interface is to return the private data from 285 * the driver's probe() method. 286 * 287 * Callers must own the device lock and the driver model's usb_bus_type.subsys 288 * writelock. So driver probe() entries don't need extra locking, 289 * but other call contexts may need to explicitly claim those locks. 290 */ 291int usb_driver_claim_interface(struct usb_driver *driver, 292 struct usb_interface *iface, void* priv) 293{ 294 struct device *dev = &iface->dev; 295 296 if (dev->driver) 297 return -EBUSY; 298 299 dev->driver = &driver->driver; 300 usb_set_intfdata(iface, priv); 301 iface->condition = USB_INTERFACE_BOUND; 302 303 /* if interface was already added, bind now; else let 304 * the future device_add() bind it, bypassing probe() 305 */ 306 if (klist_node_attached(&dev->knode_bus)) 307 device_bind_driver(dev); 308 309 return 0; 310} 311 312/** 313 * usb_driver_release_interface - unbind a driver from an interface 314 * @driver: the driver to be unbound 315 * @iface: the interface from which it will be unbound 316 * 317 * This can be used by drivers to release an interface without waiting 318 * for their disconnect() methods to be called. In typical cases this 319 * also causes the driver disconnect() method to be called. 320 * 321 * This call is synchronous, and may not be used in an interrupt context. 322 * Callers must own the device lock and the driver model's usb_bus_type.subsys 323 * writelock. So driver disconnect() entries don't need extra locking, 324 * but other call contexts may need to explicitly claim those locks. 325 */ 326void usb_driver_release_interface(struct usb_driver *driver, 327 struct usb_interface *iface) 328{ 329 struct device *dev = &iface->dev; 330 331 /* this should never happen, don't release something that's not ours */ 332 if (!dev->driver || dev->driver != &driver->driver) 333 return; 334 335 /* don't release from within disconnect() */ 336 if (iface->condition != USB_INTERFACE_BOUND) 337 return; 338 339 /* release only after device_add() */ 340 if (klist_node_attached(&dev->knode_bus)) { 341 iface->condition = USB_INTERFACE_UNBINDING; 342 device_release_driver(dev); 343 } 344 345 dev->driver = NULL; 346 usb_set_intfdata(iface, NULL); 347 iface->condition = USB_INTERFACE_UNBOUND; 348} 349 350/** 351 * usb_match_id - find first usb_device_id matching device or interface 352 * @interface: the interface of interest 353 * @id: array of usb_device_id structures, terminated by zero entry 354 * 355 * usb_match_id searches an array of usb_device_id's and returns 356 * the first one matching the device or interface, or null. 357 * This is used when binding (or rebinding) a driver to an interface. 358 * Most USB device drivers will use this indirectly, through the usb core, 359 * but some layered driver frameworks use it directly. 360 * These device tables are exported with MODULE_DEVICE_TABLE, through 361 * modutils and "modules.usbmap", to support the driver loading 362 * functionality of USB hotplugging. 363 * 364 * What Matches: 365 * 366 * The "match_flags" element in a usb_device_id controls which 367 * members are used. If the corresponding bit is set, the 368 * value in the device_id must match its corresponding member 369 * in the device or interface descriptor, or else the device_id 370 * does not match. 371 * 372 * "driver_info" is normally used only by device drivers, 373 * but you can create a wildcard "matches anything" usb_device_id 374 * as a driver's "modules.usbmap" entry if you provide an id with 375 * only a nonzero "driver_info" field. If you do this, the USB device 376 * driver's probe() routine should use additional intelligence to 377 * decide whether to bind to the specified interface. 378 * 379 * What Makes Good usb_device_id Tables: 380 * 381 * The match algorithm is very simple, so that intelligence in 382 * driver selection must come from smart driver id records. 383 * Unless you have good reasons to use another selection policy, 384 * provide match elements only in related groups, and order match 385 * specifiers from specific to general. Use the macros provided 386 * for that purpose if you can. 387 * 388 * The most specific match specifiers use device descriptor 389 * data. These are commonly used with product-specific matches; 390 * the USB_DEVICE macro lets you provide vendor and product IDs, 391 * and you can also match against ranges of product revisions. 392 * These are widely used for devices with application or vendor 393 * specific bDeviceClass values. 394 * 395 * Matches based on device class/subclass/protocol specifications 396 * are slightly more general; use the USB_DEVICE_INFO macro, or 397 * its siblings. These are used with single-function devices 398 * where bDeviceClass doesn't specify that each interface has 399 * its own class. 400 * 401 * Matches based on interface class/subclass/protocol are the 402 * most general; they let drivers bind to any interface on a 403 * multiple-function device. Use the USB_INTERFACE_INFO 404 * macro, or its siblings, to match class-per-interface style 405 * devices (as recorded in bDeviceClass). 406 * 407 * Within those groups, remember that not all combinations are 408 * meaningful. For example, don't give a product version range 409 * without vendor and product IDs; or specify a protocol without 410 * its associated class and subclass. 411 */ 412const struct usb_device_id * 413usb_match_id(struct usb_interface *interface, const struct usb_device_id *id) 414{ 415 struct usb_host_interface *intf; 416 struct usb_device *dev; 417 418 /* proc_connectinfo in devio.c may call us with id == NULL. */ 419 if (id == NULL) 420 return NULL; 421 422 intf = interface->cur_altsetting; 423 dev = interface_to_usbdev(interface); 424 425 /* It is important to check that id->driver_info is nonzero, 426 since an entry that is all zeroes except for a nonzero 427 id->driver_info is the way to create an entry that 428 indicates that the driver want to examine every 429 device and interface. */ 430 for (; id->idVendor || id->bDeviceClass || id->bInterfaceClass || 431 id->driver_info; id++) { 432 433 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && 434 id->idVendor != le16_to_cpu(dev->descriptor.idVendor)) 435 continue; 436 437 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) && 438 id->idProduct != le16_to_cpu(dev->descriptor.idProduct)) 439 continue; 440 441 /* No need to test id->bcdDevice_lo != 0, since 0 is never 442 greater than any unsigned number. */ 443 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) && 444 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice))) 445 continue; 446 447 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) && 448 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice))) 449 continue; 450 451 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) && 452 (id->bDeviceClass != dev->descriptor.bDeviceClass)) 453 continue; 454 455 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) && 456 (id->bDeviceSubClass!= dev->descriptor.bDeviceSubClass)) 457 continue; 458 459 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) && 460 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol)) 461 continue; 462 463 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) && 464 (id->bInterfaceClass != intf->desc.bInterfaceClass)) 465 continue; 466 467 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && 468 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass)) 469 continue; 470 471 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && 472 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol)) 473 continue; 474 475 return id; 476 } 477 478 return NULL; 479} 480 481 482static int __find_interface(struct device * dev, void * data) 483{ 484 struct usb_interface ** ret = (struct usb_interface **)data; 485 struct usb_interface * intf = *ret; 486 int *minor = (int *)data; 487 488 /* can't look at usb devices, only interfaces */ 489 if (dev->driver == &usb_generic_driver) 490 return 0; 491 492 intf = to_usb_interface(dev); 493 if (intf->minor != -1 && intf->minor == *minor) { 494 *ret = intf; 495 return 1; 496 } 497 return 0; 498} 499 500/** 501 * usb_find_interface - find usb_interface pointer for driver and device 502 * @drv: the driver whose current configuration is considered 503 * @minor: the minor number of the desired device 504 * 505 * This walks the driver device list and returns a pointer to the interface 506 * with the matching minor. Note, this only works for devices that share the 507 * USB major number. 508 */ 509struct usb_interface *usb_find_interface(struct usb_driver *drv, int minor) 510{ 511 struct usb_interface *intf = (struct usb_interface *)(long)minor; 512 int ret; 513 514 ret = driver_for_each_device(&drv->driver, NULL, &intf, __find_interface); 515 516 return ret ? intf : NULL; 517} 518 519static int usb_device_match (struct device *dev, struct device_driver *drv) 520{ 521 struct usb_interface *intf; 522 struct usb_driver *usb_drv; 523 const struct usb_device_id *id; 524 525 /* check for generic driver, which we don't match any device with */ 526 if (drv == &usb_generic_driver) 527 return 0; 528 529 intf = to_usb_interface(dev); 530 usb_drv = to_usb_driver(drv); 531 532 id = usb_match_id (intf, usb_drv->id_table); 533 if (id) 534 return 1; 535 536 return 0; 537} 538 539 540#ifdef CONFIG_HOTPLUG 541 542/* 543 * USB hotplugging invokes what /proc/sys/kernel/hotplug says 544 * (normally /sbin/hotplug) when USB devices get added or removed. 545 * 546 * This invokes a user mode policy agent, typically helping to load driver 547 * or other modules, configure the device, and more. Drivers can provide 548 * a MODULE_DEVICE_TABLE to help with module loading subtasks. 549 * 550 * We're called either from khubd (the typical case) or from root hub 551 * (init, kapmd, modprobe, rmmod, etc), but the agents need to handle 552 * delays in event delivery. Use sysfs (and DEVPATH) to make sure the 553 * device (and this configuration!) are still present. 554 */ 555static int usb_hotplug (struct device *dev, char **envp, int num_envp, 556 char *buffer, int buffer_size) 557{ 558 struct usb_interface *intf; 559 struct usb_device *usb_dev; 560 int i = 0; 561 int length = 0; 562 563 if (!dev) 564 return -ENODEV; 565 566 /* driver is often null here; dev_dbg() would oops */ 567 pr_debug ("usb %s: hotplug\n", dev->bus_id); 568 569 /* Must check driver_data here, as on remove driver is always NULL */ 570 if ((dev->driver == &usb_generic_driver) || 571 (dev->driver_data == &usb_generic_driver_data)) 572 return 0; 573 574 intf = to_usb_interface(dev); 575 usb_dev = interface_to_usbdev (intf); 576 577 if (usb_dev->devnum < 0) { 578 pr_debug ("usb %s: already deleted?\n", dev->bus_id); 579 return -ENODEV; 580 } 581 if (!usb_dev->bus) { 582 pr_debug ("usb %s: bus removed?\n", dev->bus_id); 583 return -ENODEV; 584 } 585 586#ifdef CONFIG_USB_DEVICEFS 587 /* If this is available, userspace programs can directly read 588 * all the device descriptors we don't tell them about. Or 589 * even act as usermode drivers. 590 * 591 * FIXME reduce hardwired intelligence here 592 */ 593 if (add_hotplug_env_var(envp, num_envp, &i, 594 buffer, buffer_size, &length, 595 "DEVICE=/proc/bus/usb/%03d/%03d", 596 usb_dev->bus->busnum, usb_dev->devnum)) 597 return -ENOMEM; 598#endif 599 600 /* per-device configurations are common */ 601 if (add_hotplug_env_var(envp, num_envp, &i, 602 buffer, buffer_size, &length, 603 "PRODUCT=%x/%x/%x", 604 le16_to_cpu(usb_dev->descriptor.idVendor), 605 le16_to_cpu(usb_dev->descriptor.idProduct), 606 le16_to_cpu(usb_dev->descriptor.bcdDevice))) 607 return -ENOMEM; 608 609 /* class-based driver binding models */ 610 if (add_hotplug_env_var(envp, num_envp, &i, 611 buffer, buffer_size, &length, 612 "TYPE=%d/%d/%d", 613 usb_dev->descriptor.bDeviceClass, 614 usb_dev->descriptor.bDeviceSubClass, 615 usb_dev->descriptor.bDeviceProtocol)) 616 return -ENOMEM; 617 618 if (usb_dev->descriptor.bDeviceClass == 0) { 619 struct usb_host_interface *alt = intf->cur_altsetting; 620 621 /* 2.4 only exposed interface zero. in 2.5, hotplug 622 * agents are called for all interfaces, and can use 623 * $DEVPATH/bInterfaceNumber if necessary. 624 */ 625 if (add_hotplug_env_var(envp, num_envp, &i, 626 buffer, buffer_size, &length, 627 "INTERFACE=%d/%d/%d", 628 alt->desc.bInterfaceClass, 629 alt->desc.bInterfaceSubClass, 630 alt->desc.bInterfaceProtocol)) 631 return -ENOMEM; 632 633 if (add_hotplug_env_var(envp, num_envp, &i, 634 buffer, buffer_size, &length, 635 "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic%02Xisc%02Xip%02X", 636 le16_to_cpu(usb_dev->descriptor.idVendor), 637 le16_to_cpu(usb_dev->descriptor.idProduct), 638 le16_to_cpu(usb_dev->descriptor.bcdDevice), 639 usb_dev->descriptor.bDeviceClass, 640 usb_dev->descriptor.bDeviceSubClass, 641 usb_dev->descriptor.bDeviceProtocol, 642 alt->desc.bInterfaceClass, 643 alt->desc.bInterfaceSubClass, 644 alt->desc.bInterfaceProtocol)) 645 return -ENOMEM; 646 } else { 647 if (add_hotplug_env_var(envp, num_envp, &i, 648 buffer, buffer_size, &length, 649 "MODALIAS=usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02Xic*isc*ip*", 650 le16_to_cpu(usb_dev->descriptor.idVendor), 651 le16_to_cpu(usb_dev->descriptor.idProduct), 652 le16_to_cpu(usb_dev->descriptor.bcdDevice), 653 usb_dev->descriptor.bDeviceClass, 654 usb_dev->descriptor.bDeviceSubClass, 655 usb_dev->descriptor.bDeviceProtocol)) 656 return -ENOMEM; 657 } 658 659 envp[i] = NULL; 660 661 return 0; 662} 663 664#else 665 666static int usb_hotplug (struct device *dev, char **envp, 667 int num_envp, char *buffer, int buffer_size) 668{ 669 return -ENODEV; 670} 671 672#endif /* CONFIG_HOTPLUG */ 673 674/** 675 * usb_release_dev - free a usb device structure when all users of it are finished. 676 * @dev: device that's been disconnected 677 * 678 * Will be called only by the device core when all users of this usb device are 679 * done. 680 */ 681static void usb_release_dev(struct device *dev) 682{ 683 struct usb_device *udev; 684 685 udev = to_usb_device(dev); 686 687 usb_destroy_configuration(udev); 688 usb_bus_put(udev->bus); 689 kfree(udev->product); 690 kfree(udev->manufacturer); 691 kfree(udev->serial); 692 kfree(udev); 693} 694 695/** 696 * usb_alloc_dev - usb device constructor (usbcore-internal) 697 * @parent: hub to which device is connected; null to allocate a root hub 698 * @bus: bus used to access the device 699 * @port1: one-based index of port; ignored for root hubs 700 * Context: !in_interrupt () 701 * 702 * Only hub drivers (including virtual root hub drivers for host 703 * controllers) should ever call this. 704 * 705 * This call may not be used in a non-sleeping context. 706 */ 707struct usb_device * 708usb_alloc_dev(struct usb_device *parent, struct usb_bus *bus, unsigned port1) 709{ 710 struct usb_device *dev; 711 712 dev = kmalloc(sizeof(*dev), GFP_KERNEL); 713 if (!dev) 714 return NULL; 715 716 memset(dev, 0, sizeof(*dev)); 717 718 bus = usb_bus_get(bus); 719 if (!bus) { 720 kfree(dev); 721 return NULL; 722 } 723 724 device_initialize(&dev->dev); 725 dev->dev.bus = &usb_bus_type; 726 dev->dev.dma_mask = bus->controller->dma_mask; 727 dev->dev.driver_data = &usb_generic_driver_data; 728 dev->dev.driver = &usb_generic_driver; 729 dev->dev.release = usb_release_dev; 730 dev->state = USB_STATE_ATTACHED; 731 732 INIT_LIST_HEAD(&dev->ep0.urb_list); 733 dev->ep0.desc.bLength = USB_DT_ENDPOINT_SIZE; 734 dev->ep0.desc.bDescriptorType = USB_DT_ENDPOINT; 735 /* ep0 maxpacket comes later, from device descriptor */ 736 dev->ep_in[0] = dev->ep_out[0] = &dev->ep0; 737 738 /* Save readable and stable topology id, distinguishing devices 739 * by location for diagnostics, tools, driver model, etc. The 740 * string is a path along hub ports, from the root. Each device's 741 * dev->devpath will be stable until USB is re-cabled, and hubs 742 * are often labeled with these port numbers. The bus_id isn't 743 * as stable: bus->busnum changes easily from modprobe order, 744 * cardbus or pci hotplugging, and so on. 745 */ 746 if (unlikely (!parent)) { 747 dev->devpath [0] = '0'; 748 749 dev->dev.parent = bus->controller; 750 sprintf (&dev->dev.bus_id[0], "usb%d", bus->busnum); 751 } else { 752 /* match any labeling on the hubs; it's one-based */ 753 if (parent->devpath [0] == '0') 754 snprintf (dev->devpath, sizeof dev->devpath, 755 "%d", port1); 756 else 757 snprintf (dev->devpath, sizeof dev->devpath, 758 "%s.%d", parent->devpath, port1); 759 760 dev->dev.parent = &parent->dev; 761 sprintf (&dev->dev.bus_id[0], "%d-%s", 762 bus->busnum, dev->devpath); 763 764 /* hub driver sets up TT records */ 765 } 766 767 dev->bus = bus; 768 dev->parent = parent; 769 INIT_LIST_HEAD(&dev->filelist); 770 771 init_MUTEX(&dev->serialize); 772 773 return dev; 774} 775 776/** 777 * usb_get_dev - increments the reference count of the usb device structure 778 * @dev: the device being referenced 779 * 780 * Each live reference to a device should be refcounted. 781 * 782 * Drivers for USB interfaces should normally record such references in 783 * their probe() methods, when they bind to an interface, and release 784 * them by calling usb_put_dev(), in their disconnect() methods. 785 * 786 * A pointer to the device with the incremented reference counter is returned. 787 */ 788struct usb_device *usb_get_dev(struct usb_device *dev) 789{ 790 if (dev) 791 get_device(&dev->dev); 792 return dev; 793} 794 795/** 796 * usb_put_dev - release a use of the usb device structure 797 * @dev: device that's been disconnected 798 * 799 * Must be called when a user of a device is finished with it. When the last 800 * user of the device calls this function, the memory of the device is freed. 801 */ 802void usb_put_dev(struct usb_device *dev) 803{ 804 if (dev) 805 put_device(&dev->dev); 806} 807 808/** 809 * usb_get_intf - increments the reference count of the usb interface structure 810 * @intf: the interface being referenced 811 * 812 * Each live reference to a interface must be refcounted. 813 * 814 * Drivers for USB interfaces should normally record such references in 815 * their probe() methods, when they bind to an interface, and release 816 * them by calling usb_put_intf(), in their disconnect() methods. 817 * 818 * A pointer to the interface with the incremented reference counter is 819 * returned. 820 */ 821struct usb_interface *usb_get_intf(struct usb_interface *intf) 822{ 823 if (intf) 824 get_device(&intf->dev); 825 return intf; 826} 827 828/** 829 * usb_put_intf - release a use of the usb interface structure 830 * @intf: interface that's been decremented 831 * 832 * Must be called when a user of an interface is finished with it. When the 833 * last user of the interface calls this function, the memory of the interface 834 * is freed. 835 */ 836void usb_put_intf(struct usb_interface *intf) 837{ 838 if (intf) 839 put_device(&intf->dev); 840} 841 842 843/* USB device locking 844 * 845 * Although locking USB devices should be straightforward, it is 846 * complicated by the way the driver-model core works. When a new USB 847 * driver is registered or unregistered, the core will automatically 848 * probe or disconnect all matching interfaces on all USB devices while 849 * holding the USB subsystem writelock. There's no good way for us to 850 * tell which devices will be used or to lock them beforehand; our only 851 * option is to effectively lock all the USB devices. 852 * 853 * We do that by using a private rw-semaphore, usb_all_devices_rwsem. 854 * When locking an individual device you must first acquire the rwsem's 855 * readlock. When a driver is registered or unregistered the writelock 856 * must be held. These actions are encapsulated in the subroutines 857 * below, so all a driver needs to do is call usb_lock_device() and 858 * usb_unlock_device(). 859 * 860 * Complications arise when several devices are to be locked at the same 861 * time. Only hub-aware drivers that are part of usbcore ever have to 862 * do this; nobody else needs to worry about it. The problem is that 863 * usb_lock_device() must not be called to lock a second device since it 864 * would acquire the rwsem's readlock reentrantly, leading to deadlock if 865 * another thread was waiting for the writelock. The solution is simple: 866 * 867 * When locking more than one device, call usb_lock_device() 868 * to lock the first one. Lock the others by calling 869 * down(&udev->serialize) directly. 870 * 871 * When unlocking multiple devices, use up(&udev->serialize) 872 * to unlock all but the last one. Unlock the last one by 873 * calling usb_unlock_device(). 874 * 875 * When locking both a device and its parent, always lock the 876 * the parent first. 877 */ 878 879/** 880 * usb_lock_device - acquire the lock for a usb device structure 881 * @udev: device that's being locked 882 * 883 * Use this routine when you don't hold any other device locks; 884 * to acquire nested inner locks call down(&udev->serialize) directly. 885 * This is necessary for proper interaction with usb_lock_all_devices(). 886 */ 887void usb_lock_device(struct usb_device *udev) 888{ 889 down_read(&usb_all_devices_rwsem); 890 down(&udev->serialize); 891} 892 893/** 894 * usb_trylock_device - attempt to acquire the lock for a usb device structure 895 * @udev: device that's being locked 896 * 897 * Don't use this routine if you already hold a device lock; 898 * use down_trylock(&udev->serialize) instead. 899 * This is necessary for proper interaction with usb_lock_all_devices(). 900 * 901 * Returns 1 if successful, 0 if contention. 902 */ 903int usb_trylock_device(struct usb_device *udev) 904{ 905 if (!down_read_trylock(&usb_all_devices_rwsem)) 906 return 0; 907 if (down_trylock(&udev->serialize)) { 908 up_read(&usb_all_devices_rwsem); 909 return 0; 910 } 911 return 1; 912} 913 914/** 915 * usb_lock_device_for_reset - cautiously acquire the lock for a 916 * usb device structure 917 * @udev: device that's being locked 918 * @iface: interface bound to the driver making the request (optional) 919 * 920 * Attempts to acquire the device lock, but fails if the device is 921 * NOTATTACHED or SUSPENDED, or if iface is specified and the interface 922 * is neither BINDING nor BOUND. Rather than sleeping to wait for the 923 * lock, the routine polls repeatedly. This is to prevent deadlock with 924 * disconnect; in some drivers (such as usb-storage) the disconnect() 925 * or suspend() method will block waiting for a device reset to complete. 926 * 927 * Returns a negative error code for failure, otherwise 1 or 0 to indicate 928 * that the device will or will not have to be unlocked. (0 can be 929 * returned when an interface is given and is BINDING, because in that 930 * case the driver already owns the device lock.) 931 */ 932int usb_lock_device_for_reset(struct usb_device *udev, 933 struct usb_interface *iface) 934{ 935 unsigned long jiffies_expire = jiffies + HZ; 936 937 if (udev->state == USB_STATE_NOTATTACHED) 938 return -ENODEV; 939 if (udev->state == USB_STATE_SUSPENDED) 940 return -EHOSTUNREACH; 941 if (iface) { 942 switch (iface->condition) { 943 case USB_INTERFACE_BINDING: 944 return 0; 945 case USB_INTERFACE_BOUND: 946 break; 947 default: 948 return -EINTR; 949 } 950 } 951 952 while (!usb_trylock_device(udev)) { 953 954 /* If we can't acquire the lock after waiting one second, 955 * we're probably deadlocked */ 956 if (time_after(jiffies, jiffies_expire)) 957 return -EBUSY; 958 959 msleep(15); 960 if (udev->state == USB_STATE_NOTATTACHED) 961 return -ENODEV; 962 if (udev->state == USB_STATE_SUSPENDED) 963 return -EHOSTUNREACH; 964 if (iface && iface->condition != USB_INTERFACE_BOUND) 965 return -EINTR; 966 } 967 return 1; 968} 969 970/** 971 * usb_unlock_device - release the lock for a usb device structure 972 * @udev: device that's being unlocked 973 * 974 * Use this routine when releasing the only device lock you hold; 975 * to release inner nested locks call up(&udev->serialize) directly. 976 * This is necessary for proper interaction with usb_lock_all_devices(). 977 */ 978void usb_unlock_device(struct usb_device *udev) 979{ 980 up(&udev->serialize); 981 up_read(&usb_all_devices_rwsem); 982} 983 984/** 985 * usb_lock_all_devices - acquire the lock for all usb device structures 986 * 987 * This is necessary when registering a new driver or probing a bus, 988 * since the driver-model core may try to use any usb_device. 989 */ 990void usb_lock_all_devices(void) 991{ 992 down_write(&usb_all_devices_rwsem); 993} 994 995/** 996 * usb_unlock_all_devices - release the lock for all usb device structures 997 */ 998void usb_unlock_all_devices(void) 999{ 1000 up_write(&usb_all_devices_rwsem); 1001} 1002 1003 1004static struct usb_device *match_device(struct usb_device *dev, 1005 u16 vendor_id, u16 product_id) 1006{ 1007 struct usb_device *ret_dev = NULL; 1008 int child; 1009 1010 dev_dbg(&dev->dev, "check for vendor %04x, product %04x ...\n", 1011 le16_to_cpu(dev->descriptor.idVendor), 1012 le16_to_cpu(dev->descriptor.idProduct)); 1013 1014 /* see if this device matches */ 1015 if ((vendor_id == le16_to_cpu(dev->descriptor.idVendor)) && 1016 (product_id == le16_to_cpu(dev->descriptor.idProduct))) { 1017 dev_dbg (&dev->dev, "matched this device!\n"); 1018 ret_dev = usb_get_dev(dev); 1019 goto exit; 1020 } 1021 1022 /* look through all of the children of this device */ 1023 for (child = 0; child < dev->maxchild; ++child) { 1024 if (dev->children[child]) { 1025 down(&dev->children[child]->serialize); 1026 ret_dev = match_device(dev->children[child], 1027 vendor_id, product_id); 1028 up(&dev->children[child]->serialize); 1029 if (ret_dev) 1030 goto exit; 1031 } 1032 } 1033exit: 1034 return ret_dev; 1035} 1036 1037/** 1038 * usb_find_device - find a specific usb device in the system 1039 * @vendor_id: the vendor id of the device to find 1040 * @product_id: the product id of the device to find 1041 * 1042 * Returns a pointer to a struct usb_device if such a specified usb 1043 * device is present in the system currently. The usage count of the 1044 * device will be incremented if a device is found. Make sure to call 1045 * usb_put_dev() when the caller is finished with the device. 1046 * 1047 * If a device with the specified vendor and product id is not found, 1048 * NULL is returned. 1049 */ 1050struct usb_device *usb_find_device(u16 vendor_id, u16 product_id) 1051{ 1052 struct list_head *buslist; 1053 struct usb_bus *bus; 1054 struct usb_device *dev = NULL; 1055 1056 down(&usb_bus_list_lock); 1057 for (buslist = usb_bus_list.next; 1058 buslist != &usb_bus_list; 1059 buslist = buslist->next) { 1060 bus = container_of(buslist, struct usb_bus, bus_list); 1061 if (!bus->root_hub) 1062 continue; 1063 usb_lock_device(bus->root_hub); 1064 dev = match_device(bus->root_hub, vendor_id, product_id); 1065 usb_unlock_device(bus->root_hub); 1066 if (dev) 1067 goto exit; 1068 } 1069exit: 1070 up(&usb_bus_list_lock); 1071 return dev; 1072} 1073 1074/** 1075 * usb_get_current_frame_number - return current bus frame number 1076 * @dev: the device whose bus is being queried 1077 * 1078 * Returns the current frame number for the USB host controller 1079 * used with the given USB device. This can be used when scheduling 1080 * isochronous requests. 1081 * 1082 * Note that different kinds of host controller have different 1083 * "scheduling horizons". While one type might support scheduling only 1084 * 32 frames into the future, others could support scheduling up to 1085 * 1024 frames into the future. 1086 */ 1087int usb_get_current_frame_number(struct usb_device *dev) 1088{ 1089 return dev->bus->op->get_frame_number (dev); 1090} 1091 1092/*-------------------------------------------------------------------*/ 1093/* 1094 * __usb_get_extra_descriptor() finds a descriptor of specific type in the 1095 * extra field of the interface and endpoint descriptor structs. 1096 */ 1097 1098int __usb_get_extra_descriptor(char *buffer, unsigned size, 1099 unsigned char type, void **ptr) 1100{ 1101 struct usb_descriptor_header *header; 1102 1103 while (size >= sizeof(struct usb_descriptor_header)) { 1104 header = (struct usb_descriptor_header *)buffer; 1105 1106 if (header->bLength < 2) { 1107 printk(KERN_ERR 1108 "%s: bogus descriptor, type %d length %d\n", 1109 usbcore_name, 1110 header->bDescriptorType, 1111 header->bLength); 1112 return -1; 1113 } 1114 1115 if (header->bDescriptorType == type) { 1116 *ptr = header; 1117 return 0; 1118 } 1119 1120 buffer += header->bLength; 1121 size -= header->bLength; 1122 } 1123 return -1; 1124} 1125 1126/** 1127 * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP 1128 * @dev: device the buffer will be used with 1129 * @size: requested buffer size 1130 * @mem_flags: affect whether allocation may block 1131 * @dma: used to return DMA address of buffer 1132 * 1133 * Return value is either null (indicating no buffer could be allocated), or 1134 * the cpu-space pointer to a buffer that may be used to perform DMA to the 1135 * specified device. Such cpu-space buffers are returned along with the DMA 1136 * address (through the pointer provided). 1137 * 1138 * These buffers are used with URB_NO_xxx_DMA_MAP set in urb->transfer_flags 1139 * to avoid behaviors like using "DMA bounce buffers", or tying down I/O 1140 * mapping hardware for long idle periods. The implementation varies between 1141 * platforms, depending on details of how DMA will work to this device. 1142 * Using these buffers also helps prevent cacheline sharing problems on 1143 * architectures where CPU caches are not DMA-coherent. 1144 * 1145 * When the buffer is no longer used, free it with usb_buffer_free(). 1146 */ 1147void *usb_buffer_alloc ( 1148 struct usb_device *dev, 1149 size_t size, 1150 unsigned mem_flags, 1151 dma_addr_t *dma 1152) 1153{ 1154 if (!dev || !dev->bus || !dev->bus->op || !dev->bus->op->buffer_alloc) 1155 return NULL; 1156 return dev->bus->op->buffer_alloc (dev->bus, size, mem_flags, dma); 1157} 1158 1159/** 1160 * usb_buffer_free - free memory allocated with usb_buffer_alloc() 1161 * @dev: device the buffer was used with 1162 * @size: requested buffer size 1163 * @addr: CPU address of buffer 1164 * @dma: DMA address of buffer 1165 * 1166 * This reclaims an I/O buffer, letting it be reused. The memory must have 1167 * been allocated using usb_buffer_alloc(), and the parameters must match 1168 * those provided in that allocation request. 1169 */ 1170void usb_buffer_free ( 1171 struct usb_device *dev, 1172 size_t size, 1173 void *addr, 1174 dma_addr_t dma 1175) 1176{ 1177 if (!dev || !dev->bus || !dev->bus->op || !dev->bus->op->buffer_free) 1178 return; 1179 dev->bus->op->buffer_free (dev->bus, size, addr, dma); 1180} 1181 1182/** 1183 * usb_buffer_map - create DMA mapping(s) for an urb 1184 * @urb: urb whose transfer_buffer/setup_packet will be mapped 1185 * 1186 * Return value is either null (indicating no buffer could be mapped), or 1187 * the parameter. URB_NO_TRANSFER_DMA_MAP and URB_NO_SETUP_DMA_MAP are 1188 * added to urb->transfer_flags if the operation succeeds. If the device 1189 * is connected to this system through a non-DMA controller, this operation 1190 * always succeeds. 1191 * 1192 * This call would normally be used for an urb which is reused, perhaps 1193 * as the target of a large periodic transfer, with usb_buffer_dmasync() 1194 * calls to synchronize memory and dma state. 1195 * 1196 * Reverse the effect of this call with usb_buffer_unmap(). 1197 */ 1198#if 0 1199struct urb *usb_buffer_map (struct urb *urb) 1200{ 1201 struct usb_bus *bus; 1202 struct device *controller; 1203 1204 if (!urb 1205 || !urb->dev 1206 || !(bus = urb->dev->bus) 1207 || !(controller = bus->controller)) 1208 return NULL; 1209 1210 if (controller->dma_mask) { 1211 urb->transfer_dma = dma_map_single (controller, 1212 urb->transfer_buffer, urb->transfer_buffer_length, 1213 usb_pipein (urb->pipe) 1214 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1215 if (usb_pipecontrol (urb->pipe)) 1216 urb->setup_dma = dma_map_single (controller, 1217 urb->setup_packet, 1218 sizeof (struct usb_ctrlrequest), 1219 DMA_TO_DEVICE); 1220 // FIXME generic api broken like pci, can't report errors 1221 // if (urb->transfer_dma == DMA_ADDR_INVALID) return 0; 1222 } else 1223 urb->transfer_dma = ~0; 1224 urb->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP 1225 | URB_NO_SETUP_DMA_MAP); 1226 return urb; 1227} 1228#endif /* 0 */ 1229 1230/* XXX DISABLED, no users currently. If you wish to re-enable this 1231 * XXX please determine whether the sync is to transfer ownership of 1232 * XXX the buffer from device to cpu or vice verse, and thusly use the 1233 * XXX appropriate _for_{cpu,device}() method. -DaveM 1234 */ 1235#if 0 1236 1237/** 1238 * usb_buffer_dmasync - synchronize DMA and CPU view of buffer(s) 1239 * @urb: urb whose transfer_buffer/setup_packet will be synchronized 1240 */ 1241void usb_buffer_dmasync (struct urb *urb) 1242{ 1243 struct usb_bus *bus; 1244 struct device *controller; 1245 1246 if (!urb 1247 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 1248 || !urb->dev 1249 || !(bus = urb->dev->bus) 1250 || !(controller = bus->controller)) 1251 return; 1252 1253 if (controller->dma_mask) { 1254 dma_sync_single (controller, 1255 urb->transfer_dma, urb->transfer_buffer_length, 1256 usb_pipein (urb->pipe) 1257 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1258 if (usb_pipecontrol (urb->pipe)) 1259 dma_sync_single (controller, 1260 urb->setup_dma, 1261 sizeof (struct usb_ctrlrequest), 1262 DMA_TO_DEVICE); 1263 } 1264} 1265#endif 1266 1267/** 1268 * usb_buffer_unmap - free DMA mapping(s) for an urb 1269 * @urb: urb whose transfer_buffer will be unmapped 1270 * 1271 * Reverses the effect of usb_buffer_map(). 1272 */ 1273#if 0 1274void usb_buffer_unmap (struct urb *urb) 1275{ 1276 struct usb_bus *bus; 1277 struct device *controller; 1278 1279 if (!urb 1280 || !(urb->transfer_flags & URB_NO_TRANSFER_DMA_MAP) 1281 || !urb->dev 1282 || !(bus = urb->dev->bus) 1283 || !(controller = bus->controller)) 1284 return; 1285 1286 if (controller->dma_mask) { 1287 dma_unmap_single (controller, 1288 urb->transfer_dma, urb->transfer_buffer_length, 1289 usb_pipein (urb->pipe) 1290 ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1291 if (usb_pipecontrol (urb->pipe)) 1292 dma_unmap_single (controller, 1293 urb->setup_dma, 1294 sizeof (struct usb_ctrlrequest), 1295 DMA_TO_DEVICE); 1296 } 1297 urb->transfer_flags &= ~(URB_NO_TRANSFER_DMA_MAP 1298 | URB_NO_SETUP_DMA_MAP); 1299} 1300#endif /* 0 */ 1301 1302/** 1303 * usb_buffer_map_sg - create scatterlist DMA mapping(s) for an endpoint 1304 * @dev: device to which the scatterlist will be mapped 1305 * @pipe: endpoint defining the mapping direction 1306 * @sg: the scatterlist to map 1307 * @nents: the number of entries in the scatterlist 1308 * 1309 * Return value is either < 0 (indicating no buffers could be mapped), or 1310 * the number of DMA mapping array entries in the scatterlist. 1311 * 1312 * The caller is responsible for placing the resulting DMA addresses from 1313 * the scatterlist into URB transfer buffer pointers, and for setting the 1314 * URB_NO_TRANSFER_DMA_MAP transfer flag in each of those URBs. 1315 * 1316 * Top I/O rates come from queuing URBs, instead of waiting for each one 1317 * to complete before starting the next I/O. This is particularly easy 1318 * to do with scatterlists. Just allocate and submit one URB for each DMA 1319 * mapping entry returned, stopping on the first error or when all succeed. 1320 * Better yet, use the usb_sg_*() calls, which do that (and more) for you. 1321 * 1322 * This call would normally be used when translating scatterlist requests, 1323 * rather than usb_buffer_map(), since on some hardware (with IOMMUs) it 1324 * may be able to coalesce mappings for improved I/O efficiency. 1325 * 1326 * Reverse the effect of this call with usb_buffer_unmap_sg(). 1327 */ 1328int usb_buffer_map_sg (struct usb_device *dev, unsigned pipe, 1329 struct scatterlist *sg, int nents) 1330{ 1331 struct usb_bus *bus; 1332 struct device *controller; 1333 1334 if (!dev 1335 || usb_pipecontrol (pipe) 1336 || !(bus = dev->bus) 1337 || !(controller = bus->controller) 1338 || !controller->dma_mask) 1339 return -1; 1340 1341 // FIXME generic api broken like pci, can't report errors 1342 return dma_map_sg (controller, sg, nents, 1343 usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1344} 1345 1346/* XXX DISABLED, no users currently. If you wish to re-enable this 1347 * XXX please determine whether the sync is to transfer ownership of 1348 * XXX the buffer from device to cpu or vice verse, and thusly use the 1349 * XXX appropriate _for_{cpu,device}() method. -DaveM 1350 */ 1351#if 0 1352 1353/** 1354 * usb_buffer_dmasync_sg - synchronize DMA and CPU view of scatterlist buffer(s) 1355 * @dev: device to which the scatterlist will be mapped 1356 * @pipe: endpoint defining the mapping direction 1357 * @sg: the scatterlist to synchronize 1358 * @n_hw_ents: the positive return value from usb_buffer_map_sg 1359 * 1360 * Use this when you are re-using a scatterlist's data buffers for 1361 * another USB request. 1362 */ 1363void usb_buffer_dmasync_sg (struct usb_device *dev, unsigned pipe, 1364 struct scatterlist *sg, int n_hw_ents) 1365{ 1366 struct usb_bus *bus; 1367 struct device *controller; 1368 1369 if (!dev 1370 || !(bus = dev->bus) 1371 || !(controller = bus->controller) 1372 || !controller->dma_mask) 1373 return; 1374 1375 dma_sync_sg (controller, sg, n_hw_ents, 1376 usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1377} 1378#endif 1379 1380/** 1381 * usb_buffer_unmap_sg - free DMA mapping(s) for a scatterlist 1382 * @dev: device to which the scatterlist will be mapped 1383 * @pipe: endpoint defining the mapping direction 1384 * @sg: the scatterlist to unmap 1385 * @n_hw_ents: the positive return value from usb_buffer_map_sg 1386 * 1387 * Reverses the effect of usb_buffer_map_sg(). 1388 */ 1389void usb_buffer_unmap_sg (struct usb_device *dev, unsigned pipe, 1390 struct scatterlist *sg, int n_hw_ents) 1391{ 1392 struct usb_bus *bus; 1393 struct device *controller; 1394 1395 if (!dev 1396 || !(bus = dev->bus) 1397 || !(controller = bus->controller) 1398 || !controller->dma_mask) 1399 return; 1400 1401 dma_unmap_sg (controller, sg, n_hw_ents, 1402 usb_pipein (pipe) ? DMA_FROM_DEVICE : DMA_TO_DEVICE); 1403} 1404 1405static int usb_generic_suspend(struct device *dev, pm_message_t message) 1406{ 1407 struct usb_interface *intf; 1408 struct usb_driver *driver; 1409 1410 if (dev->driver == &usb_generic_driver) 1411 return usb_suspend_device (to_usb_device(dev), message); 1412 1413 if ((dev->driver == NULL) || 1414 (dev->driver_data == &usb_generic_driver_data)) 1415 return 0; 1416 1417 intf = to_usb_interface(dev); 1418 driver = to_usb_driver(dev->driver); 1419 1420 /* there's only one USB suspend state */ 1421 if (intf->dev.power.power_state.event) 1422 return 0; 1423 1424 if (driver->suspend) 1425 return driver->suspend(intf, message); 1426 return 0; 1427} 1428 1429static int usb_generic_resume(struct device *dev) 1430{ 1431 struct usb_interface *intf; 1432 struct usb_driver *driver; 1433 1434 /* devices resume through their hub */ 1435 if (dev->driver == &usb_generic_driver) 1436 return usb_resume_device (to_usb_device(dev)); 1437 1438 if ((dev->driver == NULL) || 1439 (dev->driver_data == &usb_generic_driver_data)) 1440 return 0; 1441 1442 intf = to_usb_interface(dev); 1443 driver = to_usb_driver(dev->driver); 1444 1445 if (driver->resume) 1446 return driver->resume(intf); 1447 return 0; 1448} 1449 1450struct bus_type usb_bus_type = { 1451 .name = "usb", 1452 .match = usb_device_match, 1453 .hotplug = usb_hotplug, 1454 .suspend = usb_generic_suspend, 1455 .resume = usb_generic_resume, 1456}; 1457 1458#ifndef MODULE 1459 1460static int __init usb_setup_disable(char *str) 1461{ 1462 nousb = 1; 1463 return 1; 1464} 1465 1466/* format to disable USB on kernel command line is: nousb */ 1467__setup("nousb", usb_setup_disable); 1468 1469#endif 1470 1471/* 1472 * for external read access to <nousb> 1473 */ 1474int usb_disabled(void) 1475{ 1476 return nousb; 1477} 1478 1479/* 1480 * Init 1481 */ 1482static int __init usb_init(void) 1483{ 1484 int retval; 1485 if (nousb) { 1486 pr_info ("%s: USB support disabled\n", usbcore_name); 1487 return 0; 1488 } 1489 1490 retval = bus_register(&usb_bus_type); 1491 if (retval) 1492 goto out; 1493 retval = usb_host_init(); 1494 if (retval) 1495 goto host_init_failed; 1496 retval = usb_major_init(); 1497 if (retval) 1498 goto major_init_failed; 1499 retval = usb_register(&usbfs_driver); 1500 if (retval) 1501 goto driver_register_failed; 1502 retval = usbdev_init(); 1503 if (retval) 1504 goto usbdevice_init_failed; 1505 retval = usbfs_init(); 1506 if (retval) 1507 goto fs_init_failed; 1508 retval = usb_hub_init(); 1509 if (retval) 1510 goto hub_init_failed; 1511 retval = driver_register(&usb_generic_driver); 1512 if (!retval) 1513 goto out; 1514 1515 usb_hub_cleanup(); 1516hub_init_failed: 1517 usbfs_cleanup(); 1518fs_init_failed: 1519 usbdev_cleanup(); 1520usbdevice_init_failed: 1521 usb_deregister(&usbfs_driver); 1522driver_register_failed: 1523 usb_major_cleanup(); 1524major_init_failed: 1525 usb_host_cleanup(); 1526host_init_failed: 1527 bus_unregister(&usb_bus_type); 1528out: 1529 return retval; 1530} 1531 1532/* 1533 * Cleanup 1534 */ 1535static void __exit usb_exit(void) 1536{ 1537 /* This will matter if shutdown/reboot does exitcalls. */ 1538 if (nousb) 1539 return; 1540 1541 driver_unregister(&usb_generic_driver); 1542 usb_major_cleanup(); 1543 usbfs_cleanup(); 1544 usb_deregister(&usbfs_driver); 1545 usbdev_cleanup(); 1546 usb_hub_cleanup(); 1547 usb_host_cleanup(); 1548 bus_unregister(&usb_bus_type); 1549} 1550 1551subsys_initcall(usb_init); 1552module_exit(usb_exit); 1553 1554/* 1555 * USB may be built into the kernel or be built as modules. 1556 * These symbols are exported for device (or host controller) 1557 * driver modules to use. 1558 */ 1559 1560EXPORT_SYMBOL(usb_register); 1561EXPORT_SYMBOL(usb_deregister); 1562EXPORT_SYMBOL(usb_disabled); 1563 1564EXPORT_SYMBOL_GPL(usb_get_intf); 1565EXPORT_SYMBOL_GPL(usb_put_intf); 1566 1567EXPORT_SYMBOL(usb_alloc_dev); 1568EXPORT_SYMBOL(usb_put_dev); 1569EXPORT_SYMBOL(usb_get_dev); 1570EXPORT_SYMBOL(usb_hub_tt_clear_buffer); 1571 1572EXPORT_SYMBOL(usb_lock_device); 1573EXPORT_SYMBOL(usb_trylock_device); 1574EXPORT_SYMBOL(usb_lock_device_for_reset); 1575EXPORT_SYMBOL(usb_unlock_device); 1576 1577EXPORT_SYMBOL(usb_driver_claim_interface); 1578EXPORT_SYMBOL(usb_driver_release_interface); 1579EXPORT_SYMBOL(usb_match_id); 1580EXPORT_SYMBOL(usb_find_interface); 1581EXPORT_SYMBOL(usb_ifnum_to_if); 1582EXPORT_SYMBOL(usb_altnum_to_altsetting); 1583 1584EXPORT_SYMBOL(usb_reset_device); 1585EXPORT_SYMBOL(usb_disconnect); 1586 1587EXPORT_SYMBOL(__usb_get_extra_descriptor); 1588 1589EXPORT_SYMBOL(usb_find_device); 1590EXPORT_SYMBOL(usb_get_current_frame_number); 1591 1592EXPORT_SYMBOL (usb_buffer_alloc); 1593EXPORT_SYMBOL (usb_buffer_free); 1594 1595#if 0 1596EXPORT_SYMBOL (usb_buffer_map); 1597EXPORT_SYMBOL (usb_buffer_dmasync); 1598EXPORT_SYMBOL (usb_buffer_unmap); 1599#endif 1600 1601EXPORT_SYMBOL (usb_buffer_map_sg); 1602#if 0 1603EXPORT_SYMBOL (usb_buffer_dmasync_sg); 1604#endif 1605EXPORT_SYMBOL (usb_buffer_unmap_sg); 1606 1607MODULE_LICENSE("GPL"); 1608