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()
602 	reinit_completion(&dev->power.completion);  in dpm_async_fn()
605 		dev->power.async_in_progress = true;  in dpm_async_fn()
619 	dev->power.async_in_progress = false;  in dpm_async_fn()
624  * device_resume_noirq - Execute a "noirq resume" callback for given device.
642 	if (dev->power.syscore || dev->power.direct_complete)  in device_resume_noirq()
645 	if (!dev->power.is_noirq_suspended)  in device_resume_noirq()
655 	 * this device later, it needs to appear as "suspended" to PM-runtime,  in device_resume_noirq()
658 	 * Otherwise, the device is going to be resumed, so set its PM-runtime  in device_resume_noirq()
659 	 * status to "active" unless its power.set_active flag is clear, in  in device_resume_noirq()
660 	 * which case it is not necessary to update its PM-runtime status.  in device_resume_noirq()
664 	} else if (dev->power.set_active) {  in device_resume_noirq()
666 		dev->power.set_active = false;  in device_resume_noirq()
669 	if (dev->pm_domain) {  in device_resume_noirq()
670 		info = "noirq power domain ";  in device_resume_noirq()
671 		callback = pm_noirq_op(&dev->pm_domain->ops, state);  in device_resume_noirq()
672 	} else if (dev->type && dev->type->pm) {  in device_resume_noirq()
674 		callback = pm_noirq_op(dev->type->pm, state);  in device_resume_noirq()
675 	} else if (dev->class && dev->class->pm) {  in device_resume_noirq()
677 		callback = pm_noirq_op(dev->class->pm, state);  in device_resume_noirq()
678 	} else if (dev->bus && dev->bus->pm) {  in device_resume_noirq()
679 		info = "noirq bus ";  in device_resume_noirq()
680 		callback = pm_noirq_op(dev->bus->pm, state);  in device_resume_noirq()
688 	if (dev->driver && dev->driver->pm) {  in device_resume_noirq()
690 		callback = pm_noirq_op(dev->driver->pm, state);  in device_resume_noirq()
697 	dev->power.is_noirq_suspended = false;  in device_resume_noirq()
700 	complete_all(&dev->power.completion);  in device_resume_noirq()
732 	 * wait for the "non-async" ones they don't depend on.  in dpm_noirq_resume_devices()
734 	list_for_each_entry(dev, &dpm_noirq_list, power.entry)  in dpm_noirq_resume_devices()
739 		list_move_tail(&dev->power.entry, &dpm_late_early_list);  in dpm_noirq_resume_devices()
741 		if (!dev->power.async_in_progress) {  in dpm_noirq_resume_devices()
763  * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
778  * device_resume_early - Execute an "early resume" callback for given device.
794 	if (dev->power.syscore || dev->power.direct_complete)  in device_resume_early()
797 	if (!dev->power.is_late_suspended)  in device_resume_early()
803 	if (dev->pm_domain) {  in device_resume_early()
804 		info = "early power domain ";  in device_resume_early()
805 		callback = pm_late_early_op(&dev->pm_domain->ops, state);  in device_resume_early()
806 	} else if (dev->type && dev->type->pm) {  in device_resume_early()
808 		callback = pm_late_early_op(dev->type->pm, state);  in device_resume_early()
809 	} else if (dev->class && dev->class->pm) {  in device_resume_early()
811 		callback = pm_late_early_op(dev->class->pm, state);  in device_resume_early()
812 	} else if (dev->bus && dev->bus->pm) {  in device_resume_early()
813 		info = "early bus ";  in device_resume_early()
814 		callback = pm_late_early_op(dev->bus->pm, state);  in device_resume_early()
822 	if (dev->driver && dev->driver->pm) {  in device_resume_early()
824 		callback = pm_late_early_op(dev->driver->pm, state);  in device_resume_early()
831 	dev->power.is_late_suspended = false;  in device_resume_early()
837 	complete_all(&dev->power.completion);  in device_resume_early()
855  * dpm_resume_early - Execute "early resume" callbacks for all devices.
872 	 * wait for the "non-async" ones they don't depend on.  in dpm_resume_early()
874 	list_for_each_entry(dev, &dpm_late_early_list, power.entry)  in dpm_resume_early()
879 		list_move_tail(&dev->power.entry, &dpm_suspended_list);  in dpm_resume_early()
881 		if (!dev->power.async_in_progress) {  in dpm_resume_early()
903  * dpm_resume_start - Execute "noirq" and "early" device callbacks.
914  * device_resume - Execute "resume" callbacks for given device.
929 	if (dev->power.syscore)  in device_resume()
932 	if (!dev->power.is_suspended)  in device_resume()
935 	if (dev->power.direct_complete) {  in device_resume()
951 	dev->power.is_prepared = false;  in device_resume()
953 	if (dev->pm_domain) {  in device_resume()
954 		info = "power domain ";  in device_resume()
955 		callback = pm_op(&dev->pm_domain->ops, state);  in device_resume()
959 	if (dev->type && dev->type->pm) {  in device_resume()
961 		callback = pm_op(dev->type->pm, state);  in device_resume()
965 	if (dev->class && dev->class->pm) {  in device_resume()
967 		callback = pm_op(dev->class->pm, state);  in device_resume()
971 	if (dev->bus) {  in device_resume()
972 		if (dev->bus->pm) {  in device_resume()
973 			info = "bus ";  in device_resume()
974 			callback = pm_op(dev->bus->pm, state);  in device_resume()
975 		} else if (dev->bus->resume) {  in device_resume()
976 			info = "legacy bus ";  in device_resume()
977 			callback = dev->bus->resume;  in device_resume()
983 	if (!callback && dev->driver && dev->driver->pm) {  in device_resume()
985 		callback = pm_op(dev->driver->pm, state);  in device_resume()
990 	dev->power.is_suspended = false;  in device_resume()
996 	complete_all(&dev->power.completion);  in device_resume()
1016  * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
1037 	 * wait for the "non-async" ones they don't depend on.  in dpm_resume()
1039 	list_for_each_entry(dev, &dpm_suspended_list, power.entry)  in dpm_resume()
1044 		list_move_tail(&dev->power.entry, &dpm_prepared_list);  in dpm_resume()
1046 		if (!dev->power.async_in_progress) {  in dpm_resume()
1070  * device_complete - Complete a PM transition for given device.
1079 	if (dev->power.syscore)  in device_complete()
1084 	if (dev->pm_domain) {  in device_complete()
1085 		info = "completing power domain ";  in device_complete()
1086 		callback = dev->pm_domain->ops.complete;  in device_complete()
1087 	} else if (dev->type && dev->type->pm) {  in device_complete()
1089 		callback = dev->type->pm->complete;  in device_complete()
1090 	} else if (dev->class && dev->class->pm) {  in device_complete()
1092 		callback = dev->class->pm->complete;  in device_complete()
1093 	} else if (dev->bus && dev->bus->pm) {  in device_complete()
1094 		info = "completing bus ";  in device_complete()
1095 		callback = dev->bus->pm->complete;  in device_complete()
1098 	if (!callback && dev->driver && dev->driver->pm) {  in device_complete()
1100 		callback = dev->driver->pm->complete;  in device_complete()
1115  * dpm_complete - Complete a PM transition for all non-sysdev devices.
1118  * Execute the ->complete() callbacks for all devices whose PM status is not
1134 		dev->power.is_prepared = false;  in dpm_complete()
1135 		list_move(&dev->power.entry, &list);  in dpm_complete()
1150 	/* Allow device probing and trigger re-probing of deferred devices */  in dpm_complete()
1156  * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1170 /*------------------------- Suspend routines -------------------------*/
1173  * resume_event - Return a "resume" message for given "suspend" sleep state.
1198 	if (dev->parent)  in dpm_superior_set_must_resume()
1199 		dev->parent->power.must_resume = true;  in dpm_superior_set_must_resume()
1203 	list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node)  in dpm_superior_set_must_resume()
1204 		link->supplier->power.must_resume = true;  in dpm_superior_set_must_resume()
1210  * device_suspend_noirq - Execute a "noirq suspend" callback for given device.
1232 	if (dev->power.syscore || dev->power.direct_complete)  in device_suspend_noirq()
1235 	if (dev->pm_domain) {  in device_suspend_noirq()
1236 		info = "noirq power domain ";  in device_suspend_noirq()
1237 		callback = pm_noirq_op(&dev->pm_domain->ops, state);  in device_suspend_noirq()
1238 	} else if (dev->type && dev->type->pm) {  in device_suspend_noirq()
1240 		callback = pm_noirq_op(dev->type->pm, state);  in device_suspend_noirq()
1241 	} else if (dev->class && dev->class->pm) {  in device_suspend_noirq()
1243 		callback = pm_noirq_op(dev->class->pm, state);  in device_suspend_noirq()
1244 	} else if (dev->bus && dev->bus->pm) {  in device_suspend_noirq()
1245 		info = "noirq bus ";  in device_suspend_noirq()
1246 		callback = pm_noirq_op(dev->bus->pm, state);  in device_suspend_noirq()
1254 	if (dev->driver && dev->driver->pm) {  in device_suspend_noirq()
1256 		callback = pm_noirq_op(dev->driver->pm, state);  in device_suspend_noirq()
1269 	dev->power.is_noirq_suspended = true;  in device_suspend_noirq()
1278 	      dev->power.may_skip_resume) || !pm_runtime_need_not_resume(dev))  in device_suspend_noirq()
1279 		dev->power.must_resume = true;  in device_suspend_noirq()
1281 	if (dev->power.must_resume) {  in device_suspend_noirq()
1283 			dev->power.set_active = true;  in device_suspend_noirq()
1284 			if (dev->parent && !dev->parent->power.ignore_children)  in device_suspend_noirq()
1285 				dev->parent->power.set_active = true;  in device_suspend_noirq()
1291 	complete_all(&dev->power.completion);  in device_suspend_noirq()
1319 		list_move(&dev->power.entry, &dpm_noirq_list);  in dpm_noirq_suspend_devices()
1353  * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1357  * "noirq" suspend callbacks for all non-sysdev devices.
1375 	struct device *parent = dev->parent;  in dpm_propagate_wakeup_to_parent()
1380 	spin_lock_irq(&parent->power.lock);  in dpm_propagate_wakeup_to_parent()
1382 	if (device_wakeup_path(dev) && !parent->power.ignore_children)  in dpm_propagate_wakeup_to_parent()
1383 		parent->power.wakeup_path = true;  in dpm_propagate_wakeup_to_parent()
1385 	spin_unlock_irq(&parent->power.lock);  in dpm_propagate_wakeup_to_parent()
1389  * device_suspend_late - Execute a "late suspend" callback for given device.
1413 		async_error = -EBUSY;  in device_suspend_late()
1417 	if (dev->power.syscore || dev->power.direct_complete)  in device_suspend_late()
1420 	if (dev->pm_domain) {  in device_suspend_late()
1421 		info = "late power domain ";  in device_suspend_late()
1422 		callback = pm_late_early_op(&dev->pm_domain->ops, state);  in device_suspend_late()
1423 	} else if (dev->type && dev->type->pm) {  in device_suspend_late()
1425 		callback = pm_late_early_op(dev->type->pm, state);  in device_suspend_late()
1426 	} else if (dev->class && dev->class->pm) {  in device_suspend_late()
1428 		callback = pm_late_early_op(dev->class->pm, state);  in device_suspend_late()
1429 	} else if (dev->bus && dev->bus->pm) {  in device_suspend_late()
1430 		info = "late bus ";  in device_suspend_late()
1431 		callback = pm_late_early_op(dev->bus->pm, state);  in device_suspend_late()
1439 	if (dev->driver && dev->driver->pm) {  in device_suspend_late()
1441 		callback = pm_late_early_op(dev->driver->pm, state);  in device_suspend_late()
1455 	dev->power.is_late_suspended = true;  in device_suspend_late()
1459 	complete_all(&dev->power.completion);  in device_suspend_late()
1472  * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1492 		list_move(&dev->power.entry, &dpm_late_early_list);  in dpm_suspend_late()
1527  * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1550  * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1580 	if (dev->parent) {  in dpm_clear_superiors_direct_complete()
1581 		spin_lock_irq(&dev->parent->power.lock);  in dpm_clear_superiors_direct_complete()
1582 		dev->parent->power.direct_complete = false;  in dpm_clear_superiors_direct_complete()
1583 		spin_unlock_irq(&dev->parent->power.lock);  in dpm_clear_superiors_direct_complete()
1588 	list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) {  in dpm_clear_superiors_direct_complete()
1589 		spin_lock_irq(&link->supplier->power.lock);  in dpm_clear_superiors_direct_complete()
1590 		link->supplier->power.direct_complete = false;  in dpm_clear_superiors_direct_complete()
1591 		spin_unlock_irq(&link->supplier->power.lock);  in dpm_clear_superiors_direct_complete()
1598  * device_suspend - Execute "suspend" callbacks for given device.
1616 		dev->power.direct_complete = false;  in device_suspend()
1623 	 * resume it before proceeding with invoking the system-wide suspend  in device_suspend()
1626 	 * If the system-wide suspend callbacks below change the configuration  in device_suspend()
1628 	 * ensure that its runtime-resume callbacks will not be confused by that  in device_suspend()
1634 		dev->power.direct_complete = false;  in device_suspend()
1635 		async_error = -EBUSY;  in device_suspend()
1639 	if (dev->power.syscore)  in device_suspend()
1644 		dev->power.direct_complete = false;  in device_suspend()
1646 	if (dev->power.direct_complete) {  in device_suspend()
1650 				pm_dev_dbg(dev, state, "direct-complete ");  in device_suspend()
1651 				dev->power.is_suspended = true;  in device_suspend()
1657 		dev->power.direct_complete = false;  in device_suspend()
1660 	dev->power.may_skip_resume = true;  in device_suspend()
1661 	dev->power.must_resume = !dev_pm_test_driver_flags(dev, DPM_FLAG_MAY_SKIP_RESUME);  in device_suspend()
1666 	if (dev->pm_domain) {  in device_suspend()
1667 		info = "power domain ";  in device_suspend()
1668 		callback = pm_op(&dev->pm_domain->ops, state);  in device_suspend()
1672 	if (dev->type && dev->type->pm) {  in device_suspend()
1674 		callback = pm_op(dev->type->pm, state);  in device_suspend()
1678 	if (dev->class && dev->class->pm) {  in device_suspend()
1680 		callback = pm_op(dev->class->pm, state);  in device_suspend()
1684 	if (dev->bus) {  in device_suspend()
1685 		if (dev->bus->pm) {  in device_suspend()
1686 			info = "bus ";  in device_suspend()
1687 			callback = pm_op(dev->bus->pm, state);  in device_suspend()
1688 		} else if (dev->bus->suspend) {  in device_suspend()
1689 			pm_dev_dbg(dev, state, "legacy bus ");  in device_suspend()
1690 			error = legacy_suspend(dev, state, dev->bus->suspend,  in device_suspend()
1691 						"legacy bus ");  in device_suspend()
1697 	if (!callback && dev->driver && dev->driver->pm) {  in device_suspend()
1699 		callback = pm_op(dev->driver->pm, state);  in device_suspend()
1706 		dev->power.is_suspended = true;  in device_suspend()
1708 			dev->power.wakeup_path = true;  in device_suspend()
1724 	complete_all(&dev->power.completion);  in device_suspend()
1738  * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1760 		list_move(&dev->power.entry, &dpm_suspended_list);  in dpm_suspend()
1794  * device_prepare - Prepare a device for system power transition.
1798  * Execute the ->prepare() callback(s) for given device.  No new children of the
1814 	if (dev->power.syscore)  in device_prepare()
1819 	dev->power.wakeup_path = false;  in device_prepare()
1821 	if (dev->power.no_pm_callbacks)  in device_prepare()
1824 	if (dev->pm_domain)  in device_prepare()
1825 		callback = dev->pm_domain->ops.prepare;  in device_prepare()
1826 	else if (dev->type && dev->type->pm)  in device_prepare()
1827 		callback = dev->type->pm->prepare;  in device_prepare()
1828 	else if (dev->class && dev->class->pm)  in device_prepare()
1829 		callback = dev->class->pm->prepare;  in device_prepare()
1830 	else if (dev->bus && dev->bus->pm)  in device_prepare()
1831 		callback = dev->bus->pm->prepare;  in device_prepare()
1833 	if (!callback && dev->driver && dev->driver->pm)  in device_prepare()
1834 		callback = dev->driver->pm->prepare;  in device_prepare()
1848 	 * A positive return value from ->prepare() means "this device appears  in device_prepare()
1849 	 * to be runtime-suspended and its state is fine, so if it really is  in device_prepare()
1850 	 * runtime-suspended, you can leave it in that state provided that you  in device_prepare()
1854 	spin_lock_irq(&dev->power.lock);  in device_prepare()
1855 	dev->power.direct_complete = state.event == PM_EVENT_SUSPEND &&  in device_prepare()
1856 		(ret > 0 || dev->power.no_pm_callbacks) &&  in device_prepare()
1858 	spin_unlock_irq(&dev->power.lock);  in device_prepare()
1863  * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
1866  * Execute the ->prepare() callback(s) for all devices.
1904 			dev->power.is_prepared = true;  in dpm_prepare()
1905 			if (!list_empty(&dev->power.entry))  in dpm_prepare()
1906 				list_move_tail(&dev->power.entry, &dpm_prepared_list);  in dpm_prepare()
1907 		} else if (error == -EAGAIN) {  in dpm_prepare()
1910 			dev_info(dev, "not prepared for power transition: code %d\n",  in dpm_prepare()
1926  * dpm_suspend_start - Prepare devices for PM transition and suspend them.
1929  * Prepare all non-sysdev devices for system PM transition and execute "suspend"
1956  * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
1962 	dpm_wait(dev, subordinate->power.async_suspend);  in device_pm_wait_for_dev()
1968  * dpm_for_each_dev - device iterator.
1983 	list_for_each_entry(dev, &dpm_list, power.entry)  in dpm_for_each_dev()
1994 	return !ops->prepare &&  in pm_ops_is_empty()
1995 	       !ops->suspend &&  in pm_ops_is_empty()
1996 	       !ops->suspend_late &&  in pm_ops_is_empty()
1997 	       !ops->suspend_noirq &&  in pm_ops_is_empty()
1998 	       !ops->resume_noirq &&  in pm_ops_is_empty()
1999 	       !ops->resume_early &&  in pm_ops_is_empty()
2000 	       !ops->resume &&  in pm_ops_is_empty()
2001 	       !ops->complete;  in pm_ops_is_empty()
2008 	spin_lock_irqsave(&dev->power.lock, flags);  in device_pm_check_callbacks()
2009 	dev->power.no_pm_callbacks =  in device_pm_check_callbacks()
2010 		(!dev->bus || (pm_ops_is_empty(dev->bus->pm) &&  in device_pm_check_callbacks()
2011 		 !dev->bus->suspend && !dev->bus->resume)) &&  in device_pm_check_callbacks()
2012 		(!dev->class || pm_ops_is_empty(dev->class->pm)) &&  in device_pm_check_callbacks()
2013 		(!dev->type || pm_ops_is_empty(dev->type->pm)) &&  in device_pm_check_callbacks()
2014 		(!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) &&  in device_pm_check_callbacks()
2015 		(!dev->driver || (pm_ops_is_empty(dev->driver->pm) &&  in device_pm_check_callbacks()
2016 		 !dev->driver->suspend && !dev->driver->resume));  in device_pm_check_callbacks()
2017 	spin_unlock_irqrestore(&dev->power.lock, flags);  in device_pm_check_callbacks()