Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
suspend.h
Go to the documentation of this file.
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
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
24 static inline int pm_prepare_console(void)
25 {
26  return 0;
27 }
28 
29 static inline void pm_restore_console(void)
30 {
31 }
32 #endif
33 
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 
50 };
51 
52 struct suspend_stats {
53  int success;
54  int fail;
63 #define REC_FAILED_NUM 2
70 };
71 
72 extern struct suspend_stats suspend_stats;
73 
74 static inline void dpm_save_failed_dev(const char *name)
75 {
77  name,
78  sizeof(suspend_stats.failed_devs[0]));
81 }
82 
83 static inline void dpm_save_failed_errno(int err)
84 {
88 }
89 
90 static inline void dpm_save_failed_step(enum suspend_stat_step step)
91 {
95 }
96 
184  void (*end)(void);
186 };
187 
188 #ifdef CONFIG_SUSPEND
189 
193 extern void suspend_set_ops(const struct platform_suspend_ops *ops);
195 
203 extern void arch_suspend_disable_irqs(void);
204 
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 
218 static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
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 
289  void (*end)(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);
303 static inline void __init register_nosave_region(unsigned long b, unsigned long e)
304 {
305  __register_nosave_region(b, e, 0);
306 }
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 */
320 static inline void register_nosave_region(unsigned long b, unsigned long e) {}
321 static inline void register_nosave_region_late(unsigned long b, unsigned long e) {}
322 static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
323 static inline void swsusp_set_page_free(struct page *p) {}
324 static inline void swsusp_unset_page_free(struct page *p) {}
325 
326 static inline void hibernation_set_ops(const struct platform_hibernation_ops *ops) {}
327 static inline int hibernate(void) { return -ENOSYS; }
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, bool block);
360 extern bool pm_save_wakeup_count(unsigned int count);
361 extern void pm_wakep_autosleep_enabled(bool set);
362 
363 static inline void lock_system_sleep(void)
364 {
365  current->flags |= PF_FREEZER_SKIP;
366  mutex_lock(&pm_mutex);
367 }
368 
369 static inline void unlock_system_sleep(void)
370 {
371  /*
372  * Don't use freezer_count() because we don't want the call to
373  * try_to_freeze() here.
374  *
375  * Reason:
376  * Fundamentally, we just don't need it, because freezing condition
377  * doesn't come into effect until we release the pm_mutex lock,
378  * since the freezer always works with pm_mutex held.
379  *
380  * More importantly, in the case of hibernation,
381  * unlock_system_sleep() gets called in snapshot_read() and
382  * snapshot_write() when the freezing condition is still in effect.
383  * Which means, if we use try_to_freeze() here, it would make them
384  * enter the refrigerator, thus causing hibernation to lockup.
385  */
386  current->flags &= ~PF_FREEZER_SKIP;
387  mutex_unlock(&pm_mutex);
388 }
389 
390 #else /* !CONFIG_PM_SLEEP */
391 
392 static inline int register_pm_notifier(struct notifier_block *nb)
393 {
394  return 0;
395 }
396 
397 static inline int unregister_pm_notifier(struct notifier_block *nb)
398 {
399  return 0;
400 }
401 
402 #define pm_notifier(fn, pri) do { (void)(fn); } while (0)
403 
404 static inline bool pm_wakeup_pending(void) { return false; }
405 
406 static inline void lock_system_sleep(void) {}
407 static inline void unlock_system_sleep(void) {}
408 
409 #endif /* !CONFIG_PM_SLEEP */
410 
411 #ifdef CONFIG_PM_SLEEP_DEBUG
412 extern bool pm_print_times_enabled;
413 #else
414 #define pm_print_times_enabled (false)
415 #endif
416 
417 #ifdef CONFIG_PM_AUTOSLEEP
418 
419 /* kernel/power/autosleep.c */
420 void queue_up_suspend_work(void);
421 
422 #else /* !CONFIG_PM_AUTOSLEEP */
423 
424 static inline void queue_up_suspend_work(void) {}
425 
426 #endif /* !CONFIG_PM_AUTOSLEEP */
427 
428 #ifdef CONFIG_ARCH_SAVE_PAGE_KEYS
429 /*
430  * The ARCH_SAVE_PAGE_KEYS functions can be used by an architecture
431  * to save/restore additional information to/from the array of page
432  * frame numbers in the hibernation image. For s390 this is used to
433  * save and restore the storage key for each page that is included
434  * in the hibernation image.
435  */
436 unsigned long page_key_additional_pages(unsigned long pages);
437 int page_key_alloc(unsigned long pages);
438 void page_key_free(void);
439 void page_key_read(unsigned long *pfn);
440 void page_key_memorize(unsigned long *pfn);
441 void page_key_write(void *address);
442 
443 #else /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
444 
445 static inline unsigned long page_key_additional_pages(unsigned long pages)
446 {
447  return 0;
448 }
449 
450 static inline int page_key_alloc(unsigned long pages)
451 {
452  return 0;
453 }
454 
455 static inline void page_key_free(void) {}
456 static inline void page_key_read(unsigned long *pfn) {}
457 static inline void page_key_memorize(unsigned long *pfn) {}
458 static inline void page_key_write(void *address) {}
459 
460 #endif /* !CONFIG_ARCH_SAVE_PAGE_KEYS */
461 
462 #endif /* _LINUX_SUSPEND_H */