kexec jump: save/restore device state
[linux-2.6.git] / include / linux / suspend.h
1 #ifndef _LINUX_SUSPEND_H
2 #define _LINUX_SUSPEND_H
3
4 #if defined(CONFIG_X86) || defined(CONFIG_FRV) || defined(CONFIG_PPC32) || defined(CONFIG_PPC64)
5 #include <asm/suspend.h>
6 #endif
7 #include <linux/swap.h>
8 #include <linux/notifier.h>
9 #include <linux/init.h>
10 #include <linux/pm.h>
11 #include <linux/mm.h>
12 #include <asm/errno.h>
13
14 #if defined(CONFIG_PM_SLEEP) && defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
15 extern void pm_set_vt_switch(int);
16 extern int pm_prepare_console(void);
17 extern void pm_restore_console(void);
18 #else
19 static inline void pm_set_vt_switch(int do_switch)
20 {
21 }
22
23 static inline int pm_prepare_console(void)
24 {
25         return 0;
26 }
27
28 static inline void pm_restore_console(void)
29 {
30 }
31 #endif
32
33 typedef int __bitwise suspend_state_t;
34
35 #define PM_SUSPEND_ON           ((__force suspend_state_t) 0)
36 #define PM_SUSPEND_STANDBY      ((__force suspend_state_t) 1)
37 #define PM_SUSPEND_MEM          ((__force suspend_state_t) 3)
38 #define PM_SUSPEND_MAX          ((__force suspend_state_t) 4)
39
40 /**
41  * struct platform_suspend_ops - Callbacks for managing platform dependent
42  *      system sleep states.
43  *
44  * @valid: Callback to determine if given system sleep state is supported by
45  *      the platform.
46  *      Valid (ie. supported) states are advertised in /sys/power/state.  Note
47  *      that it still may be impossible to enter given system sleep state if the
48  *      conditions aren't right.
49  *      There is the %suspend_valid_only_mem function available that can be
50  *      assigned to this if the platform only supports mem sleep.
51  *
52  * @begin: Initialise a transition to given system sleep state.
53  *      @begin() is executed right prior to suspending devices.  The information
54  *      conveyed to the platform code by @begin() should be disregarded by it as
55  *      soon as @end() is executed.  If @begin() fails (ie. returns nonzero),
56  *      @prepare(), @enter() and @finish() will not be called by the PM core.
57  *      This callback is optional.  However, if it is implemented, the argument
58  *      passed to @enter() is redundant and should be ignored.
59  *
60  * @prepare: Prepare the platform for entering the system sleep state indicated
61  *      by @begin().
62  *      @prepare() is called right after devices have been suspended (ie. the
63  *      appropriate .suspend() method has been executed for each device) and
64  *      before the nonboot CPUs are disabled (it is executed with IRQs enabled).
65  *      This callback is optional.  It returns 0 on success or a negative
66  *      error code otherwise, in which case the system cannot enter the desired
67  *      sleep state (@enter() and @finish() will not be called in that case).
68  *
69  * @enter: Enter the system sleep state indicated by @begin() or represented by
70  *      the argument if @begin() is not implemented.
71  *      This callback is mandatory.  It returns 0 on success or a negative
72  *      error code otherwise, in which case the system cannot enter the desired
73  *      sleep state.
74  *
75  * @finish: Called when the system has just left a sleep state, right after
76  *      the nonboot CPUs have been enabled and before devices are resumed (it is
77  *      executed with IRQs enabled).
78  *      This callback is optional, but should be implemented by the platforms
79  *      that implement @prepare().  If implemented, it is always called after
80  *      @enter() (even if @enter() fails).
81  *
82  * @end: Called by the PM core right after resuming devices, to indicate to
83  *      the platform that the system has returned to the working state or
84  *      the transition to the sleep state has been aborted.
85  *      This callback is optional, but should be implemented by the platforms
86  *      that implement @begin(), but platforms implementing @begin() should
87  *      also provide a @end() which cleans up transitions aborted before
88  *      @enter().
89  *
90  * @recover: Recover the platform from a suspend failure.
91  *      Called by the PM core if the suspending of devices fails.
92  *      This callback is optional and should only be implemented by platforms
93  *      which require special recovery actions in that situation.
94  */
95 struct platform_suspend_ops {
96         int (*valid)(suspend_state_t state);
97         int (*begin)(suspend_state_t state);
98         int (*prepare)(void);
99         int (*enter)(suspend_state_t state);
100         void (*finish)(void);
101         void (*end)(void);
102         void (*recover)(void);
103 };
104
105 #ifdef CONFIG_SUSPEND
106 /**
107  * suspend_set_ops - set platform dependent suspend operations
108  * @ops: The new suspend operations to set.
109  */
110 extern void suspend_set_ops(struct platform_suspend_ops *ops);
111 extern int suspend_valid_only_mem(suspend_state_t state);
112
113 /**
114  * arch_suspend_disable_irqs - disable IRQs for suspend
115  *
116  * Disables IRQs (in the default case). This is a weak symbol in the common
117  * code and thus allows architectures to override it if more needs to be
118  * done. Not called for suspend to disk.
119  */
120 extern void arch_suspend_disable_irqs(void);
121
122 /**
123  * arch_suspend_enable_irqs - enable IRQs after suspend
124  *
125  * Enables IRQs (in the default case). This is a weak symbol in the common
126  * code and thus allows architectures to override it if more needs to be
127  * done. Not called for suspend to disk.
128  */
129 extern void arch_suspend_enable_irqs(void);
130
131 extern int pm_suspend(suspend_state_t state);
132 #else /* !CONFIG_SUSPEND */
133 #define suspend_valid_only_mem  NULL
134
135 static inline void suspend_set_ops(struct platform_suspend_ops *ops) {}
136 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
137 #endif /* !CONFIG_SUSPEND */
138
139 /* struct pbe is used for creating lists of pages that should be restored
140  * atomically during the resume from disk, because the page frames they have
141  * occupied before the suspend are in use.
142  */
143 struct pbe {
144         void *address;          /* address of the copy */
145         void *orig_address;     /* original address of a page */
146         struct pbe *next;
147 };
148
149 /* mm/page_alloc.c */
150 extern void mark_free_pages(struct zone *zone);
151
152 /**
153  * struct platform_hibernation_ops - hibernation platform support
154  *
155  * The methods in this structure allow a platform to carry out special
156  * operations required by it during a hibernation transition.
157  *
158  * All the methods below, except for @recover(), must be implemented.
159  *
160  * @begin: Tell the platform driver that we're starting hibernation.
161  *      Called right after shrinking memory and before freezing 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.
165  *
166  * @pre_snapshot: Prepare the platform for creating the hibernation image.
167  *      Called right after devices have been frozen and before the nonboot
168  *      CPUs are disabled (runs with IRQs on).
169  *
170  * @finish: Restore the previous state of the platform after the hibernation
171  *      image has been created *or* put the platform into the normal operation
172  *      mode after the hibernation (the same method is executed in both cases).
173  *      Called right after the nonboot CPUs have been enabled and before
174  *      thawing devices (runs with IRQs on).
175  *
176  * @prepare: Prepare the platform for entering the low power state.
177  *      Called right after the hibernation image has been saved and before
178  *      devices are prepared for entering the low power state.
179  *
180  * @enter: Put the system into the low power state after the hibernation image
181  *      has been saved to disk.
182  *      Called after the nonboot CPUs have been disabled and all of the low
183  *      level devices have been shut down (runs with IRQs off).
184  *
185  * @leave: Perform the first stage of the cleanup after the system sleep state
186  *      indicated by @set_target() has been left.
187  *      Called right after the control has been passed from the boot kernel to
188  *      the image kernel, before the nonboot CPUs are enabled and before devices
189  *      are resumed.  Executed with interrupts disabled.
190  *
191  * @pre_restore: Prepare system for the restoration from a hibernation image.
192  *      Called right after devices have been frozen and before the nonboot
193  *      CPUs are disabled (runs with IRQs on).
194  *
195  * @restore_cleanup: Clean up after a failing image restoration.
196  *      Called right after the nonboot CPUs have been enabled and before
197  *      thawing devices (runs with IRQs on).
198  *
199  * @recover: Recover the platform from a failure to suspend devices.
200  *      Called by the PM core if the suspending of devices during hibernation
201  *      fails.  This callback is optional and should only be implemented by
202  *      platforms which require special recovery actions in that situation.
203  */
204 struct platform_hibernation_ops {
205         int (*begin)(void);
206         void (*end)(void);
207         int (*pre_snapshot)(void);
208         void (*finish)(void);
209         int (*prepare)(void);
210         int (*enter)(void);
211         void (*leave)(void);
212         int (*pre_restore)(void);
213         void (*restore_cleanup)(void);
214         void (*recover)(void);
215 };
216
217 #ifdef CONFIG_HIBERNATION
218 /* kernel/power/snapshot.c */
219 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
220 static inline void register_nosave_region(unsigned long b, unsigned long e)
221 {
222         __register_nosave_region(b, e, 0);
223 }
224 static inline void register_nosave_region_late(unsigned long b, unsigned long e)
225 {
226         __register_nosave_region(b, e, 1);
227 }
228 extern int swsusp_page_is_forbidden(struct page *);
229 extern void swsusp_set_page_free(struct page *);
230 extern void swsusp_unset_page_free(struct page *);
231 extern unsigned long get_safe_page(gfp_t gfp_mask);
232
233 extern void hibernation_set_ops(struct platform_hibernation_ops *ops);
234 extern int hibernate(void);
235 #else /* CONFIG_HIBERNATION */
236 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
237 static inline void swsusp_set_page_free(struct page *p) {}
238 static inline void swsusp_unset_page_free(struct page *p) {}
239
240 static inline void hibernation_set_ops(struct platform_hibernation_ops *ops) {}
241 static inline int hibernate(void) { return -ENOSYS; }
242 #endif /* CONFIG_HIBERNATION */
243
244 #ifdef CONFIG_PM_SLEEP
245 void save_processor_state(void);
246 void restore_processor_state(void);
247
248 /* kernel/power/main.c */
249 extern int register_pm_notifier(struct notifier_block *nb);
250 extern int unregister_pm_notifier(struct notifier_block *nb);
251
252 #define pm_notifier(fn, pri) {                          \
253         static struct notifier_block fn##_nb =                  \
254                 { .notifier_call = fn, .priority = pri };       \
255         register_pm_notifier(&fn##_nb);                 \
256 }
257 #else /* !CONFIG_PM_SLEEP */
258
259 static inline int register_pm_notifier(struct notifier_block *nb)
260 {
261         return 0;
262 }
263
264 static inline int unregister_pm_notifier(struct notifier_block *nb)
265 {
266         return 0;
267 }
268
269 #define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
270 #endif /* !CONFIG_PM_SLEEP */
271
272 #ifndef CONFIG_HIBERNATION
273 static inline void register_nosave_region(unsigned long b, unsigned long e)
274 {
275 }
276 static inline void register_nosave_region_late(unsigned long b, unsigned long e)
277 {
278 }
279 #endif
280
281 extern struct mutex pm_mutex;
282
283 #endif /* _LINUX_SUSPEND_H */