blob: 5efe743ce1e88fc544cd4d98b2100861f1774105 [file] [log] [blame]
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -07001#ifndef _LINUX_SUSPEND_H
2#define _LINUX_SUSPEND_H
Linus Torvalds1da177e2005-04-16 15:20:36 -07003
Linus Torvalds1da177e2005-04-16 15:20:36 -07004#include <linux/swap.h>
5#include <linux/notifier.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006#include <linux/init.h>
7#include <linux/pm.h>
Rafael J. Wysocki7be98232007-05-06 14:50:42 -07008#include <linux/mm.h>
Srivatsa S. Bhat33e638b2011-12-06 23:18:12 +01009#include <linux/freezer.h>
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070010#include <asm/errno.h>
11
H Hartley Sweeten37cce262011-09-21 22:47:55 +020012#ifdef CONFIG_VT
Andres Salomonb6f448e2008-04-28 02:15:03 -070013extern void pm_set_vt_switch(int);
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070014#else
Andres Salomonb6f448e2008-04-28 02:15:03 -070015static inline void pm_set_vt_switch(int do_switch)
16{
17}
H Hartley Sweeten37cce262011-09-21 22:47:55 +020018#endif
Andres Salomonb6f448e2008-04-28 02:15:03 -070019
H Hartley Sweeten37cce262011-09-21 22:47:55 +020020#ifdef CONFIG_VT_CONSOLE_SLEEP
21extern int pm_prepare_console(void);
22extern void pm_restore_console(void);
23#else
Andres Salomonb6f448e2008-04-28 02:15:03 -070024static inline int pm_prepare_console(void)
25{
26 return 0;
27}
28
29static inline void pm_restore_console(void)
30{
31}
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070032#endif
33
34typedef int __bitwise suspend_state_t;
35
36#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
Zhang Rui7e73c5a2013-02-06 13:00:36 +010037#define PM_SUSPEND_FREEZE ((__force suspend_state_t) 1)
38#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070039#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
Zhang Rui7e73c5a2013-02-06 13:00:36 +010040#define PM_SUSPEND_MIN PM_SUSPEND_FREEZE
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070041#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
42
ShuoX Liu2a77c462011-08-10 23:01:26 +020043enum suspend_stat_step {
44 SUSPEND_FREEZE = 1,
45 SUSPEND_PREPARE,
46 SUSPEND_SUSPEND,
Rafael J. Wysockicf579df2012-01-29 20:38:29 +010047 SUSPEND_SUSPEND_LATE,
ShuoX Liu2a77c462011-08-10 23:01:26 +020048 SUSPEND_SUSPEND_NOIRQ,
49 SUSPEND_RESUME_NOIRQ,
Rafael J. Wysockicf579df2012-01-29 20:38:29 +010050 SUSPEND_RESUME_EARLY,
ShuoX Liu2a77c462011-08-10 23:01:26 +020051 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;
Rafael J. Wysockicf579df2012-01-29 20:38:29 +010060 int failed_suspend_late;
ShuoX Liu2a77c462011-08-10 23:01:26 +020061 int failed_suspend_noirq;
62 int failed_resume;
Rafael J. Wysockicf579df2012-01-29 20:38:29 +010063 int failed_resume_early;
ShuoX Liu2a77c462011-08-10 23:01:26 +020064 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
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -070099/**
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700100 * struct platform_suspend_ops - Callbacks for managing platform dependent
101 * system sleep states.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700102 *
103 * @valid: Callback to determine if given system sleep state is supported by
104 * the platform.
105 * Valid (ie. supported) states are advertised in /sys/power/state. Note
106 * that it still may be impossible to enter given system sleep state if the
107 * conditions aren't right.
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700108 * There is the %suspend_valid_only_mem function available that can be
109 * assigned to this if the platform only supports mem sleep.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700110 *
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100111 * @begin: Initialise a transition to given system sleep state.
112 * @begin() is executed right prior to suspending devices. The information
113 * conveyed to the platform code by @begin() should be disregarded by it as
114 * soon as @end() is executed. If @begin() fails (ie. returns nonzero),
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700115 * @prepare(), @enter() and @finish() will not be called by the PM core.
116 * This callback is optional. However, if it is implemented, the argument
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100117 * passed to @enter() is redundant and should be ignored.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700118 *
119 * @prepare: Prepare the platform for entering the system sleep state indicated
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100120 * by @begin().
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700121 * @prepare() is called right after devices have been suspended (ie. the
122 * appropriate .suspend() method has been executed for each device) and
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200123 * before device drivers' late suspend callbacks are executed. It returns
124 * 0 on success or a negative error code otherwise, in which case the
125 * system cannot enter the desired sleep state (@prepare_late(), @enter(),
Rafael J. Wysockice441012010-07-07 23:43:45 +0200126 * and @wake() will not be called in that case).
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200127 *
128 * @prepare_late: Finish preparing the platform for entering the system sleep
129 * state indicated by @begin().
130 * @prepare_late is called before disabling nonboot CPUs and after
131 * device drivers' late suspend callbacks have been executed. It returns
132 * 0 on success or a negative error code otherwise, in which case the
Rafael J. Wysockice441012010-07-07 23:43:45 +0200133 * system cannot enter the desired sleep state (@enter() will not be
134 * executed).
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700135 *
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100136 * @enter: Enter the system sleep state indicated by @begin() or represented by
137 * the argument if @begin() is not implemented.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700138 * This callback is mandatory. It returns 0 on success or a negative
139 * error code otherwise, in which case the system cannot enter the desired
140 * sleep state.
141 *
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200142 * @wake: Called when the system has just left a sleep state, right after
143 * the nonboot CPUs have been enabled and before device drivers' early
144 * resume callbacks are executed.
145 * This callback is optional, but should be implemented by the platforms
146 * that implement @prepare_late(). If implemented, it is always called
Rafael J. Wysockice441012010-07-07 23:43:45 +0200147 * after @prepare_late and @enter(), even if one of them fails.
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200148 *
149 * @finish: Finish wake-up of the platform.
150 * @finish is called right prior to calling device drivers' regular suspend
151 * callbacks.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700152 * This callback is optional, but should be implemented by the platforms
153 * that implement @prepare(). If implemented, it is always called after
Rafael J. Wysockice441012010-07-07 23:43:45 +0200154 * @enter() and @wake(), even if any of them fails. It is executed after
155 * a failing @prepare.
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100156 *
MyungJoo Ham3b5fe852011-06-12 15:57:05 +0200157 * @suspend_again: Returns whether the system should suspend again (true) or
158 * not (false). If the platform wants to poll sensors or execute some
159 * code during suspended without invoking userspace and most of devices,
160 * suspend_again callback is the place assuming that periodic-wakeup or
161 * alarm-wakeup is already setup. This allows to execute some codes while
162 * being kept suspended in the view of userland and devices.
163 *
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100164 * @end: Called by the PM core right after resuming devices, to indicate to
165 * the platform that the system has returned to the working state or
166 * the transition to the sleep state has been aborted.
167 * This callback is optional, but should be implemented by the platforms
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200168 * that implement @begin(). Accordingly, platforms implementing @begin()
169 * should also provide a @end() which cleans up transitions aborted before
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100170 * @enter().
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200171 *
172 * @recover: Recover the platform from a suspend failure.
173 * Called by the PM core if the suspending of devices fails.
174 * This callback is optional and should only be implemented by platforms
175 * which require special recovery actions in that situation.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700176 */
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700177struct platform_suspend_ops {
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700178 int (*valid)(suspend_state_t state);
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100179 int (*begin)(suspend_state_t state);
Rafael J. Wysockie6c5eb92007-10-18 03:04:41 -0700180 int (*prepare)(void);
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200181 int (*prepare_late)(void);
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700182 int (*enter)(suspend_state_t state);
Rafael J. Wysocki6a7c7ea2009-04-19 20:08:42 +0200183 void (*wake)(void);
Rafael J. Wysockie6c5eb92007-10-18 03:04:41 -0700184 void (*finish)(void);
MyungJoo Ham3b5fe852011-06-12 15:57:05 +0200185 bool (*suspend_again)(void);
Rafael J. Wysockic697eec2008-01-08 00:04:17 +0100186 void (*end)(void);
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200187 void (*recover)(void);
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700188};
189
Rafael J. Wysocki1f0b6382014-05-15 23:29:57 +0200190struct platform_freeze_ops {
191 int (*begin)(void);
Rafael J. Wysockia8d46b92014-09-30 02:29:01 +0200192 int (*prepare)(void);
193 void (*restore)(void);
Rafael J. Wysocki1f0b6382014-05-15 23:29:57 +0200194 void (*end)(void);
195};
196
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700197#ifdef CONFIG_SUSPEND
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700198/**
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700199 * suspend_set_ops - set platform dependent suspend operations
200 * @ops: The new suspend operations to set.
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700201 */
Lionel Debroux2f55ac02010-11-16 14:14:02 +0100202extern void suspend_set_ops(const struct platform_suspend_ops *ops);
Rafael J. Wysocki26398a72007-10-18 03:04:40 -0700203extern int suspend_valid_only_mem(suspend_state_t state);
Rafael J. Wysocki38106312015-02-12 23:33:15 +0100204
205/* Suspend-to-idle state machnine. */
206enum freeze_state {
207 FREEZE_STATE_NONE, /* Not suspended/suspending. */
208 FREEZE_STATE_ENTER, /* Enter suspend-to-idle. */
209 FREEZE_STATE_WAKE, /* Wake up from suspend-to-idle. */
210};
211
212extern enum freeze_state __read_mostly suspend_freeze_state;
213
214static inline bool idle_should_freeze(void)
215{
216 return unlikely(suspend_freeze_state == FREEZE_STATE_ENTER);
217}
218
Rafael J. Wysocki1f0b6382014-05-15 23:29:57 +0200219extern void freeze_set_ops(const struct platform_freeze_ops *ops);
Zhang Rui7e73c5a2013-02-06 13:00:36 +0100220extern void freeze_wake(void);
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700221
222/**
223 * arch_suspend_disable_irqs - disable IRQs for suspend
224 *
225 * Disables IRQs (in the default case). This is a weak symbol in the common
226 * code and thus allows architectures to override it if more needs to be
227 * done. Not called for suspend to disk.
228 */
229extern void arch_suspend_disable_irqs(void);
230
231/**
232 * arch_suspend_enable_irqs - enable IRQs after suspend
233 *
234 * Enables IRQs (in the default case). This is a weak symbol in the common
235 * code and thus allows architectures to override it if more needs to be
236 * done. Not called for suspend to disk.
237 */
238extern void arch_suspend_enable_irqs(void);
239
240extern int pm_suspend(suspend_state_t state);
241#else /* !CONFIG_SUSPEND */
242#define suspend_valid_only_mem NULL
243
Lionel Debroux2f55ac02010-11-16 14:14:02 +0100244static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700245static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
Rafael J. Wysocki38106312015-02-12 23:33:15 +0100246static inline bool idle_should_freeze(void) { return false; }
Rafael J. Wysocki1f0b6382014-05-15 23:29:57 +0200247static inline void freeze_set_ops(const struct platform_freeze_ops *ops) {}
Zhang Rui7e73c5a2013-02-06 13:00:36 +0100248static inline void freeze_wake(void) {}
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700249#endif /* !CONFIG_SUSPEND */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250
Rafael J. Wysocki83573762006-12-06 20:34:18 -0800251/* struct pbe is used for creating lists of pages that should be restored
252 * atomically during the resume from disk, because the page frames they have
253 * occupied before the suspend are in use.
254 */
Rafael J. Wysockidcbb5a52006-09-25 23:32:51 -0700255struct pbe {
Rafael J. Wysocki83573762006-12-06 20:34:18 -0800256 void *address; /* address of the copy */
257 void *orig_address; /* original address of a page */
Rafael J. Wysocki7088a5c2006-01-06 00:13:05 -0800258 struct pbe *next;
Rafael J. Wysockidcbb5a52006-09-25 23:32:51 -0700259};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261/* mm/page_alloc.c */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262extern void mark_free_pages(struct zone *zone);
263
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700264/**
Rafael J. Wysockib3dac3b2007-10-18 03:04:43 -0700265 * struct platform_hibernation_ops - hibernation platform support
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700266 *
Rafael J. Wysockicaea99e2008-01-08 00:08:44 +0100267 * The methods in this structure allow a platform to carry out special
268 * operations required by it during a hibernation transition.
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700269 *
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200270 * All the methods below, except for @recover(), must be implemented.
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700271 *
Rafael J. Wysockicaea99e2008-01-08 00:08:44 +0100272 * @begin: Tell the platform driver that we're starting hibernation.
Rafael J. Wysocki74f270a2007-10-18 03:04:42 -0700273 * Called right after shrinking memory and before freezing devices.
274 *
Rafael J. Wysockicaea99e2008-01-08 00:08:44 +0100275 * @end: Called by the PM core right after resuming devices, to indicate to
276 * the platform that the system has returned to the working state.
277 *
Rafael J. Wysocki74f270a2007-10-18 03:04:42 -0700278 * @pre_snapshot: Prepare the platform for creating the hibernation image.
279 * Called right after devices have been frozen and before the nonboot
280 * CPUs are disabled (runs with IRQs on).
281 *
282 * @finish: Restore the previous state of the platform after the hibernation
283 * image has been created *or* put the platform into the normal operation
284 * mode after the hibernation (the same method is executed in both cases).
285 * Called right after the nonboot CPUs have been enabled and before
286 * thawing devices (runs with IRQs on).
287 *
288 * @prepare: Prepare the platform for entering the low power state.
289 * Called right after the hibernation image has been saved and before
290 * devices are prepared for entering the low power state.
291 *
292 * @enter: Put the system into the low power state after the hibernation image
293 * has been saved to disk.
294 * Called after the nonboot CPUs have been disabled and all of the low
295 * level devices have been shut down (runs with IRQs off).
296 *
Rafael J. Wysockic7e08312007-10-18 03:04:55 -0700297 * @leave: Perform the first stage of the cleanup after the system sleep state
298 * indicated by @set_target() has been left.
299 * Called right after the control has been passed from the boot kernel to
300 * the image kernel, before the nonboot CPUs are enabled and before devices
301 * are resumed. Executed with interrupts disabled.
302 *
Rafael J. Wysocki74f270a2007-10-18 03:04:42 -0700303 * @pre_restore: Prepare system for the restoration from a hibernation image.
304 * Called right after devices have been frozen and before the nonboot
305 * CPUs are disabled (runs with IRQs on).
306 *
307 * @restore_cleanup: Clean up after a failing image restoration.
308 * Called right after the nonboot CPUs have been enabled and before
309 * thawing devices (runs with IRQs on).
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200310 *
311 * @recover: Recover the platform from a failure to suspend devices.
312 * Called by the PM core if the suspending of devices during hibernation
313 * fails. This callback is optional and should only be implemented by
314 * platforms which require special recovery actions in that situation.
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700315 */
Rafael J. Wysockib3dac3b2007-10-18 03:04:43 -0700316struct platform_hibernation_ops {
Rafael J. Wysockicaea99e2008-01-08 00:08:44 +0100317 int (*begin)(void);
318 void (*end)(void);
Rafael J. Wysocki74f270a2007-10-18 03:04:42 -0700319 int (*pre_snapshot)(void);
320 void (*finish)(void);
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700321 int (*prepare)(void);
322 int (*enter)(void);
Rafael J. Wysockic7e08312007-10-18 03:04:55 -0700323 void (*leave)(void);
Rafael J. Wysockia634cc12007-07-19 01:47:30 -0700324 int (*pre_restore)(void);
325 void (*restore_cleanup)(void);
Rafael J. Wysockid8f3de02008-06-12 23:24:06 +0200326 void (*recover)(void);
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700327};
328
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200329#ifdef CONFIG_HIBERNATION
Rafael J. Wysocki74dfd662007-05-06 14:50:43 -0700330/* kernel/power/snapshot.c */
Johannes Berg940d67f2007-05-08 19:23:49 +1000331extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
Marcin Slusarzce289e82008-08-15 00:40:19 -0700332static inline void __init register_nosave_region(unsigned long b, unsigned long e)
Johannes Berg940d67f2007-05-08 19:23:49 +1000333{
334 __register_nosave_region(b, e, 0);
335}
Marcin Slusarzce289e82008-08-15 00:40:19 -0700336static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
Johannes Berg940d67f2007-05-08 19:23:49 +1000337{
338 __register_nosave_region(b, e, 1);
339}
Rafael J. Wysocki74dfd662007-05-06 14:50:43 -0700340extern int swsusp_page_is_forbidden(struct page *);
341extern void swsusp_set_page_free(struct page *);
342extern void swsusp_unset_page_free(struct page *);
343extern unsigned long get_safe_page(gfp_t gfp_mask);
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700344
Lionel Debroux073ef1f2010-11-09 21:48:49 +0100345extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700346extern int hibernate(void);
Rafael J. Wysockiabfe2d72009-01-19 20:54:54 +0100347extern bool system_entering_hibernation(void);
Kees Cooka6e15a32014-06-13 13:30:35 -0700348extern bool hibernation_available(void);
Sebastian Capella603fb422014-03-25 01:20:29 +0100349asmlinkage int swsusp_save(void);
350extern struct pbe *restore_pblist;
Rafael J. Wysockib0cb1a12007-07-29 23:24:36 +0200351#else /* CONFIG_HIBERNATION */
Rafael J. Wysocki1f112ce2011-04-11 22:54:42 +0200352static inline void register_nosave_region(unsigned long b, unsigned long e) {}
353static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
Rafael J. Wysocki74dfd662007-05-06 14:50:43 -0700354static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
355static inline void swsusp_set_page_free(struct page *p) {}
356static inline void swsusp_unset_page_free(struct page *p) {}
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700357
Lionel Debroux073ef1f2010-11-09 21:48:49 +0100358static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
Rafael J. Wysockia3d25c22007-05-09 02:33:18 -0700359static inline int hibernate(void) { return -ENOSYS; }
Cornelia Huckfce2b1112009-06-10 01:28:19 +0200360static inline bool system_entering_hibernation(void) { return false; }
Kees Cooka6e15a32014-06-13 13:30:35 -0700361static inline bool hibernation_available(void) { return false; }
Cornelia Huckfce2b1112009-06-10 01:28:19 +0200362#endif /* CONFIG_HIBERNATION */
363
Amerigo Wang35eb6db2011-07-25 17:13:11 -0700364/* Hibernation and suspend events */
365#define PM_HIBERNATION_PREPARE 0x0001 /* Going to hibernate */
366#define PM_POST_HIBERNATION 0x0002 /* Hibernation finished */
367#define PM_SUSPEND_PREPARE 0x0003 /* Going to suspend the system */
368#define PM_POST_SUSPEND 0x0004 /* Suspend finished */
369#define PM_RESTORE_PREPARE 0x0005 /* Going to restore a saved image */
370#define PM_POST_RESTORE 0x0006 /* Restore failed */
371
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100372extern struct mutex pm_mutex;
373
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200374#ifdef CONFIG_PM_SLEEP
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375void save_processor_state(void);
376void restore_processor_state(void);
Rafael J. Wysocki25761b62005-10-30 14:59:56 -0800377
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700378/* kernel/power/main.c */
Alan Stern82525752007-11-19 23:49:18 +0100379extern int register_pm_notifier(struct notifier_block *nb);
380extern int unregister_pm_notifier(struct notifier_block *nb);
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700381
382#define pm_notifier(fn, pri) { \
383 static struct notifier_block fn##_nb = \
384 { .notifier_call = fn, .priority = pri }; \
385 register_pm_notifier(&fn##_nb); \
386}
Rafael J. Wysockic125e962010-07-05 22:43:53 +0200387
388/* drivers/base/power/wakeup.c */
389extern bool events_check_enabled;
390
Rafael J. Wysockia2867e02010-12-03 22:58:31 +0100391extern bool pm_wakeup_pending(void);
Rafael J. Wysocki068765b2014-09-01 13:47:49 +0200392extern void pm_system_wakeup(void);
393extern void pm_wakeup_clear(void);
Rafael J. Wysocki7483b4a2012-04-29 22:53:22 +0200394extern bool pm_get_wakeup_count(unsigned int *count, bool block);
Rafael J. Wysocki074037e2010-09-22 22:09:10 +0200395extern bool pm_save_wakeup_count(unsigned int count);
Rafael J. Wysocki55850942012-04-29 22:53:32 +0200396extern void pm_wakep_autosleep_enabled(bool set);
Julius Wernerbb177fe2013-06-12 12:55:22 -0700397extern void pm_print_active_wakeup_sources(void);
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100398
399static inline void lock_system_sleep(void)
400{
Srivatsa S. Bhat72081622012-01-19 23:25:33 +0100401 current->flags |= PF_FREEZER_SKIP;
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100402 mutex_lock(&pm_mutex);
403}
404
405static inline void unlock_system_sleep(void)
406{
Srivatsa S. Bhat72081622012-01-19 23:25:33 +0100407 /*
408 * Don't use freezer_count() because we don't want the call to
409 * try_to_freeze() here.
410 *
411 * Reason:
412 * Fundamentally, we just don't need it, because freezing condition
413 * doesn't come into effect until we release the pm_mutex lock,
414 * since the freezer always works with pm_mutex held.
415 *
416 * More importantly, in the case of hibernation,
417 * unlock_system_sleep() gets called in snapshot_read() and
418 * snapshot_write() when the freezing condition is still in effect.
419 * Which means, if we use try_to_freeze() here, it would make them
420 * enter the refrigerator, thus causing hibernation to lockup.
421 */
422 current->flags &= ~PF_FREEZER_SKIP;
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100423 mutex_unlock(&pm_mutex);
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100424}
425
Rafael J. Wysocki296699d2007-07-29 23:27:18 +0200426#else /* !CONFIG_PM_SLEEP */
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700427
428static inline int register_pm_notifier(struct notifier_block *nb)
429{
430 return 0;
431}
432
433static inline int unregister_pm_notifier(struct notifier_block *nb)
434{
435 return 0;
436}
437
438#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
Rafael J. Wysockidbeeec52010-10-04 22:07:32 +0200439
Rafael J. Wysockia2867e02010-12-03 22:58:31 +0100440static inline bool pm_wakeup_pending(void) { return false; }
Rafael J. Wysocki068765b2014-09-01 13:47:49 +0200441static inline void pm_system_wakeup(void) {}
442static inline void pm_wakeup_clear(void) {}
Rafael J. Wysockib10d9112007-07-19 01:47:36 -0700443
Andi Kleen6ad696d2009-11-17 14:06:22 -0800444static inline void lock_system_sleep(void) {}
445static inline void unlock_system_sleep(void) {}
446
Srivatsa S. Bhat9b6fc5d2011-12-06 23:24:38 +0100447#endif /* !CONFIG_PM_SLEEP */
Huang Ying89081d12008-07-25 19:45:10 -0700448
Rafael J. Wysockib2df1d42012-06-21 00:19:33 +0200449#ifdef CONFIG_PM_SLEEP_DEBUG
450extern bool pm_print_times_enabled;
451#else
452#define pm_print_times_enabled (false)
453#endif
454
Rafael J. Wysocki7483b4a2012-04-29 22:53:22 +0200455#ifdef CONFIG_PM_AUTOSLEEP
456
457/* kernel/power/autosleep.c */
458void queue_up_suspend_work(void);
459
460#else /* !CONFIG_PM_AUTOSLEEP */
461
462static inline void queue_up_suspend_work(void) {}
463
464#endif /* !CONFIG_PM_AUTOSLEEP */
465
Martin Schwidefsky85055dd2011-08-17 20:42:24 +0200466#ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
467/*
468 * The ARCH_SAVE_PAGE_KEYS functions can be used by an architecture
469 * to save/restore additional information to/from the array of page
470 * frame numbers in the hibernation image. For s390 this is used to
471 * save and restore the storage key for each page that is included
472 * in the hibernation image.
473 */
474unsigned long page_key_additional_pages(unsigned long pages);
475int page_key_alloc(unsigned long pages);
476void page_key_free(void);
477void page_key_read(unsigned long *pfn);
478void page_key_memorize(unsigned long *pfn);
479void page_key_write(void *address);
480
481#else /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
482
483static inline unsigned long page_key_additional_pages(unsigned long pages)
484{
485 return 0;
486}
487
488static inline int page_key_alloc(unsigned long pages)
489{
490 return 0;
491}
492
493static inline void page_key_free(void) {}
494static inline void page_key_read(unsigned long *pfn) {}
495static inline void page_key_memorize(unsigned long *pfn) {}
496static inline void page_key_write(void *address) {}
497
498#endif /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
499
Rafael J. Wysocki95d9ffb2007-10-18 03:04:39 -0700500#endif /* _LINUX_SUSPEND_H */