Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef _LINUX_SUSPEND_H
3 : : #define _LINUX_SUSPEND_H
4 : :
5 : : #include <linux/swap.h>
6 : : #include <linux/notifier.h>
7 : : #include <linux/init.h>
8 : : #include <linux/pm.h>
9 : : #include <linux/mm.h>
10 : : #include <linux/freezer.h>
11 : : #include <asm/errno.h>
12 : :
13 : : #ifdef CONFIG_VT
14 : : extern void pm_set_vt_switch(int);
15 : : #else
16 : : static inline void pm_set_vt_switch(int do_switch)
17 : : {
18 : : }
19 : : #endif
20 : :
21 : : #ifdef CONFIG_VT_CONSOLE_SLEEP
22 : : extern void pm_prepare_console(void);
23 : : extern void pm_restore_console(void);
24 : : #else
25 : : static inline void pm_prepare_console(void)
26 : : {
27 : : }
28 : :
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_TO_IDLE ((__force suspend_state_t) 1)
38 : : #define PM_SUSPEND_STANDBY ((__force suspend_state_t) 2)
39 : : #define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
40 : : #define PM_SUSPEND_MIN PM_SUSPEND_TO_IDLE
41 : : #define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
42 : :
43 : : enum suspend_stat_step {
44 : : SUSPEND_FREEZE = 1,
45 : : SUSPEND_PREPARE,
46 : : SUSPEND_SUSPEND,
47 : : SUSPEND_SUSPEND_LATE,
48 : : SUSPEND_SUSPEND_NOIRQ,
49 : : SUSPEND_RESUME_NOIRQ,
50 : : SUSPEND_RESUME_EARLY,
51 : : SUSPEND_RESUME
52 : : };
53 : :
54 : : struct suspend_stats {
55 : : int success;
56 : : int fail;
57 : : int failed_freeze;
58 : : int failed_prepare;
59 : : int failed_suspend;
60 : : int failed_suspend_late;
61 : : int failed_suspend_noirq;
62 : : int failed_resume;
63 : : int failed_resume_early;
64 : : 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 : :
74 : : extern struct suspend_stats suspend_stats;
75 : :
76 : 0 : static inline void dpm_save_failed_dev(const char *name)
77 : : {
78 : 0 : strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev],
79 : : name,
80 : : sizeof(suspend_stats.failed_devs[0]));
81 : 0 : suspend_stats.last_failed_dev++;
82 : 0 : suspend_stats.last_failed_dev %= REC_FAILED_NUM;
83 : : }
84 : :
85 : 0 : static inline void dpm_save_failed_errno(int err)
86 : : {
87 : 0 : suspend_stats.errno[suspend_stats.last_failed_errno] = err;
88 : 0 : suspend_stats.last_failed_errno++;
89 : 0 : suspend_stats.last_failed_errno %= REC_FAILED_NUM;
90 : 0 : }
91 : :
92 : 0 : static inline void dpm_save_failed_step(enum suspend_stat_step step)
93 : : {
94 : 0 : suspend_stats.failed_steps[suspend_stats.last_failed_step] = step;
95 : 0 : suspend_stats.last_failed_step++;
96 [ # # # # : 0 : suspend_stats.last_failed_step %= REC_FAILED_NUM;
# # # # ]
97 : 0 : }
98 : :
99 : : /**
100 : : * struct platform_suspend_ops - Callbacks for managing platform dependent
101 : : * system sleep states.
102 : : *
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.
108 : : * There is the %suspend_valid_only_mem function available that can be
109 : : * assigned to this if the platform only supports mem sleep.
110 : : *
111 : : * @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),
115 : : * @prepare(), @enter() and @finish() will not be called by the PM core.
116 : : * This callback is optional. However, if it is implemented, the argument
117 : : * passed to @enter() is redundant and should be ignored.
118 : : *
119 : : * @prepare: Prepare the platform for entering the system sleep state indicated
120 : : * by @begin().
121 : : * @prepare() is called right after devices have been suspended (ie. the
122 : : * appropriate .suspend() method has been executed for each device) and
123 : : * 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(),
126 : : * and @wake() will not be called in that case).
127 : : *
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
133 : : * system cannot enter the desired sleep state (@enter() will not be
134 : : * executed).
135 : : *
136 : : * @enter: Enter the system sleep state indicated by @begin() or represented by
137 : : * the argument if @begin() is not implemented.
138 : : * 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 : : *
142 : : * @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
147 : : * after @prepare_late and @enter(), even if one of them fails.
148 : : *
149 : : * @finish: Finish wake-up of the platform.
150 : : * @finish is called right prior to calling device drivers' regular suspend
151 : : * callbacks.
152 : : * This callback is optional, but should be implemented by the platforms
153 : : * that implement @prepare(). If implemented, it is always called after
154 : : * @enter() and @wake(), even if any of them fails. It is executed after
155 : : * a failing @prepare.
156 : : *
157 : : * @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 : : *
164 : : * @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
168 : : * that implement @begin(). Accordingly, platforms implementing @begin()
169 : : * should also provide a @end() which cleans up transitions aborted before
170 : : * @enter().
171 : : *
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.
176 : : */
177 : : struct platform_suspend_ops {
178 : : int (*valid)(suspend_state_t state);
179 : : int (*begin)(suspend_state_t state);
180 : : int (*prepare)(void);
181 : : int (*prepare_late)(void);
182 : : int (*enter)(suspend_state_t state);
183 : : void (*wake)(void);
184 : : void (*finish)(void);
185 : : bool (*suspend_again)(void);
186 : : void (*end)(void);
187 : : void (*recover)(void);
188 : : };
189 : :
190 : : struct platform_s2idle_ops {
191 : : int (*begin)(void);
192 : : int (*prepare)(void);
193 : : int (*prepare_late)(void);
194 : : bool (*wake)(void);
195 : : void (*restore_early)(void);
196 : : void (*restore)(void);
197 : : void (*end)(void);
198 : : };
199 : :
200 : : #ifdef CONFIG_SUSPEND
201 : : extern suspend_state_t mem_sleep_current;
202 : : extern suspend_state_t mem_sleep_default;
203 : :
204 : : /**
205 : : * suspend_set_ops - set platform dependent suspend operations
206 : : * @ops: The new suspend operations to set.
207 : : */
208 : : extern void suspend_set_ops(const struct platform_suspend_ops *ops);
209 : : extern int suspend_valid_only_mem(suspend_state_t state);
210 : :
211 : : extern unsigned int pm_suspend_global_flags;
212 : :
213 : : #define PM_SUSPEND_FLAG_FW_SUSPEND BIT(0)
214 : : #define PM_SUSPEND_FLAG_FW_RESUME BIT(1)
215 : : #define PM_SUSPEND_FLAG_NO_PLATFORM BIT(2)
216 : :
217 : 0 : static inline void pm_suspend_clear_flags(void)
218 : : {
219 [ # # ]: 0 : pm_suspend_global_flags = 0;
220 : : }
221 : :
222 : 0 : static inline void pm_set_suspend_via_firmware(void)
223 : : {
224 : 0 : pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_SUSPEND;
225 : 0 : }
226 : :
227 : 0 : static inline void pm_set_resume_via_firmware(void)
228 : : {
229 : 0 : pm_suspend_global_flags |= PM_SUSPEND_FLAG_FW_RESUME;
230 : 0 : }
231 : :
232 : 0 : static inline void pm_set_suspend_no_platform(void)
233 : : {
234 : 0 : pm_suspend_global_flags |= PM_SUSPEND_FLAG_NO_PLATFORM;
235 : 0 : }
236 : :
237 : : /**
238 : : * pm_suspend_via_firmware - Check if platform firmware will suspend the system.
239 : : *
240 : : * To be called during system-wide power management transitions to sleep states
241 : : * or during the subsequent system-wide transitions back to the working state.
242 : : *
243 : : * Return 'true' if the platform firmware is going to be invoked at the end of
244 : : * the system-wide power management transition (to a sleep state) in progress in
245 : : * order to complete it, or if the platform firmware has been invoked in order
246 : : * to complete the last (or preceding) transition of the system to a sleep
247 : : * state.
248 : : *
249 : : * This matters if the caller needs or wants to carry out some special actions
250 : : * depending on whether or not control will be passed to the platform firmware
251 : : * subsequently (for example, the device may need to be reset before letting the
252 : : * platform firmware manipulate it, which is not necessary when the platform
253 : : * firmware is not going to be invoked) or when such special actions may have
254 : : * been carried out during the preceding transition of the system to a sleep
255 : : * state (as they may need to be taken into account).
256 : : */
257 : 0 : static inline bool pm_suspend_via_firmware(void)
258 : : {
259 [ # # # # ]: 0 : return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_SUSPEND);
260 : : }
261 : :
262 : : /**
263 : : * pm_resume_via_firmware - Check if platform firmware has woken up the system.
264 : : *
265 : : * To be called during system-wide power management transitions from sleep
266 : : * states.
267 : : *
268 : : * Return 'true' if the platform firmware has passed control to the kernel at
269 : : * the beginning of the system-wide power management transition in progress, so
270 : : * the event that woke up the system from sleep has been handled by the platform
271 : : * firmware.
272 : : */
273 : 0 : static inline bool pm_resume_via_firmware(void)
274 : : {
275 [ # # ]: 0 : return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_FW_RESUME);
276 : : }
277 : :
278 : : /**
279 : : * pm_suspend_no_platform - Check if platform may change device power states.
280 : : *
281 : : * To be called during system-wide power management transitions to sleep states
282 : : * or during the subsequent system-wide transitions back to the working state.
283 : : *
284 : : * Return 'true' if the power states of devices remain under full control of the
285 : : * kernel throughout the system-wide suspend and resume cycle in progress (that
286 : : * is, if a device is put into a certain power state during suspend, it can be
287 : : * expected to remain in that state during resume).
288 : : */
289 : 0 : static inline bool pm_suspend_no_platform(void)
290 : : {
291 [ # # # # ]: 0 : return !!(pm_suspend_global_flags & PM_SUSPEND_FLAG_NO_PLATFORM);
292 : : }
293 : :
294 : : /* Suspend-to-idle state machnine. */
295 : : enum s2idle_states {
296 : : S2IDLE_STATE_NONE, /* Not suspended/suspending. */
297 : : S2IDLE_STATE_ENTER, /* Enter suspend-to-idle. */
298 : : S2IDLE_STATE_WAKE, /* Wake up from suspend-to-idle. */
299 : : };
300 : :
301 : : extern enum s2idle_states __read_mostly s2idle_state;
302 : :
303 : 0 : static inline bool idle_should_enter_s2idle(void)
304 : : {
305 [ # # # # ]: 0 : return unlikely(s2idle_state == S2IDLE_STATE_ENTER);
306 : : }
307 : :
308 : : extern bool pm_suspend_default_s2idle(void);
309 : : extern void __init pm_states_init(void);
310 : : extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
311 : : extern void s2idle_wake(void);
312 : :
313 : : /**
314 : : * arch_suspend_disable_irqs - disable IRQs for suspend
315 : : *
316 : : * Disables IRQs (in the default case). This is a weak symbol in the common
317 : : * code and thus allows architectures to override it if more needs to be
318 : : * done. Not called for suspend to disk.
319 : : */
320 : : extern void arch_suspend_disable_irqs(void);
321 : :
322 : : /**
323 : : * arch_suspend_enable_irqs - enable IRQs after suspend
324 : : *
325 : : * Enables IRQs (in the default case). This is a weak symbol in the common
326 : : * code and thus allows architectures to override it if more needs to be
327 : : * done. Not called for suspend to disk.
328 : : */
329 : : extern void arch_suspend_enable_irqs(void);
330 : :
331 : : extern int pm_suspend(suspend_state_t state);
332 : : extern bool sync_on_suspend_enabled;
333 : : #else /* !CONFIG_SUSPEND */
334 : : #define suspend_valid_only_mem NULL
335 : :
336 : : static inline void pm_suspend_clear_flags(void) {}
337 : : static inline void pm_set_suspend_via_firmware(void) {}
338 : : static inline void pm_set_resume_via_firmware(void) {}
339 : : static inline bool pm_suspend_via_firmware(void) { return false; }
340 : : static inline bool pm_resume_via_firmware(void) { return false; }
341 : : static inline bool pm_suspend_no_platform(void) { return false; }
342 : : static inline bool pm_suspend_default_s2idle(void) { return false; }
343 : :
344 : : static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
345 : : static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
346 : : static inline bool sync_on_suspend_enabled(void) { return true; }
347 : : static inline bool idle_should_enter_s2idle(void) { return false; }
348 : : static inline void __init pm_states_init(void) {}
349 : : static inline void s2idle_set_ops(const struct platform_s2idle_ops *ops) {}
350 : : static inline void s2idle_wake(void) {}
351 : : #endif /* !CONFIG_SUSPEND */
352 : :
353 : : /* struct pbe is used for creating lists of pages that should be restored
354 : : * atomically during the resume from disk, because the page frames they have
355 : : * occupied before the suspend are in use.
356 : : */
357 : : struct pbe {
358 : : void *address; /* address of the copy */
359 : : void *orig_address; /* original address of a page */
360 : : struct pbe *next;
361 : : };
362 : :
363 : : /* mm/page_alloc.c */
364 : : extern void mark_free_pages(struct zone *zone);
365 : :
366 : : /**
367 : : * struct platform_hibernation_ops - hibernation platform support
368 : : *
369 : : * The methods in this structure allow a platform to carry out special
370 : : * operations required by it during a hibernation transition.
371 : : *
372 : : * All the methods below, except for @recover(), must be implemented.
373 : : *
374 : : * @begin: Tell the platform driver that we're starting hibernation.
375 : : * Called right after shrinking memory and before freezing devices.
376 : : *
377 : : * @end: Called by the PM core right after resuming devices, to indicate to
378 : : * the platform that the system has returned to the working state.
379 : : *
380 : : * @pre_snapshot: Prepare the platform for creating the hibernation image.
381 : : * Called right after devices have been frozen and before the nonboot
382 : : * CPUs are disabled (runs with IRQs on).
383 : : *
384 : : * @finish: Restore the previous state of the platform after the hibernation
385 : : * image has been created *or* put the platform into the normal operation
386 : : * mode after the hibernation (the same method is executed in both cases).
387 : : * Called right after the nonboot CPUs have been enabled and before
388 : : * thawing devices (runs with IRQs on).
389 : : *
390 : : * @prepare: Prepare the platform for entering the low power state.
391 : : * Called right after the hibernation image has been saved and before
392 : : * devices are prepared for entering the low power state.
393 : : *
394 : : * @enter: Put the system into the low power state after the hibernation image
395 : : * has been saved to disk.
396 : : * Called after the nonboot CPUs have been disabled and all of the low
397 : : * level devices have been shut down (runs with IRQs off).
398 : : *
399 : : * @leave: Perform the first stage of the cleanup after the system sleep state
400 : : * indicated by @set_target() has been left.
401 : : * Called right after the control has been passed from the boot kernel to
402 : : * the image kernel, before the nonboot CPUs are enabled and before devices
403 : : * are resumed. Executed with interrupts disabled.
404 : : *
405 : : * @pre_restore: Prepare system for the restoration from a hibernation image.
406 : : * Called right after devices have been frozen and before the nonboot
407 : : * CPUs are disabled (runs with IRQs on).
408 : : *
409 : : * @restore_cleanup: Clean up after a failing image restoration.
410 : : * Called right after the nonboot CPUs have been enabled and before
411 : : * thawing devices (runs with IRQs on).
412 : : *
413 : : * @recover: Recover the platform from a failure to suspend devices.
414 : : * Called by the PM core if the suspending of devices during hibernation
415 : : * fails. This callback is optional and should only be implemented by
416 : : * platforms which require special recovery actions in that situation.
417 : : */
418 : : struct platform_hibernation_ops {
419 : : int (*begin)(pm_message_t stage);
420 : : void (*end)(void);
421 : : int (*pre_snapshot)(void);
422 : : void (*finish)(void);
423 : : int (*prepare)(void);
424 : : int (*enter)(void);
425 : : void (*leave)(void);
426 : : int (*pre_restore)(void);
427 : : void (*restore_cleanup)(void);
428 : : void (*recover)(void);
429 : : };
430 : :
431 : : #ifdef CONFIG_HIBERNATION
432 : : /* kernel/power/snapshot.c */
433 : : extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
434 : 150 : static inline void __init register_nosave_region(unsigned long b, unsigned long e)
435 : : {
436 : 150 : __register_nosave_region(b, e, 0);
437 : 150 : }
438 : : static inline void __init register_nosave_region_late(unsigned long b, unsigned long e)
439 : : {
440 : : __register_nosave_region(b, e, 1);
441 : : }
442 : : extern int swsusp_page_is_forbidden(struct page *);
443 : : extern void swsusp_set_page_free(struct page *);
444 : : extern void swsusp_unset_page_free(struct page *);
445 : : extern unsigned long get_safe_page(gfp_t gfp_mask);
446 : : extern asmlinkage int swsusp_arch_suspend(void);
447 : : extern asmlinkage int swsusp_arch_resume(void);
448 : :
449 : : extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
450 : : extern int hibernate(void);
451 : : extern bool system_entering_hibernation(void);
452 : : extern bool hibernation_available(void);
453 : : asmlinkage int swsusp_save(void);
454 : : extern struct pbe *restore_pblist;
455 : : int pfn_is_nosave(unsigned long pfn);
456 : : #else /* CONFIG_HIBERNATION */
457 : : static inline void register_nosave_region(unsigned long b, unsigned long e) {}
458 : : static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
459 : : static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
460 : : static inline void swsusp_set_page_free(struct page *p) {}
461 : : static inline void swsusp_unset_page_free(struct page *p) {}
462 : :
463 : : static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
464 : : static inline int hibernate(void) { return -ENOSYS; }
465 : : static inline bool system_entering_hibernation(void) { return false; }
466 : : static inline bool hibernation_available(void) { return false; }
467 : : #endif /* CONFIG_HIBERNATION */
468 : :
469 : : /* Hibernation and suspend events */
470 : : #define PM_HIBERNATION_PREPARE 0x0001 /* Going to hibernate */
471 : : #define PM_POST_HIBERNATION 0x0002 /* Hibernation finished */
472 : : #define PM_SUSPEND_PREPARE 0x0003 /* Going to suspend the system */
473 : : #define PM_POST_SUSPEND 0x0004 /* Suspend finished */
474 : : #define PM_RESTORE_PREPARE 0x0005 /* Going to restore a saved image */
475 : : #define PM_POST_RESTORE 0x0006 /* Restore failed */
476 : :
477 : : extern struct mutex system_transition_mutex;
478 : :
479 : : #ifdef CONFIG_PM_SLEEP
480 : : void save_processor_state(void);
481 : : void restore_processor_state(void);
482 : :
483 : : /* kernel/power/main.c */
484 : : extern int register_pm_notifier(struct notifier_block *nb);
485 : : extern int unregister_pm_notifier(struct notifier_block *nb);
486 : : extern void ksys_sync_helper(void);
487 : :
488 : : #define pm_notifier(fn, pri) { \
489 : : static struct notifier_block fn##_nb = \
490 : : { .notifier_call = fn, .priority = pri }; \
491 : : register_pm_notifier(&fn##_nb); \
492 : : }
493 : :
494 : : /* drivers/base/power/wakeup.c */
495 : : extern bool events_check_enabled;
496 : : extern unsigned int pm_wakeup_irq;
497 : : extern suspend_state_t pm_suspend_target_state;
498 : :
499 : : extern bool pm_wakeup_pending(void);
500 : : extern void pm_system_wakeup(void);
501 : : extern void pm_system_cancel_wakeup(void);
502 : : extern void pm_wakeup_clear(bool reset);
503 : : extern void pm_system_irq_wakeup(unsigned int irq_number);
504 : : extern bool pm_get_wakeup_count(unsigned int *count, bool block);
505 : : extern bool pm_save_wakeup_count(unsigned int count);
506 : : extern void pm_wakep_autosleep_enabled(bool set);
507 : : extern void pm_print_active_wakeup_sources(void);
508 : :
509 : : extern void lock_system_sleep(void);
510 : : extern void unlock_system_sleep(void);
511 : :
512 : : #else /* !CONFIG_PM_SLEEP */
513 : :
514 : : static inline int register_pm_notifier(struct notifier_block *nb)
515 : : {
516 : : return 0;
517 : : }
518 : :
519 : : static inline int unregister_pm_notifier(struct notifier_block *nb)
520 : : {
521 : : return 0;
522 : : }
523 : :
524 : : static inline void ksys_sync_helper(void) {}
525 : :
526 : : #define pm_notifier(fn, pri) do { (void)(fn); } while (0)
527 : :
528 : : static inline bool pm_wakeup_pending(void) { return false; }
529 : : static inline void pm_system_wakeup(void) {}
530 : : static inline void pm_wakeup_clear(bool reset) {}
531 : : static inline void pm_system_irq_wakeup(unsigned int irq_number) {}
532 : :
533 : : static inline void lock_system_sleep(void) {}
534 : : static inline void unlock_system_sleep(void) {}
535 : :
536 : : #endif /* !CONFIG_PM_SLEEP */
537 : :
538 : : #ifdef CONFIG_PM_SLEEP_DEBUG
539 : : extern bool pm_print_times_enabled;
540 : : extern bool pm_debug_messages_on;
541 : : extern __printf(2, 3) void __pm_pr_dbg(bool defer, const char *fmt, ...);
542 : : #else
543 : : #define pm_print_times_enabled (false)
544 : : #define pm_debug_messages_on (false)
545 : :
546 : : #include <linux/printk.h>
547 : :
548 : : #define __pm_pr_dbg(defer, fmt, ...) \
549 : : no_printk(KERN_DEBUG fmt, ##__VA_ARGS__)
550 : : #endif
551 : :
552 : : #define pm_pr_dbg(fmt, ...) \
553 : : __pm_pr_dbg(false, fmt, ##__VA_ARGS__)
554 : :
555 : : #define pm_deferred_pr_dbg(fmt, ...) \
556 : : __pm_pr_dbg(true, fmt, ##__VA_ARGS__)
557 : :
558 : : #ifdef CONFIG_PM_AUTOSLEEP
559 : :
560 : : /* kernel/power/autosleep.c */
561 : : void queue_up_suspend_work(void);
562 : :
563 : : #else /* !CONFIG_PM_AUTOSLEEP */
564 : :
565 : : static inline void queue_up_suspend_work(void) {}
566 : :
567 : : #endif /* !CONFIG_PM_AUTOSLEEP */
568 : :
569 : : #ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
570 : : /*
571 : : * The ARCH_SAVE_PAGE_KEYS functions can be used by an architecture
572 : : * to save/restore additional information to/from the array of page
573 : : * frame numbers in the hibernation image. For s390 this is used to
574 : : * save and restore the storage key for each page that is included
575 : : * in the hibernation image.
576 : : */
577 : : unsigned long page_key_additional_pages(unsigned long pages);
578 : : int page_key_alloc(unsigned long pages);
579 : : void page_key_free(void);
580 : : void page_key_read(unsigned long *pfn);
581 : : void page_key_memorize(unsigned long *pfn);
582 : : void page_key_write(void *address);
583 : :
584 : : #else /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
585 : :
586 : 0 : static inline unsigned long page_key_additional_pages(unsigned long pages)
587 : : {
588 [ # # ]: 0 : return 0;
589 : : }
590 : :
591 : 0 : static inline int page_key_alloc(unsigned long pages)
592 : : {
593 : 0 : return 0;
594 : : }
595 : :
596 [ # # ]: 0 : static inline void page_key_free(void) {}
597 : 0 : static inline void page_key_read(unsigned long *pfn) {}
598 : 0 : static inline void page_key_memorize(unsigned long *pfn) {}
599 [ # # # # ]: 0 : static inline void page_key_write(void *address) {}
600 : :
601 : : #endif /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
602 : :
603 : : #endif /* _LINUX_SUSPEND_H */
|
