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 (*restore)(void);
193 void (*end)(void);
194};
195
196#ifdef CONFIG_SUSPEND
197
198
199
200
201extern void suspend_set_ops(const struct platform_suspend_ops *ops);
202extern int suspend_valid_only_mem(suspend_state_t state);
203
204extern unsigned int pm_suspend_global_flags;
205
206#define PM_SUSPEND_FLAG_FW_SUSPEND (1 << 0)
207#define PM_SUSPEND_FLAG_FW_RESUME (1 << 1)
208
209static inline void pm_suspend_clear_flags(void)
210{
211 pm_suspend_global_flags = 0;
212}
213
214static inline void pm_set_suspend_via_firmware(void)
215{
216 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
217}
218
219static inline void pm_set_resume_via_firmware(void)
220{
221 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
222}
223
224static inline bool pm_suspend_via_firmware(void)
225{
226 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
227}
228
229static inline bool pm_resume_via_firmware(void)
230{
231 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
232}
233
234
235enum freeze_state {
236 FREEZE_STATE_NONE,
237 FREEZE_STATE_ENTER,
238 FREEZE_STATE_WAKE,
239};
240
241extern enum freeze_state __read_mostly suspend_freeze_state;
242
243static inline bool idle_should_freeze(void)
244{
245 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER);
246}
247
248extern void __init pm_states_init(void);
249extern void freeze_set_ops(const struct platform_freeze_ops *ops);
250extern void freeze_wake(void);
251
252
253
254
255
256
257
258
259extern void arch_suspend_disable_irqs(void);
260
261
262
263
264
265
266
267
268extern void arch_suspend_enable_irqs(void);
269
270extern int pm_suspend(suspend_state_t state);
271#else
272#define suspend_valid_only_mem NULL
273
274static inline void pm_suspend_clear_flags(void) {}
275static inline void pm_set_suspend_via_firmware(void) {}
276static inline void pm_set_resume_via_firmware(void) {}
277static inline bool pm_suspend_via_firmware(void) { return false; }
278static inline bool pm_resume_via_firmware(void) { return false; }
279
280static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
281static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
282static inline bool idle_should_freeze(void) { return false; }
283static inline void __init pm_states_init(void) {}
284static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {}
285static inline void freeze_wake(void) {}
286#endif
287
288
289
290
291
292struct pbe {
293 void *address;
294 void *orig_address;
295 struct pbe *next;
296};
297
298
299extern void mark_free_pages(struct zone *zone);
300
301
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
353struct platform_hibernation_ops {
354 int (*begin)(void);
355 void (*end)(void);
356 int (*pre_snapshot)(void);
357 void (*finish)(void);
358 int (*prepare)(void);
359 int (*enter)(void);
360 void (*leave)(void);
361 int (*pre_restore)(void);
362 void (*restore_cleanup)(void);
363 void (*recover)(void);
364};
365
366#ifdef CONFIG_HIBERNATION
367
368extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
369static inline void __init register_nosave_region(unsigned long b, unsigned long e)
370{
371 __register_nosave_region(b, e, 0);
372}
373static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
374{
375 __register_nosave_region(b, e, 1);
376}
377extern int swsusp_page_is_forbidden(struct page *);
378extern void swsusp_set_page_free(struct page *);
379extern void swsusp_unset_page_free(struct page *);
380extern unsigned long get_safe_page(gfp_t gfp_mask);
381
382extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
383extern int hibernate(void);
384extern bool system_entering_hibernation(void);
385extern bool hibernation_available(void);
386asmlinkage int swsusp_save(void);
387extern struct pbe *restore_pblist;
388#else
389static inline void register_nosave_region(unsigned long b, unsigned long e) {}
390static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
391static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
392static inline void swsusp_set_page_free(struct page *p) {}
393static inline void swsusp_unset_page_free(struct page *p) {}
394
395static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
396static inline int hibernate(void) { return -ENOSYS; }
397static inline bool system_entering_hibernation(void) { return false; }
398static inline bool hibernation_available(void) { return false; }
399#endif
400
401
402#define PM_HIBERNATION_PREPARE 0x0001
403#define PM_POST_HIBERNATION 0x0002
404#define PM_SUSPEND_PREPARE 0x0003
405#define PM_POST_SUSPEND 0x0004
406#define PM_RESTORE_PREPARE 0x0005
407#define PM_POST_RESTORE 0x0006
408
409extern struct mutex pm_mutex;
410
411#ifdef CONFIG_PM_SLEEP
412void save_processor_state(void);
413void restore_processor_state(void);
414
415
416extern int register_pm_notifier(struct notifier_block *nb);
417extern int unregister_pm_notifier(struct notifier_block *nb);
418
419#define pm_notifier(fn, pri) { \
420 static struct notifier_block fn##_nb = \
421 { .notifier_call = fn, .priority = pri }; \
422 register_pm_notifier(&fn##_nb); \
423}
424
425
426extern bool events_check_enabled;
427extern unsigned int pm_wakeup_irq;
428
429extern bool pm_wakeup_pending(void);
430extern void pm_system_wakeup(void);
431extern void pm_wakeup_clear(void);
432extern void pm_system_irq_wakeup(unsigned int irq_number);
433extern bool pm_get_wakeup_count(unsigned int *count, bool block);
434extern bool pm_save_wakeup_count(unsigned int count);
435extern void pm_wakep_autosleep_enabled(bool set);
436extern void pm_print_active_wakeup_sources(void);
437
438static inline void lock_system_sleep(void)
439{
440 current->flags |= PF_FREEZER_SKIP;
441 mutex_lock(&pm_mutex);
442}
443
444static inline void unlock_system_sleep(void)
445{
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461 current->flags &= ~PF_FREEZER_SKIP;
462 mutex_unlock(&pm_mutex);
463}
464
465#else
466
467static inline int register_pm_notifier(struct notifier_block *nb)
468{
469 return 0;
470}
471
472static inline int unregister_pm_notifier(struct notifier_block *nb)
473{
474 return 0;
475}
476
477#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
478
479static inline bool pm_wakeup_pending(void) { return false; }
480static inline void pm_system_wakeup(void) {}
481static inline void pm_wakeup_clear(void) {}
482static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
483
484static inline void lock_system_sleep(void) {}
485static inline void unlock_system_sleep(void) {}
486
487#endif
488
489#ifdef CONFIG_PM_SLEEP_DEBUG
490extern bool pm_print_times_enabled;
491#else
492#define pm_print_times_enabled (false)
493#endif
494
495#ifdef CONFIG_PM_AUTOSLEEP
496
497
498void queue_up_suspend_work(void);
499
500#else
501
502static inline void queue_up_suspend_work(void) {}
503
504#endif
505
506#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
507
508
509
510
511
512
513
514unsigned long page_key_additional_pages(unsigned long pages);
515int page_key_alloc(unsigned long pages);
516void page_key_free(void);
517void page_key_read(unsigned long *pfn);
518void page_key_memorize(unsigned long *pfn);
519void page_key_write(void *address);
520
521#else
522
523static inline unsigned long page_key_additional_pages(unsigned long pages)
524{
525 return 0;
526}
527
528static inline int page_key_alloc(unsigned long pages)
529{
530 return 0;
531}
532
533static inline void page_key_free(void) {}
534static inline void page_key_read(unsigned long *pfn) {}
535static inline void page_key_memorize(unsigned long *pfn) {}
536static inline void page_key_write(void *address) {}
537
538#endif
539
540#endif
541