This source file includes following definitions.
- pm_set_vt_switch
- pm_prepare_console
- pm_restore_console
- dpm_save_failed_dev
- dpm_save_failed_errno
- dpm_save_failed_step
- pm_suspend_clear_flags
- pm_set_suspend_via_firmware
- pm_set_resume_via_firmware
- pm_set_suspend_no_platform
- pm_suspend_via_firmware
- pm_resume_via_firmware
- pm_suspend_no_platform
- idle_should_enter_s2idle
- pm_suspend_clear_flags
- pm_set_suspend_via_firmware
- pm_set_resume_via_firmware
- pm_suspend_via_firmware
- pm_resume_via_firmware
- pm_suspend_no_platform
- pm_suspend_default_s2idle
- suspend_set_ops
- pm_suspend
- idle_should_enter_s2idle
- pm_states_init
- s2idle_set_ops
- s2idle_wake
- register_nosave_region
- register_nosave_region_late
- register_nosave_region
- register_nosave_region_late
- swsusp_page_is_forbidden
- swsusp_set_page_free
- swsusp_unset_page_free
- hibernation_set_ops
- hibernate
- system_entering_hibernation
- hibernation_available
- register_pm_notifier
- unregister_pm_notifier
- ksys_sync_helper
- pm_wakeup_pending
- pm_system_wakeup
- pm_wakeup_clear
- pm_system_irq_wakeup
- lock_system_sleep
- unlock_system_sleep
- queue_up_suspend_work
- page_key_additional_pages
- page_key_alloc
- page_key_free
- page_key_read
- page_key_memorize
- page_key_write
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
14 extern void pm_set_vt_switch(int);
15 #else
16 static inline void pm_set_vt_switch(int do_switch)
17 {
18 }
19 #endif
20
21 #ifdef CONFIG_VT_CONSOLE_SLEEP
22 extern void pm_prepare_console(void);
23 extern void pm_restore_console(void);
24 #else
25 static inline void pm_prepare_console(void)
26 {
27 }
28
29 static inline void pm_restore_console(void)
30 {
31 }
32 #endif
33
34 typedef 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
43 enum 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
54 struct 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
74 extern struct suspend_stats suspend_stats;
75
76 static 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
85 static 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
92 static 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
177 struct 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
190 struct 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
201 extern suspend_state_t mem_sleep_current;
202 extern suspend_state_t mem_sleep_default;
203
204
205
206
207
208 extern void suspend_set_ops(const struct platform_suspend_ops *ops);
209 extern int suspend_valid_only_mem(suspend_state_t state);
210
211 extern 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
217 static inline void pm_suspend_clear_flags(void)
218 {
219 pm_suspend_global_flags = 0;
220 }
221
222 static inline void pm_set_suspend_via_firmware(void)
223 {
224 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
225 }
226
227 static inline void pm_set_resume_via_firmware(void)
228 {
229 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
230 }
231
232 static 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
257 static 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
273 static 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
289 static inline bool pm_suspend_no_platform(void)
290 {
291 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_NO_PLATFORM);
292 }
293
294
295 enum s2idle_states {
296 S2IDLE_STATE_NONE,
297 S2IDLE_STATE_ENTER,
298 S2IDLE_STATE_WAKE,
299 };
300
301 extern enum s2idle_states __read_mostly s2idle_state;
302
303 static inline bool idle_should_enter_s2idle(void)
304 {
305 return unlikely(s2idle_state == S2IDLE_STATE_ENTER);
306 }
307
308 extern bool pm_suspend_default_s2idle(void);
309 extern void __init pm_states_init(void);
310 extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
311 extern void s2idle_wake(void);
312
313
314
315
316
317
318
319
320 extern void arch_suspend_disable_irqs(void);
321
322
323
324
325
326
327
328
329 extern void arch_suspend_enable_irqs(void);
330
331 extern int pm_suspend(suspend_state_t state);
332 #else
333 #define suspend_valid_only_mem NULL
334
335 static inline void pm_suspend_clear_flags(void) {}
336 static inline void pm_set_suspend_via_firmware(void) {}
337 static inline void pm_set_resume_via_firmware(void) {}
338 static inline bool pm_suspend_via_firmware(void) { return false; }
339 static inline bool pm_resume_via_firmware(void) { return false; }
340 static inline bool pm_suspend_no_platform(void) { return false; }
341 static inline bool pm_suspend_default_s2idle(void) { return false; }
342
343 static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
344 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
345 static inline bool idle_should_enter_s2idle(void) { return false; }
346 static inline void __init pm_states_init(void) {}
347 static inline void s2idle_set_ops(const struct platform_s2idle_ops *ops) {}
348 static inline void s2idle_wake(void) {}
349 #endif
350
351
352
353
354
355 struct pbe {
356 void *address;
357 void *orig_address;
358 struct pbe *next;
359 };
360
361
362 extern void mark_free_pages(struct zone *zone);
363
364
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 struct platform_hibernation_ops {
417 int (*begin)(pm_message_t stage);
418 void (*end)(void);
419 int (*pre_snapshot)(void);
420 void (*finish)(void);
421 int (*prepare)(void);
422 int (*enter)(void);
423 void (*leave)(void);
424 int (*pre_restore)(void);
425 void (*restore_cleanup)(void);
426 void (*recover)(void);
427 };
428
429 #ifdef CONFIG_HIBERNATION
430
431 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
432 static inline void __init register_nosave_region(unsigned long b, unsigned long e)
433 {
434 __register_nosave_region(b, e, 0);
435 }
436 static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
437 {
438 __register_nosave_region(b, e, 1);
439 }
440 extern int swsusp_page_is_forbidden(struct page *);
441 extern void swsusp_set_page_free(struct page *);
442 extern void swsusp_unset_page_free(struct page *);
443 extern unsigned long get_safe_page(gfp_t gfp_mask);
444 extern asmlinkage int swsusp_arch_suspend(void);
445 extern asmlinkage int swsusp_arch_resume(void);
446
447 extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
448 extern int hibernate(void);
449 extern bool system_entering_hibernation(void);
450 extern bool hibernation_available(void);
451 asmlinkage int swsusp_save(void);
452 extern struct pbe *restore_pblist;
453 int pfn_is_nosave(unsigned long pfn);
454 #else
455 static inline void register_nosave_region(unsigned long b, unsigned long e) {}
456 static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
457 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
458 static inline void swsusp_set_page_free(struct page *p) {}
459 static inline void swsusp_unset_page_free(struct page *p) {}
460
461 static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
462 static inline int hibernate(void) { return -ENOSYS; }
463 static inline bool system_entering_hibernation(void) { return false; }
464 static inline bool hibernation_available(void) { return false; }
465 #endif
466
467
468 #define PM_HIBERNATION_PREPARE 0x0001
469 #define PM_POST_HIBERNATION 0x0002
470 #define PM_SUSPEND_PREPARE 0x0003
471 #define PM_POST_SUSPEND 0x0004
472 #define PM_RESTORE_PREPARE 0x0005
473 #define PM_POST_RESTORE 0x0006
474
475 extern struct mutex system_transition_mutex;
476
477 #ifdef CONFIG_PM_SLEEP
478 void save_processor_state(void);
479 void restore_processor_state(void);
480
481
482 extern int register_pm_notifier(struct notifier_block *nb);
483 extern int unregister_pm_notifier(struct notifier_block *nb);
484 extern void ksys_sync_helper(void);
485
486 #define pm_notifier(fn, pri) { \
487 static struct notifier_block fn##_nb = \
488 { .notifier_call = fn, .priority = pri }; \
489 register_pm_notifier(&fn##_nb); \
490 }
491
492
493 extern bool events_check_enabled;
494 extern unsigned int pm_wakeup_irq;
495 extern suspend_state_t pm_suspend_target_state;
496
497 extern bool pm_wakeup_pending(void);
498 extern void pm_system_wakeup(void);
499 extern void pm_system_cancel_wakeup(void);
500 extern void pm_wakeup_clear(bool reset);
501 extern void pm_system_irq_wakeup(unsigned int irq_number);
502 extern bool pm_get_wakeup_count(unsigned int *count, bool block);
503 extern bool pm_save_wakeup_count(unsigned int count);
504 extern void pm_wakep_autosleep_enabled(bool set);
505 extern void pm_print_active_wakeup_sources(void);
506
507 extern void lock_system_sleep(void);
508 extern void unlock_system_sleep(void);
509
510 #else
511
512 static inline int register_pm_notifier(struct notifier_block *nb)
513 {
514 return 0;
515 }
516
517 static inline int unregister_pm_notifier(struct notifier_block *nb)
518 {
519 return 0;
520 }
521
522 static inline void ksys_sync_helper(void) {}
523
524 #define pm_notifier(fn, pri) do { (void)(fn); } while (0)
525
526 static inline bool pm_wakeup_pending(void) { return false; }
527 static inline void pm_system_wakeup(void) {}
528 static inline void pm_wakeup_clear(bool reset) {}
529 static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
530
531 static inline void lock_system_sleep(void) {}
532 static inline void unlock_system_sleep(void) {}
533
534 #endif
535
536 #ifdef CONFIG_PM_SLEEP_DEBUG
537 extern bool pm_print_times_enabled;
538 extern bool pm_debug_messages_on;
539 extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
540 #else
541 #define pm_print_times_enabled (false)
542 #define pm_debug_messages_on (false)
543
544 #include <linux/printk.h>
545
546 #define __pm_pr_dbg(defer, fmt, ...) \
547 no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
548 #endif
549
550 #define pm_pr_dbg(fmt, ...) \
551 __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
552
553 #define pm_deferred_pr_dbg(fmt, ...) \
554 __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
555
556 #ifdef CONFIG_PM_AUTOSLEEP
557
558
559 void queue_up_suspend_work(void);
560
561 #else
562
563 static inline void queue_up_suspend_work(void) {}
564
565 #endif
566
567 #ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
568
569
570
571
572
573
574
575 unsigned long page_key_additional_pages(unsigned long pages);
576 int page_key_alloc(unsigned long pages);
577 void page_key_free(void);
578 void page_key_read(unsigned long *pfn);
579 void page_key_memorize(unsigned long *pfn);
580 void page_key_write(void *address);
581
582 #else
583
584 static inline unsigned long page_key_additional_pages(unsigned long pages)
585 {
586 return 0;
587 }
588
589 static inline int page_key_alloc(unsigned long pages)
590 {
591 return 0;
592 }
593
594 static inline void page_key_free(void) {}
595 static inline void page_key_read(unsigned long *pfn) {}
596 static inline void page_key_memorize(unsigned long *pfn) {}
597 static inline void page_key_write(void *address) {}
598
599 #endif
600
601 #endif