1
2#ifndef _LINUX_SUSPEND_H
3#define _LINUX_SUSPEND_H
4
5#include <linux/swap.h>
6#include <linux/notifier.h>
7#include <linux/init.h>
8#include <linux/pm.h>
9#include <linux/mm.h>
10#include <linux/freezer.h>
11#include <asm/errno.h>
12
13#ifdef CONFIG_VT
14extern void pm_set_vt_switch(int);
15#else
16static inline void pm_set_vt_switch(int do_switch)
17{
18}
19#endif
20
21#ifdef CONFIG_VT_CONSOLE_SLEEP
22extern void pm_prepare_console(void);
23extern void pm_restore_console(void);
24#else
25static inline void pm_prepare_console(void)
26{
27}
28
29static inline void pm_restore_console(void)
30{
31}
32#endif
33
34typedef int __bitwise suspend_state_t;
35
36#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
37#define PM_SUSPEND_TO_IDLE ((__force suspend_state_t) 1)
38#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
39#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
40#define PM_SUSPEND_MIN PM_SUSPEND_TO_IDLE
41#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
42
43enum suspend_stat_step {
44 SUSPEND_FREEZE = 1,
45 SUSPEND_PREPARE,
46 SUSPEND_SUSPEND,
47 SUSPEND_SUSPEND_LATE,
48 SUSPEND_SUSPEND_NOIRQ,
49 SUSPEND_RESUME_NOIRQ,
50 SUSPEND_RESUME_EARLY,
51 SUSPEND_RESUME
52};
53
54struct suspend_stats {
55 int success;
56 int fail;
57 int failed_freeze;
58 int failed_prepare;
59 int failed_suspend;
60 int failed_suspend_late;
61 int failed_suspend_noirq;
62 int failed_resume;
63 int failed_resume_early;
64 int failed_resume_noirq;
65#define REC_FAILED_NUM 2
66 int last_failed_dev;
67 char failed_devs[REC_FAILED_NUM][40];
68 int last_failed_errno;
69 int errno[REC_FAILED_NUM];
70 int last_failed_step;
71 enum suspend_stat_step failed_steps[REC_FAILED_NUM];
72};
73
74extern struct suspend_stats suspend_stats;
75
76static inline void dpm_save_failed_dev(const char *name)
77{
78 strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev],
79 name,
80 sizeof(suspend_stats.failed_devs[0]));
81 suspend_stats.last_failed_dev++;
82 suspend_stats.last_failed_dev %= REC_FAILED_NUM;
83}
84
85static inline void dpm_save_failed_errno(int err)
86{
87 suspend_stats.errno[suspend_stats.last_failed_errno] = err;
88 suspend_stats.last_failed_errno++;
89 suspend_stats.last_failed_errno %= REC_FAILED_NUM;
90}
91
92static inline void dpm_save_failed_step(enum suspend_stat_step step)
93{
94 suspend_stats.failed_steps[suspend_stats.last_failed_step] = step;
95 suspend_stats.last_failed_step++;
96 suspend_stats.last_failed_step %= REC_FAILED_NUM;
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
176
177struct platform_suspend_ops {
178 int (*valid)(suspend_state_t state);
179 int (*begin)(suspend_state_t state);
180 int (*prepare)(void);
181 int (*prepare_late)(void);
182 int (*enter)(suspend_state_t state);
183 void (*wake)(void);
184 void (*finish)(void);
185 bool (*suspend_again)(void);
186 void (*end)(void);
187 void (*recover)(void);
188};
189
190struct platform_s2idle_ops {
191 int (*begin)(void);
192 int (*prepare)(void);
193 void (*wake)(void);
194 void (*sync)(void);
195 void (*restore)(void);
196 void (*end)(void);
197};
198
199#ifdef CONFIG_SUSPEND
200extern suspend_state_t mem_sleep_current;
201extern suspend_state_t mem_sleep_default;
202
203
204
205
206
207extern void suspend_set_ops(const struct platform_suspend_ops *ops);
208extern int suspend_valid_only_mem(suspend_state_t state);
209
210extern unsigned int pm_suspend_global_flags;
211
212#define PM_SUSPEND_FLAG_FW_SUSPEND (1 << 0)
213#define PM_SUSPEND_FLAG_FW_RESUME (1 << 1)
214
215static inline void pm_suspend_clear_flags(void)
216{
217 pm_suspend_global_flags = 0;
218}
219
220static inline void pm_set_suspend_via_firmware(void)
221{
222 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
223}
224
225static inline void pm_set_resume_via_firmware(void)
226{
227 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
228}
229
230static inline bool pm_suspend_via_firmware(void)
231{
232 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
233}
234
235static inline bool pm_resume_via_firmware(void)
236{
237 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
238}
239
240
241enum s2idle_states {
242 S2IDLE_STATE_NONE,
243 S2IDLE_STATE_ENTER,
244 S2IDLE_STATE_WAKE,
245};
246
247extern enum s2idle_states __read_mostly s2idle_state;
248
249static inline bool idle_should_enter_s2idle(void)
250{
251 return unlikely(s2idle_state == S2IDLE_STATE_ENTER);
252}
253
254extern bool pm_suspend_via_s2idle(void);
255extern void __init pm_states_init(void);
256extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
257extern void s2idle_wake(void);
258
259
260
261
262
263
264
265
266extern void arch_suspend_disable_irqs(void);
267
268
269
270
271
272
273
274
275extern void arch_suspend_enable_irqs(void);
276
277extern int pm_suspend(suspend_state_t state);
278#else
279#define suspend_valid_only_mem NULL
280
281static inline void pm_suspend_clear_flags(void) {}
282static inline void pm_set_suspend_via_firmware(void) {}
283static inline void pm_set_resume_via_firmware(void) {}
284static inline bool pm_suspend_via_firmware(void) { return false; }
285static inline bool pm_resume_via_firmware(void) { return false; }
286static inline bool pm_suspend_via_s2idle(void) { return false; }
287
288static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
289static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
290static inline bool idle_should_enter_s2idle(void) { return false; }
291static inline void __init pm_states_init(void) {}
292static inline void s2idle_set_ops(const struct platform_s2idle_ops *ops) {}
293static inline void s2idle_wake(void) {}
294#endif
295
296
297
298
299
300struct pbe {
301 void *address;
302 void *orig_address;
303 struct pbe *next;
304};
305
306
307extern void mark_free_pages(struct zone *zone);
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
355
356
357
358
359
360
361struct platform_hibernation_ops {
362 int (*begin)(void);
363 void (*end)(void);
364 int (*pre_snapshot)(void);
365 void (*finish)(void);
366 int (*prepare)(void);
367 int (*enter)(void);
368 void (*leave)(void);
369 int (*pre_restore)(void);
370 void (*restore_cleanup)(void);
371 void (*recover)(void);
372};
373
374#ifdef CONFIG_HIBERNATION
375
376extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
377static inline void __init register_nosave_region(unsigned long b, unsigned long e)
378{
379 __register_nosave_region(b, e, 0);
380}
381static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
382{
383 __register_nosave_region(b, e, 1);
384}
385extern int swsusp_page_is_forbidden(struct page *);
386extern void swsusp_set_page_free(struct page *);
387extern void swsusp_unset_page_free(struct page *);
388extern unsigned long get_safe_page(gfp_t gfp_mask);
389extern asmlinkage int swsusp_arch_suspend(void);
390extern asmlinkage int swsusp_arch_resume(void);
391
392extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
393extern int hibernate(void);
394extern bool system_entering_hibernation(void);
395extern bool hibernation_available(void);
396asmlinkage int swsusp_save(void);
397extern struct pbe *restore_pblist;
398#else
399static inline void register_nosave_region(unsigned long b, unsigned long e) {}
400static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
401static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
402static inline void swsusp_set_page_free(struct page *p) {}
403static inline void swsusp_unset_page_free(struct page *p) {}
404
405static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
406static inline int hibernate(void) { return -ENOSYS; }
407static inline bool system_entering_hibernation(void) { return false; }
408static inline bool hibernation_available(void) { return false; }
409#endif
410
411
412#define PM_HIBERNATION_PREPARE 0x0001
413#define PM_POST_HIBERNATION 0x0002
414#define PM_SUSPEND_PREPARE 0x0003
415#define PM_POST_SUSPEND 0x0004
416#define PM_RESTORE_PREPARE 0x0005
417#define PM_POST_RESTORE 0x0006
418
419extern struct mutex system_transition_mutex;
420
421#ifdef CONFIG_PM_SLEEP
422void save_processor_state(void);
423void restore_processor_state(void);
424
425
426extern int register_pm_notifier(struct notifier_block *nb);
427extern int unregister_pm_notifier(struct notifier_block *nb);
428
429#define pm_notifier(fn, pri) { \
430 static struct notifier_block fn##_nb = \
431 { .notifier_call = fn, .priority = pri }; \
432 register_pm_notifier(&fn##_nb); \
433}
434
435
436extern bool events_check_enabled;
437extern unsigned int pm_wakeup_irq;
438extern suspend_state_t pm_suspend_target_state;
439
440extern bool pm_wakeup_pending(void);
441extern void pm_system_wakeup(void);
442extern void pm_system_cancel_wakeup(void);
443extern void pm_wakeup_clear(bool reset);
444extern void pm_system_irq_wakeup(unsigned int irq_number);
445extern bool pm_get_wakeup_count(unsigned int *count, bool block);
446extern bool pm_save_wakeup_count(unsigned int count);
447extern void pm_wakep_autosleep_enabled(bool set);
448extern void pm_print_active_wakeup_sources(void);
449
450extern void lock_system_sleep(void);
451extern void unlock_system_sleep(void);
452
453#else
454
455static inline int register_pm_notifier(struct notifier_block *nb)
456{
457 return 0;
458}
459
460static inline int unregister_pm_notifier(struct notifier_block *nb)
461{
462 return 0;
463}
464
465#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
466
467static inline bool pm_wakeup_pending(void) { return false; }
468static inline void pm_system_wakeup(void) {}
469static inline void pm_wakeup_clear(bool reset) {}
470static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
471
472static inline void lock_system_sleep(void) {}
473static inline void unlock_system_sleep(void) {}
474
475#endif
476
477#ifdef CONFIG_PM_SLEEP_DEBUG
478extern bool pm_print_times_enabled;
479extern bool pm_debug_messages_on;
480extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
481#else
482#define pm_print_times_enabled (false)
483#define pm_debug_messages_on (false)
484
485#include <linux/printk.h>
486
487#define __pm_pr_dbg(defer, fmt, ...) \
488 no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
489#endif
490
491#define pm_pr_dbg(fmt, ...) \
492 __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
493
494#define pm_deferred_pr_dbg(fmt, ...) \
495 __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
496
497#ifdef CONFIG_PM_AUTOSLEEP
498
499
500void queue_up_suspend_work(void);
501
502#else
503
504static inline void queue_up_suspend_work(void) {}
505
506#endif
507
508#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
509
510
511
512
513
514
515
516unsigned long page_key_additional_pages(unsigned long pages);
517int page_key_alloc(unsigned long pages);
518void page_key_free(void);
519void page_key_read(unsigned long *pfn);
520void page_key_memorize(unsigned long *pfn);
521void page_key_write(void *address);
522
523#else
524
525static inline unsigned long page_key_additional_pages(unsigned long pages)
526{
527 return 0;
528}
529
530static inline int page_key_alloc(unsigned long pages)
531{
532 return 0;
533}
534
535static inline void page_key_free(void) {}
536static inline void page_key_read(unsigned long *pfn) {}
537static inline void page_key_memorize(unsigned long *pfn) {}
538static inline void page_key_write(void *address) {}
539
540#endif
541
542#endif
543