]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/base/power/runtime.c
2 * drivers/base/power/runtime.c - Helper functions for device run-time PM
4 * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
6 * This file is released under the GPLv2.
9 #include <linux/sched.h>
10 #include <linux/pm_runtime.h>
11 #include <linux/jiffies.h>
13 static int __pm_runtime_resume(struct device
*dev
, bool from_wq
);
14 static int __pm_request_idle(struct device
*dev
);
15 static int __pm_request_resume(struct device
*dev
);
18 * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
19 * @dev: Device to handle.
21 static void pm_runtime_deactivate_timer(struct device
*dev
)
23 if (dev
->power
.timer_expires
> 0) {
24 del_timer(&dev
->power
.suspend_timer
);
25 dev
->power
.timer_expires
= 0;
30 * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
31 * @dev: Device to handle.
33 static void pm_runtime_cancel_pending(struct device
*dev
)
35 pm_runtime_deactivate_timer(dev
);
37 * In case there's a request pending, make sure its work function will
38 * return without doing anything.
40 dev
->power
.request
= RPM_REQ_NONE
;
44 * __pm_runtime_idle - Notify device bus type if the device can be suspended.
45 * @dev: Device to notify the bus type about.
47 * This function must be called under dev->power.lock with interrupts disabled.
49 static int __pm_runtime_idle(struct device
*dev
)
50 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
54 if (dev
->power
.runtime_error
)
56 else if (dev
->power
.idle_notification
)
57 retval
= -EINPROGRESS
;
58 else if (atomic_read(&dev
->power
.usage_count
) > 0
59 || dev
->power
.disable_depth
> 0
60 || dev
->power
.runtime_status
!= RPM_ACTIVE
)
62 else if (!pm_children_suspended(dev
))
67 if (dev
->power
.request_pending
) {
69 * If an idle notification request is pending, cancel it. Any
70 * other pending request takes precedence over us.
72 if (dev
->power
.request
== RPM_REQ_IDLE
) {
73 dev
->power
.request
= RPM_REQ_NONE
;
74 } else if (dev
->power
.request
!= RPM_REQ_NONE
) {
80 dev
->power
.idle_notification
= true;
82 if (dev
->bus
&& dev
->bus
->pm
&& dev
->bus
->pm
->runtime_idle
) {
83 spin_unlock_irq(&dev
->power
.lock
);
85 dev
->bus
->pm
->runtime_idle(dev
);
87 spin_lock_irq(&dev
->power
.lock
);
88 } else if (dev
->type
&& dev
->type
->pm
&& dev
->type
->pm
->runtime_idle
) {
89 spin_unlock_irq(&dev
->power
.lock
);
91 dev
->type
->pm
->runtime_idle(dev
);
93 spin_lock_irq(&dev
->power
.lock
);
94 } else if (dev
->class && dev
->class->pm
95 && dev
->class->pm
->runtime_idle
) {
96 spin_unlock_irq(&dev
->power
.lock
);
98 dev
->class->pm
->runtime_idle(dev
);
100 spin_lock_irq(&dev
->power
.lock
);
103 dev
->power
.idle_notification
= false;
104 wake_up_all(&dev
->power
.wait_queue
);
111 * pm_runtime_idle - Notify device bus type if the device can be suspended.
112 * @dev: Device to notify the bus type about.
114 int pm_runtime_idle(struct device
*dev
)
118 spin_lock_irq(&dev
->power
.lock
);
119 retval
= __pm_runtime_idle(dev
);
120 spin_unlock_irq(&dev
->power
.lock
);
124 EXPORT_SYMBOL_GPL(pm_runtime_idle
);
127 * __pm_runtime_suspend - Carry out run-time suspend of given device.
128 * @dev: Device to suspend.
129 * @from_wq: If set, the function has been called via pm_wq.
131 * Check if the device can be suspended and run the ->runtime_suspend() callback
132 * provided by its bus type. If another suspend has been started earlier, wait
133 * for it to finish. If an idle notification or suspend request is pending or
134 * scheduled, cancel it.
136 * This function must be called under dev->power.lock with interrupts disabled.
138 int __pm_runtime_suspend(struct device
*dev
, bool from_wq
)
139 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
141 struct device
*parent
= NULL
;
145 dev_dbg(dev
, "__pm_runtime_suspend()%s!\n",
146 from_wq
? " from workqueue" : "");
149 if (dev
->power
.runtime_error
) {
154 /* Pending resume requests take precedence over us. */
155 if (dev
->power
.request_pending
156 && dev
->power
.request
== RPM_REQ_RESUME
) {
161 /* Other scheduled or pending requests need to be canceled. */
162 pm_runtime_cancel_pending(dev
);
164 if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
166 else if (dev
->power
.runtime_status
== RPM_RESUMING
167 || dev
->power
.disable_depth
> 0
168 || atomic_read(&dev
->power
.usage_count
) > 0)
170 else if (!pm_children_suspended(dev
))
175 if (dev
->power
.runtime_status
== RPM_SUSPENDING
) {
179 retval
= -EINPROGRESS
;
183 /* Wait for the other suspend running in parallel with us. */
185 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
186 TASK_UNINTERRUPTIBLE
);
187 if (dev
->power
.runtime_status
!= RPM_SUSPENDING
)
190 spin_unlock_irq(&dev
->power
.lock
);
194 spin_lock_irq(&dev
->power
.lock
);
196 finish_wait(&dev
->power
.wait_queue
, &wait
);
200 dev
->power
.runtime_status
= RPM_SUSPENDING
;
201 dev
->power
.deferred_resume
= false;
203 if (dev
->bus
&& dev
->bus
->pm
&& dev
->bus
->pm
->runtime_suspend
) {
204 spin_unlock_irq(&dev
->power
.lock
);
206 retval
= dev
->bus
->pm
->runtime_suspend(dev
);
208 spin_lock_irq(&dev
->power
.lock
);
209 dev
->power
.runtime_error
= retval
;
210 } else if (dev
->type
&& dev
->type
->pm
211 && dev
->type
->pm
->runtime_suspend
) {
212 spin_unlock_irq(&dev
->power
.lock
);
214 retval
= dev
->type
->pm
->runtime_suspend(dev
);
216 spin_lock_irq(&dev
->power
.lock
);
217 dev
->power
.runtime_error
= retval
;
218 } else if (dev
->class && dev
->class->pm
219 && dev
->class->pm
->runtime_suspend
) {
220 spin_unlock_irq(&dev
->power
.lock
);
222 retval
= dev
->class->pm
->runtime_suspend(dev
);
224 spin_lock_irq(&dev
->power
.lock
);
225 dev
->power
.runtime_error
= retval
;
231 dev
->power
.runtime_status
= RPM_ACTIVE
;
232 if (retval
== -EAGAIN
|| retval
== -EBUSY
) {
233 if (dev
->power
.timer_expires
== 0)
235 dev
->power
.runtime_error
= 0;
237 pm_runtime_cancel_pending(dev
);
240 dev
->power
.runtime_status
= RPM_SUSPENDED
;
241 pm_runtime_deactivate_timer(dev
);
244 parent
= dev
->parent
;
245 atomic_add_unless(&parent
->power
.child_count
, -1, 0);
248 wake_up_all(&dev
->power
.wait_queue
);
250 if (dev
->power
.deferred_resume
) {
251 __pm_runtime_resume(dev
, false);
257 __pm_runtime_idle(dev
);
259 if (parent
&& !parent
->power
.ignore_children
) {
260 spin_unlock_irq(&dev
->power
.lock
);
262 pm_request_idle(parent
);
264 spin_lock_irq(&dev
->power
.lock
);
268 dev_dbg(dev
, "__pm_runtime_suspend() returns %d!\n", retval
);
274 * pm_runtime_suspend - Carry out run-time suspend of given device.
275 * @dev: Device to suspend.
277 int pm_runtime_suspend(struct device
*dev
)
281 spin_lock_irq(&dev
->power
.lock
);
282 retval
= __pm_runtime_suspend(dev
, false);
283 spin_unlock_irq(&dev
->power
.lock
);
287 EXPORT_SYMBOL_GPL(pm_runtime_suspend
);
290 * __pm_runtime_resume - Carry out run-time resume of given device.
291 * @dev: Device to resume.
292 * @from_wq: If set, the function has been called via pm_wq.
294 * Check if the device can be woken up and run the ->runtime_resume() callback
295 * provided by its bus type. If another resume has been started earlier, wait
296 * for it to finish. If there's a suspend running in parallel with this
297 * function, wait for it to finish and resume the device. Cancel any scheduled
298 * or pending requests.
300 * This function must be called under dev->power.lock with interrupts disabled.
302 int __pm_runtime_resume(struct device
*dev
, bool from_wq
)
303 __releases(&dev
->power
.lock
) __acquires(&dev
->power
.lock
)
305 struct device
*parent
= NULL
;
308 dev_dbg(dev
, "__pm_runtime_resume()%s!\n",
309 from_wq
? " from workqueue" : "");
312 if (dev
->power
.runtime_error
) {
317 pm_runtime_cancel_pending(dev
);
319 if (dev
->power
.runtime_status
== RPM_ACTIVE
)
321 else if (dev
->power
.disable_depth
> 0)
326 if (dev
->power
.runtime_status
== RPM_RESUMING
327 || dev
->power
.runtime_status
== RPM_SUSPENDING
) {
331 if (dev
->power
.runtime_status
== RPM_SUSPENDING
)
332 dev
->power
.deferred_resume
= true;
333 retval
= -EINPROGRESS
;
337 /* Wait for the operation carried out in parallel with us. */
339 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
340 TASK_UNINTERRUPTIBLE
);
341 if (dev
->power
.runtime_status
!= RPM_RESUMING
342 && dev
->power
.runtime_status
!= RPM_SUSPENDING
)
345 spin_unlock_irq(&dev
->power
.lock
);
349 spin_lock_irq(&dev
->power
.lock
);
351 finish_wait(&dev
->power
.wait_queue
, &wait
);
355 if (!parent
&& dev
->parent
) {
357 * Increment the parent's resume counter and resume it if
360 parent
= dev
->parent
;
361 spin_unlock(&dev
->power
.lock
);
363 pm_runtime_get_noresume(parent
);
365 spin_lock(&parent
->power
.lock
);
367 * We can resume if the parent's run-time PM is disabled or it
368 * is set to ignore children.
370 if (!parent
->power
.disable_depth
371 && !parent
->power
.ignore_children
) {
372 __pm_runtime_resume(parent
, false);
373 if (parent
->power
.runtime_status
!= RPM_ACTIVE
)
376 spin_unlock(&parent
->power
.lock
);
378 spin_lock(&dev
->power
.lock
);
384 dev
->power
.runtime_status
= RPM_RESUMING
;
386 if (dev
->bus
&& dev
->bus
->pm
&& dev
->bus
->pm
->runtime_resume
) {
387 spin_unlock_irq(&dev
->power
.lock
);
389 retval
= dev
->bus
->pm
->runtime_resume(dev
);
391 spin_lock_irq(&dev
->power
.lock
);
392 dev
->power
.runtime_error
= retval
;
393 } else if (dev
->type
&& dev
->type
->pm
394 && dev
->type
->pm
->runtime_resume
) {
395 spin_unlock_irq(&dev
->power
.lock
);
397 retval
= dev
->type
->pm
->runtime_resume(dev
);
399 spin_lock_irq(&dev
->power
.lock
);
400 dev
->power
.runtime_error
= retval
;
401 } else if (dev
->class && dev
->class->pm
402 && dev
->class->pm
->runtime_resume
) {
403 spin_unlock_irq(&dev
->power
.lock
);
405 retval
= dev
->class->pm
->runtime_resume(dev
);
407 spin_lock_irq(&dev
->power
.lock
);
408 dev
->power
.runtime_error
= retval
;
414 dev
->power
.runtime_status
= RPM_SUSPENDED
;
415 pm_runtime_cancel_pending(dev
);
417 dev
->power
.runtime_status
= RPM_ACTIVE
;
419 atomic_inc(&parent
->power
.child_count
);
421 wake_up_all(&dev
->power
.wait_queue
);
424 __pm_request_idle(dev
);
428 spin_unlock_irq(&dev
->power
.lock
);
430 pm_runtime_put(parent
);
432 spin_lock_irq(&dev
->power
.lock
);
435 dev_dbg(dev
, "__pm_runtime_resume() returns %d!\n", retval
);
441 * pm_runtime_resume - Carry out run-time resume of given device.
442 * @dev: Device to suspend.
444 int pm_runtime_resume(struct device
*dev
)
448 spin_lock_irq(&dev
->power
.lock
);
449 retval
= __pm_runtime_resume(dev
, false);
450 spin_unlock_irq(&dev
->power
.lock
);
454 EXPORT_SYMBOL_GPL(pm_runtime_resume
);
457 * pm_runtime_work - Universal run-time PM work function.
458 * @work: Work structure used for scheduling the execution of this function.
460 * Use @work to get the device object the work is to be done for, determine what
461 * is to be done and execute the appropriate run-time PM function.
463 static void pm_runtime_work(struct work_struct
*work
)
465 struct device
*dev
= container_of(work
, struct device
, power
.work
);
466 enum rpm_request req
;
468 spin_lock_irq(&dev
->power
.lock
);
470 if (!dev
->power
.request_pending
)
473 req
= dev
->power
.request
;
474 dev
->power
.request
= RPM_REQ_NONE
;
475 dev
->power
.request_pending
= false;
481 __pm_runtime_idle(dev
);
483 case RPM_REQ_SUSPEND
:
484 __pm_runtime_suspend(dev
, true);
487 __pm_runtime_resume(dev
, true);
492 spin_unlock_irq(&dev
->power
.lock
);
496 * __pm_request_idle - Submit an idle notification request for given device.
497 * @dev: Device to handle.
499 * Check if the device's run-time PM status is correct for suspending the device
500 * and queue up a request to run __pm_runtime_idle() for it.
502 * This function must be called under dev->power.lock with interrupts disabled.
504 static int __pm_request_idle(struct device
*dev
)
508 if (dev
->power
.runtime_error
)
510 else if (atomic_read(&dev
->power
.usage_count
) > 0
511 || dev
->power
.disable_depth
> 0
512 || dev
->power
.runtime_status
== RPM_SUSPENDED
513 || dev
->power
.runtime_status
== RPM_SUSPENDING
)
515 else if (!pm_children_suspended(dev
))
520 if (dev
->power
.request_pending
) {
521 /* Any requests other then RPM_REQ_IDLE take precedence. */
522 if (dev
->power
.request
== RPM_REQ_NONE
)
523 dev
->power
.request
= RPM_REQ_IDLE
;
524 else if (dev
->power
.request
!= RPM_REQ_IDLE
)
529 dev
->power
.request
= RPM_REQ_IDLE
;
530 dev
->power
.request_pending
= true;
531 queue_work(pm_wq
, &dev
->power
.work
);
537 * pm_request_idle - Submit an idle notification request for given device.
538 * @dev: Device to handle.
540 int pm_request_idle(struct device
*dev
)
545 spin_lock_irqsave(&dev
->power
.lock
, flags
);
546 retval
= __pm_request_idle(dev
);
547 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
551 EXPORT_SYMBOL_GPL(pm_request_idle
);
554 * __pm_request_suspend - Submit a suspend request for given device.
555 * @dev: Device to suspend.
557 * This function must be called under dev->power.lock with interrupts disabled.
559 static int __pm_request_suspend(struct device
*dev
)
563 if (dev
->power
.runtime_error
)
566 if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
568 else if (atomic_read(&dev
->power
.usage_count
) > 0
569 || dev
->power
.disable_depth
> 0)
571 else if (dev
->power
.runtime_status
== RPM_SUSPENDING
)
572 retval
= -EINPROGRESS
;
573 else if (!pm_children_suspended(dev
))
578 pm_runtime_deactivate_timer(dev
);
580 if (dev
->power
.request_pending
) {
582 * Pending resume requests take precedence over us, but we can
583 * overtake any other pending request.
585 if (dev
->power
.request
== RPM_REQ_RESUME
)
587 else if (dev
->power
.request
!= RPM_REQ_SUSPEND
)
588 dev
->power
.request
= retval
?
589 RPM_REQ_NONE
: RPM_REQ_SUSPEND
;
595 dev
->power
.request
= RPM_REQ_SUSPEND
;
596 dev
->power
.request_pending
= true;
597 queue_work(pm_wq
, &dev
->power
.work
);
603 * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
604 * @data: Device pointer passed by pm_schedule_suspend().
606 * Check if the time is right and execute __pm_request_suspend() in that case.
608 static void pm_suspend_timer_fn(unsigned long data
)
610 struct device
*dev
= (struct device
*)data
;
612 unsigned long expires
;
614 spin_lock_irqsave(&dev
->power
.lock
, flags
);
616 expires
= dev
->power
.timer_expires
;
617 /* If 'expire' is after 'jiffies' we've been called too early. */
618 if (expires
> 0 && !time_after(expires
, jiffies
)) {
619 dev
->power
.timer_expires
= 0;
620 __pm_request_suspend(dev
);
623 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
627 * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
628 * @dev: Device to suspend.
629 * @delay: Time to wait before submitting a suspend request, in milliseconds.
631 int pm_schedule_suspend(struct device
*dev
, unsigned int delay
)
636 spin_lock_irqsave(&dev
->power
.lock
, flags
);
638 if (dev
->power
.runtime_error
) {
644 retval
= __pm_request_suspend(dev
);
648 pm_runtime_deactivate_timer(dev
);
650 if (dev
->power
.request_pending
) {
652 * Pending resume requests take precedence over us, but any
653 * other pending requests have to be canceled.
655 if (dev
->power
.request
== RPM_REQ_RESUME
) {
659 dev
->power
.request
= RPM_REQ_NONE
;
662 if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
664 else if (atomic_read(&dev
->power
.usage_count
) > 0
665 || dev
->power
.disable_depth
> 0)
667 else if (!pm_children_suspended(dev
))
672 dev
->power
.timer_expires
= jiffies
+ msecs_to_jiffies(delay
);
673 if (!dev
->power
.timer_expires
)
674 dev
->power
.timer_expires
= 1;
675 mod_timer(&dev
->power
.suspend_timer
, dev
->power
.timer_expires
);
678 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
682 EXPORT_SYMBOL_GPL(pm_schedule_suspend
);
685 * pm_request_resume - Submit a resume request for given device.
686 * @dev: Device to resume.
688 * This function must be called under dev->power.lock with interrupts disabled.
690 static int __pm_request_resume(struct device
*dev
)
694 if (dev
->power
.runtime_error
)
697 if (dev
->power
.runtime_status
== RPM_ACTIVE
)
699 else if (dev
->power
.runtime_status
== RPM_RESUMING
)
700 retval
= -EINPROGRESS
;
701 else if (dev
->power
.disable_depth
> 0)
706 pm_runtime_deactivate_timer(dev
);
708 if (dev
->power
.runtime_status
== RPM_SUSPENDING
) {
709 dev
->power
.deferred_resume
= true;
712 if (dev
->power
.request_pending
) {
713 /* If non-resume request is pending, we can overtake it. */
714 dev
->power
.request
= retval
? RPM_REQ_NONE
: RPM_REQ_RESUME
;
720 dev
->power
.request
= RPM_REQ_RESUME
;
721 dev
->power
.request_pending
= true;
722 queue_work(pm_wq
, &dev
->power
.work
);
728 * pm_request_resume - Submit a resume request for given device.
729 * @dev: Device to resume.
731 int pm_request_resume(struct device
*dev
)
736 spin_lock_irqsave(&dev
->power
.lock
, flags
);
737 retval
= __pm_request_resume(dev
);
738 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
742 EXPORT_SYMBOL_GPL(pm_request_resume
);
745 * __pm_runtime_get - Reference count a device and wake it up, if necessary.
746 * @dev: Device to handle.
747 * @sync: If set and the device is suspended, resume it synchronously.
749 * Increment the usage count of the device and resume it or submit a resume
750 * request for it, depending on the value of @sync.
752 int __pm_runtime_get(struct device
*dev
, bool sync
)
756 atomic_inc(&dev
->power
.usage_count
);
757 retval
= sync
? pm_runtime_resume(dev
) : pm_request_resume(dev
);
761 EXPORT_SYMBOL_GPL(__pm_runtime_get
);
764 * __pm_runtime_put - Decrement the device's usage counter and notify its bus.
765 * @dev: Device to handle.
766 * @sync: If the device's bus type is to be notified, do that synchronously.
768 * Decrement the usage count of the device and if it reaches zero, carry out a
769 * synchronous idle notification or submit an idle notification request for it,
770 * depending on the value of @sync.
772 int __pm_runtime_put(struct device
*dev
, bool sync
)
776 if (atomic_dec_and_test(&dev
->power
.usage_count
))
777 retval
= sync
? pm_runtime_idle(dev
) : pm_request_idle(dev
);
781 EXPORT_SYMBOL_GPL(__pm_runtime_put
);
784 * __pm_runtime_set_status - Set run-time PM status of a device.
785 * @dev: Device to handle.
786 * @status: New run-time PM status of the device.
788 * If run-time PM of the device is disabled or its power.runtime_error field is
789 * different from zero, the status may be changed either to RPM_ACTIVE, or to
790 * RPM_SUSPENDED, as long as that reflects the actual state of the device.
791 * However, if the device has a parent and the parent is not active, and the
792 * parent's power.ignore_children flag is unset, the device's status cannot be
793 * set to RPM_ACTIVE, so -EBUSY is returned in that case.
795 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
796 * and the device parent's counter of unsuspended children is modified to
797 * reflect the new status. If the new status is RPM_SUSPENDED, an idle
798 * notification request for the parent is submitted.
800 int __pm_runtime_set_status(struct device
*dev
, unsigned int status
)
802 struct device
*parent
= dev
->parent
;
804 bool notify_parent
= false;
807 if (status
!= RPM_ACTIVE
&& status
!= RPM_SUSPENDED
)
810 spin_lock_irqsave(&dev
->power
.lock
, flags
);
812 if (!dev
->power
.runtime_error
&& !dev
->power
.disable_depth
) {
817 if (dev
->power
.runtime_status
== status
)
820 if (status
== RPM_SUSPENDED
) {
821 /* It always is possible to set the status to 'suspended'. */
823 atomic_add_unless(&parent
->power
.child_count
, -1, 0);
824 notify_parent
= !parent
->power
.ignore_children
;
830 spin_lock_nested(&parent
->power
.lock
, SINGLE_DEPTH_NESTING
);
833 * It is invalid to put an active child under a parent that is
834 * not active, has run-time PM enabled and the
835 * 'power.ignore_children' flag unset.
837 if (!parent
->power
.disable_depth
838 && !parent
->power
.ignore_children
839 && parent
->power
.runtime_status
!= RPM_ACTIVE
)
841 else if (dev
->power
.runtime_status
== RPM_SUSPENDED
)
842 atomic_inc(&parent
->power
.child_count
);
844 spin_unlock(&parent
->power
.lock
);
851 dev
->power
.runtime_status
= status
;
852 dev
->power
.runtime_error
= 0;
854 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
857 pm_request_idle(parent
);
861 EXPORT_SYMBOL_GPL(__pm_runtime_set_status
);
864 * __pm_runtime_barrier - Cancel pending requests and wait for completions.
865 * @dev: Device to handle.
867 * Flush all pending requests for the device from pm_wq and wait for all
868 * run-time PM operations involving the device in progress to complete.
870 * Should be called under dev->power.lock with interrupts disabled.
872 static void __pm_runtime_barrier(struct device
*dev
)
874 pm_runtime_deactivate_timer(dev
);
876 if (dev
->power
.request_pending
) {
877 dev
->power
.request
= RPM_REQ_NONE
;
878 spin_unlock_irq(&dev
->power
.lock
);
880 cancel_work_sync(&dev
->power
.work
);
882 spin_lock_irq(&dev
->power
.lock
);
883 dev
->power
.request_pending
= false;
886 if (dev
->power
.runtime_status
== RPM_SUSPENDING
887 || dev
->power
.runtime_status
== RPM_RESUMING
888 || dev
->power
.idle_notification
) {
891 /* Suspend, wake-up or idle notification in progress. */
893 prepare_to_wait(&dev
->power
.wait_queue
, &wait
,
894 TASK_UNINTERRUPTIBLE
);
895 if (dev
->power
.runtime_status
!= RPM_SUSPENDING
896 && dev
->power
.runtime_status
!= RPM_RESUMING
897 && !dev
->power
.idle_notification
)
899 spin_unlock_irq(&dev
->power
.lock
);
903 spin_lock_irq(&dev
->power
.lock
);
905 finish_wait(&dev
->power
.wait_queue
, &wait
);
910 * pm_runtime_barrier - Flush pending requests and wait for completions.
911 * @dev: Device to handle.
913 * Prevent the device from being suspended by incrementing its usage counter and
914 * if there's a pending resume request for the device, wake the device up.
915 * Next, make sure that all pending requests for the device have been flushed
916 * from pm_wq and wait for all run-time PM operations involving the device in
917 * progress to complete.
920 * 1, if there was a resume request pending and the device had to be woken up,
923 int pm_runtime_barrier(struct device
*dev
)
927 pm_runtime_get_noresume(dev
);
928 spin_lock_irq(&dev
->power
.lock
);
930 if (dev
->power
.request_pending
931 && dev
->power
.request
== RPM_REQ_RESUME
) {
932 __pm_runtime_resume(dev
, false);
936 __pm_runtime_barrier(dev
);
938 spin_unlock_irq(&dev
->power
.lock
);
939 pm_runtime_put_noidle(dev
);
943 EXPORT_SYMBOL_GPL(pm_runtime_barrier
);
946 * __pm_runtime_disable - Disable run-time PM of a device.
947 * @dev: Device to handle.
948 * @check_resume: If set, check if there's a resume request for the device.
950 * Increment power.disable_depth for the device and if was zero previously,
951 * cancel all pending run-time PM requests for the device and wait for all
952 * operations in progress to complete. The device can be either active or
953 * suspended after its run-time PM has been disabled.
955 * If @check_resume is set and there's a resume request pending when
956 * __pm_runtime_disable() is called and power.disable_depth is zero, the
957 * function will wake up the device before disabling its run-time PM.
959 void __pm_runtime_disable(struct device
*dev
, bool check_resume
)
961 spin_lock_irq(&dev
->power
.lock
);
963 if (dev
->power
.disable_depth
> 0) {
964 dev
->power
.disable_depth
++;
969 * Wake up the device if there's a resume request pending, because that
970 * means there probably is some I/O to process and disabling run-time PM
971 * shouldn't prevent the device from processing the I/O.
973 if (check_resume
&& dev
->power
.request_pending
974 && dev
->power
.request
== RPM_REQ_RESUME
) {
976 * Prevent suspends and idle notifications from being carried
977 * out after we have woken up the device.
979 pm_runtime_get_noresume(dev
);
981 __pm_runtime_resume(dev
, false);
983 pm_runtime_put_noidle(dev
);
986 if (!dev
->power
.disable_depth
++)
987 __pm_runtime_barrier(dev
);
990 spin_unlock_irq(&dev
->power
.lock
);
992 EXPORT_SYMBOL_GPL(__pm_runtime_disable
);
995 * pm_runtime_enable - Enable run-time PM of a device.
996 * @dev: Device to handle.
998 void pm_runtime_enable(struct device
*dev
)
1000 unsigned long flags
;
1002 spin_lock_irqsave(&dev
->power
.lock
, flags
);
1004 if (dev
->power
.disable_depth
> 0)
1005 dev
->power
.disable_depth
--;
1007 dev_warn(dev
, "Unbalanced %s!\n", __func__
);
1009 spin_unlock_irqrestore(&dev
->power
.lock
, flags
);
1011 EXPORT_SYMBOL_GPL(pm_runtime_enable
);
1014 * pm_runtime_forbid - Block run-time PM of a device.
1015 * @dev: Device to handle.
1017 * Increase the device's usage count and clear its power.runtime_auto flag,
1018 * so that it cannot be suspended at run time until pm_runtime_allow() is called
1021 void pm_runtime_forbid(struct device
*dev
)
1023 spin_lock_irq(&dev
->power
.lock
);
1024 if (!dev
->power
.runtime_auto
)
1027 dev
->power
.runtime_auto
= false;
1028 atomic_inc(&dev
->power
.usage_count
);
1029 __pm_runtime_resume(dev
, false);
1032 spin_unlock_irq(&dev
->power
.lock
);
1034 EXPORT_SYMBOL_GPL(pm_runtime_forbid
);
1037 * pm_runtime_allow - Unblock run-time PM of a device.
1038 * @dev: Device to handle.
1040 * Decrease the device's usage count and set its power.runtime_auto flag.
1042 void pm_runtime_allow(struct device
*dev
)
1044 spin_lock_irq(&dev
->power
.lock
);
1045 if (dev
->power
.runtime_auto
)
1048 dev
->power
.runtime_auto
= true;
1049 if (atomic_dec_and_test(&dev
->power
.usage_count
))
1050 __pm_runtime_idle(dev
);
1053 spin_unlock_irq(&dev
->power
.lock
);
1055 EXPORT_SYMBOL_GPL(pm_runtime_allow
);
1058 * pm_runtime_init - Initialize run-time PM fields in given device object.
1059 * @dev: Device object to initialize.
1061 void pm_runtime_init(struct device
*dev
)
1063 spin_lock_init(&dev
->power
.lock
);
1065 dev
->power
.runtime_status
= RPM_SUSPENDED
;
1066 dev
->power
.idle_notification
= false;
1068 dev
->power
.disable_depth
= 1;
1069 atomic_set(&dev
->power
.usage_count
, 0);
1071 dev
->power
.runtime_error
= 0;
1073 atomic_set(&dev
->power
.child_count
, 0);
1074 pm_suspend_ignore_children(dev
, false);
1075 dev
->power
.runtime_auto
= true;
1077 dev
->power
.request_pending
= false;
1078 dev
->power
.request
= RPM_REQ_NONE
;
1079 dev
->power
.deferred_resume
= false;
1080 INIT_WORK(&dev
->power
.work
, pm_runtime_work
);
1082 dev
->power
.timer_expires
= 0;
1083 setup_timer(&dev
->power
.suspend_timer
, pm_suspend_timer_fn
,
1084 (unsigned long)dev
);
1086 init_waitqueue_head(&dev
->power
.wait_queue
);
1090 * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1091 * @dev: Device object being removed from device hierarchy.
1093 void pm_runtime_remove(struct device
*dev
)
1095 __pm_runtime_disable(dev
, false);
1097 /* Change the status back to 'suspended' to match the initial status. */
1098 if (dev
->power
.runtime_status
== RPM_ACTIVE
)
1099 pm_runtime_set_suspended(dev
);