2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* sleep.c - ACPI sleep support.
|
|
|
|
*
|
2005-03-18 14:20:46 -07:00
|
|
|
* Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
|
|
|
|
* Copyright (c) 2000-2003 Patrick Mochel
|
|
|
|
* Copyright (c) 2003 Open Source Development Lab
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/irq.h>
|
|
|
|
#include <linux/dmi.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/suspend.h>
|
2007-09-20 11:32:35 -06:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
|
|
|
#include "sleep.h"
|
|
|
|
|
|
|
|
u8 sleep_states[ACPI_S_STATE_COUNT];
|
|
|
|
|
2007-07-29 15:27:18 -06:00
|
|
|
static u32 acpi_target_sleep_state = ACPI_STATE_S0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SUSPEND
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct pm_ops acpi_pm_ops;
|
|
|
|
|
|
|
|
extern void do_suspend_lowlevel(void);
|
|
|
|
|
|
|
|
static u32 acpi_suspend_states[] = {
|
2005-03-18 14:20:46 -07:00
|
|
|
[PM_SUSPEND_ON] = ACPI_STATE_S0,
|
|
|
|
[PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
|
|
|
|
[PM_SUSPEND_MEM] = ACPI_STATE_S3,
|
|
|
|
[PM_SUSPEND_MAX] = ACPI_STATE_S5
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int init_8259A_after_S1;
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
/**
|
|
|
|
* acpi_pm_set_target - Set the target system sleep state to the state
|
|
|
|
* associated with given @pm_state, if supported.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int acpi_pm_set_target(suspend_state_t pm_state)
|
|
|
|
{
|
|
|
|
u32 acpi_state = acpi_suspend_states[pm_state];
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (sleep_states[acpi_state]) {
|
|
|
|
acpi_target_sleep_state = acpi_state;
|
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "ACPI does not support this state: %d\n",
|
|
|
|
pm_state);
|
|
|
|
error = -ENOSYS;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-09-20 11:32:35 -06:00
|
|
|
int acpi_sleep_prepare(u32 acpi_state)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
|
|
|
/* do we have a wakeup address for S2 and S3? */
|
|
|
|
if (acpi_state == ACPI_STATE_S3) {
|
|
|
|
if (!acpi_wakeup_address) {
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
acpi_set_firmware_waking_vector((acpi_physical_address)
|
|
|
|
virt_to_phys((void *)
|
|
|
|
acpi_wakeup_address));
|
|
|
|
|
|
|
|
}
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
acpi_enable_wakeup_device_prep(acpi_state);
|
|
|
|
#endif
|
|
|
|
acpi_gpe_sleep_prepare(acpi_state);
|
|
|
|
acpi_enter_sleep_state_prep(acpi_state);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
|
|
|
* acpi_pm_prepare - Do preliminary suspend work.
|
2007-07-17 14:40:06 -06:00
|
|
|
* @pm_state: ignored
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-07-17 14:40:06 -06:00
|
|
|
* If necessary, set the firmware waking vector and do arch-specific
|
|
|
|
* nastiness to get the wakeup code to the waking vector.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static int acpi_pm_prepare(suspend_state_t pm_state)
|
|
|
|
{
|
2007-07-17 14:40:06 -06:00
|
|
|
int error = acpi_sleep_prepare(acpi_target_sleep_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
if (error)
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
|
|
|
|
|
|
|
return error;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_enter - Actually enter a sleep state.
|
2007-07-17 14:40:06 -06:00
|
|
|
* @pm_state: ignored
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2007-07-24 03:58:39 -06:00
|
|
|
* Flush caches and go to sleep. For STR we have to call arch-specific
|
|
|
|
* assembly, which in turn call acpi_enter_sleep_state().
|
2005-04-16 16:20:36 -06:00
|
|
|
* It's unfortunate, but it works. Please fix if you're feeling frisky.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int acpi_pm_enter(suspend_state_t pm_state)
|
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
unsigned long flags = 0;
|
2007-07-17 14:40:06 -06:00
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
|
|
|
/* Do arch specific saving of state. */
|
2007-07-24 03:58:39 -06:00
|
|
|
if (acpi_state == ACPI_STATE_S3) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int error = acpi_save_state_mem();
|
2007-07-17 14:40:06 -06:00
|
|
|
|
|
|
|
if (error) {
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
2005-04-16 16:20:36 -06:00
|
|
|
return error;
|
2007-07-17 14:40:06 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
acpi_enable_wakeup_device(acpi_state);
|
2007-07-17 14:40:06 -06:00
|
|
|
switch (acpi_state) {
|
|
|
|
case ACPI_STATE_S1:
|
2005-04-16 16:20:36 -06:00
|
|
|
barrier();
|
|
|
|
status = acpi_enter_sleep_state(acpi_state);
|
|
|
|
break;
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
case ACPI_STATE_S3:
|
2005-04-16 16:20:36 -06:00
|
|
|
do_suspend_lowlevel();
|
|
|
|
break;
|
|
|
|
}
|
2006-04-27 03:25:00 -06:00
|
|
|
|
|
|
|
/* ACPI 3.0 specs (P62) says that it's the responsabilty
|
|
|
|
* of the OSPM to clear the status bit [ implying that the
|
|
|
|
* POWER_BUTTON event should not reach userspace ]
|
|
|
|
*/
|
|
|
|
if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3))
|
|
|
|
acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
local_irq_restore(flags);
|
|
|
|
printk(KERN_DEBUG "Back to C!\n");
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
/* restore processor state */
|
2007-07-24 03:58:39 -06:00
|
|
|
if (acpi_state == ACPI_STATE_S3)
|
2005-04-16 16:20:36 -06:00
|
|
|
acpi_restore_state_mem();
|
|
|
|
|
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_finish - Finish up suspend sequence.
|
2007-07-17 14:40:06 -06:00
|
|
|
* @pm_state: ignored
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* This is called after we wake back up (or if entering the sleep state
|
|
|
|
* failed).
|
|
|
|
*/
|
|
|
|
|
|
|
|
static int acpi_pm_finish(suspend_state_t pm_state)
|
|
|
|
{
|
2007-07-17 14:40:06 -06:00
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
acpi_leave_sleep_state(acpi_state);
|
|
|
|
acpi_disable_wakeup_device(acpi_state);
|
|
|
|
|
|
|
|
/* reset firmware waking vector */
|
|
|
|
acpi_set_firmware_waking_vector((acpi_physical_address) 0);
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
|
|
|
|
2007-07-24 20:26:33 -06:00
|
|
|
#ifdef CONFIG_X86
|
2005-04-16 16:20:36 -06:00
|
|
|
if (init_8259A_after_S1) {
|
|
|
|
printk("Broken toshiba laptop -> kicking interrupts\n");
|
|
|
|
init_8259A(0);
|
|
|
|
}
|
2007-07-24 20:26:33 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-10-30 16:00:01 -07:00
|
|
|
static int acpi_pm_state_valid(suspend_state_t pm_state)
|
|
|
|
{
|
2007-04-30 16:09:54 -06:00
|
|
|
u32 acpi_state;
|
2005-10-30 16:00:01 -07:00
|
|
|
|
2007-04-30 16:09:54 -06:00
|
|
|
switch (pm_state) {
|
|
|
|
case PM_SUSPEND_ON:
|
|
|
|
case PM_SUSPEND_STANDBY:
|
|
|
|
case PM_SUSPEND_MEM:
|
|
|
|
acpi_state = acpi_suspend_states[pm_state];
|
|
|
|
|
|
|
|
return sleep_states[acpi_state];
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
2005-10-30 16:00:01 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct pm_ops acpi_pm_ops = {
|
2005-10-30 16:00:01 -07:00
|
|
|
.valid = acpi_pm_state_valid,
|
2007-07-17 14:40:06 -06:00
|
|
|
.set_target = acpi_pm_set_target,
|
2005-03-18 14:20:46 -07:00
|
|
|
.prepare = acpi_pm_prepare,
|
|
|
|
.enter = acpi_pm_enter,
|
|
|
|
.finish = acpi_pm_finish,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-07-29 15:27:18 -06:00
|
|
|
/*
|
|
|
|
* Toshiba fails to preserve interrupts over S1, reinitialization
|
|
|
|
* of 8259 is needed after S1 resume.
|
|
|
|
*/
|
|
|
|
static int __init init_ints_after_s1(struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
printk(KERN_WARNING "%s with broken S1 detected.\n", d->ident);
|
|
|
|
init_8259A_after_S1 = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
|
|
|
|
{
|
|
|
|
.callback = init_ints_after_s1,
|
|
|
|
.ident = "Toshiba Satellite 4030cdt",
|
|
|
|
.matches = {DMI_MATCH(DMI_PRODUCT_NAME, "S4030CDT/4.3"),},
|
|
|
|
},
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_SUSPEND */
|
|
|
|
|
2007-07-29 15:24:36 -06:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2007-05-09 03:33:18 -06:00
|
|
|
static int acpi_hibernation_prepare(void)
|
|
|
|
{
|
|
|
|
return acpi_sleep_prepare(ACPI_STATE_S4);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int acpi_hibernation_enter(void)
|
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
unsigned long flags = 0;
|
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
acpi_enable_wakeup_device(ACPI_STATE_S4);
|
|
|
|
/* This shouldn't return. If it returns, we have a problem */
|
|
|
|
status = acpi_enter_sleep_state(ACPI_STATE_S4);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_hibernation_finish(void)
|
|
|
|
{
|
|
|
|
acpi_leave_sleep_state(ACPI_STATE_S4);
|
|
|
|
acpi_disable_wakeup_device(ACPI_STATE_S4);
|
|
|
|
|
|
|
|
/* reset firmware waking vector */
|
|
|
|
acpi_set_firmware_waking_vector((acpi_physical_address) 0);
|
|
|
|
}
|
|
|
|
|
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 02:47:30 -06:00
|
|
|
static int acpi_hibernation_pre_restore(void)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = acpi_hw_disable_all_gpes();
|
|
|
|
|
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_hibernation_restore_cleanup(void)
|
|
|
|
{
|
|
|
|
acpi_hw_enable_all_runtime_gpes();
|
|
|
|
}
|
|
|
|
|
2007-05-09 03:33:18 -06:00
|
|
|
static struct hibernation_ops acpi_hibernation_ops = {
|
|
|
|
.prepare = acpi_hibernation_prepare,
|
|
|
|
.enter = acpi_hibernation_enter,
|
|
|
|
.finish = acpi_hibernation_finish,
|
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 02:47:30 -06:00
|
|
|
.pre_restore = acpi_hibernation_pre_restore,
|
|
|
|
.restore_cleanup = acpi_hibernation_restore_cleanup,
|
2007-05-09 03:33:18 -06:00
|
|
|
};
|
2007-07-29 15:24:36 -06:00
|
|
|
#endif /* CONFIG_HIBERNATION */
|
2007-05-09 03:33:18 -06:00
|
|
|
|
2007-07-29 15:27:18 -06:00
|
|
|
int acpi_suspend(u32 acpi_state)
|
|
|
|
{
|
|
|
|
suspend_state_t states[] = {
|
|
|
|
[1] = PM_SUSPEND_STANDBY,
|
|
|
|
[3] = PM_SUSPEND_MEM,
|
|
|
|
[5] = PM_SUSPEND_MAX
|
|
|
|
};
|
|
|
|
|
|
|
|
if (acpi_state < 6 && states[acpi_state])
|
|
|
|
return pm_suspend(states[acpi_state]);
|
|
|
|
if (acpi_state == 4)
|
|
|
|
return hibernate();
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2007-07-17 14:40:25 -06:00
|
|
|
/**
|
|
|
|
* acpi_pm_device_sleep_state - return preferred power state of ACPI device
|
|
|
|
* in the system sleep state given by %acpi_target_sleep_state
|
|
|
|
* @dev: device to examine
|
|
|
|
* @wake: if set, the device should be able to wake up the system
|
|
|
|
* @d_min_p: used to store the upper limit of allowed states range
|
|
|
|
* Return value: preferred power state of the device on success, -ENODEV on
|
|
|
|
* failure (ie. if there's no 'struct acpi_device' for @dev)
|
|
|
|
*
|
|
|
|
* Find the lowest power (highest number) ACPI device power state that
|
|
|
|
* device @dev can be in while the system is in the sleep state represented
|
|
|
|
* by %acpi_target_sleep_state. If @wake is nonzero, the device should be
|
|
|
|
* able to wake up the system from this sleep state. If @d_min_p is set,
|
|
|
|
* the highest power (lowest number) device power state of @dev allowed
|
|
|
|
* in this system sleep state is stored at the location pointed to by it.
|
|
|
|
*
|
|
|
|
* The caller must ensure that @dev is valid before using this function.
|
|
|
|
* The caller is also responsible for figuring out if the device is
|
|
|
|
* supposed to be able to wake up the system and passing this information
|
|
|
|
* via @wake.
|
|
|
|
*/
|
|
|
|
|
|
|
|
int acpi_pm_device_sleep_state(struct device *dev, int wake, int *d_min_p)
|
|
|
|
{
|
|
|
|
acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
|
|
|
|
struct acpi_device *adev;
|
|
|
|
char acpi_method[] = "_SxD";
|
|
|
|
unsigned long d_min, d_max;
|
|
|
|
|
|
|
|
if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
|
2007-08-23 01:01:13 -06:00
|
|
|
printk(KERN_DEBUG "ACPI handle has no context!\n");
|
2007-07-17 14:40:25 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
acpi_method[2] = '0' + acpi_target_sleep_state;
|
|
|
|
/*
|
|
|
|
* If the sleep state is S0, we will return D3, but if the device has
|
|
|
|
* _S0W, we will use the value from _S0W
|
|
|
|
*/
|
|
|
|
d_min = ACPI_STATE_D0;
|
|
|
|
d_max = ACPI_STATE_D3;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If present, _SxD methods return the minimum D-state (highest power
|
|
|
|
* state) we can use for the corresponding S-states. Otherwise, the
|
|
|
|
* minimum D-state is D0 (ACPI 3.x).
|
|
|
|
*
|
|
|
|
* NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
|
|
|
|
* provided -- that's our fault recovery, we ignore retval.
|
|
|
|
*/
|
|
|
|
if (acpi_target_sleep_state > ACPI_STATE_S0)
|
|
|
|
acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If _PRW says we can wake up the system from the target sleep state,
|
|
|
|
* the D-state returned by _SxD is sufficient for that (we assume a
|
|
|
|
* wakeup-aware driver if wake is set). Still, if _SxW exists
|
|
|
|
* (ACPI 3.x), it should return the maximum (lowest power) D-state that
|
|
|
|
* can wake the system. _S0W may be valid, too.
|
|
|
|
*/
|
|
|
|
if (acpi_target_sleep_state == ACPI_STATE_S0 ||
|
|
|
|
(wake && adev->wakeup.state.enabled &&
|
|
|
|
adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
|
|
|
|
acpi_method[3] = 'W';
|
|
|
|
acpi_evaluate_integer(handle, acpi_method, NULL, &d_max);
|
|
|
|
/* Sanity check */
|
|
|
|
if (d_max < d_min)
|
|
|
|
d_min = d_max;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (d_min_p)
|
|
|
|
*d_min_p = d_min;
|
|
|
|
return d_max;
|
|
|
|
}
|
|
|
|
|
2007-09-20 11:32:35 -06:00
|
|
|
static void acpi_power_off_prepare(void)
|
|
|
|
{
|
|
|
|
/* Prepare to power off the system */
|
|
|
|
acpi_sleep_prepare(ACPI_STATE_S5);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_power_off(void)
|
|
|
|
{
|
|
|
|
/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
|
|
|
|
printk("%s called\n", __FUNCTION__);
|
|
|
|
local_irq_disable();
|
|
|
|
acpi_enter_sleep_state(ACPI_STATE_S5);
|
|
|
|
}
|
|
|
|
|
2007-02-09 23:32:16 -07:00
|
|
|
int __init acpi_sleep_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-07-29 15:27:18 -06:00
|
|
|
acpi_status status;
|
|
|
|
u8 type_a, type_b;
|
|
|
|
#ifdef CONFIG_SUSPEND
|
2005-03-18 14:20:46 -07:00
|
|
|
int i = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dmi_check_system(acpisleep_dmi_table);
|
2007-07-29 15:27:18 -06:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return 0;
|
|
|
|
|
2007-09-20 14:27:44 -06:00
|
|
|
sleep_states[ACPI_STATE_S0] = 1;
|
|
|
|
printk(KERN_INFO PREFIX "(supports S0");
|
|
|
|
|
2007-07-29 15:27:18 -06:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2007-09-20 14:27:44 -06:00
|
|
|
for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
status = acpi_get_sleep_type_data(i, &type_a, &type_b);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
sleep_states[i] = 1;
|
|
|
|
printk(" S%d", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pm_set_ops(&acpi_pm_ops);
|
2007-07-29 15:27:18 -06:00
|
|
|
#endif
|
2007-05-09 03:33:18 -06:00
|
|
|
|
2007-07-29 15:24:36 -06:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2007-07-29 15:27:18 -06:00
|
|
|
status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
2007-05-09 03:33:18 -06:00
|
|
|
hibernation_set_ops(&acpi_hibernation_ops);
|
2007-07-29 15:27:18 -06:00
|
|
|
sleep_states[ACPI_STATE_S4] = 1;
|
2007-09-20 11:32:35 -06:00
|
|
|
printk(" S4");
|
2007-07-29 15:27:18 -06:00
|
|
|
}
|
2007-05-09 03:33:18 -06:00
|
|
|
#endif
|
2007-09-20 11:32:35 -06:00
|
|
|
status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
sleep_states[ACPI_STATE_S5] = 1;
|
|
|
|
printk(" S5");
|
|
|
|
pm_power_off_prepare = acpi_power_off_prepare;
|
|
|
|
pm_power_off = acpi_power_off;
|
|
|
|
}
|
|
|
|
printk(")\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|