2 * drivers/base/power/main.c - Where the driver meets power management.
4 * Copyright (c) 2003 Patrick Mochel
5 * Copyright (c) 2003 Open Source Development Lab
7 * This file is released under the GPLv2
10 * The driver model core calls device_pm_add() when a device is registered.
11 * This will initialize the embedded device_pm_info object in the device
12 * and add it to the list of power-controlled devices. sysfs entries for
13 * controlling device power management will also be added.
15 * A separate list is used for keeping track of power info, because the power
16 * domain dependencies may differ from the ancestral dependencies that the
17 * subsystem list maintains.
20 #include <linux/device.h>
21 #include <linux/kallsyms.h>
22 #include <linux/export.h>
23 #include <linux/mutex.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/pm-trace.h>
27 #include <linux/pm_wakeirq.h>
28 #include <linux/interrupt.h>
29 #include <linux/sched.h>
30 #include <linux/async.h>
31 #include <linux/suspend.h>
32 #include <trace/events/power.h>
33 #include <linux/cpufreq.h>
34 #include <linux/cpuidle.h>
35 #include <linux/timer.h>
36 #include <linux/wakeup_reason.h>
38 #include <asm/current.h>
43 typedef int (*pm_callback_t)(struct device *);
46 * The entries in the dpm_list list are in a depth first order, simply
47 * because children are guaranteed to be discovered after parents, and
48 * are inserted at the back of the list on discovery.
50 * Since device_pm_add() may be called with a device lock held,
51 * we must never try to acquire a device lock while holding
56 static LIST_HEAD(dpm_prepared_list);
57 static LIST_HEAD(dpm_suspended_list);
58 static LIST_HEAD(dpm_late_early_list);
59 static LIST_HEAD(dpm_noirq_list);
61 struct suspend_stats suspend_stats;
62 static DEFINE_MUTEX(dpm_list_mtx);
63 static pm_message_t pm_transition;
65 static void dpm_drv_timeout(unsigned long data);
66 struct dpm_drv_wd_data {
68 struct task_struct *tsk;
71 static int async_error;
73 static char *pm_verb(int event)
76 case PM_EVENT_SUSPEND:
82 case PM_EVENT_QUIESCE:
84 case PM_EVENT_HIBERNATE:
88 case PM_EVENT_RESTORE:
90 case PM_EVENT_RECOVER:
93 return "(unknown PM event)";
98 * device_pm_sleep_init - Initialize system suspend-related device fields.
99 * @dev: Device object being initialized.
101 void device_pm_sleep_init(struct device *dev)
103 dev->power.is_prepared = false;
104 dev->power.is_suspended = false;
105 dev->power.is_noirq_suspended = false;
106 dev->power.is_late_suspended = false;
107 init_completion(&dev->power.completion);
108 complete_all(&dev->power.completion);
109 dev->power.wakeup = NULL;
110 INIT_LIST_HEAD(&dev->power.entry);
114 * device_pm_lock - Lock the list of active devices used by the PM core.
116 void device_pm_lock(void)
118 mutex_lock(&dpm_list_mtx);
122 * device_pm_unlock - Unlock the list of active devices used by the PM core.
124 void device_pm_unlock(void)
126 mutex_unlock(&dpm_list_mtx);
130 * device_pm_add - Add a device to the PM core's list of active devices.
131 * @dev: Device to add to the list.
133 void device_pm_add(struct device *dev)
135 pr_debug("PM: Adding info for %s:%s\n",
136 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
137 mutex_lock(&dpm_list_mtx);
138 if (dev->parent && dev->parent->power.is_prepared)
139 dev_warn(dev, "parent %s should not be sleeping\n",
140 dev_name(dev->parent));
141 list_add_tail(&dev->power.entry, &dpm_list);
142 mutex_unlock(&dpm_list_mtx);
146 * device_pm_remove - Remove a device from the PM core's list of active devices.
147 * @dev: Device to be removed from the list.
149 void device_pm_remove(struct device *dev)
151 pr_debug("PM: Removing info for %s:%s\n",
152 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
153 complete_all(&dev->power.completion);
154 mutex_lock(&dpm_list_mtx);
155 list_del_init(&dev->power.entry);
156 mutex_unlock(&dpm_list_mtx);
157 device_wakeup_disable(dev);
158 pm_runtime_remove(dev);
162 * device_pm_move_before - Move device in the PM core's list of active devices.
163 * @deva: Device to move in dpm_list.
164 * @devb: Device @deva should come before.
166 void device_pm_move_before(struct device *deva, struct device *devb)
168 pr_debug("PM: Moving %s:%s before %s:%s\n",
169 deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
170 devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
171 /* Delete deva from dpm_list and reinsert before devb. */
172 list_move_tail(&deva->power.entry, &devb->power.entry);
176 * device_pm_move_after - Move device in the PM core's list of active devices.
177 * @deva: Device to move in dpm_list.
178 * @devb: Device @deva should come after.
180 void device_pm_move_after(struct device *deva, struct device *devb)
182 pr_debug("PM: Moving %s:%s after %s:%s\n",
183 deva->bus ? deva->bus->name : "No Bus", dev_name(deva),
184 devb->bus ? devb->bus->name : "No Bus", dev_name(devb));
185 /* Delete deva from dpm_list and reinsert after devb. */
186 list_move(&deva->power.entry, &devb->power.entry);
190 * device_pm_move_last - Move device to end of the PM core's list of devices.
191 * @dev: Device to move in dpm_list.
193 void device_pm_move_last(struct device *dev)
195 pr_debug("PM: Moving %s:%s to end of list\n",
196 dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
197 list_move_tail(&dev->power.entry, &dpm_list);
200 static ktime_t initcall_debug_start(struct device *dev)
202 ktime_t calltime = ktime_set(0, 0);
204 if (pm_print_times_enabled) {
205 pr_info("calling %s+ @ %i, parent: %s\n",
206 dev_name(dev), task_pid_nr(current),
207 dev->parent ? dev_name(dev->parent) : "none");
208 calltime = ktime_get();
214 static void initcall_debug_report(struct device *dev, ktime_t calltime,
215 int error, pm_message_t state, char *info)
220 rettime = ktime_get();
221 nsecs = (s64) ktime_to_ns(ktime_sub(rettime, calltime));
223 if (pm_print_times_enabled) {
224 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
225 error, (unsigned long long)nsecs >> 10);
230 * dpm_wait - Wait for a PM operation to complete.
231 * @dev: Device to wait for.
232 * @async: If unset, wait only if the device's power.async_suspend flag is set.
234 static void dpm_wait(struct device *dev, bool async)
239 if (async || (pm_async_enabled && dev->power.async_suspend))
240 wait_for_completion(&dev->power.completion);
243 static int dpm_wait_fn(struct device *dev, void *async_ptr)
245 dpm_wait(dev, *((bool *)async_ptr));
249 static void dpm_wait_for_children(struct device *dev, bool async)
251 device_for_each_child(dev, &async, dpm_wait_fn);
255 * pm_op - Return the PM operation appropriate for given PM event.
256 * @ops: PM operations to choose from.
257 * @state: PM transition of the system being carried out.
259 static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state)
261 switch (state.event) {
262 #ifdef CONFIG_SUSPEND
263 case PM_EVENT_SUSPEND:
265 case PM_EVENT_RESUME:
267 #endif /* CONFIG_SUSPEND */
268 #ifdef CONFIG_HIBERNATE_CALLBACKS
269 case PM_EVENT_FREEZE:
270 case PM_EVENT_QUIESCE:
272 case PM_EVENT_HIBERNATE:
273 return ops->poweroff;
275 case PM_EVENT_RECOVER:
278 case PM_EVENT_RESTORE:
280 #endif /* CONFIG_HIBERNATE_CALLBACKS */
287 * pm_late_early_op - Return the PM operation appropriate for given PM event.
288 * @ops: PM operations to choose from.
289 * @state: PM transition of the system being carried out.
291 * Runtime PM is disabled for @dev while this function is being executed.
293 static pm_callback_t pm_late_early_op(const struct dev_pm_ops *ops,
296 switch (state.event) {
297 #ifdef CONFIG_SUSPEND
298 case PM_EVENT_SUSPEND:
299 return ops->suspend_late;
300 case PM_EVENT_RESUME:
301 return ops->resume_early;
302 #endif /* CONFIG_SUSPEND */
303 #ifdef CONFIG_HIBERNATE_CALLBACKS
304 case PM_EVENT_FREEZE:
305 case PM_EVENT_QUIESCE:
306 return ops->freeze_late;
307 case PM_EVENT_HIBERNATE:
308 return ops->poweroff_late;
310 case PM_EVENT_RECOVER:
311 return ops->thaw_early;
312 case PM_EVENT_RESTORE:
313 return ops->restore_early;
314 #endif /* CONFIG_HIBERNATE_CALLBACKS */
321 * pm_noirq_op - Return the PM operation appropriate for given PM event.
322 * @ops: PM operations to choose from.
323 * @state: PM transition of the system being carried out.
325 * The driver of @dev will not receive interrupts while this function is being
328 static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state)
330 switch (state.event) {
331 #ifdef CONFIG_SUSPEND
332 case PM_EVENT_SUSPEND:
333 return ops->suspend_noirq;
334 case PM_EVENT_RESUME:
335 return ops->resume_noirq;
336 #endif /* CONFIG_SUSPEND */
337 #ifdef CONFIG_HIBERNATE_CALLBACKS
338 case PM_EVENT_FREEZE:
339 case PM_EVENT_QUIESCE:
340 return ops->freeze_noirq;
341 case PM_EVENT_HIBERNATE:
342 return ops->poweroff_noirq;
344 case PM_EVENT_RECOVER:
345 return ops->thaw_noirq;
346 case PM_EVENT_RESTORE:
347 return ops->restore_noirq;
348 #endif /* CONFIG_HIBERNATE_CALLBACKS */
354 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
356 dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
357 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
358 ", may wakeup" : "");
361 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
364 printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
365 dev_name(dev), pm_verb(state.event), info, error);
368 static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
374 calltime = ktime_get();
375 usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
376 do_div(usecs64, NSEC_PER_USEC);
380 pr_info("PM: %s%s%s of devices complete after %ld.%03ld msecs\n",
381 info ?: "", info ? " " : "", pm_verb(state.event),
382 usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
385 static int dpm_run_callback(pm_callback_t cb, struct device *dev,
386 pm_message_t state, char *info)
394 calltime = initcall_debug_start(dev);
396 pm_dev_dbg(dev, state, info);
397 trace_device_pm_callback_start(dev, info, state.event);
399 trace_device_pm_callback_end(dev, error);
400 suspend_report_result(cb, error);
402 initcall_debug_report(dev, calltime, error, state, info);
407 #ifdef CONFIG_DPM_WATCHDOG
408 struct dpm_watchdog {
410 struct task_struct *tsk;
411 struct timer_list timer;
414 #define DECLARE_DPM_WATCHDOG_ON_STACK(wd) \
415 struct dpm_watchdog wd
418 * dpm_watchdog_handler - Driver suspend / resume watchdog handler.
419 * @data: Watchdog object address.
421 * Called when a driver has timed out suspending or resuming.
422 * There's not much we can do here to recover so panic() to
423 * capture a crash-dump in pstore.
425 static void dpm_watchdog_handler(unsigned long data)
427 struct dpm_watchdog *wd = (void *)data;
429 dev_emerg(wd->dev, "**** DPM device timeout ****\n");
430 show_stack(wd->tsk, NULL);
431 panic("%s %s: unrecoverable failure\n",
432 dev_driver_string(wd->dev), dev_name(wd->dev));
436 * dpm_watchdog_set - Enable pm watchdog for given device.
437 * @wd: Watchdog. Must be allocated on the stack.
438 * @dev: Device to handle.
440 static void dpm_watchdog_set(struct dpm_watchdog *wd, struct device *dev)
442 struct timer_list *timer = &wd->timer;
447 init_timer_on_stack(timer);
448 /* use same timeout value for both suspend and resume */
449 timer->expires = jiffies + HZ * CONFIG_DPM_WATCHDOG_TIMEOUT;
450 timer->function = dpm_watchdog_handler;
451 timer->data = (unsigned long)wd;
456 * dpm_watchdog_clear - Disable suspend/resume watchdog.
457 * @wd: Watchdog to disable.
459 static void dpm_watchdog_clear(struct dpm_watchdog *wd)
461 struct timer_list *timer = &wd->timer;
463 del_timer_sync(timer);
464 destroy_timer_on_stack(timer);
467 #define DECLARE_DPM_WATCHDOG_ON_STACK(wd)
468 #define dpm_watchdog_set(x, y)
469 #define dpm_watchdog_clear(x)
472 /*------------------------- Resume routines -------------------------*/
475 * device_resume_noirq - Execute an "early resume" callback for given device.
476 * @dev: Device to handle.
477 * @state: PM transition of the system being carried out.
478 * @async: If true, the device is being resumed asynchronously.
480 * The driver of @dev will not receive interrupts while this function is being
483 static int device_resume_noirq(struct device *dev, pm_message_t state, bool async)
485 pm_callback_t callback = NULL;
492 if (dev->power.syscore || dev->power.direct_complete)
495 if (!dev->power.is_noirq_suspended)
498 dpm_wait(dev->parent, async);
500 if (dev->pm_domain) {
501 info = "noirq power domain ";
502 callback = pm_noirq_op(&dev->pm_domain->ops, state);
503 } else if (dev->type && dev->type->pm) {
504 info = "noirq type ";
505 callback = pm_noirq_op(dev->type->pm, state);
506 } else if (dev->class && dev->class->pm) {
507 info = "noirq class ";
508 callback = pm_noirq_op(dev->class->pm, state);
509 } else if (dev->bus && dev->bus->pm) {
511 callback = pm_noirq_op(dev->bus->pm, state);
514 if (!callback && dev->driver && dev->driver->pm) {
515 info = "noirq driver ";
516 callback = pm_noirq_op(dev->driver->pm, state);
519 error = dpm_run_callback(callback, dev, state, info);
520 dev->power.is_noirq_suspended = false;
523 complete_all(&dev->power.completion);
528 static bool is_async(struct device *dev)
530 return dev->power.async_suspend && pm_async_enabled
531 && !pm_trace_is_enabled();
534 static void async_resume_noirq(void *data, async_cookie_t cookie)
536 struct device *dev = (struct device *)data;
539 error = device_resume_noirq(dev, pm_transition, true);
541 pm_dev_err(dev, pm_transition, " async", error);
547 * dpm_resume_noirq - Execute "noirq resume" callbacks for all devices.
548 * @state: PM transition of the system being carried out.
550 * Call the "noirq" resume handlers for all devices in dpm_noirq_list and
551 * enable device drivers to receive interrupts.
553 void dpm_resume_noirq(pm_message_t state)
556 ktime_t starttime = ktime_get();
558 trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, true);
559 mutex_lock(&dpm_list_mtx);
560 pm_transition = state;
563 * Advanced the async threads upfront,
564 * in case the starting of async threads is
565 * delayed by non-async resuming devices.
567 list_for_each_entry(dev, &dpm_noirq_list, power.entry) {
568 reinit_completion(&dev->power.completion);
571 async_schedule(async_resume_noirq, dev);
575 while (!list_empty(&dpm_noirq_list)) {
576 dev = to_device(dpm_noirq_list.next);
578 list_move_tail(&dev->power.entry, &dpm_late_early_list);
579 mutex_unlock(&dpm_list_mtx);
581 if (!is_async(dev)) {
584 error = device_resume_noirq(dev, state, false);
586 suspend_stats.failed_resume_noirq++;
587 dpm_save_failed_step(SUSPEND_RESUME_NOIRQ);
588 dpm_save_failed_dev(dev_name(dev));
589 pm_dev_err(dev, state, " noirq", error);
593 mutex_lock(&dpm_list_mtx);
596 mutex_unlock(&dpm_list_mtx);
597 async_synchronize_full();
598 dpm_show_time(starttime, state, "noirq");
599 resume_device_irqs();
600 device_wakeup_disarm_wake_irqs();
602 trace_suspend_resume(TPS("dpm_resume_noirq"), state.event, false);
606 * device_resume_early - Execute an "early resume" callback for given device.
607 * @dev: Device to handle.
608 * @state: PM transition of the system being carried out.
609 * @async: If true, the device is being resumed asynchronously.
611 * Runtime PM is disabled for @dev while this function is being executed.
613 static int device_resume_early(struct device *dev, pm_message_t state, bool async)
615 pm_callback_t callback = NULL;
622 if (dev->power.syscore || dev->power.direct_complete)
625 if (!dev->power.is_late_suspended)
628 dpm_wait(dev->parent, async);
630 if (dev->pm_domain) {
631 info = "early power domain ";
632 callback = pm_late_early_op(&dev->pm_domain->ops, state);
633 } else if (dev->type && dev->type->pm) {
634 info = "early type ";
635 callback = pm_late_early_op(dev->type->pm, state);
636 } else if (dev->class && dev->class->pm) {
637 info = "early class ";
638 callback = pm_late_early_op(dev->class->pm, state);
639 } else if (dev->bus && dev->bus->pm) {
641 callback = pm_late_early_op(dev->bus->pm, state);
644 if (!callback && dev->driver && dev->driver->pm) {
645 info = "early driver ";
646 callback = pm_late_early_op(dev->driver->pm, state);
649 error = dpm_run_callback(callback, dev, state, info);
650 dev->power.is_late_suspended = false;
655 pm_runtime_enable(dev);
656 complete_all(&dev->power.completion);
660 static void async_resume_early(void *data, async_cookie_t cookie)
662 struct device *dev = (struct device *)data;
665 error = device_resume_early(dev, pm_transition, true);
667 pm_dev_err(dev, pm_transition, " async", error);
673 * dpm_resume_early - Execute "early resume" callbacks for all devices.
674 * @state: PM transition of the system being carried out.
676 void dpm_resume_early(pm_message_t state)
679 ktime_t starttime = ktime_get();
681 trace_suspend_resume(TPS("dpm_resume_early"), state.event, true);
682 mutex_lock(&dpm_list_mtx);
683 pm_transition = state;
686 * Advanced the async threads upfront,
687 * in case the starting of async threads is
688 * delayed by non-async resuming devices.
690 list_for_each_entry(dev, &dpm_late_early_list, power.entry) {
691 reinit_completion(&dev->power.completion);
694 async_schedule(async_resume_early, dev);
698 while (!list_empty(&dpm_late_early_list)) {
699 dev = to_device(dpm_late_early_list.next);
701 list_move_tail(&dev->power.entry, &dpm_suspended_list);
702 mutex_unlock(&dpm_list_mtx);
704 if (!is_async(dev)) {
707 error = device_resume_early(dev, state, false);
709 suspend_stats.failed_resume_early++;
710 dpm_save_failed_step(SUSPEND_RESUME_EARLY);
711 dpm_save_failed_dev(dev_name(dev));
712 pm_dev_err(dev, state, " early", error);
715 mutex_lock(&dpm_list_mtx);
718 mutex_unlock(&dpm_list_mtx);
719 async_synchronize_full();
720 dpm_show_time(starttime, state, "early");
721 trace_suspend_resume(TPS("dpm_resume_early"), state.event, false);
725 * dpm_resume_start - Execute "noirq" and "early" device callbacks.
726 * @state: PM transition of the system being carried out.
728 void dpm_resume_start(pm_message_t state)
730 dpm_resume_noirq(state);
731 dpm_resume_early(state);
733 EXPORT_SYMBOL_GPL(dpm_resume_start);
736 * device_resume - Execute "resume" callbacks for given device.
737 * @dev: Device to handle.
738 * @state: PM transition of the system being carried out.
739 * @async: If true, the device is being resumed asynchronously.
741 static int device_resume(struct device *dev, pm_message_t state, bool async)
743 pm_callback_t callback = NULL;
746 DECLARE_DPM_WATCHDOG_ON_STACK(wd);
751 if (dev->power.syscore)
754 if (dev->power.direct_complete) {
755 /* Match the pm_runtime_disable() in __device_suspend(). */
756 pm_runtime_enable(dev);
760 dpm_wait(dev->parent, async);
761 dpm_watchdog_set(&wd, dev);
765 * This is a fib. But we'll allow new children to be added below
766 * a resumed device, even if the device hasn't been completed yet.
768 dev->power.is_prepared = false;
770 if (!dev->power.is_suspended)
773 if (dev->pm_domain) {
774 info = "power domain ";
775 callback = pm_op(&dev->pm_domain->ops, state);
779 if (dev->type && dev->type->pm) {
781 callback = pm_op(dev->type->pm, state);
786 if (dev->class->pm) {
788 callback = pm_op(dev->class->pm, state);
790 } else if (dev->class->resume) {
791 info = "legacy class ";
792 callback = dev->class->resume;
800 callback = pm_op(dev->bus->pm, state);
801 } else if (dev->bus->resume) {
802 info = "legacy bus ";
803 callback = dev->bus->resume;
809 if (!callback && dev->driver && dev->driver->pm) {
811 callback = pm_op(dev->driver->pm, state);
815 error = dpm_run_callback(callback, dev, state, info);
816 dev->power.is_suspended = false;
820 dpm_watchdog_clear(&wd);
823 complete_all(&dev->power.completion);
830 static void async_resume(void *data, async_cookie_t cookie)
832 struct device *dev = (struct device *)data;
835 error = device_resume(dev, pm_transition, true);
837 pm_dev_err(dev, pm_transition, " async", error);
842 * dpm_drv_timeout - Driver suspend / resume watchdog handler
843 * @data: struct device which timed out
845 * Called when a driver has timed out suspending or resuming.
846 * There's not much we can do here to recover so
847 * BUG() out for a crash-dump
850 static void dpm_drv_timeout(unsigned long data)
852 struct dpm_drv_wd_data *wd_data = (void *)data;
853 struct device *dev = wd_data->dev;
854 struct task_struct *tsk = wd_data->tsk;
856 printk(KERN_EMERG "**** DPM device timeout: %s (%s)\n", dev_name(dev),
857 (dev->driver ? dev->driver->name : "no driver"));
859 printk(KERN_EMERG "dpm suspend stack:\n");
860 show_stack(tsk, NULL);
866 * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
867 * @state: PM transition of the system being carried out.
869 * Execute the appropriate "resume" callback for all devices whose status
870 * indicates that they are suspended.
872 void dpm_resume(pm_message_t state)
875 ktime_t starttime = ktime_get();
877 trace_suspend_resume(TPS("dpm_resume"), state.event, true);
880 mutex_lock(&dpm_list_mtx);
881 pm_transition = state;
884 list_for_each_entry(dev, &dpm_suspended_list, power.entry) {
885 reinit_completion(&dev->power.completion);
888 async_schedule(async_resume, dev);
892 while (!list_empty(&dpm_suspended_list)) {
893 dev = to_device(dpm_suspended_list.next);
895 if (!is_async(dev)) {
898 mutex_unlock(&dpm_list_mtx);
900 error = device_resume(dev, state, false);
902 suspend_stats.failed_resume++;
903 dpm_save_failed_step(SUSPEND_RESUME);
904 dpm_save_failed_dev(dev_name(dev));
905 pm_dev_err(dev, state, "", error);
908 mutex_lock(&dpm_list_mtx);
910 if (!list_empty(&dev->power.entry))
911 list_move_tail(&dev->power.entry, &dpm_prepared_list);
914 mutex_unlock(&dpm_list_mtx);
915 async_synchronize_full();
916 dpm_show_time(starttime, state, NULL);
919 trace_suspend_resume(TPS("dpm_resume"), state.event, false);
923 * device_complete - Complete a PM transition for given device.
924 * @dev: Device to handle.
925 * @state: PM transition of the system being carried out.
927 static void device_complete(struct device *dev, pm_message_t state)
929 void (*callback)(struct device *) = NULL;
932 if (dev->power.syscore)
937 if (dev->pm_domain) {
938 info = "completing power domain ";
939 callback = dev->pm_domain->ops.complete;
940 } else if (dev->type && dev->type->pm) {
941 info = "completing type ";
942 callback = dev->type->pm->complete;
943 } else if (dev->class && dev->class->pm) {
944 info = "completing class ";
945 callback = dev->class->pm->complete;
946 } else if (dev->bus && dev->bus->pm) {
947 info = "completing bus ";
948 callback = dev->bus->pm->complete;
951 if (!callback && dev->driver && dev->driver->pm) {
952 info = "completing driver ";
953 callback = dev->driver->pm->complete;
957 pm_dev_dbg(dev, state, info);
967 * dpm_complete - Complete a PM transition for all non-sysdev devices.
968 * @state: PM transition of the system being carried out.
970 * Execute the ->complete() callbacks for all devices whose PM status is not
971 * DPM_ON (this allows new devices to be registered).
973 void dpm_complete(pm_message_t state)
975 struct list_head list;
977 trace_suspend_resume(TPS("dpm_complete"), state.event, true);
980 INIT_LIST_HEAD(&list);
981 mutex_lock(&dpm_list_mtx);
982 while (!list_empty(&dpm_prepared_list)) {
983 struct device *dev = to_device(dpm_prepared_list.prev);
986 dev->power.is_prepared = false;
987 list_move(&dev->power.entry, &list);
988 mutex_unlock(&dpm_list_mtx);
990 trace_device_pm_callback_start(dev, "", state.event);
991 device_complete(dev, state);
992 trace_device_pm_callback_end(dev, 0);
994 mutex_lock(&dpm_list_mtx);
997 list_splice(&list, &dpm_list);
998 mutex_unlock(&dpm_list_mtx);
999 trace_suspend_resume(TPS("dpm_complete"), state.event, false);
1003 * dpm_resume_end - Execute "resume" callbacks and complete system transition.
1004 * @state: PM transition of the system being carried out.
1006 * Execute "resume" callbacks for all devices and complete the PM transition of
1009 void dpm_resume_end(pm_message_t state)
1012 dpm_complete(state);
1014 EXPORT_SYMBOL_GPL(dpm_resume_end);
1017 /*------------------------- Suspend routines -------------------------*/
1020 * resume_event - Return a "resume" message for given "suspend" sleep state.
1021 * @sleep_state: PM message representing a sleep state.
1023 * Return a PM message representing the resume event corresponding to given
1026 static pm_message_t resume_event(pm_message_t sleep_state)
1028 switch (sleep_state.event) {
1029 case PM_EVENT_SUSPEND:
1031 case PM_EVENT_FREEZE:
1032 case PM_EVENT_QUIESCE:
1033 return PMSG_RECOVER;
1034 case PM_EVENT_HIBERNATE:
1035 return PMSG_RESTORE;
1041 * device_suspend_noirq - Execute a "late suspend" callback for given device.
1042 * @dev: Device to handle.
1043 * @state: PM transition of the system being carried out.
1044 * @async: If true, the device is being suspended asynchronously.
1046 * The driver of @dev will not receive interrupts while this function is being
1049 static int __device_suspend_noirq(struct device *dev, pm_message_t state, bool async)
1051 pm_callback_t callback = NULL;
1061 if (pm_wakeup_pending()) {
1062 async_error = -EBUSY;
1066 if (dev->power.syscore || dev->power.direct_complete)
1069 dpm_wait_for_children(dev, async);
1071 if (dev->pm_domain) {
1072 info = "noirq power domain ";
1073 callback = pm_noirq_op(&dev->pm_domain->ops, state);
1074 } else if (dev->type && dev->type->pm) {
1075 info = "noirq type ";
1076 callback = pm_noirq_op(dev->type->pm, state);
1077 } else if (dev->class && dev->class->pm) {
1078 info = "noirq class ";
1079 callback = pm_noirq_op(dev->class->pm, state);
1080 } else if (dev->bus && dev->bus->pm) {
1081 info = "noirq bus ";
1082 callback = pm_noirq_op(dev->bus->pm, state);
1085 if (!callback && dev->driver && dev->driver->pm) {
1086 info = "noirq driver ";
1087 callback = pm_noirq_op(dev->driver->pm, state);
1090 error = dpm_run_callback(callback, dev, state, info);
1092 dev->power.is_noirq_suspended = true;
1094 async_error = error;
1097 complete_all(&dev->power.completion);
1098 TRACE_SUSPEND(error);
1102 static void async_suspend_noirq(void *data, async_cookie_t cookie)
1104 struct device *dev = (struct device *)data;
1107 error = __device_suspend_noirq(dev, pm_transition, true);
1109 dpm_save_failed_dev(dev_name(dev));
1110 pm_dev_err(dev, pm_transition, " async", error);
1116 static int device_suspend_noirq(struct device *dev)
1118 reinit_completion(&dev->power.completion);
1120 if (is_async(dev)) {
1122 async_schedule(async_suspend_noirq, dev);
1125 return __device_suspend_noirq(dev, pm_transition, false);
1129 * dpm_suspend_noirq - Execute "noirq suspend" callbacks for all devices.
1130 * @state: PM transition of the system being carried out.
1132 * Prevent device drivers from receiving interrupts and call the "noirq" suspend
1133 * handlers for all non-sysdev devices.
1135 int dpm_suspend_noirq(pm_message_t state)
1137 ktime_t starttime = ktime_get();
1140 trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, true);
1142 device_wakeup_arm_wake_irqs();
1143 suspend_device_irqs();
1144 mutex_lock(&dpm_list_mtx);
1145 pm_transition = state;
1148 while (!list_empty(&dpm_late_early_list)) {
1149 struct device *dev = to_device(dpm_late_early_list.prev);
1152 mutex_unlock(&dpm_list_mtx);
1154 error = device_suspend_noirq(dev);
1156 mutex_lock(&dpm_list_mtx);
1158 pm_dev_err(dev, state, " noirq", error);
1159 dpm_save_failed_dev(dev_name(dev));
1163 if (!list_empty(&dev->power.entry))
1164 list_move(&dev->power.entry, &dpm_noirq_list);
1170 mutex_unlock(&dpm_list_mtx);
1171 async_synchronize_full();
1173 error = async_error;
1176 suspend_stats.failed_suspend_noirq++;
1177 dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ);
1178 dpm_resume_noirq(resume_event(state));
1180 dpm_show_time(starttime, state, "noirq");
1182 trace_suspend_resume(TPS("dpm_suspend_noirq"), state.event, false);
1187 * device_suspend_late - Execute a "late suspend" callback for given device.
1188 * @dev: Device to handle.
1189 * @state: PM transition of the system being carried out.
1190 * @async: If true, the device is being suspended asynchronously.
1192 * Runtime PM is disabled for @dev while this function is being executed.
1194 static int __device_suspend_late(struct device *dev, pm_message_t state, bool async)
1196 pm_callback_t callback = NULL;
1203 __pm_runtime_disable(dev, false);
1208 if (pm_wakeup_pending()) {
1209 async_error = -EBUSY;
1213 if (dev->power.syscore || dev->power.direct_complete)
1216 dpm_wait_for_children(dev, async);
1218 if (dev->pm_domain) {
1219 info = "late power domain ";
1220 callback = pm_late_early_op(&dev->pm_domain->ops, state);
1221 } else if (dev->type && dev->type->pm) {
1222 info = "late type ";
1223 callback = pm_late_early_op(dev->type->pm, state);
1224 } else if (dev->class && dev->class->pm) {
1225 info = "late class ";
1226 callback = pm_late_early_op(dev->class->pm, state);
1227 } else if (dev->bus && dev->bus->pm) {
1229 callback = pm_late_early_op(dev->bus->pm, state);
1232 if (!callback && dev->driver && dev->driver->pm) {
1233 info = "late driver ";
1234 callback = pm_late_early_op(dev->driver->pm, state);
1237 error = dpm_run_callback(callback, dev, state, info);
1239 dev->power.is_late_suspended = true;
1241 async_error = error;
1244 TRACE_SUSPEND(error);
1245 complete_all(&dev->power.completion);
1249 static void async_suspend_late(void *data, async_cookie_t cookie)
1251 struct device *dev = (struct device *)data;
1254 error = __device_suspend_late(dev, pm_transition, true);
1256 dpm_save_failed_dev(dev_name(dev));
1257 pm_dev_err(dev, pm_transition, " async", error);
1262 static int device_suspend_late(struct device *dev)
1264 reinit_completion(&dev->power.completion);
1266 if (is_async(dev)) {
1268 async_schedule(async_suspend_late, dev);
1272 return __device_suspend_late(dev, pm_transition, false);
1276 * dpm_suspend_late - Execute "late suspend" callbacks for all devices.
1277 * @state: PM transition of the system being carried out.
1279 int dpm_suspend_late(pm_message_t state)
1281 ktime_t starttime = ktime_get();
1284 trace_suspend_resume(TPS("dpm_suspend_late"), state.event, true);
1285 mutex_lock(&dpm_list_mtx);
1286 pm_transition = state;
1289 while (!list_empty(&dpm_suspended_list)) {
1290 struct device *dev = to_device(dpm_suspended_list.prev);
1293 mutex_unlock(&dpm_list_mtx);
1295 error = device_suspend_late(dev);
1297 mutex_lock(&dpm_list_mtx);
1299 pm_dev_err(dev, state, " late", error);
1300 dpm_save_failed_dev(dev_name(dev));
1304 if (!list_empty(&dev->power.entry))
1305 list_move(&dev->power.entry, &dpm_late_early_list);
1311 mutex_unlock(&dpm_list_mtx);
1312 async_synchronize_full();
1314 error = async_error;
1316 suspend_stats.failed_suspend_late++;
1317 dpm_save_failed_step(SUSPEND_SUSPEND_LATE);
1318 dpm_resume_early(resume_event(state));
1320 dpm_show_time(starttime, state, "late");
1322 trace_suspend_resume(TPS("dpm_suspend_late"), state.event, false);
1327 * dpm_suspend_end - Execute "late" and "noirq" device suspend callbacks.
1328 * @state: PM transition of the system being carried out.
1330 int dpm_suspend_end(pm_message_t state)
1332 int error = dpm_suspend_late(state);
1336 error = dpm_suspend_noirq(state);
1338 dpm_resume_early(resume_event(state));
1344 EXPORT_SYMBOL_GPL(dpm_suspend_end);
1347 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
1348 * @dev: Device to suspend.
1349 * @state: PM transition of the system being carried out.
1350 * @cb: Suspend callback to execute.
1351 * @info: string description of caller.
1353 static int legacy_suspend(struct device *dev, pm_message_t state,
1354 int (*cb)(struct device *dev, pm_message_t state),
1360 calltime = initcall_debug_start(dev);
1362 trace_device_pm_callback_start(dev, info, state.event);
1363 error = cb(dev, state);
1364 trace_device_pm_callback_end(dev, error);
1365 suspend_report_result(cb, error);
1367 initcall_debug_report(dev, calltime, error, state, info);
1373 * device_suspend - Execute "suspend" callbacks for given device.
1374 * @dev: Device to handle.
1375 * @state: PM transition of the system being carried out.
1376 * @async: If true, the device is being suspended asynchronously.
1378 static int __device_suspend(struct device *dev, pm_message_t state, bool async)
1380 pm_callback_t callback = NULL;
1383 struct timer_list timer;
1384 struct dpm_drv_wd_data data;
1385 char suspend_abort[MAX_SUSPEND_ABORT_LEN];
1386 DECLARE_DPM_WATCHDOG_ON_STACK(wd);
1391 dpm_wait_for_children(dev, async);
1397 * If a device configured to wake up the system from sleep states
1398 * has been suspended at run time and there's a resume request pending
1399 * for it, this is equivalent to the device signaling wakeup, so the
1400 * system suspend operation should be aborted.
1402 if (pm_runtime_barrier(dev) && device_may_wakeup(dev))
1403 pm_wakeup_event(dev, 0);
1405 if (pm_wakeup_pending()) {
1406 pm_get_active_wakeup_sources(suspend_abort,
1407 MAX_SUSPEND_ABORT_LEN);
1408 log_suspend_abort_reason(suspend_abort);
1409 async_error = -EBUSY;
1413 if (dev->power.syscore)
1418 init_timer_on_stack(&timer);
1419 timer.expires = jiffies + HZ * 12;
1420 timer.function = dpm_drv_timeout;
1421 timer.data = (unsigned long)&data;
1424 if (dev->power.direct_complete) {
1425 if (pm_runtime_status_suspended(dev)) {
1426 pm_runtime_disable(dev);
1427 if (pm_runtime_status_suspended(dev))
1430 pm_runtime_enable(dev);
1432 dev->power.direct_complete = false;
1435 dpm_watchdog_set(&wd, dev);
1438 if (dev->pm_domain) {
1439 info = "power domain ";
1440 callback = pm_op(&dev->pm_domain->ops, state);
1444 if (dev->type && dev->type->pm) {
1446 callback = pm_op(dev->type->pm, state);
1451 if (dev->class->pm) {
1453 callback = pm_op(dev->class->pm, state);
1455 } else if (dev->class->suspend) {
1456 pm_dev_dbg(dev, state, "legacy class ");
1457 error = legacy_suspend(dev, state, dev->class->suspend,
1466 callback = pm_op(dev->bus->pm, state);
1467 } else if (dev->bus->suspend) {
1468 pm_dev_dbg(dev, state, "legacy bus ");
1469 error = legacy_suspend(dev, state, dev->bus->suspend,
1476 if (!callback && dev->driver && dev->driver->pm) {
1478 callback = pm_op(dev->driver->pm, state);
1481 error = dpm_run_callback(callback, dev, state, info);
1485 struct device *parent = dev->parent;
1487 dev->power.is_suspended = true;
1489 spin_lock_irq(&parent->power.lock);
1491 dev->parent->power.direct_complete = false;
1492 if (dev->power.wakeup_path
1493 && !dev->parent->power.ignore_children)
1494 dev->parent->power.wakeup_path = true;
1496 spin_unlock_irq(&parent->power.lock);
1501 dpm_watchdog_clear(&wd);
1503 del_timer_sync(&timer);
1504 destroy_timer_on_stack(&timer);
1507 complete_all(&dev->power.completion);
1509 async_error = error;
1511 TRACE_SUSPEND(error);
1515 static void async_suspend(void *data, async_cookie_t cookie)
1517 struct device *dev = (struct device *)data;
1520 error = __device_suspend(dev, pm_transition, true);
1522 dpm_save_failed_dev(dev_name(dev));
1523 pm_dev_err(dev, pm_transition, " async", error);
1529 static int device_suspend(struct device *dev)
1531 reinit_completion(&dev->power.completion);
1533 if (is_async(dev)) {
1535 async_schedule(async_suspend, dev);
1539 return __device_suspend(dev, pm_transition, false);
1543 * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
1544 * @state: PM transition of the system being carried out.
1546 int dpm_suspend(pm_message_t state)
1548 ktime_t starttime = ktime_get();
1551 trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
1556 mutex_lock(&dpm_list_mtx);
1557 pm_transition = state;
1559 while (!list_empty(&dpm_prepared_list)) {
1560 struct device *dev = to_device(dpm_prepared_list.prev);
1563 mutex_unlock(&dpm_list_mtx);
1565 error = device_suspend(dev);
1567 mutex_lock(&dpm_list_mtx);
1569 pm_dev_err(dev, state, "", error);
1570 dpm_save_failed_dev(dev_name(dev));
1574 if (!list_empty(&dev->power.entry))
1575 list_move(&dev->power.entry, &dpm_suspended_list);
1580 mutex_unlock(&dpm_list_mtx);
1581 async_synchronize_full();
1583 error = async_error;
1585 suspend_stats.failed_suspend++;
1586 dpm_save_failed_step(SUSPEND_SUSPEND);
1588 dpm_show_time(starttime, state, NULL);
1589 trace_suspend_resume(TPS("dpm_suspend"), state.event, false);
1594 * device_prepare - Prepare a device for system power transition.
1595 * @dev: Device to handle.
1596 * @state: PM transition of the system being carried out.
1598 * Execute the ->prepare() callback(s) for given device. No new children of the
1599 * device may be registered after this function has returned.
1601 static int device_prepare(struct device *dev, pm_message_t state)
1603 int (*callback)(struct device *) = NULL;
1607 if (dev->power.syscore)
1611 * If a device's parent goes into runtime suspend at the wrong time,
1612 * it won't be possible to resume the device. To prevent this we
1613 * block runtime suspend here, during the prepare phase, and allow
1614 * it again during the complete phase.
1616 pm_runtime_get_noresume(dev);
1620 dev->power.wakeup_path = device_may_wakeup(dev);
1622 if (dev->pm_domain) {
1623 info = "preparing power domain ";
1624 callback = dev->pm_domain->ops.prepare;
1625 } else if (dev->type && dev->type->pm) {
1626 info = "preparing type ";
1627 callback = dev->type->pm->prepare;
1628 } else if (dev->class && dev->class->pm) {
1629 info = "preparing class ";
1630 callback = dev->class->pm->prepare;
1631 } else if (dev->bus && dev->bus->pm) {
1632 info = "preparing bus ";
1633 callback = dev->bus->pm->prepare;
1636 if (!callback && dev->driver && dev->driver->pm) {
1637 info = "preparing driver ";
1638 callback = dev->driver->pm->prepare;
1642 ret = callback(dev);
1647 suspend_report_result(callback, ret);
1648 pm_runtime_put(dev);
1652 * A positive return value from ->prepare() means "this device appears
1653 * to be runtime-suspended and its state is fine, so if it really is
1654 * runtime-suspended, you can leave it in that state provided that you
1655 * will do the same thing with all of its descendants". This only
1656 * applies to suspend transitions, however.
1658 spin_lock_irq(&dev->power.lock);
1659 dev->power.direct_complete = ret > 0 && state.event == PM_EVENT_SUSPEND;
1660 spin_unlock_irq(&dev->power.lock);
1665 * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
1666 * @state: PM transition of the system being carried out.
1668 * Execute the ->prepare() callback(s) for all devices.
1670 int dpm_prepare(pm_message_t state)
1674 trace_suspend_resume(TPS("dpm_prepare"), state.event, true);
1677 mutex_lock(&dpm_list_mtx);
1678 while (!list_empty(&dpm_list)) {
1679 struct device *dev = to_device(dpm_list.next);
1682 mutex_unlock(&dpm_list_mtx);
1684 trace_device_pm_callback_start(dev, "", state.event);
1685 error = device_prepare(dev, state);
1686 trace_device_pm_callback_end(dev, error);
1688 mutex_lock(&dpm_list_mtx);
1690 if (error == -EAGAIN) {
1695 printk(KERN_INFO "PM: Device %s not prepared "
1696 "for power transition: code %d\n",
1697 dev_name(dev), error);
1701 dev->power.is_prepared = true;
1702 if (!list_empty(&dev->power.entry))
1703 list_move_tail(&dev->power.entry, &dpm_prepared_list);
1706 mutex_unlock(&dpm_list_mtx);
1707 trace_suspend_resume(TPS("dpm_prepare"), state.event, false);
1712 * dpm_suspend_start - Prepare devices for PM transition and suspend them.
1713 * @state: PM transition of the system being carried out.
1715 * Prepare all non-sysdev devices for system PM transition and execute "suspend"
1716 * callbacks for them.
1718 int dpm_suspend_start(pm_message_t state)
1722 error = dpm_prepare(state);
1724 suspend_stats.failed_prepare++;
1725 dpm_save_failed_step(SUSPEND_PREPARE);
1727 error = dpm_suspend(state);
1730 EXPORT_SYMBOL_GPL(dpm_suspend_start);
1732 void __suspend_report_result(const char *function, void *fn, int ret)
1735 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
1737 EXPORT_SYMBOL_GPL(__suspend_report_result);
1740 * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete.
1741 * @dev: Device to wait for.
1742 * @subordinate: Device that needs to wait for @dev.
1744 int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
1746 dpm_wait(dev, subordinate->power.async_suspend);
1749 EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
1752 * dpm_for_each_dev - device iterator.
1753 * @data: data for the callback.
1754 * @fn: function to be called for each device.
1756 * Iterate over devices in dpm_list, and call @fn for each device,
1759 void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *))
1767 list_for_each_entry(dev, &dpm_list, power.entry)
1771 EXPORT_SYMBOL_GPL(dpm_for_each_dev);