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 * resume_device_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 resume_device_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_power_up - Power on all regular (non-sysdev) devices.
348 * @state: PM transition of the system being carried out.
350 * Execute the appropriate "noirq resume" callback for all devices marked
353 * Must be called under dpm_list_mtx. Device drivers should not receive
354 * interrupts while it's being executed.
356 static void dpm_power_up(pm_message_t state
)
360 list_for_each_entry(dev
, &dpm_list
, power
.entry
)
361 if (dev
->power
.status
> DPM_OFF
) {
364 dev
->power
.status
= DPM_OFF
;
365 error
= resume_device_noirq(dev
, state
);
367 pm_dev_err(dev
, state
, " early", error
);
372 * device_power_up - Turn on all devices that need special attention.
373 * @state: PM transition of the system being carried out.
375 * Call the "early" resume handlers and enable device drivers to receive
378 void device_power_up(pm_message_t state
)
381 resume_device_irqs();
383 EXPORT_SYMBOL_GPL(device_power_up
);
386 * resume_device - Restore state for one device.
388 * @state: PM transition of the system being carried out.
390 static int resume_device(struct device
*dev
, pm_message_t state
)
401 pm_dev_dbg(dev
, state
, "");
402 error
= pm_op(dev
, dev
->bus
->pm
, state
);
403 } else if (dev
->bus
->resume
) {
404 pm_dev_dbg(dev
, state
, "legacy ");
405 error
= dev
->bus
->resume(dev
);
413 pm_dev_dbg(dev
, state
, "type ");
414 error
= pm_op(dev
, dev
->type
->pm
, state
);
415 } else if (dev
->type
->resume
) {
416 pm_dev_dbg(dev
, state
, "legacy type ");
417 error
= dev
->type
->resume(dev
);
424 if (dev
->class->pm
) {
425 pm_dev_dbg(dev
, state
, "class ");
426 error
= pm_op(dev
, dev
->class->pm
, state
);
427 } else if (dev
->class->resume
) {
428 pm_dev_dbg(dev
, state
, "legacy class ");
429 error
= dev
->class->resume(dev
);
440 * dpm_resume - Resume every device.
441 * @state: PM transition of the system being carried out.
443 * Execute the appropriate "resume" callback for all devices the status of
444 * which indicates that they are inactive.
446 static void dpm_resume(pm_message_t state
)
448 struct list_head list
;
450 INIT_LIST_HEAD(&list
);
451 mutex_lock(&dpm_list_mtx
);
452 transition_started
= false;
453 while (!list_empty(&dpm_list
)) {
454 struct device
*dev
= to_device(dpm_list
.next
);
457 if (dev
->power
.status
>= DPM_OFF
) {
460 dev
->power
.status
= DPM_RESUMING
;
461 mutex_unlock(&dpm_list_mtx
);
463 error
= resume_device(dev
, state
);
465 mutex_lock(&dpm_list_mtx
);
467 pm_dev_err(dev
, state
, "", error
);
468 } else if (dev
->power
.status
== DPM_SUSPENDING
) {
469 /* Allow new children of the device to be registered */
470 dev
->power
.status
= DPM_RESUMING
;
472 if (!list_empty(&dev
->power
.entry
))
473 list_move_tail(&dev
->power
.entry
, &list
);
476 list_splice(&list
, &dpm_list
);
477 mutex_unlock(&dpm_list_mtx
);
481 * complete_device - Complete a PM transition for given device
483 * @state: PM transition of the system being carried out.
485 static void complete_device(struct device
*dev
, pm_message_t state
)
489 if (dev
->class && dev
->class->pm
&& dev
->class->pm
->complete
) {
490 pm_dev_dbg(dev
, state
, "completing class ");
491 dev
->class->pm
->complete(dev
);
494 if (dev
->type
&& dev
->type
->pm
&& dev
->type
->pm
->complete
) {
495 pm_dev_dbg(dev
, state
, "completing type ");
496 dev
->type
->pm
->complete(dev
);
499 if (dev
->bus
&& dev
->bus
->pm
&& dev
->bus
->pm
->complete
) {
500 pm_dev_dbg(dev
, state
, "completing ");
501 dev
->bus
->pm
->complete(dev
);
508 * dpm_complete - Complete a PM transition for all devices.
509 * @state: PM transition of the system being carried out.
511 * Execute the ->complete() callbacks for all devices that are not marked
514 static void dpm_complete(pm_message_t state
)
516 struct list_head list
;
518 INIT_LIST_HEAD(&list
);
519 mutex_lock(&dpm_list_mtx
);
520 while (!list_empty(&dpm_list
)) {
521 struct device
*dev
= to_device(dpm_list
.prev
);
524 if (dev
->power
.status
> DPM_ON
) {
525 dev
->power
.status
= DPM_ON
;
526 mutex_unlock(&dpm_list_mtx
);
528 complete_device(dev
, state
);
530 mutex_lock(&dpm_list_mtx
);
532 if (!list_empty(&dev
->power
.entry
))
533 list_move(&dev
->power
.entry
, &list
);
536 list_splice(&list
, &dpm_list
);
537 mutex_unlock(&dpm_list_mtx
);
541 * device_resume - Restore state of each device in system.
542 * @state: PM transition of the system being carried out.
544 * Resume all the devices, unlock them all, and allow new
545 * devices to be registered once again.
547 void device_resume(pm_message_t state
)
553 EXPORT_SYMBOL_GPL(device_resume
);
556 /*------------------------- Suspend routines -------------------------*/
559 * resume_event - return a PM message representing the resume event
560 * corresponding to given sleep state.
561 * @sleep_state: PM message representing a sleep state.
563 static pm_message_t
resume_event(pm_message_t sleep_state
)
565 switch (sleep_state
.event
) {
566 case PM_EVENT_SUSPEND
:
568 case PM_EVENT_FREEZE
:
569 case PM_EVENT_QUIESCE
:
571 case PM_EVENT_HIBERNATE
:
578 * suspend_device_noirq - Shut down one device (late suspend).
580 * @state: PM transition of the system being carried out.
582 * This is called with interrupts off and only a single CPU running.
584 static int suspend_device_noirq(struct device
*dev
, pm_message_t state
)
592 pm_dev_dbg(dev
, state
, "LATE ");
593 error
= pm_noirq_op(dev
, dev
->bus
->pm
, state
);
594 } else if (dev
->bus
->suspend_late
) {
595 pm_dev_dbg(dev
, state
, "legacy LATE ");
596 error
= dev
->bus
->suspend_late(dev
, state
);
597 suspend_report_result(dev
->bus
->suspend_late
, error
);
603 * device_power_down - Shut down special devices.
604 * @state: PM transition of the system being carried out.
606 * Prevent device drivers from receiving interrupts and call the "late"
609 * Must be called under dpm_list_mtx.
611 int device_power_down(pm_message_t state
)
616 suspend_device_irqs();
617 list_for_each_entry_reverse(dev
, &dpm_list
, power
.entry
) {
618 error
= suspend_device_noirq(dev
, state
);
620 pm_dev_err(dev
, state
, " late", error
);
623 dev
->power
.status
= DPM_OFF_IRQ
;
626 device_power_up(resume_event(state
));
629 EXPORT_SYMBOL_GPL(device_power_down
);
632 * suspend_device - Save state of one device.
634 * @state: PM transition of the system being carried out.
636 static int suspend_device(struct device
*dev
, pm_message_t state
)
643 if (dev
->class->pm
) {
644 pm_dev_dbg(dev
, state
, "class ");
645 error
= pm_op(dev
, dev
->class->pm
, state
);
646 } else if (dev
->class->suspend
) {
647 pm_dev_dbg(dev
, state
, "legacy class ");
648 error
= dev
->class->suspend(dev
, state
);
649 suspend_report_result(dev
->class->suspend
, error
);
657 pm_dev_dbg(dev
, state
, "type ");
658 error
= pm_op(dev
, dev
->type
->pm
, state
);
659 } else if (dev
->type
->suspend
) {
660 pm_dev_dbg(dev
, state
, "legacy type ");
661 error
= dev
->type
->suspend(dev
, state
);
662 suspend_report_result(dev
->type
->suspend
, error
);
670 pm_dev_dbg(dev
, state
, "");
671 error
= pm_op(dev
, dev
->bus
->pm
, state
);
672 } else if (dev
->bus
->suspend
) {
673 pm_dev_dbg(dev
, state
, "legacy ");
674 error
= dev
->bus
->suspend(dev
, state
);
675 suspend_report_result(dev
->bus
->suspend
, error
);
685 * dpm_suspend - Suspend every device.
686 * @state: PM transition of the system being carried out.
688 * Execute the appropriate "suspend" callbacks for all devices.
690 static int dpm_suspend(pm_message_t state
)
692 struct list_head list
;
695 INIT_LIST_HEAD(&list
);
696 mutex_lock(&dpm_list_mtx
);
697 while (!list_empty(&dpm_list
)) {
698 struct device
*dev
= to_device(dpm_list
.prev
);
701 mutex_unlock(&dpm_list_mtx
);
703 error
= suspend_device(dev
, state
);
705 mutex_lock(&dpm_list_mtx
);
707 pm_dev_err(dev
, state
, "", error
);
711 dev
->power
.status
= DPM_OFF
;
712 if (!list_empty(&dev
->power
.entry
))
713 list_move(&dev
->power
.entry
, &list
);
716 list_splice(&list
, dpm_list
.prev
);
717 mutex_unlock(&dpm_list_mtx
);
722 * prepare_device - Execute the ->prepare() callback(s) for given device.
724 * @state: PM transition of the system being carried out.
726 static int prepare_device(struct device
*dev
, pm_message_t state
)
732 if (dev
->bus
&& dev
->bus
->pm
&& dev
->bus
->pm
->prepare
) {
733 pm_dev_dbg(dev
, state
, "preparing ");
734 error
= dev
->bus
->pm
->prepare(dev
);
735 suspend_report_result(dev
->bus
->pm
->prepare
, error
);
740 if (dev
->type
&& dev
->type
->pm
&& dev
->type
->pm
->prepare
) {
741 pm_dev_dbg(dev
, state
, "preparing type ");
742 error
= dev
->type
->pm
->prepare(dev
);
743 suspend_report_result(dev
->type
->pm
->prepare
, error
);
748 if (dev
->class && dev
->class->pm
&& dev
->class->pm
->prepare
) {
749 pm_dev_dbg(dev
, state
, "preparing class ");
750 error
= dev
->class->pm
->prepare(dev
);
751 suspend_report_result(dev
->class->pm
->prepare
, error
);
760 * dpm_prepare - Prepare all devices for a PM transition.
761 * @state: PM transition of the system being carried out.
763 * Execute the ->prepare() callback for all devices.
765 static int dpm_prepare(pm_message_t state
)
767 struct list_head list
;
770 INIT_LIST_HEAD(&list
);
771 mutex_lock(&dpm_list_mtx
);
772 transition_started
= true;
773 while (!list_empty(&dpm_list
)) {
774 struct device
*dev
= to_device(dpm_list
.next
);
777 dev
->power
.status
= DPM_PREPARING
;
778 mutex_unlock(&dpm_list_mtx
);
780 error
= prepare_device(dev
, state
);
782 mutex_lock(&dpm_list_mtx
);
784 dev
->power
.status
= DPM_ON
;
785 if (error
== -EAGAIN
) {
789 printk(KERN_ERR
"PM: Failed to prepare device %s "
790 "for power transition: error %d\n",
791 kobject_name(&dev
->kobj
), error
);
795 dev
->power
.status
= DPM_SUSPENDING
;
796 if (!list_empty(&dev
->power
.entry
))
797 list_move_tail(&dev
->power
.entry
, &list
);
800 list_splice(&list
, &dpm_list
);
801 mutex_unlock(&dpm_list_mtx
);
806 * device_suspend - Save state and stop all devices in system.
807 * @state: PM transition of the system being carried out.
809 * Prepare and suspend all devices.
811 int device_suspend(pm_message_t state
)
816 error
= dpm_prepare(state
);
818 error
= dpm_suspend(state
);
821 EXPORT_SYMBOL_GPL(device_suspend
);
823 void __suspend_report_result(const char *function
, void *fn
, int ret
)
826 printk(KERN_ERR
"%s(): %pF returns %d\n", function
, fn
, ret
);
828 EXPORT_SYMBOL_GPL(__suspend_report_result
);
This page took 0.067077 seconds and 6 git commands to generate.