1
2
3
4
5
6
7
8
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/cpuidle.h>
18#include <linux/syscalls.h>
19#include <linux/gfp.h>
20#include <linux/io.h>
21#include <linux/kernel.h>
22#include <linux/list.h>
23#include <linux/mm.h>
24#include <linux/slab.h>
25#include <linux/export.h>
26#include <linux/suspend.h>
27#include <linux/syscore_ops.h>
28#include <linux/ftrace.h>
29#include <trace/events/power.h>
30#include <linux/compiler.h>
31#include <linux/moduleparam.h>
32
33#include "power.h"
34
35const char *pm_labels[] = { "mem", "standby", "freeze", NULL };
36const char *pm_states[PM_SUSPEND_MAX];
37
38unsigned int pm_suspend_global_flags;
39EXPORT_SYMBOL_GPL(pm_suspend_global_flags);
40
41static const struct platform_suspend_ops *suspend_ops;
42static const struct platform_freeze_ops *freeze_ops;
43static DECLARE_WAIT_QUEUE_HEAD(suspend_freeze_wait_head);
44
45enum freeze_state __read_mostly suspend_freeze_state;
46static DEFINE_SPINLOCK(suspend_freeze_lock);
47
48void freeze_set_ops(const struct platform_freeze_ops *ops)
49{
50 lock_system_sleep();
51 freeze_ops = ops;
52 unlock_system_sleep();
53}
54
55static void freeze_begin(void)
56{
57 suspend_freeze_state = FREEZE_STATE_NONE;
58}
59
60static void freeze_enter(void)
61{
62 spin_lock_irq(&suspend_freeze_lock);
63 if (pm_wakeup_pending())
64 goto out;
65
66 suspend_freeze_state = FREEZE_STATE_ENTER;
67 spin_unlock_irq(&suspend_freeze_lock);
68
69 get_online_cpus();
70 cpuidle_resume();
71
72
73 wake_up_all_idle_cpus();
74 pr_debug("PM: suspend-to-idle\n");
75
76 wait_event(suspend_freeze_wait_head,
77 suspend_freeze_state == FREEZE_STATE_WAKE);
78 pr_debug("PM: resume from suspend-to-idle\n");
79
80 cpuidle_pause();
81 put_online_cpus();
82
83 spin_lock_irq(&suspend_freeze_lock);
84
85 out:
86 suspend_freeze_state = FREEZE_STATE_NONE;
87 spin_unlock_irq(&suspend_freeze_lock);
88}
89
90void freeze_wake(void)
91{
92 unsigned long flags;
93
94 spin_lock_irqsave(&suspend_freeze_lock, flags);
95 if (suspend_freeze_state > FREEZE_STATE_NONE) {
96 suspend_freeze_state = FREEZE_STATE_WAKE;
97 wake_up(&suspend_freeze_wait_head);
98 }
99 spin_unlock_irqrestore(&suspend_freeze_lock, flags);
100}
101EXPORT_SYMBOL_GPL(freeze_wake);
102
103static bool valid_state(suspend_state_t state)
104{
105
106
107
108
109
110 return suspend_ops && suspend_ops->valid && suspend_ops->valid(state);
111}
112
113
114
115
116
117
118
119static bool relative_states;
120
121void __init pm_states_init(void)
122{
123
124
125
126
127 pm_states[PM_SUSPEND_FREEZE] = pm_labels[relative_states ? 0 : 2];
128}
129
130static int __init sleep_states_setup(char *str)
131{
132 relative_states = !strncmp(str, "1", 1);
133 return 1;
134}
135
136__setup("relative_sleep_states=", sleep_states_setup);
137
138
139
140
141
142void suspend_set_ops(const struct platform_suspend_ops *ops)
143{
144 suspend_state_t i;
145 int j = 0;
146
147 lock_system_sleep();
148
149 suspend_ops = ops;
150 for (i = PM_SUSPEND_MEM; i >= PM_SUSPEND_STANDBY; i--)
151 if (valid_state(i)) {
152 pm_states[i] = pm_labels[j++];
153 } else if (!relative_states) {
154 pm_states[i] = NULL;
155 j++;
156 }
157
158 pm_states[PM_SUSPEND_FREEZE] = pm_labels[j];
159
160 unlock_system_sleep();
161}
162EXPORT_SYMBOL_GPL(suspend_set_ops);
163
164
165
166
167
168
169
170
171int suspend_valid_only_mem(suspend_state_t state)
172{
173 return state == PM_SUSPEND_MEM;
174}
175EXPORT_SYMBOL_GPL(suspend_valid_only_mem);
176
177static bool sleep_state_supported(suspend_state_t state)
178{
179 return state == PM_SUSPEND_FREEZE || (suspend_ops && suspend_ops->enter);
180}
181
182static int platform_suspend_prepare(suspend_state_t state)
183{
184 return state != PM_SUSPEND_FREEZE && suspend_ops->prepare ?
185 suspend_ops->prepare() : 0;
186}
187
188static int platform_suspend_prepare_late(suspend_state_t state)
189{
190 return state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->prepare ?
191 freeze_ops->prepare() : 0;
192}
193
194static int platform_suspend_prepare_noirq(suspend_state_t state)
195{
196 return state != PM_SUSPEND_FREEZE && suspend_ops->prepare_late ?
197 suspend_ops->prepare_late() : 0;
198}
199
200static void platform_resume_noirq(suspend_state_t state)
201{
202 if (state != PM_SUSPEND_FREEZE && suspend_ops->wake)
203 suspend_ops->wake();
204}
205
206static void platform_resume_early(suspend_state_t state)
207{
208 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->restore)
209 freeze_ops->restore();
210}
211
212static void platform_resume_finish(suspend_state_t state)
213{
214 if (state != PM_SUSPEND_FREEZE && suspend_ops->finish)
215 suspend_ops->finish();
216}
217
218static int platform_suspend_begin(suspend_state_t state)
219{
220 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->begin)
221 return freeze_ops->begin();
222 else if (suspend_ops && suspend_ops->begin)
223 return suspend_ops->begin(state);
224 else
225 return 0;
226}
227
228static void platform_resume_end(suspend_state_t state)
229{
230 if (state == PM_SUSPEND_FREEZE && freeze_ops && freeze_ops->end)
231 freeze_ops->end();
232 else if (suspend_ops && suspend_ops->end)
233 suspend_ops->end();
234}
235
236static void platform_recover(suspend_state_t state)
237{
238 if (state != PM_SUSPEND_FREEZE && suspend_ops->recover)
239 suspend_ops->recover();
240}
241
242static bool platform_suspend_again(suspend_state_t state)
243{
244 return state != PM_SUSPEND_FREEZE && suspend_ops->suspend_again ?
245 suspend_ops->suspend_again() : false;
246}
247
248#ifdef CONFIG_PM_DEBUG
249static unsigned int pm_test_delay = 5;
250module_param(pm_test_delay, uint, 0644);
251MODULE_PARM_DESC(pm_test_delay,
252 "Number of seconds to wait before resuming from suspend test");
253#endif
254
255static int suspend_test(int level)
256{
257#ifdef CONFIG_PM_DEBUG
258 if (pm_test_level == level) {
259 pr_info("suspend debug: Waiting for %d second(s).\n",
260 pm_test_delay);
261 mdelay(pm_test_delay * 1000);
262 return 1;
263 }
264#endif
265 return 0;
266}
267
268
269
270
271
272
273
274
275static int suspend_prepare(suspend_state_t state)
276{
277 int error, nr_calls = 0;
278
279 if (!sleep_state_supported(state))
280 return -EPERM;
281
282 pm_prepare_console();
283
284 error = __pm_notifier_call_chain(PM_SUSPEND_PREPARE, -1, &nr_calls);
285 if (error) {
286 nr_calls--;
287 goto Finish;
288 }
289
290 trace_suspend_resume(TPS("freeze_processes"), 0, true);
291 error = suspend_freeze_processes();
292 trace_suspend_resume(TPS("freeze_processes"), 0, false);
293 if (!error)
294 return 0;
295
296 suspend_stats.failed_freeze++;
297 dpm_save_failed_step(SUSPEND_FREEZE);
298 Finish:
299 __pm_notifier_call_chain(PM_POST_SUSPEND, nr_calls, NULL);
300 pm_restore_console();
301 return error;
302}
303
304
305void __weak arch_suspend_disable_irqs(void)
306{
307 local_irq_disable();
308}
309
310
311void __weak arch_suspend_enable_irqs(void)
312{
313 local_irq_enable();
314}
315
316
317
318
319
320
321
322
323static int suspend_enter(suspend_state_t state, bool *wakeup)
324{
325 int error;
326
327 error = platform_suspend_prepare(state);
328 if (error)
329 goto Platform_finish;
330
331 error = dpm_suspend_late(PMSG_SUSPEND);
332 if (error) {
333 pr_err("PM: late suspend of devices failed\n");
334 goto Platform_finish;
335 }
336 error = platform_suspend_prepare_late(state);
337 if (error)
338 goto Devices_early_resume;
339
340 error = dpm_suspend_noirq(PMSG_SUSPEND);
341 if (error) {
342 pr_err("PM: noirq suspend of devices failed\n");
343 goto Platform_early_resume;
344 }
345 error = platform_suspend_prepare_noirq(state);
346 if (error)
347 goto Platform_wake;
348
349 if (suspend_test(TEST_PLATFORM))
350 goto Platform_wake;
351
352
353
354
355
356
357
358 if (state == PM_SUSPEND_FREEZE) {
359 trace_suspend_resume(TPS("machine_suspend"), state, true);
360 freeze_enter();
361 trace_suspend_resume(TPS("machine_suspend"), state, false);
362 goto Platform_wake;
363 }
364
365 error = disable_nonboot_cpus();
366 if (error || suspend_test(TEST_CPUS))
367 goto Enable_cpus;
368
369 arch_suspend_disable_irqs();
370 BUG_ON(!irqs_disabled());
371
372 error = syscore_suspend();
373 if (!error) {
374 *wakeup = pm_wakeup_pending();
375 if (!(suspend_test(TEST_CORE) || *wakeup)) {
376 trace_suspend_resume(TPS("machine_suspend"),
377 state, true);
378 error = suspend_ops->enter(state);
379 trace_suspend_resume(TPS("machine_suspend"),
380 state, false);
381 events_check_enabled = false;
382 } else if (*wakeup) {
383 error = -EBUSY;
384 }
385 syscore_resume();
386 }
387
388 arch_suspend_enable_irqs();
389 BUG_ON(irqs_disabled());
390
391 Enable_cpus:
392 enable_nonboot_cpus();
393
394 Platform_wake:
395 platform_resume_noirq(state);
396 dpm_resume_noirq(PMSG_RESUME);
397
398 Platform_early_resume:
399 platform_resume_early(state);
400
401 Devices_early_resume:
402 dpm_resume_early(PMSG_RESUME);
403
404 Platform_finish:
405 platform_resume_finish(state);
406 return error;
407}
408
409
410
411
412
413int suspend_devices_and_enter(suspend_state_t state)
414{
415 int error;
416 bool wakeup = false;
417
418 if (!sleep_state_supported(state))
419 return -ENOSYS;
420
421 error = platform_suspend_begin(state);
422 if (error)
423 goto Close;
424
425 suspend_console();
426 suspend_test_start();
427 error = dpm_suspend_start(PMSG_SUSPEND);
428 if (error) {
429 pr_err("PM: Some devices failed to suspend, or early wake event detected\n");
430 goto Recover_platform;
431 }
432 suspend_test_finish("suspend devices");
433 if (suspend_test(TEST_DEVICES))
434 goto Recover_platform;
435
436 do {
437 error = suspend_enter(state, &wakeup);
438 } while (!error && !wakeup && platform_suspend_again(state));
439
440 Resume_devices:
441 suspend_test_start();
442 dpm_resume_end(PMSG_RESUME);
443 suspend_test_finish("resume devices");
444 trace_suspend_resume(TPS("resume_console"), state, true);
445 resume_console();
446 trace_suspend_resume(TPS("resume_console"), state, false);
447
448 Close:
449 platform_resume_end(state);
450 return error;
451
452 Recover_platform:
453 platform_recover(state);
454 goto Resume_devices;
455}
456
457
458
459
460
461
462
463static void suspend_finish(void)
464{
465 suspend_thaw_processes();
466 pm_notifier_call_chain(PM_POST_SUSPEND);
467 pm_restore_console();
468}
469
470
471
472
473
474
475
476
477
478static int enter_state(suspend_state_t state)
479{
480 int error;
481
482 trace_suspend_resume(TPS("suspend_enter"), state, true);
483 if (state == PM_SUSPEND_FREEZE) {
484#ifdef CONFIG_PM_DEBUG
485 if (pm_test_level != TEST_NONE && pm_test_level <= TEST_CPUS) {
486 pr_warn("PM: Unsupported test mode for suspend to idle, please choose none/freezer/devices/platform.\n");
487 return -EAGAIN;
488 }
489#endif
490 } else if (!valid_state(state)) {
491 return -EINVAL;
492 }
493 if (!mutex_trylock(&pm_mutex))
494 return -EBUSY;
495
496 if (state == PM_SUSPEND_FREEZE)
497 freeze_begin();
498
499#ifndef CONFIG_SUSPEND_SKIP_SYNC
500 trace_suspend_resume(TPS("sync_filesystems"), 0, true);
501 pr_info("PM: Syncing filesystems ... ");
502 sys_sync();
503 pr_cont("done.\n");
504 trace_suspend_resume(TPS("sync_filesystems"), 0, false);
505#endif
506
507 pr_debug("PM: Preparing system for sleep (%s)\n", pm_states[state]);
508 pm_suspend_clear_flags();
509 error = suspend_prepare(state);
510 if (error)
511 goto Unlock;
512
513 if (suspend_test(TEST_FREEZER))
514 goto Finish;
515
516 trace_suspend_resume(TPS("suspend_enter"), state, false);
517 pr_debug("PM: Suspending system (%s)\n", pm_states[state]);
518 pm_restrict_gfp_mask();
519 error = suspend_devices_and_enter(state);
520 pm_restore_gfp_mask();
521
522 Finish:
523 pr_debug("PM: Finishing wakeup.\n");
524 suspend_finish();
525 Unlock:
526 mutex_unlock(&pm_mutex);
527 return error;
528}
529
530
531
532
533
534
535
536
537int pm_suspend(suspend_state_t state)
538{
539 int error;
540
541 if (state <= PM_SUSPEND_ON || state >= PM_SUSPEND_MAX)
542 return -EINVAL;
543
544 error = enter_state(state);
545 if (error) {
546 suspend_stats.fail++;
547 dpm_save_failed_errno(error);
548 } else {
549 suspend_stats.success++;
550 }
551 return error;
552}
553EXPORT_SYMBOL(pm_suspend);
554