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
27 if (dev->pm_domain) in __rpm_get_callback()
28 ops = &dev->pm_domain->ops; in __rpm_get_callback()
29 else if (dev->type && dev->type->pm) in __rpm_get_callback()
30 ops = dev->type->pm; in __rpm_get_callback()
31 else if (dev->class && dev->class->pm) in __rpm_get_callback()
32 ops = dev->class->pm; in __rpm_get_callback()
33 else if (dev->bus && dev->bus->pm) in __rpm_get_callback()
34 ops = dev->bus->pm; in __rpm_get_callback()
43 if (!cb && dev->driver && dev->driver->pm) in __rpm_get_callback()
44 cb = *(pm_callback_t *)((void *)dev->driver->pm + cb_offset); in __rpm_get_callback()
56 * update_pm_runtime_accounting - Update the time accounting of power states
70 if (dev->power.disable_depth > 0) in update_pm_runtime_accounting()
73 last = dev->power.accounting_timestamp; in update_pm_runtime_accounting()
76 dev->power.accounting_timestamp = now; in update_pm_runtime_accounting()
86 delta = now - last; in update_pm_runtime_accounting()
88 if (dev->power.runtime_status == RPM_SUSPENDED) in update_pm_runtime_accounting()
89 dev->power.suspended_time += delta; in update_pm_runtime_accounting()
91 dev->power.active_time += delta; in update_pm_runtime_accounting()
98 dev->power.runtime_status = status; in __update_runtime_status()
106 spin_lock_irqsave(&dev->power.lock, flags); in rpm_get_accounted_time()
109 time = suspended ? dev->power.suspended_time : dev->power.active_time; in rpm_get_accounted_time()
111 spin_unlock_irqrestore(&dev->power.lock, flags); in rpm_get_accounted_time()
128 * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
133 if (dev->power.timer_expires > 0) { in pm_runtime_deactivate_timer()
134 hrtimer_try_to_cancel(&dev->power.suspend_timer); in pm_runtime_deactivate_timer()
135 dev->power.timer_expires = 0; in pm_runtime_deactivate_timer()
140 * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
150 dev->power.request = RPM_REQ_NONE; in pm_runtime_cancel_pending()
154 * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
157 * Compute the autosuspend-delay expiration time based on the device's
158 * power.last_busy time. If the delay has already expired or is disabled
162 * This function may be called either with or without dev->power.lock held.
170 if (!dev->power.use_autosuspend) in pm_runtime_autosuspend_expiration()
173 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); in pm_runtime_autosuspend_expiration()
177 expires = READ_ONCE(dev->power.last_busy); in pm_runtime_autosuspend_expiration()
188 return dev->power.memalloc_noio; in dev_memalloc_noio()
192 * pm_runtime_set_memalloc_noio - Set a device's memalloc_noio flag.
227 /* hold power lock since bitfield is not SMP-safe. */ in pm_runtime_set_memalloc_noio()
228 spin_lock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
229 enabled = dev->power.memalloc_noio; in pm_runtime_set_memalloc_noio()
230 dev->power.memalloc_noio = enable; in pm_runtime_set_memalloc_noio()
231 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
240 dev = dev->parent; in pm_runtime_set_memalloc_noio()
256 * rpm_check_suspend_allowed - Test whether a device may be suspended.
263 if (dev->power.runtime_error) in rpm_check_suspend_allowed()
264 retval = -EINVAL; in rpm_check_suspend_allowed()
265 else if (dev->power.disable_depth > 0) in rpm_check_suspend_allowed()
266 retval = -EACCES; in rpm_check_suspend_allowed()
267 else if (atomic_read(&dev->power.usage_count)) in rpm_check_suspend_allowed()
268 retval = -EAGAIN; in rpm_check_suspend_allowed()
269 else if (!dev->power.ignore_children && 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 && dev->power.request == RPM_REQ_RESUME)) in rpm_check_suspend_allowed()
276 retval = -EAGAIN; in rpm_check_suspend_allowed()
278 retval = -EPERM; in rpm_check_suspend_allowed()
279 else if (dev->power.runtime_status == RPM_SUSPENDED) in rpm_check_suspend_allowed()
289 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_get_suppliers()
293 if (!(link->flags & DL_FLAG_PM_RUNTIME)) in rpm_get_suppliers()
296 retval = pm_runtime_get_sync(link->supplier); in rpm_get_suppliers()
298 if (retval < 0 && retval != -EACCES) { in rpm_get_suppliers()
299 pm_runtime_put_noidle(link->supplier); in rpm_get_suppliers()
302 refcount_inc(&link->rpm_active); in rpm_get_suppliers()
308 * pm_runtime_release_supplier - Drop references to device link's supplier.
315 struct device *supplier = link->supplier; in pm_runtime_release_supplier()
323 while (refcount_dec_not_one(&link->rpm_active) && in pm_runtime_release_supplier()
324 atomic_read(&supplier->power.usage_count) > 0) in pm_runtime_release_supplier()
332 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in __rpm_put_suppliers()
336 pm_request_idle(link->supplier); in __rpm_put_suppliers()
350 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_suspend_suppliers()
352 pm_request_idle(link->supplier); in rpm_suspend_suppliers()
358 * __rpm_callback - Run a given runtime PM callback for a given device.
363 __releases(&dev->power.lock) __acquires(&dev->power.lock) in __rpm_callback()
366 bool use_links = dev->power.links_count > 0; in __rpm_callback()
368 if (dev->power.irq_safe) { in __rpm_callback()
369 spin_unlock(&dev->power.lock); in __rpm_callback()
371 spin_unlock_irq(&dev->power.lock); in __rpm_callback()
380 if (use_links && dev->power.runtime_status == RPM_RESUMING) { in __rpm_callback()
396 if (dev->power.irq_safe) { in __rpm_callback()
397 spin_lock(&dev->power.lock); in __rpm_callback()
407 ((dev->power.runtime_status == RPM_SUSPENDING && !retval) || in __rpm_callback()
408 (dev->power.runtime_status == RPM_RESUMING && retval))) { in __rpm_callback()
417 spin_lock_irq(&dev->power.lock); in __rpm_callback()
424 * rpm_callback - Run a given runtime PM callback for a given device.
432 if (dev->power.memalloc_noio) { in rpm_callback()
452 * Since -EACCES means that runtime PM is disabled for the given device, in rpm_callback()
455 * -EAGAIN. in rpm_callback()
457 if (retval == -EACCES) in rpm_callback()
458 retval = -EAGAIN; in rpm_callback()
460 if (retval != -EAGAIN && retval != -EBUSY) in rpm_callback()
461 dev->power.runtime_error = retval; in rpm_callback()
467 * rpm_idle - Notify device bus type if the device can be suspended.
473 * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
474 * run the ->runtime_idle() callback directly. If the ->runtime_idle callback
477 * This function must be called under dev->power.lock with interrupts disabled.
490 else if (dev->power.runtime_status != RPM_ACTIVE) in rpm_idle()
491 retval = -EAGAIN; in rpm_idle()
497 else if (dev->power.request_pending && in rpm_idle()
498 dev->power.request > RPM_REQ_IDLE) in rpm_idle()
499 retval = -EAGAIN; in rpm_idle()
502 else if (dev->power.idle_notification) in rpm_idle()
503 retval = -EINPROGRESS; in rpm_idle()
509 dev->power.request = RPM_REQ_NONE; in rpm_idle()
514 if (!callback || dev->power.no_callbacks) in rpm_idle()
519 dev->power.request = RPM_REQ_IDLE; in rpm_idle()
520 if (!dev->power.request_pending) { in rpm_idle()
521 dev->power.request_pending = true; in rpm_idle()
522 queue_work(pm_wq, &dev->power.work); in rpm_idle()
528 dev->power.idle_notification = true; in rpm_idle()
530 if (dev->power.irq_safe) in rpm_idle()
531 spin_unlock(&dev->power.lock); in rpm_idle()
533 spin_unlock_irq(&dev->power.lock); in rpm_idle()
537 if (dev->power.irq_safe) in rpm_idle()
538 spin_lock(&dev->power.lock); in rpm_idle()
540 spin_lock_irq(&dev->power.lock); in rpm_idle()
542 dev->power.idle_notification = false; in rpm_idle()
543 wake_up_all(&dev->power.wait_queue); in rpm_idle()
551 * rpm_suspend - Carry out runtime suspend of given device.
556 * Cancel a pending idle notification, autosuspend or suspend. If
560 * otherwise run the ->runtime_suspend() callback directly. When
561 * ->runtime_suspend succeeded, if a deferred resume was requested while
564 * ignore_children of parent->power and irq_safe of dev->power are not set).
565 * If ->runtime_suspend failed with -EAGAIN or -EBUSY, and if the RPM_AUTO
566 * flag is set and the next autosuspend-delay expiration time is in the
567 * future, schedule another autosuspend attempt.
569 * This function must be called under dev->power.lock with interrupts disabled.
572 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_suspend()
586 if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC)) in rpm_suspend()
587 retval = -EAGAIN; in rpm_suspend()
593 if ((rpmflags & RPM_AUTO) && dev->power.runtime_status != RPM_SUSPENDING) { in rpm_suspend()
598 dev->power.request = RPM_REQ_NONE; in rpm_suspend()
602 * set to expire at or before the autosuspend delay, in rpm_suspend()
607 if (!(dev->power.timer_expires && in rpm_suspend()
608 dev->power.timer_expires <= expires)) { in rpm_suspend()
613 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) * in rpm_suspend()
616 dev->power.timer_expires = expires; in rpm_suspend()
617 hrtimer_start_range_ns(&dev->power.suspend_timer, in rpm_suspend()
622 dev->power.timer_autosuspends = 1; in rpm_suspend()
630 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_suspend()
634 retval = -EINPROGRESS; in rpm_suspend()
638 if (dev->power.irq_safe) { in rpm_suspend()
639 spin_unlock(&dev->power.lock); in rpm_suspend()
643 spin_lock(&dev->power.lock); in rpm_suspend()
649 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_suspend()
651 if (dev->power.runtime_status != RPM_SUSPENDING) in rpm_suspend()
654 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
658 spin_lock_irq(&dev->power.lock); in rpm_suspend()
660 finish_wait(&dev->power.wait_queue, &wait); in rpm_suspend()
664 if (dev->power.no_callbacks) in rpm_suspend()
669 dev->power.request = (rpmflags & RPM_AUTO) ? in rpm_suspend()
671 if (!dev->power.request_pending) { in rpm_suspend()
672 dev->power.request_pending = true; in rpm_suspend()
673 queue_work(pm_wq, &dev->power.work); in rpm_suspend()
693 if (dev->parent) { in rpm_suspend()
694 parent = dev->parent; in rpm_suspend()
695 atomic_add_unless(&parent->power.child_count, -1, 0); in rpm_suspend()
697 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
699 if (dev->power.deferred_resume) { in rpm_suspend()
700 dev->power.deferred_resume = false; in rpm_suspend()
702 retval = -EAGAIN; in rpm_suspend()
706 if (dev->power.irq_safe) in rpm_suspend()
710 if (parent && !parent->power.ignore_children) { in rpm_suspend()
711 spin_unlock(&dev->power.lock); in rpm_suspend()
713 spin_lock(&parent->power.lock); in rpm_suspend()
715 spin_unlock(&parent->power.lock); in rpm_suspend()
717 spin_lock(&dev->power.lock); in rpm_suspend()
720 if (dev->power.links_count > 0) { in rpm_suspend()
721 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
725 spin_lock_irq(&dev->power.lock); in rpm_suspend()
736 dev->power.deferred_resume = false; in rpm_suspend()
737 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
740 * On transient errors, if the callback routine failed an autosuspend, in rpm_suspend()
742 * autosuspend expiration time, automatically reschedule another in rpm_suspend()
743 * autosuspend. in rpm_suspend()
745 if (!dev->power.runtime_error && (rpmflags & RPM_AUTO) && in rpm_suspend()
755 * rpm_resume - Carry out runtime resume of given device.
766 * ->runtime_resume() callback directly. Queue an idle notification for the
769 * This function must be called under dev->power.lock with interrupts disabled.
772 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_resume()
781 if (dev->power.runtime_error) { in rpm_resume()
782 retval = -EINVAL; in rpm_resume()
783 } else if (dev->power.disable_depth > 0) { in rpm_resume()
784 if (dev->power.runtime_status == RPM_ACTIVE && in rpm_resume()
785 dev->power.last_status == RPM_ACTIVE) in rpm_resume()
788 retval = -EACCES; in rpm_resume()
795 * optimization: If an autosuspend timer is running, leave it running in rpm_resume()
799 dev->power.request = RPM_REQ_NONE; in rpm_resume()
800 if (!dev->power.timer_autosuspends) in rpm_resume()
803 if (dev->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
808 if (dev->power.runtime_status == RPM_RESUMING || in rpm_resume()
809 dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
813 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
814 dev->power.deferred_resume = true; in rpm_resume()
816 retval = -EINPROGRESS; in rpm_resume()
818 retval = -EINPROGRESS; in rpm_resume()
823 if (dev->power.irq_safe) { in rpm_resume()
824 spin_unlock(&dev->power.lock); in rpm_resume()
828 spin_lock(&dev->power.lock); in rpm_resume()
834 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_resume()
836 if (dev->power.runtime_status != RPM_RESUMING && in rpm_resume()
837 dev->power.runtime_status != RPM_SUSPENDING) in rpm_resume()
840 spin_unlock_irq(&dev->power.lock); in rpm_resume()
844 spin_lock_irq(&dev->power.lock); in rpm_resume()
846 finish_wait(&dev->power.wait_queue, &wait); in rpm_resume()
855 if (dev->power.no_callbacks && !parent && dev->parent) { in rpm_resume()
856 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING); in rpm_resume()
857 if (dev->parent->power.disable_depth > 0 || in rpm_resume()
858 dev->parent->power.ignore_children || in rpm_resume()
859 dev->parent->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
860 atomic_inc(&dev->parent->power.child_count); in rpm_resume()
861 spin_unlock(&dev->parent->power.lock); in rpm_resume()
865 spin_unlock(&dev->parent->power.lock); in rpm_resume()
870 dev->power.request = RPM_REQ_RESUME; in rpm_resume()
871 if (!dev->power.request_pending) { in rpm_resume()
872 dev->power.request_pending = true; in rpm_resume()
873 queue_work(pm_wq, &dev->power.work); in rpm_resume()
879 if (!parent && dev->parent) { in rpm_resume()
882 * necessary. Not needed if dev is irq-safe; then the in rpm_resume()
885 parent = dev->parent; in rpm_resume()
886 if (dev->power.irq_safe) in rpm_resume()
889 spin_unlock(&dev->power.lock); in rpm_resume()
893 spin_lock(&parent->power.lock); in rpm_resume()
898 if (!parent->power.disable_depth && in rpm_resume()
899 !parent->power.ignore_children) { in rpm_resume()
901 if (parent->power.runtime_status != RPM_ACTIVE) in rpm_resume()
902 retval = -EBUSY; in rpm_resume()
904 spin_unlock(&parent->power.lock); in rpm_resume()
906 spin_lock(&dev->power.lock); in rpm_resume()
914 if (dev->power.no_callbacks) in rpm_resume()
932 atomic_inc(&parent->power.child_count); in rpm_resume()
934 wake_up_all(&dev->power.wait_queue); in rpm_resume()
940 if (parent && !dev->power.irq_safe) { in rpm_resume()
941 spin_unlock_irq(&dev->power.lock); in rpm_resume()
945 spin_lock_irq(&dev->power.lock); in rpm_resume()
954 * pm_runtime_work - Universal runtime PM work function.
965 spin_lock_irq(&dev->power.lock); in pm_runtime_work()
967 if (!dev->power.request_pending) in pm_runtime_work()
970 req = dev->power.request; in pm_runtime_work()
971 dev->power.request = RPM_REQ_NONE; in pm_runtime_work()
972 dev->power.request_pending = false; in pm_runtime_work()
992 spin_unlock_irq(&dev->power.lock); in pm_runtime_work()
996 * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
1007 spin_lock_irqsave(&dev->power.lock, flags); in pm_suspend_timer_fn()
1009 expires = dev->power.timer_expires; in pm_suspend_timer_fn()
1015 dev->power.timer_expires = 0; in pm_suspend_timer_fn()
1016 rpm_suspend(dev, dev->power.timer_autosuspends ? in pm_suspend_timer_fn()
1020 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_suspend_timer_fn()
1026 * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
1028 * @delay: Time to wait before submitting a suspend request, in milliseconds.
1030 int pm_schedule_suspend(struct device *dev, unsigned int delay) in pm_schedule_suspend() argument
1036 spin_lock_irqsave(&dev->power.lock, flags); in pm_schedule_suspend()
1038 if (!delay) { in pm_schedule_suspend()
1050 expires = ktime_get_mono_fast_ns() + (u64)delay * NSEC_PER_MSEC; in pm_schedule_suspend()
1051 dev->power.timer_expires = expires; in pm_schedule_suspend()
1052 dev->power.timer_autosuspends = 0; in pm_schedule_suspend()
1053 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS); in pm_schedule_suspend()
1056 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_schedule_suspend()
1066 ret = atomic_sub_return(1, &dev->power.usage_count); in rpm_drop_usage_count()
1076 atomic_inc(&dev->power.usage_count); in rpm_drop_usage_count()
1078 return -EINVAL; in rpm_drop_usage_count()
1082 * __pm_runtime_idle - Entry point for runtime idle operations.
1109 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_idle()
1111 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_idle()
1113 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_idle()
1120 * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
1147 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_suspend()
1149 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_suspend()
1151 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_suspend()
1158 * __pm_runtime_resume - Entry point for runtime resume operations.
1173 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe && in __pm_runtime_resume()
1174 dev->power.runtime_status != RPM_ACTIVE); in __pm_runtime_resume()
1177 atomic_inc(&dev->power.usage_count); in __pm_runtime_resume()
1179 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_resume()
1181 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_resume()
1188 * pm_runtime_get_conditional - Conditionally bump up device usage counter.
1192 * Return -EINVAL if runtime PM is disabled for @dev.
1214 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_get_conditional()
1215 if (dev->power.disable_depth > 0) { in pm_runtime_get_conditional()
1216 retval = -EINVAL; in pm_runtime_get_conditional()
1217 } else if (dev->power.runtime_status != RPM_ACTIVE) { in pm_runtime_get_conditional()
1221 atomic_inc(&dev->power.usage_count); in pm_runtime_get_conditional()
1223 retval = atomic_inc_not_zero(&dev->power.usage_count); in pm_runtime_get_conditional()
1226 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_get_conditional()
1232 * pm_runtime_get_if_active - Bump up runtime PM usage counter if the device is
1238 * state, 0 is returned. -EINVAL is returned if runtime PM is disabled for the
1248 * pm_runtime_get_if_in_use - Conditionally bump up runtime PM usage counter.
1254 * 0 is returned. -EINVAL is returned if runtime PM is disabled for the device,
1264 * __pm_runtime_set_status - Set runtime PM status of a device.
1273 * set to RPM_ACTIVE, so -EBUSY is returned in that case.
1289 struct device *parent = dev->parent; in __pm_runtime_set_status()
1295 return -EINVAL; in __pm_runtime_set_status()
1297 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_set_status()
1300 * Prevent PM-runtime from being enabled for the device or return an in __pm_runtime_set_status()
1303 if (dev->power.runtime_error || dev->power.disable_depth) in __pm_runtime_set_status()
1304 dev->power.disable_depth++; in __pm_runtime_set_status()
1306 error = -EAGAIN; in __pm_runtime_set_status()
1308 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_set_status()
1329 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_set_status()
1331 if (dev->power.runtime_status == status || !parent) in __pm_runtime_set_status()
1335 atomic_add_unless(&parent->power.child_count, -1, 0); in __pm_runtime_set_status()
1336 notify_parent = !parent->power.ignore_children; in __pm_runtime_set_status()
1338 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING); in __pm_runtime_set_status()
1345 if (!parent->power.disable_depth && in __pm_runtime_set_status()
1346 !parent->power.ignore_children && in __pm_runtime_set_status()
1347 parent->power.runtime_status != RPM_ACTIVE) { in __pm_runtime_set_status()
1351 error = -EBUSY; in __pm_runtime_set_status()
1352 } else if (dev->power.runtime_status == RPM_SUSPENDED) { in __pm_runtime_set_status()
1353 atomic_inc(&parent->power.child_count); in __pm_runtime_set_status()
1356 spin_unlock(&parent->power.lock); in __pm_runtime_set_status()
1367 dev->power.runtime_error = 0; in __pm_runtime_set_status()
1370 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_set_status()
1390 * __pm_runtime_barrier - Cancel pending requests and wait for completions.
1396 * Should be called under dev->power.lock with interrupts disabled.
1402 if (dev->power.request_pending) { in __pm_runtime_barrier()
1403 dev->power.request = RPM_REQ_NONE; in __pm_runtime_barrier()
1404 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1406 cancel_work_sync(&dev->power.work); in __pm_runtime_barrier()
1408 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1409 dev->power.request_pending = false; in __pm_runtime_barrier()
1412 if (dev->power.runtime_status == RPM_SUSPENDING || in __pm_runtime_barrier()
1413 dev->power.runtime_status == RPM_RESUMING || in __pm_runtime_barrier()
1414 dev->power.idle_notification) { in __pm_runtime_barrier()
1417 /* Suspend, wake-up or idle notification in progress. */ in __pm_runtime_barrier()
1419 prepare_to_wait(&dev->power.wait_queue, &wait, in __pm_runtime_barrier()
1421 if (dev->power.runtime_status != RPM_SUSPENDING in __pm_runtime_barrier()
1422 && dev->power.runtime_status != RPM_RESUMING in __pm_runtime_barrier()
1423 && !dev->power.idle_notification) in __pm_runtime_barrier()
1425 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1429 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1431 finish_wait(&dev->power.wait_queue, &wait); in __pm_runtime_barrier()
1436 * pm_runtime_barrier - Flush pending requests and wait for completions.
1454 spin_lock_irq(&dev->power.lock); in pm_runtime_barrier()
1456 if (dev->power.request_pending in pm_runtime_barrier()
1457 && dev->power.request == RPM_REQ_RESUME) { in pm_runtime_barrier()
1464 spin_unlock_irq(&dev->power.lock); in pm_runtime_barrier()
1475 spin_lock_irq(&dev->power.lock); in pm_runtime_block_if_disabled()
1478 if (ret && dev->power.last_status == RPM_INVALID) in pm_runtime_block_if_disabled()
1479 dev->power.last_status = RPM_BLOCKED; in pm_runtime_block_if_disabled()
1481 spin_unlock_irq(&dev->power.lock); in pm_runtime_block_if_disabled()
1488 spin_lock_irq(&dev->power.lock); in pm_runtime_unblock()
1490 if (dev->power.last_status == RPM_BLOCKED) in pm_runtime_unblock()
1491 dev->power.last_status = RPM_INVALID; in pm_runtime_unblock()
1493 spin_unlock_irq(&dev->power.lock); in pm_runtime_unblock()
1498 spin_lock_irq(&dev->power.lock); in __pm_runtime_disable()
1500 if (dev->power.disable_depth > 0) { in __pm_runtime_disable()
1501 dev->power.disable_depth++; in __pm_runtime_disable()
1510 if (check_resume && dev->power.request_pending && in __pm_runtime_disable()
1511 dev->power.request == RPM_REQ_RESUME) { in __pm_runtime_disable()
1523 /* Update time accounting before disabling PM-runtime. */ in __pm_runtime_disable()
1526 if (!dev->power.disable_depth++) { in __pm_runtime_disable()
1528 dev->power.last_status = dev->power.runtime_status; in __pm_runtime_disable()
1532 spin_unlock_irq(&dev->power.lock); in __pm_runtime_disable()
1537 * pm_runtime_enable - Enable runtime PM of a device.
1544 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_enable()
1546 if (!dev->power.disable_depth) { in pm_runtime_enable()
1551 if (--dev->power.disable_depth > 0) in pm_runtime_enable()
1554 if (dev->power.last_status == RPM_BLOCKED) { in pm_runtime_enable()
1558 dev->power.last_status = RPM_INVALID; in pm_runtime_enable()
1559 dev->power.accounting_timestamp = ktime_get_mono_fast_ns(); in pm_runtime_enable()
1561 if (dev->power.runtime_status == RPM_SUSPENDED && in pm_runtime_enable()
1562 !dev->power.ignore_children && in pm_runtime_enable()
1563 atomic_read(&dev->power.child_count) > 0) in pm_runtime_enable()
1567 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_enable()
1578 * devm_pm_runtime_enable - devres-enabled version of pm_runtime_enable.
1594 * pm_runtime_forbid - Block runtime PM of a device.
1603 spin_lock_irq(&dev->power.lock); in pm_runtime_forbid()
1604 if (!dev->power.runtime_auto) in pm_runtime_forbid()
1607 dev->power.runtime_auto = false; in pm_runtime_forbid()
1608 atomic_inc(&dev->power.usage_count); in pm_runtime_forbid()
1612 spin_unlock_irq(&dev->power.lock); in pm_runtime_forbid()
1617 * pm_runtime_allow - Unblock runtime PM of a device.
1626 spin_lock_irq(&dev->power.lock); in pm_runtime_allow()
1627 if (dev->power.runtime_auto) in pm_runtime_allow()
1630 dev->power.runtime_auto = true; in pm_runtime_allow()
1638 spin_unlock_irq(&dev->power.lock); in pm_runtime_allow()
1643 * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
1647 * device is power-managed through its parent and has no runtime PM
1652 spin_lock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1653 dev->power.no_callbacks = 1; in pm_runtime_no_callbacks()
1654 spin_unlock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1661 * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1665 * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1668 * the parent from runtime suspending -- otherwise an irq-safe child might have
1669 * to wait for a non-irq-safe parent.
1673 if (dev->parent) in pm_runtime_irq_safe()
1674 pm_runtime_get_sync(dev->parent); in pm_runtime_irq_safe()
1676 spin_lock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1677 dev->power.irq_safe = 1; in pm_runtime_irq_safe()
1678 spin_unlock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1683 * update_autosuspend - Handle a change to a device's autosuspend settings.
1688 * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1691 * This function must be called under dev->power.lock with interrupts disabled.
1695 int delay = dev->power.autosuspend_delay; in update_autosuspend() local
1698 if (dev->power.use_autosuspend && delay < 0) { in update_autosuspend()
1702 atomic_inc(&dev->power.usage_count); in update_autosuspend()
1714 atomic_dec(&dev->power.usage_count); in update_autosuspend()
1716 /* Maybe we can autosuspend now. */ in update_autosuspend()
1722 * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1724 * @delay: Value of the new delay in milliseconds.
1730 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay) in pm_runtime_set_autosuspend_delay() argument
1734 spin_lock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1735 old_delay = dev->power.autosuspend_delay; in pm_runtime_set_autosuspend_delay()
1736 old_use = dev->power.use_autosuspend; in pm_runtime_set_autosuspend_delay()
1737 dev->power.autosuspend_delay = delay; in pm_runtime_set_autosuspend_delay()
1739 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1744 * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1755 spin_lock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1756 old_delay = dev->power.autosuspend_delay; in __pm_runtime_use_autosuspend()
1757 old_use = dev->power.use_autosuspend; in __pm_runtime_use_autosuspend()
1758 dev->power.use_autosuspend = use; in __pm_runtime_use_autosuspend()
1760 spin_unlock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1765 * pm_runtime_init - Initialize runtime PM fields in given device object.
1770 dev->power.runtime_status = RPM_SUSPENDED; in pm_runtime_init()
1771 dev->power.last_status = RPM_INVALID; in pm_runtime_init()
1772 dev->power.idle_notification = false; in pm_runtime_init()
1774 dev->power.disable_depth = 1; in pm_runtime_init()
1775 atomic_set(&dev->power.usage_count, 0); in pm_runtime_init()
1777 dev->power.runtime_error = 0; in pm_runtime_init()
1779 atomic_set(&dev->power.child_count, 0); in pm_runtime_init()
1781 dev->power.runtime_auto = true; in pm_runtime_init()
1783 dev->power.request_pending = false; in pm_runtime_init()
1784 dev->power.request = RPM_REQ_NONE; in pm_runtime_init()
1785 dev->power.deferred_resume = false; in pm_runtime_init()
1786 dev->power.needs_force_resume = 0; in pm_runtime_init()
1787 INIT_WORK(&dev->power.work, pm_runtime_work); in pm_runtime_init()
1789 dev->power.timer_expires = 0; in pm_runtime_init()
1790 hrtimer_setup(&dev->power.suspend_timer, pm_suspend_timer_fn, CLOCK_MONOTONIC, in pm_runtime_init()
1793 init_waitqueue_head(&dev->power.wait_queue); in pm_runtime_init()
1797 * pm_runtime_reinit - Re-initialize runtime PM fields in given device object.
1798 * @dev: Device object to re-initialize.
1803 if (dev->power.runtime_status == RPM_ACTIVE) in pm_runtime_reinit()
1805 if (dev->power.irq_safe) { in pm_runtime_reinit()
1806 spin_lock_irq(&dev->power.lock); in pm_runtime_reinit()
1807 dev->power.irq_safe = 0; in pm_runtime_reinit()
1808 spin_unlock_irq(&dev->power.lock); in pm_runtime_reinit()
1809 if (dev->parent) in pm_runtime_reinit()
1810 pm_runtime_put(dev->parent); in pm_runtime_reinit()
1816 * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1826 * pm_runtime_get_suppliers - Resume and reference-count supplier devices.
1836 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in pm_runtime_get_suppliers()
1838 if (link->flags & DL_FLAG_PM_RUNTIME) { in pm_runtime_get_suppliers()
1839 link->supplier_preactivated = true; in pm_runtime_get_suppliers()
1840 pm_runtime_get_sync(link->supplier); in pm_runtime_get_suppliers()
1847 * pm_runtime_put_suppliers - Drop references to supplier devices.
1857 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in pm_runtime_put_suppliers()
1859 if (link->supplier_preactivated) { in pm_runtime_put_suppliers()
1860 link->supplier_preactivated = false; in pm_runtime_put_suppliers()
1861 pm_runtime_put(link->supplier); in pm_runtime_put_suppliers()
1869 spin_lock_irq(&dev->power.lock); in pm_runtime_new_link()
1870 dev->power.links_count++; in pm_runtime_new_link()
1871 spin_unlock_irq(&dev->power.lock); in pm_runtime_new_link()
1876 spin_lock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1877 WARN_ON(dev->power.links_count == 0); in pm_runtime_drop_link_count()
1878 dev->power.links_count--; in pm_runtime_drop_link_count()
1879 spin_unlock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1883 * pm_runtime_drop_link - Prepare for device link removal.
1892 if (!(link->flags & DL_FLAG_PM_RUNTIME)) in pm_runtime_drop_link()
1895 pm_runtime_drop_link_count(link->consumer); in pm_runtime_drop_link()
1897 pm_request_idle(link->supplier); in pm_runtime_drop_link()
1902 return atomic_read(&dev->power.usage_count) <= 1 && in pm_runtime_need_not_resume()
1903 (atomic_read(&dev->power.child_count) == 0 || in pm_runtime_need_not_resume()
1904 dev->power.ignore_children); in pm_runtime_need_not_resume()
1908 * pm_runtime_force_suspend - Force a device into suspend state if needed.
1912 * if it is active, invoke its ->runtime_suspend callback to suspend it and
1915 * the system-wide transition under way, decrement its parent's children counter
1921 * system-wide PM transitions to sleep states. It assumes that the analogous
1925 * state where this function has called the ->runtime_suspend callback but the
1947 * If the device can stay in suspend after the system-wide transition in pm_runtime_force_suspend()
1956 dev->power.needs_force_resume = 1; in pm_runtime_force_suspend()
1969 * pm_runtime_force_resume - Force a device into resume state if needed.
1985 if (!dev->power.needs_force_resume) in pm_runtime_force_resume()
2006 dev->power.needs_force_resume = 0; in pm_runtime_force_resume()