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 void __init pm_states_init(void);
255extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
256extern void s2idle_wake(void);
257
258
259
260
261
262
263
264
265extern void arch_suspend_disable_irqs(void);
266
267
268
269
270
271
272
273
274extern void arch_suspend_enable_irqs(void);
275
276extern int pm_suspend(suspend_state_t state);
277#else
278#define suspend_valid_only_mem NULL
279
280static inline void pm_suspend_clear_flags(void) {}
281static inline void pm_set_suspend_via_firmware(void) {}
282static inline void pm_set_resume_via_firmware(void) {}
283static inline bool pm_suspend_via_firmware(void) { return false; }
284static inline bool pm_resume_via_firmware(void) { return false; }
285
286static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
287static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
288static inline bool idle_should_enter_s2idle(void) { return false; }
289static inline void __init pm_states_init(void) {}
290static inline void s2idle_set_ops(const struct platform_s2idle_ops *ops) {}
291static inline void s2idle_wake(void) {}
292#endif
293
294
295
296
297
298struct pbe {
299 void *address;
300 void *orig_address;
301 struct pbe *next;
302};
303
304
305extern void mark_free_pages(struct zone *zone);
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
355
356
357
358
359struct platform_hibernation_ops {
360 int (*begin)(void);
361 void (*end)(void);
362 int (*pre_snapshot)(void);
363 void (*finish)(void);
364 int (*prepare)(void);
365 int (*enter)(void);
366 void (*leave)(void);
367 int (*pre_restore)(void);
368 void (*restore_cleanup)(void);
369 void (*recover)(void);
370};
371
372#ifdef CONFIG_HIBERNATION
373
374extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
375static inline void __init register_nosave_region(unsigned long b, unsigned long e)
376{
377 __register_nosave_region(b, e, 0);
378}
379static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
380{
381 __register_nosave_region(b, e, 1);
382}
383extern int swsusp_page_is_forbidden(struct page *);
384extern void swsusp_set_page_free(struct page *);
385extern void swsusp_unset_page_free(struct page *);
386extern unsigned long get_safe_page(gfp_t gfp_mask);
387extern asmlinkage int swsusp_arch_suspend(void);
388extern asmlinkage int swsusp_arch_resume(void);
389
390extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
391extern int hibernate(void);
392extern bool system_entering_hibernation(void);
393extern bool hibernation_available(void);
394asmlinkage int swsusp_save(void);
395extern struct pbe *restore_pblist;
396#else
397static inline void register_nosave_region(unsigned long b, unsigned long e) {}
398static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
399static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
400static inline void swsusp_set_page_free(struct page *p) {}
401static inline void swsusp_unset_page_free(struct page *p) {}
402
403static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
404static inline int hibernate(void) { return -ENOSYS; }
405static inline bool system_entering_hibernation(void) { return false; }
406static inline bool hibernation_available(void) { return false; }
407#endif
408
409
410#define PM_HIBERNATION_PREPARE 0x0001
411#define PM_POST_HIBERNATION 0x0002
412#define PM_SUSPEND_PREPARE 0x0003
413#define PM_POST_SUSPEND 0x0004
414#define PM_RESTORE_PREPARE 0x0005
415#define PM_POST_RESTORE 0x0006
416
417extern struct mutex pm_mutex;
418
419#ifdef CONFIG_PM_SLEEP
420void save_processor_state(void);
421void restore_processor_state(void);
422
423
424extern int register_pm_notifier(struct notifier_block *nb);
425extern int unregister_pm_notifier(struct notifier_block *nb);
426
427#define pm_notifier(fn, pri) { \
428 static struct notifier_block fn##_nb = \
429 { .notifier_call = fn, .priority = pri }; \
430 register_pm_notifier(&fn##_nb); \
431}
432
433
434extern bool events_check_enabled;
435extern unsigned int pm_wakeup_irq;
436extern suspend_state_t pm_suspend_target_state;
437
438extern bool pm_wakeup_pending(void);
439extern void pm_system_wakeup(void);
440extern void pm_system_cancel_wakeup(void);
441extern void pm_wakeup_clear(bool reset);
442extern void pm_system_irq_wakeup(unsigned int irq_number);
443extern bool pm_get_wakeup_count(unsigned int *count, bool block);
444extern bool pm_save_wakeup_count(unsigned int count);
445extern void pm_wakep_autosleep_enabled(bool set);
446extern void pm_print_active_wakeup_sources(void);
447
448extern void lock_system_sleep(void);
449extern void unlock_system_sleep(void);
450
451#else
452
453static inline int register_pm_notifier(struct notifier_block *nb)
454{
455 return 0;
456}
457
458static inline int unregister_pm_notifier(struct notifier_block *nb)
459{
460 return 0;
461}
462
463#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
464
465static inline bool pm_wakeup_pending(void) { return false; }
466static inline void pm_system_wakeup(void) {}
467static inline void pm_wakeup_clear(bool reset) {}
468static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
469
470static inline void lock_system_sleep(void) {}
471static inline void unlock_system_sleep(void) {}
472
473#endif
474
475#ifdef CONFIG_PM_SLEEP_DEBUG
476extern bool pm_print_times_enabled;
477extern bool pm_debug_messages_on;
478extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
479#else
480#define pm_print_times_enabled (false)
481#define pm_debug_messages_on (false)
482
483#include <linux/printk.h>
484
485#define __pm_pr_dbg(defer, fmt, ...) \
486 no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
487#endif
488
489#define pm_pr_dbg(fmt, ...) \
490 __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
491
492#define pm_deferred_pr_dbg(fmt, ...) \
493 __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
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