1 Power Management for USB 2 3 Alan Stern <stern@rowland.harvard.edu> 4 5 October 28, 2010 6 7 8 9 What is Power Management? 10 ------------------------- 11 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.) 21 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). 30 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. 35 36 37 What is Remote Wakeup? 38 ---------------------- 39 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. 44 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. 53 54 55 When is a USB device idle? 56 -------------------------- 57 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. 66 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. 69 70 71 Forms of dynamic PM 72 ------------------- 73 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. 78 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. 85 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 92idle. 93 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. 102 103 104 The user interface for dynamic PM 105 --------------------------------- 106 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.) 118 119 power/wakeup 120 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.) 129 130 power/control 131 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. 135 136 "on" means that the device should be resumed and 137 autosuspend is not allowed. (Of course, system 138 suspends are still allowed.) 139 140 "auto" is the normal state in which the kernel is 141 allowed to autosuspend and autoresume the device. 142 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.) 147 148 power/autosuspend_delay_ms 149 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. 158 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 162API. 163 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.) 170 171 172 Changing the default idle-delay time 173 ------------------------------------ 174 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 178do: 179 180 modprobe usbcore autosuspend=5 181 182Equivalently, you could add to /etc/modprobe.conf a line saying: 183 184 options usbcore autosuspend=5 185 186Some distributions load the usbcore module very early during the boot 187process, by means of a program or script running from an initramfs 188image. To alter the parameter value you would have to rebuild that 189image. 190 191If usbcore is compiled into the kernel rather than built as a loadable 192module, you can add 193 194 usbcore.autosuspend=5 195 196to the kernel's boot command line. 197 198Finally, the parameter value can be changed while the system is 199running. If you do: 200 201 echo 5 >/sys/module/usbcore/parameters/autosuspend 202 203then each new USB device will have its autosuspend idle-delay 204initialized to 5. (The idle-delay values for already existing devices 205will not be affected.) 206 207Setting the initial default idle-delay to -1 will prevent any 208autosuspend of any USB device. This is a simple alternative to 209disabling CONFIG_USB_SUSPEND and rebuilding the kernel, and it has the 210added benefit of allowing you to enable autosuspend for selected 211devices. 212 213 214 Warnings 215 -------- 216 217The USB specification states that all USB devices must support power 218management. Nevertheless, the sad fact is that many devices do not 219support it very well. You can suspend them all right, but when you 220try to resume them they disconnect themselves from the USB bus or 221they stop working entirely. This seems to be especially prevalent 222among printers and scanners, but plenty of other types of device have 223the same deficiency. 224 225For this reason, by default the kernel disables autosuspend (the 226power/control attribute is initialized to "on") for all devices other 227than hubs. Hubs, at least, appear to be reasonably well-behaved in 228this regard. 229 230(In 2.6.21 and 2.6.22 this wasn't the case. Autosuspend was enabled 231by default for almost all USB devices. A number of people experienced 232problems as a result.) 233 234This means that non-hub devices won't be autosuspended unless the user 235or a program explicitly enables it. As of this writing there aren't 236any widespread programs which will do this; we hope that in the near 237future device managers such as HAL will take on this added 238responsibility. In the meantime you can always carry out the 239necessary operations by hand or add them to a udev script. You can 240also change the idle-delay time; 2 seconds is not the best choice for 241every device. 242 243If a driver knows that its device has proper suspend/resume support, 244it can enable autosuspend all by itself. For example, the video 245driver for a laptop's webcam might do this (in recent kernels they 246do), since these devices are rarely used and so should normally be 247autosuspended. 248 249Sometimes it turns out that even when a device does work okay with 250autosuspend there are still problems. For example, the usbhid driver, 251which manages keyboards and mice, has autosuspend support. Tests with 252a number of keyboards show that typing on a suspended keyboard, while 253causing the keyboard to do a remote wakeup all right, will nonetheless 254frequently result in lost keystrokes. Tests with mice show that some 255of them will issue a remote-wakeup request in response to button 256presses but not to motion, and some in response to neither. 257 258The kernel will not prevent you from enabling autosuspend on devices 259that can't handle it. It is even possible in theory to damage a 260device by suspending it at the wrong time. (Highly unlikely, but 261possible.) Take care. 262 263 264 The driver interface for Power Management 265 ----------------------------------------- 266 267The requirements for a USB driver to support external power management 268are pretty modest; the driver need only define 269 270 .suspend 271 .resume 272 .reset_resume 273 274methods in its usb_driver structure, and the reset_resume method is 275optional. The methods' jobs are quite simple: 276 277 The suspend method is called to warn the driver that the 278 device is going to be suspended. If the driver returns a 279 negative error code, the suspend will be aborted. Normally 280 the driver will return 0, in which case it must cancel all 281 outstanding URBs (usb_kill_urb()) and not submit any more. 282 283 The resume method is called to tell the driver that the 284 device has been resumed and the driver can return to normal 285 operation. URBs may once more be submitted. 286 287 The reset_resume method is called to tell the driver that 288 the device has been resumed and it also has been reset. 289 The driver should redo any necessary device initialization, 290 since the device has probably lost most or all of its state 291 (although the interfaces will be in the same altsettings as 292 before the suspend). 293 294If the device is disconnected or powered down while it is suspended, 295the disconnect method will be called instead of the resume or 296reset_resume method. This is also quite likely to happen when 297waking up from hibernation, as many systems do not maintain suspend 298current to the USB host controllers during hibernation. (It's 299possible to work around the hibernation-forces-disconnect problem by 300using the USB Persist facility.) 301 302The reset_resume method is used by the USB Persist facility (see 303Documentation/usb/persist.txt) and it can also be used under certain 304circumstances when CONFIG_USB_PERSIST is not enabled. Currently, if a 305device is reset during a resume and the driver does not have a 306reset_resume method, the driver won't receive any notification about 307the resume. Later kernels will call the driver's disconnect method; 3082.6.23 doesn't do this. 309 310USB drivers are bound to interfaces, so their suspend and resume 311methods get called when the interfaces are suspended or resumed. In 312principle one might want to suspend some interfaces on a device (i.e., 313force the drivers for those interface to stop all activity) without 314suspending the other interfaces. The USB core doesn't allow this; all 315interfaces are suspended when the device itself is suspended and all 316interfaces are resumed when the device is resumed. It isn't possible 317to suspend or resume some but not all of a device's interfaces. The 318closest you can come is to unbind the interfaces' drivers. 319 320 321 The driver interface for autosuspend and autoresume 322 --------------------------------------------------- 323 324To support autosuspend and autoresume, a driver should implement all 325three of the methods listed above. In addition, a driver indicates 326that it supports autosuspend by setting the .supports_autosuspend flag 327in its usb_driver structure. It is then responsible for informing the 328USB core whenever one of its interfaces becomes busy or idle. The 329driver does so by calling these six functions: 330 331 int usb_autopm_get_interface(struct usb_interface *intf); 332 void usb_autopm_put_interface(struct usb_interface *intf); 333 int usb_autopm_get_interface_async(struct usb_interface *intf); 334 void usb_autopm_put_interface_async(struct usb_interface *intf); 335 void usb_autopm_get_interface_no_resume(struct usb_interface *intf); 336 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf); 337 338The functions work by maintaining a usage counter in the 339usb_interface's embedded device structure. When the counter is > 0 340then the interface is deemed to be busy, and the kernel will not 341autosuspend the interface's device. When the usage counter is = 0 342then the interface is considered to be idle, and the kernel may 343autosuspend the device. 344 345Drivers need not be concerned about balancing changes to the usage 346counter; the USB core will undo any remaining "get"s when a driver 347is unbound from its interface. As a corollary, drivers must not call 348any of the usb_autopm_* functions after their diconnect() routine has 349returned. 350 351Drivers using the async routines are responsible for their own 352synchronization and mutual exclusion. 353 354 usb_autopm_get_interface() increments the usage counter and 355 does an autoresume if the device is suspended. If the 356 autoresume fails, the counter is decremented back. 357 358 usb_autopm_put_interface() decrements the usage counter and 359 attempts an autosuspend if the new value is = 0. 360 361 usb_autopm_get_interface_async() and 362 usb_autopm_put_interface_async() do almost the same things as 363 their non-async counterparts. The big difference is that they 364 use a workqueue to do the resume or suspend part of their 365 jobs. As a result they can be called in an atomic context, 366 such as an URB's completion handler, but when they return the 367 device will generally not yet be in the desired state. 368 369 usb_autopm_get_interface_no_resume() and 370 usb_autopm_put_interface_no_suspend() merely increment or 371 decrement the usage counter; they do not attempt to carry out 372 an autoresume or an autosuspend. Hence they can be called in 373 an atomic context. 374 375The simplest usage pattern is that a driver calls 376usb_autopm_get_interface() in its open routine and 377usb_autopm_put_interface() in its close or release routine. But other 378patterns are possible. 379 380The autosuspend attempts mentioned above will often fail for one 381reason or another. For example, the power/control attribute might be 382set to "on", or another interface in the same device might not be 383idle. This is perfectly normal. If the reason for failure was that 384the device hasn't been idle for long enough, a timer is scheduled to 385carry out the operation automatically when the autosuspend idle-delay 386has expired. 387 388Autoresume attempts also can fail, although failure would mean that 389the device is no longer present or operating properly. Unlike 390autosuspend, there's no idle-delay for an autoresume. 391 392 393 Other parts of the driver interface 394 ----------------------------------- 395 396Drivers can enable autosuspend for their devices by calling 397 398 usb_enable_autosuspend(struct usb_device *udev); 399 400in their probe() routine, if they know that the device is capable of 401suspending and resuming correctly. This is exactly equivalent to 402writing "auto" to the device's power/control attribute. Likewise, 403drivers can disable autosuspend by calling 404 405 usb_disable_autosuspend(struct usb_device *udev); 406 407This is exactly the same as writing "on" to the power/control attribute. 408 409Sometimes a driver needs to make sure that remote wakeup is enabled 410during autosuspend. For example, there's not much point 411autosuspending a keyboard if the user can't cause the keyboard to do a 412remote wakeup by typing on it. If the driver sets 413intf->needs_remote_wakeup to 1, the kernel won't autosuspend the 414device if remote wakeup isn't available. (If the device is already 415autosuspended, though, setting this flag won't cause the kernel to 416autoresume it. Normally a driver would set this flag in its probe 417method, at which time the device is guaranteed not to be 418autosuspended.) 419 420If a driver does its I/O asynchronously in interrupt context, it 421should call usb_autopm_get_interface_async() before starting output and 422usb_autopm_put_interface_async() when the output queue drains. When 423it receives an input event, it should call 424 425 usb_mark_last_busy(struct usb_device *udev); 426 427in the event handler. This tells the PM core that the device was just 428busy and therefore the next autosuspend idle-delay expiration should 429be pushed back. Many of the usb_autopm_* routines also make this call, 430so drivers need to worry only when interrupt-driven input arrives. 431 432Asynchronous operation is always subject to races. For example, a 433driver may call the usb_autopm_get_interface_async() routine at a time 434when the core has just finished deciding the device has been idle for 435long enough but not yet gotten around to calling the driver's suspend 436method. The suspend method must be responsible for synchronizing with 437the I/O request routine and the URB completion handler; it should 438cause autosuspends to fail with -EBUSY if the driver needs to use the 439device. 440 441External suspend calls should never be allowed to fail in this way, 442only autosuspend calls. The driver can tell them apart by applying 443the PMSG_IS_AUTO() macro to the message argument to the suspend 444method; it will return True for internal PM events (autosuspend) and 445False for external PM events. 446 447 448 Mutual exclusion 449 ---------------- 450 451For external events -- but not necessarily for autosuspend or 452autoresume -- the device semaphore (udev->dev.sem) will be held when a 453suspend or resume method is called. This implies that external 454suspend/resume events are mutually exclusive with calls to probe, 455disconnect, pre_reset, and post_reset; the USB core guarantees that 456this is true of autosuspend/autoresume events as well. 457 458If a driver wants to block all suspend/resume calls during some 459critical section, the best way is to lock the device and call 460usb_autopm_get_interface() (and do the reverse at the end of the 461critical section). Holding the device semaphore will block all 462external PM calls, and the usb_autopm_get_interface() will prevent any 463internal PM calls, even if it fails. (Exercise: Why?) 464 465 466 Interaction between dynamic PM and system PM 467 -------------------------------------------- 468 469Dynamic power management and system power management can interact in 470a couple of ways. 471 472Firstly, a device may already be autosuspended when a system suspend 473occurs. Since system suspends are supposed to be as transparent as 474possible, the device should remain suspended following the system 475resume. But this theory may not work out well in practice; over time 476the kernel's behavior in this regard has changed. As of 2.6.37 the 477policy is to resume all devices during a system resume and let them 478handle their own runtime suspends afterward. 479 480Secondly, a dynamic power-management event may occur as a system 481suspend is underway. The window for this is short, since system 482suspends don't take long (a few seconds usually), but it can happen. 483For example, a suspended device may send a remote-wakeup signal while 484the system is suspending. The remote wakeup may succeed, which would 485cause the system suspend to abort. If the remote wakeup doesn't 486succeed, it may still remain active and thus cause the system to 487resume as soon as the system suspend is complete. Or the remote 488wakeup may fail and get lost. Which outcome occurs depends on timing 489and on the hardware and firmware design. 490 491 492 xHCI hardware link PM 493 --------------------- 494 495xHCI host controller provides hardware link power management to usb2.0 496(xHCI 1.0 feature) and usb3.0 devices which support link PM. By 497enabling hardware LPM, the host can automatically put the device into 498lower power state(L1 for usb2.0 devices, or U1/U2 for usb3.0 devices), 499which state device can enter and resume very quickly. 500 501The user interface for controlling USB2 hardware LPM is located in the 502power/ subdirectory of each USB device's sysfs directory, that is, in 503/sys/bus/usb/devices/.../power/ where "..." is the device's ID. The 504relevant attribute files is usb2_hardware_lpm. 505 506 power/usb2_hardware_lpm 507 508 When a USB2 device which support LPM is plugged to a 509 xHCI host root hub which support software LPM, the 510 host will run a software LPM test for it; if the device 511 enters L1 state and resume successfully and the host 512 supports USB2 hardware LPM, this file will show up and 513 driver will enable hardware LPM for the device. You 514 can write y/Y/1 or n/N/0 to the file to enable/disable 515 USB2 hardware LPM manually. This is for test purpose mainly. 516