Merge branch 'release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb/linux...
[linux-2.6] / drivers / base / power / suspend.c
1 /*
2  * suspend.c - Functions for putting devices to sleep.
3  *
4  * Copyright (c) 2003 Patrick Mochel
5  * Copyright (c) 2003 Open Source Development Labs
6  *
7  * This file is released under the GPLv2
8  *
9  */
10
11 #include <linux/device.h>
12 #include <linux/kallsyms.h>
13 #include <linux/pm.h>
14 #include "../base.h"
15 #include "power.h"
16
17 /*
18  * The entries in the dpm_active list are in a depth first order, simply
19  * because children are guaranteed to be discovered after parents, and
20  * are inserted at the back of the list on discovery.
21  *
22  * All list on the suspend path are done in reverse order, so we operate
23  * on the leaves of the device tree (or forests, depending on how you want
24  * to look at it ;) first. As nodes are removed from the back of the list,
25  * they are inserted into the front of their destintation lists.
26  *
27  * Things are the reverse on the resume path - iterations are done in
28  * forward order, and nodes are inserted at the back of their destination
29  * lists. This way, the ancestors will be accessed before their descendents.
30  */
31
32 static inline char *suspend_verb(u32 event)
33 {
34         switch (event) {
35         case PM_EVENT_SUSPEND:  return "suspend";
36         case PM_EVENT_FREEZE:   return "freeze";
37         default:                return "(unknown suspend event)";
38         }
39 }
40
41
42 /**
43  *      suspend_device - Save state of one device.
44  *      @dev:   Device.
45  *      @state: Power state device is entering.
46  */
47
48 int suspend_device(struct device * dev, pm_message_t state)
49 {
50         int error = 0;
51
52         down(&dev->sem);
53         if (dev->power.power_state.event) {
54                 dev_dbg(dev, "PM: suspend %d-->%d\n",
55                         dev->power.power_state.event, state.event);
56         }
57         if (dev->power.pm_parent
58                         && dev->power.pm_parent->power.power_state.event) {
59                 dev_err(dev,
60                         "PM: suspend %d->%d, parent %s already %d\n",
61                         dev->power.power_state.event, state.event,
62                         dev->power.pm_parent->bus_id,
63                         dev->power.pm_parent->power.power_state.event);
64         }
65
66         dev->power.prev_state = dev->power.power_state;
67
68         if (dev->bus && dev->bus->suspend && !dev->power.power_state.event) {
69                 dev_dbg(dev, "%s%s\n",
70                         suspend_verb(state.event),
71                         ((state.event == PM_EVENT_SUSPEND)
72                                         && device_may_wakeup(dev))
73                                 ? ", may wakeup"
74                                 : ""
75                         );
76                 error = dev->bus->suspend(dev, state);
77                 suspend_report_result(dev->bus->suspend, error);
78         }
79         up(&dev->sem);
80         return error;
81 }
82
83
84 /**
85  *      device_suspend - Save state and stop all devices in system.
86  *      @state:         Power state to put each device in.
87  *
88  *      Walk the dpm_active list, call ->suspend() for each device, and move
89  *      it to dpm_off.
90  *      Check the return value for each. If it returns 0, then we move the
91  *      the device to the dpm_off list. If it returns -EAGAIN, we move it to
92  *      the dpm_off_irq list. If we get a different error, try and back out.
93  *
94  *      If we hit a failure with any of the devices, call device_resume()
95  *      above to bring the suspended devices back to life.
96  *
97  */
98
99 int device_suspend(pm_message_t state)
100 {
101         int error = 0;
102
103         down(&dpm_sem);
104         down(&dpm_list_sem);
105         while (!list_empty(&dpm_active) && error == 0) {
106                 struct list_head * entry = dpm_active.prev;
107                 struct device * dev = to_device(entry);
108
109                 get_device(dev);
110                 up(&dpm_list_sem);
111
112                 error = suspend_device(dev, state);
113
114                 down(&dpm_list_sem);
115
116                 /* Check if the device got removed */
117                 if (!list_empty(&dev->power.entry)) {
118                         /* Move it to the dpm_off or dpm_off_irq list */
119                         if (!error) {
120                                 list_del(&dev->power.entry);
121                                 list_add(&dev->power.entry, &dpm_off);
122                         } else if (error == -EAGAIN) {
123                                 list_del(&dev->power.entry);
124                                 list_add(&dev->power.entry, &dpm_off_irq);
125                                 error = 0;
126                         }
127                 }
128                 if (error)
129                         printk(KERN_ERR "Could not suspend device %s: "
130                                 "error %d\n", kobject_name(&dev->kobj), error);
131                 put_device(dev);
132         }
133         up(&dpm_list_sem);
134         if (error) {
135                 /* we failed... before resuming, bring back devices from
136                  * dpm_off_irq list back to main dpm_off list, we do want
137                  * to call resume() on them, in case they partially suspended
138                  * despite returning -EAGAIN
139                  */
140                 while (!list_empty(&dpm_off_irq)) {
141                         struct list_head * entry = dpm_off_irq.next;
142                         list_del(entry);
143                         list_add(entry, &dpm_off);
144                 }
145                 dpm_resume();
146         }
147         up(&dpm_sem);
148         return error;
149 }
150
151 EXPORT_SYMBOL_GPL(device_suspend);
152
153
154 /**
155  *      device_power_down - Shut down special devices.
156  *      @state:         Power state to enter.
157  *
158  *      Walk the dpm_off_irq list, calling ->power_down() for each device that
159  *      couldn't power down the device with interrupts enabled. When we're
160  *      done, power down system devices.
161  */
162
163 int device_power_down(pm_message_t state)
164 {
165         int error = 0;
166         struct device * dev;
167
168         list_for_each_entry_reverse(dev, &dpm_off_irq, power.entry) {
169                 if ((error = suspend_device(dev, state)))
170                         break;
171         }
172         if (error)
173                 goto Error;
174         if ((error = sysdev_suspend(state)))
175                 goto Error;
176  Done:
177         return error;
178  Error:
179         printk(KERN_ERR "Could not power down device %s: "
180                 "error %d\n", kobject_name(&dev->kobj), error);
181         dpm_power_up();
182         goto Done;
183 }
184
185 EXPORT_SYMBOL_GPL(device_power_down);
186
187 void __suspend_report_result(const char *function, void *fn, int ret)
188 {
189         if (ret) {
190                 printk(KERN_ERR "%s(): ", function);
191                 print_fn_descriptor_symbol("%s() returns ", (unsigned long)fn);
192                 printk("%d\n", ret);
193         }
194 }
195 EXPORT_SYMBOL_GPL(__suspend_report_result);