drivers/usb/core/driver.c

   1 /*
   2  * drivers/usb/driver.c - most of the driver model stuff for usb
   3  *
   4  * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
   5  *
   6  * based on drivers/usb/usb.c which had the following copyrights:
   7  *      (C) Copyright Linus Torvalds 1999
   8  *      (C) Copyright Johannes Erdfelt 1999-2001
   9  *      (C) Copyright Andreas Gal 1999
  10  *      (C) Copyright Gregory P. Smith 1999
  11  *      (C) Copyright Deti Fliegl 1999 (new USB architecture)
  12  *      (C) Copyright Randy Dunlap 2000
  13  *      (C) Copyright David Brownell 2000-2004
  14  *      (C) Copyright Yggdrasil Computing, Inc. 2000
  15  *              (usb_device_id matching changes by Adam J. Richter)
  16  *      (C) Copyright Greg Kroah-Hartman 2002-2003
  17  *
  18  * NOTE! This is not actually a driver at all, rather this is
  19  * just a collection of helper routines that implement the
  20  * matching, probing, releasing, suspending and resuming for
  21  * real drivers.
  22  *
  23  */
  24
  25 #include <linux/device.h>
  26 #include <linux/slab.h>
  27 #include <linux/usb.h>
  28 #include <linux/usb/quirks.h>
  29 #include <linux/usb/hcd.h>
  30
  31 #include "usb.h"
  32
  33
  34 #ifdef CONFIG_HOTPLUG
  35
  36 /*
  37  * Adds a new dynamic USBdevice ID to this driver,
  38  * and cause the driver to probe for all devices again.
  39  */
  40 ssize_t usb_store_new_id(struct usb_dynids *dynids,
  41                          struct device_driver *driver,
  42                          const char *buf, size_t count)
  43 {
  44         struct usb_dynid *dynid;
  45         u32 idVendor = 0;
  46         u32 idProduct = 0;
  47         int fields = 0;
  48         int retval = 0;
  49
  50         fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
  51         if (fields < 2)
  52                 return -EINVAL;
  53
  54         dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
  55         if (!dynid)
  56                 return -ENOMEM;
  57
  58         INIT_LIST_HEAD(&dynid->node);
  59         dynid->id.idVendor = idVendor;
  60         dynid->id.idProduct = idProduct;
  61         dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
  62
  63         spin_lock(&dynids->lock);
  64         list_add_tail(&dynid->node, &dynids->list);
  65         spin_unlock(&dynids->lock);
  66
  67         if (get_driver(driver)) {
  68                 retval = driver_attach(driver);
  69                 put_driver(driver);
  70         }
  71
  72         if (retval)
  73                 return retval;
  74         return count;
  75 }
  76 EXPORT_SYMBOL_GPL(usb_store_new_id);
  77
  78 static ssize_t store_new_id(struct device_driver *driver,
  79                             const char *buf, size_t count)
  80 {
  81         struct usb_driver *usb_drv = to_usb_driver(driver);
  82
  83         return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
  84 }
  85 static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id);
  86
  87 /**
  88  * store_remove_id - remove a USB device ID from this driver
  89  * @driver: target device driver
  90  * @buf: buffer for scanning device ID data
  91  * @count: input size
  92  *
  93  * Removes a dynamic usb device ID from this driver.
  94  */
  95 static ssize_t
  96 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
  97 {
  98         struct usb_dynid *dynid, *n;
  99         struct usb_driver *usb_driver = to_usb_driver(driver);
 100         u32 idVendor = 0;
 101         u32 idProduct = 0;
 102         int fields = 0;
 103         int retval = 0;
 104
 105         fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
 106         if (fields < 2)
 107                 return -EINVAL;
 108
 109         spin_lock(&usb_driver->dynids.lock);
 110         list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
 111                 struct usb_device_id *id = &dynid->id;
 112                 if ((id->idVendor == idVendor) &&
 113                     (id->idProduct == idProduct)) {
 114                         list_del(&dynid->node);
 115                         kfree(dynid);
 116                         retval = 0;
 117                         break;
 118                 }
 119         }
 120         spin_unlock(&usb_driver->dynids.lock);
 121
 122         if (retval)
 123                 return retval;
 124         return count;
 125 }
 126 static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id);
 127
 128 static int usb_create_newid_file(struct usb_driver *usb_drv)
 129 {
 130         int error = 0;
 131
 132         if (usb_drv->no_dynamic_id)
 133                 goto exit;
 134
 135         if (usb_drv->probe != NULL)
 136                 error = driver_create_file(&usb_drv->drvwrap.driver,
 137                                            &driver_attr_new_id);
 138 exit:
 139         return error;
 140 }
 141
 142 static void usb_remove_newid_file(struct usb_driver *usb_drv)
 143 {
 144         if (usb_drv->no_dynamic_id)
 145                 return;
 146
 147         if (usb_drv->probe != NULL)
 148                 driver_remove_file(&usb_drv->drvwrap.driver,
 149                                    &driver_attr_new_id);
 150 }
 151
 152 static int
 153 usb_create_removeid_file(struct usb_driver *drv)
 154 {
 155         int error = 0;
 156         if (drv->probe != NULL)
 157                 error = driver_create_file(&drv->drvwrap.driver,
 158                                 &driver_attr_remove_id);
 159         return error;
 160 }
 161
 162 static void usb_remove_removeid_file(struct usb_driver *drv)
 163 {
 164         driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id);
 165 }
 166
 167 static void usb_free_dynids(struct usb_driver *usb_drv)
 168 {
 169         struct usb_dynid *dynid, *n;
 170
 171         spin_lock(&usb_drv->dynids.lock);
 172         list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
 173                 list_del(&dynid->node);
 174                 kfree(dynid);
 175         }
 176         spin_unlock(&usb_drv->dynids.lock);
 177 }
 178 #else
 179 static inline int usb_create_newid_file(struct usb_driver *usb_drv)
 180 {
 181         return 0;
 182 }
 183
 184 static void usb_remove_newid_file(struct usb_driver *usb_drv)
 185 {
 186 }
 187
 188 static int
 189 usb_create_removeid_file(struct usb_driver *drv)
 190 {
 191         return 0;
 192 }
 193
 194 static void usb_remove_removeid_file(struct usb_driver *drv)
 195 {
 196 }
 197
 198 static inline void usb_free_dynids(struct usb_driver *usb_drv)
 199 {
 200 }
 201 #endif
 202
 203 static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
 204                                                         struct usb_driver *drv)
 205 {
 206         struct usb_dynid *dynid;
 207
 208         spin_lock(&drv->dynids.lock);
 209         list_for_each_entry(dynid, &drv->dynids.list, node) {
 210                 if (usb_match_one_id(intf, &dynid->id)) {
 211                         spin_unlock(&drv->dynids.lock);
 212                         return &dynid->id;
 213                 }
 214         }
 215         spin_unlock(&drv->dynids.lock);
 216         return NULL;
 217 }
 218
 219
 220 /* called from driver core with dev locked */
 221 static int usb_probe_device(struct device *dev)
 222 {
 223         struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 224         struct usb_device *udev = to_usb_device(dev);
 225         int error = 0;
 226
 227         dev_dbg(dev, "%s\n", __func__);
 228
 229         /* TODO: Add real matching code */
 230
 231         /* The device should always appear to be in use
 232          * unless the driver suports autosuspend.
 233          */
 234         if (!udriver->supports_autosuspend)
 235                 error = usb_autoresume_device(udev);
 236
 237         if (!error)
 238                 error = udriver->probe(udev);
 239         return error;
 240 }
 241
 242 /* called from driver core with dev locked */
 243 static int usb_unbind_device(struct device *dev)
 244 {
 245         struct usb_device *udev = to_usb_device(dev);
 246         struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
 247
 248         udriver->disconnect(udev);
 249         if (!udriver->supports_autosuspend)
 250                 usb_autosuspend_device(udev);
 251         return 0;
 252 }
 253
 254 /*
 255  * Cancel any pending scheduled resets
 256  *
 257  * [see usb_queue_reset_device()]
 258  *
 259  * Called after unconfiguring / when releasing interfaces. See
 260  * comments in __usb_queue_reset_device() regarding
 261  * udev->reset_running.
 262  */
 263 static void usb_cancel_queued_reset(struct usb_interface *iface)
 264 {
 265         if (iface->reset_running == 0)
 266                 cancel_work_sync(&iface->reset_ws);
 267 }
 268
 269 /* called from driver core with dev locked */
 270 static int usb_probe_interface(struct device *dev)
 271 {
 272         struct usb_driver *driver = to_usb_driver(dev->driver);
 273         struct usb_interface *intf = to_usb_interface(dev);
 274         struct usb_device *udev = interface_to_usbdev(intf);
 275         const struct usb_device_id *id;
 276         int error = -ENODEV;
 277
 278         dev_dbg(dev, "%s\n", __func__);
 279
 280         intf->needs_binding = 0;
 281
 282         if (usb_device_is_owned(udev))
 283                 return error;
 284
 285         if (udev->authorized == 0) {
 286                 dev_err(&intf->dev, "Device is not authorized for usage\n");
 287                 return error;
 288         }
 289
 290         id = usb_match_id(intf, driver->id_table);
 291         if (!id)
 292                 id = usb_match_dynamic_id(intf, driver);
 293         if (!id)
 294                 return error;
 295
 296         dev_dbg(dev, "%s - got id\n", __func__);
 297
 298         error = usb_autoresume_device(udev);
 299         if (error)
 300                 return error;
 301
 302         intf->condition = USB_INTERFACE_BINDING;
 303
 304         /* Probed interfaces are initially active.  They are
 305          * runtime-PM-enabled only if the driver has autosuspend support.
 306          * They are sensitive to their children's power states.
 307          */
 308         pm_runtime_set_active(dev);
 309         pm_suspend_ignore_children(dev, false);
 310         if (driver->supports_autosuspend)
 311                 pm_runtime_enable(dev);
 312
 313         /* Carry out a deferred switch to altsetting 0 */
 314         if (intf->needs_altsetting0) {
 315                 error = usb_set_interface(udev, intf->altsetting[0].
 316                                 desc.bInterfaceNumber, 0);
 317                 if (error < 0)
 318                         goto err;
 319                 intf->needs_altsetting0 = 0;
 320         }
 321
 322         error = driver->probe(intf, id);
 323         if (error)
 324                 goto err;
 325
 326         intf->condition = USB_INTERFACE_BOUND;
 327         usb_autosuspend_device(udev);
 328         return error;
 329
 330  err:
 331         intf->needs_remote_wakeup = 0;
 332         intf->condition = USB_INTERFACE_UNBOUND;
 333         usb_cancel_queued_reset(intf);
 334
 335         /* Unbound interfaces are always runtime-PM-disabled and -suspended */
 336         if (driver->supports_autosuspend)
 337                 pm_runtime_disable(dev);
 338         pm_runtime_set_suspended(dev);
 339
 340         usb_autosuspend_device(udev);
 341         return error;
 342 }
 343
 344 /* called from driver core with dev locked */
 345 static int usb_unbind_interface(struct device *dev)
 346 {
 347         struct usb_driver *driver = to_usb_driver(dev->driver);
 348         struct usb_interface *intf = to_usb_interface(dev);
 349         struct usb_device *udev;
 350         int error, r;
 351
 352         intf->condition = USB_INTERFACE_UNBINDING;
 353
 354         /* Autoresume for set_interface call below */
 355         udev = interface_to_usbdev(intf);
 356         error = usb_autoresume_device(udev);
 357
 358         /* Terminate all URBs for this interface unless the driver
 359          * supports "soft" unbinding.
 360          */
 361         if (!driver->soft_unbind)
 362                 usb_disable_interface(udev, intf, false);
 363
 364         driver->disconnect(intf);
 365         usb_cancel_queued_reset(intf);
 366
 367         /* Reset other interface state.
 368          * We cannot do a Set-Interface if the device is suspended or
 369          * if it is prepared for a system sleep (since installing a new
 370          * altsetting means creating new endpoint device entries).
 371          * When either of these happens, defer the Set-Interface.
 372          */
 373         if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
 374                 /* Already in altsetting 0 so skip Set-Interface.
 375                  * Just re-enable it without affecting the endpoint toggles.
 376                  */
 377                 usb_enable_interface(udev, intf, false);
 378         } else if (!error && !intf->dev.power.in_suspend) {
 379                 r = usb_set_interface(udev, intf->altsetting[0].
 380                                 desc.bInterfaceNumber, 0);
 381                 if (r < 0)
 382                         intf->needs_altsetting0 = 1;
 383         } else {
 384                 intf->needs_altsetting0 = 1;
 385         }
 386         usb_set_intfdata(intf, NULL);
 387
 388         intf->condition = USB_INTERFACE_UNBOUND;
 389         intf->needs_remote_wakeup = 0;
 390
 391         /* Unbound interfaces are always runtime-PM-disabled and -suspended */
 392         if (driver->supports_autosuspend)
 393                 pm_runtime_disable(dev);
 394         pm_runtime_set_suspended(dev);
 395
 396         /* Undo any residual pm_autopm_get_interface_* calls */
 397         for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
 398                 usb_autopm_put_interface_no_suspend(intf);
 399         atomic_set(&intf->pm_usage_cnt, 0);
 400
 401         if (!error)
 402                 usb_autosuspend_device(udev);
 403
 404         return 0;
 405 }
 406
 407 /**
 408  * usb_driver_claim_interface - bind a driver to an interface
 409  * @driver: the driver to be bound
 410  * @iface: the interface to which it will be bound; must be in the
 411  *      usb device's active configuration
 412  * @priv: driver data associated with that interface
 413  *
 414  * This is used by usb device drivers that need to claim more than one
 415  * interface on a device when probing (audio and acm are current examples).
 416  * No device driver should directly modify internal usb_interface or
 417  * usb_device structure members.
 418  *
 419  * Few drivers should need to use this routine, since the most natural
 420  * way to bind to an interface is to return the private data from
 421  * the driver's probe() method.
 422  *
 423  * Callers must own the device lock, so driver probe() entries don't need
 424  * extra locking, but other call contexts may need to explicitly claim that
 425  * lock.
 426  */
 427 int usb_driver_claim_interface(struct usb_driver *driver,
 428                                 struct usb_interface *iface, void *priv)
 429 {
 430         struct device *dev = &iface->dev;
 431         int retval = 0;
 432
 433         if (dev->driver)
 434                 return -EBUSY;
 435
 436         dev->driver = &driver->drvwrap.driver;
 437         usb_set_intfdata(iface, priv);
 438         iface->needs_binding = 0;
 439
 440         iface->condition = USB_INTERFACE_BOUND;
 441
 442         /* Claimed interfaces are initially inactive (suspended) and
 443          * runtime-PM-enabled, but only if the driver has autosuspend
 444          * support.  Otherwise they are marked active, to prevent the
 445          * device from being autosuspended, but left disabled.  In either
 446          * case they are sensitive to their children's power states.
 447          */
 448         pm_suspend_ignore_children(dev, false);
 449         if (driver->supports_autosuspend)
 450                 pm_runtime_enable(dev);
 451         else
 452                 pm_runtime_set_active(dev);
 453
 454         /* if interface was already added, bind now; else let
 455          * the future device_add() bind it, bypassing probe()
 456          */
 457         if (device_is_registered(dev))
 458                 retval = device_bind_driver(dev);
 459
 460         return retval;
 461 }
 462 EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
 463
 464 /**
 465  * usb_driver_release_interface - unbind a driver from an interface
 466  * @driver: the driver to be unbound
 467  * @iface: the interface from which it will be unbound
 468  *
 469  * This can be used by drivers to release an interface without waiting
 470  * for their disconnect() methods to be called.  In typical cases this
 471  * also causes the driver disconnect() method to be called.
 472  *
 473  * This call is synchronous, and may not be used in an interrupt context.
 474  * Callers must own the device lock, so driver disconnect() entries don't
 475  * need extra locking, but other call contexts may need to explicitly claim
 476  * that lock.
 477  */
 478 void usb_driver_release_interface(struct usb_driver *driver,
 479                                         struct usb_interface *iface)
 480 {
 481         struct device *dev = &iface->dev;
 482
 483         /* this should never happen, don't release something that's not ours */
 484         if (!dev->driver || dev->driver != &driver->drvwrap.driver)
 485                 return;
 486
 487         /* don't release from within disconnect() */
 488         if (iface->condition != USB_INTERFACE_BOUND)
 489                 return;
 490         iface->condition = USB_INTERFACE_UNBINDING;
 491
 492         /* Release via the driver core only if the interface
 493          * has already been registered
 494          */
 495         if (device_is_registered(dev)) {
 496                 device_release_driver(dev);
 497         } else {
 498                 device_lock(dev);
 499                 usb_unbind_interface(dev);
 500                 dev->driver = NULL;
 501                 device_unlock(dev);
 502         }
 503 }
 504 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
 505
 506 /* returns 0 if no match, 1 if match */
 507 int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
 508 {
 509         if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 510             id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
 511                 return 0;
 512
 513         if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
 514             id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
 515                 return 0;
 516
 517         /* No need to test id->bcdDevice_lo != 0, since 0 is never
 518            greater than any unsigned number. */
 519         if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
 520             (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
 521                 return 0;
 522
 523         if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
 524             (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
 525                 return 0;
 526
 527         if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
 528             (id->bDeviceClass != dev->descriptor.bDeviceClass))
 529                 return 0;
 530
 531         if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
 532             (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
 533                 return 0;
 534
 535         if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
 536             (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
 537                 return 0;
 538
 539         return 1;
 540 }
 541
 542 /* returns 0 if no match, 1 if match */
 543 int usb_match_one_id(struct usb_interface *interface,
 544                      const struct usb_device_id *id)
 545 {
 546         struct usb_host_interface *intf;
 547         struct usb_device *dev;
 548
 549         /* proc_connectinfo in devio.c may call us with id == NULL. */
 550         if (id == NULL)
 551                 return 0;
 552
 553         intf = interface->cur_altsetting;
 554         dev = interface_to_usbdev(interface);
 555
 556         if (!usb_match_device(dev, id))
 557                 return 0;
 558
 559         /* The interface class, subclass, and protocol should never be
 560          * checked for a match if the device class is Vendor Specific,
 561          * unless the match record specifies the Vendor ID. */
 562         if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
 563                         !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
 564                         (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
 565                                 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
 566                                 USB_DEVICE_ID_MATCH_INT_PROTOCOL)))
 567                 return 0;
 568
 569         if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
 570             (id->bInterfaceClass != intf->desc.bInterfaceClass))
 571                 return 0;
 572
 573         if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
 574             (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
 575                 return 0;
 576
 577         if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
 578             (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
 579                 return 0;
 580
 581         return 1;
 582 }
 583 EXPORT_SYMBOL_GPL(usb_match_one_id);
 584
 585 /**
 586  * usb_match_id - find first usb_device_id matching device or interface
 587  * @interface: the interface of interest
 588  * @id: array of usb_device_id structures, terminated by zero entry
 589  *
 590  * usb_match_id searches an array of usb_device_id's and returns
 591  * the first one matching the device or interface, or null.
 592  * This is used when binding (or rebinding) a driver to an interface.
 593  * Most USB device drivers will use this indirectly, through the usb core,
 594  * but some layered driver frameworks use it directly.
 595  * These device tables are exported with MODULE_DEVICE_TABLE, through
 596  * modutils, to support the driver loading functionality of USB hotplugging.
 597  *
 598  * What Matches:
 599  *
 600  * The "match_flags" element in a usb_device_id controls which
 601  * members are used.  If the corresponding bit is set, the
 602  * value in the device_id must match its corresponding member
 603  * in the device or interface descriptor, or else the device_id
 604  * does not match.
 605  *
 606  * "driver_info" is normally used only by device drivers,
 607  * but you can create a wildcard "matches anything" usb_device_id
 608  * as a driver's "modules.usbmap" entry if you provide an id with
 609  * only a nonzero "driver_info" field.  If you do this, the USB device
 610  * driver's probe() routine should use additional intelligence to
 611  * decide whether to bind to the specified interface.
 612  *
 613  * What Makes Good usb_device_id Tables:
 614  *
 615  * The match algorithm is very simple, so that intelligence in
 616  * driver selection must come from smart driver id records.
 617  * Unless you have good reasons to use another selection policy,
 618  * provide match elements only in related groups, and order match
 619  * specifiers from specific to general.  Use the macros provided
 620  * for that purpose if you can.
 621  *
 622  * The most specific match specifiers use device descriptor
 623  * data.  These are commonly used with product-specific matches;
 624  * the USB_DEVICE macro lets you provide vendor and product IDs,
 625  * and you can also match against ranges of product revisions.
 626  * These are widely used for devices with application or vendor
 627  * specific bDeviceClass values.
 628  *
 629  * Matches based on device class/subclass/protocol specifications
 630  * are slightly more general; use the USB_DEVICE_INFO macro, or
 631  * its siblings.  These are used with single-function devices
 632  * where bDeviceClass doesn't specify that each interface has
 633  * its own class.
 634  *
 635  * Matches based on interface class/subclass/protocol are the
 636  * most general; they let drivers bind to any interface on a
 637  * multiple-function device.  Use the USB_INTERFACE_INFO
 638  * macro, or its siblings, to match class-per-interface style
 639  * devices (as recorded in bInterfaceClass).
 640  *
 641  * Note that an entry created by USB_INTERFACE_INFO won't match
 642  * any interface if the device class is set to Vendor-Specific.
 643  * This is deliberate; according to the USB spec the meanings of
 644  * the interface class/subclass/protocol for these devices are also
 645  * vendor-specific, and hence matching against a standard product
 646  * class wouldn't work anyway.  If you really want to use an
 647  * interface-based match for such a device, create a match record
 648  * that also specifies the vendor ID.  (Unforunately there isn't a
 649  * standard macro for creating records like this.)
 650  *
 651  * Within those groups, remember that not all combinations are
 652  * meaningful.  For example, don't give a product version range
 653  * without vendor and product IDs; or specify a protocol without
 654  * its associated class and subclass.
 655  */
 656 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 657                                          const struct usb_device_id *id)
 658 {
 659         /* proc_connectinfo in devio.c may call us with id == NULL. */
 660         if (id == NULL)
 661                 return NULL;
 662
 663         /* It is important to check that id->driver_info is nonzero,
 664            since an entry that is all zeroes except for a nonzero
 665            id->driver_info is the way to create an entry that
 666            indicates that the driver want to examine every
 667            device and interface. */
 668         for (; id->idVendor || id->idProduct || id->bDeviceClass ||
 669                id->bInterfaceClass || id->driver_info; id++) {
 670                 if (usb_match_one_id(interface, id))
 671                         return id;
 672         }
 673
 674         return NULL;
 675 }
 676 EXPORT_SYMBOL_GPL(usb_match_id);
 677
 678 static int usb_device_match(struct device *dev, struct device_driver *drv)
 679 {
 680         /* devices and interfaces are handled separately */
 681         if (is_usb_device(dev)) {
 682
 683                 /* interface drivers never match devices */
 684                 if (!is_usb_device_driver(drv))
 685                         return 0;
 686
 687                 /* TODO: Add real matching code */
 688                 return 1;
 689
 690         } else if (is_usb_interface(dev)) {
 691                 struct usb_interface *intf;
 692                 struct usb_driver *usb_drv;
 693                 const struct usb_device_id *id;
 694
 695                 /* device drivers never match interfaces */
 696                 if (is_usb_device_driver(drv))
 697                         return 0;
 698
 699                 intf = to_usb_interface(dev);
 700                 usb_drv = to_usb_driver(drv);
 701
 702                 id = usb_match_id(intf, usb_drv->id_table);
 703                 if (id)
 704                         return 1;
 705
 706                 id = usb_match_dynamic_id(intf, usb_drv);
 707                 if (id)
 708                         return 1;
 709         }
 710
 711         return 0;
 712 }
 713
 714 #ifdef  CONFIG_HOTPLUG
 715 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 716 {
 717         struct usb_device *usb_dev;
 718
 719         if (is_usb_device(dev)) {
 720                 usb_dev = to_usb_device(dev);
 721         } else if (is_usb_interface(dev)) {
 722                 struct usb_interface *intf = to_usb_interface(dev);
 723
 724                 usb_dev = interface_to_usbdev(intf);
 725         } else {
 726                 return 0;
 727         }
 728
 729         if (usb_dev->devnum < 0) {
 730                 /* driver is often null here; dev_dbg() would oops */
 731                 pr_debug("usb %s: already deleted?\n", dev_name(dev));
 732                 return -ENODEV;
 733         }
 734         if (!usb_dev->bus) {
 735                 pr_debug("usb %s: bus removed?\n", dev_name(dev));
 736                 return -ENODEV;
 737         }
 738
 739 #ifdef  CONFIG_USB_DEVICEFS
 740         /* If this is available, userspace programs can directly read
 741          * all the device descriptors we don't tell them about.  Or
 742          * act as usermode drivers.
 743          */
 744         if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d",
 745                            usb_dev->bus->busnum, usb_dev->devnum))
 746                 return -ENOMEM;
 747 #endif
 748
 749         /* per-device configurations are common */
 750         if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
 751                            le16_to_cpu(usb_dev->descriptor.idVendor),
 752                            le16_to_cpu(usb_dev->descriptor.idProduct),
 753                            le16_to_cpu(usb_dev->descriptor.bcdDevice)))
 754                 return -ENOMEM;
 755
 756         /* class-based driver binding models */
 757         if (add_uevent_var(env, "TYPE=%d/%d/%d",
 758                            usb_dev->descriptor.bDeviceClass,
 759                            usb_dev->descriptor.bDeviceSubClass,
 760                            usb_dev->descriptor.bDeviceProtocol))
 761                 return -ENOMEM;
 762
 763         return 0;
 764 }
 765
 766 #else
 767
 768 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
 769 {
 770         return -ENODEV;
 771 }
 772 #endif  /* CONFIG_HOTPLUG */
 773
 774 /**
 775  * usb_register_device_driver - register a USB device (not interface) driver
 776  * @new_udriver: USB operations for the device driver
 777  * @owner: module owner of this driver.
 778  *
 779  * Registers a USB device driver with the USB core.  The list of
 780  * unattached devices will be rescanned whenever a new driver is
 781  * added, allowing the new driver to attach to any recognized devices.
 782  * Returns a negative error code on failure and 0 on success.
 783  */
 784 int usb_register_device_driver(struct usb_device_driver *new_udriver,
 785                 struct module *owner)
 786 {
 787         int retval = 0;
 788
 789         if (usb_disabled())
 790                 return -ENODEV;
 791
 792         new_udriver->drvwrap.for_devices = 1;
 793         new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
 794         new_udriver->drvwrap.driver.bus = &usb_bus_type;
 795         new_udriver->drvwrap.driver.probe = usb_probe_device;
 796         new_udriver->drvwrap.driver.remove = usb_unbind_device;
 797         new_udriver->drvwrap.driver.owner = owner;
 798
 799         retval = driver_register(&new_udriver->drvwrap.driver);
 800
 801         if (!retval) {
 802                 pr_info("%s: registered new device driver %s\n",
 803                         usbcore_name, new_udriver->name);
 804                 usbfs_update_special();
 805         } else {
 806                 printk(KERN_ERR "%s: error %d registering device "
 807                         "       driver %s\n",
 808                         usbcore_name, retval, new_udriver->name);
 809         }
 810
 811         return retval;
 812 }
 813 EXPORT_SYMBOL_GPL(usb_register_device_driver);
 814
 815 /**
 816  * usb_deregister_device_driver - unregister a USB device (not interface) driver
 817  * @udriver: USB operations of the device driver to unregister
 818  * Context: must be able to sleep
 819  *
 820  * Unlinks the specified driver from the internal USB driver list.
 821  */
 822 void usb_deregister_device_driver(struct usb_device_driver *udriver)
 823 {
 824         pr_info("%s: deregistering device driver %s\n",
 825                         usbcore_name, udriver->name);
 826
 827         driver_unregister(&udriver->drvwrap.driver);
 828         usbfs_update_special();
 829 }
 830 EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
 831
 832 /**
 833  * usb_register_driver - register a USB interface driver
 834  * @new_driver: USB operations for the interface driver
 835  * @owner: module owner of this driver.
 836  * @mod_name: module name string
 837  *
 838  * Registers a USB interface driver with the USB core.  The list of
 839  * unattached interfaces will be rescanned whenever a new driver is
 840  * added, allowing the new driver to attach to any recognized interfaces.
 841  * Returns a negative error code on failure and 0 on success.
 842  *
 843  * NOTE: if you want your driver to use the USB major number, you must call
 844  * usb_register_dev() to enable that functionality.  This function no longer
 845  * takes care of that.
 846  */
 847 int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
 848                         const char *mod_name)
 849 {
 850         int retval = 0;
 851
 852         if (usb_disabled())
 853                 return -ENODEV;
 854
 855         new_driver->drvwrap.for_devices = 0;
 856         new_driver->drvwrap.driver.name = (char *) new_driver->name;
 857         new_driver->drvwrap.driver.bus = &usb_bus_type;
 858         new_driver->drvwrap.driver.probe = usb_probe_interface;
 859         new_driver->drvwrap.driver.remove = usb_unbind_interface;
 860         new_driver->drvwrap.driver.owner = owner;
 861         new_driver->drvwrap.driver.mod_name = mod_name;
 862         spin_lock_init(&new_driver->dynids.lock);
 863         INIT_LIST_HEAD(&new_driver->dynids.list);
 864
 865         retval = driver_register(&new_driver->drvwrap.driver);
 866         if (retval)
 867                 goto out;
 868
 869         usbfs_update_special();
 870
 871         retval = usb_create_newid_file(new_driver);
 872         if (retval)
 873                 goto out_newid;
 874
 875         retval = usb_create_removeid_file(new_driver);
 876         if (retval)
 877                 goto out_removeid;
 878
 879         pr_info("%s: registered new interface driver %s\n",
 880                         usbcore_name, new_driver->name);
 881
 882 out:
 883         return retval;
 884
 885 out_removeid:
 886         usb_remove_newid_file(new_driver);
 887 out_newid:
 888         driver_unregister(&new_driver->drvwrap.driver);
 889
 890         printk(KERN_ERR "%s: error %d registering interface "
 891                         "       driver %s\n",
 892                         usbcore_name, retval, new_driver->name);
 893         goto out;
 894 }
 895 EXPORT_SYMBOL_GPL(usb_register_driver);
 896
 897 /**
 898  * usb_deregister - unregister a USB interface driver
 899  * @driver: USB operations of the interface driver to unregister
 900  * Context: must be able to sleep
 901  *
 902  * Unlinks the specified driver from the internal USB driver list.
 903  *
 904  * NOTE: If you called usb_register_dev(), you still need to call
 905  * usb_deregister_dev() to clean up your driver's allocated minor numbers,
 906  * this * call will no longer do it for you.
 907  */
 908 void usb_deregister(struct usb_driver *driver)
 909 {
 910         pr_info("%s: deregistering interface driver %s\n",
 911                         usbcore_name, driver->name);
 912
 913         usb_remove_removeid_file(driver);
 914         usb_remove_newid_file(driver);
 915         usb_free_dynids(driver);
 916         driver_unregister(&driver->drvwrap.driver);
 917
 918         usbfs_update_special();
 919 }
 920 EXPORT_SYMBOL_GPL(usb_deregister);
 921
 922 /* Forced unbinding of a USB interface driver, either because
 923  * it doesn't support pre_reset/post_reset/reset_resume or
 924  * because it doesn't support suspend/resume.
 925  *
 926  * The caller must hold @intf's device's lock, but not its pm_mutex
 927  * and not @intf->dev.sem.
 928  */
 929 void usb_forced_unbind_intf(struct usb_interface *intf)
 930 {
 931         struct usb_driver *driver = to_usb_driver(intf->dev.driver);
 932
 933         dev_dbg(&intf->dev, "forced unbind\n");
 934         usb_driver_release_interface(driver, intf);
 935
 936         /* Mark the interface for later rebinding */
 937         intf->needs_binding = 1;
 938 }
 939
 940 /* Delayed forced unbinding of a USB interface driver and scan
 941  * for rebinding.
 942  *
 943  * The caller must hold @intf's device's lock, but not its pm_mutex
 944  * and not @intf->dev.sem.
 945  *
 946  * Note: Rebinds will be skipped if a system sleep transition is in
 947  * progress and the PM "complete" callback hasn't occurred yet.
 948  */
 949 void usb_rebind_intf(struct usb_interface *intf)
 950 {
 951         int rc;
 952
 953         /* Delayed unbind of an existing driver */
 954         if (intf->dev.driver) {
 955                 struct usb_driver *driver =
 956                                 to_usb_driver(intf->dev.driver);
 957
 958                 dev_dbg(&intf->dev, "forced unbind\n");
 959                 usb_driver_release_interface(driver, intf);
 960         }
 961
 962         /* Try to rebind the interface */
 963         if (!intf->dev.power.in_suspend) {
 964                 intf->needs_binding = 0;
 965                 rc = device_attach(&intf->dev);
 966                 if (rc < 0)
 967                         dev_warn(&intf->dev, "rebind failed: %d\n", rc);
 968         }
 969 }
 970
 971 #ifdef CONFIG_PM
 972
 973 #define DO_UNBIND       0
 974 #define DO_REBIND       1
 975
 976 /* Unbind drivers for @udev's interfaces that don't support suspend/resume,
 977  * or rebind interfaces that have been unbound, according to @action.
 978  *
 979  * The caller must hold @udev's device lock.
 980  */
 981 static void do_unbind_rebind(struct usb_device *udev, int action)
 982 {
 983         struct usb_host_config  *config;
 984         int                     i;
 985         struct usb_interface    *intf;
 986         struct usb_driver       *drv;
 987
 988         config = udev->actconfig;
 989         if (config) {
 990                 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
 991                         intf = config->interface[i];
 992                         switch (action) {
 993                         case DO_UNBIND:
 994                                 if (intf->dev.driver) {
 995                                         drv = to_usb_driver(intf->dev.driver);
 996                                         if (!drv->suspend || !drv->resume)
 997                                                 usb_forced_unbind_intf(intf);
 998                                 }
 999                                 break;
1000                         case DO_REBIND:
1001                                 if (intf->needs_binding)
1002                                         usb_rebind_intf(intf);
1003                                 break;
1004                         }
1005                 }
1006         }
1007 }
1008
1009 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1010 {
1011         struct usb_device_driver        *udriver;
1012         int                             status = 0;
1013
1014         if (udev->state == USB_STATE_NOTATTACHED ||
1015                         udev->state == USB_STATE_SUSPENDED)
1016                 goto done;
1017
1018         /* For devices that don't have a driver, we do a generic suspend. */
1019         if (udev->dev.driver)
1020                 udriver = to_usb_device_driver(udev->dev.driver);
1021         else {
1022                 udev->do_remote_wakeup = 0;
1023                 udriver = &usb_generic_driver;
1024         }
1025         status = udriver->suspend(udev, msg);
1026
1027  done:
1028         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1029         return status;
1030 }
1031
1032 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1033 {
1034         struct usb_device_driver        *udriver;
1035         int                             status = 0;
1036
1037         if (udev->state == USB_STATE_NOTATTACHED)
1038                 goto done;
1039
1040         /* Can't resume it if it doesn't have a driver. */
1041         if (udev->dev.driver == NULL) {
1042                 status = -ENOTCONN;
1043                 goto done;
1044         }
1045
1046         /* Non-root devices on a full/low-speed bus must wait for their
1047          * companion high-speed root hub, in case a handoff is needed.
1048          */
1049         if (!(msg.event & PM_EVENT_AUTO) && udev->parent &&
1050                         udev->bus->hs_companion)
1051                 device_pm_wait_for_dev(&udev->dev,
1052                                 &udev->bus->hs_companion->root_hub->dev);
1053
1054         if (udev->quirks & USB_QUIRK_RESET_RESUME)
1055                 udev->reset_resume = 1;
1056
1057         udriver = to_usb_device_driver(udev->dev.driver);
1058         status = udriver->resume(udev, msg);
1059
1060  done:
1061         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1062         return status;
1063 }
1064
1065 static int usb_suspend_interface(struct usb_device *udev,
1066                 struct usb_interface *intf, pm_message_t msg)
1067 {
1068         struct usb_driver       *driver;
1069         int                     status = 0;
1070
1071         if (udev->state == USB_STATE_NOTATTACHED ||
1072                         intf->condition == USB_INTERFACE_UNBOUND)
1073                 goto done;
1074         driver = to_usb_driver(intf->dev.driver);
1075
1076         if (driver->suspend) {
1077                 status = driver->suspend(intf, msg);
1078                 if (status && !(msg.event & PM_EVENT_AUTO))
1079                         dev_err(&intf->dev, "%s error %d\n",
1080                                         "suspend", status);
1081         } else {
1082                 /* Later we will unbind the driver and reprobe */
1083                 intf->needs_binding = 1;
1084                 dev_warn(&intf->dev, "no %s for driver %s?\n",
1085                                 "suspend", driver->name);
1086         }
1087
1088  done:
1089         dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1090         return status;
1091 }
1092
1093 static int usb_resume_interface(struct usb_device *udev,
1094                 struct usb_interface *intf, pm_message_t msg, int reset_resume)
1095 {
1096         struct usb_driver       *driver;
1097         int                     status = 0;
1098
1099         if (udev->state == USB_STATE_NOTATTACHED)
1100                 goto done;
1101
1102         /* Don't let autoresume interfere with unbinding */
1103         if (intf->condition == USB_INTERFACE_UNBINDING)
1104                 goto done;
1105
1106         /* Can't resume it if it doesn't have a driver. */
1107         if (intf->condition == USB_INTERFACE_UNBOUND) {
1108
1109                 /* Carry out a deferred switch to altsetting 0 */
1110                 if (intf->needs_altsetting0 && !intf->dev.power.in_suspend) {
1111                         usb_set_interface(udev, intf->altsetting[0].
1112                                         desc.bInterfaceNumber, 0);
1113                         intf->needs_altsetting0 = 0;
1114                 }
1115                 goto done;
1116         }
1117
1118         /* Don't resume if the interface is marked for rebinding */
1119         if (intf->needs_binding)
1120                 goto done;
1121         driver = to_usb_driver(intf->dev.driver);
1122
1123         if (reset_resume) {
1124                 if (driver->reset_resume) {
1125                         status = driver->reset_resume(intf);
1126                         if (status)
1127                                 dev_err(&intf->dev, "%s error %d\n",
1128                                                 "reset_resume", status);
1129                 } else {
1130                         intf->needs_binding = 1;
1131                         dev_warn(&intf->dev, "no %s for driver %s?\n",
1132                                         "reset_resume", driver->name);
1133                 }
1134         } else {
1135                 if (driver->resume) {
1136                         status = driver->resume(intf);
1137                         if (status)
1138                                 dev_err(&intf->dev, "%s error %d\n",
1139                                                 "resume", status);
1140                 } else {
1141                         intf->needs_binding = 1;
1142                         dev_warn(&intf->dev, "no %s for driver %s?\n",
1143                                         "resume", driver->name);
1144                 }
1145         }
1146
1147 done:
1148         dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1149
1150         /* Later we will unbind the driver and/or reprobe, if necessary */
1151         return status;
1152 }
1153
1154 /**
1155  * usb_suspend_both - suspend a USB device and its interfaces
1156  * @udev: the usb_device to suspend
1157  * @msg: Power Management message describing this state transition
1158  *
1159  * This is the central routine for suspending USB devices.  It calls the
1160  * suspend methods for all the interface drivers in @udev and then calls
1161  * the suspend method for @udev itself.  If an error occurs at any stage,
1162  * all the interfaces which were suspended are resumed so that they remain
1163  * in the same state as the device.
1164  *
1165  * Autosuspend requests originating from a child device or an interface
1166  * driver may be made without the protection of @udev's device lock, but
1167  * all other suspend calls will hold the lock.  Usbcore will insure that
1168  * method calls do not arrive during bind, unbind, or reset operations.
1169  * However drivers must be prepared to handle suspend calls arriving at
1170  * unpredictable times.
1171  *
1172  * This routine can run only in process context.
1173  */
1174 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1175 {
1176         int                     status = 0;
1177         int                     i = 0, n = 0;
1178         struct usb_interface    *intf;
1179
1180         if (udev->state == USB_STATE_NOTATTACHED ||
1181                         udev->state == USB_STATE_SUSPENDED)
1182                 goto done;
1183
1184         /* Suspend all the interfaces and then udev itself */
1185         if (udev->actconfig) {
1186                 n = udev->actconfig->desc.bNumInterfaces;
1187                 for (i = n - 1; i >= 0; --i) {
1188                         intf = udev->actconfig->interface[i];
1189                         status = usb_suspend_interface(udev, intf, msg);
1190                         if (status != 0)
1191                                 break;
1192                 }
1193         }
1194         if (status == 0)
1195                 status = usb_suspend_device(udev, msg);
1196
1197         /* If the suspend failed, resume interfaces that did get suspended */
1198         if (status != 0) {
1199                 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1200                 while (++i < n) {
1201                         intf = udev->actconfig->interface[i];
1202                         usb_resume_interface(udev, intf, msg, 0);
1203                 }
1204
1205         /* If the suspend succeeded then prevent any more URB submissions
1206          * and flush any outstanding URBs.
1207          */
1208         } else {
1209                 udev->can_submit = 0;
1210                 for (i = 0; i < 16; ++i) {
1211                         usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1212                         usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1213                 }
1214         }
1215
1216  done:
1217         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1218         return status;
1219 }
1220
1221 /**
1222  * usb_resume_both - resume a USB device and its interfaces
1223  * @udev: the usb_device to resume
1224  * @msg: Power Management message describing this state transition
1225  *
1226  * This is the central routine for resuming USB devices.  It calls the
1227  * the resume method for @udev and then calls the resume methods for all
1228  * the interface drivers in @udev.
1229  *
1230  * Autoresume requests originating from a child device or an interface
1231  * driver may be made without the protection of @udev's device lock, but
1232  * all other resume calls will hold the lock.  Usbcore will insure that
1233  * method calls do not arrive during bind, unbind, or reset operations.
1234  * However drivers must be prepared to handle resume calls arriving at
1235  * unpredictable times.
1236  *
1237  * This routine can run only in process context.
1238  */
1239 static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1240 {
1241         int                     status = 0;
1242         int                     i;
1243         struct usb_interface    *intf;
1244
1245         if (udev->state == USB_STATE_NOTATTACHED) {
1246                 status = -ENODEV;
1247                 goto done;
1248         }
1249         udev->can_submit = 1;
1250
1251         /* Resume the device */
1252         if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
1253                 status = usb_resume_device(udev, msg);
1254
1255         /* Resume the interfaces */
1256         if (status == 0 && udev->actconfig) {
1257                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1258                         intf = udev->actconfig->interface[i];
1259                         usb_resume_interface(udev, intf, msg,
1260                                         udev->reset_resume);
1261                 }
1262         }
1263         usb_mark_last_busy(udev);
1264
1265  done:
1266         dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1267         if (!status)
1268                 udev->reset_resume = 0;
1269         return status;
1270 }
1271
1272 static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
1273 {
1274         int     w;
1275
1276         /* Remote wakeup is needed only when we actually go to sleep.
1277          * For things like FREEZE and QUIESCE, if the device is already
1278          * autosuspended then its current wakeup setting is okay.
1279          */
1280         if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
1281                 if (udev->state != USB_STATE_SUSPENDED)
1282                         udev->do_remote_wakeup = 0;
1283                 return;
1284         }
1285
1286         /* Enable remote wakeup if it is allowed, even if no interface drivers
1287          * actually want it.
1288          */
1289         w = device_may_wakeup(&udev->dev);
1290
1291         /* If the device is autosuspended with the wrong wakeup setting,
1292          * autoresume now so the setting can be changed.
1293          */
1294         if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
1295                 pm_runtime_resume(&udev->dev);
1296         udev->do_remote_wakeup = w;
1297 }
1298
1299 /* The device lock is held by the PM core */
1300 int usb_suspend(struct device *dev, pm_message_t msg)
1301 {
1302         struct usb_device       *udev = to_usb_device(dev);
1303
1304         do_unbind_rebind(udev, DO_UNBIND);
1305         choose_wakeup(udev, msg);
1306         return usb_suspend_both(udev, msg);
1307 }
1308
1309 /* The device lock is held by the PM core */
1310 int usb_resume(struct device *dev, pm_message_t msg)
1311 {
1312         struct usb_device       *udev = to_usb_device(dev);
1313         int                     status;
1314
1315         /* For PM complete calls, all we do is rebind interfaces */
1316         if (msg.event == PM_EVENT_ON) {
1317                 if (udev->state != USB_STATE_NOTATTACHED)
1318                         do_unbind_rebind(udev, DO_REBIND);
1319                 status = 0;
1320
1321         /* For all other calls, take the device back to full power and
1322          * tell the PM core in case it was autosuspended previously.
1323          * Unbind the interfaces that will need rebinding later.
1324          */
1325         } else {
1326                 status = usb_resume_both(udev, msg);
1327                 if (status == 0) {
1328                         pm_runtime_disable(dev);
1329                         pm_runtime_set_active(dev);
1330                         pm_runtime_enable(dev);
1331                         do_unbind_rebind(udev, DO_REBIND);
1332                 }
1333         }
1334
1335         /* Avoid PM error messages for devices disconnected while suspended
1336          * as we'll display regular disconnect messages just a bit later.
1337          */
1338         if (status == -ENODEV || status == -ESHUTDOWN)
1339                 status = 0;
1340         return status;
1341 }
1342
1343 #endif /* CONFIG_PM */
1344
1345 #ifdef CONFIG_USB_SUSPEND
1346
1347 /**
1348  * usb_enable_autosuspend - allow a USB device to be autosuspended
1349  * @udev: the USB device which may be autosuspended
1350  *
1351  * This routine allows @udev to be autosuspended.  An autosuspend won't
1352  * take place until the autosuspend_delay has elapsed and all the other
1353  * necessary conditions are satisfied.
1354  *
1355  * The caller must hold @udev's device lock.
1356  */
1357 void usb_enable_autosuspend(struct usb_device *udev)
1358 {
1359         pm_runtime_allow(&udev->dev);
1360 }
1361 EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
1362
1363 /**
1364  * usb_disable_autosuspend - prevent a USB device from being autosuspended
1365  * @udev: the USB device which may not be autosuspended
1366  *
1367  * This routine prevents @udev from being autosuspended and wakes it up
1368  * if it is already autosuspended.
1369  *
1370  * The caller must hold @udev's device lock.
1371  */
1372 void usb_disable_autosuspend(struct usb_device *udev)
1373 {
1374         pm_runtime_forbid(&udev->dev);
1375 }
1376 EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
1377
1378 /**
1379  * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
1380  * @udev: the usb_device to autosuspend
1381  *
1382  * This routine should be called when a core subsystem is finished using
1383  * @udev and wants to allow it to autosuspend.  Examples would be when
1384  * @udev's device file in usbfs is closed or after a configuration change.
1385  *
1386  * @udev's usage counter is decremented; if it drops to 0 and all the
1387  * interfaces are inactive then a delayed autosuspend will be attempted.
1388  * The attempt may fail (see autosuspend_check()).
1389  *
1390  * The caller must hold @udev's device lock.
1391  *
1392  * This routine can run only in process context.
1393  */
1394 void usb_autosuspend_device(struct usb_device *udev)
1395 {
1396         int     status;
1397
1398         usb_mark_last_busy(udev);
1399         status = pm_runtime_put_sync_autosuspend(&udev->dev);
1400         dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1401                         __func__, atomic_read(&udev->dev.power.usage_count),
1402                         status);
1403 }
1404
1405 /**
1406  * usb_autoresume_device - immediately autoresume a USB device and its interfaces
1407  * @udev: the usb_device to autoresume
1408  *
1409  * This routine should be called when a core subsystem wants to use @udev
1410  * and needs to guarantee that it is not suspended.  No autosuspend will
1411  * occur until usb_autosuspend_device() is called.  (Note that this will
1412  * not prevent suspend events originating in the PM core.)  Examples would
1413  * be when @udev's device file in usbfs is opened or when a remote-wakeup
1414  * request is received.
1415  *
1416  * @udev's usage counter is incremented to prevent subsequent autosuspends.
1417  * However if the autoresume fails then the usage counter is re-decremented.
1418  *
1419  * The caller must hold @udev's device lock.
1420  *
1421  * This routine can run only in process context.
1422  */
1423 int usb_autoresume_device(struct usb_device *udev)
1424 {
1425         int     status;
1426
1427         status = pm_runtime_get_sync(&udev->dev);
1428         if (status < 0)
1429                 pm_runtime_put_sync(&udev->dev);
1430         dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1431                         __func__, atomic_read(&udev->dev.power.usage_count),
1432                         status);
1433         if (status > 0)
1434                 status = 0;
1435         return status;
1436 }
1437
1438 /**
1439  * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
1440  * @intf: the usb_interface whose counter should be decremented
1441  *
1442  * This routine should be called by an interface driver when it is
1443  * finished using @intf and wants to allow it to autosuspend.  A typical
1444  * example would be a character-device driver when its device file is
1445  * closed.
1446  *
1447  * The routine decrements @intf's usage counter.  When the counter reaches
1448  * 0, a delayed autosuspend request for @intf's device is attempted.  The
1449  * attempt may fail (see autosuspend_check()).
1450  *
1451  * This routine can run only in process context.
1452  */
1453 void usb_autopm_put_interface(struct usb_interface *intf)
1454 {
1455         struct usb_device       *udev = interface_to_usbdev(intf);
1456         int                     status;
1457
1458         usb_mark_last_busy(udev);
1459         atomic_dec(&intf->pm_usage_cnt);
1460         status = pm_runtime_put_sync(&intf->dev);
1461         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1462                         __func__, atomic_read(&intf->dev.power.usage_count),
1463                         status);
1464 }
1465 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1466
1467 /**
1468  * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
1469  * @intf: the usb_interface whose counter should be decremented
1470  *
1471  * This routine does much the same thing as usb_autopm_put_interface():
1472  * It decrements @intf's usage counter and schedules a delayed
1473  * autosuspend request if the counter is <= 0.  The difference is that it
1474  * does not perform any synchronization; callers should hold a private
1475  * lock and handle all synchronization issues themselves.
1476  *
1477  * Typically a driver would call this routine during an URB's completion
1478  * handler, if no more URBs were pending.
1479  *
1480  * This routine can run in atomic context.
1481  */
1482 void usb_autopm_put_interface_async(struct usb_interface *intf)
1483 {
1484         struct usb_device       *udev = interface_to_usbdev(intf);
1485         int                     status;
1486
1487         usb_mark_last_busy(udev);
1488         atomic_dec(&intf->pm_usage_cnt);
1489         status = pm_runtime_put(&intf->dev);
1490         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1491                         __func__, atomic_read(&intf->dev.power.usage_count),
1492                         status);
1493 }
1494 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1495
1496 /**
1497  * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
1498  * @intf: the usb_interface whose counter should be decremented
1499  *
1500  * This routine decrements @intf's usage counter but does not carry out an
1501  * autosuspend.
1502  *
1503  * This routine can run in atomic context.
1504  */
1505 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
1506 {
1507         struct usb_device       *udev = interface_to_usbdev(intf);
1508
1509         usb_mark_last_busy(udev);
1510         atomic_dec(&intf->pm_usage_cnt);
1511         pm_runtime_put_noidle(&intf->dev);
1512 }
1513 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
1514
1515 /**
1516  * usb_autopm_get_interface - increment a USB interface's PM-usage counter
1517  * @intf: the usb_interface whose counter should be incremented
1518  *
1519  * This routine should be called by an interface driver when it wants to
1520  * use @intf and needs to guarantee that it is not suspended.  In addition,
1521  * the routine prevents @intf from being autosuspended subsequently.  (Note
1522  * that this will not prevent suspend events originating in the PM core.)
1523  * This prevention will persist until usb_autopm_put_interface() is called
1524  * or @intf is unbound.  A typical example would be a character-device
1525  * driver when its device file is opened.
1526  *
1527  * @intf's usage counter is incremented to prevent subsequent autosuspends.
1528  * However if the autoresume fails then the counter is re-decremented.
1529  *
1530  * This routine can run only in process context.
1531  */
1532 int usb_autopm_get_interface(struct usb_interface *intf)
1533 {
1534         int     status;
1535
1536         status = pm_runtime_get_sync(&intf->dev);
1537         if (status < 0)
1538                 pm_runtime_put_sync(&intf->dev);
1539         else
1540                 atomic_inc(&intf->pm_usage_cnt);
1541         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1542                         __func__, atomic_read(&intf->dev.power.usage_count),
1543                         status);
1544         if (status > 0)
1545                 status = 0;
1546         return status;
1547 }
1548 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1549
1550 /**
1551  * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
1552  * @intf: the usb_interface whose counter should be incremented
1553  *
1554  * This routine does much the same thing as
1555  * usb_autopm_get_interface(): It increments @intf's usage counter and
1556  * queues an autoresume request if the device is suspended.  The
1557  * differences are that it does not perform any synchronization (callers
1558  * should hold a private lock and handle all synchronization issues
1559  * themselves), and it does not autoresume the device directly (it only
1560  * queues a request).  After a successful call, the device may not yet be
1561  * resumed.
1562  *
1563  * This routine can run in atomic context.
1564  */
1565 int usb_autopm_get_interface_async(struct usb_interface *intf)
1566 {
1567         int     status;
1568
1569         status = pm_runtime_get(&intf->dev);
1570         if (status < 0 && status != -EINPROGRESS)
1571                 pm_runtime_put_noidle(&intf->dev);
1572         else
1573                 atomic_inc(&intf->pm_usage_cnt);
1574         dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1575                         __func__, atomic_read(&intf->dev.power.usage_count),
1576                         status);
1577         if (status > 0)
1578                 status = 0;
1579         return status;
1580 }
1581 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1582
1583 /**
1584  * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
1585  * @intf: the usb_interface whose counter should be incremented
1586  *
1587  * This routine increments @intf's usage counter but does not carry out an
1588  * autoresume.
1589  *
1590  * This routine can run in atomic context.
1591  */
1592 void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
1593 {
1594         struct usb_device       *udev = interface_to_usbdev(intf);
1595
1596         usb_mark_last_busy(udev);
1597         atomic_inc(&intf->pm_usage_cnt);
1598         pm_runtime_get_noresume(&intf->dev);
1599 }
1600 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
1601
1602 /* Internal routine to check whether we may autosuspend a device. */
1603 static int autosuspend_check(struct usb_device *udev)
1604 {
1605         int                     w, i;
1606         struct usb_interface    *intf;
1607
1608         /* Fail if autosuspend is disabled, or any interfaces are in use, or
1609          * any interface drivers require remote wakeup but it isn't available.
1610          */
1611         w = 0;
1612         if (udev->actconfig) {
1613                 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1614                         intf = udev->actconfig->interface[i];
1615
1616                         /* We don't need to check interfaces that are
1617                          * disabled for runtime PM.  Either they are unbound
1618                          * or else their drivers don't support autosuspend
1619                          * and so they are permanently active.
1620                          */
1621                         if (intf->dev.power.disable_depth)
1622                                 continue;
1623                         if (atomic_read(&intf->dev.power.usage_count) > 0)
1624                                 return -EBUSY;
1625                         w |= intf->needs_remote_wakeup;
1626
1627                         /* Don't allow autosuspend if the device will need
1628                          * a reset-resume and any of its interface drivers
1629                          * doesn't include support or needs remote wakeup.
1630                          */
1631                         if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1632                                 struct usb_driver *driver;
1633
1634                                 driver = to_usb_driver(intf->dev.driver);
1635                                 if (!driver->reset_resume ||
1636                                                 intf->needs_remote_wakeup)
1637                                         return -EOPNOTSUPP;
1638                         }
1639                 }
1640         }
1641         if (w && !device_can_wakeup(&udev->dev)) {
1642                 dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
1643                 return -EOPNOTSUPP;
1644         }
1645         udev->do_remote_wakeup = w;
1646         return 0;
1647 }
1648
1649 int usb_runtime_suspend(struct device *dev)
1650 {
1651         struct usb_device       *udev = to_usb_device(dev);
1652         int                     status;
1653
1654         /* A USB device can be suspended if it passes the various autosuspend
1655          * checks.  Runtime suspend for a USB device means suspending all the
1656          * interfaces and then the device itself.
1657          */
1658         if (autosuspend_check(udev) != 0)
1659                 return -EAGAIN;
1660
1661         status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1662         /* The PM core reacts badly unless the return code is 0,
1663          * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
1664          */
1665         if (status != 0)
1666                 return -EBUSY;
1667         return status;
1668 }
1669
1670 int usb_runtime_resume(struct device *dev)
1671 {
1672         struct usb_device       *udev = to_usb_device(dev);
1673         int                     status;
1674
1675         /* Runtime resume for a USB device means resuming both the device
1676          * and all its interfaces.
1677          */
1678         status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1679         return status;
1680 }
1681
1682 int usb_runtime_idle(struct device *dev)
1683 {
1684         struct usb_device       *udev = to_usb_device(dev);
1685
1686         /* An idle USB device can be suspended if it passes the various
1687          * autosuspend checks.
1688          */
1689         if (autosuspend_check(udev) == 0)
1690                 pm_runtime_autosuspend(dev);
1691         return 0;
1692 }
1693
1694 #endif /* CONFIG_USB_SUSPEND */
1695
1696 struct bus_type usb_bus_type = {
1697         .name =         "usb",
1698         .match =        usb_device_match,
1699         .uevent =       usb_uevent,
1700 };