Lines Matching +full:bus +full:- +full:power
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
11 * controlling device power management will also be added.
13 * A separate list is used for keeping track of power info, because the power
26 #include <linux/pm-trace.h>
33 #include <trace/events/power.h>
39 #include "power.h"
93 * device_pm_sleep_init - Initialize system suspend-related device fields.
98 dev->power.is_prepared = false; in device_pm_sleep_init()
99 dev->power.is_suspended = false; in device_pm_sleep_init()
100 dev->power.is_noirq_suspended = false; in device_pm_sleep_init()
101 dev->power.is_late_suspended = false; in device_pm_sleep_init()
102 init_completion(&dev->power.completion); in device_pm_sleep_init()
103 complete_all(&dev->power.completion); in device_pm_sleep_init()
104 dev->power.wakeup = NULL; in device_pm_sleep_init()
105 INIT_LIST_HEAD(&dev->power.entry); in device_pm_sleep_init()
109 * device_pm_lock - Lock the list of active devices used by the PM core.
117 * device_pm_unlock - Unlock the list of active devices used by the PM core.
125 * device_pm_add - Add a device to the PM core's list of active devices.
135 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_add()
138 if (dev->parent && dev->parent->power.is_prepared) in device_pm_add()
140 dev_name(dev->parent)); in device_pm_add()
141 list_add_tail(&dev->power.entry, &dpm_list); in device_pm_add()
142 dev->power.in_dpm_list = true; in device_pm_add()
147 * device_pm_remove - Remove a device from the PM core's list of active devices.
156 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_remove()
157 complete_all(&dev->power.completion); in device_pm_remove()
159 list_del_init(&dev->power.entry); in device_pm_remove()
160 dev->power.in_dpm_list = false; in device_pm_remove()
168 * device_pm_move_before - Move device in the PM core's list of active devices.
175 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_before()
176 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_before()
178 list_move_tail(&deva->power.entry, &devb->power.entry); in device_pm_move_before()
182 * device_pm_move_after - Move device in the PM core's list of active devices.
189 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_after()
190 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_after()
192 list_move(&deva->power.entry, &devb->power.entry); in device_pm_move_after()
196 * device_pm_move_last - Move device to end of the PM core's list of devices.
202 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_move_last()
203 list_move_tail(&dev->power.entry, &dpm_list); in device_pm_move_last()
213 dev->parent ? dev_name(dev->parent) : "none"); in initcall_debug_start()
231 * dpm_wait - Wait for a PM operation to complete.
233 * @async: If unset, wait only if the device's power.async_suspend flag is set.
240 if (async || (pm_async_enabled && dev->power.async_suspend)) in dpm_wait()
241 wait_for_completion(&dev->power.completion); in dpm_wait()
269 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) in dpm_wait_for_suppliers()
270 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_wait_for_suppliers()
271 dpm_wait(link->supplier, async); in dpm_wait_for_suppliers()
294 parent = get_device(dev->parent); in dpm_wait_for_superior()
326 list_for_each_entry_rcu_locked(link, &dev->links.consumers, s_node) in dpm_wait_for_consumers()
327 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_wait_for_consumers()
328 dpm_wait(link->consumer, async); in dpm_wait_for_consumers()
340 * pm_op - Return the PM operation appropriate for given PM event.
349 return ops->suspend; in pm_op()
351 return ops->resume; in pm_op()
356 return ops->freeze; in pm_op()
358 return ops->poweroff; in pm_op()
361 return ops->thaw; in pm_op()
363 return ops->restore; in pm_op()
371 * pm_late_early_op - Return the PM operation appropriate for given PM event.
383 return ops->suspend_late; in pm_late_early_op()
385 return ops->resume_early; in pm_late_early_op()
390 return ops->freeze_late; in pm_late_early_op()
392 return ops->poweroff_late; in pm_late_early_op()
395 return ops->thaw_early; in pm_late_early_op()
397 return ops->restore_early; in pm_late_early_op()
405 * pm_noirq_op - Return the PM operation appropriate for given PM event.
417 return ops->suspend_noirq; in pm_noirq_op()
419 return ops->resume_noirq; in pm_noirq_op()
424 return ops->freeze_noirq; in pm_noirq_op()
426 return ops->poweroff_noirq; in pm_noirq_op()
429 return ops->thaw_noirq; in pm_noirq_op()
431 return ops->restore_noirq; in pm_noirq_op()
442 ", may wakeup" : "", dev->power.driver_flags); in pm_dev_dbg()
506 * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
511 * capture a crash-dump in pstore.
516 struct timer_list *timer = &wd->timer; in dpm_watchdog_handler()
519 if (wd->fatal) { in dpm_watchdog_handler()
520 dev_emerg(wd->dev, "**** DPM device timeout ****\n"); in dpm_watchdog_handler()
521 show_stack(wd->tsk, NULL, KERN_EMERG); in dpm_watchdog_handler()
523 dev_driver_string(wd->dev), dev_name(wd->dev)); in dpm_watchdog_handler()
526 time_left = CONFIG_DPM_WATCHDOG_TIMEOUT - CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_handler()
527 dev_warn(wd->dev, "**** DPM device timeout after %u seconds; %u seconds until panic ****\n", in dpm_watchdog_handler()
529 show_stack(wd->tsk, NULL, KERN_WARNING); in dpm_watchdog_handler()
531 wd->fatal = true; in dpm_watchdog_handler()
536 * dpm_watchdog_set - Enable pm watchdog for given device.
542 struct timer_list *timer = &wd->timer; in dpm_watchdog_set()
544 wd->dev = dev; in dpm_watchdog_set()
545 wd->tsk = current; in dpm_watchdog_set()
546 wd->fatal = CONFIG_DPM_WATCHDOG_TIMEOUT == CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_set()
550 timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_WARNING_TIMEOUT; in dpm_watchdog_set()
555 * dpm_watchdog_clear - Disable suspend/resume watchdog.
560 struct timer_list *timer = &wd->timer; in dpm_watchdog_clear()
571 /*------------------------- Resume routines -------------------------*/
574 * dev_pm_skip_resume - System-wide device resume optimization check.
578 * - %false if the transition under way is RESTORE.
579 * - Return value of dev_pm_skip_suspend() if the transition under way is THAW.
580 * - The logical negation of %power.must_resume otherwise (that is, when the
591 return !dev->power.must_resume; in dev_pm_skip_resume()
596 return dev->power.async_suspend && pm_async_enabled in is_async()
605 dev->power.work_in_progress = true; in dpm_async_fn()
616 * not running and it is safe to update power.work_in_progress without in dpm_async_fn()
619 dev->power.work_in_progress = false; in dpm_async_fn()
626 reinit_completion(&dev->power.completion); in dpm_clear_async_state()
627 dev->power.work_in_progress = false; in dpm_clear_async_state()
631 * device_resume_noirq - Execute a "noirq resume" callback for given device.
649 if (dev->power.syscore || dev->power.direct_complete) in device_resume_noirq()
652 if (!dev->power.is_noirq_suspended) in device_resume_noirq()
662 * this device later, it needs to appear as "suspended" to PM-runtime, in device_resume_noirq()
665 * Otherwise, the device is going to be resumed, so set its PM-runtime in device_resume_noirq()
666 * status to "active" unless its power.smart_suspend flag is clear, in in device_resume_noirq()
667 * which case it is not necessary to update its PM-runtime status. in device_resume_noirq()
674 if (dev->pm_domain) { in device_resume_noirq()
675 info = "noirq power domain "; in device_resume_noirq()
676 callback = pm_noirq_op(&dev->pm_domain->ops, state); in device_resume_noirq()
677 } else if (dev->type && dev->type->pm) { in device_resume_noirq()
679 callback = pm_noirq_op(dev->type->pm, state); in device_resume_noirq()
680 } else if (dev->class && dev->class->pm) { in device_resume_noirq()
682 callback = pm_noirq_op(dev->class->pm, state); in device_resume_noirq()
683 } else if (dev->bus && dev->bus->pm) { in device_resume_noirq()
684 info = "noirq bus "; in device_resume_noirq()
685 callback = pm_noirq_op(dev->bus->pm, state); in device_resume_noirq()
693 if (dev->driver && dev->driver->pm) { in device_resume_noirq()
695 callback = pm_noirq_op(dev->driver->pm, state); in device_resume_noirq()
702 dev->power.is_noirq_suspended = false; in device_resume_noirq()
705 complete_all(&dev->power.completion); in device_resume_noirq()
737 * wait for the "non-async" ones they don't depend on. in dpm_noirq_resume_devices()
739 list_for_each_entry(dev, &dpm_noirq_list, power.entry) { in dpm_noirq_resume_devices()
746 list_move_tail(&dev->power.entry, &dpm_late_early_list); in dpm_noirq_resume_devices()
748 if (!dev->power.work_in_progress) { in dpm_noirq_resume_devices()
770 * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
785 * device_resume_early - Execute an "early resume" callback for given device.
801 if (dev->power.syscore || dev->power.direct_complete) in device_resume_early()
804 if (!dev->power.is_late_suspended) in device_resume_early()
810 if (dev->pm_domain) { in device_resume_early()
811 info = "early power domain "; in device_resume_early()
812 callback = pm_late_early_op(&dev->pm_domain->ops, state); in device_resume_early()
813 } else if (dev->type && dev->type->pm) { in device_resume_early()
815 callback = pm_late_early_op(dev->type->pm, state); in device_resume_early()
816 } else if (dev->class && dev->class->pm) { in device_resume_early()
818 callback = pm_late_early_op(dev->class->pm, state); in device_resume_early()
819 } else if (dev->bus && dev->bus->pm) { in device_resume_early()
820 info = "early bus "; in device_resume_early()
821 callback = pm_late_early_op(dev->bus->pm, state); in device_resume_early()
829 if (dev->driver && dev->driver->pm) { in device_resume_early()
831 callback = pm_late_early_op(dev->driver->pm, state); in device_resume_early()
838 dev->power.is_late_suspended = false; in device_resume_early()
844 complete_all(&dev->power.completion); in device_resume_early()
862 * dpm_resume_early - Execute "early resume" callbacks for all devices.
879 * wait for the "non-async" ones they don't depend on. in dpm_resume_early()
881 list_for_each_entry(dev, &dpm_late_early_list, power.entry) { in dpm_resume_early()
888 list_move_tail(&dev->power.entry, &dpm_suspended_list); in dpm_resume_early()
890 if (!dev->power.work_in_progress) { in dpm_resume_early()
912 * dpm_resume_start - Execute "noirq" and "early" device callbacks.
923 * device_resume - Execute "resume" callbacks for given device.
938 if (dev->power.syscore) in device_resume()
941 if (!dev->power.is_suspended) in device_resume()
944 if (dev->power.direct_complete) { in device_resume()
949 if (dev->power.no_pm_callbacks) in device_resume()
950 dev->power.is_prepared = false; in device_resume()
967 dev->power.is_prepared = false; in device_resume()
969 if (dev->pm_domain) { in device_resume()
970 info = "power domain "; in device_resume()
971 callback = pm_op(&dev->pm_domain->ops, state); in device_resume()
975 if (dev->type && dev->type->pm) { in device_resume()
977 callback = pm_op(dev->type->pm, state); in device_resume()
981 if (dev->class && dev->class->pm) { in device_resume()
983 callback = pm_op(dev->class->pm, state); in device_resume()
987 if (dev->bus) { in device_resume()
988 if (dev->bus->pm) { in device_resume()
989 info = "bus "; in device_resume()
990 callback = pm_op(dev->bus->pm, state); in device_resume()
991 } else if (dev->bus->resume) { in device_resume()
992 info = "legacy bus "; in device_resume()
993 callback = dev->bus->resume; in device_resume()
999 if (!callback && dev->driver && dev->driver->pm) { in device_resume()
1001 callback = pm_op(dev->driver->pm, state); in device_resume()
1006 dev->power.is_suspended = false; in device_resume()
1012 complete_all(&dev->power.completion); in device_resume()
1032 * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
1053 * wait for the "non-async" ones they don't depend on. in dpm_resume()
1055 list_for_each_entry(dev, &dpm_suspended_list, power.entry) { in dpm_resume()
1062 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_resume()
1064 if (!dev->power.work_in_progress) { in dpm_resume()
1088 * device_complete - Complete a PM transition for given device.
1097 if (dev->power.syscore) in device_complete()
1102 if (dev->pm_domain) { in device_complete()
1103 info = "completing power domain "; in device_complete()
1104 callback = dev->pm_domain->ops.complete; in device_complete()
1105 } else if (dev->type && dev->type->pm) { in device_complete()
1107 callback = dev->type->pm->complete; in device_complete()
1108 } else if (dev->class && dev->class->pm) { in device_complete()
1110 callback = dev->class->pm->complete; in device_complete()
1111 } else if (dev->bus && dev->bus->pm) { in device_complete()
1112 info = "completing bus "; in device_complete()
1113 callback = dev->bus->pm->complete; in device_complete()
1116 if (!callback && dev->driver && dev->driver->pm) { in device_complete()
1118 callback = dev->driver->pm->complete; in device_complete()
1135 * dpm_complete - Complete a PM transition for all non-sysdev devices.
1138 * Execute the ->complete() callbacks for all devices whose PM status is not
1154 dev->power.is_prepared = false; in dpm_complete()
1155 list_move(&dev->power.entry, &list); in dpm_complete()
1170 /* Allow device probing and trigger re-probing of deferred devices */ in dpm_complete()
1176 * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1190 /*------------------------- Suspend routines -------------------------*/
1193 * resume_event - Return a "resume" message for given "suspend" sleep state.
1218 if (dev->parent) in dpm_superior_set_must_resume()
1219 dev->parent->power.must_resume = true; in dpm_superior_set_must_resume()
1223 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) in dpm_superior_set_must_resume()
1224 link->supplier->power.must_resume = true; in dpm_superior_set_must_resume()
1230 * device_suspend_noirq - Execute a "noirq suspend" callback for given device.
1252 if (dev->power.syscore || dev->power.direct_complete) in device_suspend_noirq()
1255 if (dev->pm_domain) { in device_suspend_noirq()
1256 info = "noirq power domain "; in device_suspend_noirq()
1257 callback = pm_noirq_op(&dev->pm_domain->ops, state); in device_suspend_noirq()
1258 } else if (dev->type && dev->type->pm) { in device_suspend_noirq()
1260 callback = pm_noirq_op(dev->type->pm, state); in device_suspend_noirq()
1261 } else if (dev->class && dev->class->pm) { in device_suspend_noirq()
1263 callback = pm_noirq_op(dev->class->pm, state); in device_suspend_noirq()
1264 } else if (dev->bus && dev->bus->pm) { in device_suspend_noirq()
1265 info = "noirq bus "; in device_suspend_noirq()
1266 callback = pm_noirq_op(dev->bus->pm, state); in device_suspend_noirq()
1274 if (dev->driver && dev->driver->pm) { in device_suspend_noirq()
1276 callback = pm_noirq_op(dev->driver->pm, state); in device_suspend_noirq()
1289 dev->power.is_noirq_suspended = true; in device_suspend_noirq()
1298 dev->power.may_skip_resume) || !pm_runtime_need_not_resume(dev)) in device_suspend_noirq()
1299 dev->power.must_resume = true; in device_suspend_noirq()
1301 if (dev->power.must_resume) in device_suspend_noirq()
1305 complete_all(&dev->power.completion); in device_suspend_noirq()
1333 list_move(&dev->power.entry, &dpm_noirq_list); in dpm_noirq_suspend_devices()
1368 * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1372 * "noirq" suspend callbacks for all non-sysdev devices.
1390 struct device *parent = dev->parent; in dpm_propagate_wakeup_to_parent()
1395 spin_lock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1397 if (device_wakeup_path(dev) && !parent->power.ignore_children) in dpm_propagate_wakeup_to_parent()
1398 parent->power.wakeup_path = true; in dpm_propagate_wakeup_to_parent()
1400 spin_unlock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1404 * device_suspend_late - Execute a "late suspend" callback for given device.
1432 async_error = -EBUSY; in device_suspend_late()
1436 if (dev->power.syscore || dev->power.direct_complete) in device_suspend_late()
1439 if (dev->pm_domain) { in device_suspend_late()
1440 info = "late power domain "; in device_suspend_late()
1441 callback = pm_late_early_op(&dev->pm_domain->ops, state); in device_suspend_late()
1442 } else if (dev->type && dev->type->pm) { in device_suspend_late()
1444 callback = pm_late_early_op(dev->type->pm, state); in device_suspend_late()
1445 } else if (dev->class && dev->class->pm) { in device_suspend_late()
1447 callback = pm_late_early_op(dev->class->pm, state); in device_suspend_late()
1448 } else if (dev->bus && dev->bus->pm) { in device_suspend_late()
1449 info = "late bus "; in device_suspend_late()
1450 callback = pm_late_early_op(dev->bus->pm, state); in device_suspend_late()
1458 if (dev->driver && dev->driver->pm) { in device_suspend_late()
1460 callback = pm_late_early_op(dev->driver->pm, state); in device_suspend_late()
1474 dev->power.is_late_suspended = true; in device_suspend_late()
1478 complete_all(&dev->power.completion); in device_suspend_late()
1491 * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1511 list_move(&dev->power.entry, &dpm_late_early_list); in dpm_suspend_late()
1547 * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1570 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1600 if (dev->parent) { in dpm_clear_superiors_direct_complete()
1601 spin_lock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1602 dev->parent->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1603 spin_unlock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1608 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) { in dpm_clear_superiors_direct_complete()
1609 spin_lock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1610 link->supplier->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1611 spin_unlock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1618 * device_suspend - Execute "suspend" callbacks for given device.
1636 dev->power.direct_complete = false; in device_suspend()
1643 * resume it before proceeding with invoking the system-wide suspend in device_suspend()
1646 * If the system-wide suspend callbacks below change the configuration in device_suspend()
1648 * ensure that its runtime-resume callbacks will not be confused by that in device_suspend()
1654 dev->power.direct_complete = false; in device_suspend()
1655 async_error = -EBUSY; in device_suspend()
1659 if (dev->power.syscore) in device_suspend()
1664 dev->power.direct_complete = false; in device_suspend()
1666 if (dev->power.direct_complete) { in device_suspend()
1670 pm_dev_dbg(dev, state, "direct-complete "); in device_suspend()
1671 dev->power.is_suspended = true; in device_suspend()
1677 dev->power.direct_complete = false; in device_suspend()
1680 dev->power.may_skip_resume = true; in device_suspend()
1681 dev->power.must_resume = !dev_pm_test_driver_flags(dev, DPM_FLAG_MAY_SKIP_RESUME); in device_suspend()
1686 if (dev->pm_domain) { in device_suspend()
1687 info = "power domain "; in device_suspend()
1688 callback = pm_op(&dev->pm_domain->ops, state); in device_suspend()
1692 if (dev->type && dev->type->pm) { in device_suspend()
1694 callback = pm_op(dev->type->pm, state); in device_suspend()
1698 if (dev->class && dev->class->pm) { in device_suspend()
1700 callback = pm_op(dev->class->pm, state); in device_suspend()
1704 if (dev->bus) { in device_suspend()
1705 if (dev->bus->pm) { in device_suspend()
1706 info = "bus "; in device_suspend()
1707 callback = pm_op(dev->bus->pm, state); in device_suspend()
1708 } else if (dev->bus->suspend) { in device_suspend()
1709 pm_dev_dbg(dev, state, "legacy bus "); in device_suspend()
1710 error = legacy_suspend(dev, state, dev->bus->suspend, in device_suspend()
1711 "legacy bus "); in device_suspend()
1717 if (!callback && dev->driver && dev->driver->pm) { in device_suspend()
1719 callback = pm_op(dev->driver->pm, state); in device_suspend()
1726 dev->power.is_suspended = true; in device_suspend()
1728 dev->power.wakeup_path = true; in device_suspend()
1744 complete_all(&dev->power.completion); in device_suspend()
1758 * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1780 list_move(&dev->power.entry, &dpm_suspended_list); in dpm_suspend()
1828 if (!dev->power.no_pm_callbacks && in device_prepare_smart_suspend()
1832 if (dev->parent && !dev_pm_smart_suspend(dev->parent) && in device_prepare_smart_suspend()
1833 !dev->parent->power.ignore_children && !pm_runtime_blocked(dev->parent)) in device_prepare_smart_suspend()
1838 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) { in device_prepare_smart_suspend()
1839 if (!(link->flags & DL_FLAG_PM_RUNTIME)) in device_prepare_smart_suspend()
1842 if (!dev_pm_smart_suspend(link->supplier) && in device_prepare_smart_suspend()
1843 !pm_runtime_blocked(link->supplier)) { in device_prepare_smart_suspend()
1855 * device_prepare - Prepare a device for system power transition.
1859 * Execute the ->prepare() callback(s) for given device. No new children of the
1878 * suspend-resume cycle is complete, so prepare to trigger a warning on in device_prepare()
1883 if (dev->power.syscore) in device_prepare()
1888 dev->power.wakeup_path = false; in device_prepare()
1890 if (dev->power.no_pm_callbacks) in device_prepare()
1893 if (dev->pm_domain) in device_prepare()
1894 callback = dev->pm_domain->ops.prepare; in device_prepare()
1895 else if (dev->type && dev->type->pm) in device_prepare()
1896 callback = dev->type->pm->prepare; in device_prepare()
1897 else if (dev->class && dev->class->pm) in device_prepare()
1898 callback = dev->class->pm->prepare; in device_prepare()
1899 else if (dev->bus && dev->bus->pm) in device_prepare()
1900 callback = dev->bus->pm->prepare; in device_prepare()
1902 if (!callback && dev->driver && dev->driver->pm) in device_prepare()
1903 callback = dev->driver->pm->prepare; in device_prepare()
1920 spin_lock_irq(&dev->power.lock); in device_prepare()
1922 dev->power.smart_suspend = smart_suspend; in device_prepare()
1924 * A positive return value from ->prepare() means "this device appears in device_prepare()
1925 * to be runtime-suspended and its state is fine, so if it really is in device_prepare()
1926 * runtime-suspended, you can leave it in that state provided that you in device_prepare()
1930 dev->power.direct_complete = state.event == PM_EVENT_SUSPEND && in device_prepare()
1931 (ret > 0 || dev->power.no_pm_callbacks) && in device_prepare()
1934 spin_unlock_irq(&dev->power.lock); in device_prepare()
1940 * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
1943 * Execute the ->prepare() callback(s) for all devices.
1981 dev->power.is_prepared = true; in dpm_prepare()
1982 if (!list_empty(&dev->power.entry)) in dpm_prepare()
1983 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_prepare()
1984 } else if (error == -EAGAIN) { in dpm_prepare()
1987 dev_info(dev, "not prepared for power transition: code %d\n", in dpm_prepare()
2003 * dpm_suspend_start - Prepare devices for PM transition and suspend them.
2006 * Prepare all non-sysdev devices for system PM transition and execute "suspend"
2033 * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
2039 dpm_wait(dev, subordinate->power.async_suspend); in device_pm_wait_for_dev()
2045 * dpm_for_each_dev - device iterator.
2060 list_for_each_entry(dev, &dpm_list, power.entry) in dpm_for_each_dev()
2071 return !ops->prepare && in pm_ops_is_empty()
2072 !ops->suspend && in pm_ops_is_empty()
2073 !ops->suspend_late && in pm_ops_is_empty()
2074 !ops->suspend_noirq && in pm_ops_is_empty()
2075 !ops->resume_noirq && in pm_ops_is_empty()
2076 !ops->resume_early && in pm_ops_is_empty()
2077 !ops->resume && in pm_ops_is_empty()
2078 !ops->complete; in pm_ops_is_empty()
2085 spin_lock_irqsave(&dev->power.lock, flags); in device_pm_check_callbacks()
2086 dev->power.no_pm_callbacks = in device_pm_check_callbacks()
2087 (!dev->bus || (pm_ops_is_empty(dev->bus->pm) && in device_pm_check_callbacks()
2088 !dev->bus->suspend && !dev->bus->resume)) && in device_pm_check_callbacks()
2089 (!dev->class || pm_ops_is_empty(dev->class->pm)) && in device_pm_check_callbacks()
2090 (!dev->type || pm_ops_is_empty(dev->type->pm)) && in device_pm_check_callbacks()
2091 (!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) && in device_pm_check_callbacks()
2092 (!dev->driver || (pm_ops_is_empty(dev->driver->pm) && in device_pm_check_callbacks()
2093 !dev->driver->suspend && !dev->driver->resume)); in device_pm_check_callbacks()
2094 spin_unlock_irqrestore(&dev->power.lock, flags); in device_pm_check_callbacks()