projects/linux·blob v4.12 · refs

540 lines · 18.3 KiB

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 void pm_prepare_console(void);
22extern void pm_restore_console(void);
23#else
24static inline void pm_prepare_console(void)
25{
26}
27
28static inline void pm_restore_console(void)
29{
30}
31#endif
32
33typedef int __bitwise suspend_state_t;
34
35#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
36#define PM_SUSPEND_FREEZE ((__force suspend_state_t) 1)
37#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
38#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
39#define PM_SUSPEND_MIN PM_SUSPEND_FREEZE
40#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
41
42enum suspend_stat_step {
43 SUSPEND_FREEZE = 1,
44 SUSPEND_PREPARE,
45 SUSPEND_SUSPEND,
46 SUSPEND_SUSPEND_LATE,
47 SUSPEND_SUSPEND_NOIRQ,
48 SUSPEND_RESUME_NOIRQ,
49 SUSPEND_RESUME_EARLY,
50 SUSPEND_RESUME
51};
52
53struct suspend_stats {
54 int success;
55 int fail;
56 int failed_freeze;
57 int failed_prepare;
58 int failed_suspend;
59 int failed_suspend_late;
60 int failed_suspend_noirq;
61 int failed_resume;
62 int failed_resume_early;
63 int failed_resume_noirq;
64#define REC_FAILED_NUM 2
65 int last_failed_dev;
66 char failed_devs[REC_FAILED_NUM][40];
67 int last_failed_errno;
68 int errno[REC_FAILED_NUM];
69 int last_failed_step;
70 enum suspend_stat_step failed_steps[REC_FAILED_NUM];
71};
72
73extern struct suspend_stats suspend_stats;
74
75static inline void dpm_save_failed_dev(const char *name)
76{
77 strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev],
78 name,
79 sizeof(suspend_stats.failed_devs[0]));
80 suspend_stats.last_failed_dev++;
81 suspend_stats.last_failed_dev %= REC_FAILED_NUM;
82}
83
84static inline void dpm_save_failed_errno(int err)
85{
86 suspend_stats.errno[suspend_stats.last_failed_errno] = err;
87 suspend_stats.last_failed_errno++;
88 suspend_stats.last_failed_errno %= REC_FAILED_NUM;
89}
90
91static inline void dpm_save_failed_step(enum suspend_stat_step step)
92{
93 suspend_stats.failed_steps[suspend_stats.last_failed_step] = step;
94 suspend_stats.last_failed_step++;
95 suspend_stats.last_failed_step %= REC_FAILED_NUM;
96}
97
98/**
99 * struct platform_suspend_ops - Callbacks for managing platform dependent
100 * system sleep states.
101 *
102 * @valid: Callback to determine if given system sleep state is supported by
103 * the platform.
104 * Valid (ie. supported) states are advertised in /sys/power/state. Note
105 * that it still may be impossible to enter given system sleep state if the
106 * conditions aren't right.
107 * There is the %suspend_valid_only_mem function available that can be
108 * assigned to this if the platform only supports mem sleep.
109 *
110 * @begin: Initialise a transition to given system sleep state.
111 * @begin() is executed right prior to suspending devices. The information
112 * conveyed to the platform code by @begin() should be disregarded by it as
113 * soon as @end() is executed. If @begin() fails (ie. returns nonzero),
114 * @prepare(), @enter() and @finish() will not be called by the PM core.
115 * This callback is optional. However, if it is implemented, the argument
116 * passed to @enter() is redundant and should be ignored.
117 *
118 * @prepare: Prepare the platform for entering the system sleep state indicated
119 * by @begin().
120 * @prepare() is called right after devices have been suspended (ie. the
121 * appropriate .suspend() method has been executed for each device) and
122 * before device drivers' late suspend callbacks are executed. It returns
123 * 0 on success or a negative error code otherwise, in which case the
124 * system cannot enter the desired sleep state (@prepare_late(), @enter(),
125 * and @wake() will not be called in that case).
126 *
127 * @prepare_late: Finish preparing the platform for entering the system sleep
128 * state indicated by @begin().
129 * @prepare_late is called before disabling nonboot CPUs and after
130 * device drivers' late suspend callbacks have been executed. It returns
131 * 0 on success or a negative error code otherwise, in which case the
132 * system cannot enter the desired sleep state (@enter() will not be
133 * executed).
134 *
135 * @enter: Enter the system sleep state indicated by @begin() or represented by
136 * the argument if @begin() is not implemented.
137 * This callback is mandatory. It returns 0 on success or a negative
138 * error code otherwise, in which case the system cannot enter the desired
139 * sleep state.
140 *
141 * @wake: Called when the system has just left a sleep state, right after
142 * the nonboot CPUs have been enabled and before device drivers' early
143 * resume callbacks are executed.
144 * This callback is optional, but should be implemented by the platforms
145 * that implement @prepare_late(). If implemented, it is always called
146 * after @prepare_late and @enter(), even if one of them fails.
147 *
148 * @finish: Finish wake-up of the platform.
149 * @finish is called right prior to calling device drivers' regular suspend
150 * callbacks.
151 * This callback is optional, but should be implemented by the platforms
152 * that implement @prepare(). If implemented, it is always called after
153 * @enter() and @wake(), even if any of them fails. It is executed after
154 * a failing @prepare.
155 *
156 * @suspend_again: Returns whether the system should suspend again (true) or
157 * not (false). If the platform wants to poll sensors or execute some
158 * code during suspended without invoking userspace and most of devices,
159 * suspend_again callback is the place assuming that periodic-wakeup or
160 * alarm-wakeup is already setup. This allows to execute some codes while
161 * being kept suspended in the view of userland and devices.
162 *
163 * @end: Called by the PM core right after resuming devices, to indicate to
164 * the platform that the system has returned to the working state or
165 * the transition to the sleep state has been aborted.
166 * This callback is optional, but should be implemented by the platforms
167 * that implement @begin(). Accordingly, platforms implementing @begin()
168 * should also provide a @end() which cleans up transitions aborted before
169 * @enter().
170 *
171 * @recover: Recover the platform from a suspend failure.
172 * Called by the PM core if the suspending of devices fails.
173 * This callback is optional and should only be implemented by platforms
174 * which require special recovery actions in that situation.
175 */
176struct platform_suspend_ops {
177 int (*valid)(suspend_state_t state);
178 int (*begin)(suspend_state_t state);
179 int (*prepare)(void);
180 int (*prepare_late)(void);
181 int (*enter)(suspend_state_t state);
182 void (*wake)(void);
183 void (*finish)(void);
184 bool (*suspend_again)(void);
185 void (*end)(void);
186 void (*recover)(void);
187};
188
189struct platform_freeze_ops {
190 int (*begin)(void);
191 int (*prepare)(void);
192 void (*restore)(void);
193 void (*end)(void);
194};
195
196#ifdef CONFIG_SUSPEND
197/**
198 * suspend_set_ops - set platform dependent suspend operations
199 * @ops: The new suspend operations to set.
200 */
201extern void suspend_set_ops(const struct platform_suspend_ops *ops);
202extern int suspend_valid_only_mem(suspend_state_t state);
203
204extern unsigned int pm_suspend_global_flags;
205
206#define PM_SUSPEND_FLAG_FW_SUSPEND (1 << 0)
207#define PM_SUSPEND_FLAG_FW_RESUME (1 << 1)
208
209static inline void pm_suspend_clear_flags(void)
210{
211 pm_suspend_global_flags = 0;
212}
213
214static inline void pm_set_suspend_via_firmware(void)
215{
216 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
217}
218
219static inline void pm_set_resume_via_firmware(void)
220{
221 pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
222}
223
224static inline bool pm_suspend_via_firmware(void)
225{
226 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
227}
228
229static inline bool pm_resume_via_firmware(void)
230{
231 return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
232}
233
234/* Suspend-to-idle state machnine. */
235enum freeze_state {
236 FREEZE_STATE_NONE, /* Not suspended/suspending. */
237 FREEZE_STATE_ENTER, /* Enter suspend-to-idle. */
238 FREEZE_STATE_WAKE, /* Wake up from suspend-to-idle. */
239};
240
241extern enum freeze_state __read_mostly suspend_freeze_state;
242
243static inline bool idle_should_freeze(void)
244{
245 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER);
246}
247
248extern void __init pm_states_init(void);
249extern void freeze_set_ops(const struct platform_freeze_ops *ops);
250extern void freeze_wake(void);
251
252/**
253 * arch_suspend_disable_irqs - disable IRQs for suspend
254 *
255 * Disables IRQs (in the default case). This is a weak symbol in the common
256 * code and thus allows architectures to override it if more needs to be
257 * done. Not called for suspend to disk.
258 */
259extern void arch_suspend_disable_irqs(void);
260
261/**
262 * arch_suspend_enable_irqs - enable IRQs after suspend
263 *
264 * Enables IRQs (in the default case). This is a weak symbol in the common
265 * code and thus allows architectures to override it if more needs to be
266 * done. Not called for suspend to disk.
267 */
268extern void arch_suspend_enable_irqs(void);
269
270extern int pm_suspend(suspend_state_t state);
271#else /* !CONFIG_SUSPEND */
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 __init pm_states_init(void) {}
284static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {}
285static inline void freeze_wake(void) {}
286#endif /* !CONFIG_SUSPEND */
287
288/* struct pbe is used for creating lists of pages that should be restored
289 * atomically during the resume from disk, because the page frames they have
290 * occupied before the suspend are in use.
291 */
292struct pbe {
293 void *address; /* address of the copy */
294 void *orig_address; /* original address of a page */
295 struct pbe *next;
296};
297
298/* mm/page_alloc.c */
299extern void mark_free_pages(struct zone *zone);
300
301/**
302 * struct platform_hibernation_ops - hibernation platform support
303 *
304 * The methods in this structure allow a platform to carry out special
305 * operations required by it during a hibernation transition.
306 *
307 * All the methods below, except for @recover(), must be implemented.
308 *
309 * @begin: Tell the platform driver that we're starting hibernation.
310 * Called right after shrinking memory and before freezing devices.
311 *
312 * @end: Called by the PM core right after resuming devices, to indicate to
313 * the platform that the system has returned to the working state.
314 *
315 * @pre_snapshot: Prepare the platform for creating the hibernation image.
316 * Called right after devices have been frozen and before the nonboot
317 * CPUs are disabled (runs with IRQs on).
318 *
319 * @finish: Restore the previous state of the platform after the hibernation
320 * image has been created *or* put the platform into the normal operation
321 * mode after the hibernation (the same method is executed in both cases).
322 * Called right after the nonboot CPUs have been enabled and before
323 * thawing devices (runs with IRQs on).
324 *
325 * @prepare: Prepare the platform for entering the low power state.
326 * Called right after the hibernation image has been saved and before
327 * devices are prepared for entering the low power state.
328 *
329 * @enter: Put the system into the low power state after the hibernation image
330 * has been saved to disk.
331 * Called after the nonboot CPUs have been disabled and all of the low
332 * level devices have been shut down (runs with IRQs off).
333 *
334 * @leave: Perform the first stage of the cleanup after the system sleep state
335 * indicated by @set_target() has been left.
336 * Called right after the control has been passed from the boot kernel to
337 * the image kernel, before the nonboot CPUs are enabled and before devices
338 * are resumed. Executed with interrupts disabled.
339 *
340 * @pre_restore: Prepare system for the restoration from a hibernation image.
341 * Called right after devices have been frozen and before the nonboot
342 * CPUs are disabled (runs with IRQs on).
343 *
344 * @restore_cleanup: Clean up after a failing image restoration.
345 * Called right after the nonboot CPUs have been enabled and before
346 * thawing devices (runs with IRQs on).
347 *
348 * @recover: Recover the platform from a failure to suspend devices.
349 * Called by the PM core if the suspending of devices during hibernation
350 * fails. This callback is optional and should only be implemented by
351 * platforms which require special recovery actions in that situation.
352 */
353struct platform_hibernation_ops {
354 int (*begin)(void);
355 void (*end)(void);
356 int (*pre_snapshot)(void);
357 void (*finish)(void);
358 int (*prepare)(void);
359 int (*enter)(void);
360 void (*leave)(void);
361 int (*pre_restore)(void);
362 void (*restore_cleanup)(void);
363 void (*recover)(void);
364};
365
366#ifdef CONFIG_HIBERNATION
367/* kernel/power/snapshot.c */
368extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
369static inline void __init register_nosave_region(unsigned long b, unsigned long e)
370{
371 __register_nosave_region(b, e, 0);
372}
373static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
374{
375 __register_nosave_region(b, e, 1);
376}
377extern int swsusp_page_is_forbidden(struct page *);
378extern void swsusp_set_page_free(struct page *);
379extern void swsusp_unset_page_free(struct page *);
380extern unsigned long get_safe_page(gfp_t gfp_mask);
381
382extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
383extern int hibernate(void);
384extern bool system_entering_hibernation(void);
385extern bool hibernation_available(void);
386asmlinkage int swsusp_save(void);
387extern struct pbe *restore_pblist;
388#else /* CONFIG_HIBERNATION */
389static inline void register_nosave_region(unsigned long b, unsigned long e) {}
390static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
391static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
392static inline void swsusp_set_page_free(struct page *p) {}
393static inline void swsusp_unset_page_free(struct page *p) {}
394
395static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
396static inline int hibernate(void) { return -ENOSYS; }
397static inline bool system_entering_hibernation(void) { return false; }
398static inline bool hibernation_available(void) { return false; }
399#endif /* CONFIG_HIBERNATION */
400
401/* Hibernation and suspend events */
402#define PM_HIBERNATION_PREPARE 0x0001 /* Going to hibernate */
403#define PM_POST_HIBERNATION 0x0002 /* Hibernation finished */
404#define PM_SUSPEND_PREPARE 0x0003 /* Going to suspend the system */
405#define PM_POST_SUSPEND 0x0004 /* Suspend finished */
406#define PM_RESTORE_PREPARE 0x0005 /* Going to restore a saved image */
407#define PM_POST_RESTORE 0x0006 /* Restore failed */
408
409extern struct mutex pm_mutex;
410
411#ifdef CONFIG_PM_SLEEP
412void save_processor_state(void);
413void restore_processor_state(void);
414
415/* kernel/power/main.c */
416extern int register_pm_notifier(struct notifier_block *nb);
417extern int unregister_pm_notifier(struct notifier_block *nb);
418
419#define pm_notifier(fn, pri) { \
420 static struct notifier_block fn##_nb = \
421 { .notifier_call = fn, .priority = pri }; \
422 register_pm_notifier(&fn##_nb); \
423}
424
425/* drivers/base/power/wakeup.c */
426extern bool events_check_enabled;
427extern unsigned int pm_wakeup_irq;
428
429extern bool pm_wakeup_pending(void);
430extern void pm_system_wakeup(void);
431extern void pm_wakeup_clear(void);
432extern void pm_system_irq_wakeup(unsigned int irq_number);
433extern bool pm_get_wakeup_count(unsigned int *count, bool block);
434extern bool pm_save_wakeup_count(unsigned int count);
435extern void pm_wakep_autosleep_enabled(bool set);
436extern void pm_print_active_wakeup_sources(void);
437
438static inline void lock_system_sleep(void)
439{
440 current->flags |= PF_FREEZER_SKIP;
441 mutex_lock(&pm_mutex);
442}
443
444static inline void unlock_system_sleep(void)
445{
446 /*
447 * Don't use freezer_count() because we don't want the call to
448 * try_to_freeze() here.
449 *
450 * Reason:
451 * Fundamentally, we just don't need it, because freezing condition
452 * doesn't come into effect until we release the pm_mutex lock,
453 * since the freezer always works with pm_mutex held.
454 *
455 * More importantly, in the case of hibernation,
456 * unlock_system_sleep() gets called in snapshot_read() and
457 * snapshot_write() when the freezing condition is still in effect.
458 * Which means, if we use try_to_freeze() here, it would make them
459 * enter the refrigerator, thus causing hibernation to lockup.
460 */
461 current->flags &= ~PF_FREEZER_SKIP;
462 mutex_unlock(&pm_mutex);
463}
464
465#else /* !CONFIG_PM_SLEEP */
466
467static inline int register_pm_notifier(struct notifier_block *nb)
468{
469 return 0;
470}
471
472static inline int unregister_pm_notifier(struct notifier_block *nb)
473{
474 return 0;
475}
476
477#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
478
479static inline bool pm_wakeup_pending(void) { return false; }
480static inline void pm_system_wakeup(void) {}
481static inline void pm_wakeup_clear(void) {}
482static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
483
484static inline void lock_system_sleep(void) {}
485static inline void unlock_system_sleep(void) {}
486
487#endif /* !CONFIG_PM_SLEEP */
488
489#ifdef CONFIG_PM_SLEEP_DEBUG
490extern bool pm_print_times_enabled;
491#else
492#define pm_print_times_enabled (false)
493#endif
494
495#ifdef CONFIG_PM_AUTOSLEEP
496
497/* kernel/power/autosleep.c */
498void queue_up_suspend_work(void);
499
500#else /* !CONFIG_PM_AUTOSLEEP */
501
502static inline void queue_up_suspend_work(void) {}
503
504#endif /* !CONFIG_PM_AUTOSLEEP */
505
506#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
507/*
508 * The ARCH_SAVE_PAGE_KEYS functions can be used by an architecture
509 * to save/restore additional information to/from the array of page
510 * frame numbers in the hibernation image. For s390 this is used to
511 * save and restore the storage key for each page that is included
512 * in the hibernation image.
513 */
514unsigned long page_key_additional_pages(unsigned long pages);
515int page_key_alloc(unsigned long pages);
516void page_key_free(void);
517void page_key_read(unsigned long *pfn);
518void page_key_memorize(unsigned long *pfn);
519void page_key_write(void *address);
520
521#else /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
522
523static inline unsigned long page_key_additional_pages(unsigned long pages)
524{
525 return 0;
526}
527
528static inline int page_key_alloc(unsigned long pages)
529{
530 return 0;
531}
532
533static inline void page_key_free(void) {}
534static inline void page_key_read(unsigned long *pfn) {}
535static inline void page_key_memorize(unsigned long *pfn) {}
536static inline void page_key_write(void *address) {}
537
538#endif /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
539
540#endif /* _LINUX_SUSPEND_H */