2 * suspend.c - Functions for putting devices to sleep.
4 * Copyright (c) 2003 Patrick Mochel
5 * Copyright (c) 2003 Open Source Development Labs
7 * This file is released under the GPLv2
11 #include <linux/device.h>
14 extern int sysdev_suspend(u32 state);
17 * The entries in the dpm_active list are in a depth first order, simply
18 * because children are guaranteed to be discovered after parents, and
19 * are inserted at the back of the list on discovery.
21 * All list on the suspend path are done in reverse order, so we operate
22 * on the leaves of the device tree (or forests, depending on how you want
23 * to look at it ;) first. As nodes are removed from the back of the list,
24 * they are inserted into the front of their destintation lists.
26 * Things are the reverse on the resume path - iterations are done in
27 * forward order, and nodes are inserted at the back of their destination
28 * lists. This way, the ancestors will be accessed before their descendents.
33 * suspend_device - Save state of one device.
35 * @state: Power state device is entering.
38 int suspend_device(struct device * dev, u32 state)
42 dev_dbg(dev, "suspending\n");
44 dev->power.prev_state = dev->power.power_state;
46 if (dev->bus && dev->bus->suspend && !dev->power.power_state)
47 error = dev->bus->suspend(dev,state);
54 * device_suspend - Save state and stop all devices in system.
55 * @state: Power state to put each device in.
57 * Walk the dpm_active list, call ->suspend() for each device, and move
59 * Check the return value for each. If it returns 0, then we move the
60 * the device to the dpm_off list. If it returns -EAGAIN, we move it to
61 * the dpm_off_irq list. If we get a different error, try and back out.
63 * If we hit a failure with any of the devices, call device_resume()
64 * above to bring the suspended devices back to life.
66 * Note this function leaves dpm_sem held to
67 * a) block other devices from registering.
68 * b) prevent other PM operations from happening after we've begun.
69 * c) make sure we're exclusive when we disable interrupts.
73 int device_suspend(u32 state)
78 while(!list_empty(&dpm_active)) {
79 struct list_head * entry = dpm_active.prev;
80 struct device * dev = to_device(entry);
81 error = suspend_device(dev,state);
84 list_del(&dev->power.entry);
85 list_add(&dev->power.entry,&dpm_off);
86 } else if (error == -EAGAIN) {
87 list_del(&dev->power.entry);
88 list_add(&dev->power.entry,&dpm_off_irq);
90 printk(KERN_ERR "Could not suspend device %s: "
91 "error %d\n", kobject_name(&dev->kobj), error);
103 EXPORT_SYMBOL(device_suspend);
107 * device_power_down - Shut down special devices.
108 * @state: Power state to enter.
110 * Walk the dpm_off_irq list, calling ->power_down() for each device that
111 * couldn't power down the device with interrupts enabled. When we're
112 * done, power down system devices.
115 int device_power_down(u32 state)
120 list_for_each_entry_reverse(dev,&dpm_off_irq,power.entry) {
121 if ((error = suspend_device(dev,state)))
126 if ((error = sysdev_suspend(state)))
135 EXPORT_SYMBOL(device_power_down);