drivers/usb/core/usb.c

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