blob: c9ffa9ced7eec964e47c2513584f9041a6fb9c7e [file] [log] [blame]
Alan Sterncd38c1e2007-10-10 16:24:56 -04001 Power Management for USB
2
3 Alan Stern <stern@rowland.harvard.edu>
4
Alan Sternfcc4a012010-11-15 15:57:51 -05005 October 28, 2010
Alan Sterncd38c1e2007-10-10 16:24:56 -04006
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
Alan Stern9bbdf1e2010-01-08 12:57:28 -050032built 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -040035
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
Alan Sternbaf67742009-12-08 15:49:48 -050074Dynamic 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -040078
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
Alan Sternbaf67742009-12-08 15:49:48 -050097userspace), 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400102
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
Alan Sternfcc4a012010-11-15 15:57:51 -0500110relevant 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.)
Alan Sterncd38c1e2007-10-10 16:24:56 -0400118
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
Alan Sterna9030982010-04-02 13:22:16 -0400130 power/control
Alan Sterncd38c1e2007-10-10 16:24:56 -0400131
Alan Stern8e4ceb32009-12-07 13:01:37 -0500132 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400135
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
Alan Stern8e4ceb32009-12-07 13:01:37 -0500143 (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.)
Alan Sterncd38c1e2007-10-10 16:24:56 -0400147
Alan Sternfcc4a012010-11-15 15:57:51 -0500148 power/autosuspend_delay_ms
Alan Sterncd38c1e2007-10-10 16:24:56 -0400149
150 This file contains an integer value, which is the
Alan Sternfcc4a012010-11-15 15:57:51 -0500151 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400158
Alan Sternfcc4a012010-11-15 15:57:51 -0500159Writing "-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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400163
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
Alan Sterna9030982010-04-02 13:22:16 -0400167power/level attribute did not exist prior to 2.6.22. power/control
Alan Sternfcc4a012010-11-15 15:57:51 -0500168was 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.)
Alan Sterncd38c1e2007-10-10 16:24:56 -0400170
171
172 Changing the default idle-delay time
173 ------------------------------------
174
Alan Sternfcc4a012010-11-15 15:57:51 -0500175The 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
Alan Sterncd38c1e2007-10-10 16:24:56 -0400178do:
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
Alan Sterna9030982010-04-02 13:22:16 -0400226power/control attribute is initialized to "on") for all devices other
Alan Sterncd38c1e2007-10-10 16:24:56 -0400227than 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
Alan Stern088f7fe2010-01-08 12:56:54 -0500243If a driver knows that its device has proper suspend/resume support,
244it can enable autosuspend all by itself. For example, the video
Alan Sternfcc4a012010-11-15 15:57:51 -0500245driver 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.
Alan Stern088f7fe2010-01-08 12:56:54 -0500248
Alan Sterncd38c1e2007-10-10 16:24:56 -0400249Sometimes it turns out that even when a device does work okay with
Alan Sternfcc4a012010-11-15 15:57:51 -0500250autosuspend 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400257
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
Alan Sternfcc4a012010-11-15 15:57:51 -0500260device by suspending it at the wrong time. (Highly unlikely, but
261possible.) Take care.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400262
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
Alan Stern3c886c52007-11-16 11:58:15 -0500294If 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
Alan Sterncd38c1e2007-10-10 16:24:56 -0400302The 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
Alan Stern8e4ceb32009-12-07 13:01:37 -0500329driver does so by calling these six functions:
Alan Sterncd38c1e2007-10-10 16:24:56 -0400330
331 int usb_autopm_get_interface(struct usb_interface *intf);
332 void usb_autopm_put_interface(struct usb_interface *intf);
Alan Stern9ac39f22008-11-12 16:19:49 -0500333 int usb_autopm_get_interface_async(struct usb_interface *intf);
334 void usb_autopm_put_interface_async(struct usb_interface *intf);
Alan Stern8e4ceb32009-12-07 13:01:37 -0500335 void usb_autopm_get_interface_no_resume(struct usb_interface *intf);
336 void usb_autopm_put_interface_no_suspend(struct usb_interface *intf);
Alan Sterncd38c1e2007-10-10 16:24:56 -0400337
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500338The 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400344
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500345Drivers 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400350
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500351Drivers using the async routines are responsible for their own
352synchronization and mutual exclusion.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400353
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500354 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400360
Alan Stern9ac39f22008-11-12 16:19:49 -0500361 usb_autopm_get_interface_async() and
362 usb_autopm_put_interface_async() do almost the same things as
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500363 their non-async counterparts. The big difference is that they
364 use a workqueue to do the resume or suspend part of their
Alan Stern9ac39f22008-11-12 16:19:49 -0500365 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
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500367 device will generally not yet be in the desired state.
Alan Stern9ac39f22008-11-12 16:19:49 -0500368
Alan Stern8e4ceb32009-12-07 13:01:37 -0500369 usb_autopm_get_interface_no_resume() and
370 usb_autopm_put_interface_no_suspend() merely increment or
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500371 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.
Geoff Levand81ab5b82008-09-20 14:41:47 -0700374
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500375The simplest usage pattern is that a driver calls
Alan Sterncd38c1e2007-10-10 16:24:56 -0400376usb_autopm_get_interface() in its open routine and
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500377usb_autopm_put_interface() in its close or release routine. But other
378patterns are possible.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400379
380The autosuspend attempts mentioned above will often fail for one
Alan Sterna9030982010-04-02 13:22:16 -0400381reason or another. For example, the power/control attribute might be
Alan Sterncd38c1e2007-10-10 16:24:56 -0400382set to "on", or another interface in the same device might not be
383idle. This is perfectly normal. If the reason for failure was that
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500384the 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400387
Alan Sternbaf67742009-12-08 15:49:48 -0500388Autoresume attempts also can fail, although failure would mean that
389the device is no longer present or operating properly. Unlike
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500390autosuspend, there's no idle-delay for an autoresume.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400391
392
393 Other parts of the driver interface
394 -----------------------------------
395
Alan Stern088f7fe2010-01-08 12:56:54 -0500396Drivers 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
Alan Sterna9030982010-04-02 13:22:16 -0400402writing "auto" to the device's power/control attribute. Likewise,
Alan Stern088f7fe2010-01-08 12:56:54 -0500403drivers can disable autosuspend by calling
404
405 usb_disable_autosuspend(struct usb_device *udev);
406
Alan Sterna9030982010-04-02 13:22:16 -0400407This is exactly the same as writing "on" to the power/control attribute.
Alan Stern088f7fe2010-01-08 12:56:54 -0500408
Alan Sterncd38c1e2007-10-10 16:24:56 -0400409Sometimes 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
Alan Sternfcc4a012010-11-15 15:57:51 -0500414device 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.)
Alan Sterncd38c1e2007-10-10 16:24:56 -0400419
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500420If 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
Alan Sterncd38c1e2007-10-10 16:24:56 -0400424
425 usb_mark_last_busy(struct usb_device *udev);
426
Alan Sternfcc4a012010-11-15 15:57:51 -0500427in 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400431
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500432Asynchronous operation is always subject to races. For example, a
Alan Sternfcc4a012010-11-15 15:57:51 -0500433driver 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400440
441External suspend calls should never be allowed to fail in this way,
442only autosuspend calls. The driver can tell them apart by checking
Alan Sternfb34d532009-11-13 11:53:59 -0500443the PM_EVENT_AUTO bit in the message.event argument to the suspend
444method; this bit will be set for internal PM events (autosuspend) and
445clear for external PM events.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400446
Alan Sterncd38c1e2007-10-10 16:24:56 -0400447
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500448 Mutual exclusion
449 ----------------
Alan Sterncd38c1e2007-10-10 16:24:56 -0400450
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500451For 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400457
458If a driver wants to block all suspend/resume calls during some
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500459critical 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?)
Alan Sterncd38c1e2007-10-10 16:24:56 -0400464
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
Alan Stern9bbdf1e2010-01-08 12:57:28 -0500472Firstly, 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
Alan Sternfcc4a012010-11-15 15:57:51 -0500476the 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.
Alan Sterncd38c1e2007-10-10 16:24:56 -0400479
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.