Lines Matching +full:system +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
25 #include <linux/pm-trace.h>
95 * device_pm_sleep_init - Initialize system suspend-related device fields.
100 dev->power.is_prepared = false; in device_pm_sleep_init()
101 dev->power.is_suspended = false; in device_pm_sleep_init()
102 dev->power.is_noirq_suspended = false; in device_pm_sleep_init()
103 dev->power.is_late_suspended = false; in device_pm_sleep_init()
104 init_completion(&dev->power.completion); in device_pm_sleep_init()
105 complete_all(&dev->power.completion); in device_pm_sleep_init()
106 dev->power.wakeup = NULL; in device_pm_sleep_init()
107 INIT_LIST_HEAD(&dev->power.entry); in device_pm_sleep_init()
111 * device_pm_lock - Lock the list of active devices used by the PM core.
119 * device_pm_unlock - Unlock the list of active devices used by the PM core.
127 * device_pm_add - Add a device to the PM core's list of active devices.
137 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_add()
140 if (dev->parent && dev->parent->power.is_prepared) in device_pm_add()
142 dev_name(dev->parent)); in device_pm_add()
143 list_add_tail(&dev->power.entry, &dpm_list); in device_pm_add()
144 dev->power.in_dpm_list = true; in device_pm_add()
149 * device_pm_remove - Remove a device from the PM core's list of active devices.
158 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_remove()
159 complete_all(&dev->power.completion); in device_pm_remove()
161 list_del_init(&dev->power.entry); in device_pm_remove()
162 dev->power.in_dpm_list = false; in device_pm_remove()
170 * device_pm_move_before - Move device in the PM core's list of active devices.
177 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_before()
178 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_before()
180 list_move_tail(&deva->power.entry, &devb->power.entry); in device_pm_move_before()
184 * device_pm_move_after - Move device in the PM core's list of active devices.
191 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), in device_pm_move_after()
192 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); in device_pm_move_after()
194 list_move(&deva->power.entry, &devb->power.entry); in device_pm_move_after()
198 * device_pm_move_last - Move device to end of the PM core's list of devices.
204 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); in device_pm_move_last()
205 list_move_tail(&dev->power.entry, &dpm_list); in device_pm_move_last()
215 dev->parent ? dev_name(dev->parent) : "none"); in initcall_debug_start()
236 * dpm_wait - Wait for a PM operation to complete.
245 if (async || (pm_async_enabled && dev->power.async_suspend)) in dpm_wait()
246 wait_for_completion(&dev->power.completion); in dpm_wait()
274 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) in dpm_wait_for_suppliers()
275 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_wait_for_suppliers()
276 dpm_wait(link->supplier, async); in dpm_wait_for_suppliers()
299 parent = get_device(dev->parent); in dpm_wait_for_superior()
324 * probe, but that cannot happen during system suspend/resume. In in dpm_wait_for_consumers()
331 list_for_each_entry_rcu_locked(link, &dev->links.consumers, s_node) in dpm_wait_for_consumers()
332 if (READ_ONCE(link->status) != DL_STATE_DORMANT) in dpm_wait_for_consumers()
333 dpm_wait(link->consumer, async); in dpm_wait_for_consumers()
345 * pm_op - Return the PM operation appropriate for given PM event.
347 * @state: PM transition of the system being carried out.
354 return ops->suspend; in pm_op()
356 return ops->resume; in pm_op()
361 return ops->freeze; in pm_op()
363 return ops->poweroff; in pm_op()
366 return ops->thaw; in pm_op()
368 return ops->restore; in pm_op()
376 * pm_late_early_op - Return the PM operation appropriate for given PM event.
378 * @state: PM transition of the system being carried out.
388 return ops->suspend_late; in pm_late_early_op()
390 return ops->resume_early; in pm_late_early_op()
395 return ops->freeze_late; in pm_late_early_op()
397 return ops->poweroff_late; in pm_late_early_op()
400 return ops->thaw_early; in pm_late_early_op()
402 return ops->restore_early; in pm_late_early_op()
410 * pm_noirq_op - Return the PM operation appropriate for given PM event.
412 * @state: PM transition of the system being carried out.
422 return ops->suspend_noirq; in pm_noirq_op()
424 return ops->resume_noirq; in pm_noirq_op()
429 return ops->freeze_noirq; in pm_noirq_op()
431 return ops->poweroff_noirq; in pm_noirq_op()
434 return ops->thaw_noirq; in pm_noirq_op()
436 return ops->restore_noirq; in pm_noirq_op()
510 * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
515 * capture a crash-dump in pstore.
521 dev_emerg(wd->dev, "**** DPM device timeout ****\n"); in dpm_watchdog_handler()
522 show_stack(wd->tsk, NULL, KERN_EMERG); in dpm_watchdog_handler()
524 dev_driver_string(wd->dev), dev_name(wd->dev)); in dpm_watchdog_handler()
528 * dpm_watchdog_set - Enable pm watchdog for given device.
534 struct timer_list *timer = &wd->timer; in dpm_watchdog_set()
536 wd->dev = dev; in dpm_watchdog_set()
537 wd->tsk = current; in dpm_watchdog_set()
541 timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_TIMEOUT; in dpm_watchdog_set()
546 * dpm_watchdog_clear - Disable suspend/resume watchdog.
551 struct timer_list *timer = &wd->timer; in dpm_watchdog_clear()
562 /*------------------------- Resume routines -------------------------*/
565 * dev_pm_skip_resume - System-wide device resume optimization check.
569 * - %false if the transition under way is RESTORE.
570 * - Return value of dev_pm_skip_suspend() if the transition under way is THAW.
571 * - The logical negation of %power.must_resume otherwise (that is, when the
582 return !dev->power.must_resume; in dev_pm_skip_resume()
586 * device_resume_noirq - Execute a "noirq resume" callback for given device.
588 * @state: PM transition of the system being carried out.
604 if (dev->power.syscore || dev->power.direct_complete) in device_resume_noirq()
607 if (!dev->power.is_noirq_suspended) in device_resume_noirq()
617 * this device later, it needs to appear as "suspended" to PM-runtime, in device_resume_noirq()
620 * Otherwise, the device is going to be resumed, so set its PM-runtime in device_resume_noirq()
629 if (dev->pm_domain) { in device_resume_noirq()
631 callback = pm_noirq_op(&dev->pm_domain->ops, state); in device_resume_noirq()
632 } else if (dev->type && dev->type->pm) { in device_resume_noirq()
634 callback = pm_noirq_op(dev->type->pm, state); in device_resume_noirq()
635 } else if (dev->class && dev->class->pm) { in device_resume_noirq()
637 callback = pm_noirq_op(dev->class->pm, state); in device_resume_noirq()
638 } else if (dev->bus && dev->bus->pm) { in device_resume_noirq()
639 info = "noirq bus "; in device_resume_noirq()
640 callback = pm_noirq_op(dev->bus->pm, state); in device_resume_noirq()
648 if (dev->driver && dev->driver->pm) { in device_resume_noirq()
650 callback = pm_noirq_op(dev->driver->pm, state); in device_resume_noirq()
657 dev->power.is_noirq_suspended = false; in device_resume_noirq()
660 complete_all(&dev->power.completion); in device_resume_noirq()
667 return dev->power.async_suspend && pm_async_enabled in is_async()
673 reinit_completion(&dev->power.completion); in dpm_async_fn()
708 * delayed by non-async resuming devices. in dpm_noirq_resume_devices()
716 list_move_tail(&dev->power.entry, &dpm_late_early_list); in dpm_noirq_resume_devices()
741 * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
742 * @state: PM transition of the system being carried out.
758 * device_resume_early - Execute an "early resume" callback for given device.
760 * @state: PM transition of the system being carried out.
774 if (dev->power.syscore || dev->power.direct_complete) in device_resume_early()
777 if (!dev->power.is_late_suspended) in device_resume_early()
783 if (dev->pm_domain) { in device_resume_early()
785 callback = pm_late_early_op(&dev->pm_domain->ops, state); in device_resume_early()
786 } else if (dev->type && dev->type->pm) { in device_resume_early()
788 callback = pm_late_early_op(dev->type->pm, state); in device_resume_early()
789 } else if (dev->class && dev->class->pm) { in device_resume_early()
791 callback = pm_late_early_op(dev->class->pm, state); in device_resume_early()
792 } else if (dev->bus && dev->bus->pm) { in device_resume_early()
793 info = "early bus "; in device_resume_early()
794 callback = pm_late_early_op(dev->bus->pm, state); in device_resume_early()
802 if (dev->driver && dev->driver->pm) { in device_resume_early()
804 callback = pm_late_early_op(dev->driver->pm, state); in device_resume_early()
811 dev->power.is_late_suspended = false; in device_resume_early()
817 complete_all(&dev->power.completion); in device_resume_early()
834 * dpm_resume_early - Execute "early resume" callbacks for all devices.
835 * @state: PM transition of the system being carried out.
849 * delayed by non-async resuming devices. in dpm_resume_early()
857 list_move_tail(&dev->power.entry, &dpm_suspended_list); in dpm_resume_early()
881 * dpm_resume_start - Execute "noirq" and "early" device callbacks.
882 * @state: PM transition of the system being carried out.
892 * device_resume - Execute "resume" callbacks for given device.
894 * @state: PM transition of the system being carried out.
907 if (dev->power.syscore) in device_resume()
910 if (dev->power.direct_complete) { in device_resume()
926 dev->power.is_prepared = false; in device_resume()
928 if (!dev->power.is_suspended) in device_resume()
931 if (dev->pm_domain) { in device_resume()
933 callback = pm_op(&dev->pm_domain->ops, state); in device_resume()
937 if (dev->type && dev->type->pm) { in device_resume()
939 callback = pm_op(dev->type->pm, state); in device_resume()
943 if (dev->class && dev->class->pm) { in device_resume()
945 callback = pm_op(dev->class->pm, state); in device_resume()
949 if (dev->bus) { in device_resume()
950 if (dev->bus->pm) { in device_resume()
951 info = "bus "; in device_resume()
952 callback = pm_op(dev->bus->pm, state); in device_resume()
953 } else if (dev->bus->resume) { in device_resume()
954 info = "legacy bus "; in device_resume()
955 callback = dev->bus->resume; in device_resume()
961 if (!callback && dev->driver && dev->driver->pm) { in device_resume()
963 callback = pm_op(dev->driver->pm, state); in device_resume()
968 dev->power.is_suspended = false; in device_resume()
975 complete_all(&dev->power.completion); in device_resume()
994 * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
995 * @state: PM transition of the system being carried out.
1033 if (!list_empty(&dev->power.entry)) in dpm_resume()
1034 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_resume()
1047 * device_complete - Complete a PM transition for given device.
1049 * @state: PM transition of the system being carried out.
1056 if (dev->power.syscore) in device_complete()
1061 if (dev->pm_domain) { in device_complete()
1063 callback = dev->pm_domain->ops.complete; in device_complete()
1064 } else if (dev->type && dev->type->pm) { in device_complete()
1066 callback = dev->type->pm->complete; in device_complete()
1067 } else if (dev->class && dev->class->pm) { in device_complete()
1069 callback = dev->class->pm->complete; in device_complete()
1070 } else if (dev->bus && dev->bus->pm) { in device_complete()
1071 info = "completing bus "; in device_complete()
1072 callback = dev->bus->pm->complete; in device_complete()
1075 if (!callback && dev->driver && dev->driver->pm) { in device_complete()
1077 callback = dev->driver->pm->complete; in device_complete()
1092 * dpm_complete - Complete a PM transition for all non-sysdev devices.
1093 * @state: PM transition of the system being carried out.
1095 * Execute the ->complete() callbacks for all devices whose PM status is not
1111 dev->power.is_prepared = false; in dpm_complete()
1112 list_move(&dev->power.entry, &list); in dpm_complete()
1125 /* Allow device probing and trigger re-probing of deferred devices */ in dpm_complete()
1131 * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1132 * @state: PM transition of the system being carried out.
1135 * the system.
1145 /*------------------------- Suspend routines -------------------------*/
1148 * resume_event - Return a "resume" message for given "suspend" sleep state.
1173 if (dev->parent) in dpm_superior_set_must_resume()
1174 dev->parent->power.must_resume = true; in dpm_superior_set_must_resume()
1178 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) in dpm_superior_set_must_resume()
1179 link->supplier->power.must_resume = true; in dpm_superior_set_must_resume()
1185 * __device_suspend_noirq - Execute a "noirq suspend" callback for given device.
1187 * @state: PM transition of the system being carried out.
1207 if (dev->power.syscore || dev->power.direct_complete) in __device_suspend_noirq()
1210 if (dev->pm_domain) { in __device_suspend_noirq()
1212 callback = pm_noirq_op(&dev->pm_domain->ops, state); in __device_suspend_noirq()
1213 } else if (dev->type && dev->type->pm) { in __device_suspend_noirq()
1215 callback = pm_noirq_op(dev->type->pm, state); in __device_suspend_noirq()
1216 } else if (dev->class && dev->class->pm) { in __device_suspend_noirq()
1218 callback = pm_noirq_op(dev->class->pm, state); in __device_suspend_noirq()
1219 } else if (dev->bus && dev->bus->pm) { in __device_suspend_noirq()
1220 info = "noirq bus "; in __device_suspend_noirq()
1221 callback = pm_noirq_op(dev->bus->pm, state); in __device_suspend_noirq()
1229 if (dev->driver && dev->driver->pm) { in __device_suspend_noirq()
1231 callback = pm_noirq_op(dev->driver->pm, state); in __device_suspend_noirq()
1244 dev->power.is_noirq_suspended = true; in __device_suspend_noirq()
1248 * system suspend (as indicated by their PM-runtime usage counters) in __device_suspend_noirq()
1252 if (atomic_read(&dev->power.usage_count) > 1 || in __device_suspend_noirq()
1254 dev->power.may_skip_resume)) in __device_suspend_noirq()
1255 dev->power.must_resume = true; in __device_suspend_noirq()
1257 if (dev->power.must_resume) in __device_suspend_noirq()
1261 complete_all(&dev->power.completion); in __device_suspend_noirq()
1313 if (!list_empty(&dev->power.entry)) in dpm_noirq_suspend_devices()
1314 list_move(&dev->power.entry, &dpm_noirq_list); in dpm_noirq_suspend_devices()
1335 * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1336 * @state: PM transition of the system being carried out.
1339 * "noirq" suspend callbacks for all non-sysdev devices.
1359 struct device *parent = dev->parent; in dpm_propagate_wakeup_to_parent()
1364 spin_lock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1366 if (dev->power.wakeup_path && !parent->power.ignore_children) in dpm_propagate_wakeup_to_parent()
1367 parent->power.wakeup_path = true; in dpm_propagate_wakeup_to_parent()
1369 spin_unlock_irq(&parent->power.lock); in dpm_propagate_wakeup_to_parent()
1373 * __device_suspend_late - Execute a "late suspend" callback for given device.
1375 * @state: PM transition of the system being carried out.
1397 async_error = -EBUSY; in __device_suspend_late()
1401 if (dev->power.syscore || dev->power.direct_complete) in __device_suspend_late()
1404 if (dev->pm_domain) { in __device_suspend_late()
1406 callback = pm_late_early_op(&dev->pm_domain->ops, state); in __device_suspend_late()
1407 } else if (dev->type && dev->type->pm) { in __device_suspend_late()
1409 callback = pm_late_early_op(dev->type->pm, state); in __device_suspend_late()
1410 } else if (dev->class && dev->class->pm) { in __device_suspend_late()
1412 callback = pm_late_early_op(dev->class->pm, state); in __device_suspend_late()
1413 } else if (dev->bus && dev->bus->pm) { in __device_suspend_late()
1414 info = "late bus "; in __device_suspend_late()
1415 callback = pm_late_early_op(dev->bus->pm, state); in __device_suspend_late()
1423 if (dev->driver && dev->driver->pm) { in __device_suspend_late()
1425 callback = pm_late_early_op(dev->driver->pm, state); in __device_suspend_late()
1439 dev->power.is_late_suspended = true; in __device_suspend_late()
1443 complete_all(&dev->power.completion); in __device_suspend_late()
1469 * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1470 * @state: PM transition of the system being carried out.
1491 if (!list_empty(&dev->power.entry)) in dpm_suspend_late()
1492 list_move(&dev->power.entry, &dpm_late_early_list); in dpm_suspend_late()
1520 * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1521 * @state: PM transition of the system being carried out.
1543 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1545 * @state: PM transition of the system being carried out.
1573 if (dev->parent) { in dpm_clear_superiors_direct_complete()
1574 spin_lock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1575 dev->parent->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1576 spin_unlock_irq(&dev->parent->power.lock); in dpm_clear_superiors_direct_complete()
1581 list_for_each_entry_rcu_locked(link, &dev->links.suppliers, c_node) { in dpm_clear_superiors_direct_complete()
1582 spin_lock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1583 link->supplier->power.direct_complete = false; in dpm_clear_superiors_direct_complete()
1584 spin_unlock_irq(&link->supplier->power.lock); in dpm_clear_superiors_direct_complete()
1591 * __device_suspend - Execute "suspend" callbacks for given device.
1593 * @state: PM transition of the system being carried out.
1609 dev->power.direct_complete = false; in __device_suspend()
1616 * resume it before proceeding with invoking the system-wide suspend in __device_suspend()
1619 * If the system-wide suspend callbacks below change the configuration in __device_suspend()
1621 * ensure that its runtime-resume callbacks will not be confused by that in __device_suspend()
1627 dev->power.direct_complete = false; in __device_suspend()
1628 async_error = -EBUSY; in __device_suspend()
1632 if (dev->power.syscore) in __device_suspend()
1636 if (device_may_wakeup(dev) || dev->power.wakeup_path) in __device_suspend()
1637 dev->power.direct_complete = false; in __device_suspend()
1639 if (dev->power.direct_complete) { in __device_suspend()
1643 pm_dev_dbg(dev, state, "direct-complete "); in __device_suspend()
1649 dev->power.direct_complete = false; in __device_suspend()
1652 dev->power.may_skip_resume = true; in __device_suspend()
1653 dev->power.must_resume = !dev_pm_test_driver_flags(dev, DPM_FLAG_MAY_SKIP_RESUME); in __device_suspend()
1658 if (dev->pm_domain) { in __device_suspend()
1660 callback = pm_op(&dev->pm_domain->ops, state); in __device_suspend()
1664 if (dev->type && dev->type->pm) { in __device_suspend()
1666 callback = pm_op(dev->type->pm, state); in __device_suspend()
1670 if (dev->class && dev->class->pm) { in __device_suspend()
1672 callback = pm_op(dev->class->pm, state); in __device_suspend()
1676 if (dev->bus) { in __device_suspend()
1677 if (dev->bus->pm) { in __device_suspend()
1678 info = "bus "; in __device_suspend()
1679 callback = pm_op(dev->bus->pm, state); in __device_suspend()
1680 } else if (dev->bus->suspend) { in __device_suspend()
1681 pm_dev_dbg(dev, state, "legacy bus "); in __device_suspend()
1682 error = legacy_suspend(dev, state, dev->bus->suspend, in __device_suspend()
1683 "legacy bus "); in __device_suspend()
1689 if (!callback && dev->driver && dev->driver->pm) { in __device_suspend()
1691 callback = pm_op(dev->driver->pm, state); in __device_suspend()
1698 dev->power.is_suspended = true; in __device_suspend()
1700 dev->power.wakeup_path = true; in __device_suspend()
1716 complete_all(&dev->power.completion); in __device_suspend()
1744 * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1745 * @state: PM transition of the system being carried out.
1776 if (!list_empty(&dev->power.entry)) in dpm_suspend()
1777 list_move(&dev->power.entry, &dpm_suspended_list); in dpm_suspend()
1796 * device_prepare - Prepare a device for system power transition.
1798 * @state: PM transition of the system being carried out.
1800 * Execute the ->prepare() callback(s) for given device. No new children of the
1816 if (dev->power.syscore) in device_prepare()
1821 dev->power.wakeup_path = false; in device_prepare()
1823 if (dev->power.no_pm_callbacks) in device_prepare()
1826 if (dev->pm_domain) in device_prepare()
1827 callback = dev->pm_domain->ops.prepare; in device_prepare()
1828 else if (dev->type && dev->type->pm) in device_prepare()
1829 callback = dev->type->pm->prepare; in device_prepare()
1830 else if (dev->class && dev->class->pm) in device_prepare()
1831 callback = dev->class->pm->prepare; in device_prepare()
1832 else if (dev->bus && dev->bus->pm) in device_prepare()
1833 callback = dev->bus->pm->prepare; in device_prepare()
1835 if (!callback && dev->driver && dev->driver->pm) in device_prepare()
1836 callback = dev->driver->pm->prepare; in device_prepare()
1850 * A positive return value from ->prepare() means "this device appears in device_prepare()
1851 * to be runtime-suspended and its state is fine, so if it really is in device_prepare()
1852 * runtime-suspended, you can leave it in that state provided that you in device_prepare()
1856 spin_lock_irq(&dev->power.lock); in device_prepare()
1857 dev->power.direct_complete = state.event == PM_EVENT_SUSPEND && in device_prepare()
1858 (ret > 0 || dev->power.no_pm_callbacks) && in device_prepare()
1860 spin_unlock_irq(&dev->power.lock); in device_prepare()
1865 * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
1866 * @state: PM transition of the system being carried out.
1868 * Execute the ->prepare() callback(s) for all devices.
1885 * hibernation and system behavior will be unpredictable in this case. in dpm_prepare()
1904 if (error == -EAGAIN) { in dpm_prepare()
1917 dev->power.is_prepared = true; in dpm_prepare()
1918 if (!list_empty(&dev->power.entry)) in dpm_prepare()
1919 list_move_tail(&dev->power.entry, &dpm_prepared_list); in dpm_prepare()
1928 * dpm_suspend_start - Prepare devices for PM transition and suspend them.
1929 * @state: PM transition of the system being carried out.
1931 * Prepare all non-sysdev devices for system PM transition and execute "suspend"
1958 * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
1964 dpm_wait(dev, subordinate->power.async_suspend); in device_pm_wait_for_dev()
1970 * dpm_for_each_dev - device iterator.
1996 return !ops->prepare && in pm_ops_is_empty()
1997 !ops->suspend && in pm_ops_is_empty()
1998 !ops->suspend_late && in pm_ops_is_empty()
1999 !ops->suspend_noirq && in pm_ops_is_empty()
2000 !ops->resume_noirq && in pm_ops_is_empty()
2001 !ops->resume_early && in pm_ops_is_empty()
2002 !ops->resume && in pm_ops_is_empty()
2003 !ops->complete; in pm_ops_is_empty()
2010 spin_lock_irqsave(&dev->power.lock, flags); in device_pm_check_callbacks()
2011 dev->power.no_pm_callbacks = in device_pm_check_callbacks()
2012 (!dev->bus || (pm_ops_is_empty(dev->bus->pm) && in device_pm_check_callbacks()
2013 !dev->bus->suspend && !dev->bus->resume)) && in device_pm_check_callbacks()
2014 (!dev->class || pm_ops_is_empty(dev->class->pm)) && in device_pm_check_callbacks()
2015 (!dev->type || pm_ops_is_empty(dev->type->pm)) && in device_pm_check_callbacks()
2016 (!dev->pm_domain || pm_ops_is_empty(&dev->pm_domain->ops)) && in device_pm_check_callbacks()
2017 (!dev->driver || (pm_ops_is_empty(dev->driver->pm) && in device_pm_check_callbacks()
2018 !dev->driver->suspend && !dev->driver->resume)); in device_pm_check_callbacks()
2019 spin_unlock_irqrestore(&dev->power.lock, flags); in device_pm_check_callbacks()