1                        Power Management for USB
   3                 Alan Stern <>
   5                            October 28, 2010
   9        What is Power Management?
  10        -------------------------
  12Power Management (PM) is the practice of saving energy by suspending
  13parts of a computer system when they aren't being used.  While a
  14component is "suspended" it is in a nonfunctional low-power state; it
  15might even be turned off completely.  A suspended component can be
  16"resumed" (returned to a functional full-power state) when the kernel
  17needs to use it.  (There also are forms of PM in which components are
  18placed in a less functional but still usable state instead of being
  19suspended; an example would be reducing the CPU's clock rate.  This
  20document will not discuss those other forms.)
  22When the parts being suspended include the CPU and most of the rest of
  23the system, we speak of it as a "system suspend".  When a particular
  24device is turned off while the system as a whole remains running, we
  25call it a "dynamic suspend" (also known as a "runtime suspend" or
  26"selective suspend").  This document concentrates mostly on how
  27dynamic PM is implemented in the USB subsystem, although system PM is
  28covered to some extent (see Documentation/power/*.txt for more
  29information about system PM).
  31Note: Dynamic PM support for USB is present only if the kernel was
  32built with CONFIG_USB_SUSPEND enabled (which depends on
  33CONFIG_PM_RUNTIME).  System PM support is present only if the kernel
  34was built with CONFIG_SUSPEND or CONFIG_HIBERNATION enabled.
  37        What is Remote Wakeup?
  38        ----------------------
  40When a device has been suspended, it generally doesn't resume until
  41the computer tells it to.  Likewise, if the entire computer has been
  42suspended, it generally doesn't resume until the user tells it to, say
  43by pressing a power button or opening the cover.
  45However some devices have the capability of resuming by themselves, or
  46asking the kernel to resume them, or even telling the entire computer
  47to resume.  This capability goes by several names such as "Wake On
  48LAN"; we will refer to it generically as "remote wakeup".  When a
  49device is enabled for remote wakeup and it is suspended, it may resume
  50itself (or send a request to be resumed) in response to some external
  51event.  Examples include a suspended keyboard resuming when a key is
  52pressed, or a suspended USB hub resuming when a device is plugged in.
  55        When is a USB device idle?
  56        --------------------------
  58A device is idle whenever the kernel thinks it's not busy doing
  59anything important and thus is a candidate for being suspended.  The
  60exact definition depends on the device's driver; drivers are allowed
  61to declare that a device isn't idle even when there's no actual
  62communication taking place.  (For example, a hub isn't considered idle
  63unless all the devices plugged into that hub are already suspended.)
  64In addition, a device isn't considered idle so long as a program keeps
  65its usbfs file open, whether or not any I/O is going on.
  67If a USB device has no driver, its usbfs file isn't open, and it isn't
  68being accessed through sysfs, then it definitely is idle.
  71        Forms of dynamic PM
  72        -------------------
  74Dynamic suspends occur when the kernel decides to suspend an idle
  75device.  This is called "autosuspend" for short.  In general, a device
  76won't be autosuspended unless it has been idle for some minimum period
  77of time, the so-called idle-delay time.
  79Of course, nothing the kernel does on its own initiative should
  80prevent the computer or its devices from working properly.  If a
  81device has been autosuspended and a program tries to use it, the
  82kernel will automatically resume the device (autoresume).  For the
  83same reason, an autosuspended device will usually have remote wakeup
  84enabled, if the device supports remote wakeup.
  86It is worth mentioning that many USB drivers don't support
  87autosuspend.  In fact, at the time of this writing (Linux 2.6.23) the
  88only drivers which do support it are the hub driver, kaweth, asix,
  89usblp, usblcd, and usb-skeleton (which doesn't count).  If a
  90non-supporting driver is bound to a device, the device won't be
  91autosuspended.  In effect, the kernel pretends the device is never
  94We can categorize power management events in two broad classes:
  95external and internal.  External events are those triggered by some
  96agent outside the USB stack: system suspend/resume (triggered by
  97userspace), manual dynamic resume (also triggered by userspace), and
  98remote wakeup (triggered by the device).  Internal events are those
  99triggered within the USB stack: autosuspend and autoresume.  Note that
 100all dynamic suspend events are internal; external agents are not
 101allowed to issue dynamic suspends.
 104        The user interface for dynamic PM
 105        ---------------------------------
 107The user interface for controlling dynamic PM is located in the power/
 108subdirectory of each USB device's sysfs directory, that is, in
 109/sys/bus/usb/devices/.../power/ where "..." is the device's ID.  The
 110relevant attribute files are: wakeup, control, and
 111autosuspend_delay_ms.  (There may also be a file named "level"; this
 112file was deprecated as of the 2.6.35 kernel and replaced by the
 113"control" file.  In 2.6.38 the "autosuspend" file will be deprecated
 114and replaced by the "autosuspend_delay_ms" file.  The only difference
 115is that the newer file expresses the delay in milliseconds whereas the
 116older file uses seconds.  Confusingly, both files are present in 2.6.37
 117but only "autosuspend" works.)
 119        power/wakeup
 121                This file is empty if the device does not support
 122                remote wakeup.  Otherwise the file contains either the
 123                word "enabled" or the word "disabled", and you can
 124                write those words to the file.  The setting determines
 125                whether or not remote wakeup will be enabled when the
 126                device is next suspended.  (If the setting is changed
 127                while the device is suspended, the change won't take
 128                effect until the following suspend.)
 130        power/control
 132                This file contains one of two words: "on" or "auto".
 133                You can write those words to the file to change the
 134                device's setting.
 136                "on" means that the device should be resumed and
 137                autosuspend is not allowed.  (Of course, system
 138                suspends are still allowed.)
 140                "auto" is the normal state in which the kernel is
 141                allowed to autosuspend and autoresume the device.
 143                (In kernels up to 2.6.32, you could also specify
 144                "suspend", meaning that the device should remain
 145                suspended and autoresume was not allowed.  This
 146                setting is no longer supported.)
 148        power/autosuspend_delay_ms
 150                This file contains an integer value, which is the
 151                number of milliseconds the device should remain idle
 152                before the kernel will autosuspend it (the idle-delay
 153                time).  The default is 2000.  0 means to autosuspend
 154                as soon as the device becomes idle, and negative
 155                values mean never to autosuspend.  You can write a
 156                number to the file to change the autosuspend
 157                idle-delay time.
 159Writing "-1" to power/autosuspend_delay_ms and writing "on" to
 160power/control do essentially the same thing -- they both prevent the
 161device from being autosuspended.  Yes, this is a redundancy in the
 164(In 2.6.21 writing "0" to power/autosuspend would prevent the device
 165from being autosuspended; the behavior was changed in 2.6.22.  The
 166power/autosuspend attribute did not exist prior to 2.6.21, and the
 167power/level attribute did not exist prior to 2.6.22.  power/control
 168was added in 2.6.34, and power/autosuspend_delay_ms was added in
 1692.6.37 but did not become functional until 2.6.38.)
 172        Changing the default idle-delay time
 173        ------------------------------------
 175The default autosuspend idle-delay time (in seconds) is controlled by
 176a module parameter in usbcore.  You can specify the value when usbcore
 177is loaded.  For example, to set it to 5 seconds instead of 2 you would
 180        modprobe usbcore autosuspend=5
 182Equivalently, you could add to a configuration file in /etc/modprobe.d
 183a line saying:
 185        options usbcore autosuspend=5
 187Some distributions load the usbcore module very early during the boot
 188process, by means of a program or script running from an initramfs
 189image.  To alter the parameter value you would have to rebuild that
 192If usbcore is compiled into the kernel rather than built as a loadable
 193module, you can add
 195        usbcore.autosuspend=5
 197to the kernel's boot command line.
 199Finally, the parameter value can be changed while the system is
 200running.  If you do:
 202        echo 5 >/sys/module/usbcore/parameters/autosuspend
 204then each new USB device will have its autosuspend idle-delay
 205initialized to 5.  (The idle-delay values for already existing devices
 206will not be affected.)
 208Setting the initial default idle-delay to -1 will prevent any
 209autosuspend of any USB device.  This is a simple alternative to
 210disabling CONFIG_USB_SUSPEND and rebuilding the kernel, and it has the
 211added benefit of allowing you to enable autosuspend for selected
 215        Warnings
 216        --------
 218The USB specification states that all USB devices must support power
 219management.  Nevertheless, the sad fact is that many devices do not
 220support it very well.  You can suspend them all right, but when you
 221try to resume them they disconnect themselves from the USB bus or
 222they stop working entirely.  This seems to be especially prevalent
 223among printers and scanners, but plenty of other types of device have
 224the same deficiency.
 226For this reason, by default the kernel disables autosuspend (the
 227power/control attribute is initialized to "on") for all devices other
 228than hubs.  Hubs, at least, appear to be reasonably well-behaved in
 229this regard.
 231(In 2.6.21 and 2.6.22 this wasn't the case.  Autosuspend was enabled
 232by default for almost all USB devices.  A number of people experienced
 233problems as a result.)
 235This means that non-hub devices won't be autosuspended unless the user
 236or a program explicitly enables it.  As of this writing there aren't
 237any widespread programs which will do this; we hope that in the near
 238future device managers such as HAL will take on this added
 239responsibility.  In the meantime you can always carry out the
 240necessary operations by hand or add them to a udev script.  You can
 241also change the idle-delay time; 2 seconds is not the best choice for
 242every device.
 244If a driver knows that its device has proper suspend/resume support,
 245it can enable autosuspend all by itself.  For example, the video
 246driver for a laptop's webcam might do this (in recent kernels they
 247do), since these devices are rarely used and so should normally be
 250Sometimes it turns out that even when a device does work okay with
 251autosuspend there are still problems.  For example, the usbhid driver,
 252which manages keyboards and mice, has autosuspend support.  Tests with
 253a number of keyboards show that typing on a suspended keyboard, while
 254causing the keyboard to do a remote wakeup all right, will nonetheless
 255frequently result in lost keystrokes.  Tests with mice show that some
 256of them will issue a remote-wakeup request in response to button
 257presses but not to motion, and some in response to neither.
 259The kernel will not prevent you from enabling autosuspend on devices
 260that can't handle it.  It is even possible in theory to damage a
 261device by suspending it at the wrong time.  (Highly unlikely, but
 262possible.)  Take care.
 265        The driver interface for Power Management
 266        -----------------------------------------
 268The requirements for a USB driver to support external power management
 269are pretty modest; the driver need only define
 271        .suspend
 272        .resume
 273        .reset_resume
 275methods in its usb_driver structure, and the reset_resume method is
 276optional.  The methods' jobs are quite simple:
 278        The suspend method is called to warn the driver that the
 279        device is going to be suspended.  If the driver returns a
 280        negative error code, the suspend will be aborted.  Normally
 281        the driver will return 0, in which case it must cancel all
 282        outstanding URBs (usb_kill_urb()) and not submit any more.
 284        The resume method is called to tell the driver that the
 285        device has been resumed and the driver can return to normal
 286        operation.  URBs may once more be submitted.
 288        The reset_resume method is called to tell the driver that
 289        the device has been resumed and it also has been reset.
 290        The driver should redo any necessary device initialization,
 291        since the device has probably lost most or all of its state
 292        (although the interfaces will be in the same altsettings as
 293        before the suspend).
 295If the device is disconnected or powered down while it is suspended,
 296the disconnect method will be called instead of the resume or
 297reset_resume method.  This is also quite likely to happen when
 298waking up from hibernation, as many systems do not maintain suspend
 299current to the USB host controllers during hibernation.  (It's
 300possible to work around the hibernation-forces-disconnect problem by
 301using the USB Persist facility.)
 303The reset_resume method is used by the USB Persist facility (see
 304Documentation/usb/persist.txt) and it can also be used under certain
 305circumstances when CONFIG_USB_PERSIST is not enabled.  Currently, if a
 306device is reset during a resume and the driver does not have a
 307reset_resume method, the driver won't receive any notification about
 308the resume.  Later kernels will call the driver's disconnect method;
 3092.6.23 doesn't do this.
 311USB drivers are bound to interfaces, so their suspend and resume
 312methods get called when the interfaces are suspended or resumed.  In
 313principle one might want to suspend some interfaces on a device (i.e.,
 314force the drivers for those interface to stop all activity) without
 315suspending the other interfaces.  The USB core doesn't allow this; all
 316interfaces are suspended when the device itself is suspended and all
 317interfaces are resumed when the device is resumed.  It isn't possible
 318to suspend or resume some but not all of a device's interfaces.  The
 319closest you can come is to unbind the interfaces' drivers.
 322        The driver interface for autosuspend and autoresume
 323        ---------------------------------------------------
 325To support autosuspend and autoresume, a driver should implement all
 326three of the methods listed above.  In addition, a driver indicates
 327that it supports autosuspend by setting the .supports_autosuspend flag
 328in its usb_driver structure.  It is then responsible for informing the
 329USB core whenever one of its interfaces becomes busy or idle.  The
 330driver does so by calling these six functions:
 332        int  usb_autopm_get_interface(struct usb_interface *intf);
 333        void usb_autopm_put_interface(struct usb_interface *intf);
 334        int  usb_autopm_get_interface_async(struct usb_interface *intf);
 335        void usb_autopm_put_interface_async(struct usb_interface *intf);
 336        void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
 337        void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
 339The functions work by maintaining a usage counter in the
 340usb_interface's embedded device structure.  When the counter is > 0
 341then the interface is deemed to be busy, and the kernel will not
 342autosuspend the interface's device.  When the usage counter is = 0
 343then the interface is considered to be idle, and the kernel may
 344autosuspend the device.
 346Drivers need not be concerned about balancing changes to the usage
 347counter; the USB core will undo any remaining "get"s when a driver
 348is unbound from its interface.  As a corollary, drivers must not call
 349any of the usb_autopm_* functions after their disconnect() routine has
 352Drivers using the async routines are responsible for their own
 353synchronization and mutual exclusion.
 355        usb_autopm_get_interface() increments the usage counter and
 356        does an autoresume if the device is suspended.  If the
 357        autoresume fails, the counter is decremented back.
 359        usb_autopm_put_interface() decrements the usage counter and
 360        attempts an autosuspend if the new value is = 0.
 362        usb_autopm_get_interface_async() and
 363        usb_autopm_put_interface_async() do almost the same things as
 364        their non-async counterparts.  The big difference is that they
 365        use a workqueue to do the resume or suspend part of their
 366        jobs.  As a result they can be called in an atomic context,
 367        such as an URB's completion handler, but when they return the
 368        device will generally not yet be in the desired state.
 370        usb_autopm_get_interface_no_resume() and
 371        usb_autopm_put_interface_no_suspend() merely increment or
 372        decrement the usage counter; they do not attempt to carry out
 373        an autoresume or an autosuspend.  Hence they can be called in
 374        an atomic context.
 376The simplest usage pattern is that a driver calls
 377usb_autopm_get_interface() in its open routine and
 378usb_autopm_put_interface() in its close or release routine.  But other
 379patterns are possible.
 381The autosuspend attempts mentioned above will often fail for one
 382reason or another.  For example, the power/control attribute might be
 383set to "on", or another interface in the same device might not be
 384idle.  This is perfectly normal.  If the reason for failure was that
 385the device hasn't been idle for long enough, a timer is scheduled to
 386carry out the operation automatically when the autosuspend idle-delay
 387has expired.
 389Autoresume attempts also can fail, although failure would mean that
 390the device is no longer present or operating properly.  Unlike
 391autosuspend, there's no idle-delay for an autoresume.
 394        Other parts of the driver interface
 395        -----------------------------------
 397Drivers can enable autosuspend for their devices by calling
 399        usb_enable_autosuspend(struct usb_device *udev);
 401in their probe() routine, if they know that the device is capable of
 402suspending and resuming correctly.  This is exactly equivalent to
 403writing "auto" to the device's power/control attribute.  Likewise,
 404drivers can disable autosuspend by calling
 406        usb_disable_autosuspend(struct usb_device *udev);
 408This is exactly the same as writing "on" to the power/control attribute.
 410Sometimes a driver needs to make sure that remote wakeup is enabled
 411during autosuspend.  For example, there's not much point
 412autosuspending a keyboard if the user can't cause the keyboard to do a
 413remote wakeup by typing on it.  If the driver sets
 414intf->needs_remote_wakeup to 1, the kernel won't autosuspend the
 415device if remote wakeup isn't available.  (If the device is already
 416autosuspended, though, setting this flag won't cause the kernel to
 417autoresume it.  Normally a driver would set this flag in its probe
 418method, at which time the device is guaranteed not to be
 421If a driver does its I/O asynchronously in interrupt context, it
 422should call usb_autopm_get_interface_async() before starting output and
 423usb_autopm_put_interface_async() when the output queue drains.  When
 424it receives an input event, it should call
 426        usb_mark_last_busy(struct usb_device *udev);
 428in the event handler.  This tells the PM core that the device was just
 429busy and therefore the next autosuspend idle-delay expiration should
 430be pushed back.  Many of the usb_autopm_* routines also make this call,
 431so drivers need to worry only when interrupt-driven input arrives.
 433Asynchronous operation is always subject to races.  For example, a
 434driver may call the usb_autopm_get_interface_async() routine at a time
 435when the core has just finished deciding the device has been idle for
 436long enough but not yet gotten around to calling the driver's suspend
 437method.  The suspend method must be responsible for synchronizing with
 438the I/O request routine and the URB completion handler; it should
 439cause autosuspends to fail with -EBUSY if the driver needs to use the
 442External suspend calls should never be allowed to fail in this way,
 443only autosuspend calls.  The driver can tell them apart by applying
 444the PMSG_IS_AUTO() macro to the message argument to the suspend
 445method; it will return True for internal PM events (autosuspend) and
 446False for external PM events.
 449        Mutual exclusion
 450        ----------------
 452For external events -- but not necessarily for autosuspend or
 453autoresume -- the device semaphore (udev->dev.sem) will be held when a
 454suspend or resume method is called.  This implies that external
 455suspend/resume events are mutually exclusive with calls to probe,
 456disconnect, pre_reset, and post_reset; the USB core guarantees that
 457this is true of autosuspend/autoresume events as well.
 459If a driver wants to block all suspend/resume calls during some
 460critical section, the best way is to lock the device and call
 461usb_autopm_get_interface() (and do the reverse at the end of the
 462critical section).  Holding the device semaphore will block all
 463external PM calls, and the usb_autopm_get_interface() will prevent any
 464internal PM calls, even if it fails.  (Exercise: Why?)
 467        Interaction between dynamic PM and system PM
 468        --------------------------------------------
 470Dynamic power management and system power management can interact in
 471a couple of ways.
 473Firstly, a device may already be autosuspended when a system suspend
 474occurs.  Since system suspends are supposed to be as transparent as
 475possible, the device should remain suspended following the system
 476resume.  But this theory may not work out well in practice; over time
 477the kernel's behavior in this regard has changed.  As of 2.6.37 the
 478policy is to resume all devices during a system resume and let them
 479handle their own runtime suspends afterward.
 481Secondly, a dynamic power-management event may occur as a system
 482suspend is underway.  The window for this is short, since system
 483suspends don't take long (a few seconds usually), but it can happen.
 484For example, a suspended device may send a remote-wakeup signal while
 485the system is suspending.  The remote wakeup may succeed, which would
 486cause the system suspend to abort.  If the remote wakeup doesn't
 487succeed, it may still remain active and thus cause the system to
 488resume as soon as the system suspend is complete.  Or the remote
 489wakeup may fail and get lost.  Which outcome occurs depends on timing
 490and on the hardware and firmware design.
 493        xHCI hardware link PM
 494        ---------------------
 496xHCI host controller provides hardware link power management to usb2.0
 497(xHCI 1.0 feature) and usb3.0 devices which support link PM. By
 498enabling hardware LPM, the host can automatically put the device into
 499lower power state(L1 for usb2.0 devices, or U1/U2 for usb3.0 devices),
 500which state device can enter and resume very quickly.
 502The user interface for controlling USB2 hardware LPM is located in the
 503power/ subdirectory of each USB device's sysfs directory, that is, in
 504/sys/bus/usb/devices/.../power/ where "..." is the device's ID. The
 505relevant attribute files is usb2_hardware_lpm.
 507        power/usb2_hardware_lpm
 509                When a USB2 device which support LPM is plugged to a
 510                xHCI host root hub which support software LPM, the
 511                host will run a software LPM test for it; if the device
 512                enters L1 state and resume successfully and the host
 513                supports USB2 hardware LPM, this file will show up and
 514                driver will enable hardware LPM for the device. You
 515                can write y/Y/1 or n/N/0 to the file to enable/disable
 516                USB2 hardware LPM manually. This is for test purpose mainly.