Lines Matching +full:pm +full:- +full:bus
1 // SPDX-License-Identifier: GPL-2.0
3 * drivers/base/power/main.c - Where the driver meets power management.
10 * and add it to the list of power-controlled devices. sysfs entries for
18 #define pr_fmt(fmt) "PM: " fmt
24 #include <linux/pm.h>
26 #include <linux/pm-trace.h>
66 * pm_hibernate_is_recovering - if recovering from hibernate due to error.
99 return "(unknown PM event)"; in pm_verb()
104 * device_pm_sleep_init - Initialize system suspend-related device fields.
109 dev->power.is_prepared = false; in device_pm_sleep_init()
110 dev->power.is_suspended = false; in device_pm_sleep_init()
111 dev->power.is_noirq_suspended = false; in device_pm_sleep_init()
112 dev->power.is_late_suspended = false; in device_pm_sleep_init()
113 init_completion(&dev->power.completion); in device_pm_sleep_init()
114 complete_all(&dev->power.completion); in device_pm_sleep_init()
115 dev->power.wakeup = NULL; in device_pm_sleep_init()
116 INIT_LIST_HEAD(&dev->power.entry); in device_pm_sleep_init()
120 * device_pm_lock - Lock the list of active devices used by the PM core.
128 * device_pm_unlock - Unlock the list of active devices used by the PM core.
136 * device_pm_add - Add a device to the PM core's list of active devices.
141 /* Skip PM setup/initialization. */ in device_pm_add()
146 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_add()
149 if (dev->parent && dev->parent->power.is_prepared) in device_pm_add()
151 dev_name(dev->parent)); in device_pm_add()
152 list_add_tail(&dev->power.entry, &dpm_list); in device_pm_add()
153 dev->power.in_dpm_list = true; in device_pm_add()
158 * device_pm_remove - Remove a device from the PM core's list of active devices.
167 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_remove()
168 complete_all(&dev->power.completion); in device_pm_remove()
170 list_del_init(&dev->power.entry); in device_pm_remove()
171 dev->power.in_dpm_list = false; in device_pm_remove()
179 * device_pm_move_before - Move device in the PM core's list of active devices.
186 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_before()
187 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_before()
189 list_move_tail(&deva->power.entry, &devb->power.entry); in device_pm_move_before()
193 * device_pm_move_after - Move device in the PM core's list of active devices.
200 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_after()
201 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_after()
203 list_move(&deva->power.entry, &devb->power.entry); in device_pm_move_after()
207 * device_pm_move_last - Move device to end of the PM core's list of devices.
213 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_move_last()
214 list_move_tail(&dev->power.entry, &dpm_list); in device_pm_move_last()
224 dev->parent ? dev_name(dev->parent) : "none"); in initcall_debug_start()
242 * dpm_wait - Wait for a PM operation to complete.
251 if (async || (pm_async_enabled && dev->power.async_suspend)) in dpm_wait()
252 wait_for_completion(&dev->power.completion); in dpm_wait()
281 if (READ_ONCE(link->status) != DL_STATE_DORMANT && in dpm_wait_for_suppliers()
282 !device_link_flag_is_sync_state_only(link->flags)) in dpm_wait_for_suppliers()
283 dpm_wait(link->supplier, async); in dpm_wait_for_suppliers()
306 parent = get_device(dev->parent); in dpm_wait_for_superior()
339 if (READ_ONCE(link->status) != DL_STATE_DORMANT && in dpm_wait_for_consumers()
340 !device_link_flag_is_sync_state_only(link->flags)) in dpm_wait_for_consumers()
341 dpm_wait(link->consumer, async); in dpm_wait_for_consumers()
353 * pm_op - Return the PM operation appropriate for given PM event.
354 * @ops: PM operations to choose from.
355 * @state: PM transition of the system being carried out.
362 return ops->suspend; in pm_op()
364 return ops->resume; in pm_op()
369 return ops->freeze; in pm_op()
371 return ops->poweroff; in pm_op()
374 return ops->thaw; in pm_op()
376 return ops->restore; in pm_op()
384 * pm_late_early_op - Return the PM operation appropriate for given PM event.
385 * @ops: PM operations to choose from.
386 * @state: PM transition of the system being carried out.
388 * Runtime PM is disabled for @dev while this function is being executed.
396 return ops->suspend_late; in pm_late_early_op()
398 return ops->resume_early; in pm_late_early_op()
403 return ops->freeze_late; in pm_late_early_op()
405 return ops->poweroff_late; in pm_late_early_op()
408 return ops->thaw_early; in pm_late_early_op()
410 return ops->restore_early; in pm_late_early_op()
418 * pm_noirq_op - Return the PM operation appropriate for given PM event.
419 * @ops: PM operations to choose from.
420 * @state: PM transition of the system being carried out.
430 return ops->suspend_noirq; in pm_noirq_op()
432 return ops->resume_noirq; in pm_noirq_op()
437 return ops->freeze_noirq; in pm_noirq_op()
439 return ops->poweroff_noirq; in pm_noirq_op()
442 return ops->thaw_noirq; in pm_noirq_op()
444 return ops->restore_noirq; in pm_noirq_op()
455 ", may wakeup" : "", dev->power.driver_flags); in pm_dev_dbg()
519 * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
520 * @t: The timer that PM watchdog depends on.
524 * capture a crash-dump in pstore.
529 struct timer_list *timer = &wd->timer; in dpm_watchdog_handler()
532 if (wd->fatal) { in dpm_watchdog_handler()
533 dev_emerg(wd->dev, "**** DPM device timeout ****\n"); in dpm_watchdog_handler()
534 show_stack(wd->tsk, NULL, KERN_EMERG); in dpm_watchdog_handler()
536 dev_driver_string(wd->dev), dev_name(wd->dev)); in dpm_watchdog_handler()
539 time_left = CONFIG_DPM_WATCHDOG_TIMEOUT - CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_handler()
540 dev_warn(wd->dev, "**** DPM device timeout after %u seconds; %u seconds until panic ****\n", in dpm_watchdog_handler()
542 show_stack(wd->tsk, NULL, KERN_WARNING); in dpm_watchdog_handler()
544 wd->fatal = true; in dpm_watchdog_handler()
549 * dpm_watchdog_set - Enable pm watchdog for given device.
555 struct timer_list *timer = &wd->timer; in dpm_watchdog_set()
557 wd->dev = dev; in dpm_watchdog_set()
558 wd->tsk = current; in dpm_watchdog_set()
559 wd->fatal = CONFIG_DPM_WATCHDOG_TIMEOUT == CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_set()
563 timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_set()
568 * dpm_watchdog_clear - Disable suspend/resume watchdog.
573 struct timer_list *timer = &wd->timer; in dpm_watchdog_clear()
584 /*------------------------- Resume routines -------------------------*/
587 * dev_pm_skip_resume - System-wide device resume optimization check.
591 * - %false if the transition under way is RESTORE.
592 * - Return value of dev_pm_skip_suspend() if the transition under way is THAW.
593 * - The logical negation of %power.must_resume otherwise (that is, when the
604 return !dev->power.must_resume; in dev_pm_skip_resume()
609 return dev->power.async_suspend && pm_async_enabled in is_async()
615 if (dev->power.work_in_progress) in __dpm_async()
621 dev->power.work_in_progress = true; in __dpm_async()
645 dev->power.work_in_progress = false; in dpm_async_with_cleanup()
677 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_async_resume_subordinate()
678 dpm_async_with_cleanup(link->consumer, func); in dpm_async_resume_subordinate()
685 reinit_completion(&dev->power.completion); in dpm_clear_async_state()
686 dev->power.work_in_progress = false; in dpm_clear_async_state()
698 return !dev->parent && list_empty(&dev->links.suppliers); in dpm_root_device()
704 * device_resume_noirq - Execute a "noirq resume" callback for given device.
706 * @state: PM transition of the system being carried out.
722 if (dev->power.syscore || dev->power.direct_complete) in device_resume_noirq()
725 if (!dev->power.is_noirq_suspended) { in device_resume_noirq()
735 dev->power.must_resume = false; in device_resume_noirq()
747 * this device later, it needs to appear as "suspended" to PM-runtime, in device_resume_noirq()
750 * Otherwise, the device is going to be resumed, so set its PM-runtime in device_resume_noirq()
752 * which case it is not necessary to update its PM-runtime status. in device_resume_noirq()
759 if (dev->pm_domain) { in device_resume_noirq()
761 callback = pm_noirq_op(&dev->pm_domain->ops, state); in device_resume_noirq()
762 } else if (dev->type && dev->type->pm) { in device_resume_noirq()
764 callback = pm_noirq_op(dev->type->pm, state); in device_resume_noirq()
765 } else if (dev->class && dev->class->pm) { in device_resume_noirq()
767 callback = pm_noirq_op(dev->class->pm, state); in device_resume_noirq()
768 } else if (dev->bus && dev->bus->pm) { in device_resume_noirq()
769 info = "noirq bus "; in device_resume_noirq()
770 callback = pm_noirq_op(dev->bus->pm, state); in device_resume_noirq()
778 if (dev->driver && dev->driver->pm) { in device_resume_noirq()
780 callback = pm_noirq_op(dev->driver->pm, state); in device_resume_noirq()
787 dev->power.is_noirq_suspended = false; in device_resume_noirq()
790 complete_all(&dev->power.completion); in device_resume_noirq()
834 list_move_tail(&dev->power.entry, &dpm_late_early_list); in dpm_noirq_resume_devices()
858 * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
859 * @state: PM transition of the system being carried out.
875 * device_resume_early - Execute an "early resume" callback for given device.
877 * @state: PM transition of the system being carried out.
880 * Runtime PM is disabled for @dev while this function is being executed.
891 if (dev->power.syscore || dev->power.direct_complete) in device_resume_early()
894 if (!dev->power.is_late_suspended) in device_resume_early()
900 if (dev->pm_domain) { in device_resume_early()
902 callback = pm_late_early_op(&dev->pm_domain->ops, state); in device_resume_early()
903 } else if (dev->type && dev->type->pm) { in device_resume_early()
905 callback = pm_late_early_op(dev->type->pm, state); in device_resume_early()
906 } else if (dev->class && dev->class->pm) { in device_resume_early()
908 callback = pm_late_early_op(dev->class->pm, state); in device_resume_early()
909 } else if (dev->bus && dev->bus->pm) { in device_resume_early()
910 info = "early bus "; in device_resume_early()
911 callback = pm_late_early_op(dev->bus->pm, state); in device_resume_early()
919 if (dev->driver && dev->driver->pm) { in device_resume_early()
921 callback = pm_late_early_op(dev->driver->pm, state); in device_resume_early()
928 dev->power.is_late_suspended = false; in device_resume_early()
934 complete_all(&dev->power.completion); in device_resume_early()
954 * dpm_resume_early - Execute "early resume" callbacks for all devices.
955 * @state: PM transition of the system being carried out.
981 list_move_tail(&dev->power.entry, &dpm_suspended_list); in dpm_resume_early()
1005 * dpm_resume_start - Execute "noirq" and "early" device callbacks.
1006 * @state: PM transition of the system being carried out.
1018 * device_resume - Execute "resume" callbacks for given device.
1020 * @state: PM transition of the system being carried out.
1033 if (dev->power.syscore) in device_resume()
1036 if (!dev->power.is_suspended) in device_resume()
1039 dev->power.is_suspended = false; in device_resume()
1041 if (dev->power.direct_complete) { in device_resume()
1044 * point if it has no PM callbacks. in device_resume()
1046 if (dev->power.no_pm_callbacks) in device_resume()
1047 dev->power.is_prepared = false; in device_resume()
1064 dev->power.is_prepared = false; in device_resume()
1066 if (dev->pm_domain) { in device_resume()
1068 callback = pm_op(&dev->pm_domain->ops, state); in device_resume()
1072 if (dev->type && dev->type->pm) { in device_resume()
1074 callback = pm_op(dev->type->pm, state); in device_resume()
1078 if (dev->class && dev->class->pm) { in device_resume()
1080 callback = pm_op(dev->class->pm, state); in device_resume()
1084 if (dev->bus) { in device_resume()
1085 if (dev->bus->pm) { in device_resume()
1086 info = "bus "; in device_resume()
1087 callback = pm_op(dev->bus->pm, state); in device_resume()
1088 } else if (dev->bus->resume) { in device_resume()
1089 info = "legacy bus "; in device_resume()
1090 callback = dev->bus->resume; in device_resume()
1096 if (!callback && dev->driver && dev->driver->pm) { in device_resume()
1098 callback = pm_op(dev->driver->pm, state); in device_resume()
1108 complete_all(&dev->power.completion); in device_resume()
1130 * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
1131 * @state: PM transition of the system being carried out.
1160 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_resume()
1186 * device_complete - Complete a PM transition for given device.
1188 * @state: PM transition of the system being carried out.
1195 if (dev->power.syscore) in device_complete()
1200 if (dev->pm_domain) { in device_complete()
1202 callback = dev->pm_domain->ops.complete; in device_complete()
1203 } else if (dev->type && dev->type->pm) { in device_complete()
1205 callback = dev->type->pm->complete; in device_complete()
1206 } else if (dev->class && dev->class->pm) { in device_complete()
1208 callback = dev->class->pm->complete; in device_complete()
1209 } else if (dev->bus && dev->bus->pm) { in device_complete()
1210 info = "completing bus "; in device_complete()
1211 callback = dev->bus->pm->complete; in device_complete()
1214 if (!callback && dev->driver && dev->driver->pm) { in device_complete()
1216 callback = dev->driver->pm->complete; in device_complete()
1227 /* If enabling runtime PM for the device is blocked, unblock it. */ in device_complete()
1233 * dpm_complete - Complete a PM transition for all non-sysdev devices.
1234 * @state: PM transition of the system being carried out.
1236 * Execute the ->complete() callbacks for all devices whose PM status is not
1251 dev->power.is_prepared = false; in dpm_complete()
1252 list_move(&dev->power.entry, &list); in dpm_complete()
1267 /* Allow device probing and trigger re-probing of deferred devices */ in dpm_complete()
1273 * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1274 * @state: PM transition of the system being carried out.
1276 * Execute "resume" callbacks for all devices and complete the PM transition of
1288 /*------------------------- Suspend routines -------------------------*/
1308 return list_empty(&dev->links.consumers); in dpm_leaf_device()
1326 if (dev->parent) in dpm_async_suspend_parent()
1327 dpm_async_with_cleanup(dev->parent, func); in dpm_async_suspend_parent()
1344 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_async_suspend_superior()
1345 dpm_async_with_cleanup(link->supplier, func); in dpm_async_suspend_superior()
1361 if (!dev->power.work_in_progress) in dpm_async_suspend_complete_all()
1362 complete_all(&dev->power.completion); in dpm_async_suspend_complete_all()
1367 * resume_event - Return a "resume" message for given "suspend" sleep state.
1368 * @sleep_state: PM message representing a sleep state.
1370 * Return a PM message representing the resume event corresponding to given
1392 if (dev->parent) in dpm_superior_set_must_resume()
1393 dev->parent->power.must_resume = true; in dpm_superior_set_must_resume()
1398 link->supplier->power.must_resume = true; in dpm_superior_set_must_resume()
1406 * device_suspend_noirq - Execute a "noirq suspend" callback for given device.
1408 * @state: PM transition of the system being carried out.
1428 if (dev->power.syscore || dev->power.direct_complete) in device_suspend_noirq()
1431 if (dev->pm_domain) { in device_suspend_noirq()
1433 callback = pm_noirq_op(&dev->pm_domain->ops, state); in device_suspend_noirq()
1434 } else if (dev->type && dev->type->pm) { in device_suspend_noirq()
1436 callback = pm_noirq_op(dev->type->pm, state); in device_suspend_noirq()
1437 } else if (dev->class && dev->class->pm) { in device_suspend_noirq()
1439 callback = pm_noirq_op(dev->class->pm, state); in device_suspend_noirq()
1440 } else if (dev->bus && dev->bus->pm) { in device_suspend_noirq()
1441 info = "noirq bus "; in device_suspend_noirq()
1442 callback = pm_noirq_op(dev->bus->pm, state); in device_suspend_noirq()
1450 if (dev->driver && dev->driver->pm) { in device_suspend_noirq()
1452 callback = pm_noirq_op(dev->driver->pm, state); in device_suspend_noirq()
1465 dev->power.is_noirq_suspended = true; in device_suspend_noirq()
1471 * runtime PM usage counters and child counters) would be suboptimal. in device_suspend_noirq()
1474 dev->power.may_skip_resume) || !pm_runtime_need_not_resume(dev)) in device_suspend_noirq()
1475 dev->power.must_resume = true; in device_suspend_noirq()
1477 if (dev->power.must_resume) in device_suspend_noirq()
1481 complete_all(&dev->power.completion); in device_suspend_noirq()
1524 list_move(&dev->power.entry, &dpm_noirq_list); in dpm_noirq_suspend_devices()
1564 * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1565 * @state: PM transition of the system being carried out.
1568 * "noirq" suspend callbacks for all non-sysdev devices.
1586 struct device *parent = dev->parent; in dpm_propagate_wakeup_to_parent()
1591 spin_lock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1593 if (device_wakeup_path(dev) && !parent->power.ignore_children) in dpm_propagate_wakeup_to_parent()
1594 parent->power.wakeup_path = true; in dpm_propagate_wakeup_to_parent()
1596 spin_unlock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1602 * device_suspend_late - Execute a "late suspend" callback for given device.
1604 * @state: PM transition of the system being carried out.
1607 * Runtime PM is disabled for @dev while this function is being executed.
1619 * Disable runtime PM for the device without checking if there is a in device_suspend_late()
1630 WRITE_ONCE(async_error, -EBUSY); in device_suspend_late()
1634 if (dev->power.syscore || dev->power.direct_complete) in device_suspend_late()
1637 if (dev->pm_domain) { in device_suspend_late()
1639 callback = pm_late_early_op(&dev->pm_domain->ops, state); in device_suspend_late()
1640 } else if (dev->type && dev->type->pm) { in device_suspend_late()
1642 callback = pm_late_early_op(dev->type->pm, state); in device_suspend_late()
1643 } else if (dev->class && dev->class->pm) { in device_suspend_late()
1645 callback = pm_late_early_op(dev->class->pm, state); in device_suspend_late()
1646 } else if (dev->bus && dev->bus->pm) { in device_suspend_late()
1647 info = "late bus "; in device_suspend_late()
1648 callback = pm_late_early_op(dev->bus->pm, state); in device_suspend_late()
1656 if (dev->driver && dev->driver->pm) { in device_suspend_late()
1658 callback = pm_late_early_op(dev->driver->pm, state); in device_suspend_late()
1672 dev->power.is_late_suspended = true; in device_suspend_late()
1676 complete_all(&dev->power.completion); in device_suspend_late()
1693 * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1694 * @state: PM transition of the system being carried out.
1724 list_move(&dev->power.entry, &dpm_late_early_list); in dpm_suspend_late()
1765 * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1766 * @state: PM transition of the system being carried out.
1788 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1790 * @state: PM transition of the system being carried out.
1818 if (dev->parent) { in dpm_clear_superiors_direct_complete()
1819 spin_lock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1820 dev->parent->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1821 spin_unlock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1827 spin_lock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1828 link->supplier->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1829 spin_unlock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1838 * device_suspend - Execute "suspend" callbacks for given device.
1840 * @state: PM transition of the system being carried out.
1856 dev->power.direct_complete = false; in device_suspend()
1861 * Wait for possible runtime PM transitions of the device in progress in device_suspend()
1863 * resume it before proceeding with invoking the system-wide suspend in device_suspend()
1866 * If the system-wide suspend callbacks below change the configuration in device_suspend()
1867 * of the device, they must disable runtime PM for it or otherwise in device_suspend()
1868 * ensure that its runtime-resume callbacks will not be confused by that in device_suspend()
1874 dev->power.direct_complete = false; in device_suspend()
1875 WRITE_ONCE(async_error, -EBUSY); in device_suspend()
1879 if (dev->power.syscore) in device_suspend()
1884 dev->power.direct_complete = false; in device_suspend()
1886 if (dev->power.direct_complete) { in device_suspend()
1890 pm_dev_dbg(dev, state, "direct-complete "); in device_suspend()
1891 dev->power.is_suspended = true; in device_suspend()
1897 dev->power.direct_complete = false; in device_suspend()
1900 dev->power.may_skip_resume = true; in device_suspend()
1901 dev->power.must_resume = !dev_pm_test_driver_flags(dev, DPM_FLAG_MAY_SKIP_RESUME); in device_suspend()
1906 if (dev->pm_domain) { in device_suspend()
1908 callback = pm_op(&dev->pm_domain->ops, state); in device_suspend()
1912 if (dev->type && dev->type->pm) { in device_suspend()
1914 callback = pm_op(dev->type->pm, state); in device_suspend()
1918 if (dev->class && dev->class->pm) { in device_suspend()
1920 callback = pm_op(dev->class->pm, state); in device_suspend()
1924 if (dev->bus) { in device_suspend()
1925 if (dev->bus->pm) { in device_suspend()
1926 info = "bus "; in device_suspend()
1927 callback = pm_op(dev->bus->pm, state); in device_suspend()
1928 } else if (dev->bus->suspend) { in device_suspend()
1929 pm_dev_dbg(dev, state, "legacy bus "); in device_suspend()
1930 error = legacy_suspend(dev, state, dev->bus->suspend, in device_suspend()
1931 "legacy bus "); in device_suspend()
1937 if (!callback && dev->driver && dev->driver->pm) { in device_suspend()
1939 callback = pm_op(dev->driver->pm, state); in device_suspend()
1946 dev->power.is_suspended = true; in device_suspend()
1948 dev->power.wakeup_path = true; in device_suspend()
1964 complete_all(&dev->power.completion); in device_suspend()
1982 * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1983 * @state: PM transition of the system being carried out.
2015 list_move(&dev->power.entry, &dpm_suspended_list); in dpm_suspend()
2062 * for it and for devices without PM callbacks. in device_prepare_smart_suspend()
2065 * or any of its suppliers that take runtime PM into account, it cannot in device_prepare_smart_suspend()
2068 if (!dev->power.no_pm_callbacks && in device_prepare_smart_suspend()
2072 if (dev->parent && !dev_pm_smart_suspend(dev->parent) && in device_prepare_smart_suspend()
2073 !dev->parent->power.ignore_children && !pm_runtime_blocked(dev->parent)) in device_prepare_smart_suspend()
2082 if (!dev_pm_smart_suspend(link->supplier) && in device_prepare_smart_suspend()
2083 !pm_runtime_blocked(link->supplier)) { in device_prepare_smart_suspend()
2095 * device_prepare - Prepare a device for system power transition.
2097 * @state: PM transition of the system being carried out.
2099 * Execute the ->prepare() callback(s) for given device. No new children of the
2116 * If runtime PM is disabled for the device at this point and it has in device_prepare()
2118 * suspend-resume cycle is complete, so prepare to trigger a warning on in device_prepare()
2123 if (dev->power.syscore) in device_prepare()
2128 dev->power.wakeup_path = false; in device_prepare()
2130 if (dev->power.no_pm_callbacks) in device_prepare()
2133 if (dev->pm_domain) in device_prepare()
2134 callback = dev->pm_domain->ops.prepare; in device_prepare()
2135 else if (dev->type && dev->type->pm) in device_prepare()
2136 callback = dev->type->pm->prepare; in device_prepare()
2137 else if (dev->class && dev->class->pm) in device_prepare()
2138 callback = dev->class->pm->prepare; in device_prepare()
2139 else if (dev->bus && dev->bus->pm) in device_prepare()
2140 callback = dev->bus->pm->prepare; in device_prepare()
2142 if (!callback && dev->driver && dev->driver->pm) in device_prepare()
2143 callback = dev->driver->pm->prepare; in device_prepare()
2156 /* Do not enable "smart suspend" for devices with disabled runtime PM. */ in device_prepare()
2160 spin_lock_irq(&dev->power.lock); in device_prepare()
2162 dev->power.smart_suspend = smart_suspend; in device_prepare()
2164 * A positive return value from ->prepare() means "this device appears in device_prepare()
2165 * to be runtime-suspended and its state is fine, so if it really is in device_prepare()
2166 * runtime-suspended, you can leave it in that state provided that you in device_prepare()
2170 dev->power.direct_complete = state.event == PM_EVENT_SUSPEND && in device_prepare()
2171 (ret > 0 || dev->power.no_pm_callbacks) && in device_prepare()
2174 spin_unlock_irq(&dev->power.lock); in device_prepare()
2180 * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
2181 * @state: PM transition of the system being carried out.
2183 * Execute the ->prepare() callback(s) for all devices.
2220 dev->power.is_prepared = true; in dpm_prepare()
2221 if (!list_empty(&dev->power.entry)) in dpm_prepare()
2222 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_prepare()
2223 } else if (error == -EAGAIN) { in dpm_prepare()
2242 * dpm_suspend_start - Prepare devices for PM transition and suspend them.
2243 * @state: PM transition of the system being carried out.
2245 * Prepare all non-sysdev devices for system PM transition and execute "suspend"
2274 * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
2280 dpm_wait(dev, subordinate->power.async_suspend); in device_pm_wait_for_dev()
2286 * dpm_for_each_dev - device iterator.
2312 return !ops->prepare && in pm_ops_is_empty()
2313 !ops->suspend && in pm_ops_is_empty()
2314 !ops->suspend_late && in pm_ops_is_empty()
2315 !ops->suspend_noirq && in pm_ops_is_empty()
2316 !ops->resume_noirq && in pm_ops_is_empty()
2317 !ops->resume_early && in pm_ops_is_empty()
2318 !ops->resume && in pm_ops_is_empty()
2319 !ops->complete; in pm_ops_is_empty()
2326 spin_lock_irqsave(&dev->power.lock, flags); in device_pm_check_callbacks()
2327 dev->power.no_pm_callbacks = in device_pm_check_callbacks()
2328 (!dev->bus || (pm_ops_is_empty(dev->bus->pm) && in device_pm_check_callbacks()
2329 !dev->bus->suspend && !dev->bus->resume)) && in device_pm_check_callbacks()
2330 (!dev->class || pm_ops_is_empty(dev->class->pm)) && in device_pm_check_callbacks()
2331 (!dev->type || pm_ops_is_empty(dev->type->pm)) && in device_pm_check_callbacks()
2332 (!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) && in device_pm_check_callbacks()
2333 (!dev->driver || (pm_ops_is_empty(dev->driver->pm) && in device_pm_check_callbacks()
2334 !dev->driver->suspend && !dev->driver->resume)); in device_pm_check_callbacks()
2335 spin_unlock_irqrestore(&dev->power.lock, flags); in device_pm_check_callbacks()