Lines Matching +full:autosuspend +full:- +full:delay
1 // SPDX-License-Identifier: GPL-2.0
3 * drivers/base/power/runtime.c - Helper functions for device runtime PM
26 if (dev->pm_domain) in __rpm_get_callback()
27 ops = &dev->pm_domain->ops; in __rpm_get_callback()
28 else if (dev->type && dev->type->pm) in __rpm_get_callback()
29 ops = dev->type->pm; in __rpm_get_callback()
30 else if (dev->class && dev->class->pm) in __rpm_get_callback()
31 ops = dev->class->pm; in __rpm_get_callback()
32 else if (dev->bus && dev->bus->pm) in __rpm_get_callback()
33 ops = dev->bus->pm; in __rpm_get_callback()
42 if (!cb && dev->driver && dev->driver->pm) in __rpm_get_callback()
43 cb = *(pm_callback_t *)((void *)dev->driver->pm + cb_offset); in __rpm_get_callback()
55 * update_pm_runtime_accounting - Update the time accounting of 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()
85 delta = now - last; 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()
126 * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
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()
138 * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
148 dev->power.request = RPM_REQ_NONE; in pm_runtime_cancel_pending()
152 * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
155 * Compute the autosuspend-delay expiration time based on the device's
156 * power.last_busy time. If the delay has already expired or is disabled
160 * This function may be called either with or without dev->power.lock held.
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()
190 * pm_runtime_set_memalloc_noio - Set a device's memalloc_noio flag.
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()
238 dev = dev->parent; in pm_runtime_set_memalloc_noio()
255 * rpm_check_suspend_allowed - Test whether a device may be suspended.
262 if (dev->power.runtime_error) in rpm_check_suspend_allowed()
263 retval = -EINVAL; in rpm_check_suspend_allowed()
264 else if (dev->power.disable_depth > 0) in rpm_check_suspend_allowed()
265 retval = -EACCES; in rpm_check_suspend_allowed()
266 else if (atomic_read(&dev->power.usage_count) > 0) in rpm_check_suspend_allowed()
267 retval = -EAGAIN; 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()
270 retval = -EBUSY; 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()
277 retval = -EAGAIN; in rpm_check_suspend_allowed()
279 retval = -EPERM; in rpm_check_suspend_allowed()
280 else if (dev->power.runtime_status == RPM_SUSPENDED) in rpm_check_suspend_allowed()
290 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_get_suppliers()
294 if (!(link->flags & DL_FLAG_PM_RUNTIME) || in rpm_get_suppliers()
295 READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) in rpm_get_suppliers()
298 retval = pm_runtime_get_sync(link->supplier); in rpm_get_suppliers()
300 if (retval < 0 && retval != -EACCES) { in rpm_get_suppliers()
301 pm_runtime_put_noidle(link->supplier); in rpm_get_suppliers()
304 refcount_inc(&link->rpm_active); in rpm_get_suppliers()
313 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_put_suppliers()
315 if (READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) in rpm_put_suppliers()
318 while (refcount_dec_not_one(&link->rpm_active)) in rpm_put_suppliers()
319 pm_runtime_put(link->supplier); in rpm_put_suppliers()
324 * __rpm_callback - Run a given runtime PM callback for a given device.
329 __releases(&dev->power.lock) __acquires(&dev->power.lock) in __rpm_callback()
332 bool use_links = dev->power.links_count > 0; in __rpm_callback()
334 if (dev->power.irq_safe) { in __rpm_callback()
335 spin_unlock(&dev->power.lock); in __rpm_callback()
337 spin_unlock_irq(&dev->power.lock); in __rpm_callback()
346 if (use_links && dev->power.runtime_status == RPM_RESUMING) { in __rpm_callback()
359 if (dev->power.irq_safe) { in __rpm_callback()
360 spin_lock(&dev->power.lock); in __rpm_callback()
370 && ((dev->power.runtime_status == RPM_SUSPENDING && !retval) in __rpm_callback()
371 || (dev->power.runtime_status == RPM_RESUMING && retval))) { in __rpm_callback()
380 spin_lock_irq(&dev->power.lock); in __rpm_callback()
387 * rpm_idle - Notify device bus type if the device can be suspended.
393 * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
394 * run the ->runtime_idle() callback directly. If the ->runtime_idle callback
397 * This function must be called under dev->power.lock with interrupts disabled.
410 else if (dev->power.runtime_status != RPM_ACTIVE) in rpm_idle()
411 retval = -EAGAIN; in rpm_idle()
417 else if (dev->power.request_pending && in rpm_idle()
418 dev->power.request > RPM_REQ_IDLE) in rpm_idle()
419 retval = -EAGAIN; in rpm_idle()
422 else if (dev->power.idle_notification) in rpm_idle()
423 retval = -EINPROGRESS; in rpm_idle()
428 dev->power.request = RPM_REQ_NONE; in rpm_idle()
430 if (dev->power.no_callbacks) in rpm_idle()
435 dev->power.request = RPM_REQ_IDLE; in rpm_idle()
436 if (!dev->power.request_pending) { in rpm_idle()
437 dev->power.request_pending = true; in rpm_idle()
438 queue_work(pm_wq, &dev->power.work); in rpm_idle()
444 dev->power.idle_notification = true; in rpm_idle()
451 dev->power.idle_notification = false; in rpm_idle()
452 wake_up_all(&dev->power.wait_queue); in rpm_idle()
460 * rpm_callback - Run a given runtime PM callback for a given device.
469 return -ENOSYS; in rpm_callback()
471 if (dev->power.memalloc_noio) { in rpm_callback()
490 dev->power.runtime_error = retval; in rpm_callback()
491 return retval != -EACCES ? retval : -EIO; in rpm_callback()
495 * rpm_suspend - Carry out runtime suspend of given device.
500 * Cancel a pending idle notification, autosuspend or suspend. If
504 * otherwise run the ->runtime_suspend() callback directly. When
505 * ->runtime_suspend succeeded, if a deferred resume was requested while
508 * ignore_children of parent->power and irq_safe of dev->power are not set).
509 * If ->runtime_suspend failed with -EAGAIN or -EBUSY, and if the RPM_AUTO
510 * flag is set and the next autosuspend-delay expiration time is in the
511 * future, schedule another autosuspend attempt.
513 * This function must be called under dev->power.lock with interrupts disabled.
516 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_suspend()
531 else if (dev->power.runtime_status == RPM_RESUMING && in rpm_suspend()
533 retval = -EAGAIN; in rpm_suspend()
539 && dev->power.runtime_status != RPM_SUSPENDING) { in rpm_suspend()
544 dev->power.request = RPM_REQ_NONE; in rpm_suspend()
548 * set to expire at or before the autosuspend delay, in rpm_suspend()
553 if (!(dev->power.timer_expires && in rpm_suspend()
554 dev->power.timer_expires <= expires)) { in rpm_suspend()
559 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) * in rpm_suspend()
562 dev->power.timer_expires = expires; in rpm_suspend()
563 hrtimer_start_range_ns(&dev->power.suspend_timer, in rpm_suspend()
568 dev->power.timer_autosuspends = 1; in rpm_suspend()
576 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_suspend()
580 retval = -EINPROGRESS; in rpm_suspend()
584 if (dev->power.irq_safe) { in rpm_suspend()
585 spin_unlock(&dev->power.lock); in rpm_suspend()
589 spin_lock(&dev->power.lock); in rpm_suspend()
595 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_suspend()
597 if (dev->power.runtime_status != RPM_SUSPENDING) in rpm_suspend()
600 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
604 spin_lock_irq(&dev->power.lock); in rpm_suspend()
606 finish_wait(&dev->power.wait_queue, &wait); in rpm_suspend()
610 if (dev->power.no_callbacks) in rpm_suspend()
615 dev->power.request = (rpmflags & RPM_AUTO) ? in rpm_suspend()
617 if (!dev->power.request_pending) { in rpm_suspend()
618 dev->power.request_pending = true; in rpm_suspend()
619 queue_work(pm_wq, &dev->power.work); in rpm_suspend()
637 if (dev->parent) { in rpm_suspend()
638 parent = dev->parent; in rpm_suspend()
639 atomic_add_unless(&parent->power.child_count, -1, 0); in rpm_suspend()
641 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
643 if (dev->power.deferred_resume) { in rpm_suspend()
644 dev->power.deferred_resume = false; in rpm_suspend()
646 retval = -EAGAIN; in rpm_suspend()
651 if (parent && !parent->power.ignore_children && !dev->power.irq_safe) { in rpm_suspend()
652 spin_unlock(&dev->power.lock); in rpm_suspend()
654 spin_lock(&parent->power.lock); in rpm_suspend()
656 spin_unlock(&parent->power.lock); in rpm_suspend()
658 spin_lock(&dev->power.lock); in rpm_suspend()
669 dev->power.deferred_resume = false; in rpm_suspend()
670 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
672 if (retval == -EAGAIN || retval == -EBUSY) { in rpm_suspend()
673 dev->power.runtime_error = 0; in rpm_suspend()
676 * If the callback routine failed an autosuspend, and in rpm_suspend()
678 * is a new autosuspend expiration time, automatically in rpm_suspend()
679 * reschedule another autosuspend. in rpm_suspend()
691 * rpm_resume - Carry out runtime resume of given device.
702 * ->runtime_resume() callback directly. Queue an idle notification for the
705 * This function must be called under dev->power.lock with interrupts disabled.
708 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_resume()
717 if (dev->power.runtime_error) in rpm_resume()
718 retval = -EINVAL; in rpm_resume()
719 else if (dev->power.disable_depth == 1 && dev->power.is_suspended in rpm_resume()
720 && dev->power.runtime_status == RPM_ACTIVE) in rpm_resume()
722 else if (dev->power.disable_depth > 0) in rpm_resume()
723 retval = -EACCES; in rpm_resume()
729 * optimization: If an autosuspend timer is running, leave it running in rpm_resume()
733 dev->power.request = RPM_REQ_NONE; in rpm_resume()
734 if (!dev->power.timer_autosuspends) in rpm_resume()
737 if (dev->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
742 if (dev->power.runtime_status == RPM_RESUMING in rpm_resume()
743 || dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
747 if (dev->power.runtime_status == RPM_SUSPENDING) in rpm_resume()
748 dev->power.deferred_resume = true; in rpm_resume()
750 retval = -EINPROGRESS; in rpm_resume()
754 if (dev->power.irq_safe) { in rpm_resume()
755 spin_unlock(&dev->power.lock); in rpm_resume()
759 spin_lock(&dev->power.lock); in rpm_resume()
765 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_resume()
767 if (dev->power.runtime_status != RPM_RESUMING in rpm_resume()
768 && dev->power.runtime_status != RPM_SUSPENDING) in rpm_resume()
771 spin_unlock_irq(&dev->power.lock); in rpm_resume()
775 spin_lock_irq(&dev->power.lock); in rpm_resume()
777 finish_wait(&dev->power.wait_queue, &wait); in rpm_resume()
786 if (dev->power.no_callbacks && !parent && dev->parent) { in rpm_resume()
787 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING); in rpm_resume()
788 if (dev->parent->power.disable_depth > 0 in rpm_resume()
789 || dev->parent->power.ignore_children in rpm_resume()
790 || dev->parent->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
791 atomic_inc(&dev->parent->power.child_count); in rpm_resume()
792 spin_unlock(&dev->parent->power.lock); in rpm_resume()
796 spin_unlock(&dev->parent->power.lock); in rpm_resume()
801 dev->power.request = RPM_REQ_RESUME; in rpm_resume()
802 if (!dev->power.request_pending) { in rpm_resume()
803 dev->power.request_pending = true; in rpm_resume()
804 queue_work(pm_wq, &dev->power.work); in rpm_resume()
810 if (!parent && dev->parent) { in rpm_resume()
813 * necessary. Not needed if dev is irq-safe; then the in rpm_resume()
816 parent = dev->parent; in rpm_resume()
817 if (dev->power.irq_safe) in rpm_resume()
819 spin_unlock(&dev->power.lock); in rpm_resume()
823 spin_lock(&parent->power.lock); in rpm_resume()
828 if (!parent->power.disable_depth in rpm_resume()
829 && !parent->power.ignore_children) { in rpm_resume()
831 if (parent->power.runtime_status != RPM_ACTIVE) in rpm_resume()
832 retval = -EBUSY; in rpm_resume()
834 spin_unlock(&parent->power.lock); in rpm_resume()
836 spin_lock(&dev->power.lock); in rpm_resume()
843 if (dev->power.no_callbacks) in rpm_resume()
861 atomic_inc(&parent->power.child_count); in rpm_resume()
863 wake_up_all(&dev->power.wait_queue); in rpm_resume()
869 if (parent && !dev->power.irq_safe) { in rpm_resume()
870 spin_unlock_irq(&dev->power.lock); in rpm_resume()
874 spin_lock_irq(&dev->power.lock); in rpm_resume()
883 * pm_runtime_work - Universal runtime PM work function.
894 spin_lock_irq(&dev->power.lock); in pm_runtime_work()
896 if (!dev->power.request_pending) in pm_runtime_work()
899 req = dev->power.request; in pm_runtime_work()
900 dev->power.request = RPM_REQ_NONE; in pm_runtime_work()
901 dev->power.request_pending = false; in pm_runtime_work()
921 spin_unlock_irq(&dev->power.lock); in pm_runtime_work()
925 * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
936 spin_lock_irqsave(&dev->power.lock, flags); in pm_suspend_timer_fn()
938 expires = dev->power.timer_expires; in pm_suspend_timer_fn()
944 dev->power.timer_expires = 0; in pm_suspend_timer_fn()
945 rpm_suspend(dev, dev->power.timer_autosuspends ? in pm_suspend_timer_fn()
949 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_suspend_timer_fn()
955 * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
957 * @delay: Time to wait before submitting a suspend request, in milliseconds.
959 int pm_schedule_suspend(struct device *dev, unsigned int delay) in pm_schedule_suspend() argument
965 spin_lock_irqsave(&dev->power.lock, flags); in pm_schedule_suspend()
967 if (!delay) { in pm_schedule_suspend()
979 expires = ktime_get_mono_fast_ns() + (u64)delay * NSEC_PER_MSEC; in pm_schedule_suspend()
980 dev->power.timer_expires = expires; in pm_schedule_suspend()
981 dev->power.timer_autosuspends = 0; in pm_schedule_suspend()
982 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS); in pm_schedule_suspend()
985 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_schedule_suspend()
992 * __pm_runtime_idle - Entry point for runtime idle operations.
1009 if (!atomic_dec_and_test(&dev->power.usage_count)) in __pm_runtime_idle()
1013 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_idle()
1015 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_idle()
1017 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_idle()
1024 * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
1041 if (!atomic_dec_and_test(&dev->power.usage_count)) in __pm_runtime_suspend()
1045 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_suspend()
1047 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_suspend()
1049 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_suspend()
1056 * __pm_runtime_resume - Entry point for runtime resume operations.
1071 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe && in __pm_runtime_resume()
1072 dev->power.runtime_status != RPM_ACTIVE); in __pm_runtime_resume()
1075 atomic_inc(&dev->power.usage_count); in __pm_runtime_resume()
1077 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_resume()
1079 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_resume()
1086 * pm_runtime_get_if_in_use - Conditionally bump up the device's usage counter.
1089 * Return -EINVAL if runtime PM is disabled for the device.
1100 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_get_if_in_use()
1101 retval = dev->power.disable_depth > 0 ? -EINVAL : in pm_runtime_get_if_in_use()
1102 dev->power.runtime_status == RPM_ACTIVE in pm_runtime_get_if_in_use()
1103 && atomic_inc_not_zero(&dev->power.usage_count); in pm_runtime_get_if_in_use()
1104 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_get_if_in_use()
1110 * __pm_runtime_set_status - Set runtime PM status of a device.
1119 * set to RPM_ACTIVE, so -EBUSY is returned in that case.
1135 struct device *parent = dev->parent; in __pm_runtime_set_status()
1140 return -EINVAL; in __pm_runtime_set_status()
1142 spin_lock_irq(&dev->power.lock); in __pm_runtime_set_status()
1145 * Prevent PM-runtime from being enabled for the device or return an in __pm_runtime_set_status()
1148 if (dev->power.runtime_error || dev->power.disable_depth) in __pm_runtime_set_status()
1149 dev->power.disable_depth++; in __pm_runtime_set_status()
1151 error = -EAGAIN; in __pm_runtime_set_status()
1153 spin_unlock_irq(&dev->power.lock); in __pm_runtime_set_status()
1174 spin_lock_irq(&dev->power.lock); in __pm_runtime_set_status()
1176 if (dev->power.runtime_status == status || !parent) in __pm_runtime_set_status()
1180 atomic_add_unless(&parent->power.child_count, -1, 0); in __pm_runtime_set_status()
1181 notify_parent = !parent->power.ignore_children; in __pm_runtime_set_status()
1183 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING); in __pm_runtime_set_status()
1190 if (!parent->power.disable_depth in __pm_runtime_set_status()
1191 && !parent->power.ignore_children in __pm_runtime_set_status()
1192 && parent->power.runtime_status != RPM_ACTIVE) { in __pm_runtime_set_status()
1196 error = -EBUSY; in __pm_runtime_set_status()
1197 } else if (dev->power.runtime_status == RPM_SUSPENDED) { in __pm_runtime_set_status()
1198 atomic_inc(&parent->power.child_count); in __pm_runtime_set_status()
1201 spin_unlock(&parent->power.lock); in __pm_runtime_set_status()
1212 dev->power.runtime_error = 0; in __pm_runtime_set_status()
1215 spin_unlock_irq(&dev->power.lock); in __pm_runtime_set_status()
1235 * __pm_runtime_barrier - Cancel pending requests and wait for completions.
1241 * Should be called under dev->power.lock with interrupts disabled.
1247 if (dev->power.request_pending) { in __pm_runtime_barrier()
1248 dev->power.request = RPM_REQ_NONE; in __pm_runtime_barrier()
1249 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1251 cancel_work_sync(&dev->power.work); in __pm_runtime_barrier()
1253 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1254 dev->power.request_pending = false; in __pm_runtime_barrier()
1257 if (dev->power.runtime_status == RPM_SUSPENDING in __pm_runtime_barrier()
1258 || dev->power.runtime_status == RPM_RESUMING in __pm_runtime_barrier()
1259 || dev->power.idle_notification) { in __pm_runtime_barrier()
1262 /* Suspend, wake-up or idle notification in progress. */ in __pm_runtime_barrier()
1264 prepare_to_wait(&dev->power.wait_queue, &wait, in __pm_runtime_barrier()
1266 if (dev->power.runtime_status != RPM_SUSPENDING in __pm_runtime_barrier()
1267 && dev->power.runtime_status != RPM_RESUMING in __pm_runtime_barrier()
1268 && !dev->power.idle_notification) in __pm_runtime_barrier()
1270 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1274 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1276 finish_wait(&dev->power.wait_queue, &wait); in __pm_runtime_barrier()
1281 * pm_runtime_barrier - Flush pending requests and wait for completions.
1299 spin_lock_irq(&dev->power.lock); in pm_runtime_barrier()
1301 if (dev->power.request_pending in pm_runtime_barrier()
1302 && dev->power.request == RPM_REQ_RESUME) { in pm_runtime_barrier()
1309 spin_unlock_irq(&dev->power.lock); in pm_runtime_barrier()
1317 * __pm_runtime_disable - Disable runtime PM of a device.
1332 spin_lock_irq(&dev->power.lock); in __pm_runtime_disable()
1334 if (dev->power.disable_depth > 0) { in __pm_runtime_disable()
1335 dev->power.disable_depth++; in __pm_runtime_disable()
1344 if (check_resume && dev->power.request_pending in __pm_runtime_disable()
1345 && dev->power.request == RPM_REQ_RESUME) { in __pm_runtime_disable()
1357 /* Update time accounting before disabling PM-runtime. */ in __pm_runtime_disable()
1360 if (!dev->power.disable_depth++) in __pm_runtime_disable()
1364 spin_unlock_irq(&dev->power.lock); in __pm_runtime_disable()
1369 * pm_runtime_enable - Enable runtime PM of a device.
1376 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_enable()
1378 if (dev->power.disable_depth > 0) { in pm_runtime_enable()
1379 dev->power.disable_depth--; in pm_runtime_enable()
1382 if (!dev->power.disable_depth) in pm_runtime_enable()
1383 dev->power.accounting_timestamp = ktime_get_mono_fast_ns(); in pm_runtime_enable()
1388 WARN(!dev->power.disable_depth && in pm_runtime_enable()
1389 dev->power.runtime_status == RPM_SUSPENDED && in pm_runtime_enable()
1390 !dev->power.ignore_children && in pm_runtime_enable()
1391 atomic_read(&dev->power.child_count) > 0, in pm_runtime_enable()
1395 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_enable()
1400 * pm_runtime_forbid - Block runtime PM of a device.
1409 spin_lock_irq(&dev->power.lock); in pm_runtime_forbid()
1410 if (!dev->power.runtime_auto) in pm_runtime_forbid()
1413 dev->power.runtime_auto = false; in pm_runtime_forbid()
1414 atomic_inc(&dev->power.usage_count); in pm_runtime_forbid()
1418 spin_unlock_irq(&dev->power.lock); in pm_runtime_forbid()
1423 * pm_runtime_allow - Unblock runtime PM of a device.
1430 spin_lock_irq(&dev->power.lock); in pm_runtime_allow()
1431 if (dev->power.runtime_auto) in pm_runtime_allow()
1434 dev->power.runtime_auto = true; in pm_runtime_allow()
1435 if (atomic_dec_and_test(&dev->power.usage_count)) in pm_runtime_allow()
1439 spin_unlock_irq(&dev->power.lock); in pm_runtime_allow()
1444 * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
1448 * device is power-managed through its parent and has no runtime PM
1453 spin_lock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1454 dev->power.no_callbacks = 1; in pm_runtime_no_callbacks()
1455 spin_unlock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1462 * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1466 * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1469 * the parent from runtime suspending -- otherwise an irq-safe child might have
1470 * to wait for a non-irq-safe parent.
1474 if (dev->parent) in pm_runtime_irq_safe()
1475 pm_runtime_get_sync(dev->parent); in pm_runtime_irq_safe()
1476 spin_lock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1477 dev->power.irq_safe = 1; in pm_runtime_irq_safe()
1478 spin_unlock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1483 * update_autosuspend - Handle a change to a device's autosuspend settings.
1488 * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1491 * This function must be called under dev->power.lock with interrupts disabled.
1495 int delay = dev->power.autosuspend_delay; in update_autosuspend() local
1498 if (dev->power.use_autosuspend && delay < 0) { in update_autosuspend()
1502 atomic_inc(&dev->power.usage_count); in update_autosuspend()
1512 atomic_dec(&dev->power.usage_count); in update_autosuspend()
1514 /* Maybe we can autosuspend now. */ in update_autosuspend()
1520 * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1522 * @delay: Value of the new delay in milliseconds.
1528 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay) in pm_runtime_set_autosuspend_delay() argument
1532 spin_lock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1533 old_delay = dev->power.autosuspend_delay; in pm_runtime_set_autosuspend_delay()
1534 old_use = dev->power.use_autosuspend; in pm_runtime_set_autosuspend_delay()
1535 dev->power.autosuspend_delay = delay; in pm_runtime_set_autosuspend_delay()
1537 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1542 * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1553 spin_lock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1554 old_delay = dev->power.autosuspend_delay; in __pm_runtime_use_autosuspend()
1555 old_use = dev->power.use_autosuspend; in __pm_runtime_use_autosuspend()
1556 dev->power.use_autosuspend = use; in __pm_runtime_use_autosuspend()
1558 spin_unlock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1563 * pm_runtime_init - Initialize runtime PM fields in given device object.
1568 dev->power.runtime_status = RPM_SUSPENDED; in pm_runtime_init()
1569 dev->power.idle_notification = false; in pm_runtime_init()
1571 dev->power.disable_depth = 1; in pm_runtime_init()
1572 atomic_set(&dev->power.usage_count, 0); in pm_runtime_init()
1574 dev->power.runtime_error = 0; in pm_runtime_init()
1576 atomic_set(&dev->power.child_count, 0); in pm_runtime_init()
1578 dev->power.runtime_auto = true; in pm_runtime_init()
1580 dev->power.request_pending = false; in pm_runtime_init()
1581 dev->power.request = RPM_REQ_NONE; in pm_runtime_init()
1582 dev->power.deferred_resume = false; in pm_runtime_init()
1583 INIT_WORK(&dev->power.work, pm_runtime_work); in pm_runtime_init()
1585 dev->power.timer_expires = 0; in pm_runtime_init()
1586 hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); in pm_runtime_init()
1587 dev->power.suspend_timer.function = pm_suspend_timer_fn; in pm_runtime_init()
1589 init_waitqueue_head(&dev->power.wait_queue); in pm_runtime_init()
1593 * pm_runtime_reinit - Re-initialize runtime PM fields in given device object.
1594 * @dev: Device object to re-initialize.
1599 if (dev->power.runtime_status == RPM_ACTIVE) in pm_runtime_reinit()
1601 if (dev->power.irq_safe) { in pm_runtime_reinit()
1602 spin_lock_irq(&dev->power.lock); in pm_runtime_reinit()
1603 dev->power.irq_safe = 0; in pm_runtime_reinit()
1604 spin_unlock_irq(&dev->power.lock); in pm_runtime_reinit()
1605 if (dev->parent) in pm_runtime_reinit()
1606 pm_runtime_put(dev->parent); in pm_runtime_reinit()
1612 * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1622 * pm_runtime_clean_up_links - Prepare links to consumers for driver removal.
1631 * Since the device is guaranteed to be runtime-active at the point this is
1645 list_for_each_entry_rcu(link, &dev->links.consumers, s_node, in pm_runtime_clean_up_links()
1647 if (!(link->flags & DL_FLAG_MANAGED)) in pm_runtime_clean_up_links()
1650 while (refcount_dec_not_one(&link->rpm_active)) in pm_runtime_clean_up_links()
1658 * pm_runtime_get_suppliers - Resume and reference-count supplier devices.
1668 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in pm_runtime_get_suppliers()
1670 if (link->flags & DL_FLAG_PM_RUNTIME) { in pm_runtime_get_suppliers()
1671 link->supplier_preactivated = true; in pm_runtime_get_suppliers()
1672 refcount_inc(&link->rpm_active); in pm_runtime_get_suppliers()
1673 pm_runtime_get_sync(link->supplier); in pm_runtime_get_suppliers()
1680 * pm_runtime_put_suppliers - Drop references to supplier devices.
1690 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in pm_runtime_put_suppliers()
1692 if (link->supplier_preactivated) { in pm_runtime_put_suppliers()
1693 link->supplier_preactivated = false; in pm_runtime_put_suppliers()
1694 if (refcount_dec_not_one(&link->rpm_active)) in pm_runtime_put_suppliers()
1695 pm_runtime_put(link->supplier); in pm_runtime_put_suppliers()
1703 spin_lock_irq(&dev->power.lock); in pm_runtime_new_link()
1704 dev->power.links_count++; in pm_runtime_new_link()
1705 spin_unlock_irq(&dev->power.lock); in pm_runtime_new_link()
1710 spin_lock_irq(&dev->power.lock); in pm_runtime_drop_link()
1711 WARN_ON(dev->power.links_count == 0); in pm_runtime_drop_link()
1712 dev->power.links_count--; in pm_runtime_drop_link()
1713 spin_unlock_irq(&dev->power.lock); in pm_runtime_drop_link()
1718 return atomic_read(&dev->power.usage_count) <= 1 && in pm_runtime_need_not_resume()
1719 (atomic_read(&dev->power.child_count) == 0 || in pm_runtime_need_not_resume()
1720 dev->power.ignore_children); in pm_runtime_need_not_resume()
1724 * pm_runtime_force_suspend - Force a device into suspend state if needed.
1728 * if it is active, invoke its ->runtime_suspend callback to suspend it and
1731 * the system-wide transition under way, decrement its parent's children counter
1737 * system-wide PM transitions to sleep states. It assumes that the analogous
1756 * If the device can stay in suspend after the system-wide transition in pm_runtime_force_suspend()
1775 * pm_runtime_force_resume - Force a device into resume state if needed.