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);
434extern int swsusp_page_is_forbidden(struct page *);
435extern void swsusp_set_page_free(struct page *);
436extern void swsusp_unset_page_free(struct page *);
437extern unsigned long get_safe_page(gfp_t gfp_mask);
438extern asmlinkage int swsusp_arch_suspend(void);
439extern asmlinkage int swsusp_arch_resume(void);
440
441extern u32 swsusp_hardware_signature;
442extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
443extern int hibernate(void);
444extern bool system_entering_hibernation(void);
445extern bool hibernation_available(void);
446asmlinkage int swsusp_save(void);
447extern struct pbe *restore_pblist;
448int pfn_is_nosave(unsigned long pfn);
449
450int hibernate_quiet_exec(int (*func)(void *data), void *data);
451#else
452static inline void register_nosave_region(unsigned long b, unsigned long e) {}
453static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
454static inline void swsusp_set_page_free(struct page *p) {}
455static inline void swsusp_unset_page_free(struct page *p) {}
456
457static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
458static inline int hibernate(void) { return -ENOSYS; }
459static inline bool system_entering_hibernation(void) { return false; }
460static inline bool hibernation_available(void) { return false; }
461
462static inline int hibernate_quiet_exec(int (*func)(void *data), void *data) {
463 return -ENOTSUPP;
464}
465#endif
466
467#ifdef CONFIG_HIBERNATION_SNAPSHOT_DEV
468int is_hibernate_resume_dev(dev_t dev);
469#else
470static inline int is_hibernate_resume_dev(dev_t dev) { return 0; }
471#endif
472
473
474#define PM_HIBERNATION_PREPARE 0x0001
475#define PM_POST_HIBERNATION 0x0002
476#define PM_SUSPEND_PREPARE 0x0003
477#define PM_POST_SUSPEND 0x0004
478#define PM_RESTORE_PREPARE 0x0005
479#define PM_POST_RESTORE 0x0006
480
481extern struct mutex system_transition_mutex;
482
483#ifdef CONFIG_PM_SLEEP
484void save_processor_state(void);
485void restore_processor_state(void);
486
487
488extern int register_pm_notifier(struct notifier_block *nb);
489extern int unregister_pm_notifier(struct notifier_block *nb);
490extern void ksys_sync_helper(void);
491
492#define pm_notifier(fn, pri) { \
493 static struct notifier_block fn##_nb = \
494 { .notifier_call = fn, .priority = pri }; \
495 register_pm_notifier(&fn##_nb); \
496}
497
498
499extern bool events_check_enabled;
500extern suspend_state_t pm_suspend_target_state;
501
502extern bool pm_wakeup_pending(void);
503extern void pm_system_wakeup(void);
504extern void pm_system_cancel_wakeup(void);
505extern void pm_wakeup_clear(unsigned int irq_number);
506extern void pm_system_irq_wakeup(unsigned int irq_number);
507extern unsigned int pm_wakeup_irq(void);
508extern bool pm_get_wakeup_count(unsigned int *count, bool block);
509extern bool pm_save_wakeup_count(unsigned int count);
510extern void pm_wakep_autosleep_enabled(bool set);
511extern void pm_print_active_wakeup_sources(void);
512
513extern void lock_system_sleep(void);
514extern void unlock_system_sleep(void);
515
516#else
517
518static inline int register_pm_notifier(struct notifier_block *nb)
519{
520 return 0;
521}
522
523static inline int unregister_pm_notifier(struct notifier_block *nb)
524{
525 return 0;
526}
527
528static inline void ksys_sync_helper(void) {}
529
530#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
531
532static inline bool pm_wakeup_pending(void) { return false; }
533static inline void pm_system_wakeup(void) {}
534static inline void pm_wakeup_clear(bool reset) {}
535static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
536
537static inline void lock_system_sleep(void) {}
538static inline void unlock_system_sleep(void) {}
539
540#endif
541
542#ifdef CONFIG_PM_SLEEP_DEBUG
543extern bool pm_print_times_enabled;
544extern bool pm_debug_messages_on;
545extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
546#else
547#define pm_print_times_enabled (false)
548#define pm_debug_messages_on (false)
549
550#include <linux/printk.h>
551
552#define __pm_pr_dbg(defer, fmt, ...) \
553 no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
554#endif
555
556#define pm_pr_dbg(fmt, ...) \
557 __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
558
559#define pm_deferred_pr_dbg(fmt, ...) \
560 __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
561
562#ifdef CONFIG_PM_AUTOSLEEP
563
564
565void queue_up_suspend_work(void);
566
567#else
568
569static inline void queue_up_suspend_work(void) {}
570
571#endif
572
573#endif
574