PM: Move definition of struct pm_ops to suspend.h
[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 int pm_prepare_console(void);
16 extern void pm_restore_console(void);
17 #else
18 static inline int pm_prepare_console(void) { return 0; }
19 static inline void pm_restore_console(void) {}
20 #endif
21
22 typedef int __bitwise suspend_state_t;
23
24 #define PM_SUSPEND_ON           ((__force suspend_state_t) 0)
25 #define PM_SUSPEND_STANDBY      ((__force suspend_state_t) 1)
26 #define PM_SUSPEND_MEM          ((__force suspend_state_t) 3)
27 #define PM_SUSPEND_MAX          ((__force suspend_state_t) 4)
28
29 /**
30  * struct pm_ops - Callbacks for managing platform dependent system sleep
31  *      states.
32  *
33  * @valid: Callback to determine if given system sleep state is supported by
34  *      the platform.
35  *      Valid (ie. supported) states are advertised in /sys/power/state.  Note
36  *      that it still may be impossible to enter given system sleep state if the
37  *      conditions aren't right.
38  *      There is the %pm_valid_only_mem function available that can be assigned
39  *      to this if the platform only supports mem sleep.
40  *
41  * @set_target: Tell the platform which system sleep state is going to be
42  *      entered.
43  *      @set_target() is executed right prior to suspending devices.  The
44  *      information conveyed to the platform code by @set_target() should be
45  *      disregarded by the platform as soon as @finish() is executed and if
46  *      @prepare() fails.  If @set_target() fails (ie. returns nonzero),
47  *      @prepare(), @enter() and @finish() will not be called by the PM core.
48  *      This callback is optional.  However, if it is implemented, the argument
49  *      passed to @prepare(), @enter() and @finish() is meaningless and should
50  *      be ignored.
51  *
52  * @prepare: Prepare the platform for entering the system sleep state indicated
53  *      by @set_target() or represented by the argument if @set_target() is not
54  *      implemented.
55  *      @prepare() is called right after devices have been suspended (ie. the
56  *      appropriate .suspend() method has been executed for each device) and
57  *      before the nonboot CPUs are disabled (it is executed with IRQs enabled).
58  *      This callback is optional.  It returns 0 on success or a negative
59  *      error code otherwise, in which case the system cannot enter the desired
60  *      sleep state (@enter() and @finish() will not be called in that case).
61  *
62  * @enter: Enter the system sleep state indicated by @set_target() or
63  *      represented by the argument if @set_target() is not implemented.
64  *      This callback is mandatory.  It returns 0 on success or a negative
65  *      error code otherwise, in which case the system cannot enter the desired
66  *      sleep state.
67  *
68  * @finish: Called when the system has just left a sleep state, right after
69  *      the nonboot CPUs have been enabled and before devices are resumed (it is
70  *      executed with IRQs enabled).  If @set_target() is not implemented, the
71  *      argument represents the sleep state being left.
72  *      This callback is optional, but should be implemented by the platforms
73  *      that implement @prepare().  If implemented, it is always called after
74  *      @enter() (even if @enter() fails).
75  */
76 struct pm_ops {
77         int (*valid)(suspend_state_t state);
78         int (*set_target)(suspend_state_t state);
79         int (*prepare)(suspend_state_t state);
80         int (*enter)(suspend_state_t state);
81         int (*finish)(suspend_state_t state);
82 };
83
84 #ifdef CONFIG_SUSPEND
85 extern struct pm_ops *pm_ops;
86
87 /**
88  * pm_set_ops - set platform dependent power management ops
89  * @pm_ops: The new power management operations to set.
90  */
91 extern void pm_set_ops(struct pm_ops *pm_ops);
92 extern int pm_valid_only_mem(suspend_state_t state);
93
94 /**
95  * arch_suspend_disable_irqs - disable IRQs for suspend
96  *
97  * Disables IRQs (in the default case). This is a weak symbol in the common
98  * code and thus allows architectures to override it if more needs to be
99  * done. Not called for suspend to disk.
100  */
101 extern void arch_suspend_disable_irqs(void);
102
103 /**
104  * arch_suspend_enable_irqs - enable IRQs after suspend
105  *
106  * Enables IRQs (in the default case). This is a weak symbol in the common
107  * code and thus allows architectures to override it if more needs to be
108  * done. Not called for suspend to disk.
109  */
110 extern void arch_suspend_enable_irqs(void);
111
112 extern int pm_suspend(suspend_state_t state);
113 #else /* !CONFIG_SUSPEND */
114 #define suspend_valid_only_mem  NULL
115
116 static inline void pm_set_ops(struct pm_ops *pm_ops) {}
117 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
118 #endif /* !CONFIG_SUSPEND */
119
120 /* struct pbe is used for creating lists of pages that should be restored
121  * atomically during the resume from disk, because the page frames they have
122  * occupied before the suspend are in use.
123  */
124 struct pbe {
125         void *address;          /* address of the copy */
126         void *orig_address;     /* original address of a page */
127         struct pbe *next;
128 };
129
130 /* mm/page_alloc.c */
131 extern void drain_local_pages(void);
132 extern void mark_free_pages(struct zone *zone);
133
134 /**
135  * struct hibernation_ops - hibernation platform support
136  *
137  * The methods in this structure allow a platform to override the default
138  * mechanism of shutting down the machine during a hibernation transition.
139  *
140  * All three methods must be assigned.
141  *
142  * @prepare: prepare system for hibernation
143  * @enter: shut down system after state has been saved to disk
144  * @finish: finish/clean up after state has been reloaded
145  * @pre_restore: prepare system for the restoration from a hibernation image
146  * @restore_cleanup: clean up after a failing image restoration
147  */
148 struct hibernation_ops {
149         int (*prepare)(void);
150         int (*enter)(void);
151         void (*finish)(void);
152         int (*pre_restore)(void);
153         void (*restore_cleanup)(void);
154 };
155
156 #ifdef CONFIG_HIBERNATION
157 /* kernel/power/snapshot.c */
158 extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
159 static inline void register_nosave_region(unsigned long b, unsigned long e)
160 {
161         __register_nosave_region(b, e, 0);
162 }
163 static inline void register_nosave_region_late(unsigned long b, unsigned long e)
164 {
165         __register_nosave_region(b, e, 1);
166 }
167 extern int swsusp_page_is_forbidden(struct page *);
168 extern void swsusp_set_page_free(struct page *);
169 extern void swsusp_unset_page_free(struct page *);
170 extern unsigned long get_safe_page(gfp_t gfp_mask);
171
172 extern void hibernation_set_ops(struct hibernation_ops *ops);
173 extern int hibernate(void);
174 #else /* CONFIG_HIBERNATION */
175 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
176 static inline void swsusp_set_page_free(struct page *p) {}
177 static inline void swsusp_unset_page_free(struct page *p) {}
178
179 static inline void hibernation_set_ops(struct hibernation_ops *ops) {}
180 static inline int hibernate(void) { return -ENOSYS; }
181 #endif /* CONFIG_HIBERNATION */
182
183 #ifdef CONFIG_PM_SLEEP
184 void save_processor_state(void);
185 void restore_processor_state(void);
186 struct saved_context;
187 void __save_processor_state(struct saved_context *ctxt);
188 void __restore_processor_state(struct saved_context *ctxt);
189
190 /* kernel/power/main.c */
191 extern struct blocking_notifier_head pm_chain_head;
192
193 static inline int register_pm_notifier(struct notifier_block *nb)
194 {
195         return blocking_notifier_chain_register(&pm_chain_head, nb);
196 }
197
198 static inline int unregister_pm_notifier(struct notifier_block *nb)
199 {
200         return blocking_notifier_chain_unregister(&pm_chain_head, nb);
201 }
202
203 #define pm_notifier(fn, pri) {                          \
204         static struct notifier_block fn##_nb =                  \
205                 { .notifier_call = fn, .priority = pri };       \
206         register_pm_notifier(&fn##_nb);                 \
207 }
208 #else /* !CONFIG_PM_SLEEP */
209
210 static inline int register_pm_notifier(struct notifier_block *nb)
211 {
212         return 0;
213 }
214
215 static inline int unregister_pm_notifier(struct notifier_block *nb)
216 {
217         return 0;
218 }
219
220 #define pm_notifier(fn, pri)    do { (void)(fn); } while (0)
221 #endif /* !CONFIG_PM_SLEEP */
222
223 #ifndef CONFIG_HIBERNATION
224 static inline void register_nosave_region(unsigned long b, unsigned long e)
225 {
226 }
227 static inline void register_nosave_region_late(unsigned long b, unsigned long e)
228 {
229 }
230 #endif
231
232 #endif /* _LINUX_SUSPEND_H */