2 * drivers/usb/driver.c - most of the driver model stuff for usb
4 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de>
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
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
25 #include <linux/device.h>
26 #include <linux/slab.h>
27 #include <linux/export.h>
28 #include <linux/usb.h>
29 #include <linux/usb/quirks.h>
30 #include <linux/usb/hcd.h>
38 * Adds a new dynamic USBdevice ID to this driver,
39 * and cause the driver to probe for all devices again.
41 ssize_t usb_store_new_id(struct usb_dynids *dynids,
42 struct device_driver *driver,
43 const char *buf, size_t count)
45 struct usb_dynid *dynid;
48 unsigned int bInterfaceClass = 0;
52 fields = sscanf(buf, "%x %x %x", &idVendor, &idProduct,
57 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL);
61 INIT_LIST_HEAD(&dynid->node);
62 dynid->id.idVendor = idVendor;
63 dynid->id.idProduct = idProduct;
64 dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE;
66 dynid->id.bInterfaceClass = (u8)bInterfaceClass;
67 dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS;
70 spin_lock(&dynids->lock);
71 list_add_tail(&dynid->node, &dynids->list);
72 spin_unlock(&dynids->lock);
74 retval = driver_attach(driver);
80 EXPORT_SYMBOL_GPL(usb_store_new_id);
82 ssize_t usb_show_dynids(struct usb_dynids *dynids, char *buf)
84 struct usb_dynid *dynid;
87 list_for_each_entry(dynid, &dynids->list, node)
88 if (dynid->id.bInterfaceClass != 0)
89 count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x %02x\n",
90 dynid->id.idVendor, dynid->id.idProduct,
91 dynid->id.bInterfaceClass);
93 count += scnprintf(&buf[count], PAGE_SIZE - count, "%04x %04x\n",
94 dynid->id.idVendor, dynid->id.idProduct);
97 EXPORT_SYMBOL_GPL(usb_show_dynids);
99 static ssize_t show_dynids(struct device_driver *driver, char *buf)
101 struct usb_driver *usb_drv = to_usb_driver(driver);
103 return usb_show_dynids(&usb_drv->dynids, buf);
106 static ssize_t store_new_id(struct device_driver *driver,
107 const char *buf, size_t count)
109 struct usb_driver *usb_drv = to_usb_driver(driver);
111 return usb_store_new_id(&usb_drv->dynids, driver, buf, count);
113 static DRIVER_ATTR(new_id, S_IRUGO | S_IWUSR, show_dynids, store_new_id);
116 * store_remove_id - remove a USB device ID from this driver
117 * @driver: target device driver
118 * @buf: buffer for scanning device ID data
121 * Removes a dynamic usb device ID from this driver.
124 store_remove_id(struct device_driver *driver, const char *buf, size_t count)
126 struct usb_dynid *dynid, *n;
127 struct usb_driver *usb_driver = to_usb_driver(driver);
132 fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
136 spin_lock(&usb_driver->dynids.lock);
137 list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) {
138 struct usb_device_id *id = &dynid->id;
139 if ((id->idVendor == idVendor) &&
140 (id->idProduct == idProduct)) {
141 list_del(&dynid->node);
146 spin_unlock(&usb_driver->dynids.lock);
149 static DRIVER_ATTR(remove_id, S_IRUGO | S_IWUSR, show_dynids, store_remove_id);
151 static int usb_create_newid_files(struct usb_driver *usb_drv)
155 if (usb_drv->no_dynamic_id)
158 if (usb_drv->probe != NULL) {
159 error = driver_create_file(&usb_drv->drvwrap.driver,
160 &driver_attr_new_id);
162 error = driver_create_file(&usb_drv->drvwrap.driver,
163 &driver_attr_remove_id);
165 driver_remove_file(&usb_drv->drvwrap.driver,
166 &driver_attr_new_id);
173 static void usb_remove_newid_files(struct usb_driver *usb_drv)
175 if (usb_drv->no_dynamic_id)
178 if (usb_drv->probe != NULL) {
179 driver_remove_file(&usb_drv->drvwrap.driver,
180 &driver_attr_remove_id);
181 driver_remove_file(&usb_drv->drvwrap.driver,
182 &driver_attr_new_id);
186 static void usb_free_dynids(struct usb_driver *usb_drv)
188 struct usb_dynid *dynid, *n;
190 spin_lock(&usb_drv->dynids.lock);
191 list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) {
192 list_del(&dynid->node);
195 spin_unlock(&usb_drv->dynids.lock);
198 static inline int usb_create_newid_files(struct usb_driver *usb_drv)
203 static void usb_remove_newid_files(struct usb_driver *usb_drv)
207 static inline void usb_free_dynids(struct usb_driver *usb_drv)
212 static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf,
213 struct usb_driver *drv)
215 struct usb_dynid *dynid;
217 spin_lock(&drv->dynids.lock);
218 list_for_each_entry(dynid, &drv->dynids.list, node) {
219 if (usb_match_one_id(intf, &dynid->id)) {
220 spin_unlock(&drv->dynids.lock);
224 spin_unlock(&drv->dynids.lock);
229 /* called from driver core with dev locked */
230 static int usb_probe_device(struct device *dev)
232 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
233 struct usb_device *udev = to_usb_device(dev);
236 dev_dbg(dev, "%s\n", __func__);
238 /* TODO: Add real matching code */
240 /* The device should always appear to be in use
241 * unless the driver suports autosuspend.
243 if (!udriver->supports_autosuspend)
244 error = usb_autoresume_device(udev);
247 error = udriver->probe(udev);
251 /* called from driver core with dev locked */
252 static int usb_unbind_device(struct device *dev)
254 struct usb_device *udev = to_usb_device(dev);
255 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver);
257 udriver->disconnect(udev);
258 if (!udriver->supports_autosuspend)
259 usb_autosuspend_device(udev);
264 * Cancel any pending scheduled resets
266 * [see usb_queue_reset_device()]
268 * Called after unconfiguring / when releasing interfaces. See
269 * comments in __usb_queue_reset_device() regarding
270 * udev->reset_running.
272 static void usb_cancel_queued_reset(struct usb_interface *iface)
274 if (iface->reset_running == 0)
275 cancel_work_sync(&iface->reset_ws);
278 /* called from driver core with dev locked */
279 static int usb_probe_interface(struct device *dev)
281 struct usb_driver *driver = to_usb_driver(dev->driver);
282 struct usb_interface *intf = to_usb_interface(dev);
283 struct usb_device *udev = interface_to_usbdev(intf);
284 const struct usb_device_id *id;
286 int lpm_disable_error;
288 dev_dbg(dev, "%s\n", __func__);
290 intf->needs_binding = 0;
292 if (usb_device_is_owned(udev))
295 if (udev->authorized == 0) {
296 dev_err(&intf->dev, "Device is not authorized for usage\n");
300 id = usb_match_id(intf, driver->id_table);
302 id = usb_match_dynamic_id(intf, driver);
306 dev_dbg(dev, "%s - got id\n", __func__);
308 error = usb_autoresume_device(udev);
312 intf->condition = USB_INTERFACE_BINDING;
314 /* Probed interfaces are initially active. They are
315 * runtime-PM-enabled only if the driver has autosuspend support.
316 * They are sensitive to their children's power states.
318 pm_runtime_set_active(dev);
319 pm_suspend_ignore_children(dev, false);
320 if (driver->supports_autosuspend)
321 pm_runtime_enable(dev);
323 /* If the new driver doesn't allow hub-initiated LPM, and we can't
324 * disable hub-initiated LPM, then fail the probe.
326 * Otherwise, leaving LPM enabled should be harmless, because the
327 * endpoint intervals should remain the same, and the U1/U2 timeouts
328 * should remain the same.
330 * If we need to install alt setting 0 before probe, or another alt
331 * setting during probe, that should also be fine. usb_set_interface()
332 * will attempt to disable LPM, and fail if it can't disable it.
334 lpm_disable_error = usb_unlocked_disable_lpm(udev);
335 if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
336 dev_err(&intf->dev, "%s Failed to disable LPM for driver %s\n.",
337 __func__, driver->name);
338 error = lpm_disable_error;
342 /* Carry out a deferred switch to altsetting 0 */
343 if (intf->needs_altsetting0) {
344 error = usb_set_interface(udev, intf->altsetting[0].
345 desc.bInterfaceNumber, 0);
348 intf->needs_altsetting0 = 0;
351 error = driver->probe(intf, id);
355 intf->condition = USB_INTERFACE_BOUND;
357 /* If the LPM disable succeeded, balance the ref counts. */
358 if (!lpm_disable_error)
359 usb_unlocked_enable_lpm(udev);
361 usb_autosuspend_device(udev);
365 usb_set_intfdata(intf, NULL);
366 intf->needs_remote_wakeup = 0;
367 intf->condition = USB_INTERFACE_UNBOUND;
368 usb_cancel_queued_reset(intf);
370 /* Unbound interfaces are always runtime-PM-disabled and -suspended */
371 if (driver->supports_autosuspend)
372 pm_runtime_disable(dev);
373 pm_runtime_set_suspended(dev);
375 usb_autosuspend_device(udev);
379 /* called from driver core with dev locked */
380 static int usb_unbind_interface(struct device *dev)
382 struct usb_driver *driver = to_usb_driver(dev->driver);
383 struct usb_interface *intf = to_usb_interface(dev);
384 struct usb_device *udev;
385 int error, r, lpm_disable_error;
387 intf->condition = USB_INTERFACE_UNBINDING;
389 /* Autoresume for set_interface call below */
390 udev = interface_to_usbdev(intf);
391 error = usb_autoresume_device(udev);
393 /* Hub-initiated LPM policy may change, so attempt to disable LPM until
394 * the driver is unbound. If LPM isn't disabled, that's fine because it
395 * wouldn't be enabled unless all the bound interfaces supported
398 lpm_disable_error = usb_unlocked_disable_lpm(udev);
400 /* Terminate all URBs for this interface unless the driver
401 * supports "soft" unbinding.
403 if (!driver->soft_unbind)
404 usb_disable_interface(udev, intf, false);
406 driver->disconnect(intf);
407 usb_cancel_queued_reset(intf);
409 /* Reset other interface state.
410 * We cannot do a Set-Interface if the device is suspended or
411 * if it is prepared for a system sleep (since installing a new
412 * altsetting means creating new endpoint device entries).
413 * When either of these happens, defer the Set-Interface.
415 if (intf->cur_altsetting->desc.bAlternateSetting == 0) {
416 /* Already in altsetting 0 so skip Set-Interface.
417 * Just re-enable it without affecting the endpoint toggles.
419 usb_enable_interface(udev, intf, false);
420 } else if (!error && !intf->dev.power.is_prepared) {
421 r = usb_set_interface(udev, intf->altsetting[0].
422 desc.bInterfaceNumber, 0);
424 intf->needs_altsetting0 = 1;
426 intf->needs_altsetting0 = 1;
428 usb_set_intfdata(intf, NULL);
430 intf->condition = USB_INTERFACE_UNBOUND;
431 intf->needs_remote_wakeup = 0;
433 /* Attempt to re-enable USB3 LPM, if the disable succeeded. */
434 if (!lpm_disable_error)
435 usb_unlocked_enable_lpm(udev);
437 /* Unbound interfaces are always runtime-PM-disabled and -suspended */
438 if (driver->supports_autosuspend)
439 pm_runtime_disable(dev);
440 pm_runtime_set_suspended(dev);
442 /* Undo any residual pm_autopm_get_interface_* calls */
443 for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r)
444 usb_autopm_put_interface_no_suspend(intf);
445 atomic_set(&intf->pm_usage_cnt, 0);
448 usb_autosuspend_device(udev);
454 * usb_driver_claim_interface - bind a driver to an interface
455 * @driver: the driver to be bound
456 * @iface: the interface to which it will be bound; must be in the
457 * usb device's active configuration
458 * @priv: driver data associated with that interface
460 * This is used by usb device drivers that need to claim more than one
461 * interface on a device when probing (audio and acm are current examples).
462 * No device driver should directly modify internal usb_interface or
463 * usb_device structure members.
465 * Few drivers should need to use this routine, since the most natural
466 * way to bind to an interface is to return the private data from
467 * the driver's probe() method.
469 * Callers must own the device lock, so driver probe() entries don't need
470 * extra locking, but other call contexts may need to explicitly claim that
473 int usb_driver_claim_interface(struct usb_driver *driver,
474 struct usb_interface *iface, void *priv)
476 struct device *dev = &iface->dev;
477 struct usb_device *udev;
479 int lpm_disable_error;
484 udev = interface_to_usbdev(iface);
486 dev->driver = &driver->drvwrap.driver;
487 usb_set_intfdata(iface, priv);
488 iface->needs_binding = 0;
490 iface->condition = USB_INTERFACE_BOUND;
492 /* Disable LPM until this driver is bound. */
493 lpm_disable_error = usb_unlocked_disable_lpm(udev);
494 if (lpm_disable_error && driver->disable_hub_initiated_lpm) {
495 dev_err(&iface->dev, "%s Failed to disable LPM for driver %s\n.",
496 __func__, driver->name);
500 /* Claimed interfaces are initially inactive (suspended) and
501 * runtime-PM-enabled, but only if the driver has autosuspend
502 * support. Otherwise they are marked active, to prevent the
503 * device from being autosuspended, but left disabled. In either
504 * case they are sensitive to their children's power states.
506 pm_suspend_ignore_children(dev, false);
507 if (driver->supports_autosuspend)
508 pm_runtime_enable(dev);
510 pm_runtime_set_active(dev);
512 /* if interface was already added, bind now; else let
513 * the future device_add() bind it, bypassing probe()
515 if (device_is_registered(dev))
516 retval = device_bind_driver(dev);
518 /* Attempt to re-enable USB3 LPM, if the disable was successful. */
519 if (!lpm_disable_error)
520 usb_unlocked_enable_lpm(udev);
524 EXPORT_SYMBOL_GPL(usb_driver_claim_interface);
527 * usb_driver_release_interface - unbind a driver from an interface
528 * @driver: the driver to be unbound
529 * @iface: the interface from which it will be unbound
531 * This can be used by drivers to release an interface without waiting
532 * for their disconnect() methods to be called. In typical cases this
533 * also causes the driver disconnect() method to be called.
535 * This call is synchronous, and may not be used in an interrupt context.
536 * Callers must own the device lock, so driver disconnect() entries don't
537 * need extra locking, but other call contexts may need to explicitly claim
540 void usb_driver_release_interface(struct usb_driver *driver,
541 struct usb_interface *iface)
543 struct device *dev = &iface->dev;
545 /* this should never happen, don't release something that's not ours */
546 if (!dev->driver || dev->driver != &driver->drvwrap.driver)
549 /* don't release from within disconnect() */
550 if (iface->condition != USB_INTERFACE_BOUND)
552 iface->condition = USB_INTERFACE_UNBINDING;
554 /* Release via the driver core only if the interface
555 * has already been registered
557 if (device_is_registered(dev)) {
558 device_release_driver(dev);
561 usb_unbind_interface(dev);
566 EXPORT_SYMBOL_GPL(usb_driver_release_interface);
568 /* returns 0 if no match, 1 if match */
569 int usb_match_device(struct usb_device *dev, const struct usb_device_id *id)
571 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
572 id->idVendor != le16_to_cpu(dev->descriptor.idVendor))
575 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) &&
576 id->idProduct != le16_to_cpu(dev->descriptor.idProduct))
579 /* No need to test id->bcdDevice_lo != 0, since 0 is never
580 greater than any unsigned number. */
581 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) &&
582 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice)))
585 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) &&
586 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice)))
589 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) &&
590 (id->bDeviceClass != dev->descriptor.bDeviceClass))
593 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) &&
594 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass))
597 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) &&
598 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol))
604 /* returns 0 if no match, 1 if match */
605 int usb_match_one_id_intf(struct usb_device *dev,
606 struct usb_host_interface *intf,
607 const struct usb_device_id *id)
609 /* The interface class, subclass, protocol and number should never be
610 * checked for a match if the device class is Vendor Specific,
611 * unless the match record specifies the Vendor ID. */
612 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC &&
613 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) &&
614 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS |
615 USB_DEVICE_ID_MATCH_INT_SUBCLASS |
616 USB_DEVICE_ID_MATCH_INT_PROTOCOL |
617 USB_DEVICE_ID_MATCH_INT_NUMBER)))
620 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) &&
621 (id->bInterfaceClass != intf->desc.bInterfaceClass))
624 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) &&
625 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass))
628 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) &&
629 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol))
632 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_NUMBER) &&
633 (id->bInterfaceNumber != intf->desc.bInterfaceNumber))
639 /* returns 0 if no match, 1 if match */
640 int usb_match_one_id(struct usb_interface *interface,
641 const struct usb_device_id *id)
643 struct usb_host_interface *intf;
644 struct usb_device *dev;
646 /* proc_connectinfo in devio.c may call us with id == NULL. */
650 intf = interface->cur_altsetting;
651 dev = interface_to_usbdev(interface);
653 if (!usb_match_device(dev, id))
656 return usb_match_one_id_intf(dev, intf, id);
658 EXPORT_SYMBOL_GPL(usb_match_one_id);
661 * usb_match_id - find first usb_device_id matching device or interface
662 * @interface: the interface of interest
663 * @id: array of usb_device_id structures, terminated by zero entry
665 * usb_match_id searches an array of usb_device_id's and returns
666 * the first one matching the device or interface, or null.
667 * This is used when binding (or rebinding) a driver to an interface.
668 * Most USB device drivers will use this indirectly, through the usb core,
669 * but some layered driver frameworks use it directly.
670 * These device tables are exported with MODULE_DEVICE_TABLE, through
671 * modutils, to support the driver loading functionality of USB hotplugging.
675 * The "match_flags" element in a usb_device_id controls which
676 * members are used. If the corresponding bit is set, the
677 * value in the device_id must match its corresponding member
678 * in the device or interface descriptor, or else the device_id
681 * "driver_info" is normally used only by device drivers,
682 * but you can create a wildcard "matches anything" usb_device_id
683 * as a driver's "modules.usbmap" entry if you provide an id with
684 * only a nonzero "driver_info" field. If you do this, the USB device
685 * driver's probe() routine should use additional intelligence to
686 * decide whether to bind to the specified interface.
688 * What Makes Good usb_device_id Tables:
690 * The match algorithm is very simple, so that intelligence in
691 * driver selection must come from smart driver id records.
692 * Unless you have good reasons to use another selection policy,
693 * provide match elements only in related groups, and order match
694 * specifiers from specific to general. Use the macros provided
695 * for that purpose if you can.
697 * The most specific match specifiers use device descriptor
698 * data. These are commonly used with product-specific matches;
699 * the USB_DEVICE macro lets you provide vendor and product IDs,
700 * and you can also match against ranges of product revisions.
701 * These are widely used for devices with application or vendor
702 * specific bDeviceClass values.
704 * Matches based on device class/subclass/protocol specifications
705 * are slightly more general; use the USB_DEVICE_INFO macro, or
706 * its siblings. These are used with single-function devices
707 * where bDeviceClass doesn't specify that each interface has
710 * Matches based on interface class/subclass/protocol are the
711 * most general; they let drivers bind to any interface on a
712 * multiple-function device. Use the USB_INTERFACE_INFO
713 * macro, or its siblings, to match class-per-interface style
714 * devices (as recorded in bInterfaceClass).
716 * Note that an entry created by USB_INTERFACE_INFO won't match
717 * any interface if the device class is set to Vendor-Specific.
718 * This is deliberate; according to the USB spec the meanings of
719 * the interface class/subclass/protocol for these devices are also
720 * vendor-specific, and hence matching against a standard product
721 * class wouldn't work anyway. If you really want to use an
722 * interface-based match for such a device, create a match record
723 * that also specifies the vendor ID. (Unforunately there isn't a
724 * standard macro for creating records like this.)
726 * Within those groups, remember that not all combinations are
727 * meaningful. For example, don't give a product version range
728 * without vendor and product IDs; or specify a protocol without
729 * its associated class and subclass.
731 const struct usb_device_id *usb_match_id(struct usb_interface *interface,
732 const struct usb_device_id *id)
734 /* proc_connectinfo in devio.c may call us with id == NULL. */
738 /* It is important to check that id->driver_info is nonzero,
739 since an entry that is all zeroes except for a nonzero
740 id->driver_info is the way to create an entry that
741 indicates that the driver want to examine every
742 device and interface. */
743 for (; id->idVendor || id->idProduct || id->bDeviceClass ||
744 id->bInterfaceClass || id->driver_info; id++) {
745 if (usb_match_one_id(interface, id))
751 EXPORT_SYMBOL_GPL(usb_match_id);
753 static int usb_device_match(struct device *dev, struct device_driver *drv)
755 /* devices and interfaces are handled separately */
756 if (is_usb_device(dev)) {
758 /* interface drivers never match devices */
759 if (!is_usb_device_driver(drv))
762 /* TODO: Add real matching code */
765 } else if (is_usb_interface(dev)) {
766 struct usb_interface *intf;
767 struct usb_driver *usb_drv;
768 const struct usb_device_id *id;
770 /* device drivers never match interfaces */
771 if (is_usb_device_driver(drv))
774 intf = to_usb_interface(dev);
775 usb_drv = to_usb_driver(drv);
777 id = usb_match_id(intf, usb_drv->id_table);
781 id = usb_match_dynamic_id(intf, usb_drv);
789 #ifdef CONFIG_HOTPLUG
790 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
792 struct usb_device *usb_dev;
794 if (is_usb_device(dev)) {
795 usb_dev = to_usb_device(dev);
796 } else if (is_usb_interface(dev)) {
797 struct usb_interface *intf = to_usb_interface(dev);
799 usb_dev = interface_to_usbdev(intf);
804 if (usb_dev->devnum < 0) {
805 /* driver is often null here; dev_dbg() would oops */
806 pr_debug("usb %s: already deleted?\n", dev_name(dev));
810 pr_debug("usb %s: bus removed?\n", dev_name(dev));
814 /* per-device configurations are common */
815 if (add_uevent_var(env, "PRODUCT=%x/%x/%x",
816 le16_to_cpu(usb_dev->descriptor.idVendor),
817 le16_to_cpu(usb_dev->descriptor.idProduct),
818 le16_to_cpu(usb_dev->descriptor.bcdDevice)))
821 /* class-based driver binding models */
822 if (add_uevent_var(env, "TYPE=%d/%d/%d",
823 usb_dev->descriptor.bDeviceClass,
824 usb_dev->descriptor.bDeviceSubClass,
825 usb_dev->descriptor.bDeviceProtocol))
833 static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
837 #endif /* CONFIG_HOTPLUG */
840 * usb_register_device_driver - register a USB device (not interface) driver
841 * @new_udriver: USB operations for the device driver
842 * @owner: module owner of this driver.
844 * Registers a USB device driver with the USB core. The list of
845 * unattached devices will be rescanned whenever a new driver is
846 * added, allowing the new driver to attach to any recognized devices.
847 * Returns a negative error code on failure and 0 on success.
849 int usb_register_device_driver(struct usb_device_driver *new_udriver,
850 struct module *owner)
857 new_udriver->drvwrap.for_devices = 1;
858 new_udriver->drvwrap.driver.name = (char *) new_udriver->name;
859 new_udriver->drvwrap.driver.bus = &usb_bus_type;
860 new_udriver->drvwrap.driver.probe = usb_probe_device;
861 new_udriver->drvwrap.driver.remove = usb_unbind_device;
862 new_udriver->drvwrap.driver.owner = owner;
864 retval = driver_register(&new_udriver->drvwrap.driver);
867 pr_info("%s: registered new device driver %s\n",
868 usbcore_name, new_udriver->name);
870 printk(KERN_ERR "%s: error %d registering device "
872 usbcore_name, retval, new_udriver->name);
876 EXPORT_SYMBOL_GPL(usb_register_device_driver);
879 * usb_deregister_device_driver - unregister a USB device (not interface) driver
880 * @udriver: USB operations of the device driver to unregister
881 * Context: must be able to sleep
883 * Unlinks the specified driver from the internal USB driver list.
885 void usb_deregister_device_driver(struct usb_device_driver *udriver)
887 pr_info("%s: deregistering device driver %s\n",
888 usbcore_name, udriver->name);
890 driver_unregister(&udriver->drvwrap.driver);
892 EXPORT_SYMBOL_GPL(usb_deregister_device_driver);
895 * usb_register_driver - register a USB interface driver
896 * @new_driver: USB operations for the interface driver
897 * @owner: module owner of this driver.
898 * @mod_name: module name string
900 * Registers a USB interface driver with the USB core. The list of
901 * unattached interfaces will be rescanned whenever a new driver is
902 * added, allowing the new driver to attach to any recognized interfaces.
903 * Returns a negative error code on failure and 0 on success.
905 * NOTE: if you want your driver to use the USB major number, you must call
906 * usb_register_dev() to enable that functionality. This function no longer
907 * takes care of that.
909 int usb_register_driver(struct usb_driver *new_driver, struct module *owner,
910 const char *mod_name)
917 new_driver->drvwrap.for_devices = 0;
918 new_driver->drvwrap.driver.name = (char *) new_driver->name;
919 new_driver->drvwrap.driver.bus = &usb_bus_type;
920 new_driver->drvwrap.driver.probe = usb_probe_interface;
921 new_driver->drvwrap.driver.remove = usb_unbind_interface;
922 new_driver->drvwrap.driver.owner = owner;
923 new_driver->drvwrap.driver.mod_name = mod_name;
924 spin_lock_init(&new_driver->dynids.lock);
925 INIT_LIST_HEAD(&new_driver->dynids.list);
927 retval = driver_register(&new_driver->drvwrap.driver);
931 retval = usb_create_newid_files(new_driver);
935 pr_info("%s: registered new interface driver %s\n",
936 usbcore_name, new_driver->name);
942 driver_unregister(&new_driver->drvwrap.driver);
944 printk(KERN_ERR "%s: error %d registering interface "
946 usbcore_name, retval, new_driver->name);
949 EXPORT_SYMBOL_GPL(usb_register_driver);
952 * usb_deregister - unregister a USB interface driver
953 * @driver: USB operations of the interface driver to unregister
954 * Context: must be able to sleep
956 * Unlinks the specified driver from the internal USB driver list.
958 * NOTE: If you called usb_register_dev(), you still need to call
959 * usb_deregister_dev() to clean up your driver's allocated minor numbers,
960 * this * call will no longer do it for you.
962 void usb_deregister(struct usb_driver *driver)
964 pr_info("%s: deregistering interface driver %s\n",
965 usbcore_name, driver->name);
967 usb_remove_newid_files(driver);
968 driver_unregister(&driver->drvwrap.driver);
969 usb_free_dynids(driver);
971 EXPORT_SYMBOL_GPL(usb_deregister);
973 /* Forced unbinding of a USB interface driver, either because
974 * it doesn't support pre_reset/post_reset/reset_resume or
975 * because it doesn't support suspend/resume.
977 * The caller must hold @intf's device's lock, but not its pm_mutex
978 * and not @intf->dev.sem.
980 void usb_forced_unbind_intf(struct usb_interface *intf)
982 struct usb_driver *driver = to_usb_driver(intf->dev.driver);
984 dev_dbg(&intf->dev, "forced unbind\n");
985 usb_driver_release_interface(driver, intf);
987 /* Mark the interface for later rebinding */
988 intf->needs_binding = 1;
991 /* Delayed forced unbinding of a USB interface driver and scan
994 * The caller must hold @intf's device's lock, but not its pm_mutex
995 * and not @intf->dev.sem.
997 * Note: Rebinds will be skipped if a system sleep transition is in
998 * progress and the PM "complete" callback hasn't occurred yet.
1000 void usb_rebind_intf(struct usb_interface *intf)
1004 /* Delayed unbind of an existing driver */
1005 if (intf->dev.driver)
1006 usb_forced_unbind_intf(intf);
1008 /* Try to rebind the interface */
1009 if (!intf->dev.power.is_prepared) {
1010 intf->needs_binding = 0;
1011 rc = device_attach(&intf->dev);
1013 dev_warn(&intf->dev, "rebind failed: %d\n", rc);
1019 /* Unbind drivers for @udev's interfaces that don't support suspend/resume
1020 * There is no check for reset_resume here because it can be determined
1021 * only during resume whether reset_resume is needed.
1023 * The caller must hold @udev's device lock.
1025 static void unbind_no_pm_drivers_interfaces(struct usb_device *udev)
1027 struct usb_host_config *config;
1029 struct usb_interface *intf;
1030 struct usb_driver *drv;
1032 config = udev->actconfig;
1034 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1035 intf = config->interface[i];
1037 if (intf->dev.driver) {
1038 drv = to_usb_driver(intf->dev.driver);
1039 if (!drv->suspend || !drv->resume)
1040 usb_forced_unbind_intf(intf);
1046 /* Unbind drivers for @udev's interfaces that failed to support reset-resume.
1047 * These interfaces have the needs_binding flag set by usb_resume_interface().
1049 * The caller must hold @udev's device lock.
1051 static void unbind_no_reset_resume_drivers_interfaces(struct usb_device *udev)
1053 struct usb_host_config *config;
1055 struct usb_interface *intf;
1057 config = udev->actconfig;
1059 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1060 intf = config->interface[i];
1061 if (intf->dev.driver && intf->needs_binding)
1062 usb_forced_unbind_intf(intf);
1067 static void do_rebind_interfaces(struct usb_device *udev)
1069 struct usb_host_config *config;
1071 struct usb_interface *intf;
1073 config = udev->actconfig;
1075 for (i = 0; i < config->desc.bNumInterfaces; ++i) {
1076 intf = config->interface[i];
1077 if (intf->needs_binding)
1078 usb_rebind_intf(intf);
1083 static int usb_suspend_device(struct usb_device *udev, pm_message_t msg)
1085 struct usb_device_driver *udriver;
1088 if (udev->state == USB_STATE_NOTATTACHED ||
1089 udev->state == USB_STATE_SUSPENDED)
1092 /* For devices that don't have a driver, we do a generic suspend. */
1093 if (udev->dev.driver)
1094 udriver = to_usb_device_driver(udev->dev.driver);
1096 udev->do_remote_wakeup = 0;
1097 udriver = &usb_generic_driver;
1099 status = udriver->suspend(udev, msg);
1102 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1106 static int usb_resume_device(struct usb_device *udev, pm_message_t msg)
1108 struct usb_device_driver *udriver;
1111 if (udev->state == USB_STATE_NOTATTACHED)
1114 /* Can't resume it if it doesn't have a driver. */
1115 if (udev->dev.driver == NULL) {
1120 /* Non-root devices on a full/low-speed bus must wait for their
1121 * companion high-speed root hub, in case a handoff is needed.
1123 if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion)
1124 device_pm_wait_for_dev(&udev->dev,
1125 &udev->bus->hs_companion->root_hub->dev);
1127 if (udev->quirks & USB_QUIRK_RESET_RESUME)
1128 udev->reset_resume = 1;
1130 udriver = to_usb_device_driver(udev->dev.driver);
1131 status = udriver->resume(udev, msg);
1134 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1138 static int usb_suspend_interface(struct usb_device *udev,
1139 struct usb_interface *intf, pm_message_t msg)
1141 struct usb_driver *driver;
1144 if (udev->state == USB_STATE_NOTATTACHED ||
1145 intf->condition == USB_INTERFACE_UNBOUND)
1147 driver = to_usb_driver(intf->dev.driver);
1149 /* at this time we know the driver supports suspend */
1150 status = driver->suspend(intf, msg);
1151 if (status && !PMSG_IS_AUTO(msg))
1152 dev_err(&intf->dev, "suspend error %d\n", status);
1155 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1159 static int usb_resume_interface(struct usb_device *udev,
1160 struct usb_interface *intf, pm_message_t msg, int reset_resume)
1162 struct usb_driver *driver;
1165 if (udev->state == USB_STATE_NOTATTACHED)
1168 /* Don't let autoresume interfere with unbinding */
1169 if (intf->condition == USB_INTERFACE_UNBINDING)
1172 /* Can't resume it if it doesn't have a driver. */
1173 if (intf->condition == USB_INTERFACE_UNBOUND) {
1175 /* Carry out a deferred switch to altsetting 0 */
1176 if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) {
1177 usb_set_interface(udev, intf->altsetting[0].
1178 desc.bInterfaceNumber, 0);
1179 intf->needs_altsetting0 = 0;
1184 /* Don't resume if the interface is marked for rebinding */
1185 if (intf->needs_binding)
1187 driver = to_usb_driver(intf->dev.driver);
1190 if (driver->reset_resume) {
1191 status = driver->reset_resume(intf);
1193 dev_err(&intf->dev, "%s error %d\n",
1194 "reset_resume", status);
1196 intf->needs_binding = 1;
1197 dev_warn(&intf->dev, "no %s for driver %s?\n",
1198 "reset_resume", driver->name);
1201 status = driver->resume(intf);
1203 dev_err(&intf->dev, "resume error %d\n", status);
1207 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status);
1209 /* Later we will unbind the driver and/or reprobe, if necessary */
1214 * usb_suspend_both - suspend a USB device and its interfaces
1215 * @udev: the usb_device to suspend
1216 * @msg: Power Management message describing this state transition
1218 * This is the central routine for suspending USB devices. It calls the
1219 * suspend methods for all the interface drivers in @udev and then calls
1220 * the suspend method for @udev itself. If an error occurs at any stage,
1221 * all the interfaces which were suspended are resumed so that they remain
1222 * in the same state as the device.
1224 * Autosuspend requests originating from a child device or an interface
1225 * driver may be made without the protection of @udev's device lock, but
1226 * all other suspend calls will hold the lock. Usbcore will insure that
1227 * method calls do not arrive during bind, unbind, or reset operations.
1228 * However drivers must be prepared to handle suspend calls arriving at
1229 * unpredictable times.
1231 * This routine can run only in process context.
1233 static int usb_suspend_both(struct usb_device *udev, pm_message_t msg)
1237 struct usb_interface *intf;
1239 if (udev->state == USB_STATE_NOTATTACHED ||
1240 udev->state == USB_STATE_SUSPENDED)
1243 /* Suspend all the interfaces and then udev itself */
1244 if (udev->actconfig) {
1245 n = udev->actconfig->desc.bNumInterfaces;
1246 for (i = n - 1; i >= 0; --i) {
1247 intf = udev->actconfig->interface[i];
1248 status = usb_suspend_interface(udev, intf, msg);
1250 /* Ignore errors during system sleep transitions */
1251 if (!PMSG_IS_AUTO(msg))
1258 status = usb_suspend_device(udev, msg);
1261 * Ignore errors from non-root-hub devices during
1262 * system sleep transitions. For the most part,
1263 * these devices should go to low power anyway when
1264 * the entire bus is suspended.
1266 if (udev->parent && !PMSG_IS_AUTO(msg))
1270 /* If the suspend failed, resume interfaces that did get suspended */
1272 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME);
1274 intf = udev->actconfig->interface[i];
1275 usb_resume_interface(udev, intf, msg, 0);
1278 /* If the suspend succeeded then prevent any more URB submissions
1279 * and flush any outstanding URBs.
1282 udev->can_submit = 0;
1283 for (i = 0; i < 16; ++i) {
1284 usb_hcd_flush_endpoint(udev, udev->ep_out[i]);
1285 usb_hcd_flush_endpoint(udev, udev->ep_in[i]);
1290 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1295 * usb_resume_both - resume a USB device and its interfaces
1296 * @udev: the usb_device to resume
1297 * @msg: Power Management message describing this state transition
1299 * This is the central routine for resuming USB devices. It calls the
1300 * the resume method for @udev and then calls the resume methods for all
1301 * the interface drivers in @udev.
1303 * Autoresume requests originating from a child device or an interface
1304 * driver may be made without the protection of @udev's device lock, but
1305 * all other resume calls will hold the lock. Usbcore will insure that
1306 * method calls do not arrive during bind, unbind, or reset operations.
1307 * However drivers must be prepared to handle resume calls arriving at
1308 * unpredictable times.
1310 * This routine can run only in process context.
1312 static int usb_resume_both(struct usb_device *udev, pm_message_t msg)
1316 struct usb_interface *intf;
1318 if (udev->state == USB_STATE_NOTATTACHED) {
1322 udev->can_submit = 1;
1324 /* Resume the device */
1325 if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume)
1326 status = usb_resume_device(udev, msg);
1328 /* Resume the interfaces */
1329 if (status == 0 && udev->actconfig) {
1330 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1331 intf = udev->actconfig->interface[i];
1332 usb_resume_interface(udev, intf, msg,
1333 udev->reset_resume);
1336 usb_mark_last_busy(udev);
1339 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status);
1341 udev->reset_resume = 0;
1345 static void choose_wakeup(struct usb_device *udev, pm_message_t msg)
1349 /* Remote wakeup is needed only when we actually go to sleep.
1350 * For things like FREEZE and QUIESCE, if the device is already
1351 * autosuspended then its current wakeup setting is okay.
1353 if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) {
1354 if (udev->state != USB_STATE_SUSPENDED)
1355 udev->do_remote_wakeup = 0;
1359 /* Enable remote wakeup if it is allowed, even if no interface drivers
1362 w = device_may_wakeup(&udev->dev);
1364 /* If the device is autosuspended with the wrong wakeup setting,
1365 * autoresume now so the setting can be changed.
1367 if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup)
1368 pm_runtime_resume(&udev->dev);
1369 udev->do_remote_wakeup = w;
1372 /* The device lock is held by the PM core */
1373 int usb_suspend(struct device *dev, pm_message_t msg)
1375 struct usb_device *udev = to_usb_device(dev);
1377 unbind_no_pm_drivers_interfaces(udev);
1379 /* From now on we are sure all drivers support suspend/resume
1380 * but not necessarily reset_resume()
1381 * so we may still need to unbind and rebind upon resume
1383 choose_wakeup(udev, msg);
1384 return usb_suspend_both(udev, msg);
1387 /* The device lock is held by the PM core */
1388 int usb_resume_complete(struct device *dev)
1390 struct usb_device *udev = to_usb_device(dev);
1392 /* For PM complete calls, all we do is rebind interfaces
1393 * whose needs_binding flag is set
1395 if (udev->state != USB_STATE_NOTATTACHED)
1396 do_rebind_interfaces(udev);
1400 /* The device lock is held by the PM core */
1401 int usb_resume(struct device *dev, pm_message_t msg)
1403 struct usb_device *udev = to_usb_device(dev);
1406 /* For all calls, take the device back to full power and
1407 * tell the PM core in case it was autosuspended previously.
1408 * Unbind the interfaces that will need rebinding later,
1409 * because they fail to support reset_resume.
1410 * (This can't be done in usb_resume_interface()
1411 * above because it doesn't own the right set of locks.)
1413 status = usb_resume_both(udev, msg);
1415 pm_runtime_disable(dev);
1416 pm_runtime_set_active(dev);
1417 pm_runtime_enable(dev);
1418 unbind_no_reset_resume_drivers_interfaces(udev);
1421 /* Avoid PM error messages for devices disconnected while suspended
1422 * as we'll display regular disconnect messages just a bit later.
1424 if (status == -ENODEV || status == -ESHUTDOWN)
1429 #endif /* CONFIG_PM */
1431 #ifdef CONFIG_USB_SUSPEND
1434 * usb_enable_autosuspend - allow a USB device to be autosuspended
1435 * @udev: the USB device which may be autosuspended
1437 * This routine allows @udev to be autosuspended. An autosuspend won't
1438 * take place until the autosuspend_delay has elapsed and all the other
1439 * necessary conditions are satisfied.
1441 * The caller must hold @udev's device lock.
1443 void usb_enable_autosuspend(struct usb_device *udev)
1445 pm_runtime_allow(&udev->dev);
1447 EXPORT_SYMBOL_GPL(usb_enable_autosuspend);
1450 * usb_disable_autosuspend - prevent a USB device from being autosuspended
1451 * @udev: the USB device which may not be autosuspended
1453 * This routine prevents @udev from being autosuspended and wakes it up
1454 * if it is already autosuspended.
1456 * The caller must hold @udev's device lock.
1458 void usb_disable_autosuspend(struct usb_device *udev)
1460 pm_runtime_forbid(&udev->dev);
1462 EXPORT_SYMBOL_GPL(usb_disable_autosuspend);
1465 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces
1466 * @udev: the usb_device to autosuspend
1468 * This routine should be called when a core subsystem is finished using
1469 * @udev and wants to allow it to autosuspend. Examples would be when
1470 * @udev's device file in usbfs is closed or after a configuration change.
1472 * @udev's usage counter is decremented; if it drops to 0 and all the
1473 * interfaces are inactive then a delayed autosuspend will be attempted.
1474 * The attempt may fail (see autosuspend_check()).
1476 * The caller must hold @udev's device lock.
1478 * This routine can run only in process context.
1480 void usb_autosuspend_device(struct usb_device *udev)
1484 usb_mark_last_busy(udev);
1485 status = pm_runtime_put_sync_autosuspend(&udev->dev);
1486 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1487 __func__, atomic_read(&udev->dev.power.usage_count),
1492 * usb_autoresume_device - immediately autoresume a USB device and its interfaces
1493 * @udev: the usb_device to autoresume
1495 * This routine should be called when a core subsystem wants to use @udev
1496 * and needs to guarantee that it is not suspended. No autosuspend will
1497 * occur until usb_autosuspend_device() is called. (Note that this will
1498 * not prevent suspend events originating in the PM core.) Examples would
1499 * be when @udev's device file in usbfs is opened or when a remote-wakeup
1500 * request is received.
1502 * @udev's usage counter is incremented to prevent subsequent autosuspends.
1503 * However if the autoresume fails then the usage counter is re-decremented.
1505 * The caller must hold @udev's device lock.
1507 * This routine can run only in process context.
1509 int usb_autoresume_device(struct usb_device *udev)
1513 status = pm_runtime_get_sync(&udev->dev);
1515 pm_runtime_put_sync(&udev->dev);
1516 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n",
1517 __func__, atomic_read(&udev->dev.power.usage_count),
1525 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter
1526 * @intf: the usb_interface whose counter should be decremented
1528 * This routine should be called by an interface driver when it is
1529 * finished using @intf and wants to allow it to autosuspend. A typical
1530 * example would be a character-device driver when its device file is
1533 * The routine decrements @intf's usage counter. When the counter reaches
1534 * 0, a delayed autosuspend request for @intf's device is attempted. The
1535 * attempt may fail (see autosuspend_check()).
1537 * This routine can run only in process context.
1539 void usb_autopm_put_interface(struct usb_interface *intf)
1541 struct usb_device *udev = interface_to_usbdev(intf);
1544 usb_mark_last_busy(udev);
1545 atomic_dec(&intf->pm_usage_cnt);
1546 status = pm_runtime_put_sync(&intf->dev);
1547 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1548 __func__, atomic_read(&intf->dev.power.usage_count),
1551 EXPORT_SYMBOL_GPL(usb_autopm_put_interface);
1554 * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter
1555 * @intf: the usb_interface whose counter should be decremented
1557 * This routine does much the same thing as usb_autopm_put_interface():
1558 * It decrements @intf's usage counter and schedules a delayed
1559 * autosuspend request if the counter is <= 0. The difference is that it
1560 * does not perform any synchronization; callers should hold a private
1561 * lock and handle all synchronization issues themselves.
1563 * Typically a driver would call this routine during an URB's completion
1564 * handler, if no more URBs were pending.
1566 * This routine can run in atomic context.
1568 void usb_autopm_put_interface_async(struct usb_interface *intf)
1570 struct usb_device *udev = interface_to_usbdev(intf);
1573 usb_mark_last_busy(udev);
1574 atomic_dec(&intf->pm_usage_cnt);
1575 status = pm_runtime_put(&intf->dev);
1576 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1577 __func__, atomic_read(&intf->dev.power.usage_count),
1580 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async);
1583 * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter
1584 * @intf: the usb_interface whose counter should be decremented
1586 * This routine decrements @intf's usage counter but does not carry out an
1589 * This routine can run in atomic context.
1591 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf)
1593 struct usb_device *udev = interface_to_usbdev(intf);
1595 usb_mark_last_busy(udev);
1596 atomic_dec(&intf->pm_usage_cnt);
1597 pm_runtime_put_noidle(&intf->dev);
1599 EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend);
1602 * usb_autopm_get_interface - increment a USB interface's PM-usage counter
1603 * @intf: the usb_interface whose counter should be incremented
1605 * This routine should be called by an interface driver when it wants to
1606 * use @intf and needs to guarantee that it is not suspended. In addition,
1607 * the routine prevents @intf from being autosuspended subsequently. (Note
1608 * that this will not prevent suspend events originating in the PM core.)
1609 * This prevention will persist until usb_autopm_put_interface() is called
1610 * or @intf is unbound. A typical example would be a character-device
1611 * driver when its device file is opened.
1613 * @intf's usage counter is incremented to prevent subsequent autosuspends.
1614 * However if the autoresume fails then the counter is re-decremented.
1616 * This routine can run only in process context.
1618 int usb_autopm_get_interface(struct usb_interface *intf)
1622 status = pm_runtime_get_sync(&intf->dev);
1624 pm_runtime_put_sync(&intf->dev);
1626 atomic_inc(&intf->pm_usage_cnt);
1627 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1628 __func__, atomic_read(&intf->dev.power.usage_count),
1634 EXPORT_SYMBOL_GPL(usb_autopm_get_interface);
1637 * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter
1638 * @intf: the usb_interface whose counter should be incremented
1640 * This routine does much the same thing as
1641 * usb_autopm_get_interface(): It increments @intf's usage counter and
1642 * queues an autoresume request if the device is suspended. The
1643 * differences are that it does not perform any synchronization (callers
1644 * should hold a private lock and handle all synchronization issues
1645 * themselves), and it does not autoresume the device directly (it only
1646 * queues a request). After a successful call, the device may not yet be
1649 * This routine can run in atomic context.
1651 int usb_autopm_get_interface_async(struct usb_interface *intf)
1655 status = pm_runtime_get(&intf->dev);
1656 if (status < 0 && status != -EINPROGRESS)
1657 pm_runtime_put_noidle(&intf->dev);
1659 atomic_inc(&intf->pm_usage_cnt);
1660 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n",
1661 __func__, atomic_read(&intf->dev.power.usage_count),
1663 if (status > 0 || status == -EINPROGRESS)
1667 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async);
1670 * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter
1671 * @intf: the usb_interface whose counter should be incremented
1673 * This routine increments @intf's usage counter but does not carry out an
1676 * This routine can run in atomic context.
1678 void usb_autopm_get_interface_no_resume(struct usb_interface *intf)
1680 struct usb_device *udev = interface_to_usbdev(intf);
1682 usb_mark_last_busy(udev);
1683 atomic_inc(&intf->pm_usage_cnt);
1684 pm_runtime_get_noresume(&intf->dev);
1686 EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume);
1688 /* Internal routine to check whether we may autosuspend a device. */
1689 static int autosuspend_check(struct usb_device *udev)
1692 struct usb_interface *intf;
1694 /* Fail if autosuspend is disabled, or any interfaces are in use, or
1695 * any interface drivers require remote wakeup but it isn't available.
1698 if (udev->actconfig) {
1699 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) {
1700 intf = udev->actconfig->interface[i];
1702 /* We don't need to check interfaces that are
1703 * disabled for runtime PM. Either they are unbound
1704 * or else their drivers don't support autosuspend
1705 * and so they are permanently active.
1707 if (intf->dev.power.disable_depth)
1709 if (atomic_read(&intf->dev.power.usage_count) > 0)
1711 w |= intf->needs_remote_wakeup;
1713 /* Don't allow autosuspend if the device will need
1714 * a reset-resume and any of its interface drivers
1715 * doesn't include support or needs remote wakeup.
1717 if (udev->quirks & USB_QUIRK_RESET_RESUME) {
1718 struct usb_driver *driver;
1720 driver = to_usb_driver(intf->dev.driver);
1721 if (!driver->reset_resume ||
1722 intf->needs_remote_wakeup)
1727 if (w && !device_can_wakeup(&udev->dev)) {
1728 dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n");
1731 udev->do_remote_wakeup = w;
1735 int usb_runtime_suspend(struct device *dev)
1737 struct usb_device *udev = to_usb_device(dev);
1740 /* A USB device can be suspended if it passes the various autosuspend
1741 * checks. Runtime suspend for a USB device means suspending all the
1742 * interfaces and then the device itself.
1744 if (autosuspend_check(udev) != 0)
1747 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND);
1749 /* Allow a retry if autosuspend failed temporarily */
1750 if (status == -EAGAIN || status == -EBUSY)
1751 usb_mark_last_busy(udev);
1753 /* The PM core reacts badly unless the return code is 0,
1754 * -EAGAIN, or -EBUSY, so always return -EBUSY on an error.
1761 int usb_runtime_resume(struct device *dev)
1763 struct usb_device *udev = to_usb_device(dev);
1766 /* Runtime resume for a USB device means resuming both the device
1767 * and all its interfaces.
1769 status = usb_resume_both(udev, PMSG_AUTO_RESUME);
1773 int usb_runtime_idle(struct device *dev)
1775 struct usb_device *udev = to_usb_device(dev);
1777 /* An idle USB device can be suspended if it passes the various
1778 * autosuspend checks.
1780 if (autosuspend_check(udev) == 0)
1781 pm_runtime_autosuspend(dev);
1785 int usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable)
1787 struct usb_hcd *hcd = bus_to_hcd(udev->bus);
1790 if (hcd->driver->set_usb2_hw_lpm) {
1791 ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable);
1793 udev->usb2_hw_lpm_enabled = enable;
1799 #endif /* CONFIG_USB_SUSPEND */
1801 struct bus_type usb_bus_type = {
1803 .match = usb_device_match,
1804 .uevent = usb_uevent,