Lines Matching full: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) in update_pm_runtime_accounting()
72 last = dev->power.accounting_timestamp; in update_pm_runtime_accounting()
75 dev->power.accounting_timestamp = now; in update_pm_runtime_accounting()
87 if (dev->power.runtime_status == RPM_SUSPENDED) in update_pm_runtime_accounting()
88 dev->power.suspended_time += delta; in update_pm_runtime_accounting()
90 dev->power.active_time += delta; in update_pm_runtime_accounting()
96 dev->power.runtime_status = status; in __update_runtime_status()
104 spin_lock_irqsave(&dev->power.lock, flags); in rpm_get_accounted_time()
107 time = suspended ? dev->power.suspended_time : dev->power.active_time; in rpm_get_accounted_time()
109 spin_unlock_irqrestore(&dev->power.lock, flags); in rpm_get_accounted_time()
131 if (dev->power.timer_expires > 0) { in pm_runtime_deactivate_timer()
132 hrtimer_try_to_cancel(&dev->power.suspend_timer); in pm_runtime_deactivate_timer()
133 dev->power.timer_expires = 0; in pm_runtime_deactivate_timer()
148 dev->power.request = RPM_REQ_NONE; in pm_runtime_cancel_pending()
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) in pm_runtime_autosuspend_expiration()
171 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); in pm_runtime_autosuspend_expiration()
175 expires = READ_ONCE(dev->power.last_busy); in pm_runtime_autosuspend_expiration()
186 return dev->power.memalloc_noio; in dev_memalloc_noio()
225 /* hold power lock since bitfield is not SMP-safe. */ in pm_runtime_set_memalloc_noio()
226 spin_lock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
227 enabled = dev->power.memalloc_noio; in pm_runtime_set_memalloc_noio()
228 dev->power.memalloc_noio = enable; in pm_runtime_set_memalloc_noio()
229 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
262 if (dev->power.runtime_error) in rpm_check_suspend_allowed()
264 else if (dev->power.disable_depth > 0) in rpm_check_suspend_allowed()
266 else if (atomic_read(&dev->power.usage_count) > 0) in rpm_check_suspend_allowed()
268 else if (!dev->power.ignore_children && in rpm_check_suspend_allowed()
269 atomic_read(&dev->power.child_count)) in rpm_check_suspend_allowed()
273 else if ((dev->power.deferred_resume in rpm_check_suspend_allowed()
274 && dev->power.runtime_status == RPM_SUSPENDING) in rpm_check_suspend_allowed()
275 || (dev->power.request_pending in rpm_check_suspend_allowed()
276 && dev->power.request == RPM_REQ_RESUME)) in rpm_check_suspend_allowed()
280 else if (dev->power.runtime_status == RPM_SUSPENDED) in rpm_check_suspend_allowed()
322 * The additional power.usage_count check is a safety net in case in pm_runtime_release_supplier()
328 atomic_read(&supplier->power.usage_count) > 0) in pm_runtime_release_supplier()
367 __releases(&dev->power.lock) __acquires(&dev->power.lock) in __rpm_callback()
370 bool use_links = dev->power.links_count > 0; in __rpm_callback()
372 if (dev->power.irq_safe) { in __rpm_callback()
373 spin_unlock(&dev->power.lock); in __rpm_callback()
375 spin_unlock_irq(&dev->power.lock); in __rpm_callback()
384 if (use_links && dev->power.runtime_status == RPM_RESUMING) { in __rpm_callback()
399 if (dev->power.irq_safe) { in __rpm_callback()
400 spin_lock(&dev->power.lock); in __rpm_callback()
410 && ((dev->power.runtime_status == RPM_SUSPENDING && !retval) in __rpm_callback()
411 || (dev->power.runtime_status == RPM_RESUMING && retval))) { in __rpm_callback()
420 spin_lock_irq(&dev->power.lock); in __rpm_callback()
437 * This function must be called under dev->power.lock with interrupts disabled.
450 else if (dev->power.runtime_status != RPM_ACTIVE) in rpm_idle()
457 else if (dev->power.request_pending && in rpm_idle()
458 dev->power.request > RPM_REQ_IDLE) in rpm_idle()
462 else if (dev->power.idle_notification) in rpm_idle()
468 dev->power.request = RPM_REQ_NONE; in rpm_idle()
470 if (dev->power.no_callbacks) in rpm_idle()
475 dev->power.request = RPM_REQ_IDLE; in rpm_idle()
476 if (!dev->power.request_pending) { in rpm_idle()
477 dev->power.request_pending = true; in rpm_idle()
478 queue_work(pm_wq, &dev->power.work); in rpm_idle()
484 dev->power.idle_notification = true; in rpm_idle()
491 dev->power.idle_notification = false; in rpm_idle()
492 wake_up_all(&dev->power.wait_queue); in rpm_idle()
511 if (dev->power.memalloc_noio) { in rpm_callback()
530 dev->power.runtime_error = retval; in rpm_callback()
548 * ignore_children of parent->power and irq_safe of dev->power are not set).
553 * This function must be called under dev->power.lock with interrupts disabled.
556 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_suspend()
570 if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC)) in rpm_suspend()
577 && dev->power.runtime_status != RPM_SUSPENDING) { in rpm_suspend()
582 dev->power.request = RPM_REQ_NONE; in rpm_suspend()
591 if (!(dev->power.timer_expires && in rpm_suspend()
592 dev->power.timer_expires <= expires)) { in rpm_suspend()
597 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) * in rpm_suspend()
600 dev->power.timer_expires = expires; in rpm_suspend()
601 hrtimer_start_range_ns(&dev->power.suspend_timer, in rpm_suspend()
606 dev->power.timer_autosuspends = 1; in rpm_suspend()
614 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_suspend()
622 if (dev->power.irq_safe) { in rpm_suspend()
623 spin_unlock(&dev->power.lock); in rpm_suspend()
627 spin_lock(&dev->power.lock); in rpm_suspend()
633 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_suspend()
635 if (dev->power.runtime_status != RPM_SUSPENDING) in rpm_suspend()
638 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
642 spin_lock_irq(&dev->power.lock); in rpm_suspend()
644 finish_wait(&dev->power.wait_queue, &wait); in rpm_suspend()
648 if (dev->power.no_callbacks) in rpm_suspend()
653 dev->power.request = (rpmflags & RPM_AUTO) ? in rpm_suspend()
655 if (!dev->power.request_pending) { in rpm_suspend()
656 dev->power.request_pending = true; in rpm_suspend()
657 queue_work(pm_wq, &dev->power.work); in rpm_suspend()
677 atomic_add_unless(&parent->power.child_count, -1, 0); in rpm_suspend()
679 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
681 if (dev->power.deferred_resume) { in rpm_suspend()
682 dev->power.deferred_resume = false; in rpm_suspend()
688 if (dev->power.irq_safe) in rpm_suspend()
692 if (parent && !parent->power.ignore_children) { in rpm_suspend()
693 spin_unlock(&dev->power.lock); in rpm_suspend()
695 spin_lock(&parent->power.lock); in rpm_suspend()
697 spin_unlock(&parent->power.lock); in rpm_suspend()
699 spin_lock(&dev->power.lock); in rpm_suspend()
702 if (dev->power.links_count > 0) { in rpm_suspend()
703 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
707 spin_lock_irq(&dev->power.lock); in rpm_suspend()
718 dev->power.deferred_resume = false; in rpm_suspend()
719 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
722 dev->power.runtime_error = 0; in rpm_suspend()
754 * This function must be called under dev->power.lock with interrupts disabled.
757 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_resume()
766 if (dev->power.runtime_error) in rpm_resume()
768 else if (dev->power.disable_depth == 1 && dev->power.is_suspended in rpm_resume()
769 && dev->power.runtime_status == RPM_ACTIVE) in rpm_resume()
771 else if (dev->power.disable_depth > 0) in rpm_resume()
782 dev->power.request = RPM_REQ_NONE; in rpm_resume()
783 if (!dev->power.timer_autosuspends) in rpm_resume()
786 if (dev->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
791 if (dev->power.runtime_status == RPM_RESUMING in rpm_resume()
792 || dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
796 if (dev->power.runtime_status == RPM_SUSPENDING) in rpm_resume()
797 dev->power.deferred_resume = true; in rpm_resume()
803 if (dev->power.irq_safe) { in rpm_resume()
804 spin_unlock(&dev->power.lock); in rpm_resume()
808 spin_lock(&dev->power.lock); in rpm_resume()
814 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_resume()
816 if (dev->power.runtime_status != RPM_RESUMING in rpm_resume()
817 && dev->power.runtime_status != RPM_SUSPENDING) in rpm_resume()
820 spin_unlock_irq(&dev->power.lock); in rpm_resume()
824 spin_lock_irq(&dev->power.lock); in rpm_resume()
826 finish_wait(&dev->power.wait_queue, &wait); in rpm_resume()
832 * power.no_callbacks is set, because otherwise we don't know whether in rpm_resume()
835 if (dev->power.no_callbacks && !parent && dev->parent) { in rpm_resume()
836 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING); in rpm_resume()
837 if (dev->parent->power.disable_depth > 0 in rpm_resume()
838 || dev->parent->power.ignore_children in rpm_resume()
839 || dev->parent->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
840 atomic_inc(&dev->parent->power.child_count); in rpm_resume()
841 spin_unlock(&dev->parent->power.lock); in rpm_resume()
845 spin_unlock(&dev->parent->power.lock); in rpm_resume()
850 dev->power.request = RPM_REQ_RESUME; in rpm_resume()
851 if (!dev->power.request_pending) { in rpm_resume()
852 dev->power.request_pending = true; in rpm_resume()
853 queue_work(pm_wq, &dev->power.work); in rpm_resume()
866 if (dev->power.irq_safe) in rpm_resume()
868 spin_unlock(&dev->power.lock); in rpm_resume()
872 spin_lock(&parent->power.lock); in rpm_resume()
877 if (!parent->power.disable_depth in rpm_resume()
878 && !parent->power.ignore_children) { in rpm_resume()
880 if (parent->power.runtime_status != RPM_ACTIVE) in rpm_resume()
883 spin_unlock(&parent->power.lock); in rpm_resume()
885 spin_lock(&dev->power.lock); in rpm_resume()
892 if (dev->power.no_callbacks) in rpm_resume()
910 atomic_inc(&parent->power.child_count); in rpm_resume()
912 wake_up_all(&dev->power.wait_queue); in rpm_resume()
918 if (parent && !dev->power.irq_safe) { in rpm_resume()
919 spin_unlock_irq(&dev->power.lock); in rpm_resume()
923 spin_lock_irq(&dev->power.lock); in rpm_resume()
940 struct device *dev = container_of(work, struct device, power.work); in pm_runtime_work()
943 spin_lock_irq(&dev->power.lock); in pm_runtime_work()
945 if (!dev->power.request_pending) in pm_runtime_work()
948 req = dev->power.request; in pm_runtime_work()
949 dev->power.request = RPM_REQ_NONE; in pm_runtime_work()
950 dev->power.request_pending = false; in pm_runtime_work()
970 spin_unlock_irq(&dev->power.lock); in pm_runtime_work()
981 struct device *dev = container_of(timer, struct device, power.suspend_timer); in pm_suspend_timer_fn()
985 spin_lock_irqsave(&dev->power.lock, flags); in pm_suspend_timer_fn()
987 expires = dev->power.timer_expires; in pm_suspend_timer_fn()
993 dev->power.timer_expires = 0; in pm_suspend_timer_fn()
994 rpm_suspend(dev, dev->power.timer_autosuspends ? in pm_suspend_timer_fn()
998 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_suspend_timer_fn()
1014 spin_lock_irqsave(&dev->power.lock, flags); in pm_schedule_suspend()
1029 dev->power.timer_expires = expires; in pm_schedule_suspend()
1030 dev->power.timer_autosuspends = 0; in pm_schedule_suspend()
1031 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS); in pm_schedule_suspend()
1034 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_schedule_suspend()
1058 if (!atomic_dec_and_test(&dev->power.usage_count)) { in __pm_runtime_idle()
1064 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_idle()
1066 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_idle()
1068 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_idle()
1092 if (!atomic_dec_and_test(&dev->power.usage_count)) { in __pm_runtime_suspend()
1098 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_suspend()
1100 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_suspend()
1102 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_suspend()
1124 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe && in __pm_runtime_resume()
1125 dev->power.runtime_status != RPM_ACTIVE); in __pm_runtime_resume()
1128 atomic_inc(&dev->power.usage_count); in __pm_runtime_resume()
1130 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_resume()
1132 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_resume()
1165 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_get_if_active()
1166 if (dev->power.disable_depth > 0) { in pm_runtime_get_if_active()
1168 } else if (dev->power.runtime_status != RPM_ACTIVE) { in pm_runtime_get_if_active()
1172 atomic_inc(&dev->power.usage_count); in pm_runtime_get_if_active()
1174 retval = atomic_inc_not_zero(&dev->power.usage_count); in pm_runtime_get_if_active()
1177 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_get_if_active()
1188 * If runtime PM of the device is disabled or its power.runtime_error field is
1192 * parent's power.ignore_children flag is unset, the device's status cannot be
1195 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1216 spin_lock_irq(&dev->power.lock); in __pm_runtime_set_status()
1222 if (dev->power.runtime_error || dev->power.disable_depth) in __pm_runtime_set_status()
1223 dev->power.disable_depth++; in __pm_runtime_set_status()
1227 spin_unlock_irq(&dev->power.lock); in __pm_runtime_set_status()
1248 spin_lock_irq(&dev->power.lock); in __pm_runtime_set_status()
1250 if (dev->power.runtime_status == status || !parent) in __pm_runtime_set_status()
1254 atomic_add_unless(&parent->power.child_count, -1, 0); in __pm_runtime_set_status()
1255 notify_parent = !parent->power.ignore_children; in __pm_runtime_set_status()
1257 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING); in __pm_runtime_set_status()
1262 * 'power.ignore_children' flag unset. in __pm_runtime_set_status()
1264 if (!parent->power.disable_depth in __pm_runtime_set_status()
1265 && !parent->power.ignore_children in __pm_runtime_set_status()
1266 && parent->power.runtime_status != RPM_ACTIVE) { in __pm_runtime_set_status()
1271 } else if (dev->power.runtime_status == RPM_SUSPENDED) { in __pm_runtime_set_status()
1272 atomic_inc(&parent->power.child_count); in __pm_runtime_set_status()
1275 spin_unlock(&parent->power.lock); in __pm_runtime_set_status()
1286 dev->power.runtime_error = 0; in __pm_runtime_set_status()
1289 spin_unlock_irq(&dev->power.lock); in __pm_runtime_set_status()
1315 * Should be called under dev->power.lock with interrupts disabled.
1321 if (dev->power.request_pending) { in __pm_runtime_barrier()
1322 dev->power.request = RPM_REQ_NONE; in __pm_runtime_barrier()
1323 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1325 cancel_work_sync(&dev->power.work); in __pm_runtime_barrier()
1327 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1328 dev->power.request_pending = false; in __pm_runtime_barrier()
1331 if (dev->power.runtime_status == RPM_SUSPENDING in __pm_runtime_barrier()
1332 || dev->power.runtime_status == RPM_RESUMING in __pm_runtime_barrier()
1333 || dev->power.idle_notification) { in __pm_runtime_barrier()
1338 prepare_to_wait(&dev->power.wait_queue, &wait, in __pm_runtime_barrier()
1340 if (dev->power.runtime_status != RPM_SUSPENDING in __pm_runtime_barrier()
1341 && dev->power.runtime_status != RPM_RESUMING in __pm_runtime_barrier()
1342 && !dev->power.idle_notification) in __pm_runtime_barrier()
1344 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1348 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1350 finish_wait(&dev->power.wait_queue, &wait); in __pm_runtime_barrier()
1373 spin_lock_irq(&dev->power.lock); in pm_runtime_barrier()
1375 if (dev->power.request_pending in pm_runtime_barrier()
1376 && dev->power.request == RPM_REQ_RESUME) { in pm_runtime_barrier()
1383 spin_unlock_irq(&dev->power.lock); in pm_runtime_barrier()
1395 * Increment power.disable_depth for the device and if it was zero previously,
1401 * __pm_runtime_disable() is called and power.disable_depth is zero, the
1406 spin_lock_irq(&dev->power.lock); in __pm_runtime_disable()
1408 if (dev->power.disable_depth > 0) { in __pm_runtime_disable()
1409 dev->power.disable_depth++; in __pm_runtime_disable()
1418 if (check_resume && dev->power.request_pending in __pm_runtime_disable()
1419 && dev->power.request == RPM_REQ_RESUME) { in __pm_runtime_disable()
1434 if (!dev->power.disable_depth++) in __pm_runtime_disable()
1438 spin_unlock_irq(&dev->power.lock); in __pm_runtime_disable()
1450 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_enable()
1452 if (dev->power.disable_depth > 0) { in pm_runtime_enable()
1453 dev->power.disable_depth--; in pm_runtime_enable()
1456 if (!dev->power.disable_depth) in pm_runtime_enable()
1457 dev->power.accounting_timestamp = ktime_get_mono_fast_ns(); in pm_runtime_enable()
1462 WARN(!dev->power.disable_depth && in pm_runtime_enable()
1463 dev->power.runtime_status == RPM_SUSPENDED && in pm_runtime_enable()
1464 !dev->power.ignore_children && in pm_runtime_enable()
1465 atomic_read(&dev->power.child_count) > 0, in pm_runtime_enable()
1469 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_enable()
1477 * Increase the device's usage count and clear its power.runtime_auto flag,
1483 spin_lock_irq(&dev->power.lock); in pm_runtime_forbid()
1484 if (!dev->power.runtime_auto) in pm_runtime_forbid()
1487 dev->power.runtime_auto = false; in pm_runtime_forbid()
1488 atomic_inc(&dev->power.usage_count); in pm_runtime_forbid()
1492 spin_unlock_irq(&dev->power.lock); in pm_runtime_forbid()
1500 * Decrease the device's usage count and set its power.runtime_auto flag.
1504 spin_lock_irq(&dev->power.lock); in pm_runtime_allow()
1505 if (dev->power.runtime_auto) in pm_runtime_allow()
1508 dev->power.runtime_auto = true; in pm_runtime_allow()
1509 if (atomic_dec_and_test(&dev->power.usage_count)) in pm_runtime_allow()
1515 spin_unlock_irq(&dev->power.lock); in pm_runtime_allow()
1523 * Set the power.no_callbacks flag, which tells the PM core that this
1524 * device is power-managed through its parent and has no runtime PM
1529 spin_lock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1530 dev->power.no_callbacks = 1; in pm_runtime_no_callbacks()
1531 spin_unlock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1541 * Set the power.irq_safe flag, which tells the PM core that the
1552 spin_lock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1553 dev->power.irq_safe = 1; in pm_runtime_irq_safe()
1554 spin_unlock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1567 * This function must be called under dev->power.lock with interrupts disabled.
1571 int delay = dev->power.autosuspend_delay; in update_autosuspend()
1574 if (dev->power.use_autosuspend && delay < 0) { in update_autosuspend()
1578 atomic_inc(&dev->power.usage_count); in update_autosuspend()
1590 atomic_dec(&dev->power.usage_count); in update_autosuspend()
1602 * Set the device's power.autosuspend_delay value. If it changes to negative
1603 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1610 spin_lock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1611 old_delay = dev->power.autosuspend_delay; in pm_runtime_set_autosuspend_delay()
1612 old_use = dev->power.use_autosuspend; in pm_runtime_set_autosuspend_delay()
1613 dev->power.autosuspend_delay = delay; in pm_runtime_set_autosuspend_delay()
1615 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1624 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1631 spin_lock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1632 old_delay = dev->power.autosuspend_delay; in __pm_runtime_use_autosuspend()
1633 old_use = dev->power.use_autosuspend; in __pm_runtime_use_autosuspend()
1634 dev->power.use_autosuspend = use; in __pm_runtime_use_autosuspend()
1636 spin_unlock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1646 dev->power.runtime_status = RPM_SUSPENDED; in pm_runtime_init()
1647 dev->power.idle_notification = false; in pm_runtime_init()
1649 dev->power.disable_depth = 1; in pm_runtime_init()
1650 atomic_set(&dev->power.usage_count, 0); in pm_runtime_init()
1652 dev->power.runtime_error = 0; in pm_runtime_init()
1654 atomic_set(&dev->power.child_count, 0); in pm_runtime_init()
1656 dev->power.runtime_auto = true; in pm_runtime_init()
1658 dev->power.request_pending = false; in pm_runtime_init()
1659 dev->power.request = RPM_REQ_NONE; in pm_runtime_init()
1660 dev->power.deferred_resume = false; in pm_runtime_init()
1661 dev->power.needs_force_resume = 0; in pm_runtime_init()
1662 INIT_WORK(&dev->power.work, pm_runtime_work); in pm_runtime_init()
1664 dev->power.timer_expires = 0; in pm_runtime_init()
1665 hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); in pm_runtime_init()
1666 dev->power.suspend_timer.function = pm_suspend_timer_fn; in pm_runtime_init()
1668 init_waitqueue_head(&dev->power.wait_queue); in pm_runtime_init()
1678 if (dev->power.runtime_status == RPM_ACTIVE) in pm_runtime_reinit()
1680 if (dev->power.irq_safe) { in pm_runtime_reinit()
1681 spin_lock_irq(&dev->power.lock); in pm_runtime_reinit()
1682 dev->power.irq_safe = 0; in pm_runtime_reinit()
1683 spin_unlock_irq(&dev->power.lock); in pm_runtime_reinit()
1739 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_put_suppliers()
1742 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_put_suppliers()
1752 spin_lock_irq(&dev->power.lock); in pm_runtime_new_link()
1753 dev->power.links_count++; in pm_runtime_new_link()
1754 spin_unlock_irq(&dev->power.lock); in pm_runtime_new_link()
1759 spin_lock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1760 WARN_ON(dev->power.links_count == 0); in pm_runtime_drop_link_count()
1761 dev->power.links_count--; in pm_runtime_drop_link_count()
1762 spin_unlock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1784 return atomic_read(&dev->power.usage_count) <= 1 && in pm_runtime_need_not_resume()
1785 (atomic_read(&dev->power.child_count) == 0 || in pm_runtime_need_not_resume()
1786 dev->power.ignore_children); in pm_runtime_need_not_resume()
1802 * sure the device is put into low power state and it should only be used during
1831 dev->power.needs_force_resume = 1; in pm_runtime_force_suspend()
1847 * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1848 * those actions and bring the device into full power, if it is expected to be
1859 if (!pm_runtime_status_suspended(dev) || !dev->power.needs_force_resume) in pm_runtime_force_resume()
1878 dev->power.needs_force_resume = 0; in pm_runtime_force_resume()