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