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