2 * drivers/base/power/runtime.c - Helper functions for device runtime PM
4 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
5 * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
7 * This file is released under the GPLv2.
10 #include <linux/sched.h>
11 #include <linux/export.h>
12 #include <linux/pm_runtime.h>
13 #include <trace/events/rpm.h>
16 static int rpm_resume(struct device
*dev
, int rpmflags
);
17 static int rpm_suspend(struct device
*dev
, int rpmflags
);
20 * update_pm_runtime_accounting - Update the time accounting of power states
21 * @dev: Device to update the accounting for
23 * In order to be able to have time accounting of the various power states
24 * (as used by programs such as PowerTOP to show the effectiveness of runtime
25 * PM), we need to track the time spent in each state.
26 * update_pm_runtime_accounting must be called each time before the
27 * runtime_status field is updated, to account the time in the old state
30 void update_pm_runtime_accounting(struct device
*dev
)
32 unsigned long now
= jiffies
;
35 delta
= now
- dev
->power
.accounting_timestamp
;
37 dev
->power
.accounting_timestamp
= now
;
39 if (dev
->power
.disable_depth
> 0)
42 if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
43 dev
->power
.suspended_jiffies
+= delta
;
45 dev
->power
.active_jiffies
+= delta
;
48 static void __update_runtime_status(struct device
*dev
, enum rpm_status status
)
50 update_pm_runtime_accounting(dev
);
51 dev
->power
.runtime_status
= status
;
55 * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
56 * @dev: Device to handle.
58 static void pm_runtime_deactivate_timer(struct device
*dev
)
60 if (dev
->power
.timer_expires
> 0) {
61 del_timer(&dev
->power
.suspend_timer
);
62 dev
->power
.timer_expires
= 0;
67 * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
68 * @dev: Device to handle.
70 static void pm_runtime_cancel_pending(struct device
*dev
)
72 pm_runtime_deactivate_timer(dev
);
74 * In case there's a request pending, make sure its work function will
75 * return without doing anything.
77 dev
->power
.request
= RPM_REQ_NONE
;
81 * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
82 * @dev: Device to handle.
84 * Compute the autosuspend-delay expiration time based on the device's
85 * power.last_busy time. If the delay has already expired or is disabled
86 * (negative) or the power.use_autosuspend flag isn't set, return 0.
87 * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
89 * This function may be called either with or without dev->power.lock held.
90 * Either way it can be racy, since power.last_busy may be updated at any time.
92 unsigned long pm_runtime_autosuspend_expiration(struct device
*dev
)
94 int autosuspend_delay
;
96 unsigned long last_busy
;
97 unsigned long expires
= 0;
99 if (!dev
->power
.use_autosuspend
)
102 autosuspend_delay
= ACCESS_ONCE(dev
->power
.autosuspend_delay
);
103 if (autosuspend_delay
< 0)
106 last_busy
= ACCESS_ONCE(dev
->power
.last_busy
);
107 elapsed
= jiffies
- last_busy
;
109 goto out
; /* jiffies has wrapped around. */
112 * If the autosuspend_delay is >= 1 second, align the timer by rounding
113 * up to the nearest second.
115 expires
= last_busy
+ msecs_to_jiffies(autosuspend_delay
);
116 if (autosuspend_delay
>= 1000)
117 expires
= round_jiffies(expires
);
119 if (elapsed
>= expires
- last_busy
)
120 expires
= 0; /* Already expired. */
125 EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration
);
127 static int dev_memalloc_noio(struct device
*dev
, void *data
)
129 return dev
->power
.memalloc_noio
;
133 * pm_runtime_set_memalloc_noio - Set a device's memalloc_noio flag.
134 * @dev: Device to handle.
135 * @enable: True for setting the flag and False for clearing the flag.
137 * Set the flag for all devices in the path from the device to the
138 * root device in the device tree if @enable is true, otherwise clear
139 * the flag for devices in the path whose siblings don't set the flag.
141 * The function should only be called by block device, or network
142 * device driver for solving the deadlock problem during runtime
145 * If memory allocation with GFP_KERNEL is called inside runtime
146 * resume/suspend callback of any one of its ancestors(or the
147 * block device itself), the deadlock may be triggered inside the
148 * memory allocation since it might not complete until the block
149 * device becomes active and the involed page I/O finishes. The
150 * situation is pointed out first by Alan Stern. Network device
151 * are involved in iSCSI kind of situation.
153 * The lock of dev_hotplug_mutex is held in the function for handling
154 * hotplug race because pm_runtime_set_memalloc_noio() may be called
157 * The function should be called between device_add() and device_del()
158 * on the affected device(block/network device).
160 void pm_runtime_set_memalloc_noio(struct device
*dev
, bool enable
)
162 static DEFINE_MUTEX(dev_hotplug_mutex
);
164 mutex_lock(&dev_hotplug_mutex
);
168 /* hold power lock since bitfield is not SMP-safe. */
169 spin_lock_irq(&dev
->power
.lock
);
170 enabled
= dev
->power
.memalloc_noio
;
171 dev
->power
.memalloc_noio
= enable
;
172 spin_unlock_irq(&dev
->power
.lock
);
175 * not need to enable ancestors any more if the device
178 if (enabled
&& enable
)
184 * clear flag of the parent device only if all the
185 * children don't set the flag because ancestor's
186 * flag was set by any one of the descendants.
188 if (!dev
|| (!enable
&&
189 device_for_each_child(dev
, NULL
,
193 mutex_unlock(&dev_hotplug_mutex
);
195 EXPORT_SYMBOL_GPL(pm_runtime_set_memalloc_noio
);
198 * rpm_check_suspend_allowed - Test whether a device may be suspended.
199 * @dev: Device to test.
201 static int rpm_check_suspend_allowed(struct device
*dev
)
205 if (dev
->power
.runtime_error
)
207 else if (dev
->power
.disable_depth
> 0)
209 else if (atomic_read(&dev
->power
.usage_count
) > 0)
211 else if (!pm_children_suspended(dev
))
214 /* Pending resume requests take precedence over suspends. */
215 else if ((dev
->power
.deferred_resume
216 && dev
->power
.runtime_status
== RPM_SUSPENDING
)
217 || (dev
->power
.request_pending
218 && dev
->power
.request
== RPM_REQ_RESUME
))
220 else if (__dev_pm_qos_read_value(dev
) < 0)
222 else if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
229 * __rpm_callback - Run a given runtime PM callback for a given device.
230 * @cb: Runtime PM callback to run.
231 * @dev: Device to run the callback for.
233 static int __rpm_callback(int (*cb
)(struct device
*), struct device
*dev
)
234 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
238 if (dev
->power
.irq_safe
)
239 spin_unlock(&dev
->power
.lock
);
241 spin_unlock_irq(&dev
->power
.lock
);
245 if (dev
->power
.irq_safe
)
246 spin_lock(&dev
->power
.lock
);
248 spin_lock_irq(&dev
->power
.lock
);
254 * rpm_idle - Notify device bus type if the device can be suspended.
255 * @dev: Device to notify the bus type about.
256 * @rpmflags: Flag bits.
258 * Check if the device's runtime PM status allows it to be suspended. If
259 * another idle notification has been started earlier, return immediately. If
260 * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
261 * run the ->runtime_idle() callback directly.
263 * This function must be called under dev->power.lock with interrupts disabled.
265 static int rpm_idle(struct device
*dev
, int rpmflags
)
267 int (*callback
)(struct device
*);
270 trace_rpm_idle(dev
, rpmflags
);
271 retval
= rpm_check_suspend_allowed(dev
);
273 ; /* Conditions are wrong. */
275 /* Idle notifications are allowed only in the RPM_ACTIVE state. */
276 else if (dev
->power
.runtime_status
!= RPM_ACTIVE
)
280 * Any pending request other than an idle notification takes
281 * precedence over us, except that the timer may be running.
283 else if (dev
->power
.request_pending
&&
284 dev
->power
.request
> RPM_REQ_IDLE
)
287 /* Act as though RPM_NOWAIT is always set. */
288 else if (dev
->power
.idle_notification
)
289 retval
= -EINPROGRESS
;
293 /* Pending requests need to be canceled. */
294 dev
->power
.request
= RPM_REQ_NONE
;
296 if (dev
->power
.no_callbacks
) {
297 /* Assume ->runtime_idle() callback would have suspended. */
298 retval
= rpm_suspend(dev
, rpmflags
);
302 /* Carry out an asynchronous or a synchronous idle notification. */
303 if (rpmflags
& RPM_ASYNC
) {
304 dev
->power
.request
= RPM_REQ_IDLE
;
305 if (!dev
->power
.request_pending
) {
306 dev
->power
.request_pending
= true;
307 queue_work(pm_wq
, &dev
->power
.work
);
312 dev
->power
.idle_notification
= true;
315 callback
= dev
->pm_domain
->ops
.runtime_idle
;
316 else if (dev
->type
&& dev
->type
->pm
)
317 callback
= dev
->type
->pm
->runtime_idle
;
318 else if (dev
->class && dev
->class->pm
)
319 callback
= dev
->class->pm
->runtime_idle
;
320 else if (dev
->bus
&& dev
->bus
->pm
)
321 callback
= dev
->bus
->pm
->runtime_idle
;
325 if (!callback
&& dev
->driver
&& dev
->driver
->pm
)
326 callback
= dev
->driver
->pm
->runtime_idle
;
329 __rpm_callback(callback
, dev
);
331 dev
->power
.idle_notification
= false;
332 wake_up_all(&dev
->power
.wait_queue
);
335 trace_rpm_return_int(dev
, _THIS_IP_
, retval
);
340 * rpm_callback - Run a given runtime PM callback for a given device.
341 * @cb: Runtime PM callback to run.
342 * @dev: Device to run the callback for.
344 static int rpm_callback(int (*cb
)(struct device
*), struct device
*dev
)
351 if (dev
->power
.memalloc_noio
) {
352 unsigned int noio_flag
;
355 * Deadlock might be caused if memory allocation with
356 * GFP_KERNEL happens inside runtime_suspend and
357 * runtime_resume callbacks of one block device's
358 * ancestor or the block device itself. Network
359 * device might be thought as part of iSCSI block
360 * device, so network device and its ancestor should
361 * be marked as memalloc_noio too.
363 noio_flag
= memalloc_noio_save();
364 retval
= __rpm_callback(cb
, dev
);
365 memalloc_noio_restore(noio_flag
);
367 retval
= __rpm_callback(cb
, dev
);
370 dev
->power
.runtime_error
= retval
;
371 return retval
!= -EACCES
? retval
: -EIO
;
375 * rpm_suspend - Carry out runtime suspend of given device.
376 * @dev: Device to suspend.
377 * @rpmflags: Flag bits.
379 * Check if the device's runtime PM status allows it to be suspended.
380 * Cancel a pending idle notification, autosuspend or suspend. If
381 * another suspend has been started earlier, either return immediately
382 * or wait for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC
383 * flags. If the RPM_ASYNC flag is set then queue a suspend request;
384 * otherwise run the ->runtime_suspend() callback directly. When
385 * ->runtime_suspend succeeded, if a deferred resume was requested while
386 * the callback was running then carry it out, otherwise send an idle
387 * notification for its parent (if the suspend succeeded and both
388 * ignore_children of parent->power and irq_safe of dev->power are not set).
389 * If ->runtime_suspend failed with -EAGAIN or -EBUSY, and if the RPM_AUTO
390 * flag is set and the next autosuspend-delay expiration time is in the
391 * future, schedule another autosuspend attempt.
393 * This function must be called under dev->power.lock with interrupts disabled.
395 static int rpm_suspend(struct device
*dev
, int rpmflags
)
396 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
398 int (*callback
)(struct device
*);
399 struct device
*parent
= NULL
;
402 trace_rpm_suspend(dev
, rpmflags
);
405 retval
= rpm_check_suspend_allowed(dev
);
408 ; /* Conditions are wrong. */
410 /* Synchronous suspends are not allowed in the RPM_RESUMING state. */
411 else if (dev
->power
.runtime_status
== RPM_RESUMING
&&
412 !(rpmflags
& RPM_ASYNC
))
417 /* If the autosuspend_delay time hasn't expired yet, reschedule. */
418 if ((rpmflags
& RPM_AUTO
)
419 && dev
->power
.runtime_status
!= RPM_SUSPENDING
) {
420 unsigned long expires
= pm_runtime_autosuspend_expiration(dev
);
423 /* Pending requests need to be canceled. */
424 dev
->power
.request
= RPM_REQ_NONE
;
427 * Optimization: If the timer is already running and is
428 * set to expire at or before the autosuspend delay,
429 * avoid the overhead of resetting it. Just let it
430 * expire; pm_suspend_timer_fn() will take care of the
433 if (!(dev
->power
.timer_expires
&& time_before_eq(
434 dev
->power
.timer_expires
, expires
))) {
435 dev
->power
.timer_expires
= expires
;
436 mod_timer(&dev
->power
.suspend_timer
, expires
);
438 dev
->power
.timer_autosuspends
= 1;
443 /* Other scheduled or pending requests need to be canceled. */
444 pm_runtime_cancel_pending(dev
);
446 if (dev
->power
.runtime_status
== RPM_SUSPENDING
) {
449 if (rpmflags
& (RPM_ASYNC
| RPM_NOWAIT
)) {
450 retval
= -EINPROGRESS
;
454 if (dev
->power
.irq_safe
) {
455 spin_unlock(&dev
->power
.lock
);
459 spin_lock(&dev
->power
.lock
);
463 /* Wait for the other suspend running in parallel with us. */
465 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
466 TASK_UNINTERRUPTIBLE
);
467 if (dev
->power
.runtime_status
!= RPM_SUSPENDING
)
470 spin_unlock_irq(&dev
->power
.lock
);
474 spin_lock_irq(&dev
->power
.lock
);
476 finish_wait(&dev
->power
.wait_queue
, &wait
);
480 if (dev
->power
.no_callbacks
)
481 goto no_callback
; /* Assume success. */
483 /* Carry out an asynchronous or a synchronous suspend. */
484 if (rpmflags
& RPM_ASYNC
) {
485 dev
->power
.request
= (rpmflags
& RPM_AUTO
) ?
486 RPM_REQ_AUTOSUSPEND
: RPM_REQ_SUSPEND
;
487 if (!dev
->power
.request_pending
) {
488 dev
->power
.request_pending
= true;
489 queue_work(pm_wq
, &dev
->power
.work
);
494 __update_runtime_status(dev
, RPM_SUSPENDING
);
497 callback
= dev
->pm_domain
->ops
.runtime_suspend
;
498 else if (dev
->type
&& dev
->type
->pm
)
499 callback
= dev
->type
->pm
->runtime_suspend
;
500 else if (dev
->class && dev
->class->pm
)
501 callback
= dev
->class->pm
->runtime_suspend
;
502 else if (dev
->bus
&& dev
->bus
->pm
)
503 callback
= dev
->bus
->pm
->runtime_suspend
;
507 if (!callback
&& dev
->driver
&& dev
->driver
->pm
)
508 callback
= dev
->driver
->pm
->runtime_suspend
;
510 retval
= rpm_callback(callback
, dev
);
515 __update_runtime_status(dev
, RPM_SUSPENDED
);
516 pm_runtime_deactivate_timer(dev
);
519 parent
= dev
->parent
;
520 atomic_add_unless(&parent
->power
.child_count
, -1, 0);
522 wake_up_all(&dev
->power
.wait_queue
);
524 if (dev
->power
.deferred_resume
) {
525 dev
->power
.deferred_resume
= false;
531 /* Maybe the parent is now able to suspend. */
532 if (parent
&& !parent
->power
.ignore_children
&& !dev
->power
.irq_safe
) {
533 spin_unlock(&dev
->power
.lock
);
535 spin_lock(&parent
->power
.lock
);
536 rpm_idle(parent
, RPM_ASYNC
);
537 spin_unlock(&parent
->power
.lock
);
539 spin_lock(&dev
->power
.lock
);
543 trace_rpm_return_int(dev
, _THIS_IP_
, retval
);
548 __update_runtime_status(dev
, RPM_ACTIVE
);
549 dev
->power
.deferred_resume
= false;
550 wake_up_all(&dev
->power
.wait_queue
);
552 if (retval
== -EAGAIN
|| retval
== -EBUSY
) {
553 dev
->power
.runtime_error
= 0;
556 * If the callback routine failed an autosuspend, and
557 * if the last_busy time has been updated so that there
558 * is a new autosuspend expiration time, automatically
559 * reschedule another autosuspend.
561 if ((rpmflags
& RPM_AUTO
) &&
562 pm_runtime_autosuspend_expiration(dev
) != 0)
565 pm_runtime_cancel_pending(dev
);
571 * rpm_resume - Carry out runtime resume of given device.
572 * @dev: Device to resume.
573 * @rpmflags: Flag bits.
575 * Check if the device's runtime PM status allows it to be resumed. Cancel
576 * any scheduled or pending requests. If another resume has been started
577 * earlier, either return immediately or wait for it to finish, depending on the
578 * RPM_NOWAIT and RPM_ASYNC flags. Similarly, if there's a suspend running in
579 * parallel with this function, either tell the other process to resume after
580 * suspending (deferred_resume) or wait for it to finish. If the RPM_ASYNC
581 * flag is set then queue a resume request; otherwise run the
582 * ->runtime_resume() callback directly. Queue an idle notification for the
583 * device if the resume succeeded.
585 * This function must be called under dev->power.lock with interrupts disabled.
587 static int rpm_resume(struct device
*dev
, int rpmflags
)
588 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
590 int (*callback
)(struct device
*);
591 struct device
*parent
= NULL
;
594 trace_rpm_resume(dev
, rpmflags
);
597 if (dev
->power
.runtime_error
)
599 else if (dev
->power
.disable_depth
== 1 && dev
->power
.is_suspended
600 && dev
->power
.runtime_status
== RPM_ACTIVE
)
602 else if (dev
->power
.disable_depth
> 0)
608 * Other scheduled or pending requests need to be canceled. Small
609 * optimization: If an autosuspend timer is running, leave it running
610 * rather than cancelling it now only to restart it again in the near
613 dev
->power
.request
= RPM_REQ_NONE
;
614 if (!dev
->power
.timer_autosuspends
)
615 pm_runtime_deactivate_timer(dev
);
617 if (dev
->power
.runtime_status
== RPM_ACTIVE
) {
622 if (dev
->power
.runtime_status
== RPM_RESUMING
623 || dev
->power
.runtime_status
== RPM_SUSPENDING
) {
626 if (rpmflags
& (RPM_ASYNC
| RPM_NOWAIT
)) {
627 if (dev
->power
.runtime_status
== RPM_SUSPENDING
)
628 dev
->power
.deferred_resume
= true;
630 retval
= -EINPROGRESS
;
634 if (dev
->power
.irq_safe
) {
635 spin_unlock(&dev
->power
.lock
);
639 spin_lock(&dev
->power
.lock
);
643 /* Wait for the operation carried out in parallel with us. */
645 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
646 TASK_UNINTERRUPTIBLE
);
647 if (dev
->power
.runtime_status
!= RPM_RESUMING
648 && dev
->power
.runtime_status
!= RPM_SUSPENDING
)
651 spin_unlock_irq(&dev
->power
.lock
);
655 spin_lock_irq(&dev
->power
.lock
);
657 finish_wait(&dev
->power
.wait_queue
, &wait
);
662 * See if we can skip waking up the parent. This is safe only if
663 * power.no_callbacks is set, because otherwise we don't know whether
664 * the resume will actually succeed.
666 if (dev
->power
.no_callbacks
&& !parent
&& dev
->parent
) {
667 spin_lock_nested(&dev
->parent
->power
.lock
, SINGLE_DEPTH_NESTING
);
668 if (dev
->parent
->power
.disable_depth
> 0
669 || dev
->parent
->power
.ignore_children
670 || dev
->parent
->power
.runtime_status
== RPM_ACTIVE
) {
671 atomic_inc(&dev
->parent
->power
.child_count
);
672 spin_unlock(&dev
->parent
->power
.lock
);
674 goto no_callback
; /* Assume success. */
676 spin_unlock(&dev
->parent
->power
.lock
);
679 /* Carry out an asynchronous or a synchronous resume. */
680 if (rpmflags
& RPM_ASYNC
) {
681 dev
->power
.request
= RPM_REQ_RESUME
;
682 if (!dev
->power
.request_pending
) {
683 dev
->power
.request_pending
= true;
684 queue_work(pm_wq
, &dev
->power
.work
);
690 if (!parent
&& dev
->parent
) {
692 * Increment the parent's usage counter and resume it if
693 * necessary. Not needed if dev is irq-safe; then the
694 * parent is permanently resumed.
696 parent
= dev
->parent
;
697 if (dev
->power
.irq_safe
)
699 spin_unlock(&dev
->power
.lock
);
701 pm_runtime_get_noresume(parent
);
703 spin_lock(&parent
->power
.lock
);
705 * We can resume if the parent's runtime PM is disabled or it
706 * is set to ignore children.
708 if (!parent
->power
.disable_depth
709 && !parent
->power
.ignore_children
) {
710 rpm_resume(parent
, 0);
711 if (parent
->power
.runtime_status
!= RPM_ACTIVE
)
714 spin_unlock(&parent
->power
.lock
);
716 spin_lock(&dev
->power
.lock
);
723 if (dev
->power
.no_callbacks
)
724 goto no_callback
; /* Assume success. */
726 __update_runtime_status(dev
, RPM_RESUMING
);
729 callback
= dev
->pm_domain
->ops
.runtime_resume
;
730 else if (dev
->type
&& dev
->type
->pm
)
731 callback
= dev
->type
->pm
->runtime_resume
;
732 else if (dev
->class && dev
->class->pm
)
733 callback
= dev
->class->pm
->runtime_resume
;
734 else if (dev
->bus
&& dev
->bus
->pm
)
735 callback
= dev
->bus
->pm
->runtime_resume
;
739 if (!callback
&& dev
->driver
&& dev
->driver
->pm
)
740 callback
= dev
->driver
->pm
->runtime_resume
;
742 retval
= rpm_callback(callback
, dev
);
744 __update_runtime_status(dev
, RPM_SUSPENDED
);
745 pm_runtime_cancel_pending(dev
);
748 __update_runtime_status(dev
, RPM_ACTIVE
);
750 atomic_inc(&parent
->power
.child_count
);
752 wake_up_all(&dev
->power
.wait_queue
);
755 rpm_idle(dev
, RPM_ASYNC
);
758 if (parent
&& !dev
->power
.irq_safe
) {
759 spin_unlock_irq(&dev
->power
.lock
);
761 pm_runtime_put(parent
);
763 spin_lock_irq(&dev
->power
.lock
);
766 trace_rpm_return_int(dev
, _THIS_IP_
, retval
);
772 * pm_runtime_work - Universal runtime PM work function.
773 * @work: Work structure used for scheduling the execution of this function.
775 * Use @work to get the device object the work is to be done for, determine what
776 * is to be done and execute the appropriate runtime PM function.
778 static void pm_runtime_work(struct work_struct
*work
)
780 struct device
*dev
= container_of(work
, struct device
, power
.work
);
781 enum rpm_request req
;
783 spin_lock_irq(&dev
->power
.lock
);
785 if (!dev
->power
.request_pending
)
788 req
= dev
->power
.request
;
789 dev
->power
.request
= RPM_REQ_NONE
;
790 dev
->power
.request_pending
= false;
796 rpm_idle(dev
, RPM_NOWAIT
);
798 case RPM_REQ_SUSPEND
:
799 rpm_suspend(dev
, RPM_NOWAIT
);
801 case RPM_REQ_AUTOSUSPEND
:
802 rpm_suspend(dev
, RPM_NOWAIT
| RPM_AUTO
);
805 rpm_resume(dev
, RPM_NOWAIT
);
810 spin_unlock_irq(&dev
->power
.lock
);
814 * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
815 * @data: Device pointer passed by pm_schedule_suspend().
817 * Check if the time is right and queue a suspend request.
819 static void pm_suspend_timer_fn(unsigned long data
)
821 struct device
*dev
= (struct device
*)data
;
823 unsigned long expires
;
825 spin_lock_irqsave(&dev
->power
.lock
, flags
);
827 expires
= dev
->power
.timer_expires
;
828 /* If 'expire' is after 'jiffies' we've been called too early. */
829 if (expires
> 0 && !time_after(expires
, jiffies
)) {
830 dev
->power
.timer_expires
= 0;
831 rpm_suspend(dev
, dev
->power
.timer_autosuspends
?
832 (RPM_ASYNC
| RPM_AUTO
) : RPM_ASYNC
);
835 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
839 * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
840 * @dev: Device to suspend.
841 * @delay: Time to wait before submitting a suspend request, in milliseconds.
843 int pm_schedule_suspend(struct device
*dev
, unsigned int delay
)
848 spin_lock_irqsave(&dev
->power
.lock
, flags
);
851 retval
= rpm_suspend(dev
, RPM_ASYNC
);
855 retval
= rpm_check_suspend_allowed(dev
);
859 /* Other scheduled or pending requests need to be canceled. */
860 pm_runtime_cancel_pending(dev
);
862 dev
->power
.timer_expires
= jiffies
+ msecs_to_jiffies(delay
);
863 dev
->power
.timer_expires
+= !dev
->power
.timer_expires
;
864 dev
->power
.timer_autosuspends
= 0;
865 mod_timer(&dev
->power
.suspend_timer
, dev
->power
.timer_expires
);
868 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
872 EXPORT_SYMBOL_GPL(pm_schedule_suspend
);
875 * __pm_runtime_idle - Entry point for runtime idle operations.
876 * @dev: Device to send idle notification for.
877 * @rpmflags: Flag bits.
879 * If the RPM_GET_PUT flag is set, decrement the device's usage count and
880 * return immediately if it is larger than zero. Then carry out an idle
881 * notification, either synchronous or asynchronous.
883 * This routine may be called in atomic context if the RPM_ASYNC flag is set,
884 * or if pm_runtime_irq_safe() has been called.
886 int __pm_runtime_idle(struct device
*dev
, int rpmflags
)
891 might_sleep_if(!(rpmflags
& RPM_ASYNC
) && !dev
->power
.irq_safe
);
893 if (rpmflags
& RPM_GET_PUT
) {
894 if (!atomic_dec_and_test(&dev
->power
.usage_count
))
898 spin_lock_irqsave(&dev
->power
.lock
, flags
);
899 retval
= rpm_idle(dev
, rpmflags
);
900 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
904 EXPORT_SYMBOL_GPL(__pm_runtime_idle
);
907 * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
908 * @dev: Device to suspend.
909 * @rpmflags: Flag bits.
911 * If the RPM_GET_PUT flag is set, decrement the device's usage count and
912 * return immediately if it is larger than zero. Then carry out a suspend,
913 * either synchronous or asynchronous.
915 * This routine may be called in atomic context if the RPM_ASYNC flag is set,
916 * or if pm_runtime_irq_safe() has been called.
918 int __pm_runtime_suspend(struct device
*dev
, int rpmflags
)
923 might_sleep_if(!(rpmflags
& RPM_ASYNC
) && !dev
->power
.irq_safe
);
925 if (rpmflags
& RPM_GET_PUT
) {
926 if (!atomic_dec_and_test(&dev
->power
.usage_count
))
930 spin_lock_irqsave(&dev
->power
.lock
, flags
);
931 retval
= rpm_suspend(dev
, rpmflags
);
932 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
936 EXPORT_SYMBOL_GPL(__pm_runtime_suspend
);
939 * __pm_runtime_resume - Entry point for runtime resume operations.
940 * @dev: Device to resume.
941 * @rpmflags: Flag bits.
943 * If the RPM_GET_PUT flag is set, increment the device's usage count. Then
944 * carry out a resume, either synchronous or asynchronous.
946 * This routine may be called in atomic context if the RPM_ASYNC flag is set,
947 * or if pm_runtime_irq_safe() has been called.
949 int __pm_runtime_resume(struct device
*dev
, int rpmflags
)
954 might_sleep_if(!(rpmflags
& RPM_ASYNC
) && !dev
->power
.irq_safe
);
956 if (rpmflags
& RPM_GET_PUT
)
957 atomic_inc(&dev
->power
.usage_count
);
959 spin_lock_irqsave(&dev
->power
.lock
, flags
);
960 retval
= rpm_resume(dev
, rpmflags
);
961 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
965 EXPORT_SYMBOL_GPL(__pm_runtime_resume
);
968 * __pm_runtime_set_status - Set runtime PM status of a device.
969 * @dev: Device to handle.
970 * @status: New runtime PM status of the device.
972 * If runtime PM of the device is disabled or its power.runtime_error field is
973 * different from zero, the status may be changed either to RPM_ACTIVE, or to
974 * RPM_SUSPENDED, as long as that reflects the actual state of the device.
975 * However, if the device has a parent and the parent is not active, and the
976 * parent's power.ignore_children flag is unset, the device's status cannot be
977 * set to RPM_ACTIVE, so -EBUSY is returned in that case.
979 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
980 * and the device parent's counter of unsuspended children is modified to
981 * reflect the new status. If the new status is RPM_SUSPENDED, an idle
982 * notification request for the parent is submitted.
984 int __pm_runtime_set_status(struct device
*dev
, unsigned int status
)
986 struct device
*parent
= dev
->parent
;
988 bool notify_parent
= false;
991 if (status
!= RPM_ACTIVE
&& status
!= RPM_SUSPENDED
)
994 spin_lock_irqsave(&dev
->power
.lock
, flags
);
996 if (!dev
->power
.runtime_error
&& !dev
->power
.disable_depth
) {
1001 if (dev
->power
.runtime_status
== status
)
1004 if (status
== RPM_SUSPENDED
) {
1005 /* It always is possible to set the status to 'suspended'. */
1007 atomic_add_unless(&parent
->power
.child_count
, -1, 0);
1008 notify_parent
= !parent
->power
.ignore_children
;
1014 spin_lock_nested(&parent
->power
.lock
, SINGLE_DEPTH_NESTING
);
1017 * It is invalid to put an active child under a parent that is
1018 * not active, has runtime PM enabled and the
1019 * 'power.ignore_children' flag unset.
1021 if (!parent
->power
.disable_depth
1022 && !parent
->power
.ignore_children
1023 && parent
->power
.runtime_status
!= RPM_ACTIVE
)
1025 else if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
1026 atomic_inc(&parent
->power
.child_count
);
1028 spin_unlock(&parent
->power
.lock
);
1035 __update_runtime_status(dev
, status
);
1036 dev
->power
.runtime_error
= 0;
1038 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
1041 pm_request_idle(parent
);
1045 EXPORT_SYMBOL_GPL(__pm_runtime_set_status
);
1048 * __pm_runtime_barrier - Cancel pending requests and wait for completions.
1049 * @dev: Device to handle.
1051 * Flush all pending requests for the device from pm_wq and wait for all
1052 * runtime PM operations involving the device in progress to complete.
1054 * Should be called under dev->power.lock with interrupts disabled.
1056 static void __pm_runtime_barrier(struct device
*dev
)
1058 pm_runtime_deactivate_timer(dev
);
1060 if (dev
->power
.request_pending
) {
1061 dev
->power
.request
= RPM_REQ_NONE
;
1062 spin_unlock_irq(&dev
->power
.lock
);
1064 cancel_work_sync(&dev
->power
.work
);
1066 spin_lock_irq(&dev
->power
.lock
);
1067 dev
->power
.request_pending
= false;
1070 if (dev
->power
.runtime_status
== RPM_SUSPENDING
1071 || dev
->power
.runtime_status
== RPM_RESUMING
1072 || dev
->power
.idle_notification
) {
1075 /* Suspend, wake-up or idle notification in progress. */
1077 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
1078 TASK_UNINTERRUPTIBLE
);
1079 if (dev
->power
.runtime_status
!= RPM_SUSPENDING
1080 && dev
->power
.runtime_status
!= RPM_RESUMING
1081 && !dev
->power
.idle_notification
)
1083 spin_unlock_irq(&dev
->power
.lock
);
1087 spin_lock_irq(&dev
->power
.lock
);
1089 finish_wait(&dev
->power
.wait_queue
, &wait
);
1094 * pm_runtime_barrier - Flush pending requests and wait for completions.
1095 * @dev: Device to handle.
1097 * Prevent the device from being suspended by incrementing its usage counter and
1098 * if there's a pending resume request for the device, wake the device up.
1099 * Next, make sure that all pending requests for the device have been flushed
1100 * from pm_wq and wait for all runtime PM operations involving the device in
1101 * progress to complete.
1104 * 1, if there was a resume request pending and the device had to be woken up,
1107 int pm_runtime_barrier(struct device
*dev
)
1111 pm_runtime_get_noresume(dev
);
1112 spin_lock_irq(&dev
->power
.lock
);
1114 if (dev
->power
.request_pending
1115 && dev
->power
.request
== RPM_REQ_RESUME
) {
1120 __pm_runtime_barrier(dev
);
1122 spin_unlock_irq(&dev
->power
.lock
);
1123 pm_runtime_put_noidle(dev
);
1127 EXPORT_SYMBOL_GPL(pm_runtime_barrier
);
1130 * __pm_runtime_disable - Disable runtime PM of a device.
1131 * @dev: Device to handle.
1132 * @check_resume: If set, check if there's a resume request for the device.
1134 * Increment power.disable_depth for the device and if was zero previously,
1135 * cancel all pending runtime PM requests for the device and wait for all
1136 * operations in progress to complete. The device can be either active or
1137 * suspended after its runtime PM has been disabled.
1139 * If @check_resume is set and there's a resume request pending when
1140 * __pm_runtime_disable() is called and power.disable_depth is zero, the
1141 * function will wake up the device before disabling its runtime PM.
1143 void __pm_runtime_disable(struct device
*dev
, bool check_resume
)
1145 spin_lock_irq(&dev
->power
.lock
);
1147 if (dev
->power
.disable_depth
> 0) {
1148 dev
->power
.disable_depth
++;
1153 * Wake up the device if there's a resume request pending, because that
1154 * means there probably is some I/O to process and disabling runtime PM
1155 * shouldn't prevent the device from processing the I/O.
1157 if (check_resume
&& dev
->power
.request_pending
1158 && dev
->power
.request
== RPM_REQ_RESUME
) {
1160 * Prevent suspends and idle notifications from being carried
1161 * out after we have woken up the device.
1163 pm_runtime_get_noresume(dev
);
1167 pm_runtime_put_noidle(dev
);
1170 if (!dev
->power
.disable_depth
++)
1171 __pm_runtime_barrier(dev
);
1174 spin_unlock_irq(&dev
->power
.lock
);
1176 EXPORT_SYMBOL_GPL(__pm_runtime_disable
);
1179 * pm_runtime_enable - Enable runtime PM of a device.
1180 * @dev: Device to handle.
1182 void pm_runtime_enable(struct device
*dev
)
1184 unsigned long flags
;
1186 spin_lock_irqsave(&dev
->power
.lock
, flags
);
1188 if (dev
->power
.disable_depth
> 0)
1189 dev
->power
.disable_depth
--;
1191 dev_warn(dev
, "Unbalanced %s!\n", __func__
);
1193 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
1195 EXPORT_SYMBOL_GPL(pm_runtime_enable
);
1198 * pm_runtime_forbid - Block runtime PM of a device.
1199 * @dev: Device to handle.
1201 * Increase the device's usage count and clear its power.runtime_auto flag,
1202 * so that it cannot be suspended at run time until pm_runtime_allow() is called
1205 void pm_runtime_forbid(struct device
*dev
)
1207 spin_lock_irq(&dev
->power
.lock
);
1208 if (!dev
->power
.runtime_auto
)
1211 dev
->power
.runtime_auto
= false;
1212 atomic_inc(&dev
->power
.usage_count
);
1216 spin_unlock_irq(&dev
->power
.lock
);
1218 EXPORT_SYMBOL_GPL(pm_runtime_forbid
);
1221 * pm_runtime_allow - Unblock runtime PM of a device.
1222 * @dev: Device to handle.
1224 * Decrease the device's usage count and set its power.runtime_auto flag.
1226 void pm_runtime_allow(struct device
*dev
)
1228 spin_lock_irq(&dev
->power
.lock
);
1229 if (dev
->power
.runtime_auto
)
1232 dev
->power
.runtime_auto
= true;
1233 if (atomic_dec_and_test(&dev
->power
.usage_count
))
1234 rpm_idle(dev
, RPM_AUTO
);
1237 spin_unlock_irq(&dev
->power
.lock
);
1239 EXPORT_SYMBOL_GPL(pm_runtime_allow
);
1242 * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
1243 * @dev: Device to handle.
1245 * Set the power.no_callbacks flag, which tells the PM core that this
1246 * device is power-managed through its parent and has no runtime PM
1247 * callbacks of its own. The runtime sysfs attributes will be removed.
1249 void pm_runtime_no_callbacks(struct device
*dev
)
1251 spin_lock_irq(&dev
->power
.lock
);
1252 dev
->power
.no_callbacks
= 1;
1253 spin_unlock_irq(&dev
->power
.lock
);
1254 if (device_is_registered(dev
))
1255 rpm_sysfs_remove(dev
);
1257 EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks
);
1260 * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1261 * @dev: Device to handle
1263 * Set the power.irq_safe flag, which tells the PM core that the
1264 * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1265 * always be invoked with the spinlock held and interrupts disabled. It also
1266 * causes the parent's usage counter to be permanently incremented, preventing
1267 * the parent from runtime suspending -- otherwise an irq-safe child might have
1268 * to wait for a non-irq-safe parent.
1270 void pm_runtime_irq_safe(struct device
*dev
)
1273 pm_runtime_get_sync(dev
->parent
);
1274 spin_lock_irq(&dev
->power
.lock
);
1275 dev
->power
.irq_safe
= 1;
1276 spin_unlock_irq(&dev
->power
.lock
);
1278 EXPORT_SYMBOL_GPL(pm_runtime_irq_safe
);
1281 * update_autosuspend - Handle a change to a device's autosuspend settings.
1282 * @dev: Device to handle.
1283 * @old_delay: The former autosuspend_delay value.
1284 * @old_use: The former use_autosuspend value.
1286 * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1287 * set; otherwise allow it. Send an idle notification if suspends are allowed.
1289 * This function must be called under dev->power.lock with interrupts disabled.
1291 static void update_autosuspend(struct device
*dev
, int old_delay
, int old_use
)
1293 int delay
= dev
->power
.autosuspend_delay
;
1295 /* Should runtime suspend be prevented now? */
1296 if (dev
->power
.use_autosuspend
&& delay
< 0) {
1298 /* If it used to be allowed then prevent it. */
1299 if (!old_use
|| old_delay
>= 0) {
1300 atomic_inc(&dev
->power
.usage_count
);
1305 /* Runtime suspend should be allowed now. */
1308 /* If it used to be prevented then allow it. */
1309 if (old_use
&& old_delay
< 0)
1310 atomic_dec(&dev
->power
.usage_count
);
1312 /* Maybe we can autosuspend now. */
1313 rpm_idle(dev
, RPM_AUTO
);
1318 * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1319 * @dev: Device to handle.
1320 * @delay: Value of the new delay in milliseconds.
1322 * Set the device's power.autosuspend_delay value. If it changes to negative
1323 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1324 * changes the other way, allow runtime suspends.
1326 void pm_runtime_set_autosuspend_delay(struct device
*dev
, int delay
)
1328 int old_delay
, old_use
;
1330 spin_lock_irq(&dev
->power
.lock
);
1331 old_delay
= dev
->power
.autosuspend_delay
;
1332 old_use
= dev
->power
.use_autosuspend
;
1333 dev
->power
.autosuspend_delay
= delay
;
1334 update_autosuspend(dev
, old_delay
, old_use
);
1335 spin_unlock_irq(&dev
->power
.lock
);
1337 EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay
);
1340 * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1341 * @dev: Device to handle.
1342 * @use: New value for use_autosuspend.
1344 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1345 * suspends as needed.
1347 void __pm_runtime_use_autosuspend(struct device
*dev
, bool use
)
1349 int old_delay
, old_use
;
1351 spin_lock_irq(&dev
->power
.lock
);
1352 old_delay
= dev
->power
.autosuspend_delay
;
1353 old_use
= dev
->power
.use_autosuspend
;
1354 dev
->power
.use_autosuspend
= use
;
1355 update_autosuspend(dev
, old_delay
, old_use
);
1356 spin_unlock_irq(&dev
->power
.lock
);
1358 EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend
);
1361 * pm_runtime_init - Initialize runtime PM fields in given device object.
1362 * @dev: Device object to initialize.
1364 void pm_runtime_init(struct device
*dev
)
1366 dev
->power
.runtime_status
= RPM_SUSPENDED
;
1367 dev
->power
.idle_notification
= false;
1369 dev
->power
.disable_depth
= 1;
1370 atomic_set(&dev
->power
.usage_count
, 0);
1372 dev
->power
.runtime_error
= 0;
1374 atomic_set(&dev
->power
.child_count
, 0);
1375 pm_suspend_ignore_children(dev
, false);
1376 dev
->power
.runtime_auto
= true;
1378 dev
->power
.request_pending
= false;
1379 dev
->power
.request
= RPM_REQ_NONE
;
1380 dev
->power
.deferred_resume
= false;
1381 dev
->power
.accounting_timestamp
= jiffies
;
1382 INIT_WORK(&dev
->power
.work
, pm_runtime_work
);
1384 dev
->power
.timer_expires
= 0;
1385 setup_timer(&dev
->power
.suspend_timer
, pm_suspend_timer_fn
,
1386 (unsigned long)dev
);
1388 init_waitqueue_head(&dev
->power
.wait_queue
);
1392 * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1393 * @dev: Device object being removed from device hierarchy.
1395 void pm_runtime_remove(struct device
*dev
)
1397 __pm_runtime_disable(dev
, false);
1399 /* Change the status back to 'suspended' to match the initial status. */
1400 if (dev
->power
.runtime_status
== RPM_ACTIVE
)
1401 pm_runtime_set_suspended(dev
);
1402 if (dev
->power
.irq_safe
&& dev
->parent
)
1403 pm_runtime_put_sync(dev
->parent
);