2007-10-18 18:04:39 +08:00
|
|
|
#ifndef _LINUX_SUSPEND_H
|
|
|
|
|
#define _LINUX_SUSPEND_H
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-03 20:31:38 +08:00
|
|
|
#if defined(CONFIG_X86) || defined(CONFIG_FRV) || defined(CONFIG_PPC32) || defined(CONFIG_PPC64)
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <asm/suspend.h>
|
|
|
|
|
#endif
|
|
|
|
|
#include <linux/swap.h>
|
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
|
#include <linux/init.h>
|
|
|
|
|
#include <linux/pm.h>
|
2007-05-07 05:50:42 +08:00
|
|
|
#include <linux/mm.h>
|
2007-10-18 18:04:39 +08:00
|
|
|
#include <asm/errno.h>
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_PM_SLEEP) && defined(CONFIG_VT) && defined(CONFIG_VT_CONSOLE)
|
|
|
|
|
extern int pm_prepare_console(void);
|
|
|
|
|
extern void pm_restore_console(void);
|
|
|
|
|
#else
|
|
|
|
|
static inline int pm_prepare_console(void) { return 0; }
|
|
|
|
|
static inline void pm_restore_console(void) {}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
typedef int __bitwise suspend_state_t;
|
|
|
|
|
|
|
|
|
|
#define PM_SUSPEND_ON ((__force suspend_state_t) 0)
|
|
|
|
|
#define PM_SUSPEND_STANDBY ((__force suspend_state_t) 1)
|
|
|
|
|
#define PM_SUSPEND_MEM ((__force suspend_state_t) 3)
|
|
|
|
|
#define PM_SUSPEND_MAX ((__force suspend_state_t) 4)
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct pm_ops - Callbacks for managing platform dependent system sleep
|
|
|
|
|
* states.
|
|
|
|
|
*
|
|
|
|
|
* @valid: Callback to determine if given system sleep state is supported by
|
|
|
|
|
* the platform.
|
|
|
|
|
* Valid (ie. supported) states are advertised in /sys/power/state. Note
|
|
|
|
|
* that it still may be impossible to enter given system sleep state if the
|
|
|
|
|
* conditions aren't right.
|
|
|
|
|
* There is the %pm_valid_only_mem function available that can be assigned
|
|
|
|
|
* to this if the platform only supports mem sleep.
|
|
|
|
|
*
|
|
|
|
|
* @set_target: Tell the platform which system sleep state is going to be
|
|
|
|
|
* entered.
|
|
|
|
|
* @set_target() is executed right prior to suspending devices. The
|
|
|
|
|
* information conveyed to the platform code by @set_target() should be
|
|
|
|
|
* disregarded by the platform as soon as @finish() is executed and if
|
|
|
|
|
* @prepare() fails. If @set_target() fails (ie. returns nonzero),
|
|
|
|
|
* @prepare(), @enter() and @finish() will not be called by the PM core.
|
|
|
|
|
* This callback is optional. However, if it is implemented, the argument
|
|
|
|
|
* passed to @prepare(), @enter() and @finish() is meaningless and should
|
|
|
|
|
* be ignored.
|
|
|
|
|
*
|
|
|
|
|
* @prepare: Prepare the platform for entering the system sleep state indicated
|
|
|
|
|
* by @set_target() or represented by the argument if @set_target() is not
|
|
|
|
|
* implemented.
|
|
|
|
|
* @prepare() is called right after devices have been suspended (ie. the
|
|
|
|
|
* appropriate .suspend() method has been executed for each device) and
|
|
|
|
|
* before the nonboot CPUs are disabled (it is executed with IRQs enabled).
|
|
|
|
|
* This callback is optional. It returns 0 on success or a negative
|
|
|
|
|
* error code otherwise, in which case the system cannot enter the desired
|
|
|
|
|
* sleep state (@enter() and @finish() will not be called in that case).
|
|
|
|
|
*
|
|
|
|
|
* @enter: Enter the system sleep state indicated by @set_target() or
|
|
|
|
|
* represented by the argument if @set_target() is not implemented.
|
|
|
|
|
* This callback is mandatory. It returns 0 on success or a negative
|
|
|
|
|
* error code otherwise, in which case the system cannot enter the desired
|
|
|
|
|
* sleep state.
|
|
|
|
|
*
|
|
|
|
|
* @finish: Called when the system has just left a sleep state, right after
|
|
|
|
|
* the nonboot CPUs have been enabled and before devices are resumed (it is
|
|
|
|
|
* executed with IRQs enabled). If @set_target() is not implemented, the
|
|
|
|
|
* argument represents the sleep state being left.
|
|
|
|
|
* This callback is optional, but should be implemented by the platforms
|
|
|
|
|
* that implement @prepare(). If implemented, it is always called after
|
|
|
|
|
* @enter() (even if @enter() fails).
|
|
|
|
|
*/
|
|
|
|
|
struct pm_ops {
|
|
|
|
|
int (*valid)(suspend_state_t state);
|
|
|
|
|
int (*set_target)(suspend_state_t state);
|
|
|
|
|
int (*prepare)(suspend_state_t state);
|
|
|
|
|
int (*enter)(suspend_state_t state);
|
|
|
|
|
int (*finish)(suspend_state_t state);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SUSPEND
|
|
|
|
|
extern struct pm_ops *pm_ops;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* pm_set_ops - set platform dependent power management ops
|
|
|
|
|
* @pm_ops: The new power management operations to set.
|
|
|
|
|
*/
|
|
|
|
|
extern void pm_set_ops(struct pm_ops *pm_ops);
|
|
|
|
|
extern int pm_valid_only_mem(suspend_state_t state);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* arch_suspend_disable_irqs - disable IRQs for suspend
|
|
|
|
|
*
|
|
|
|
|
* Disables IRQs (in the default case). This is a weak symbol in the common
|
|
|
|
|
* code and thus allows architectures to override it if more needs to be
|
|
|
|
|
* done. Not called for suspend to disk.
|
|
|
|
|
*/
|
|
|
|
|
extern void arch_suspend_disable_irqs(void);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* arch_suspend_enable_irqs - enable IRQs after suspend
|
|
|
|
|
*
|
|
|
|
|
* Enables IRQs (in the default case). This is a weak symbol in the common
|
|
|
|
|
* code and thus allows architectures to override it if more needs to be
|
|
|
|
|
* done. Not called for suspend to disk.
|
|
|
|
|
*/
|
|
|
|
|
extern void arch_suspend_enable_irqs(void);
|
|
|
|
|
|
|
|
|
|
extern int pm_suspend(suspend_state_t state);
|
|
|
|
|
#else /* !CONFIG_SUSPEND */
|
|
|
|
|
#define suspend_valid_only_mem NULL
|
|
|
|
|
|
|
|
|
|
static inline void pm_set_ops(struct pm_ops *pm_ops) {}
|
|
|
|
|
static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
|
|
|
|
|
#endif /* !CONFIG_SUSPEND */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
/* struct pbe is used for creating lists of pages that should be restored
|
|
|
|
|
* atomically during the resume from disk, because the page frames they have
|
|
|
|
|
* occupied before the suspend are in use.
|
|
|
|
|
*/
|
2006-09-26 14:32:51 +08:00
|
|
|
struct pbe {
|
[PATCH] swsusp: Improve handling of highmem
Currently swsusp saves the contents of highmem pages by copying them to the
normal zone which is quite inefficient (eg. it requires two normal pages
to be used for saving one highmem page). This may be improved by using
highmem for saving the contents of saveable highmem pages.
Namely, during the suspend phase of the suspend-resume cycle we try to
allocate as many free highmem pages as there are saveable highmem pages.
If there are not enough highmem image pages to store the contents of all of
the saveable highmem pages, some of them will be stored in the "normal"
memory. Next, we allocate as many free "normal" pages as needed to store
the (remaining) image data. We use a memory bitmap to mark the allocated
free pages (ie. highmem as well as "normal" image pages).
Now, we use another memory bitmap to mark all of the saveable pages
(highmem as well as "normal") and the contents of the saveable pages are
copied into the image pages. Then, the second bitmap is used to save the
pfns corresponding to the saveable pages and the first one is used to save
their data.
During the resume phase the pfns of the pages that were saveable during the
suspend are loaded from the image and used to mark the "unsafe" page
frames. Next, we try to allocate as many free highmem page frames as to
load all of the image data that had been in the highmem before the suspend
and we allocate so many free "normal" page frames that the total number of
allocated free pages (highmem and "normal") is equal to the size of the
image. While doing this we have to make sure that there will be some extra
free "normal" and "safe" page frames for two lists of PBEs constructed
later.
Now, the image data are loaded, if possible, into their "original" page
frames. The image data that cannot be written into their "original" page
frames are loaded into "safe" page frames and their "original" kernel
virtual addresses, as well as the addresses of the "safe" pages containing
their copies, are stored in one of two lists of PBEs.
One list of PBEs is for the copies of "normal" suspend pages (ie. "normal"
pages that were saveable during the suspend) and it is used in the same way
as previously (ie. by the architecture-dependent parts of swsusp). The
other list of PBEs is for the copies of highmem suspend pages. The pages
in this list are restored (in a reversible way) right before the
arch-dependent code is called.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-07 12:34:18 +08:00
|
|
|
void *address; /* address of the copy */
|
|
|
|
|
void *orig_address; /* original address of a page */
|
2006-01-06 16:13:05 +08:00
|
|
|
struct pbe *next;
|
2006-09-26 14:32:51 +08:00
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* mm/page_alloc.c */
|
|
|
|
|
extern void drain_local_pages(void);
|
|
|
|
|
extern void mark_free_pages(struct zone *zone);
|
|
|
|
|
|
2007-05-09 17:33:18 +08:00
|
|
|
/**
|
|
|
|
|
* struct hibernation_ops - hibernation platform support
|
|
|
|
|
*
|
|
|
|
|
* The methods in this structure allow a platform to override the default
|
|
|
|
|
* mechanism of shutting down the machine during a hibernation transition.
|
|
|
|
|
*
|
|
|
|
|
* All three methods must be assigned.
|
|
|
|
|
*
|
|
|
|
|
* @prepare: prepare system for hibernation
|
|
|
|
|
* @enter: shut down system after state has been saved to disk
|
|
|
|
|
* @finish: finish/clean up after state has been reloaded
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 16:47:30 +08:00
|
|
|
* @pre_restore: prepare system for the restoration from a hibernation image
|
|
|
|
|
* @restore_cleanup: clean up after a failing image restoration
|
2007-05-09 17:33:18 +08:00
|
|
|
*/
|
|
|
|
|
struct hibernation_ops {
|
|
|
|
|
int (*prepare)(void);
|
|
|
|
|
int (*enter)(void);
|
|
|
|
|
void (*finish)(void);
|
swsusp: introduce restore platform operations
At least on some machines it is necessary to prepare the ACPI firmware for the
restoration of the system memory state from the hibernation image if the
"platform" mode of hibernation has been used. Namely, in that cases we need
to disable the GPEs before replacing the "boot" kernel with the "frozen"
kernel (cf. http://bugzilla.kernel.org/show_bug.cgi?id=7887). After the
restore they will be re-enabled by hibernation_ops->finish(), but if the
restore fails, they have to be re-enabled by the restore code explicitly.
For this purpose we can introduce two additional hibernation operations,
called pre_restore() and restore_cleanup() and call them from the restore code
path. Still, they should be called if the "platform" mode of hibernation has
been used, so we need to pass the information about the hibernation mode from
the "frozen" kernel to the "boot" kernel in the image header.
Apparently, we can't drop the disabling of GPEs before the restore because of
Bug #7887 . We also can't do it unconditionally, because the GPEs wouldn't
have been enabled after a successful restore if the suspend had been done in
the 'shutdown' or 'reboot' mode.
In principle we could (and probably should) unconditionally disable the GPEs
before each snapshot creation *and* before the restore, but then we'd have to
unconditionally enable them after the snapshot creation as well as after the
restore (or restore failure) Still, for this purpose we'd need to modify
acpi_enter_sleep_state_prep() and acpi_leave_sleep_state() and we'd have to
introduce some mechanism synchronizing the disablind/enabling of the GPEs with
the device drivers' .suspend()/.resume() routines and with
disable_/enable_nonboot_cpus(). However, this would have affected the
suspend (ie. s2ram) code as well as the hibernation, which I'd like to avoid
in this patch series.
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Cc: Nigel Cunningham <nigel@nigel.suspend2.net>
Cc: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-07-19 16:47:30 +08:00
|
|
|
int (*pre_restore)(void);
|
|
|
|
|
void (*restore_cleanup)(void);
|
2007-05-09 17:33:18 +08:00
|
|
|
};
|
|
|
|
|
|
2007-07-30 05:24:36 +08:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2007-05-07 05:50:43 +08:00
|
|
|
/* kernel/power/snapshot.c */
|
2007-05-08 17:23:49 +08:00
|
|
|
extern void __register_nosave_region(unsigned long b, unsigned long e, int km);
|
|
|
|
|
static inline void register_nosave_region(unsigned long b, unsigned long e)
|
|
|
|
|
{
|
|
|
|
|
__register_nosave_region(b, e, 0);
|
|
|
|
|
}
|
|
|
|
|
static inline void register_nosave_region_late(unsigned long b, unsigned long e)
|
|
|
|
|
{
|
|
|
|
|
__register_nosave_region(b, e, 1);
|
|
|
|
|
}
|
2007-05-07 05:50:43 +08:00
|
|
|
extern int swsusp_page_is_forbidden(struct page *);
|
|
|
|
|
extern void swsusp_set_page_free(struct page *);
|
|
|
|
|
extern void swsusp_unset_page_free(struct page *);
|
|
|
|
|
extern unsigned long get_safe_page(gfp_t gfp_mask);
|
2007-05-09 17:33:18 +08:00
|
|
|
|
|
|
|
|
extern void hibernation_set_ops(struct hibernation_ops *ops);
|
|
|
|
|
extern int hibernate(void);
|
2007-07-30 05:24:36 +08:00
|
|
|
#else /* CONFIG_HIBERNATION */
|
2007-05-07 05:50:43 +08:00
|
|
|
static inline int swsusp_page_is_forbidden(struct page *p) { return 0; }
|
|
|
|
|
static inline void swsusp_set_page_free(struct page *p) {}
|
|
|
|
|
static inline void swsusp_unset_page_free(struct page *p) {}
|
2007-05-09 17:33:18 +08:00
|
|
|
|
|
|
|
|
static inline void hibernation_set_ops(struct hibernation_ops *ops) {}
|
|
|
|
|
static inline int hibernate(void) { return -ENOSYS; }
|
2007-07-30 05:24:36 +08:00
|
|
|
#endif /* CONFIG_HIBERNATION */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-07-30 05:27:18 +08:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2005-04-17 06:20:36 +08:00
|
|
|
void save_processor_state(void);
|
|
|
|
|
void restore_processor_state(void);
|
|
|
|
|
struct saved_context;
|
|
|
|
|
void __save_processor_state(struct saved_context *ctxt);
|
|
|
|
|
void __restore_processor_state(struct saved_context *ctxt);
|
2005-10-31 06:59:56 +08:00
|
|
|
|
2007-07-19 16:47:36 +08:00
|
|
|
/* kernel/power/main.c */
|
|
|
|
|
extern struct blocking_notifier_head pm_chain_head;
|
|
|
|
|
|
|
|
|
|
static inline int register_pm_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return blocking_notifier_chain_register(&pm_chain_head, nb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int unregister_pm_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return blocking_notifier_chain_unregister(&pm_chain_head, nb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define pm_notifier(fn, pri) { \
|
|
|
|
|
static struct notifier_block fn##_nb = \
|
|
|
|
|
{ .notifier_call = fn, .priority = pri }; \
|
|
|
|
|
register_pm_notifier(&fn##_nb); \
|
|
|
|
|
}
|
2007-07-30 05:27:18 +08:00
|
|
|
#else /* !CONFIG_PM_SLEEP */
|
2007-07-19 16:47:36 +08:00
|
|
|
|
|
|
|
|
static inline int register_pm_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int unregister_pm_notifier(struct notifier_block *nb)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define pm_notifier(fn, pri) do { (void)(fn); } while (0)
|
2007-07-30 05:27:18 +08:00
|
|
|
#endif /* !CONFIG_PM_SLEEP */
|
2007-07-19 16:47:36 +08:00
|
|
|
|
2007-07-30 05:27:18 +08:00
|
|
|
#ifndef CONFIG_HIBERNATION
|
2007-07-19 16:47:36 +08:00
|
|
|
static inline void register_nosave_region(unsigned long b, unsigned long e)
|
|
|
|
|
{
|
|
|
|
|
}
|
2007-07-27 01:40:59 +08:00
|
|
|
static inline void register_nosave_region_late(unsigned long b, unsigned long e)
|
|
|
|
|
{
|
|
|
|
|
}
|
2007-07-19 16:47:36 +08:00
|
|
|
#endif
|
|
|
|
|
|
2007-10-18 18:04:39 +08:00
|
|
|
#endif /* _LINUX_SUSPEND_H */
|