Lines Matching refs:power
3 * drivers/base/power/runtime.c - Helper functions for device runtime PM
17 #include "power.h"
55 * update_pm_runtime_accounting - Update the time accounting of power states
58 * In order to be able to have time accounting of the various power states
69 if (dev->power.disable_depth > 0)
72 last = dev->power.accounting_timestamp;
75 dev->power.accounting_timestamp = now;
87 if (dev->power.runtime_status == RPM_SUSPENDED)
88 dev->power.suspended_time += delta;
90 dev->power.active_time += delta;
96 dev->power.runtime_status = status;
104 spin_lock_irqsave(&dev->power.lock, flags);
107 time = suspended ? dev->power.suspended_time : dev->power.active_time;
109 spin_unlock_irqrestore(&dev->power.lock, flags);
131 if (dev->power.timer_expires > 0) {
132 hrtimer_try_to_cancel(&dev->power.suspend_timer);
133 dev->power.timer_expires = 0;
148 dev->power.request = RPM_REQ_NONE;
156 * power.last_busy time. If the delay has already expired or is disabled
157 * (negative) or the power.use_autosuspend flag isn't set, return 0.
160 * This function may be called either with or without dev->power.lock held.
161 * Either way it can be racy, since power.last_busy may be updated at any time.
168 if (!dev->power.use_autosuspend)
171 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);
175 expires = READ_ONCE(dev->power.last_busy);
186 return dev->power.memalloc_noio;
225 /* hold power lock since bitfield is not SMP-safe. */
226 spin_lock_irq(&dev->power.lock);
227 enabled = dev->power.memalloc_noio;
228 dev->power.memalloc_noio = enable;
229 spin_unlock_irq(&dev->power.lock);
262 if (dev->power.runtime_error)
264 else if (dev->power.disable_depth > 0)
266 else if (atomic_read(&dev->power.usage_count) > 0)
268 else if (!dev->power.ignore_children &&
269 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
276 && dev->power.request == RPM_REQ_RESUME))
280 else if (dev->power.runtime_status == RPM_SUSPENDED)
319 * The additional power.usage_count check is a safety net in case
325 atomic_read(&supplier->power.usage_count) > 0)
364 __releases(&dev->power.lock) __acquires(&dev->power.lock)
367 bool use_links = dev->power.links_count > 0;
369 if (dev->power.irq_safe) {
370 spin_unlock(&dev->power.lock);
372 spin_unlock_irq(&dev->power.lock);
381 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);
434 * This function must be called under dev->power.lock with interrupts disabled.
447 else if (dev->power.runtime_status != RPM_ACTIVE)
454 else if (dev->power.request_pending &&
455 dev->power.request > RPM_REQ_IDLE)
459 else if (dev->power.idle_notification)
465 dev->power.request = RPM_REQ_NONE;
470 if (!callback || dev->power.no_callbacks)
475 dev->power.request = RPM_REQ_IDLE;
476 if (!dev->power.request_pending) {
477 dev->power.request_pending = true;
478 queue_work(pm_wq, &dev->power.work);
484 dev->power.idle_notification = true;
486 if (dev->power.irq_safe)
487 spin_unlock(&dev->power.lock);
489 spin_unlock_irq(&dev->power.lock);
493 if (dev->power.irq_safe)
494 spin_lock(&dev->power.lock);
496 spin_lock_irq(&dev->power.lock);
498 dev->power.idle_notification = false;
499 wake_up_all(&dev->power.wait_queue);
518 if (dev->power.memalloc_noio) {
537 dev->power.runtime_error = retval;
555 * ignore_children of parent->power and irq_safe of dev->power are not set).
560 * This function must be called under dev->power.lock with interrupts disabled.
563 __releases(&dev->power.lock) __acquires(&dev->power.lock)
577 if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC))
584 && dev->power.runtime_status != RPM_SUSPENDING) {
589 dev->power.request = RPM_REQ_NONE;
598 if (!(dev->power.timer_expires &&
599 dev->power.timer_expires <= expires)) {
604 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *
607 dev->power.timer_expires = expires;
608 hrtimer_start_range_ns(&dev->power.suspend_timer,
613 dev->power.timer_autosuspends = 1;
621 if (dev->power.runtime_status == RPM_SUSPENDING) {
629 if (dev->power.irq_safe) {
630 spin_unlock(&dev->power.lock);
634 spin_lock(&dev->power.lock);
640 prepare_to_wait(&dev->power.wait_queue, &wait,
642 if (dev->power.runtime_status != RPM_SUSPENDING)
645 spin_unlock_irq(&dev->power.lock);
649 spin_lock_irq(&dev->power.lock);
651 finish_wait(&dev->power.wait_queue, &wait);
655 if (dev->power.no_callbacks)
660 dev->power.request = (rpmflags & RPM_AUTO) ?
662 if (!dev->power.request_pending) {
663 dev->power.request_pending = true;
664 queue_work(pm_wq, &dev->power.work);
686 atomic_add_unless(&parent->power.child_count, -1, 0);
688 wake_up_all(&dev->power.wait_queue);
690 if (dev->power.deferred_resume) {
691 dev->power.deferred_resume = false;
697 if (dev->power.irq_safe)
701 if (parent && !parent->power.ignore_children) {
702 spin_unlock(&dev->power.lock);
704 spin_lock(&parent->power.lock);
706 spin_unlock(&parent->power.lock);
708 spin_lock(&dev->power.lock);
711 if (dev->power.links_count > 0) {
712 spin_unlock_irq(&dev->power.lock);
716 spin_lock_irq(&dev->power.lock);
727 dev->power.deferred_resume = false;
728 wake_up_all(&dev->power.wait_queue);
731 dev->power.runtime_error = 0;
763 * This function must be called under dev->power.lock with interrupts disabled.
766 __releases(&dev->power.lock) __acquires(&dev->power.lock)
775 if (dev->power.runtime_error)
777 else if (dev->power.disable_depth == 1 && dev->power.is_suspended
778 && dev->power.runtime_status == RPM_ACTIVE)
780 else if (dev->power.disable_depth > 0)
791 dev->power.request = RPM_REQ_NONE;
792 if (!dev->power.timer_autosuspends)
795 if (dev->power.runtime_status == RPM_ACTIVE) {
800 if (dev->power.runtime_status == RPM_RESUMING
801 || dev->power.runtime_status == RPM_SUSPENDING) {
805 if (dev->power.runtime_status == RPM_SUSPENDING)
806 dev->power.deferred_resume = true;
812 if (dev->power.irq_safe) {
813 spin_unlock(&dev->power.lock);
817 spin_lock(&dev->power.lock);
823 prepare_to_wait(&dev->power.wait_queue, &wait,
825 if (dev->power.runtime_status != RPM_RESUMING
826 && dev->power.runtime_status != RPM_SUSPENDING)
829 spin_unlock_irq(&dev->power.lock);
833 spin_lock_irq(&dev->power.lock);
835 finish_wait(&dev->power.wait_queue, &wait);
841 * power.no_callbacks is set, because otherwise we don't know whether
844 if (dev->power.no_callbacks && !parent && dev->parent) {
845 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
846 if (dev->parent->power.disable_depth > 0
847 || dev->parent->power.ignore_children
848 || dev->parent->power.runtime_status == RPM_ACTIVE) {
849 atomic_inc(&dev->parent->power.child_count);
850 spin_unlock(&dev->parent->power.lock);
854 spin_unlock(&dev->parent->power.lock);
859 dev->power.request = RPM_REQ_RESUME;
860 if (!dev->power.request_pending) {
861 dev->power.request_pending = true;
862 queue_work(pm_wq, &dev->power.work);
875 if (dev->power.irq_safe)
877 spin_unlock(&dev->power.lock);
881 spin_lock(&parent->power.lock);
886 if (!parent->power.disable_depth
887 && !parent->power.ignore_children) {
889 if (parent->power.runtime_status != RPM_ACTIVE)
892 spin_unlock(&parent->power.lock);
894 spin_lock(&dev->power.lock);
901 if (dev->power.no_callbacks)
919 atomic_inc(&parent->power.child_count);
921 wake_up_all(&dev->power.wait_queue);
927 if (parent && !dev->power.irq_safe) {
928 spin_unlock_irq(&dev->power.lock);
932 spin_lock_irq(&dev->power.lock);
949 struct device *dev = container_of(work, struct device, power.work);
952 spin_lock_irq(&dev->power.lock);
954 if (!dev->power.request_pending)
957 req = dev->power.request;
958 dev->power.request = RPM_REQ_NONE;
959 dev->power.request_pending = false;
979 spin_unlock_irq(&dev->power.lock);
990 struct device *dev = container_of(timer, struct device, power.suspend_timer);
994 spin_lock_irqsave(&dev->power.lock, flags);
996 expires = dev->power.timer_expires;
1002 dev->power.timer_expires = 0;
1003 rpm_suspend(dev, dev->power.timer_autosuspends ?
1007 spin_unlock_irqrestore(&dev->power.lock, flags);
1023 spin_lock_irqsave(&dev->power.lock, flags);
1038 dev->power.timer_expires = expires;
1039 dev->power.timer_autosuspends = 0;
1040 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS);
1043 spin_unlock_irqrestore(&dev->power.lock, flags);
1067 if (!atomic_dec_and_test(&dev->power.usage_count)) {
1073 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
1075 spin_lock_irqsave(&dev->power.lock, flags);
1077 spin_unlock_irqrestore(&dev->power.lock, flags);
1101 if (!atomic_dec_and_test(&dev->power.usage_count)) {
1107 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
1109 spin_lock_irqsave(&dev->power.lock, flags);
1111 spin_unlock_irqrestore(&dev->power.lock, flags);
1133 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe &&
1134 dev->power.runtime_status != RPM_ACTIVE);
1137 atomic_inc(&dev->power.usage_count);
1139 spin_lock_irqsave(&dev->power.lock, flags);
1141 spin_unlock_irqrestore(&dev->power.lock, flags);
1174 spin_lock_irqsave(&dev->power.lock, flags);
1175 if (dev->power.disable_depth > 0) {
1177 } else if (dev->power.runtime_status != RPM_ACTIVE) {
1181 atomic_inc(&dev->power.usage_count);
1183 retval = atomic_inc_not_zero(&dev->power.usage_count);
1186 spin_unlock_irqrestore(&dev->power.lock, flags);
1197 * If runtime PM of the device is disabled or its power.runtime_error field is
1201 * parent's power.ignore_children flag is unset, the device's status cannot be
1204 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1225 spin_lock_irq(&dev->power.lock);
1231 if (dev->power.runtime_error || dev->power.disable_depth)
1232 dev->power.disable_depth++;
1236 spin_unlock_irq(&dev->power.lock);
1257 spin_lock_irq(&dev->power.lock);
1259 if (dev->power.runtime_status == status || !parent)
1263 atomic_add_unless(&parent->power.child_count, -1, 0);
1264 notify_parent = !parent->power.ignore_children;
1266 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
1271 * 'power.ignore_children' flag unset.
1273 if (!parent->power.disable_depth
1274 && !parent->power.ignore_children
1275 && parent->power.runtime_status != RPM_ACTIVE) {
1280 } else if (dev->power.runtime_status == RPM_SUSPENDED) {
1281 atomic_inc(&parent->power.child_count);
1284 spin_unlock(&parent->power.lock);
1295 dev->power.runtime_error = 0;
1298 spin_unlock_irq(&dev->power.lock);
1324 * Should be called under dev->power.lock with interrupts disabled.
1330 if (dev->power.request_pending) {
1331 dev->power.request = RPM_REQ_NONE;
1332 spin_unlock_irq(&dev->power.lock);
1334 cancel_work_sync(&dev->power.work);
1336 spin_lock_irq(&dev->power.lock);
1337 dev->power.request_pending = false;
1340 if (dev->power.runtime_status == RPM_SUSPENDING
1341 || dev->power.runtime_status == RPM_RESUMING
1342 || dev->power.idle_notification) {
1347 prepare_to_wait(&dev->power.wait_queue, &wait,
1349 if (dev->power.runtime_status != RPM_SUSPENDING
1350 && dev->power.runtime_status != RPM_RESUMING
1351 && !dev->power.idle_notification)
1353 spin_unlock_irq(&dev->power.lock);
1357 spin_lock_irq(&dev->power.lock);
1359 finish_wait(&dev->power.wait_queue, &wait);
1382 spin_lock_irq(&dev->power.lock);
1384 if (dev->power.request_pending
1385 && dev->power.request == RPM_REQ_RESUME) {
1392 spin_unlock_irq(&dev->power.lock);
1404 * Increment power.disable_depth for the device and if it was zero previously,
1410 * __pm_runtime_disable() is called and power.disable_depth is zero, the
1415 spin_lock_irq(&dev->power.lock);
1417 if (dev->power.disable_depth > 0) {
1418 dev->power.disable_depth++;
1427 if (check_resume && dev->power.request_pending
1428 && dev->power.request == RPM_REQ_RESUME) {
1443 if (!dev->power.disable_depth++)
1447 spin_unlock_irq(&dev->power.lock);
1459 spin_lock_irqsave(&dev->power.lock, flags);
1461 if (dev->power.disable_depth > 0) {
1462 dev->power.disable_depth--;
1465 if (!dev->power.disable_depth)
1466 dev->power.accounting_timestamp = ktime_get_mono_fast_ns();
1471 WARN(!dev->power.disable_depth &&
1472 dev->power.runtime_status == RPM_SUSPENDED &&
1473 !dev->power.ignore_children &&
1474 atomic_read(&dev->power.child_count) > 0,
1478 spin_unlock_irqrestore(&dev->power.lock, flags);
1508 * Increase the device's usage count and clear its power.runtime_auto flag,
1514 spin_lock_irq(&dev->power.lock);
1515 if (!dev->power.runtime_auto)
1518 dev->power.runtime_auto = false;
1519 atomic_inc(&dev->power.usage_count);
1523 spin_unlock_irq(&dev->power.lock);
1531 * Decrease the device's usage count and set its power.runtime_auto flag.
1535 spin_lock_irq(&dev->power.lock);
1536 if (dev->power.runtime_auto)
1539 dev->power.runtime_auto = true;
1540 if (atomic_dec_and_test(&dev->power.usage_count))
1546 spin_unlock_irq(&dev->power.lock);
1554 * Set the power.no_callbacks flag, which tells the PM core that this
1555 * device is power-managed through its parent and has no runtime PM
1560 spin_lock_irq(&dev->power.lock);
1561 dev->power.no_callbacks = 1;
1562 spin_unlock_irq(&dev->power.lock);
1572 * Set the power.irq_safe flag, which tells the PM core that the
1583 spin_lock_irq(&dev->power.lock);
1584 dev->power.irq_safe = 1;
1585 spin_unlock_irq(&dev->power.lock);
1598 * This function must be called under dev->power.lock with interrupts disabled.
1602 int delay = dev->power.autosuspend_delay;
1605 if (dev->power.use_autosuspend && delay < 0) {
1609 atomic_inc(&dev->power.usage_count);
1621 atomic_dec(&dev->power.usage_count);
1633 * Set the device's power.autosuspend_delay value. If it changes to negative
1634 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1641 spin_lock_irq(&dev->power.lock);
1642 old_delay = dev->power.autosuspend_delay;
1643 old_use = dev->power.use_autosuspend;
1644 dev->power.autosuspend_delay = delay;
1646 spin_unlock_irq(&dev->power.lock);
1655 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1662 spin_lock_irq(&dev->power.lock);
1663 old_delay = dev->power.autosuspend_delay;
1664 old_use = dev->power.use_autosuspend;
1665 dev->power.use_autosuspend = use;
1667 spin_unlock_irq(&dev->power.lock);
1677 dev->power.runtime_status = RPM_SUSPENDED;
1678 dev->power.idle_notification = false;
1680 dev->power.disable_depth = 1;
1681 atomic_set(&dev->power.usage_count, 0);
1683 dev->power.runtime_error = 0;
1685 atomic_set(&dev->power.child_count, 0);
1687 dev->power.runtime_auto = true;
1689 dev->power.request_pending = false;
1690 dev->power.request = RPM_REQ_NONE;
1691 dev->power.deferred_resume = false;
1692 dev->power.needs_force_resume = 0;
1693 INIT_WORK(&dev->power.work, pm_runtime_work);
1695 dev->power.timer_expires = 0;
1696 hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1697 dev->power.suspend_timer.function = pm_suspend_timer_fn;
1699 init_waitqueue_head(&dev->power.wait_queue);
1709 if (dev->power.runtime_status == RPM_ACTIVE)
1711 if (dev->power.irq_safe) {
1712 spin_lock_irq(&dev->power.lock);
1713 dev->power.irq_safe = 0;
1714 spin_unlock_irq(&dev->power.lock);
1770 spin_lock_irqsave(&dev->power.lock, flags);
1773 spin_unlock_irqrestore(&dev->power.lock, flags);
1783 spin_lock_irq(&dev->power.lock);
1784 dev->power.links_count++;
1785 spin_unlock_irq(&dev->power.lock);
1790 spin_lock_irq(&dev->power.lock);
1791 WARN_ON(dev->power.links_count == 0);
1792 dev->power.links_count--;
1793 spin_unlock_irq(&dev->power.lock);
1816 return atomic_read(&dev->power.usage_count) <= 1 &&
1817 (atomic_read(&dev->power.child_count) == 0 ||
1818 dev->power.ignore_children);
1834 * sure the device is put into low power state and it should only be used during
1863 dev->power.needs_force_resume = 1;
1879 * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1880 * those actions and bring the device into full power, if it is expected to be
1891 if (!pm_runtime_status_suspended(dev) || !dev->power.needs_force_resume)
1910 dev->power.needs_force_resume = 0;