Lines Matching full:power
3 * drivers/base/power/runtime.c - Helper functions for device runtime PM
18 #include "power.h"
56 * update_pm_runtime_accounting - Update the time accounting of power states
59 * In order to be able to have time accounting of the various power states
70 if (dev->power.disable_depth > 0)
73 last = dev->power.accounting_timestamp;
76 dev->power.accounting_timestamp = now;
88 if (dev->power.runtime_status == RPM_SUSPENDED)
89 dev->power.suspended_time += delta;
91 dev->power.active_time += delta;
98 dev->power.runtime_status = status;
106 spin_lock_irqsave(&dev->power.lock, flags);
109 time = suspended ? dev->power.suspended_time : dev->power.active_time;
111 spin_unlock_irqrestore(&dev->power.lock, flags);
133 if (dev->power.timer_expires > 0) {
134 hrtimer_try_to_cancel(&dev->power.suspend_timer);
135 dev->power.timer_expires = 0;
150 dev->power.request = RPM_REQ_NONE;
158 * power.last_busy time. If the delay has already expired or is disabled
159 * (negative) or the power.use_autosuspend flag isn't set, return 0.
162 * This function may be called either with or without dev->power.lock held.
163 * Either way it can be racy, since power.last_busy may be updated at any time.
170 if (!dev->power.use_autosuspend)
173 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);
177 expires = READ_ONCE(dev->power.last_busy);
188 return dev->power.memalloc_noio;
227 /* hold power lock since bitfield is not SMP-safe. */
228 spin_lock_irq(&dev->power.lock);
229 enabled = dev->power.memalloc_noio;
230 dev->power.memalloc_noio = enable;
231 spin_unlock_irq(&dev->power.lock);
263 if (dev->power.runtime_error)
265 else if (dev->power.disable_depth > 0)
267 else if (atomic_read(&dev->power.usage_count))
269 else if (!dev->power.ignore_children && atomic_read(&dev->power.child_count))
273 else if ((dev->power.deferred_resume &&
274 dev->power.runtime_status == RPM_SUSPENDING) ||
275 (dev->power.request_pending && dev->power.request == RPM_REQ_RESUME))
279 else if (dev->power.runtime_status == RPM_SUSPENDED)
318 * The additional power.usage_count check is a safety net in case
324 atomic_read(&supplier->power.usage_count) > 0)
363 __releases(&dev->power.lock) __acquires(&dev->power.lock)
366 bool use_links = dev->power.links_count > 0;
368 if (dev->power.irq_safe) {
369 spin_unlock(&dev->power.lock);
371 spin_unlock_irq(&dev->power.lock);
380 if (use_links && dev->power.runtime_status == RPM_RESUMING) {
396 if (dev->power.irq_safe) {
397 spin_lock(&dev->power.lock);
407 ((dev->power.runtime_status == RPM_SUSPENDING && !retval) ||
408 (dev->power.runtime_status == RPM_RESUMING && retval))) {
417 spin_lock_irq(&dev->power.lock);
432 if (dev->power.memalloc_noio) {
461 dev->power.runtime_error = retval;
477 * This function must be called under dev->power.lock with interrupts disabled.
490 else if (dev->power.runtime_status != RPM_ACTIVE)
497 else if (dev->power.request_pending &&
498 dev->power.request > RPM_REQ_IDLE)
502 else if (dev->power.idle_notification)
509 dev->power.request = RPM_REQ_NONE;
514 if (!callback || dev->power.no_callbacks)
519 dev->power.request = RPM_REQ_IDLE;
520 if (!dev->power.request_pending) {
521 dev->power.request_pending = true;
522 queue_work(pm_wq, &dev->power.work);
528 dev->power.idle_notification = true;
530 if (dev->power.irq_safe)
531 spin_unlock(&dev->power.lock);
533 spin_unlock_irq(&dev->power.lock);
537 if (dev->power.irq_safe)
538 spin_lock(&dev->power.lock);
540 spin_lock_irq(&dev->power.lock);
542 dev->power.idle_notification = false;
543 wake_up_all(&dev->power.wait_queue);
564 * ignore_children of parent->power and irq_safe of dev->power are not set).
569 * This function must be called under dev->power.lock with interrupts disabled.
572 __releases(&dev->power.lock) __acquires(&dev->power.lock)
586 if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC))
593 if ((rpmflags & RPM_AUTO) && dev->power.runtime_status != RPM_SUSPENDING) {
598 dev->power.request = RPM_REQ_NONE;
607 if (!(dev->power.timer_expires &&
608 dev->power.timer_expires <= expires)) {
613 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *
616 dev->power.timer_expires = expires;
617 hrtimer_start_range_ns(&dev->power.suspend_timer,
622 dev->power.timer_autosuspends = 1;
630 if (dev->power.runtime_status == RPM_SUSPENDING) {
638 if (dev->power.irq_safe) {
639 spin_unlock(&dev->power.lock);
643 spin_lock(&dev->power.lock);
649 prepare_to_wait(&dev->power.wait_queue, &wait,
651 if (dev->power.runtime_status != RPM_SUSPENDING)
654 spin_unlock_irq(&dev->power.lock);
658 spin_lock_irq(&dev->power.lock);
660 finish_wait(&dev->power.wait_queue, &wait);
664 if (dev->power.no_callbacks)
669 dev->power.request = (rpmflags & RPM_AUTO) ?
671 if (!dev->power.request_pending) {
672 dev->power.request_pending = true;
673 queue_work(pm_wq, &dev->power.work);
695 atomic_add_unless(&parent->power.child_count, -1, 0);
697 wake_up_all(&dev->power.wait_queue);
699 if (dev->power.deferred_resume) {
700 dev->power.deferred_resume = false;
706 if (dev->power.irq_safe)
710 if (parent && !parent->power.ignore_children) {
711 spin_unlock(&dev->power.lock);
713 spin_lock(&parent->power.lock);
715 spin_unlock(&parent->power.lock);
717 spin_lock(&dev->power.lock);
720 if (dev->power.links_count > 0) {
721 spin_unlock_irq(&dev->power.lock);
725 spin_lock_irq(&dev->power.lock);
736 dev->power.deferred_resume = false;
737 wake_up_all(&dev->power.wait_queue);
745 if (!dev->power.runtime_error && (rpmflags & RPM_AUTO) &&
769 * This function must be called under dev->power.lock with interrupts disabled.
772 __releases(&dev->power.lock) __acquires(&dev->power.lock)
781 if (dev->power.runtime_error) {
783 } else if (dev->power.disable_depth > 0) {
784 if (dev->power.runtime_status == RPM_ACTIVE &&
785 dev->power.last_status == RPM_ACTIVE)
799 dev->power.request = RPM_REQ_NONE;
800 if (!dev->power.timer_autosuspends)
803 if (dev->power.runtime_status == RPM_ACTIVE) {
808 if (dev->power.runtime_status == RPM_RESUMING ||
809 dev->power.runtime_status == RPM_SUSPENDING) {
813 if (dev->power.runtime_status == RPM_SUSPENDING) {
814 dev->power.deferred_resume = true;
823 if (dev->power.irq_safe) {
824 spin_unlock(&dev->power.lock);
828 spin_lock(&dev->power.lock);
834 prepare_to_wait(&dev->power.wait_queue, &wait,
836 if (dev->power.runtime_status != RPM_RESUMING &&
837 dev->power.runtime_status != RPM_SUSPENDING)
840 spin_unlock_irq(&dev->power.lock);
844 spin_lock_irq(&dev->power.lock);
846 finish_wait(&dev->power.wait_queue, &wait);
852 * power.no_callbacks is set, because otherwise we don't know whether
855 if (dev->power.no_callbacks && !parent && dev->parent) {
856 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
857 if (dev->parent->power.disable_depth > 0 ||
858 dev->parent->power.ignore_children ||
859 dev->parent->power.runtime_status == RPM_ACTIVE) {
860 atomic_inc(&dev->parent->power.child_count);
861 spin_unlock(&dev->parent->power.lock);
865 spin_unlock(&dev->parent->power.lock);
870 dev->power.request = RPM_REQ_RESUME;
871 if (!dev->power.request_pending) {
872 dev->power.request_pending = true;
873 queue_work(pm_wq, &dev->power.work);
886 if (dev->power.irq_safe)
889 spin_unlock(&dev->power.lock);
893 spin_lock(&parent->power.lock);
898 if (!parent->power.disable_depth &&
899 !parent->power.ignore_children) {
901 if (parent->power.runtime_status != RPM_ACTIVE)
904 spin_unlock(&parent->power.lock);
906 spin_lock(&dev->power.lock);
914 if (dev->power.no_callbacks)
932 atomic_inc(&parent->power.child_count);
934 wake_up_all(&dev->power.wait_queue);
940 if (parent && !dev->power.irq_safe) {
941 spin_unlock_irq(&dev->power.lock);
945 spin_lock_irq(&dev->power.lock);
962 struct device *dev = container_of(work, struct device, power.work);
965 spin_lock_irq(&dev->power.lock);
967 if (!dev->power.request_pending)
970 req = dev->power.request;
971 dev->power.request = RPM_REQ_NONE;
972 dev->power.request_pending = false;
992 spin_unlock_irq(&dev->power.lock);
1003 struct device *dev = container_of(timer, struct device, power.suspend_timer);
1007 spin_lock_irqsave(&dev->power.lock, flags);
1009 expires = dev->power.timer_expires;
1015 dev->power.timer_expires = 0;
1016 rpm_suspend(dev, dev->power.timer_autosuspends ?
1020 spin_unlock_irqrestore(&dev->power.lock, flags);
1036 spin_lock_irqsave(&dev->power.lock, flags);
1051 dev->power.timer_expires = expires;
1052 dev->power.timer_autosuspends = 0;
1053 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS);
1056 spin_unlock_irqrestore(&dev->power.lock, flags);
1066 ret = atomic_sub_return(1, &dev->power.usage_count);
1076 atomic_inc(&dev->power.usage_count);
1109 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
1111 spin_lock_irqsave(&dev->power.lock, flags);
1113 spin_unlock_irqrestore(&dev->power.lock, flags);
1147 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
1149 spin_lock_irqsave(&dev->power.lock, flags);
1151 spin_unlock_irqrestore(&dev->power.lock, flags);
1173 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe &&
1174 dev->power.runtime_status != RPM_ACTIVE);
1177 atomic_inc(&dev->power.usage_count);
1179 spin_lock_irqsave(&dev->power.lock, flags);
1181 spin_unlock_irqrestore(&dev->power.lock, flags);
1214 spin_lock_irqsave(&dev->power.lock, flags);
1215 if (dev->power.disable_depth > 0) {
1217 } else if (dev->power.runtime_status != RPM_ACTIVE) {
1221 atomic_inc(&dev->power.usage_count);
1223 retval = atomic_inc_not_zero(&dev->power.usage_count);
1226 spin_unlock_irqrestore(&dev->power.lock, flags);
1268 * If runtime PM of the device is disabled or its power.runtime_error field is
1272 * parent's power.ignore_children flag is unset, the device's status cannot be
1275 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1297 spin_lock_irqsave(&dev->power.lock, flags);
1303 if (dev->power.runtime_error || dev->power.disable_depth)
1304 dev->power.disable_depth++;
1308 spin_unlock_irqrestore(&dev->power.lock, flags);
1329 spin_lock_irqsave(&dev->power.lock, flags);
1331 if (dev->power.runtime_status == status || !parent)
1335 atomic_add_unless(&parent->power.child_count, -1, 0);
1336 notify_parent = !parent->power.ignore_children;
1338 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
1343 * 'power.ignore_children' flag unset.
1345 if (!parent->power.disable_depth &&
1346 !parent->power.ignore_children &&
1347 parent->power.runtime_status != RPM_ACTIVE) {
1352 } else if (dev->power.runtime_status == RPM_SUSPENDED) {
1353 atomic_inc(&parent->power.child_count);
1356 spin_unlock(&parent->power.lock);
1367 dev->power.runtime_error = 0;
1370 spin_unlock_irqrestore(&dev->power.lock, flags);
1396 * Should be called under dev->power.lock with interrupts disabled.
1402 if (dev->power.request_pending) {
1403 dev->power.request = RPM_REQ_NONE;
1404 spin_unlock_irq(&dev->power.lock);
1406 cancel_work_sync(&dev->power.work);
1408 spin_lock_irq(&dev->power.lock);
1409 dev->power.request_pending = false;
1412 if (dev->power.runtime_status == RPM_SUSPENDING ||
1413 dev->power.runtime_status == RPM_RESUMING ||
1414 dev->power.idle_notification) {
1419 prepare_to_wait(&dev->power.wait_queue, &wait,
1421 if (dev->power.runtime_status != RPM_SUSPENDING
1422 && dev->power.runtime_status != RPM_RESUMING
1423 && !dev->power.idle_notification)
1425 spin_unlock_irq(&dev->power.lock);
1429 spin_lock_irq(&dev->power.lock);
1431 finish_wait(&dev->power.wait_queue, &wait);
1454 spin_lock_irq(&dev->power.lock);
1456 if (dev->power.request_pending
1457 && dev->power.request == RPM_REQ_RESUME) {
1464 spin_unlock_irq(&dev->power.lock);
1475 spin_lock_irq(&dev->power.lock);
1478 if (ret && dev->power.last_status == RPM_INVALID)
1479 dev->power.last_status = RPM_BLOCKED;
1481 spin_unlock_irq(&dev->power.lock);
1488 spin_lock_irq(&dev->power.lock);
1490 if (dev->power.last_status == RPM_BLOCKED)
1491 dev->power.last_status = RPM_INVALID;
1493 spin_unlock_irq(&dev->power.lock);
1498 spin_lock_irq(&dev->power.lock);
1500 if (dev->power.disable_depth > 0) {
1501 dev->power.disable_depth++;
1510 if (check_resume && dev->power.request_pending &&
1511 dev->power.request == RPM_REQ_RESUME) {
1526 if (!dev->power.disable_depth++) {
1528 dev->power.last_status = dev->power.runtime_status;
1532 spin_unlock_irq(&dev->power.lock);
1544 spin_lock_irqsave(&dev->power.lock, flags);
1546 if (!dev->power.disable_depth) {
1551 if (--dev->power.disable_depth > 0)
1554 if (dev->power.last_status == RPM_BLOCKED) {
1558 dev->power.last_status = RPM_INVALID;
1559 dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
1561 if (dev->power.runtime_status == RPM_SUSPENDED &&
1562 !dev->power.ignore_children &&
1563 atomic_read(&dev->power.child_count) > 0)
1567 spin_unlock_irqrestore(&dev->power.lock, flags);
1597 * Increase the device's usage count and clear its power.runtime_auto flag,
1603 spin_lock_irq(&dev->power.lock);
1604 if (!dev->power.runtime_auto)
1607 dev->power.runtime_auto = false;
1608 atomic_inc(&dev->power.usage_count);
1612 spin_unlock_irq(&dev->power.lock);
1620 * Decrease the device's usage count and set its power.runtime_auto flag.
1626 spin_lock_irq(&dev->power.lock);
1627 if (dev->power.runtime_auto)
1630 dev->power.runtime_auto = true;
1638 spin_unlock_irq(&dev->power.lock);
1646 * Set the power.no_callbacks flag, which tells the PM core that this
1647 * device is power-managed through its parent and has no runtime PM
1652 spin_lock_irq(&dev->power.lock);
1653 dev->power.no_callbacks = 1;
1654 spin_unlock_irq(&dev->power.lock);
1664 * Set the power.irq_safe flag, which tells the PM core that the
1676 spin_lock_irq(&dev->power.lock);
1677 dev->power.irq_safe = 1;
1678 spin_unlock_irq(&dev->power.lock);
1691 * This function must be called under dev->power.lock with interrupts disabled.
1695 int delay = dev->power.autosuspend_delay;
1698 if (dev->power.use_autosuspend && delay < 0) {
1702 atomic_inc(&dev->power.usage_count);
1714 atomic_dec(&dev->power.usage_count);
1726 * Set the device's power.autosuspend_delay value. If it changes to negative
1727 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1734 spin_lock_irq(&dev->power.lock);
1735 old_delay = dev->power.autosuspend_delay;
1736 old_use = dev->power.use_autosuspend;
1737 dev->power.autosuspend_delay = delay;
1739 spin_unlock_irq(&dev->power.lock);
1748 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1755 spin_lock_irq(&dev->power.lock);
1756 old_delay = dev->power.autosuspend_delay;
1757 old_use = dev->power.use_autosuspend;
1758 dev->power.use_autosuspend = use;
1760 spin_unlock_irq(&dev->power.lock);
1770 dev->power.runtime_status = RPM_SUSPENDED;
1771 dev->power.last_status = RPM_INVALID;
1772 dev->power.idle_notification = false;
1774 dev->power.disable_depth = 1;
1775 atomic_set(&dev->power.usage_count, 0);
1777 dev->power.runtime_error = 0;
1779 atomic_set(&dev->power.child_count, 0);
1781 dev->power.runtime_auto = true;
1783 dev->power.request_pending = false;
1784 dev->power.request = RPM_REQ_NONE;
1785 dev->power.deferred_resume = false;
1786 dev->power.needs_force_resume = 0;
1787 INIT_WORK(&dev->power.work, pm_runtime_work);
1789 dev->power.timer_expires = 0;
1790 hrtimer_setup(&dev->power.suspend_timer, pm_suspend_timer_fn, CLOCK_MONOTONIC,
1793 init_waitqueue_head(&dev->power.wait_queue);
1803 if (dev->power.runtime_status == RPM_ACTIVE)
1805 if (dev->power.irq_safe) {
1806 spin_lock_irq(&dev->power.lock);
1807 dev->power.irq_safe = 0;
1808 spin_unlock_irq(&dev->power.lock);
1869 spin_lock_irq(&dev->power.lock);
1870 dev->power.links_count++;
1871 spin_unlock_irq(&dev->power.lock);
1876 spin_lock_irq(&dev->power.lock);
1877 WARN_ON(dev->power.links_count == 0);
1878 dev->power.links_count--;
1879 spin_unlock_irq(&dev->power.lock);
1902 return atomic_read(&dev->power.usage_count) <= 1 &&
1903 (atomic_read(&dev->power.child_count) == 0 ||
1904 dev->power.ignore_children);
1920 * sure the device is put into low power state and it should only be used during
1956 dev->power.needs_force_resume = 1;
1973 * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1974 * those actions and bring the device into full power, if it is expected to be
1985 if (!dev->power.needs_force_resume)
2006 dev->power.needs_force_resume = 0;