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/export.h>
25 #include <linux/suspend.h>
26 #include <linux/syscore_ops.h>
27 #include <linux/ftrace.h>
28 #include <trace/events/power.h>
29
30 #include "power.h"
31
32 const char *const pm_states[PM_SUSPEND_MAX] = {
33 [PM_SUSPEND_STANDBY] = "standby",
34 [PM_SUSPEND_MEM] = "mem",
35 };
36
37 static const struct platform_suspend_ops *suspend_ops;
38
39 /**
40 * suspend_set_ops - Set the global suspend method table.
41 * @ops: Suspend operations to use.
42 */
suspend_set_ops(const struct platform_suspend_ops * ops)43 void suspend_set_ops(const struct platform_suspend_ops *ops)
44 {
45 lock_system_sleep();
46 suspend_ops = ops;
47 unlock_system_sleep();
48 }
49 EXPORT_SYMBOL_GPL(suspend_set_ops);
50
valid_state(suspend_state_t state)51 bool valid_state(suspend_state_t state)
52 {
53 /*
54 * All states need lowlevel support and need to be valid to the lowlevel
55 * implementation, no valid callback implies that none are valid.
56 */
57 return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
58 }
59
60 /**
61 * suspend_valid_only_mem - Generic memory-only valid callback.
62 *
63 * Platform drivers that implement mem suspend only and only need to check for
64 * that in their .valid() callback can use this instead of rolling their own
65 * .valid() callback.
66 */
suspend_valid_only_mem(suspend_state_t state)67 int suspend_valid_only_mem(suspend_state_t state)
68 {
69 return state == PM_SUSPEND_MEM;
70 }
71 EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
72
suspend_test(int level)73 static int suspend_test(int level)
74 {
75 #ifdef CONFIG_PM_DEBUG
76 if (pm_test_level == level) {
77 printk(KERN_INFO "suspend debug: Waiting for 5 seconds.\n");
78 mdelay(5000);
79 return 1;
80 }
81 #endif /* !CONFIG_PM_DEBUG */
82 return 0;
83 }
84
85 /**
86 * suspend_prepare - Prepare for entering system sleep state.
87 *
88 * Common code run for every system sleep state that can be entered (except for
89 * hibernation). Run suspend notifiers, allocate the "suspend" console and
90 * freeze processes.
91 */
suspend_prepare(void)92 static int suspend_prepare(void)
93 {
94 int error;
95
96 if (!suspend_ops || !suspend_ops->enter)
97 return -EPERM;
98
99 pm_prepare_console();
100
101 error = pm_notifier_call_chain(PM_SUSPEND_PREPARE);
102 if (error)
103 goto Finish;
104
105 error = suspend_freeze_processes();
106 if (!error)
107 return 0;
108
109 suspend_stats.failed_freeze++;
110 dpm_save_failed_step(SUSPEND_FREEZE);
111 Finish:
112 pm_notifier_call_chain(PM_POST_SUSPEND);
113 pm_restore_console();
114 return error;
115 }
116
117 /* default implementation */
arch_suspend_disable_irqs(void)118 void __attribute__ ((weak)) arch_suspend_disable_irqs(void)
119 {
120 local_irq_disable();
121 }
122
123 /* default implementation */
arch_suspend_enable_irqs(void)124 void __attribute__ ((weak)) arch_suspend_enable_irqs(void)
125 {
126 local_irq_enable();
127 }
128
129 /**
130 * suspend_enter - Make the system enter the given sleep state.
131 * @state: System sleep state to enter.
132 * @wakeup: Returns information that the sleep state should not be re-entered.
133 *
134 * This function should be called after devices have been suspended.
135 */
suspend_enter(suspend_state_t state,bool * wakeup)136 static int suspend_enter(suspend_state_t state, bool *wakeup)
137 {
138 int error;
139
140 if (suspend_ops->prepare) {
141 error = suspend_ops->prepare();
142 if (error)
143 goto Platform_finish;
144 }
145
146 error = dpm_suspend_end(PMSG_SUSPEND);
147 if (error) {
148 printk(KERN_ERR "PM: Some devices failed to power down\n");
149 goto Platform_finish;
150 }
151
152 if (suspend_ops->prepare_late) {
153 error = suspend_ops->prepare_late();
154 if (error)
155 goto Platform_wake;
156 }
157
158 if (suspend_test(TEST_PLATFORM))
159 goto Platform_wake;
160
161 error = disable_nonboot_cpus();
162 if (error || suspend_test(TEST_CPUS))
163 goto Enable_cpus;
164
165 arch_suspend_disable_irqs();
166 BUG_ON(!irqs_disabled());
167
168 error = syscore_suspend();
169 if (!error) {
170 *wakeup = pm_wakeup_pending();
171 if (!(suspend_test(TEST_CORE) || *wakeup)) {
172 error = suspend_ops->enter(state);
173 events_check_enabled = false;
174 }
175 syscore_resume();
176 }
177
178 arch_suspend_enable_irqs();
179 BUG_ON(irqs_disabled());
180
181 Enable_cpus:
182 enable_nonboot_cpus();
183
184 Platform_wake:
185 if (suspend_ops->wake)
186 suspend_ops->wake();
187
188 dpm_resume_start(PMSG_RESUME);
189
190 Platform_finish:
191 if (suspend_ops->finish)
192 suspend_ops->finish();
193
194 return error;
195 }
196
197 /**
198 * suspend_devices_and_enter - Suspend devices and enter system sleep state.
199 * @state: System sleep state to enter.
200 */
suspend_devices_and_enter(suspend_state_t state)201 int suspend_devices_and_enter(suspend_state_t state)
202 {
203 int error;
204 bool wakeup = false;
205
206 if (!suspend_ops)
207 return -ENOSYS;
208
209 trace_machine_suspend(state);
210 if (suspend_ops->begin) {
211 error = suspend_ops->begin(state);
212 if (error)
213 goto Close;
214 }
215 suspend_console();
216 ftrace_stop();
217 suspend_test_start();
218 error = dpm_suspend_start(PMSG_SUSPEND);
219 if (error) {
220 printk(KERN_ERR "PM: Some devices failed to suspend\n");
221 goto Recover_platform;
222 }
223 suspend_test_finish("suspend devices");
224 if (suspend_test(TEST_DEVICES))
225 goto Recover_platform;
226
227 do {
228 error = suspend_enter(state, &wakeup);
229 } while (!error && !wakeup
230 && suspend_ops->suspend_again && suspend_ops->suspend_again());
231
232 Resume_devices:
233 suspend_test_start();
234 dpm_resume_end(PMSG_RESUME);
235 suspend_test_finish("resume devices");
236 ftrace_start();
237 resume_console();
238 Close:
239 if (suspend_ops->end)
240 suspend_ops->end();
241 trace_machine_suspend(PWR_EVENT_EXIT);
242 return error;
243
244 Recover_platform:
245 if (suspend_ops->recover)
246 suspend_ops->recover();
247 goto Resume_devices;
248 }
249
250 /**
251 * suspend_finish - Clean up before finishing the suspend sequence.
252 *
253 * Call platform code to clean up, restart processes, and free the console that
254 * we've allocated. This routine is not called for hibernation.
255 */
suspend_finish(void)256 static void suspend_finish(void)
257 {
258 suspend_thaw_processes();
259 pm_notifier_call_chain(PM_POST_SUSPEND);
260 pm_restore_console();
261 }
262
263 /**
264 * enter_state - Do common work needed to enter system sleep state.
265 * @state: System sleep state to enter.
266 *
267 * Make sure that no one else is trying to put the system into a sleep state.
268 * Fail if that's not the case. Otherwise, prepare for system suspend, make the
269 * system enter the given sleep state and clean up after wakeup.
270 */
enter_state(suspend_state_t state)271 static int enter_state(suspend_state_t state)
272 {
273 int error;
274
275 if (!valid_state(state))
276 return -ENODEV;
277
278 if (!mutex_trylock(&pm_mutex))
279 return -EBUSY;
280
281 printk(KERN_INFO "PM: Syncing filesystems ... ");
282 sys_sync();
283 printk("done.\n");
284
285 pr_debug("PM: Preparing system for %s sleep\n", pm_states[state]);
286 error = suspend_prepare();
287 if (error)
288 goto Unlock;
289
290 if (suspend_test(TEST_FREEZER))
291 goto Finish;
292
293 pr_debug("PM: Entering %s sleep\n", pm_states[state]);
294 pm_restrict_gfp_mask();
295 error = suspend_devices_and_enter(state);
296 pm_restore_gfp_mask();
297
298 Finish:
299 pr_debug("PM: Finishing wakeup.\n");
300 suspend_finish();
301 Unlock:
302 mutex_unlock(&pm_mutex);
303 return error;
304 }
305
306 /**
307 * pm_suspend - Externally visible function for suspending the system.
308 * @state: System sleep state to enter.
309 *
310 * Check if the value of @state represents one of the supported states,
311 * execute enter_state() and update system suspend statistics.
312 */
pm_suspend(suspend_state_t state)313 int pm_suspend(suspend_state_t state)
314 {
315 int error;
316
317 if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
318 return -EINVAL;
319
320 error = enter_state(state);
321 if (error) {
322 suspend_stats.fail++;
323 dpm_save_failed_errno(error);
324 } else {
325 suspend_stats.success++;
326 }
327 return error;
328 }
329 EXPORT_SYMBOL(pm_suspend);
330