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>
26 #include <linux/interrupt.h>
32 * The entries in the dpm_list list are in a depth first order, simply
33 * because children are guaranteed to be discovered after parents, and
34 * are inserted at the back of the list on discovery.
36 * Since device_pm_add() may be called with a device semaphore held,
37 * we must never try to acquire a device semaphore while holding
43 static DEFINE_MUTEX(dpm_list_mtx);
46 * Set once the preparation of devices for a PM transition has started, reset
47 * before starting to resume devices. Protected by dpm_list_mtx.
49 static bool transition_started;
52 * device_pm_lock - lock the list of active devices used by the PM core
54 void device_pm_lock(void)
56 mutex_lock(&dpm_list_mtx);
60 * device_pm_unlock - unlock the list of active devices used by the PM core
62 void device_pm_unlock(void)
64 mutex_unlock(&dpm_list_mtx);
68 * device_pm_add - add a device to the list of active devices
69 * @dev: Device to be added to the list
71 void device_pm_add(struct device *dev)
73 pr_debug("PM: Adding info for %s:%s\n",
74 dev->bus ? dev->bus->name : "No Bus",
75 kobject_name(&dev->kobj));
76 mutex_lock(&dpm_list_mtx);
78 if (dev->parent->power.status >= DPM_SUSPENDING)
79 dev_warn(dev, "parent %s should not be sleeping\n",
80 dev_name(dev->parent));
81 } else if (transition_started) {
83 * We refuse to register parentless devices while a PM
84 * transition is in progress in order to avoid leaving them
85 * unhandled down the road
87 dev_WARN(dev, "Parentless device registered during a PM transaction\n");
90 list_add_tail(&dev->power.entry, &dpm_list);
91 mutex_unlock(&dpm_list_mtx);
95 * device_pm_remove - remove a device from the list of active devices
96 * @dev: Device to be removed from the list
98 * This function also removes the device's PM-related sysfs attributes.
100 void device_pm_remove(struct device *dev)
102 pr_debug("PM: Removing info for %s:%s\n",
103 dev->bus ? dev->bus->name : "No Bus",
104 kobject_name(&dev->kobj));
105 mutex_lock(&dpm_list_mtx);
106 list_del_init(&dev->power.entry);
107 mutex_unlock(&dpm_list_mtx);
111 * device_pm_move_before - move device in dpm_list
112 * @deva: Device to move in dpm_list
113 * @devb: Device @deva should come before
115 void device_pm_move_before(struct device *deva, struct device *devb)
117 pr_debug("PM: Moving %s:%s before %s:%s\n",
118 deva->bus ? deva->bus->name : "No Bus",
119 kobject_name(&deva->kobj),
120 devb->bus ? devb->bus->name : "No Bus",
121 kobject_name(&devb->kobj));
122 /* Delete deva from dpm_list and reinsert before devb. */
123 list_move_tail(&deva->power.entry, &devb->power.entry);
127 * device_pm_move_after - move device in dpm_list
128 * @deva: Device to move in dpm_list
129 * @devb: Device @deva should come after
131 void device_pm_move_after(struct device *deva, struct device *devb)
133 pr_debug("PM: Moving %s:%s after %s:%s\n",
134 deva->bus ? deva->bus->name : "No Bus",
135 kobject_name(&deva->kobj),
136 devb->bus ? devb->bus->name : "No Bus",
137 kobject_name(&devb->kobj));
138 /* Delete deva from dpm_list and reinsert after devb. */
139 list_move(&deva->power.entry, &devb->power.entry);
143 * device_pm_move_last - move device to end of dpm_list
144 * @dev: Device to move in dpm_list
146 void device_pm_move_last(struct device *dev)
148 pr_debug("PM: Moving %s:%s to end of list\n",
149 dev->bus ? dev->bus->name : "No Bus",
150 kobject_name(&dev->kobj));
151 list_move_tail(&dev->power.entry, &dpm_list);
155 * pm_op - execute the PM operation appropiate for given PM event
157 * @ops: PM operations to choose from.
158 * @state: PM transition of the system being carried out.
160 static int pm_op(struct device *dev, struct dev_pm_ops *ops,
165 switch (state.event) {
166 #ifdef CONFIG_SUSPEND
167 case PM_EVENT_SUSPEND:
169 error = ops->suspend(dev);
170 suspend_report_result(ops->suspend, error);
173 case PM_EVENT_RESUME:
175 error = ops->resume(dev);
176 suspend_report_result(ops->resume, error);
179 #endif /* CONFIG_SUSPEND */
180 #ifdef CONFIG_HIBERNATION
181 case PM_EVENT_FREEZE:
182 case PM_EVENT_QUIESCE:
184 error = ops->freeze(dev);
185 suspend_report_result(ops->freeze, error);
188 case PM_EVENT_HIBERNATE:
190 error = ops->poweroff(dev);
191 suspend_report_result(ops->poweroff, error);
195 case PM_EVENT_RECOVER:
197 error = ops->thaw(dev);
198 suspend_report_result(ops->thaw, error);
201 case PM_EVENT_RESTORE:
203 error = ops->restore(dev);
204 suspend_report_result(ops->restore, error);
207 #endif /* CONFIG_HIBERNATION */
215 * pm_noirq_op - execute the PM operation appropiate for given PM event
217 * @ops: PM operations to choose from.
218 * @state: PM transition of the system being carried out.
220 * The operation is executed with interrupts disabled by the only remaining
221 * functional CPU in the system.
223 static int pm_noirq_op(struct device *dev, struct dev_pm_ops *ops,
228 switch (state.event) {
229 #ifdef CONFIG_SUSPEND
230 case PM_EVENT_SUSPEND:
231 if (ops->suspend_noirq) {
232 error = ops->suspend_noirq(dev);
233 suspend_report_result(ops->suspend_noirq, error);
236 case PM_EVENT_RESUME:
237 if (ops->resume_noirq) {
238 error = ops->resume_noirq(dev);
239 suspend_report_result(ops->resume_noirq, error);
242 #endif /* CONFIG_SUSPEND */
243 #ifdef CONFIG_HIBERNATION
244 case PM_EVENT_FREEZE:
245 case PM_EVENT_QUIESCE:
246 if (ops->freeze_noirq) {
247 error = ops->freeze_noirq(dev);
248 suspend_report_result(ops->freeze_noirq, error);
251 case PM_EVENT_HIBERNATE:
252 if (ops->poweroff_noirq) {
253 error = ops->poweroff_noirq(dev);
254 suspend_report_result(ops->poweroff_noirq, error);
258 case PM_EVENT_RECOVER:
259 if (ops->thaw_noirq) {
260 error = ops->thaw_noirq(dev);
261 suspend_report_result(ops->thaw_noirq, error);
264 case PM_EVENT_RESTORE:
265 if (ops->restore_noirq) {
266 error = ops->restore_noirq(dev);
267 suspend_report_result(ops->restore_noirq, error);
270 #endif /* CONFIG_HIBERNATION */
277 static char *pm_verb(int event)
280 case PM_EVENT_SUSPEND:
282 case PM_EVENT_RESUME:
284 case PM_EVENT_FREEZE:
286 case PM_EVENT_QUIESCE:
288 case PM_EVENT_HIBERNATE:
292 case PM_EVENT_RESTORE:
294 case PM_EVENT_RECOVER:
297 return "(unknown PM event)";
301 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
303 dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
304 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
305 ", may wakeup" : "");
308 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
311 printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
312 kobject_name(&dev->kobj), pm_verb(state.event), info, error);
315 /*------------------------- Resume routines -------------------------*/
318 * device_resume_noirq - Power on one device (early resume).
320 * @state: PM transition of the system being carried out.
322 * Must be called with interrupts disabled.
324 static int device_resume_noirq(struct device *dev, pm_message_t state)
335 pm_dev_dbg(dev, state, "EARLY ");
336 error = pm_noirq_op(dev, dev->bus->pm, state);
337 } else if (dev->bus->resume_early) {
338 pm_dev_dbg(dev, state, "legacy EARLY ");
339 error = dev->bus->resume_early(dev);
347 * dpm_resume_noirq - Power on all regular (non-sysdev) devices.
348 * @state: PM transition of the system being carried out.
350 * Call the "noirq" resume handlers for all devices marked as
351 * DPM_OFF_IRQ and enable device drivers to receive interrupts.
353 * Must be called under dpm_list_mtx. Device drivers should not receive
354 * interrupts while it's being executed.
356 void dpm_resume_noirq(pm_message_t state)
360 mutex_lock(&dpm_list_mtx);
361 list_for_each_entry(dev, &dpm_list, power.entry)
362 if (dev->power.status > DPM_OFF) {
365 dev->power.status = DPM_OFF;
366 error = device_resume_noirq(dev, state);
368 pm_dev_err(dev, state, " early", error);
370 mutex_unlock(&dpm_list_mtx);
371 resume_device_irqs();
373 EXPORT_SYMBOL_GPL(dpm_resume_noirq);
376 * device_resume - Restore state for one device.
378 * @state: PM transition of the system being carried out.
380 static int device_resume(struct device *dev, pm_message_t state)
391 pm_dev_dbg(dev, state, "");
392 error = pm_op(dev, dev->bus->pm, state);
393 } else if (dev->bus->resume) {
394 pm_dev_dbg(dev, state, "legacy ");
395 error = dev->bus->resume(dev);
403 pm_dev_dbg(dev, state, "type ");
404 error = pm_op(dev, dev->type->pm, state);
405 } else if (dev->type->resume) {
406 pm_dev_dbg(dev, state, "legacy type ");
407 error = dev->type->resume(dev);
414 if (dev->class->pm) {
415 pm_dev_dbg(dev, state, "class ");
416 error = pm_op(dev, dev->class->pm, state);
417 } else if (dev->class->resume) {
418 pm_dev_dbg(dev, state, "legacy class ");
419 error = dev->class->resume(dev);
430 * dpm_resume - Resume every device.
431 * @state: PM transition of the system being carried out.
433 * Execute the appropriate "resume" callback for all devices the status of
434 * which indicates that they are inactive.
436 static void dpm_resume(pm_message_t state)
438 struct list_head list;
440 INIT_LIST_HEAD(&list);
441 mutex_lock(&dpm_list_mtx);
442 transition_started = false;
443 while (!list_empty(&dpm_list)) {
444 struct device *dev = to_device(dpm_list.next);
447 if (dev->power.status >= DPM_OFF) {
450 dev->power.status = DPM_RESUMING;
451 mutex_unlock(&dpm_list_mtx);
453 error = device_resume(dev, state);
455 mutex_lock(&dpm_list_mtx);
457 pm_dev_err(dev, state, "", error);
458 } else if (dev->power.status == DPM_SUSPENDING) {
459 /* Allow new children of the device to be registered */
460 dev->power.status = DPM_RESUMING;
462 if (!list_empty(&dev->power.entry))
463 list_move_tail(&dev->power.entry, &list);
466 list_splice(&list, &dpm_list);
467 mutex_unlock(&dpm_list_mtx);
471 * device_complete - Complete a PM transition for given device
473 * @state: PM transition of the system being carried out.
475 static void device_complete(struct device *dev, pm_message_t state)
479 if (dev->class && dev->class->pm && dev->class->pm->complete) {
480 pm_dev_dbg(dev, state, "completing class ");
481 dev->class->pm->complete(dev);
484 if (dev->type && dev->type->pm && dev->type->pm->complete) {
485 pm_dev_dbg(dev, state, "completing type ");
486 dev->type->pm->complete(dev);
489 if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
490 pm_dev_dbg(dev, state, "completing ");
491 dev->bus->pm->complete(dev);
498 * dpm_complete - Complete a PM transition for all devices.
499 * @state: PM transition of the system being carried out.
501 * Execute the ->complete() callbacks for all devices that are not marked
504 static void dpm_complete(pm_message_t state)
506 struct list_head list;
508 INIT_LIST_HEAD(&list);
509 mutex_lock(&dpm_list_mtx);
510 while (!list_empty(&dpm_list)) {
511 struct device *dev = to_device(dpm_list.prev);
514 if (dev->power.status > DPM_ON) {
515 dev->power.status = DPM_ON;
516 mutex_unlock(&dpm_list_mtx);
518 device_complete(dev, state);
520 mutex_lock(&dpm_list_mtx);
522 if (!list_empty(&dev->power.entry))
523 list_move(&dev->power.entry, &list);
526 list_splice(&list, &dpm_list);
527 mutex_unlock(&dpm_list_mtx);
531 * dpm_resume_end - Restore state of each device in system.
532 * @state: PM transition of the system being carried out.
534 * Resume all the devices, unlock them all, and allow new
535 * devices to be registered once again.
537 void dpm_resume_end(pm_message_t state)
543 EXPORT_SYMBOL_GPL(dpm_resume_end);
546 /*------------------------- Suspend routines -------------------------*/
549 * resume_event - return a PM message representing the resume event
550 * corresponding to given sleep state.
551 * @sleep_state: PM message representing a sleep state.
553 static pm_message_t resume_event(pm_message_t sleep_state)
555 switch (sleep_state.event) {
556 case PM_EVENT_SUSPEND:
558 case PM_EVENT_FREEZE:
559 case PM_EVENT_QUIESCE:
561 case PM_EVENT_HIBERNATE:
568 * device_suspend_noirq - Shut down one device (late suspend).
570 * @state: PM transition of the system being carried out.
572 * This is called with interrupts off and only a single CPU running.
574 static int device_suspend_noirq(struct device *dev, pm_message_t state)
582 pm_dev_dbg(dev, state, "LATE ");
583 error = pm_noirq_op(dev, dev->bus->pm, state);
584 } else if (dev->bus->suspend_late) {
585 pm_dev_dbg(dev, state, "legacy LATE ");
586 error = dev->bus->suspend_late(dev, state);
587 suspend_report_result(dev->bus->suspend_late, error);
593 * dpm_suspend_noirq - Power down all regular (non-sysdev) devices.
594 * @state: PM transition of the system being carried out.
596 * Prevent device drivers from receiving interrupts and call the "noirq"
599 * Must be called under dpm_list_mtx.
601 int dpm_suspend_noirq(pm_message_t state)
606 suspend_device_irqs();
607 mutex_lock(&dpm_list_mtx);
608 list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
609 error = device_suspend_noirq(dev, state);
611 pm_dev_err(dev, state, " late", error);
614 dev->power.status = DPM_OFF_IRQ;
616 mutex_unlock(&dpm_list_mtx);
618 dpm_resume_noirq(resume_event(state));
621 EXPORT_SYMBOL_GPL(dpm_suspend_noirq);
624 * device_suspend - Save state of one device.
626 * @state: PM transition of the system being carried out.
628 static int device_suspend(struct device *dev, pm_message_t state)
635 if (dev->class->pm) {
636 pm_dev_dbg(dev, state, "class ");
637 error = pm_op(dev, dev->class->pm, state);
638 } else if (dev->class->suspend) {
639 pm_dev_dbg(dev, state, "legacy class ");
640 error = dev->class->suspend(dev, state);
641 suspend_report_result(dev->class->suspend, error);
649 pm_dev_dbg(dev, state, "type ");
650 error = pm_op(dev, dev->type->pm, state);
651 } else if (dev->type->suspend) {
652 pm_dev_dbg(dev, state, "legacy type ");
653 error = dev->type->suspend(dev, state);
654 suspend_report_result(dev->type->suspend, error);
662 pm_dev_dbg(dev, state, "");
663 error = pm_op(dev, dev->bus->pm, state);
664 } else if (dev->bus->suspend) {
665 pm_dev_dbg(dev, state, "legacy ");
666 error = dev->bus->suspend(dev, state);
667 suspend_report_result(dev->bus->suspend, error);
677 * dpm_suspend - Suspend every device.
678 * @state: PM transition of the system being carried out.
680 * Execute the appropriate "suspend" callbacks for all devices.
682 static int dpm_suspend(pm_message_t state)
684 struct list_head list;
687 INIT_LIST_HEAD(&list);
688 mutex_lock(&dpm_list_mtx);
689 while (!list_empty(&dpm_list)) {
690 struct device *dev = to_device(dpm_list.prev);
693 mutex_unlock(&dpm_list_mtx);
695 error = device_suspend(dev, state);
697 mutex_lock(&dpm_list_mtx);
699 pm_dev_err(dev, state, "", error);
703 dev->power.status = DPM_OFF;
704 if (!list_empty(&dev->power.entry))
705 list_move(&dev->power.entry, &list);
708 list_splice(&list, dpm_list.prev);
709 mutex_unlock(&dpm_list_mtx);
714 * device_prepare - Execute the ->prepare() callback(s) for given device.
716 * @state: PM transition of the system being carried out.
718 static int device_prepare(struct device *dev, pm_message_t state)
724 if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
725 pm_dev_dbg(dev, state, "preparing ");
726 error = dev->bus->pm->prepare(dev);
727 suspend_report_result(dev->bus->pm->prepare, error);
732 if (dev->type && dev->type->pm && dev->type->pm->prepare) {
733 pm_dev_dbg(dev, state, "preparing type ");
734 error = dev->type->pm->prepare(dev);
735 suspend_report_result(dev->type->pm->prepare, error);
740 if (dev->class && dev->class->pm && dev->class->pm->prepare) {
741 pm_dev_dbg(dev, state, "preparing class ");
742 error = dev->class->pm->prepare(dev);
743 suspend_report_result(dev->class->pm->prepare, error);
752 * dpm_prepare - Prepare all devices for a PM transition.
753 * @state: PM transition of the system being carried out.
755 * Execute the ->prepare() callback for all devices.
757 static int dpm_prepare(pm_message_t state)
759 struct list_head list;
762 INIT_LIST_HEAD(&list);
763 mutex_lock(&dpm_list_mtx);
764 transition_started = true;
765 while (!list_empty(&dpm_list)) {
766 struct device *dev = to_device(dpm_list.next);
769 dev->power.status = DPM_PREPARING;
770 mutex_unlock(&dpm_list_mtx);
772 error = device_prepare(dev, state);
774 mutex_lock(&dpm_list_mtx);
776 dev->power.status = DPM_ON;
777 if (error == -EAGAIN) {
781 printk(KERN_ERR "PM: Failed to prepare device %s "
782 "for power transition: error %d\n",
783 kobject_name(&dev->kobj), error);
787 dev->power.status = DPM_SUSPENDING;
788 if (!list_empty(&dev->power.entry))
789 list_move_tail(&dev->power.entry, &list);
792 list_splice(&list, &dpm_list);
793 mutex_unlock(&dpm_list_mtx);
798 * dpm_suspend_start - Save state and stop all devices in system.
799 * @state: PM transition of the system being carried out.
801 * Prepare and suspend all devices.
803 int dpm_suspend_start(pm_message_t state)
808 error = dpm_prepare(state);
810 error = dpm_suspend(state);
813 EXPORT_SYMBOL_GPL(dpm_suspend_start);
815 void __suspend_report_result(const char *function, void *fn, int ret)
818 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
820 EXPORT_SYMBOL_GPL(__suspend_report_result);