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 int pm_prepare_console(void);
22extern void pm_restore_console(void);
23#else
24static inline int pm_prepare_console(void)
25{
26 return 0;
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_FREEZE ((__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_FREEZE
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_freeze_ops {
191 int (*begin)(void);
192 int (*prepare)(void);
193 void (*restore)(void);
194 void (*end)(void);
195};
196
197#ifdef CONFIG_SUSPEND
198
199
200
201
202extern void suspend_set_ops(const struct platform_suspend_ops *ops);
203extern int suspend_valid_only_mem(suspend_state_t state);
204
205
206enum freeze_state {
207 FREEZE_STATE_NONE,
208 FREEZE_STATE_ENTER,
209 FREEZE_STATE_WAKE,
210};
211
212extern enum freeze_state __read_mostly suspend_freeze_state;
213
214static inline bool idle_should_freeze(void)
215{
216 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER);
217}
218
219extern void freeze_set_ops(const struct platform_freeze_ops *ops);
220extern void freeze_wake(void);
221
222
223
224
225
226
227
228
229extern void arch_suspend_disable_irqs(void);
230
231
232
233
234
235
236
237
238extern void arch_suspend_enable_irqs(void);
239
240extern int pm_suspend(suspend_state_t state);
241#else
242#define suspend_valid_only_mem NULL
243
244static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
245static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
246static inline bool idle_should_freeze(void) { return false; }
247static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {}
248static inline void freeze_wake(void) {}
249#endif
250
251
252
253
254
255struct pbe {
256 void *address;
257 void *orig_address;
258 struct pbe *next;
259};
260
261
262extern void mark_free_pages(struct zone *zone);
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316struct platform_hibernation_ops {
317 int (*begin)(void);
318 void (*end)(void);
319 int (*pre_snapshot)(void);
320 void (*finish)(void);
321 int (*prepare)(void);
322 int (*enter)(void);
323 void (*leave)(void);
324 int (*pre_restore)(void);
325 void (*restore_cleanup)(void);
326 void (*recover)(void);
327};
328
329#ifdef CONFIG_HIBERNATION
330
331extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
332static inline void __init register_nosave_region(unsigned long b, unsigned long e)
333{
334 __register_nosave_region(b, e, 0);
335}
336static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
337{
338 __register_nosave_region(b, e, 1);
339}
340extern int swsusp_page_is_forbidden(struct page *);
341extern void swsusp_set_page_free(struct page *);
342extern void swsusp_unset_page_free(struct page *);
343extern unsigned long get_safe_page(gfp_t gfp_mask);
344
345extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
346extern int hibernate(void);
347extern bool system_entering_hibernation(void);
348extern bool hibernation_available(void);
349asmlinkage int swsusp_save(void);
350extern struct pbe *restore_pblist;
351#else
352static inline void register_nosave_region(unsigned long b, unsigned long e) {}
353static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
354static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
355static inline void swsusp_set_page_free(struct page *p) {}
356static inline void swsusp_unset_page_free(struct page *p) {}
357
358static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
359static inline int hibernate(void) { return -ENOSYS; }
360static inline bool system_entering_hibernation(void) { return false; }
361static inline bool hibernation_available(void) { return false; }
362#endif
363
364
365#define PM_HIBERNATION_PREPARE 0x0001
366#define PM_POST_HIBERNATION 0x0002
367#define PM_SUSPEND_PREPARE 0x0003
368#define PM_POST_SUSPEND 0x0004
369#define PM_RESTORE_PREPARE 0x0005
370#define PM_POST_RESTORE 0x0006
371
372extern struct mutex pm_mutex;
373
374#ifdef CONFIG_PM_SLEEP
375void save_processor_state(void);
376void restore_processor_state(void);
377
378
379extern int register_pm_notifier(struct notifier_block *nb);
380extern int unregister_pm_notifier(struct notifier_block *nb);
381
382#define pm_notifier(fn, pri) { \
383 static struct notifier_block fn##_nb = \
384 { .notifier_call = fn, .priority = pri }; \
385 register_pm_notifier(&fn##_nb); \
386}
387
388
389extern bool events_check_enabled;
390
391extern bool pm_wakeup_pending(void);
392extern void pm_system_wakeup(void);
393extern void pm_wakeup_clear(void);
394extern bool pm_get_wakeup_count(unsigned int *count, bool block);
395extern bool pm_save_wakeup_count(unsigned int count);
396extern void pm_wakep_autosleep_enabled(bool set);
397extern void pm_print_active_wakeup_sources(void);
398
399static inline void lock_system_sleep(void)
400{
401 current->flags |= PF_FREEZER_SKIP;
402 mutex_lock(&pm_mutex);
403}
404
405static inline void unlock_system_sleep(void)
406{
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422 current->flags &= ~PF_FREEZER_SKIP;
423 mutex_unlock(&pm_mutex);
424}
425
426#else
427
428static inline int register_pm_notifier(struct notifier_block *nb)
429{
430 return 0;
431}
432
433static inline int unregister_pm_notifier(struct notifier_block *nb)
434{
435 return 0;
436}
437
438#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
439
440static inline bool pm_wakeup_pending(void) { return false; }
441static inline void pm_system_wakeup(void) {}
442static inline void pm_wakeup_clear(void) {}
443
444static inline void lock_system_sleep(void) {}
445static inline void unlock_system_sleep(void) {}
446
447#endif
448
449#ifdef CONFIG_PM_SLEEP_DEBUG
450extern bool pm_print_times_enabled;
451#else
452#define pm_print_times_enabled (false)
453#endif
454
455#ifdef CONFIG_PM_AUTOSLEEP
456
457
458void queue_up_suspend_work(void);
459
460#else
461
462static inline void queue_up_suspend_work(void) {}
463
464#endif
465
466#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
467
468
469
470
471
472
473
474unsigned long page_key_additional_pages(unsigned long pages);
475int page_key_alloc(unsigned long pages);
476void page_key_free(void);
477void page_key_read(unsigned long *pfn);
478void page_key_memorize(unsigned long *pfn);
479void page_key_write(void *address);
480
481#else
482
483static inline unsigned long page_key_additional_pages(unsigned long pages)
484{
485 return 0;
486}
487
488static inline int page_key_alloc(unsigned long pages)
489{
490 return 0;
491}
492
493static inline void page_key_free(void) {}
494static inline void page_key_read(unsigned long *pfn) {}
495static inline void page_key_memorize(unsigned long *pfn) {}
496static inline void page_key_write(void *address) {}
497
498#endif
499
500#endif
501