]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - kernel/power/suspend.c
7335952ee473956e6a1e7b57f3d397220e6c5536
[~shefty/rdma-dev.git] / kernel / power / suspend.c
1 /*
2  * kernel/power/suspend.c - Suspend to RAM and standby functionality.
3  *
4  * Copyright (c) 2003 Patrick Mochel
5  * Copyright (c) 2003 Open Source Development Lab
6  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
7  *
8  * This file is released under the GPLv2.
9  */
10
11 #include <linux/string.h>
12 #include <linux/delay.h>
13 #include <linux/errno.h>
14 #include <linux/init.h>
15 #include <linux/console.h>
16 #include <linux/cpu.h>
17 #include <linux/syscalls.h>
18 #include <linux/gfp.h>
19 #include <linux/io.h>
20 #include <linux/kernel.h>
21 #include <linux/list.h>
22 #include <linux/mm.h>
23 #include <linux/slab.h>
24 #include <linux/suspend.h>
25
26 #include "power.h"
27
28 const char *const pm_states[PM_SUSPEND_MAX] = {
29         [PM_SUSPEND_STANDBY]    = "standby",
30         [PM_SUSPEND_MEM]        = "mem",
31 };
32
33 static struct platform_suspend_ops *suspend_ops;
34
35 /**
36  *      suspend_set_ops - Set the global suspend method table.
37  *      @ops:   Pointer to ops structure.
38  */
39 void suspend_set_ops(struct platform_suspend_ops *ops)
40 {
41         mutex_lock(&pm_mutex);
42         suspend_ops = ops;
43         mutex_unlock(&pm_mutex);
44 }
45
46 bool valid_state(suspend_state_t state)
47 {
48         /*
49          * All states need lowlevel support and need to be valid to the lowlevel
50          * implementation, no valid callback implies that none are valid.
51          */
52         return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
53 }
54
55 /**
56  * suspend_valid_only_mem - generic memory-only valid callback
57  *
58  * Platform drivers that implement mem suspend only and only need
59  * to check for that in their .valid callback can use this instead
60  * of rolling their own .valid callback.
61  */
62 int suspend_valid_only_mem(suspend_state_t state)
63 {
64         return state == PM_SUSPEND_MEM;
65 }
66
67 static int suspend_test(int level)
68 {
69 #ifdef CONFIG_PM_DEBUG
70         if (pm_test_level == level) {
71                 printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
72                 mdelay(5000);
73                 return 1;
74         }
75 #endif /* !CONFIG_PM_DEBUG */
76         return 0;
77 }
78
79 /**
80  *      suspend_prepare - Do prep work before entering low-power state.
81  *
82  *      This is common code that is called for each state that we're entering.
83  *      Run suspend notifiers, allocate a console and stop all processes.
84  */
85 static int suspend_prepare(void)
86 {
87         int error;
88
89         if (!suspend_ops || !suspend_ops->enter)
90                 return -EPERM;
91
92         pm_prepare_console();
93
94         error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
95         if (error)
96                 goto Finish;
97
98         error = usermodehelper_disable();
99         if (error)
100                 goto Finish;
101
102         error = suspend_freeze_processes();
103         if (!error)
104                 return 0;
105
106         suspend_thaw_processes();
107         usermodehelper_enable();
108  Finish:
109         pm_notifier_call_chain(PM_POST_SUSPEND);
110         pm_restore_console();
111         return error;
112 }
113
114 /* default implementation */
115 void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
116 {
117         local_irq_disable();
118 }
119
120 /* default implementation */
121 void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
122 {
123         local_irq_enable();
124 }
125
126 /**
127  *      suspend_enter - enter the desired system sleep state.
128  *      @state:         state to enter
129  *
130  *      This function should be called after devices have been suspended.
131  */
132 static int suspend_enter(suspend_state_t state)
133 {
134         int error;
135
136         if (suspend_ops->prepare) {
137                 error = suspend_ops->prepare();
138                 if (error)
139                         goto Platform_finish;
140         }
141
142         error = dpm_suspend_noirq(PMSG_SUSPEND);
143         if (error) {
144                 printk(KERN_ERR "PM: Some devices failed to power down\n");
145                 goto Platform_finish;
146         }
147
148         if (suspend_ops->prepare_late) {
149                 error = suspend_ops->prepare_late();
150                 if (error)
151                         goto Platform_wake;
152         }
153
154         if (suspend_test(TEST_PLATFORM))
155                 goto Platform_wake;
156
157         error = disable_nonboot_cpus();
158         if (error || suspend_test(TEST_CPUS))
159                 goto Enable_cpus;
160
161         arch_suspend_disable_irqs();
162         BUG_ON(!irqs_disabled());
163
164         error = sysdev_suspend(PMSG_SUSPEND);
165         if (!error) {
166                 if (!suspend_test(TEST_CORE) && pm_check_wakeup_events()) {
167                         error = suspend_ops->enter(state);
168                         events_check_enabled = false;
169                 }
170                 sysdev_resume();
171         }
172
173         arch_suspend_enable_irqs();
174         BUG_ON(irqs_disabled());
175
176  Enable_cpus:
177         enable_nonboot_cpus();
178
179  Platform_wake:
180         if (suspend_ops->wake)
181                 suspend_ops->wake();
182
183         dpm_resume_noirq(PMSG_RESUME);
184
185  Platform_finish:
186         if (suspend_ops->finish)
187                 suspend_ops->finish();
188
189         return error;
190 }
191
192 /**
193  *      suspend_devices_and_enter - suspend devices and enter the desired system
194  *                                  sleep state.
195  *      @state:           state to enter
196  */
197 int suspend_devices_and_enter(suspend_state_t state)
198 {
199         int error;
200         gfp_t saved_mask;
201
202         if (!suspend_ops)
203                 return -ENOSYS;
204
205         if (suspend_ops->begin) {
206                 error = suspend_ops->begin(state);
207                 if (error)
208                         goto Close;
209         }
210         suspend_console();
211         saved_mask = clear_gfp_allowed_mask(GFP_IOFS);
212         suspend_test_start();
213         error = dpm_suspend_start(PMSG_SUSPEND);
214         if (error) {
215                 printk(KERN_ERR "PM: Some devices failed to suspend\n");
216                 goto Recover_platform;
217         }
218         suspend_test_finish("suspend devices");
219         if (suspend_test(TEST_DEVICES))
220                 goto Recover_platform;
221
222         suspend_enter(state);
223
224  Resume_devices:
225         suspend_test_start();
226         dpm_resume_end(PMSG_RESUME);
227         suspend_test_finish("resume devices");
228         set_gfp_allowed_mask(saved_mask);
229         resume_console();
230  Close:
231         if (suspend_ops->end)
232                 suspend_ops->end();
233         return error;
234
235  Recover_platform:
236         if (suspend_ops->recover)
237                 suspend_ops->recover();
238         goto Resume_devices;
239 }
240
241 /**
242  *      suspend_finish - Do final work before exiting suspend sequence.
243  *
244  *      Call platform code to clean up, restart processes, and free the
245  *      console that we've allocated. This is not called for suspend-to-disk.
246  */
247 static void suspend_finish(void)
248 {
249         suspend_thaw_processes();
250         usermodehelper_enable();
251         pm_notifier_call_chain(PM_POST_SUSPEND);
252         pm_restore_console();
253 }
254
255 /**
256  *      enter_state - Do common work of entering low-power state.
257  *      @state:         pm_state structure for state we're entering.
258  *
259  *      Make sure we're the only ones trying to enter a sleep state. Fail
260  *      if someone has beat us to it, since we don't want anything weird to
261  *      happen when we wake up.
262  *      Then, do the setup for suspend, enter the state, and cleaup (after
263  *      we've woken up).
264  */
265 int enter_state(suspend_state_t state)
266 {
267         int error;
268
269         if (!valid_state(state))
270                 return -ENODEV;
271
272         if (!mutex_trylock(&pm_mutex))
273                 return -EBUSY;
274
275         printk(KERN_INFO "PM: Syncing filesystems ... ");
276         sys_sync();
277         printk("done.\n");
278
279         pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
280         error = suspend_prepare();
281         if (error)
282                 goto Unlock;
283
284         if (suspend_test(TEST_FREEZER))
285                 goto Finish;
286
287         pr_debug("PM: Entering %s sleep\n", pm_states[state]);
288         error = suspend_devices_and_enter(state);
289
290  Finish:
291         pr_debug("PM: Finishing wakeup.\n");
292         suspend_finish();
293  Unlock:
294         mutex_unlock(&pm_mutex);
295         return error;
296 }
297
298 /**
299  *      pm_suspend - Externally visible function for suspending system.
300  *      @state:         Enumerated value of state to enter.
301  *
302  *      Determine whether or not value is within range, get state
303  *      structure, and enter (above).
304  */
305 int pm_suspend(suspend_state_t state)
306 {
307         if (state > PM_SUSPEND_ON && state <= PM_SUSPEND_MAX)
308                 return enter_state(state);
309         return -EINVAL;
310 }
311 EXPORT_SYMBOL(pm_suspend);