Lines Matching full:power
2 * 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
70 delta = now - dev->power.accounting_timestamp; in update_pm_runtime_accounting()
72 dev->power.accounting_timestamp = now; in update_pm_runtime_accounting()
74 if (dev->power.disable_depth > 0) in update_pm_runtime_accounting()
77 if (dev->power.runtime_status == RPM_SUSPENDED) in update_pm_runtime_accounting()
78 dev->power.suspended_jiffies += delta; in update_pm_runtime_accounting()
80 dev->power.active_jiffies += delta; in update_pm_runtime_accounting()
86 dev->power.runtime_status = status; in __update_runtime_status()
95 if (dev->power.timer_expires > 0) { in pm_runtime_deactivate_timer()
96 del_timer(&dev->power.suspend_timer); in pm_runtime_deactivate_timer()
97 dev->power.timer_expires = 0; in pm_runtime_deactivate_timer()
112 dev->power.request = RPM_REQ_NONE; in pm_runtime_cancel_pending()
120 * power.last_busy time. If the delay has already expired or is disabled
121 * (negative) or the power.use_autosuspend flag isn't set, return 0.
124 * This function may be called either with or without dev->power.lock held.
125 * Either way it can be racy, since power.last_busy may be updated at any time.
134 if (!dev->power.use_autosuspend) in pm_runtime_autosuspend_expiration()
137 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); in pm_runtime_autosuspend_expiration()
141 last_busy = READ_ONCE(dev->power.last_busy); in pm_runtime_autosuspend_expiration()
164 return dev->power.memalloc_noio; in dev_memalloc_noio()
203 /* hold power lock since bitfield is not SMP-safe. */ in pm_runtime_set_memalloc_noio()
204 spin_lock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
205 enabled = dev->power.memalloc_noio; in pm_runtime_set_memalloc_noio()
206 dev->power.memalloc_noio = enable; in pm_runtime_set_memalloc_noio()
207 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
240 if (dev->power.runtime_error) in rpm_check_suspend_allowed()
242 else if (dev->power.disable_depth > 0) in rpm_check_suspend_allowed()
244 else if (atomic_read(&dev->power.usage_count) > 0) in rpm_check_suspend_allowed()
246 else if (!dev->power.ignore_children && in rpm_check_suspend_allowed()
247 atomic_read(&dev->power.child_count)) in rpm_check_suspend_allowed()
251 else if ((dev->power.deferred_resume in rpm_check_suspend_allowed()
252 && dev->power.runtime_status == RPM_SUSPENDING) in rpm_check_suspend_allowed()
253 || (dev->power.request_pending in rpm_check_suspend_allowed()
254 && dev->power.request == RPM_REQ_RESUME)) in rpm_check_suspend_allowed()
258 else if (dev->power.runtime_status == RPM_SUSPENDED) in rpm_check_suspend_allowed()
305 __releases(&dev->power.lock) __acquires(&dev->power.lock) in __rpm_callback()
308 bool use_links = dev->power.links_count > 0; in __rpm_callback()
310 if (dev->power.irq_safe) { in __rpm_callback()
311 spin_unlock(&dev->power.lock); in __rpm_callback()
313 spin_unlock_irq(&dev->power.lock); in __rpm_callback()
322 if (use_links && dev->power.runtime_status == RPM_RESUMING) { in __rpm_callback()
335 if (dev->power.irq_safe) { in __rpm_callback()
336 spin_lock(&dev->power.lock); in __rpm_callback()
346 && ((dev->power.runtime_status == RPM_SUSPENDING && !retval) in __rpm_callback()
347 || (dev->power.runtime_status == RPM_RESUMING && retval))) { in __rpm_callback()
356 spin_lock_irq(&dev->power.lock); in __rpm_callback()
373 * This function must be called under dev->power.lock with interrupts disabled.
386 else if (dev->power.runtime_status != RPM_ACTIVE) in rpm_idle()
393 else if (dev->power.request_pending && in rpm_idle()
394 dev->power.request > RPM_REQ_IDLE) in rpm_idle()
398 else if (dev->power.idle_notification) in rpm_idle()
404 dev->power.request = RPM_REQ_NONE; in rpm_idle()
406 if (dev->power.no_callbacks) in rpm_idle()
411 dev->power.request = RPM_REQ_IDLE; in rpm_idle()
412 if (!dev->power.request_pending) { in rpm_idle()
413 dev->power.request_pending = true; in rpm_idle()
414 queue_work(pm_wq, &dev->power.work); in rpm_idle()
420 dev->power.idle_notification = true; in rpm_idle()
427 dev->power.idle_notification = false; in rpm_idle()
428 wake_up_all(&dev->power.wait_queue); in rpm_idle()
447 if (dev->power.memalloc_noio) { in rpm_callback()
466 dev->power.runtime_error = retval; in rpm_callback()
484 * ignore_children of parent->power and irq_safe of dev->power are not set).
489 * This function must be called under dev->power.lock with interrupts disabled.
492 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_suspend()
507 else if (dev->power.runtime_status == RPM_RESUMING && in rpm_suspend()
515 && dev->power.runtime_status != RPM_SUSPENDING) { in rpm_suspend()
520 dev->power.request = RPM_REQ_NONE; in rpm_suspend()
529 if (!(dev->power.timer_expires && time_before_eq( in rpm_suspend()
530 dev->power.timer_expires, expires))) { in rpm_suspend()
531 dev->power.timer_expires = expires; in rpm_suspend()
532 mod_timer(&dev->power.suspend_timer, expires); in rpm_suspend()
534 dev->power.timer_autosuspends = 1; in rpm_suspend()
542 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_suspend()
550 if (dev->power.irq_safe) { in rpm_suspend()
551 spin_unlock(&dev->power.lock); in rpm_suspend()
555 spin_lock(&dev->power.lock); in rpm_suspend()
561 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_suspend()
563 if (dev->power.runtime_status != RPM_SUSPENDING) in rpm_suspend()
566 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
570 spin_lock_irq(&dev->power.lock); in rpm_suspend()
572 finish_wait(&dev->power.wait_queue, &wait); in rpm_suspend()
576 if (dev->power.no_callbacks) in rpm_suspend()
581 dev->power.request = (rpmflags & RPM_AUTO) ? in rpm_suspend()
583 if (!dev->power.request_pending) { in rpm_suspend()
584 dev->power.request_pending = true; in rpm_suspend()
585 queue_work(pm_wq, &dev->power.work); in rpm_suspend()
605 atomic_add_unless(&parent->power.child_count, -1, 0); in rpm_suspend()
607 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
609 if (dev->power.deferred_resume) { in rpm_suspend()
610 dev->power.deferred_resume = false; in rpm_suspend()
617 if (parent && !parent->power.ignore_children && !dev->power.irq_safe) { in rpm_suspend()
618 spin_unlock(&dev->power.lock); in rpm_suspend()
620 spin_lock(&parent->power.lock); in rpm_suspend()
622 spin_unlock(&parent->power.lock); in rpm_suspend()
624 spin_lock(&dev->power.lock); in rpm_suspend()
635 dev->power.deferred_resume = false; in rpm_suspend()
636 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
639 dev->power.runtime_error = 0; in rpm_suspend()
671 * This function must be called under dev->power.lock with interrupts disabled.
674 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_resume()
683 if (dev->power.runtime_error) in rpm_resume()
685 else if (dev->power.disable_depth == 1 && dev->power.is_suspended in rpm_resume()
686 && dev->power.runtime_status == RPM_ACTIVE) in rpm_resume()
688 else if (dev->power.disable_depth > 0) in rpm_resume()
699 dev->power.request = RPM_REQ_NONE; in rpm_resume()
700 if (!dev->power.timer_autosuspends) in rpm_resume()
703 if (dev->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
708 if (dev->power.runtime_status == RPM_RESUMING in rpm_resume()
709 || dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
713 if (dev->power.runtime_status == RPM_SUSPENDING) in rpm_resume()
714 dev->power.deferred_resume = true; in rpm_resume()
720 if (dev->power.irq_safe) { in rpm_resume()
721 spin_unlock(&dev->power.lock); in rpm_resume()
725 spin_lock(&dev->power.lock); in rpm_resume()
731 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_resume()
733 if (dev->power.runtime_status != RPM_RESUMING in rpm_resume()
734 && dev->power.runtime_status != RPM_SUSPENDING) in rpm_resume()
737 spin_unlock_irq(&dev->power.lock); in rpm_resume()
741 spin_lock_irq(&dev->power.lock); in rpm_resume()
743 finish_wait(&dev->power.wait_queue, &wait); in rpm_resume()
749 * power.no_callbacks is set, because otherwise we don't know whether in rpm_resume()
752 if (dev->power.no_callbacks && !parent && dev->parent) { in rpm_resume()
753 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING); in rpm_resume()
754 if (dev->parent->power.disable_depth > 0 in rpm_resume()
755 || dev->parent->power.ignore_children in rpm_resume()
756 || dev->parent->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
757 atomic_inc(&dev->parent->power.child_count); in rpm_resume()
758 spin_unlock(&dev->parent->power.lock); in rpm_resume()
762 spin_unlock(&dev->parent->power.lock); in rpm_resume()
767 dev->power.request = RPM_REQ_RESUME; in rpm_resume()
768 if (!dev->power.request_pending) { in rpm_resume()
769 dev->power.request_pending = true; in rpm_resume()
770 queue_work(pm_wq, &dev->power.work); in rpm_resume()
783 if (dev->power.irq_safe) in rpm_resume()
785 spin_unlock(&dev->power.lock); in rpm_resume()
789 spin_lock(&parent->power.lock); in rpm_resume()
794 if (!parent->power.disable_depth in rpm_resume()
795 && !parent->power.ignore_children) { in rpm_resume()
797 if (parent->power.runtime_status != RPM_ACTIVE) in rpm_resume()
800 spin_unlock(&parent->power.lock); in rpm_resume()
802 spin_lock(&dev->power.lock); in rpm_resume()
809 if (dev->power.no_callbacks) in rpm_resume()
827 atomic_inc(&parent->power.child_count); in rpm_resume()
829 wake_up_all(&dev->power.wait_queue); in rpm_resume()
835 if (parent && !dev->power.irq_safe) { in rpm_resume()
836 spin_unlock_irq(&dev->power.lock); in rpm_resume()
840 spin_lock_irq(&dev->power.lock); in rpm_resume()
857 struct device *dev = container_of(work, struct device, power.work); in pm_runtime_work()
860 spin_lock_irq(&dev->power.lock); in pm_runtime_work()
862 if (!dev->power.request_pending) in pm_runtime_work()
865 req = dev->power.request; in pm_runtime_work()
866 dev->power.request = RPM_REQ_NONE; in pm_runtime_work()
867 dev->power.request_pending = false; in pm_runtime_work()
887 spin_unlock_irq(&dev->power.lock); in pm_runtime_work()
898 struct device *dev = from_timer(dev, t, power.suspend_timer); in pm_suspend_timer_fn()
902 spin_lock_irqsave(&dev->power.lock, flags); in pm_suspend_timer_fn()
904 expires = dev->power.timer_expires; in pm_suspend_timer_fn()
907 dev->power.timer_expires = 0; in pm_suspend_timer_fn()
908 rpm_suspend(dev, dev->power.timer_autosuspends ? in pm_suspend_timer_fn()
912 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_suspend_timer_fn()
925 spin_lock_irqsave(&dev->power.lock, flags); in pm_schedule_suspend()
939 dev->power.timer_expires = jiffies + msecs_to_jiffies(delay); in pm_schedule_suspend()
940 dev->power.timer_expires += !dev->power.timer_expires; in pm_schedule_suspend()
941 dev->power.timer_autosuspends = 0; in pm_schedule_suspend()
942 mod_timer(&dev->power.suspend_timer, dev->power.timer_expires); in pm_schedule_suspend()
945 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_schedule_suspend()
969 if (!atomic_dec_and_test(&dev->power.usage_count)) in __pm_runtime_idle()
973 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_idle()
975 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_idle()
977 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_idle()
1001 if (!atomic_dec_and_test(&dev->power.usage_count)) in __pm_runtime_suspend()
1005 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_suspend()
1007 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_suspend()
1009 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_suspend()
1031 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe && in __pm_runtime_resume()
1032 dev->power.runtime_status != RPM_ACTIVE); in __pm_runtime_resume()
1035 atomic_inc(&dev->power.usage_count); in __pm_runtime_resume()
1037 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_resume()
1039 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_resume()
1060 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_get_if_in_use()
1061 retval = dev->power.disable_depth > 0 ? -EINVAL : in pm_runtime_get_if_in_use()
1062 dev->power.runtime_status == RPM_ACTIVE in pm_runtime_get_if_in_use()
1063 && atomic_inc_not_zero(&dev->power.usage_count); in pm_runtime_get_if_in_use()
1064 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_get_if_in_use()
1074 * If runtime PM of the device is disabled or its power.runtime_error field is
1078 * parent's power.ignore_children flag is unset, the device's status cannot be
1081 * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1096 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_set_status()
1098 if (!dev->power.runtime_error && !dev->power.disable_depth) { in __pm_runtime_set_status()
1103 if (dev->power.runtime_status == status || !parent) in __pm_runtime_set_status()
1107 atomic_add_unless(&parent->power.child_count, -1, 0); in __pm_runtime_set_status()
1108 notify_parent = !parent->power.ignore_children; in __pm_runtime_set_status()
1110 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING); in __pm_runtime_set_status()
1115 * 'power.ignore_children' flag unset. in __pm_runtime_set_status()
1117 if (!parent->power.disable_depth in __pm_runtime_set_status()
1118 && !parent->power.ignore_children in __pm_runtime_set_status()
1119 && parent->power.runtime_status != RPM_ACTIVE) { in __pm_runtime_set_status()
1124 } else if (dev->power.runtime_status == RPM_SUSPENDED) { in __pm_runtime_set_status()
1125 atomic_inc(&parent->power.child_count); in __pm_runtime_set_status()
1128 spin_unlock(&parent->power.lock); in __pm_runtime_set_status()
1136 dev->power.runtime_error = 0; in __pm_runtime_set_status()
1138 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_set_status()
1154 * Should be called under dev->power.lock with interrupts disabled.
1160 if (dev->power.request_pending) { in __pm_runtime_barrier()
1161 dev->power.request = RPM_REQ_NONE; in __pm_runtime_barrier()
1162 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1164 cancel_work_sync(&dev->power.work); in __pm_runtime_barrier()
1166 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1167 dev->power.request_pending = false; in __pm_runtime_barrier()
1170 if (dev->power.runtime_status == RPM_SUSPENDING in __pm_runtime_barrier()
1171 || dev->power.runtime_status == RPM_RESUMING in __pm_runtime_barrier()
1172 || dev->power.idle_notification) { in __pm_runtime_barrier()
1177 prepare_to_wait(&dev->power.wait_queue, &wait, in __pm_runtime_barrier()
1179 if (dev->power.runtime_status != RPM_SUSPENDING in __pm_runtime_barrier()
1180 && dev->power.runtime_status != RPM_RESUMING in __pm_runtime_barrier()
1181 && !dev->power.idle_notification) in __pm_runtime_barrier()
1183 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1187 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1189 finish_wait(&dev->power.wait_queue, &wait); in __pm_runtime_barrier()
1212 spin_lock_irq(&dev->power.lock); in pm_runtime_barrier()
1214 if (dev->power.request_pending in pm_runtime_barrier()
1215 && dev->power.request == RPM_REQ_RESUME) { in pm_runtime_barrier()
1222 spin_unlock_irq(&dev->power.lock); in pm_runtime_barrier()
1234 * Increment power.disable_depth for the device and if it was zero previously,
1240 * __pm_runtime_disable() is called and power.disable_depth is zero, the
1245 spin_lock_irq(&dev->power.lock); in __pm_runtime_disable()
1247 if (dev->power.disable_depth > 0) { in __pm_runtime_disable()
1248 dev->power.disable_depth++; in __pm_runtime_disable()
1257 if (check_resume && dev->power.request_pending in __pm_runtime_disable()
1258 && dev->power.request == RPM_REQ_RESUME) { in __pm_runtime_disable()
1270 if (!dev->power.disable_depth++) in __pm_runtime_disable()
1274 spin_unlock_irq(&dev->power.lock); in __pm_runtime_disable()
1286 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_enable()
1288 if (dev->power.disable_depth > 0) in pm_runtime_enable()
1289 dev->power.disable_depth--; in pm_runtime_enable()
1293 WARN(!dev->power.disable_depth && in pm_runtime_enable()
1294 dev->power.runtime_status == RPM_SUSPENDED && in pm_runtime_enable()
1295 !dev->power.ignore_children && in pm_runtime_enable()
1296 atomic_read(&dev->power.child_count) > 0, in pm_runtime_enable()
1300 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_enable()
1308 * Increase the device's usage count and clear its power.runtime_auto flag,
1314 spin_lock_irq(&dev->power.lock); in pm_runtime_forbid()
1315 if (!dev->power.runtime_auto) in pm_runtime_forbid()
1318 dev->power.runtime_auto = false; in pm_runtime_forbid()
1319 atomic_inc(&dev->power.usage_count); in pm_runtime_forbid()
1323 spin_unlock_irq(&dev->power.lock); in pm_runtime_forbid()
1331 * Decrease the device's usage count and set its power.runtime_auto flag.
1335 spin_lock_irq(&dev->power.lock); in pm_runtime_allow()
1336 if (dev->power.runtime_auto) in pm_runtime_allow()
1339 dev->power.runtime_auto = true; in pm_runtime_allow()
1340 if (atomic_dec_and_test(&dev->power.usage_count)) in pm_runtime_allow()
1344 spin_unlock_irq(&dev->power.lock); in pm_runtime_allow()
1352 * Set the power.no_callbacks flag, which tells the PM core that this
1353 * device is power-managed through its parent and has no runtime PM
1358 spin_lock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1359 dev->power.no_callbacks = 1; in pm_runtime_no_callbacks()
1360 spin_unlock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1370 * Set the power.irq_safe flag, which tells the PM core that the
1381 spin_lock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1382 dev->power.irq_safe = 1; in pm_runtime_irq_safe()
1383 spin_unlock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1396 * This function must be called under dev->power.lock with interrupts disabled.
1400 int delay = dev->power.autosuspend_delay; in update_autosuspend()
1403 if (dev->power.use_autosuspend && delay < 0) { in update_autosuspend()
1407 atomic_inc(&dev->power.usage_count); in update_autosuspend()
1417 atomic_dec(&dev->power.usage_count); in update_autosuspend()
1429 * Set the device's power.autosuspend_delay value. If it changes to negative
1430 * and the power.use_autosuspend flag is set, prevent runtime suspends. If it
1437 spin_lock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1438 old_delay = dev->power.autosuspend_delay; in pm_runtime_set_autosuspend_delay()
1439 old_use = dev->power.use_autosuspend; in pm_runtime_set_autosuspend_delay()
1440 dev->power.autosuspend_delay = delay; in pm_runtime_set_autosuspend_delay()
1442 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1451 * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1458 spin_lock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1459 old_delay = dev->power.autosuspend_delay; in __pm_runtime_use_autosuspend()
1460 old_use = dev->power.use_autosuspend; in __pm_runtime_use_autosuspend()
1461 dev->power.use_autosuspend = use; in __pm_runtime_use_autosuspend()
1463 spin_unlock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1473 dev->power.runtime_status = RPM_SUSPENDED; in pm_runtime_init()
1474 dev->power.idle_notification = false; in pm_runtime_init()
1476 dev->power.disable_depth = 1; in pm_runtime_init()
1477 atomic_set(&dev->power.usage_count, 0); in pm_runtime_init()
1479 dev->power.runtime_error = 0; in pm_runtime_init()
1481 atomic_set(&dev->power.child_count, 0); in pm_runtime_init()
1483 dev->power.runtime_auto = true; in pm_runtime_init()
1485 dev->power.request_pending = false; in pm_runtime_init()
1486 dev->power.request = RPM_REQ_NONE; in pm_runtime_init()
1487 dev->power.deferred_resume = false; in pm_runtime_init()
1488 dev->power.accounting_timestamp = jiffies; in pm_runtime_init()
1489 INIT_WORK(&dev->power.work, pm_runtime_work); in pm_runtime_init()
1491 dev->power.timer_expires = 0; in pm_runtime_init()
1492 timer_setup(&dev->power.suspend_timer, pm_suspend_timer_fn, 0); in pm_runtime_init()
1494 init_waitqueue_head(&dev->power.wait_queue); in pm_runtime_init()
1504 if (dev->power.runtime_status == RPM_ACTIVE) in pm_runtime_reinit()
1506 if (dev->power.irq_safe) { in pm_runtime_reinit()
1507 spin_lock_irq(&dev->power.lock); in pm_runtime_reinit()
1508 dev->power.irq_safe = 0; in pm_runtime_reinit()
1509 spin_unlock_irq(&dev->power.lock); in pm_runtime_reinit()
1605 spin_lock_irq(&dev->power.lock); in pm_runtime_new_link()
1606 dev->power.links_count++; in pm_runtime_new_link()
1607 spin_unlock_irq(&dev->power.lock); in pm_runtime_new_link()
1612 spin_lock_irq(&dev->power.lock); in pm_runtime_drop_link()
1613 WARN_ON(dev->power.links_count == 0); in pm_runtime_drop_link()
1614 dev->power.links_count--; in pm_runtime_drop_link()
1615 spin_unlock_irq(&dev->power.lock); in pm_runtime_drop_link()
1620 return atomic_read(&dev->power.usage_count) <= 1 && in pm_runtime_need_not_resume()
1621 (atomic_read(&dev->power.child_count) == 0 || in pm_runtime_need_not_resume()
1622 dev->power.ignore_children); in pm_runtime_need_not_resume()
1638 * sure the device is put into low power state and it should only be used during
1681 * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1682 * those actions and bring the device into full power, if it is expected to be