blob: acb3f83b8079486e214dc23e315ca3f9f6f755c4 [file] [log] [blame]
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001/*
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02002 * drivers/base/power/runtime.c - Helper functions for device runtime PM
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02003 *
4 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
Alan Stern1bfee5b2010-09-25 23:35:00 +02005 * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02006 *
7 * This file is released under the GPLv2.
8 */
9
10#include <linux/sched.h>
11#include <linux/pm_runtime.h>
Alan Stern7490e442010-09-25 23:35:15 +020012#include "power.h"
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +020013
Alan Stern140a6c92010-09-25 23:35:07 +020014static int rpm_resume(struct device *dev, int rpmflags);
Alan Stern7490e442010-09-25 23:35:15 +020015static int rpm_suspend(struct device *dev, int rpmflags);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +020016
17/**
Alan Stern47693732010-09-25 23:34:46 +020018 * update_pm_runtime_accounting - Update the time accounting of power states
19 * @dev: Device to update the accounting for
20 *
21 * In order to be able to have time accounting of the various power states
22 * (as used by programs such as PowerTOP to show the effectiveness of runtime
23 * PM), we need to track the time spent in each state.
24 * update_pm_runtime_accounting must be called each time before the
25 * runtime_status field is updated, to account the time in the old state
26 * correctly.
27 */
28void update_pm_runtime_accounting(struct device *dev)
29{
30 unsigned long now = jiffies;
31 int delta;
32
33 delta = now - dev->power.accounting_timestamp;
34
35 if (delta < 0)
36 delta = 0;
37
38 dev->power.accounting_timestamp = now;
39
40 if (dev->power.disable_depth > 0)
41 return;
42
43 if (dev->power.runtime_status == RPM_SUSPENDED)
44 dev->power.suspended_jiffies += delta;
45 else
46 dev->power.active_jiffies += delta;
47}
48
49static void __update_runtime_status(struct device *dev, enum rpm_status status)
50{
51 update_pm_runtime_accounting(dev);
52 dev->power.runtime_status = status;
53}
54
55/**
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +020056 * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
57 * @dev: Device to handle.
58 */
59static void pm_runtime_deactivate_timer(struct device *dev)
60{
61 if (dev->power.timer_expires > 0) {
62 del_timer(&dev->power.suspend_timer);
63 dev->power.timer_expires = 0;
64 }
65}
66
67/**
68 * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
69 * @dev: Device to handle.
70 */
71static void pm_runtime_cancel_pending(struct device *dev)
72{
73 pm_runtime_deactivate_timer(dev);
74 /*
75 * In case there's a request pending, make sure its work function will
76 * return without doing anything.
77 */
78 dev->power.request = RPM_REQ_NONE;
79}
80
Alan Stern15bcb91d2010-09-25 23:35:21 +020081/*
82 * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
83 * @dev: Device to handle.
84 *
85 * Compute the autosuspend-delay expiration time based on the device's
86 * power.last_busy time. If the delay has already expired or is disabled
87 * (negative) or the power.use_autosuspend flag isn't set, return 0.
88 * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
89 *
90 * This function may be called either with or without dev->power.lock held.
91 * Either way it can be racy, since power.last_busy may be updated at any time.
92 */
93unsigned long pm_runtime_autosuspend_expiration(struct device *dev)
94{
95 int autosuspend_delay;
96 long elapsed;
97 unsigned long last_busy;
98 unsigned long expires = 0;
99
100 if (!dev->power.use_autosuspend)
101 goto out;
102
103 autosuspend_delay = ACCESS_ONCE(dev->power.autosuspend_delay);
104 if (autosuspend_delay < 0)
105 goto out;
106
107 last_busy = ACCESS_ONCE(dev->power.last_busy);
108 elapsed = jiffies - last_busy;
109 if (elapsed < 0)
110 goto out; /* jiffies has wrapped around. */
111
112 /*
113 * If the autosuspend_delay is >= 1 second, align the timer by rounding
114 * up to the nearest second.
115 */
116 expires = last_busy + msecs_to_jiffies(autosuspend_delay);
117 if (autosuspend_delay >= 1000)
118 expires = round_jiffies(expires);
119 expires += !expires;
120 if (elapsed >= expires - last_busy)
121 expires = 0; /* Already expired. */
122
123 out:
124 return expires;
125}
126EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
127
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200128/**
Alan Stern1bfee5b2010-09-25 23:35:00 +0200129 * rpm_check_suspend_allowed - Test whether a device may be suspended.
130 * @dev: Device to test.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200131 */
Alan Stern1bfee5b2010-09-25 23:35:00 +0200132static int rpm_check_suspend_allowed(struct device *dev)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200133{
134 int retval = 0;
135
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200136 if (dev->power.runtime_error)
137 retval = -EINVAL;
Rafael J. Wysocki632e2702011-07-01 22:29:15 +0200138 else if (dev->power.disable_depth > 0)
139 retval = -EACCES;
140 else if (atomic_read(&dev->power.usage_count) > 0)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200141 retval = -EAGAIN;
142 else if (!pm_children_suspended(dev))
143 retval = -EBUSY;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200144
145 /* Pending resume requests take precedence over suspends. */
146 else if ((dev->power.deferred_resume
Kevin Winchester78ca7c32010-10-29 15:29:55 +0200147 && dev->power.runtime_status == RPM_SUSPENDING)
Alan Stern1bfee5b2010-09-25 23:35:00 +0200148 || (dev->power.request_pending
149 && dev->power.request == RPM_REQ_RESUME))
150 retval = -EAGAIN;
151 else if (dev->power.runtime_status == RPM_SUSPENDED)
152 retval = 1;
153
154 return retval;
155}
156
Alan Stern1bfee5b2010-09-25 23:35:00 +0200157/**
Alan Stern140a6c92010-09-25 23:35:07 +0200158 * rpm_idle - Notify device bus type if the device can be suspended.
Alan Stern1bfee5b2010-09-25 23:35:00 +0200159 * @dev: Device to notify the bus type about.
160 * @rpmflags: Flag bits.
161 *
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200162 * Check if the device's runtime PM status allows it to be suspended. If
Alan Stern1bfee5b2010-09-25 23:35:00 +0200163 * another idle notification has been started earlier, return immediately. If
164 * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
165 * run the ->runtime_idle() callback directly.
166 *
167 * This function must be called under dev->power.lock with interrupts disabled.
168 */
Alan Stern140a6c92010-09-25 23:35:07 +0200169static int rpm_idle(struct device *dev, int rpmflags)
Alan Stern1bfee5b2010-09-25 23:35:00 +0200170{
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200171 int (*callback)(struct device *);
Alan Stern1bfee5b2010-09-25 23:35:00 +0200172 int retval;
173
174 retval = rpm_check_suspend_allowed(dev);
175 if (retval < 0)
176 ; /* Conditions are wrong. */
177
178 /* Idle notifications are allowed only in the RPM_ACTIVE state. */
179 else if (dev->power.runtime_status != RPM_ACTIVE)
180 retval = -EAGAIN;
181
182 /*
183 * Any pending request other than an idle notification takes
184 * precedence over us, except that the timer may be running.
185 */
186 else if (dev->power.request_pending &&
187 dev->power.request > RPM_REQ_IDLE)
188 retval = -EAGAIN;
189
190 /* Act as though RPM_NOWAIT is always set. */
191 else if (dev->power.idle_notification)
192 retval = -EINPROGRESS;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200193 if (retval)
194 goto out;
195
Alan Stern1bfee5b2010-09-25 23:35:00 +0200196 /* Pending requests need to be canceled. */
197 dev->power.request = RPM_REQ_NONE;
198
Alan Stern7490e442010-09-25 23:35:15 +0200199 if (dev->power.no_callbacks) {
200 /* Assume ->runtime_idle() callback would have suspended. */
201 retval = rpm_suspend(dev, rpmflags);
202 goto out;
203 }
204
Alan Stern1bfee5b2010-09-25 23:35:00 +0200205 /* Carry out an asynchronous or a synchronous idle notification. */
206 if (rpmflags & RPM_ASYNC) {
207 dev->power.request = RPM_REQ_IDLE;
208 if (!dev->power.request_pending) {
209 dev->power.request_pending = true;
210 queue_work(pm_wq, &dev->power.work);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200211 }
Alan Stern1bfee5b2010-09-25 23:35:00 +0200212 goto out;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200213 }
214
215 dev->power.idle_notification = true;
216
Rafael J. Wysocki564b9052011-06-23 01:52:55 +0200217 if (dev->pm_domain)
218 callback = dev->pm_domain->ops.runtime_idle;
Rafael J. Wysocki4d27e9d2011-04-29 00:35:50 +0200219 else if (dev->type && dev->type->pm)
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200220 callback = dev->type->pm->runtime_idle;
221 else if (dev->class && dev->class->pm)
222 callback = dev->class->pm->runtime_idle;
Rafael J. Wysocki9659cc02011-02-18 23:20:21 +0100223 else if (dev->bus && dev->bus->pm)
224 callback = dev->bus->pm->runtime_idle;
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200225 else
226 callback = NULL;
227
Rafael J. Wysocki4d27e9d2011-04-29 00:35:50 +0200228 if (callback) {
Kevin Hilman02b26772011-08-05 21:45:20 +0200229 if (dev->power.irq_safe)
230 spin_unlock(&dev->power.lock);
231 else
232 spin_unlock_irq(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200233
Rafael J. Wysocki4d27e9d2011-04-29 00:35:50 +0200234 callback(dev);
Rafael J. Wysockia6ab7aa2009-12-22 20:43:17 +0100235
Kevin Hilman02b26772011-08-05 21:45:20 +0200236 if (dev->power.irq_safe)
237 spin_lock(&dev->power.lock);
238 else
239 spin_lock_irq(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200240 }
241
242 dev->power.idle_notification = false;
243 wake_up_all(&dev->power.wait_queue);
244
245 out:
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200246 return retval;
247}
248
249/**
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200250 * rpm_callback - Run a given runtime PM callback for a given device.
251 * @cb: Runtime PM callback to run.
252 * @dev: Device to run the callback for.
253 */
254static int rpm_callback(int (*cb)(struct device *), struct device *dev)
255 __releases(&dev->power.lock) __acquires(&dev->power.lock)
256{
257 int retval;
258
259 if (!cb)
260 return -ENOSYS;
261
Alan Sternc7b61de2010-12-01 00:14:42 +0100262 if (dev->power.irq_safe) {
263 retval = cb(dev);
264 } else {
265 spin_unlock_irq(&dev->power.lock);
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200266
Alan Sternc7b61de2010-12-01 00:14:42 +0100267 retval = cb(dev);
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200268
Alan Sternc7b61de2010-12-01 00:14:42 +0100269 spin_lock_irq(&dev->power.lock);
270 }
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200271 dev->power.runtime_error = retval;
Rafael J. Wysocki632e2702011-07-01 22:29:15 +0200272 return retval != -EACCES ? retval : -EIO;
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200273}
274
275/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200276 * rpm_suspend - Carry out runtime suspend of given device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200277 * @dev: Device to suspend.
Alan Stern3f9af052010-09-25 23:34:54 +0200278 * @rpmflags: Flag bits.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200279 *
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200280 * Check if the device's runtime PM status allows it to be suspended. If
Alan Stern1bfee5b2010-09-25 23:35:00 +0200281 * another suspend has been started earlier, either return immediately or wait
282 * for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags. Cancel a
283 * pending idle notification. If the RPM_ASYNC flag is set then queue a
284 * suspend request; otherwise run the ->runtime_suspend() callback directly.
285 * If a deferred resume was requested while the callback was running then carry
286 * it out; otherwise send an idle notification for the device (if the suspend
287 * failed) or for its parent (if the suspend succeeded).
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200288 *
289 * This function must be called under dev->power.lock with interrupts disabled.
290 */
Alan Stern140a6c92010-09-25 23:35:07 +0200291static int rpm_suspend(struct device *dev, int rpmflags)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200292 __releases(&dev->power.lock) __acquires(&dev->power.lock)
293{
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200294 int (*callback)(struct device *);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200295 struct device *parent = NULL;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200296 int retval;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200297
Alan Stern3f9af052010-09-25 23:34:54 +0200298 dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200299
300 repeat:
Alan Stern1bfee5b2010-09-25 23:35:00 +0200301 retval = rpm_check_suspend_allowed(dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200302
Alan Stern1bfee5b2010-09-25 23:35:00 +0200303 if (retval < 0)
304 ; /* Conditions are wrong. */
305
306 /* Synchronous suspends are not allowed in the RPM_RESUMING state. */
307 else if (dev->power.runtime_status == RPM_RESUMING &&
308 !(rpmflags & RPM_ASYNC))
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200309 retval = -EAGAIN;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200310 if (retval)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200311 goto out;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200312
Alan Stern15bcb91d2010-09-25 23:35:21 +0200313 /* If the autosuspend_delay time hasn't expired yet, reschedule. */
314 if ((rpmflags & RPM_AUTO)
315 && dev->power.runtime_status != RPM_SUSPENDING) {
316 unsigned long expires = pm_runtime_autosuspend_expiration(dev);
317
318 if (expires != 0) {
319 /* Pending requests need to be canceled. */
320 dev->power.request = RPM_REQ_NONE;
321
322 /*
323 * Optimization: If the timer is already running and is
324 * set to expire at or before the autosuspend delay,
325 * avoid the overhead of resetting it. Just let it
326 * expire; pm_suspend_timer_fn() will take care of the
327 * rest.
328 */
329 if (!(dev->power.timer_expires && time_before_eq(
330 dev->power.timer_expires, expires))) {
331 dev->power.timer_expires = expires;
332 mod_timer(&dev->power.suspend_timer, expires);
333 }
334 dev->power.timer_autosuspends = 1;
335 goto out;
336 }
337 }
338
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200339 /* Other scheduled or pending requests need to be canceled. */
340 pm_runtime_cancel_pending(dev);
341
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200342 if (dev->power.runtime_status == RPM_SUSPENDING) {
343 DEFINE_WAIT(wait);
344
Alan Stern1bfee5b2010-09-25 23:35:00 +0200345 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200346 retval = -EINPROGRESS;
347 goto out;
348 }
349
350 /* Wait for the other suspend running in parallel with us. */
351 for (;;) {
352 prepare_to_wait(&dev->power.wait_queue, &wait,
353 TASK_UNINTERRUPTIBLE);
354 if (dev->power.runtime_status != RPM_SUSPENDING)
355 break;
356
357 spin_unlock_irq(&dev->power.lock);
358
359 schedule();
360
361 spin_lock_irq(&dev->power.lock);
362 }
363 finish_wait(&dev->power.wait_queue, &wait);
364 goto repeat;
365 }
366
Alan Stern7490e442010-09-25 23:35:15 +0200367 dev->power.deferred_resume = false;
368 if (dev->power.no_callbacks)
369 goto no_callback; /* Assume success. */
370
Alan Stern1bfee5b2010-09-25 23:35:00 +0200371 /* Carry out an asynchronous or a synchronous suspend. */
372 if (rpmflags & RPM_ASYNC) {
Alan Stern15bcb91d2010-09-25 23:35:21 +0200373 dev->power.request = (rpmflags & RPM_AUTO) ?
374 RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200375 if (!dev->power.request_pending) {
376 dev->power.request_pending = true;
377 queue_work(pm_wq, &dev->power.work);
378 }
379 goto out;
380 }
381
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200382 __update_runtime_status(dev, RPM_SUSPENDING);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200383
Rafael J. Wysocki564b9052011-06-23 01:52:55 +0200384 if (dev->pm_domain)
385 callback = dev->pm_domain->ops.runtime_suspend;
Rafael J. Wysocki4d27e9d2011-04-29 00:35:50 +0200386 else if (dev->type && dev->type->pm)
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200387 callback = dev->type->pm->runtime_suspend;
388 else if (dev->class && dev->class->pm)
389 callback = dev->class->pm->runtime_suspend;
Rafael J. Wysocki9659cc02011-02-18 23:20:21 +0100390 else if (dev->bus && dev->bus->pm)
391 callback = dev->bus->pm->runtime_suspend;
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200392 else
393 callback = NULL;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200394
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200395 retval = rpm_callback(callback, dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200396 if (retval) {
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200397 __update_runtime_status(dev, RPM_ACTIVE);
ShuoX Liu2cffff12011-07-08 20:53:55 +0200398 dev->power.deferred_resume = false;
Rafael J. Wysockif71648d2010-10-11 01:02:27 +0200399 if (retval == -EAGAIN || retval == -EBUSY)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200400 dev->power.runtime_error = 0;
Rafael J. Wysockif71648d2010-10-11 01:02:27 +0200401 else
Alan Stern240c7332010-03-23 00:50:07 +0100402 pm_runtime_cancel_pending(dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200403 } else {
Alan Stern7490e442010-09-25 23:35:15 +0200404 no_callback:
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200405 __update_runtime_status(dev, RPM_SUSPENDED);
Alan Stern240c7332010-03-23 00:50:07 +0100406 pm_runtime_deactivate_timer(dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200407
408 if (dev->parent) {
409 parent = dev->parent;
410 atomic_add_unless(&parent->power.child_count, -1, 0);
411 }
412 }
413 wake_up_all(&dev->power.wait_queue);
414
415 if (dev->power.deferred_resume) {
Alan Stern140a6c92010-09-25 23:35:07 +0200416 rpm_resume(dev, 0);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200417 retval = -EAGAIN;
418 goto out;
419 }
420
Alan Sternc3810c82011-01-25 20:50:07 +0100421 /* Maybe the parent is now able to suspend. */
Alan Sternc7b61de2010-12-01 00:14:42 +0100422 if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {
Alan Sternc3810c82011-01-25 20:50:07 +0100423 spin_unlock(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200424
Alan Sternc3810c82011-01-25 20:50:07 +0100425 spin_lock(&parent->power.lock);
426 rpm_idle(parent, RPM_ASYNC);
427 spin_unlock(&parent->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200428
Alan Sternc3810c82011-01-25 20:50:07 +0100429 spin_lock(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200430 }
431
432 out:
Alan Stern3f9af052010-09-25 23:34:54 +0200433 dev_dbg(dev, "%s returns %d\n", __func__, retval);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200434
435 return retval;
436}
437
438/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200439 * rpm_resume - Carry out runtime resume of given device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200440 * @dev: Device to resume.
Alan Stern3f9af052010-09-25 23:34:54 +0200441 * @rpmflags: Flag bits.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200442 *
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200443 * Check if the device's runtime PM status allows it to be resumed. Cancel
Alan Stern1bfee5b2010-09-25 23:35:00 +0200444 * any scheduled or pending requests. If another resume has been started
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300445 * earlier, either return immediately or wait for it to finish, depending on the
Alan Stern1bfee5b2010-09-25 23:35:00 +0200446 * RPM_NOWAIT and RPM_ASYNC flags. Similarly, if there's a suspend running in
447 * parallel with this function, either tell the other process to resume after
448 * suspending (deferred_resume) or wait for it to finish. If the RPM_ASYNC
449 * flag is set then queue a resume request; otherwise run the
450 * ->runtime_resume() callback directly. Queue an idle notification for the
451 * device if the resume succeeded.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200452 *
453 * This function must be called under dev->power.lock with interrupts disabled.
454 */
Alan Stern140a6c92010-09-25 23:35:07 +0200455static int rpm_resume(struct device *dev, int rpmflags)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200456 __releases(&dev->power.lock) __acquires(&dev->power.lock)
457{
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200458 int (*callback)(struct device *);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200459 struct device *parent = NULL;
460 int retval = 0;
461
Alan Stern3f9af052010-09-25 23:34:54 +0200462 dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200463
464 repeat:
Alan Stern1bfee5b2010-09-25 23:35:00 +0200465 if (dev->power.runtime_error)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200466 retval = -EINVAL;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200467 else if (dev->power.disable_depth > 0)
Rafael J. Wysocki632e2702011-07-01 22:29:15 +0200468 retval = -EACCES;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200469 if (retval)
470 goto out;
471
Alan Stern15bcb91d2010-09-25 23:35:21 +0200472 /*
473 * Other scheduled or pending requests need to be canceled. Small
474 * optimization: If an autosuspend timer is running, leave it running
475 * rather than cancelling it now only to restart it again in the near
476 * future.
477 */
478 dev->power.request = RPM_REQ_NONE;
479 if (!dev->power.timer_autosuspends)
480 pm_runtime_deactivate_timer(dev);
Alan Stern1bfee5b2010-09-25 23:35:00 +0200481
482 if (dev->power.runtime_status == RPM_ACTIVE) {
483 retval = 1;
484 goto out;
485 }
486
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200487 if (dev->power.runtime_status == RPM_RESUMING
488 || dev->power.runtime_status == RPM_SUSPENDING) {
489 DEFINE_WAIT(wait);
490
Alan Stern1bfee5b2010-09-25 23:35:00 +0200491 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200492 if (dev->power.runtime_status == RPM_SUSPENDING)
493 dev->power.deferred_resume = true;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200494 else
495 retval = -EINPROGRESS;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200496 goto out;
497 }
498
499 /* Wait for the operation carried out in parallel with us. */
500 for (;;) {
501 prepare_to_wait(&dev->power.wait_queue, &wait,
502 TASK_UNINTERRUPTIBLE);
503 if (dev->power.runtime_status != RPM_RESUMING
504 && dev->power.runtime_status != RPM_SUSPENDING)
505 break;
506
507 spin_unlock_irq(&dev->power.lock);
508
509 schedule();
510
511 spin_lock_irq(&dev->power.lock);
512 }
513 finish_wait(&dev->power.wait_queue, &wait);
514 goto repeat;
515 }
516
Alan Stern7490e442010-09-25 23:35:15 +0200517 /*
518 * See if we can skip waking up the parent. This is safe only if
519 * power.no_callbacks is set, because otherwise we don't know whether
520 * the resume will actually succeed.
521 */
522 if (dev->power.no_callbacks && !parent && dev->parent) {
Ming Leid63be5f2010-10-22 23:48:14 +0200523 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
Alan Stern7490e442010-09-25 23:35:15 +0200524 if (dev->parent->power.disable_depth > 0
525 || dev->parent->power.ignore_children
526 || dev->parent->power.runtime_status == RPM_ACTIVE) {
527 atomic_inc(&dev->parent->power.child_count);
528 spin_unlock(&dev->parent->power.lock);
529 goto no_callback; /* Assume success. */
530 }
531 spin_unlock(&dev->parent->power.lock);
532 }
533
Alan Stern1bfee5b2010-09-25 23:35:00 +0200534 /* Carry out an asynchronous or a synchronous resume. */
535 if (rpmflags & RPM_ASYNC) {
536 dev->power.request = RPM_REQ_RESUME;
537 if (!dev->power.request_pending) {
538 dev->power.request_pending = true;
539 queue_work(pm_wq, &dev->power.work);
540 }
541 retval = 0;
542 goto out;
543 }
544
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200545 if (!parent && dev->parent) {
546 /*
Alan Sternc7b61de2010-12-01 00:14:42 +0100547 * Increment the parent's usage counter and resume it if
548 * necessary. Not needed if dev is irq-safe; then the
549 * parent is permanently resumed.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200550 */
551 parent = dev->parent;
Alan Sternc7b61de2010-12-01 00:14:42 +0100552 if (dev->power.irq_safe)
553 goto skip_parent;
Alan Stern862f89b2009-11-25 01:06:37 +0100554 spin_unlock(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200555
556 pm_runtime_get_noresume(parent);
557
Alan Stern862f89b2009-11-25 01:06:37 +0100558 spin_lock(&parent->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200559 /*
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200560 * We can resume if the parent's runtime PM is disabled or it
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200561 * is set to ignore children.
562 */
563 if (!parent->power.disable_depth
564 && !parent->power.ignore_children) {
Alan Stern140a6c92010-09-25 23:35:07 +0200565 rpm_resume(parent, 0);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200566 if (parent->power.runtime_status != RPM_ACTIVE)
567 retval = -EBUSY;
568 }
Alan Stern862f89b2009-11-25 01:06:37 +0100569 spin_unlock(&parent->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200570
Alan Stern862f89b2009-11-25 01:06:37 +0100571 spin_lock(&dev->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200572 if (retval)
573 goto out;
574 goto repeat;
575 }
Alan Sternc7b61de2010-12-01 00:14:42 +0100576 skip_parent:
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200577
Alan Stern7490e442010-09-25 23:35:15 +0200578 if (dev->power.no_callbacks)
579 goto no_callback; /* Assume success. */
580
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200581 __update_runtime_status(dev, RPM_RESUMING);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200582
Rafael J. Wysocki564b9052011-06-23 01:52:55 +0200583 if (dev->pm_domain)
584 callback = dev->pm_domain->ops.runtime_resume;
Rafael J. Wysocki4d27e9d2011-04-29 00:35:50 +0200585 else if (dev->type && dev->type->pm)
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200586 callback = dev->type->pm->runtime_resume;
587 else if (dev->class && dev->class->pm)
588 callback = dev->class->pm->runtime_resume;
Rafael J. Wysocki9659cc02011-02-18 23:20:21 +0100589 else if (dev->bus && dev->bus->pm)
590 callback = dev->bus->pm->runtime_resume;
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200591 else
592 callback = NULL;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200593
Rafael J. Wysocki71c63122010-10-04 22:08:01 +0200594 retval = rpm_callback(callback, dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200595 if (retval) {
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200596 __update_runtime_status(dev, RPM_SUSPENDED);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200597 pm_runtime_cancel_pending(dev);
598 } else {
Alan Stern7490e442010-09-25 23:35:15 +0200599 no_callback:
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200600 __update_runtime_status(dev, RPM_ACTIVE);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200601 if (parent)
602 atomic_inc(&parent->power.child_count);
603 }
604 wake_up_all(&dev->power.wait_queue);
605
606 if (!retval)
Alan Stern140a6c92010-09-25 23:35:07 +0200607 rpm_idle(dev, RPM_ASYNC);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200608
609 out:
Alan Sternc7b61de2010-12-01 00:14:42 +0100610 if (parent && !dev->power.irq_safe) {
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200611 spin_unlock_irq(&dev->power.lock);
612
613 pm_runtime_put(parent);
614
615 spin_lock_irq(&dev->power.lock);
616 }
617
Alan Stern3f9af052010-09-25 23:34:54 +0200618 dev_dbg(dev, "%s returns %d\n", __func__, retval);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200619
620 return retval;
621}
622
623/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200624 * pm_runtime_work - Universal runtime PM work function.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200625 * @work: Work structure used for scheduling the execution of this function.
626 *
627 * Use @work to get the device object the work is to be done for, determine what
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200628 * is to be done and execute the appropriate runtime PM function.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200629 */
630static void pm_runtime_work(struct work_struct *work)
631{
632 struct device *dev = container_of(work, struct device, power.work);
633 enum rpm_request req;
634
635 spin_lock_irq(&dev->power.lock);
636
637 if (!dev->power.request_pending)
638 goto out;
639
640 req = dev->power.request;
641 dev->power.request = RPM_REQ_NONE;
642 dev->power.request_pending = false;
643
644 switch (req) {
645 case RPM_REQ_NONE:
646 break;
647 case RPM_REQ_IDLE:
Alan Stern140a6c92010-09-25 23:35:07 +0200648 rpm_idle(dev, RPM_NOWAIT);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200649 break;
650 case RPM_REQ_SUSPEND:
Alan Stern140a6c92010-09-25 23:35:07 +0200651 rpm_suspend(dev, RPM_NOWAIT);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200652 break;
Alan Stern15bcb91d2010-09-25 23:35:21 +0200653 case RPM_REQ_AUTOSUSPEND:
654 rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
655 break;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200656 case RPM_REQ_RESUME:
Alan Stern140a6c92010-09-25 23:35:07 +0200657 rpm_resume(dev, RPM_NOWAIT);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200658 break;
659 }
660
661 out:
662 spin_unlock_irq(&dev->power.lock);
663}
664
665/**
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200666 * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
667 * @data: Device pointer passed by pm_schedule_suspend().
668 *
Alan Stern1bfee5b2010-09-25 23:35:00 +0200669 * Check if the time is right and queue a suspend request.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200670 */
671static void pm_suspend_timer_fn(unsigned long data)
672{
673 struct device *dev = (struct device *)data;
674 unsigned long flags;
675 unsigned long expires;
676
677 spin_lock_irqsave(&dev->power.lock, flags);
678
679 expires = dev->power.timer_expires;
680 /* If 'expire' is after 'jiffies' we've been called too early. */
681 if (expires > 0 && !time_after(expires, jiffies)) {
682 dev->power.timer_expires = 0;
Alan Stern15bcb91d2010-09-25 23:35:21 +0200683 rpm_suspend(dev, dev->power.timer_autosuspends ?
684 (RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200685 }
686
687 spin_unlock_irqrestore(&dev->power.lock, flags);
688}
689
690/**
691 * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
692 * @dev: Device to suspend.
693 * @delay: Time to wait before submitting a suspend request, in milliseconds.
694 */
695int pm_schedule_suspend(struct device *dev, unsigned int delay)
696{
697 unsigned long flags;
Alan Stern1bfee5b2010-09-25 23:35:00 +0200698 int retval;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200699
700 spin_lock_irqsave(&dev->power.lock, flags);
701
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200702 if (!delay) {
Alan Stern140a6c92010-09-25 23:35:07 +0200703 retval = rpm_suspend(dev, RPM_ASYNC);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200704 goto out;
705 }
706
Alan Stern1bfee5b2010-09-25 23:35:00 +0200707 retval = rpm_check_suspend_allowed(dev);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200708 if (retval)
709 goto out;
710
Alan Stern1bfee5b2010-09-25 23:35:00 +0200711 /* Other scheduled or pending requests need to be canceled. */
712 pm_runtime_cancel_pending(dev);
713
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200714 dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
Alan Stern1bfee5b2010-09-25 23:35:00 +0200715 dev->power.timer_expires += !dev->power.timer_expires;
Alan Stern15bcb91d2010-09-25 23:35:21 +0200716 dev->power.timer_autosuspends = 0;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200717 mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
718
719 out:
720 spin_unlock_irqrestore(&dev->power.lock, flags);
721
722 return retval;
723}
724EXPORT_SYMBOL_GPL(pm_schedule_suspend);
725
726/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200727 * __pm_runtime_idle - Entry point for runtime idle operations.
Alan Stern140a6c92010-09-25 23:35:07 +0200728 * @dev: Device to send idle notification for.
729 * @rpmflags: Flag bits.
730 *
731 * If the RPM_GET_PUT flag is set, decrement the device's usage count and
732 * return immediately if it is larger than zero. Then carry out an idle
733 * notification, either synchronous or asynchronous.
734 *
735 * This routine may be called in atomic context if the RPM_ASYNC flag is set.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200736 */
Alan Stern140a6c92010-09-25 23:35:07 +0200737int __pm_runtime_idle(struct device *dev, int rpmflags)
738{
739 unsigned long flags;
740 int retval;
741
742 if (rpmflags & RPM_GET_PUT) {
743 if (!atomic_dec_and_test(&dev->power.usage_count))
744 return 0;
745 }
746
747 spin_lock_irqsave(&dev->power.lock, flags);
748 retval = rpm_idle(dev, rpmflags);
749 spin_unlock_irqrestore(&dev->power.lock, flags);
750
751 return retval;
752}
753EXPORT_SYMBOL_GPL(__pm_runtime_idle);
754
755/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200756 * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
Alan Stern140a6c92010-09-25 23:35:07 +0200757 * @dev: Device to suspend.
758 * @rpmflags: Flag bits.
759 *
Alan Stern15bcb91d2010-09-25 23:35:21 +0200760 * If the RPM_GET_PUT flag is set, decrement the device's usage count and
761 * return immediately if it is larger than zero. Then carry out a suspend,
762 * either synchronous or asynchronous.
Alan Stern140a6c92010-09-25 23:35:07 +0200763 *
764 * This routine may be called in atomic context if the RPM_ASYNC flag is set.
765 */
766int __pm_runtime_suspend(struct device *dev, int rpmflags)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200767{
768 unsigned long flags;
769 int retval;
770
Alan Stern15bcb91d2010-09-25 23:35:21 +0200771 if (rpmflags & RPM_GET_PUT) {
772 if (!atomic_dec_and_test(&dev->power.usage_count))
773 return 0;
774 }
775
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200776 spin_lock_irqsave(&dev->power.lock, flags);
Alan Stern140a6c92010-09-25 23:35:07 +0200777 retval = rpm_suspend(dev, rpmflags);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200778 spin_unlock_irqrestore(&dev->power.lock, flags);
779
780 return retval;
781}
Alan Stern140a6c92010-09-25 23:35:07 +0200782EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200783
784/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200785 * __pm_runtime_resume - Entry point for runtime resume operations.
Alan Stern140a6c92010-09-25 23:35:07 +0200786 * @dev: Device to resume.
Alan Stern3f9af052010-09-25 23:34:54 +0200787 * @rpmflags: Flag bits.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200788 *
Alan Stern140a6c92010-09-25 23:35:07 +0200789 * If the RPM_GET_PUT flag is set, increment the device's usage count. Then
790 * carry out a resume, either synchronous or asynchronous.
791 *
792 * This routine may be called in atomic context if the RPM_ASYNC flag is set.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200793 */
Alan Stern140a6c92010-09-25 23:35:07 +0200794int __pm_runtime_resume(struct device *dev, int rpmflags)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200795{
Alan Stern140a6c92010-09-25 23:35:07 +0200796 unsigned long flags;
Alan Stern1d531c12009-12-13 20:28:30 +0100797 int retval;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200798
Alan Stern140a6c92010-09-25 23:35:07 +0200799 if (rpmflags & RPM_GET_PUT)
800 atomic_inc(&dev->power.usage_count);
801
802 spin_lock_irqsave(&dev->power.lock, flags);
803 retval = rpm_resume(dev, rpmflags);
804 spin_unlock_irqrestore(&dev->power.lock, flags);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200805
806 return retval;
807}
Alan Stern140a6c92010-09-25 23:35:07 +0200808EXPORT_SYMBOL_GPL(__pm_runtime_resume);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200809
810/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200811 * __pm_runtime_set_status - Set runtime PM status of a device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200812 * @dev: Device to handle.
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200813 * @status: New runtime PM status of the device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200814 *
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200815 * If runtime PM of the device is disabled or its power.runtime_error field is
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200816 * different from zero, the status may be changed either to RPM_ACTIVE, or to
817 * RPM_SUSPENDED, as long as that reflects the actual state of the device.
818 * However, if the device has a parent and the parent is not active, and the
819 * parent's power.ignore_children flag is unset, the device's status cannot be
820 * set to RPM_ACTIVE, so -EBUSY is returned in that case.
821 *
822 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
823 * and the device parent's counter of unsuspended children is modified to
824 * reflect the new status. If the new status is RPM_SUSPENDED, an idle
825 * notification request for the parent is submitted.
826 */
827int __pm_runtime_set_status(struct device *dev, unsigned int status)
828{
829 struct device *parent = dev->parent;
830 unsigned long flags;
831 bool notify_parent = false;
832 int error = 0;
833
834 if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
835 return -EINVAL;
836
837 spin_lock_irqsave(&dev->power.lock, flags);
838
839 if (!dev->power.runtime_error && !dev->power.disable_depth) {
840 error = -EAGAIN;
841 goto out;
842 }
843
844 if (dev->power.runtime_status == status)
845 goto out_set;
846
847 if (status == RPM_SUSPENDED) {
848 /* It always is possible to set the status to 'suspended'. */
849 if (parent) {
850 atomic_add_unless(&parent->power.child_count, -1, 0);
851 notify_parent = !parent->power.ignore_children;
852 }
853 goto out_set;
854 }
855
856 if (parent) {
Rafael J. Wysockibab636b2009-12-03 20:21:21 +0100857 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200858
859 /*
860 * It is invalid to put an active child under a parent that is
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200861 * not active, has runtime PM enabled and the
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200862 * 'power.ignore_children' flag unset.
863 */
864 if (!parent->power.disable_depth
865 && !parent->power.ignore_children
Rafael J. Wysocki965c4ac2009-12-03 21:04:41 +0100866 && parent->power.runtime_status != RPM_ACTIVE)
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200867 error = -EBUSY;
Rafael J. Wysocki965c4ac2009-12-03 21:04:41 +0100868 else if (dev->power.runtime_status == RPM_SUSPENDED)
869 atomic_inc(&parent->power.child_count);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200870
Alan Stern862f89b2009-11-25 01:06:37 +0100871 spin_unlock(&parent->power.lock);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200872
873 if (error)
874 goto out;
875 }
876
877 out_set:
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +0200878 __update_runtime_status(dev, status);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200879 dev->power.runtime_error = 0;
880 out:
881 spin_unlock_irqrestore(&dev->power.lock, flags);
882
883 if (notify_parent)
884 pm_request_idle(parent);
885
886 return error;
887}
888EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
889
890/**
891 * __pm_runtime_barrier - Cancel pending requests and wait for completions.
892 * @dev: Device to handle.
893 *
894 * Flush all pending requests for the device from pm_wq and wait for all
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200895 * runtime PM operations involving the device in progress to complete.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200896 *
897 * Should be called under dev->power.lock with interrupts disabled.
898 */
899static void __pm_runtime_barrier(struct device *dev)
900{
901 pm_runtime_deactivate_timer(dev);
902
903 if (dev->power.request_pending) {
904 dev->power.request = RPM_REQ_NONE;
905 spin_unlock_irq(&dev->power.lock);
906
907 cancel_work_sync(&dev->power.work);
908
909 spin_lock_irq(&dev->power.lock);
910 dev->power.request_pending = false;
911 }
912
913 if (dev->power.runtime_status == RPM_SUSPENDING
914 || dev->power.runtime_status == RPM_RESUMING
915 || dev->power.idle_notification) {
916 DEFINE_WAIT(wait);
917
918 /* Suspend, wake-up or idle notification in progress. */
919 for (;;) {
920 prepare_to_wait(&dev->power.wait_queue, &wait,
921 TASK_UNINTERRUPTIBLE);
922 if (dev->power.runtime_status != RPM_SUSPENDING
923 && dev->power.runtime_status != RPM_RESUMING
924 && !dev->power.idle_notification)
925 break;
926 spin_unlock_irq(&dev->power.lock);
927
928 schedule();
929
930 spin_lock_irq(&dev->power.lock);
931 }
932 finish_wait(&dev->power.wait_queue, &wait);
933 }
934}
935
936/**
937 * pm_runtime_barrier - Flush pending requests and wait for completions.
938 * @dev: Device to handle.
939 *
940 * Prevent the device from being suspended by incrementing its usage counter and
941 * if there's a pending resume request for the device, wake the device up.
942 * Next, make sure that all pending requests for the device have been flushed
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200943 * from pm_wq and wait for all runtime PM operations involving the device in
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200944 * progress to complete.
945 *
946 * Return value:
947 * 1, if there was a resume request pending and the device had to be woken up,
948 * 0, otherwise
949 */
950int pm_runtime_barrier(struct device *dev)
951{
952 int retval = 0;
953
954 pm_runtime_get_noresume(dev);
955 spin_lock_irq(&dev->power.lock);
956
957 if (dev->power.request_pending
958 && dev->power.request == RPM_REQ_RESUME) {
Alan Stern140a6c92010-09-25 23:35:07 +0200959 rpm_resume(dev, 0);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200960 retval = 1;
961 }
962
963 __pm_runtime_barrier(dev);
964
965 spin_unlock_irq(&dev->power.lock);
966 pm_runtime_put_noidle(dev);
967
968 return retval;
969}
970EXPORT_SYMBOL_GPL(pm_runtime_barrier);
971
972/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200973 * __pm_runtime_disable - Disable runtime PM of a device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200974 * @dev: Device to handle.
975 * @check_resume: If set, check if there's a resume request for the device.
976 *
977 * Increment power.disable_depth for the device and if was zero previously,
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200978 * cancel all pending runtime PM requests for the device and wait for all
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200979 * operations in progress to complete. The device can be either active or
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200980 * suspended after its runtime PM has been disabled.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200981 *
982 * If @check_resume is set and there's a resume request pending when
983 * __pm_runtime_disable() is called and power.disable_depth is zero, the
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200984 * function will wake up the device before disabling its runtime PM.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200985 */
986void __pm_runtime_disable(struct device *dev, bool check_resume)
987{
988 spin_lock_irq(&dev->power.lock);
989
990 if (dev->power.disable_depth > 0) {
991 dev->power.disable_depth++;
992 goto out;
993 }
994
995 /*
996 * Wake up the device if there's a resume request pending, because that
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +0200997 * means there probably is some I/O to process and disabling runtime PM
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +0200998 * shouldn't prevent the device from processing the I/O.
999 */
1000 if (check_resume && dev->power.request_pending
1001 && dev->power.request == RPM_REQ_RESUME) {
1002 /*
1003 * Prevent suspends and idle notifications from being carried
1004 * out after we have woken up the device.
1005 */
1006 pm_runtime_get_noresume(dev);
1007
Alan Stern140a6c92010-09-25 23:35:07 +02001008 rpm_resume(dev, 0);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001009
1010 pm_runtime_put_noidle(dev);
1011 }
1012
1013 if (!dev->power.disable_depth++)
1014 __pm_runtime_barrier(dev);
1015
1016 out:
1017 spin_unlock_irq(&dev->power.lock);
1018}
1019EXPORT_SYMBOL_GPL(__pm_runtime_disable);
1020
1021/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001022 * pm_runtime_enable - Enable runtime PM of a device.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001023 * @dev: Device to handle.
1024 */
1025void pm_runtime_enable(struct device *dev)
1026{
1027 unsigned long flags;
1028
1029 spin_lock_irqsave(&dev->power.lock, flags);
1030
1031 if (dev->power.disable_depth > 0)
1032 dev->power.disable_depth--;
1033 else
1034 dev_warn(dev, "Unbalanced %s!\n", __func__);
1035
1036 spin_unlock_irqrestore(&dev->power.lock, flags);
1037}
1038EXPORT_SYMBOL_GPL(pm_runtime_enable);
1039
1040/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001041 * pm_runtime_forbid - Block runtime PM of a device.
Rafael J. Wysocki53823632010-01-23 22:02:51 +01001042 * @dev: Device to handle.
1043 *
1044 * Increase the device's usage count and clear its power.runtime_auto flag,
1045 * so that it cannot be suspended at run time until pm_runtime_allow() is called
1046 * for it.
1047 */
1048void pm_runtime_forbid(struct device *dev)
1049{
1050 spin_lock_irq(&dev->power.lock);
1051 if (!dev->power.runtime_auto)
1052 goto out;
1053
1054 dev->power.runtime_auto = false;
1055 atomic_inc(&dev->power.usage_count);
Alan Stern140a6c92010-09-25 23:35:07 +02001056 rpm_resume(dev, 0);
Rafael J. Wysocki53823632010-01-23 22:02:51 +01001057
1058 out:
1059 spin_unlock_irq(&dev->power.lock);
1060}
1061EXPORT_SYMBOL_GPL(pm_runtime_forbid);
1062
1063/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001064 * pm_runtime_allow - Unblock runtime PM of a device.
Rafael J. Wysocki53823632010-01-23 22:02:51 +01001065 * @dev: Device to handle.
1066 *
1067 * Decrease the device's usage count and set its power.runtime_auto flag.
1068 */
1069void pm_runtime_allow(struct device *dev)
1070{
1071 spin_lock_irq(&dev->power.lock);
1072 if (dev->power.runtime_auto)
1073 goto out;
1074
1075 dev->power.runtime_auto = true;
1076 if (atomic_dec_and_test(&dev->power.usage_count))
Alan Stern15bcb91d2010-09-25 23:35:21 +02001077 rpm_idle(dev, RPM_AUTO);
Rafael J. Wysocki53823632010-01-23 22:02:51 +01001078
1079 out:
1080 spin_unlock_irq(&dev->power.lock);
1081}
1082EXPORT_SYMBOL_GPL(pm_runtime_allow);
1083
1084/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001085 * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
Alan Stern7490e442010-09-25 23:35:15 +02001086 * @dev: Device to handle.
1087 *
1088 * Set the power.no_callbacks flag, which tells the PM core that this
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001089 * device is power-managed through its parent and has no runtime PM
1090 * callbacks of its own. The runtime sysfs attributes will be removed.
Alan Stern7490e442010-09-25 23:35:15 +02001091 */
1092void pm_runtime_no_callbacks(struct device *dev)
1093{
1094 spin_lock_irq(&dev->power.lock);
1095 dev->power.no_callbacks = 1;
1096 spin_unlock_irq(&dev->power.lock);
1097 if (device_is_registered(dev))
1098 rpm_sysfs_remove(dev);
1099}
1100EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
1101
1102/**
Alan Sternc7b61de2010-12-01 00:14:42 +01001103 * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1104 * @dev: Device to handle
1105 *
1106 * Set the power.irq_safe flag, which tells the PM core that the
1107 * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1108 * always be invoked with the spinlock held and interrupts disabled. It also
1109 * causes the parent's usage counter to be permanently incremented, preventing
1110 * the parent from runtime suspending -- otherwise an irq-safe child might have
1111 * to wait for a non-irq-safe parent.
1112 */
1113void pm_runtime_irq_safe(struct device *dev)
1114{
1115 if (dev->parent)
1116 pm_runtime_get_sync(dev->parent);
1117 spin_lock_irq(&dev->power.lock);
1118 dev->power.irq_safe = 1;
1119 spin_unlock_irq(&dev->power.lock);
1120}
1121EXPORT_SYMBOL_GPL(pm_runtime_irq_safe);
1122
1123/**
Alan Stern15bcb91d2010-09-25 23:35:21 +02001124 * update_autosuspend - Handle a change to a device's autosuspend settings.
1125 * @dev: Device to handle.
1126 * @old_delay: The former autosuspend_delay value.
1127 * @old_use: The former use_autosuspend value.
1128 *
1129 * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1130 * set; otherwise allow it. Send an idle notification if suspends are allowed.
1131 *
1132 * This function must be called under dev->power.lock with interrupts disabled.
1133 */
1134static void update_autosuspend(struct device *dev, int old_delay, int old_use)
1135{
1136 int delay = dev->power.autosuspend_delay;
1137
1138 /* Should runtime suspend be prevented now? */
1139 if (dev->power.use_autosuspend && delay < 0) {
1140
1141 /* If it used to be allowed then prevent it. */
1142 if (!old_use || old_delay >= 0) {
1143 atomic_inc(&dev->power.usage_count);
1144 rpm_resume(dev, 0);
1145 }
1146 }
1147
1148 /* Runtime suspend should be allowed now. */
1149 else {
1150
1151 /* If it used to be prevented then allow it. */
1152 if (old_use && old_delay < 0)
1153 atomic_dec(&dev->power.usage_count);
1154
1155 /* Maybe we can autosuspend now. */
1156 rpm_idle(dev, RPM_AUTO);
1157 }
1158}
1159
1160/**
1161 * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1162 * @dev: Device to handle.
1163 * @delay: Value of the new delay in milliseconds.
1164 *
1165 * Set the device's power.autosuspend_delay value. If it changes to negative
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001166 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1167 * changes the other way, allow runtime suspends.
Alan Stern15bcb91d2010-09-25 23:35:21 +02001168 */
1169void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
1170{
1171 int old_delay, old_use;
1172
1173 spin_lock_irq(&dev->power.lock);
1174 old_delay = dev->power.autosuspend_delay;
1175 old_use = dev->power.use_autosuspend;
1176 dev->power.autosuspend_delay = delay;
1177 update_autosuspend(dev, old_delay, old_use);
1178 spin_unlock_irq(&dev->power.lock);
1179}
1180EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
1181
1182/**
1183 * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1184 * @dev: Device to handle.
1185 * @use: New value for use_autosuspend.
1186 *
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001187 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
Alan Stern15bcb91d2010-09-25 23:35:21 +02001188 * suspends as needed.
1189 */
1190void __pm_runtime_use_autosuspend(struct device *dev, bool use)
1191{
1192 int old_delay, old_use;
1193
1194 spin_lock_irq(&dev->power.lock);
1195 old_delay = dev->power.autosuspend_delay;
1196 old_use = dev->power.use_autosuspend;
1197 dev->power.use_autosuspend = use;
1198 update_autosuspend(dev, old_delay, old_use);
1199 spin_unlock_irq(&dev->power.lock);
1200}
1201EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
1202
1203/**
Rafael J. Wysocki62052ab2011-07-06 10:52:13 +02001204 * pm_runtime_init - Initialize runtime PM fields in given device object.
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001205 * @dev: Device object to initialize.
1206 */
1207void pm_runtime_init(struct device *dev)
1208{
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001209 dev->power.runtime_status = RPM_SUSPENDED;
1210 dev->power.idle_notification = false;
1211
1212 dev->power.disable_depth = 1;
1213 atomic_set(&dev->power.usage_count, 0);
1214
1215 dev->power.runtime_error = 0;
1216
1217 atomic_set(&dev->power.child_count, 0);
1218 pm_suspend_ignore_children(dev, false);
Rafael J. Wysocki53823632010-01-23 22:02:51 +01001219 dev->power.runtime_auto = true;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001220
1221 dev->power.request_pending = false;
1222 dev->power.request = RPM_REQ_NONE;
1223 dev->power.deferred_resume = false;
Arjan van de Ven8d4b9d12010-07-19 02:01:06 +02001224 dev->power.accounting_timestamp = jiffies;
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001225 INIT_WORK(&dev->power.work, pm_runtime_work);
1226
1227 dev->power.timer_expires = 0;
1228 setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,
1229 (unsigned long)dev);
1230
1231 init_waitqueue_head(&dev->power.wait_queue);
1232}
1233
1234/**
1235 * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1236 * @dev: Device object being removed from device hierarchy.
1237 */
1238void pm_runtime_remove(struct device *dev)
1239{
1240 __pm_runtime_disable(dev, false);
1241
1242 /* Change the status back to 'suspended' to match the initial status. */
1243 if (dev->power.runtime_status == RPM_ACTIVE)
1244 pm_runtime_set_suspended(dev);
Alan Sternc7b61de2010-12-01 00:14:42 +01001245 if (dev->power.irq_safe && dev->parent)
1246 pm_runtime_put_sync(dev->parent);
Rafael J. Wysocki5e928f72009-08-18 23:38:32 +02001247}