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 intialize 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/mutex.h>
24 #include <linux/resume-trace.h>
25 #include <linux/rwsem.h>
31 * The entries in the dpm_list list are in a depth first order, simply
32 * because children are guaranteed to be discovered after parents, and
33 * are inserted at the back of the list on discovery.
35 * Since device_pm_add() may be called with a device semaphore held,
36 * we must never try to acquire a device semaphore while holding
42 static DEFINE_MUTEX(dpm_list_mtx);
45 * Set once the preparation of devices for a PM transition has started, reset
46 * before starting to resume devices. Protected by dpm_list_mtx.
48 static bool transition_started;
51 * device_pm_lock - lock the list of active devices used by the PM core
53 void device_pm_lock(void)
55 mutex_lock(&dpm_list_mtx);
59 * device_pm_unlock - unlock the list of active devices used by the PM core
61 void device_pm_unlock(void)
63 mutex_unlock(&dpm_list_mtx);
67 * device_pm_add - add a device to the list of active devices
68 * @dev: Device to be added to the list
70 void device_pm_add(struct device *dev)
72 pr_debug("PM: Adding info for %s:%s\n",
73 dev->bus ? dev->bus->name : "No Bus",
74 kobject_name(&dev->kobj));
75 mutex_lock(&dpm_list_mtx);
77 if (dev->parent->power.status >= DPM_SUSPENDING) {
78 dev_warn(dev, "parent %s is sleeping, will not add\n",
82 } else if (transition_started) {
84 * We refuse to register parentless devices while a PM
85 * transition is in progress in order to avoid leaving them
86 * unhandled down the road
91 list_add_tail(&dev->power.entry, &dpm_list);
92 mutex_unlock(&dpm_list_mtx);
96 * device_pm_remove - remove a device from the list of active devices
97 * @dev: Device to be removed from the list
99 * This function also removes the device's PM-related sysfs attributes.
101 void device_pm_remove(struct device *dev)
103 pr_debug("PM: Removing info for %s:%s\n",
104 dev->bus ? dev->bus->name : "No Bus",
105 kobject_name(&dev->kobj));
106 mutex_lock(&dpm_list_mtx);
107 list_del_init(&dev->power.entry);
108 mutex_unlock(&dpm_list_mtx);
112 * pm_op - execute the PM operation appropiate for given PM event
114 * @ops: PM operations to choose from.
115 * @state: PM transition of the system being carried out.
117 static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state)
121 switch (state.event) {
122 #ifdef CONFIG_SUSPEND
123 case PM_EVENT_SUSPEND:
125 error = ops->suspend(dev);
126 suspend_report_result(ops->suspend, error);
129 case PM_EVENT_RESUME:
131 error = ops->resume(dev);
132 suspend_report_result(ops->resume, error);
135 #endif /* CONFIG_SUSPEND */
136 #ifdef CONFIG_HIBERNATION
137 case PM_EVENT_FREEZE:
138 case PM_EVENT_QUIESCE:
140 error = ops->freeze(dev);
141 suspend_report_result(ops->freeze, error);
144 case PM_EVENT_HIBERNATE:
146 error = ops->poweroff(dev);
147 suspend_report_result(ops->poweroff, error);
151 case PM_EVENT_RECOVER:
153 error = ops->thaw(dev);
154 suspend_report_result(ops->thaw, error);
157 case PM_EVENT_RESTORE:
159 error = ops->restore(dev);
160 suspend_report_result(ops->restore, error);
163 #endif /* CONFIG_HIBERNATION */
171 * pm_noirq_op - execute the PM operation appropiate for given PM event
173 * @ops: PM operations to choose from.
174 * @state: PM transition of the system being carried out.
176 * The operation is executed with interrupts disabled by the only remaining
177 * functional CPU in the system.
179 static int pm_noirq_op(struct device *dev, struct pm_ext_ops *ops,
184 switch (state.event) {
185 #ifdef CONFIG_SUSPEND
186 case PM_EVENT_SUSPEND:
187 if (ops->suspend_noirq) {
188 error = ops->suspend_noirq(dev);
189 suspend_report_result(ops->suspend_noirq, error);
192 case PM_EVENT_RESUME:
193 if (ops->resume_noirq) {
194 error = ops->resume_noirq(dev);
195 suspend_report_result(ops->resume_noirq, error);
198 #endif /* CONFIG_SUSPEND */
199 #ifdef CONFIG_HIBERNATION
200 case PM_EVENT_FREEZE:
201 case PM_EVENT_QUIESCE:
202 if (ops->freeze_noirq) {
203 error = ops->freeze_noirq(dev);
204 suspend_report_result(ops->freeze_noirq, error);
207 case PM_EVENT_HIBERNATE:
208 if (ops->poweroff_noirq) {
209 error = ops->poweroff_noirq(dev);
210 suspend_report_result(ops->poweroff_noirq, error);
214 case PM_EVENT_RECOVER:
215 if (ops->thaw_noirq) {
216 error = ops->thaw_noirq(dev);
217 suspend_report_result(ops->thaw_noirq, error);
220 case PM_EVENT_RESTORE:
221 if (ops->restore_noirq) {
222 error = ops->restore_noirq(dev);
223 suspend_report_result(ops->restore_noirq, error);
226 #endif /* CONFIG_HIBERNATION */
233 static char *pm_verb(int event)
236 case PM_EVENT_SUSPEND:
238 case PM_EVENT_RESUME:
240 case PM_EVENT_FREEZE:
242 case PM_EVENT_QUIESCE:
244 case PM_EVENT_HIBERNATE:
248 case PM_EVENT_RESTORE:
250 case PM_EVENT_RECOVER:
253 return "(unknown PM event)";
257 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
259 dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
260 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
261 ", may wakeup" : "");
264 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
267 printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
268 kobject_name(&dev->kobj), pm_verb(state.event), info, error);
271 /*------------------------- Resume routines -------------------------*/
274 * resume_device_noirq - Power on one device (early resume).
276 * @state: PM transition of the system being carried out.
278 * Must be called with interrupts disabled.
280 static int resume_device_noirq(struct device *dev, pm_message_t state)
291 pm_dev_dbg(dev, state, "EARLY ");
292 error = pm_noirq_op(dev, dev->bus->pm, state);
293 } else if (dev->bus->resume_early) {
294 pm_dev_dbg(dev, state, "legacy EARLY ");
295 error = dev->bus->resume_early(dev);
303 * dpm_power_up - Power on all regular (non-sysdev) devices.
304 * @state: PM transition of the system being carried out.
306 * Execute the appropriate "noirq resume" callback for all devices marked
309 * Must be called with interrupts disabled and only one CPU running.
311 static void dpm_power_up(pm_message_t state)
315 list_for_each_entry(dev, &dpm_list, power.entry)
316 if (dev->power.status > DPM_OFF) {
319 dev->power.status = DPM_OFF;
320 error = resume_device_noirq(dev, state);
322 pm_dev_err(dev, state, " early", error);
327 * device_power_up - Turn on all devices that need special attention.
328 * @state: PM transition of the system being carried out.
330 * Power on system devices, then devices that required we shut them down
331 * with interrupts disabled.
333 * Must be called with interrupts disabled.
335 void device_power_up(pm_message_t state)
340 EXPORT_SYMBOL_GPL(device_power_up);
343 * resume_device - Restore state for one device.
345 * @state: PM transition of the system being carried out.
347 static int resume_device(struct device *dev, pm_message_t state)
358 pm_dev_dbg(dev, state, "");
359 error = pm_op(dev, &dev->bus->pm->base, state);
360 } else if (dev->bus->resume) {
361 pm_dev_dbg(dev, state, "legacy ");
362 error = dev->bus->resume(dev);
370 pm_dev_dbg(dev, state, "type ");
371 error = pm_op(dev, dev->type->pm, state);
372 } else if (dev->type->resume) {
373 pm_dev_dbg(dev, state, "legacy type ");
374 error = dev->type->resume(dev);
381 if (dev->class->pm) {
382 pm_dev_dbg(dev, state, "class ");
383 error = pm_op(dev, dev->class->pm, state);
384 } else if (dev->class->resume) {
385 pm_dev_dbg(dev, state, "legacy class ");
386 error = dev->class->resume(dev);
397 * dpm_resume - Resume every device.
398 * @state: PM transition of the system being carried out.
400 * Execute the appropriate "resume" callback for all devices the status of
401 * which indicates that they are inactive.
403 static void dpm_resume(pm_message_t state)
405 struct list_head list;
407 INIT_LIST_HEAD(&list);
408 mutex_lock(&dpm_list_mtx);
409 transition_started = false;
410 while (!list_empty(&dpm_list)) {
411 struct device *dev = to_device(dpm_list.next);
414 if (dev->power.status >= DPM_OFF) {
417 dev->power.status = DPM_RESUMING;
418 mutex_unlock(&dpm_list_mtx);
420 error = resume_device(dev, state);
422 mutex_lock(&dpm_list_mtx);
424 pm_dev_err(dev, state, "", error);
425 } else if (dev->power.status == DPM_SUSPENDING) {
426 /* Allow new children of the device to be registered */
427 dev->power.status = DPM_RESUMING;
429 if (!list_empty(&dev->power.entry))
430 list_move_tail(&dev->power.entry, &list);
433 list_splice(&list, &dpm_list);
434 mutex_unlock(&dpm_list_mtx);
438 * complete_device - Complete a PM transition for given device
440 * @state: PM transition of the system being carried out.
442 static void complete_device(struct device *dev, pm_message_t state)
446 if (dev->class && dev->class->pm && dev->class->pm->complete) {
447 pm_dev_dbg(dev, state, "completing class ");
448 dev->class->pm->complete(dev);
451 if (dev->type && dev->type->pm && dev->type->pm->complete) {
452 pm_dev_dbg(dev, state, "completing type ");
453 dev->type->pm->complete(dev);
456 if (dev->bus && dev->bus->pm && dev->bus->pm->base.complete) {
457 pm_dev_dbg(dev, state, "completing ");
458 dev->bus->pm->base.complete(dev);
465 * dpm_complete - Complete a PM transition for all devices.
466 * @state: PM transition of the system being carried out.
468 * Execute the ->complete() callbacks for all devices that are not marked
471 static void dpm_complete(pm_message_t state)
473 struct list_head list;
475 INIT_LIST_HEAD(&list);
476 mutex_lock(&dpm_list_mtx);
477 while (!list_empty(&dpm_list)) {
478 struct device *dev = to_device(dpm_list.prev);
481 if (dev->power.status > DPM_ON) {
482 dev->power.status = DPM_ON;
483 mutex_unlock(&dpm_list_mtx);
485 complete_device(dev, state);
487 mutex_lock(&dpm_list_mtx);
489 if (!list_empty(&dev->power.entry))
490 list_move(&dev->power.entry, &list);
493 list_splice(&list, &dpm_list);
494 mutex_unlock(&dpm_list_mtx);
498 * device_resume - Restore state of each device in system.
499 * @state: PM transition of the system being carried out.
501 * Resume all the devices, unlock them all, and allow new
502 * devices to be registered once again.
504 void device_resume(pm_message_t state)
510 EXPORT_SYMBOL_GPL(device_resume);
513 /*------------------------- Suspend routines -------------------------*/
516 * resume_event - return a PM message representing the resume event
517 * corresponding to given sleep state.
518 * @sleep_state: PM message representing a sleep state.
520 static pm_message_t resume_event(pm_message_t sleep_state)
522 switch (sleep_state.event) {
523 case PM_EVENT_SUSPEND:
525 case PM_EVENT_FREEZE:
526 case PM_EVENT_QUIESCE:
528 case PM_EVENT_HIBERNATE:
535 * suspend_device_noirq - Shut down one device (late suspend).
537 * @state: PM transition of the system being carried out.
539 * This is called with interrupts off and only a single CPU running.
541 static int suspend_device_noirq(struct device *dev, pm_message_t state)
549 pm_dev_dbg(dev, state, "LATE ");
550 error = pm_noirq_op(dev, dev->bus->pm, state);
551 } else if (dev->bus->suspend_late) {
552 pm_dev_dbg(dev, state, "legacy LATE ");
553 error = dev->bus->suspend_late(dev, state);
554 suspend_report_result(dev->bus->suspend_late, error);
560 * device_power_down - Shut down special devices.
561 * @state: PM transition of the system being carried out.
563 * Power down devices that require interrupts to be disabled.
564 * Then power down system devices.
566 * Must be called with interrupts disabled and only one CPU running.
568 int device_power_down(pm_message_t state)
573 list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
574 error = suspend_device_noirq(dev, state);
576 pm_dev_err(dev, state, " late", error);
579 dev->power.status = DPM_OFF_IRQ;
582 error = sysdev_suspend(state);
584 dpm_power_up(resume_event(state));
587 EXPORT_SYMBOL_GPL(device_power_down);
590 * suspend_device - Save state of one device.
592 * @state: PM transition of the system being carried out.
594 static int suspend_device(struct device *dev, pm_message_t state)
601 if (dev->class->pm) {
602 pm_dev_dbg(dev, state, "class ");
603 error = pm_op(dev, dev->class->pm, state);
604 } else if (dev->class->suspend) {
605 pm_dev_dbg(dev, state, "legacy class ");
606 error = dev->class->suspend(dev, state);
607 suspend_report_result(dev->class->suspend, error);
615 pm_dev_dbg(dev, state, "type ");
616 error = pm_op(dev, dev->type->pm, state);
617 } else if (dev->type->suspend) {
618 pm_dev_dbg(dev, state, "legacy type ");
619 error = dev->type->suspend(dev, state);
620 suspend_report_result(dev->type->suspend, error);
628 pm_dev_dbg(dev, state, "");
629 error = pm_op(dev, &dev->bus->pm->base, state);
630 } else if (dev->bus->suspend) {
631 pm_dev_dbg(dev, state, "legacy ");
632 error = dev->bus->suspend(dev, state);
633 suspend_report_result(dev->bus->suspend, error);
643 * dpm_suspend - Suspend every device.
644 * @state: PM transition of the system being carried out.
646 * Execute the appropriate "suspend" callbacks for all devices.
648 static int dpm_suspend(pm_message_t state)
650 struct list_head list;
653 INIT_LIST_HEAD(&list);
654 mutex_lock(&dpm_list_mtx);
655 while (!list_empty(&dpm_list)) {
656 struct device *dev = to_device(dpm_list.prev);
659 mutex_unlock(&dpm_list_mtx);
661 error = suspend_device(dev, state);
663 mutex_lock(&dpm_list_mtx);
665 pm_dev_err(dev, state, "", error);
669 dev->power.status = DPM_OFF;
670 if (!list_empty(&dev->power.entry))
671 list_move(&dev->power.entry, &list);
674 list_splice(&list, dpm_list.prev);
675 mutex_unlock(&dpm_list_mtx);
680 * prepare_device - Execute the ->prepare() callback(s) for given device.
682 * @state: PM transition of the system being carried out.
684 static int prepare_device(struct device *dev, pm_message_t state)
690 if (dev->bus && dev->bus->pm && dev->bus->pm->base.prepare) {
691 pm_dev_dbg(dev, state, "preparing ");
692 error = dev->bus->pm->base.prepare(dev);
693 suspend_report_result(dev->bus->pm->base.prepare, error);
698 if (dev->type && dev->type->pm && dev->type->pm->prepare) {
699 pm_dev_dbg(dev, state, "preparing type ");
700 error = dev->type->pm->prepare(dev);
701 suspend_report_result(dev->type->pm->prepare, error);
706 if (dev->class && dev->class->pm && dev->class->pm->prepare) {
707 pm_dev_dbg(dev, state, "preparing class ");
708 error = dev->class->pm->prepare(dev);
709 suspend_report_result(dev->class->pm->prepare, error);
718 * dpm_prepare - Prepare all devices for a PM transition.
719 * @state: PM transition of the system being carried out.
721 * Execute the ->prepare() callback for all devices.
723 static int dpm_prepare(pm_message_t state)
725 struct list_head list;
728 INIT_LIST_HEAD(&list);
729 mutex_lock(&dpm_list_mtx);
730 transition_started = true;
731 while (!list_empty(&dpm_list)) {
732 struct device *dev = to_device(dpm_list.next);
735 dev->power.status = DPM_PREPARING;
736 mutex_unlock(&dpm_list_mtx);
738 error = prepare_device(dev, state);
740 mutex_lock(&dpm_list_mtx);
742 dev->power.status = DPM_ON;
743 if (error == -EAGAIN) {
747 printk(KERN_ERR "PM: Failed to prepare device %s "
748 "for power transition: error %d\n",
749 kobject_name(&dev->kobj), error);
753 dev->power.status = DPM_SUSPENDING;
754 if (!list_empty(&dev->power.entry))
755 list_move_tail(&dev->power.entry, &list);
758 list_splice(&list, &dpm_list);
759 mutex_unlock(&dpm_list_mtx);
764 * device_suspend - Save state and stop all devices in system.
765 * @state: PM transition of the system being carried out.
767 * Prepare and suspend all devices.
769 int device_suspend(pm_message_t state)
774 error = dpm_prepare(state);
776 error = dpm_suspend(state);
779 EXPORT_SYMBOL_GPL(device_suspend);
781 void __suspend_report_result(const char *function, void *fn, int ret)
784 printk(KERN_ERR "%s(): ", function);
785 print_fn_descriptor_symbol("%s returns ", fn);
789 EXPORT_SYMBOL_GPL(__suspend_report_result);