1#ifndef _LINUX_SUSPEND_H
2#define _LINUX_SUSPEND_H
3
4#include <linux/swap.h>
5#include <linux/notifier.h>
6#include <linux/init.h>
7#include <linux/pm.h>
8#include <linux/mm.h>
9#include <linux/freezer.h>
10#include <asm/errno.h>
11
12#ifdef CONFIG_VT
13extern void pm_set_vt_switch(int);
14#else
15static inline void pm_set_vt_switch(int do_switch)
16{
17}
18#endif
19
20#ifdef CONFIG_VT_CONSOLE_SLEEP
21extern void pm_prepare_console(void);
22extern void pm_restore_console(void);
23#else
24static inline void pm_prepare_console(void)
25{
26}
27
28static inline void pm_restore_console(void)
29{
30}
31#endif
32
33typedef int __bitwise suspend_state_t;
34
35#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
36#define PM_SUSPEND_FREEZE ((__force suspend_state_t) 1)
37#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
38#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
39#define PM_SUSPEND_MIN PM_SUSPEND_FREEZE
40#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
41
42enum suspend_stat_step {
43 SUSPEND_FREEZE = 1,
44 SUSPEND_PREPARE,
45 SUSPEND_SUSPEND,
46 SUSPEND_SUSPEND_LATE,
47 SUSPEND_SUSPEND_NOIRQ,
48 SUSPEND_RESUME_NOIRQ,
49 SUSPEND_RESUME_EARLY,
50 SUSPEND_RESUME
51};
52
53struct suspend_stats {
54 int success;
55 int fail;
56 int failed_freeze;
57 int failed_prepare;
58 int failed_suspend;
59 int failed_suspend_late;
60 int failed_suspend_noirq;
61 int failed_resume;
62 int failed_resume_early;
63 int failed_resume_noirq;
64#define REC_FAILED_NUM 2
65 int last_failed_dev;
66 char failed_devs[REC_FAILED_NUM][40];
67 int last_failed_errno;
68 int errno[REC_FAILED_NUM];
69 int last_failed_step;
70 enum suspend_stat_step failed_steps[REC_FAILED_NUM];
71};
72
73extern struct suspend_stats suspend_stats;
74
75static inline void dpm_save_failed_dev(const char *name)
76{
77 strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev],
78 name,
79 sizeof(suspend_stats.failed_devs[0]));
80 suspend_stats.last_failed_dev++;
81 suspend_stats.last_failed_dev %= REC_FAILED_NUM;
82}
83
84static inline void dpm_save_failed_errno(int err)
85{
86 suspend_stats.errno[suspend_stats.last_failed_errno] = err;
87 suspend_stats.last_failed_errno++;
88 suspend_stats.last_failed_errno %= REC_FAILED_NUM;
89}
90
91static inline void dpm_save_failed_step(enum suspend_stat_step step)
92{
93 suspend_stats.failed_steps[suspend_stats.last_failed_step] = step;
94 suspend_stats.last_failed_step++;
95 suspend_stats.last_failed_step %= REC_FAILED_NUM;
96}
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176struct platform_suspend_ops {
177 int (*valid)(suspend_state_t state);
178 int (*begin)(suspend_state_t state);
179 int (*prepare)(void);
180 int (*prepare_late)(void);
181 int (*enter)(suspend_state_t state);
182 void (*wake)(void);
183 void (*finish)(void);
184 bool (*suspend_again)(void);
185 void (*end)(void);
186 void (*recover)(void);
187};
188
189struct platform_freeze_ops {
190 int (*begin)(void);
191 int (*prepare)(void);
192 void (*wake)(void);
193 void (*sync)(void);
194 void (*restore)(void);
195 void (*end)(void);
196};
197
198#ifdef CONFIG_SUSPEND
199
200
201
202
203extern void suspend_set_ops(const struct platform_suspend_ops *ops);
204extern int suspend_valid_only_mem(suspend_state_t state);
205
206extern unsigned int pm_suspend_global_flags;
207
208#define PM_SUSPEND_FLAG_FW_SUSPEND (1 << 0)
209#define PM_SUSPEND_FLAG_FW_RESUME (1 << 1)
210
211static inline void pm_suspend_clear_flags(void)
212{
213 pm_suspend_global_flags = 0;
214}
215
216static inline void pm_set_suspend_via_firmware(void)
217{
218 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
219}
220
221static inline void pm_set_resume_via_firmware(void)
222{
223 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
224}
225
226static inline bool pm_suspend_via_firmware(void)
227{
228 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
229}
230
231static inline bool pm_resume_via_firmware(void)
232{
233 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
234}
235
236
237enum freeze_state {
238 FREEZE_STATE_NONE,
239 FREEZE_STATE_ENTER,
240 FREEZE_STATE_WAKE,
241};
242
243extern enum freeze_state __read_mostly suspend_freeze_state;
244
245static inline bool idle_should_freeze(void)
246{
247 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER);
248}
249
250extern void __init pm_states_init(void);
251extern void freeze_set_ops(const struct platform_freeze_ops *ops);
252extern void freeze_wake(void);
253
254
255
256
257
258
259
260
261extern void arch_suspend_disable_irqs(void);
262
263
264
265
266
267
268
269
270extern void arch_suspend_enable_irqs(void);
271
272extern int pm_suspend(suspend_state_t state);
273#else
274#define suspend_valid_only_mem NULL
275
276static inline void pm_suspend_clear_flags(void) {}
277static inline void pm_set_suspend_via_firmware(void) {}
278static inline void pm_set_resume_via_firmware(void) {}
279static inline bool pm_suspend_via_firmware(void) { return false; }
280static inline bool pm_resume_via_firmware(void) { return false; }
281
282static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
283static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
284static inline bool idle_should_freeze(void) { return false; }
285static inline void __init pm_states_init(void) {}
286static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {}
287static inline void freeze_wake(void) {}
288#endif
289
290
291
292
293
294struct pbe {
295 void *address;
296 void *orig_address;
297 struct pbe *next;
298};
299
300
301extern void mark_free_pages(struct zone *zone);
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355struct platform_hibernation_ops {
356 int (*begin)(void);
357 void (*end)(void);
358 int (*pre_snapshot)(void);
359 void (*finish)(void);
360 int (*prepare)(void);
361 int (*enter)(void);
362 void (*leave)(void);
363 int (*pre_restore)(void);
364 void (*restore_cleanup)(void);
365 void (*recover)(void);
366};
367
368#ifdef CONFIG_HIBERNATION
369
370extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
371static inline void __init register_nosave_region(unsigned long b, unsigned long e)
372{
373 __register_nosave_region(b, e, 0);
374}
375static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
376{
377 __register_nosave_region(b, e, 1);
378}
379extern int swsusp_page_is_forbidden(struct page *);
380extern void swsusp_set_page_free(struct page *);
381extern void swsusp_unset_page_free(struct page *);
382extern unsigned long get_safe_page(gfp_t gfp_mask);
383
384extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
385extern int hibernate(void);
386extern bool system_entering_hibernation(void);
387extern bool hibernation_available(void);
388asmlinkage int swsusp_save(void);
389extern struct pbe *restore_pblist;
390#else
391static inline void register_nosave_region(unsigned long b, unsigned long e) {}
392static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
393static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
394static inline void swsusp_set_page_free(struct page *p) {}
395static inline void swsusp_unset_page_free(struct page *p) {}
396
397static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
398static inline int hibernate(void) { return -ENOSYS; }
399static inline bool system_entering_hibernation(void) { return false; }
400static inline bool hibernation_available(void) { return false; }
401#endif
402
403
404#define PM_HIBERNATION_PREPARE 0x0001
405#define PM_POST_HIBERNATION 0x0002
406#define PM_SUSPEND_PREPARE 0x0003
407#define PM_POST_SUSPEND 0x0004
408#define PM_RESTORE_PREPARE 0x0005
409#define PM_POST_RESTORE 0x0006
410
411extern struct mutex pm_mutex;
412
413#ifdef CONFIG_PM_SLEEP
414void save_processor_state(void);
415void restore_processor_state(void);
416
417
418extern int register_pm_notifier(struct notifier_block *nb);
419extern int unregister_pm_notifier(struct notifier_block *nb);
420
421#define pm_notifier(fn, pri) { \
422 static struct notifier_block fn##_nb = \
423 { .notifier_call = fn, .priority = pri }; \
424 register_pm_notifier(&fn##_nb); \
425}
426
427
428extern bool events_check_enabled;
429extern unsigned int pm_wakeup_irq;
430
431extern bool pm_wakeup_pending(void);
432extern void pm_system_wakeup(void);
433extern void pm_system_cancel_wakeup(void);
434extern void pm_wakeup_clear(bool reset);
435extern void pm_system_irq_wakeup(unsigned int irq_number);
436extern bool pm_get_wakeup_count(unsigned int *count, bool block);
437extern bool pm_save_wakeup_count(unsigned int count);
438extern void pm_wakep_autosleep_enabled(bool set);
439extern void pm_print_active_wakeup_sources(void);
440
441static inline void lock_system_sleep(void)
442{
443 current->flags |= PF_FREEZER_SKIP;
444 mutex_lock(&pm_mutex);
445}
446
447static inline void unlock_system_sleep(void)
448{
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464 current->flags &= ~PF_FREEZER_SKIP;
465 mutex_unlock(&pm_mutex);
466}
467
468#else
469
470static inline int register_pm_notifier(struct notifier_block *nb)
471{
472 return 0;
473}
474
475static inline int unregister_pm_notifier(struct notifier_block *nb)
476{
477 return 0;
478}
479
480#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
481
482static inline bool pm_wakeup_pending(void) { return false; }
483static inline void pm_system_wakeup(void) {}
484static inline void pm_wakeup_clear(bool reset) {}
485static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
486
487static inline void lock_system_sleep(void) {}
488static inline void unlock_system_sleep(void) {}
489
490#endif
491
492#ifdef CONFIG_PM_SLEEP_DEBUG
493extern bool pm_print_times_enabled;
494#else
495#define pm_print_times_enabled (false)
496#endif
497
498#ifdef CONFIG_PM_AUTOSLEEP
499
500
501void queue_up_suspend_work(void);
502
503#else
504
505static inline void queue_up_suspend_work(void) {}
506
507#endif
508
509#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
510
511
512
513
514
515
516
517unsigned long page_key_additional_pages(unsigned long pages);
518int page_key_alloc(unsigned long pages);
519void page_key_free(void);
520void page_key_read(unsigned long *pfn);
521void page_key_memorize(unsigned long *pfn);
522void page_key_write(void *address);
523
524#else
525
526static inline unsigned long page_key_additional_pages(unsigned long pages)
527{
528 return 0;
529}
530
531static inline int page_key_alloc(unsigned long pages)
532{
533 return 0;
534}
535
536static inline void page_key_free(void) {}
537static inline void page_key_read(unsigned long *pfn) {}
538static inline void page_key_memorize(unsigned long *pfn) {}
539static inline void page_key_write(void *address) {}
540
541#endif
542
543#endif
544