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 int (*prepare_late)(void);
194 bool (*wake)(void);
195 void (*restore_early)(void);
196 void (*restore)(void);
197 void (*end)(void);
198};
199
200#ifdef CONFIG_SUSPEND
201extern suspend_state_t mem_sleep_current;
202extern suspend_state_t mem_sleep_default;
203
204
205
206
207
208extern void suspend_set_ops(const struct platform_suspend_ops *ops);
209extern int suspend_valid_only_mem(suspend_state_t state);
210
211extern unsigned int pm_suspend_global_flags;
212
213#define PM_SUSPEND_FLAG_FW_SUSPEND BIT(0)
214#define PM_SUSPEND_FLAG_FW_RESUME BIT(1)
215#define PM_SUSPEND_FLAG_NO_PLATFORM BIT(2)
216
217static inline void pm_suspend_clear_flags(void)
218{
219 pm_suspend_global_flags = 0;
220}
221
222static inline void pm_set_suspend_via_firmware(void)
223{
224 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
225}
226
227static inline void pm_set_resume_via_firmware(void)
228{
229 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
230}
231
232static inline void pm_set_suspend_no_platform(void)
233{
234 pm_suspend_global_flags |= PM_SUSPEND_FLAG_NO_PLATFORM;
235}
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257static inline bool pm_suspend_via_firmware(void)
258{
259 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
260}
261
262
263
264
265
266
267
268
269
270
271
272
273static inline bool pm_resume_via_firmware(void)
274{
275 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
276}
277
278
279
280
281
282
283
284
285
286
287
288
289static inline bool pm_suspend_no_platform(void)
290{
291 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_NO_PLATFORM);
292}
293
294
295enum s2idle_states {
296 S2IDLE_STATE_NONE,
297 S2IDLE_STATE_ENTER,
298 S2IDLE_STATE_WAKE,
299};
300
301extern enum s2idle_states __read_mostly s2idle_state;
302
303static inline bool idle_should_enter_s2idle(void)
304{
305 return unlikely(s2idle_state == S2IDLE_STATE_ENTER);
306}
307
308extern bool pm_suspend_default_s2idle(void);
309extern void __init pm_states_init(void);
310extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
311extern void s2idle_wake(void);
312
313
314
315
316
317
318
319
320extern void arch_suspend_disable_irqs(void);
321
322
323
324
325
326
327
328
329extern void arch_suspend_enable_irqs(void);
330
331extern int pm_suspend(suspend_state_t state);
332extern bool sync_on_suspend_enabled;
333#else
334#define suspend_valid_only_mem NULL
335
336static inline void pm_suspend_clear_flags(void) {}
337static inline void pm_set_suspend_via_firmware(void) {}
338static inline void pm_set_resume_via_firmware(void) {}
339static inline bool pm_suspend_via_firmware(void) { return false; }
340static inline bool pm_resume_via_firmware(void) { return false; }
341static inline bool pm_suspend_no_platform(void) { return false; }
342static inline bool pm_suspend_default_s2idle(void) { return false; }
343
344static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
345static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
346static inline bool sync_on_suspend_enabled(void) { return true; }
347static inline bool idle_should_enter_s2idle(void) { return false; }
348static inline void __init pm_states_init(void) {}
349static inline void s2idle_set_ops(const struct platform_s2idle_ops *ops) {}
350static inline void s2idle_wake(void) {}
351#endif
352
353
354
355
356
357struct pbe {
358 void *address;
359 void *orig_address;
360 struct pbe *next;
361};
362
363
364extern void mark_free_pages(struct zone *zone);
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418struct platform_hibernation_ops {
419 int (*begin)(pm_message_t stage);
420 void (*end)(void);
421 int (*pre_snapshot)(void);
422 void (*finish)(void);
423 int (*prepare)(void);
424 int (*enter)(void);
425 void (*leave)(void);
426 int (*pre_restore)(void);
427 void (*restore_cleanup)(void);
428 void (*recover)(void);
429};
430
431#ifdef CONFIG_HIBERNATION
432
433extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
434static inline void __init register_nosave_region(unsigned long b, unsigned long e)
435{
436 __register_nosave_region(b, e, 0);
437}
438static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
439{
440 __register_nosave_region(b, e, 1);
441}
442extern int swsusp_page_is_forbidden(struct page *);
443extern void swsusp_set_page_free(struct page *);
444extern void swsusp_unset_page_free(struct page *);
445extern unsigned long get_safe_page(gfp_t gfp_mask);
446extern asmlinkage int swsusp_arch_suspend(void);
447extern asmlinkage int swsusp_arch_resume(void);
448
449extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
450extern int hibernate(void);
451extern bool system_entering_hibernation(void);
452extern bool hibernation_available(void);
453asmlinkage int swsusp_save(void);
454extern struct pbe *restore_pblist;
455int pfn_is_nosave(unsigned long pfn);
456
457int hibernate_quiet_exec(int (*func)(void *data), void *data);
458#else
459static inline void register_nosave_region(unsigned long b, unsigned long e) {}
460static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
461static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
462static inline void swsusp_set_page_free(struct page *p) {}
463static inline void swsusp_unset_page_free(struct page *p) {}
464
465static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
466static inline int hibernate(void) { return -ENOSYS; }
467static inline bool system_entering_hibernation(void) { return false; }
468static inline bool hibernation_available(void) { return false; }
469
470static inline int hibernate_quiet_exec(int (*func)(void *data), void *data) {
471 return -ENOTSUPP;
472}
473#endif
474
475#ifdef CONFIG_HIBERNATION_SNAPSHOT_DEV
476int is_hibernate_resume_dev(const struct inode *);
477#else
478static inline int is_hibernate_resume_dev(const struct inode *i) { return 0; }
479#endif
480
481
482#define PM_HIBERNATION_PREPARE 0x0001
483#define PM_POST_HIBERNATION 0x0002
484#define PM_SUSPEND_PREPARE 0x0003
485#define PM_POST_SUSPEND 0x0004
486#define PM_RESTORE_PREPARE 0x0005
487#define PM_POST_RESTORE 0x0006
488
489extern struct mutex system_transition_mutex;
490
491#ifdef CONFIG_PM_SLEEP
492void save_processor_state(void);
493void restore_processor_state(void);
494
495
496extern int register_pm_notifier(struct notifier_block *nb);
497extern int unregister_pm_notifier(struct notifier_block *nb);
498extern void ksys_sync_helper(void);
499
500#define pm_notifier(fn, pri) { \
501 static struct notifier_block fn##_nb = \
502 { .notifier_call = fn, .priority = pri }; \
503 register_pm_notifier(&fn##_nb); \
504}
505
506
507extern bool events_check_enabled;
508extern unsigned int pm_wakeup_irq;
509extern suspend_state_t pm_suspend_target_state;
510
511extern bool pm_wakeup_pending(void);
512extern void pm_system_wakeup(void);
513extern void pm_system_cancel_wakeup(void);
514extern void pm_wakeup_clear(bool reset);
515extern void pm_system_irq_wakeup(unsigned int irq_number);
516extern bool pm_get_wakeup_count(unsigned int *count, bool block);
517extern bool pm_save_wakeup_count(unsigned int count);
518extern void pm_wakep_autosleep_enabled(bool set);
519extern void pm_print_active_wakeup_sources(void);
520
521extern void lock_system_sleep(void);
522extern void unlock_system_sleep(void);
523
524#else
525
526static inline int register_pm_notifier(struct notifier_block *nb)
527{
528 return 0;
529}
530
531static inline int unregister_pm_notifier(struct notifier_block *nb)
532{
533 return 0;
534}
535
536static inline void ksys_sync_helper(void) {}
537
538#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
539
540static inline bool pm_wakeup_pending(void) { return false; }
541static inline void pm_system_wakeup(void) {}
542static inline void pm_wakeup_clear(bool reset) {}
543static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
544
545static inline void lock_system_sleep(void) {}
546static inline void unlock_system_sleep(void) {}
547
548#endif
549
550#ifdef CONFIG_PM_SLEEP_DEBUG
551extern bool pm_print_times_enabled;
552extern bool pm_debug_messages_on;
553extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
554#else
555#define pm_print_times_enabled (false)
556#define pm_debug_messages_on (false)
557
558#include <linux/printk.h>
559
560#define __pm_pr_dbg(defer, fmt, ...) \
561 no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
562#endif
563
564#define pm_pr_dbg(fmt, ...) \
565 __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
566
567#define pm_deferred_pr_dbg(fmt, ...) \
568 __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
569
570#ifdef CONFIG_PM_AUTOSLEEP
571
572
573void queue_up_suspend_work(void);
574
575#else
576
577static inline void queue_up_suspend_work(void) {}
578
579#endif
580
581#endif
582