2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* sleep.c - ACPI sleep support.
|
|
|
|
*
|
2005-03-18 21:20:46 +00:00
|
|
|
* Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
|
2005-04-16 22:20:36 +00: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>
|
2008-08-12 02:20:22 +00:00
|
|
|
#include <linux/reboot.h>
|
2011-02-14 23:42:46 +00:00
|
|
|
#include <linux/acpi.h>
|
2007-09-20 17:32:35 +00:00
|
|
|
|
|
|
|
#include <asm/io.h>
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <acpi/acpi_bus.h>
|
|
|
|
#include <acpi/acpi_drivers.h>
|
2009-03-13 18:08:26 +00:00
|
|
|
|
|
|
|
#include "internal.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "sleep.h"
|
|
|
|
|
2010-10-19 01:47:25 +00:00
|
|
|
static u8 sleep_states[ACPI_S_STATE_COUNT];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-08-12 02:20:22 +00:00
|
|
|
static void acpi_sleep_tts_switch(u32 acpi_state)
|
|
|
|
{
|
|
|
|
union acpi_object in_arg = { ACPI_TYPE_INTEGER };
|
|
|
|
struct acpi_object_list arg_list = { 1, &in_arg };
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
|
|
|
|
in_arg.integer.value = acpi_state;
|
|
|
|
status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL);
|
|
|
|
if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
|
|
|
|
/*
|
|
|
|
* OS can't evaluate the _TTS object correctly. Some warning
|
|
|
|
* message will be printed. But it won't break anything.
|
|
|
|
*/
|
|
|
|
printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tts_notify_reboot(struct notifier_block *this,
|
|
|
|
unsigned long code, void *x)
|
|
|
|
{
|
|
|
|
acpi_sleep_tts_switch(ACPI_STATE_S5);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block tts_notifier = {
|
|
|
|
.notifier_call = tts_notify_reboot,
|
|
|
|
.next = NULL,
|
|
|
|
.priority = 0,
|
|
|
|
};
|
|
|
|
|
2008-01-07 23:10:57 +00:00
|
|
|
static int acpi_sleep_prepare(u32 acpi_state)
|
2007-09-24 12:33:21 +00:00
|
|
|
{
|
|
|
|
#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;
|
|
|
|
}
|
2008-06-24 21:03:48 +00:00
|
|
|
acpi_set_firmware_waking_vector(
|
|
|
|
(acpi_physical_address)acpi_wakeup_address);
|
2007-09-24 12:33:21 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
#endif
|
2008-01-07 23:10:57 +00:00
|
|
|
printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
|
|
|
|
acpi_state);
|
2010-07-07 02:09:38 +00:00
|
|
|
acpi_enable_wakeup_devices(acpi_state);
|
2007-09-24 12:33:21 +00:00
|
|
|
acpi_enter_sleep_state_prep(acpi_state);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-22 18:58:43 +00:00
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
2010-12-07 14:52:25 +00:00
|
|
|
static u32 acpi_target_sleep_state = ACPI_STATE_S0;
|
|
|
|
|
2010-07-23 20:59:09 +00:00
|
|
|
/*
|
|
|
|
* The ACPI specification wants us to save NVS memory regions during hibernation
|
|
|
|
* and to restore them during the subsequent resume. Windows does that also for
|
|
|
|
* suspend to RAM. However, it is known that this mechanism does not work on
|
|
|
|
* all machines, so we allow the user to disable it with the help of the
|
|
|
|
* 'acpi_sleep=nonvs' kernel command line option.
|
|
|
|
*/
|
|
|
|
static bool nvs_nosave;
|
|
|
|
|
|
|
|
void __init acpi_nvs_nosave(void)
|
|
|
|
{
|
|
|
|
nvs_nosave = true;
|
|
|
|
}
|
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
/*
|
|
|
|
* ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
|
|
|
|
* user to request that behavior by using the 'acpi_old_suspend_ordering'
|
|
|
|
* kernel command line option that causes the following variable to be set.
|
|
|
|
*/
|
|
|
|
static bool old_suspend_ordering;
|
|
|
|
|
|
|
|
void __init acpi_old_suspend_ordering(void)
|
|
|
|
{
|
|
|
|
old_suspend_ordering = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-04-08 23:39:40 +00:00
|
|
|
* acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
|
2008-06-12 21:24:06 +00:00
|
|
|
*/
|
2010-04-08 23:39:40 +00:00
|
|
|
static int acpi_pm_freeze(void)
|
2008-06-12 21:24:06 +00:00
|
|
|
{
|
2008-12-16 08:57:46 +00:00
|
|
|
acpi_disable_all_gpes();
|
2010-04-08 23:39:40 +00:00
|
|
|
acpi_os_wait_events_complete(NULL);
|
2010-04-08 23:40:38 +00:00
|
|
|
acpi_ec_block_transactions();
|
2008-06-12 21:24:06 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-01 22:14:09 +00:00
|
|
|
/**
|
|
|
|
* acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
|
|
|
|
*/
|
|
|
|
static int acpi_pm_pre_suspend(void)
|
|
|
|
{
|
|
|
|
acpi_pm_freeze();
|
2011-01-07 00:42:31 +00:00
|
|
|
return suspend_nvs_save();
|
2010-07-01 22:14:09 +00:00
|
|
|
}
|
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
/**
|
|
|
|
* __acpi_pm_prepare - Prepare the platform to enter the target state.
|
|
|
|
*
|
|
|
|
* If necessary, set the firmware waking vector and do arch-specific
|
|
|
|
* nastiness to get the wakeup code to the waking vector.
|
|
|
|
*/
|
|
|
|
static int __acpi_pm_prepare(void)
|
|
|
|
{
|
|
|
|
int error = acpi_sleep_prepare(acpi_target_sleep_state);
|
|
|
|
if (error)
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
2010-07-01 22:14:09 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_prepare - Prepare the platform to enter the target sleep
|
|
|
|
* state and disable the GPEs.
|
|
|
|
*/
|
|
|
|
static int acpi_pm_prepare(void)
|
|
|
|
{
|
|
|
|
int error = __acpi_pm_prepare();
|
|
|
|
if (!error)
|
2011-01-07 00:42:31 +00:00
|
|
|
error = acpi_pm_pre_suspend();
|
2010-04-08 23:39:40 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_finish - Instruct the platform to leave a sleep state.
|
|
|
|
*
|
|
|
|
* This is called after we wake back up (or if entering the sleep state
|
|
|
|
* failed).
|
|
|
|
*/
|
|
|
|
static void acpi_pm_finish(void)
|
|
|
|
{
|
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
|
|
|
|
2010-06-12 05:15:40 +00:00
|
|
|
acpi_ec_unblock_transactions();
|
2011-01-19 21:27:55 +00:00
|
|
|
suspend_nvs_free();
|
2010-05-28 20:32:15 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
if (acpi_state == ACPI_STATE_S0)
|
|
|
|
return;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
|
|
|
|
acpi_state);
|
2010-07-07 02:09:38 +00:00
|
|
|
acpi_disable_wakeup_devices(acpi_state);
|
2008-06-12 21:24:06 +00:00
|
|
|
acpi_leave_sleep_state(acpi_state);
|
|
|
|
|
|
|
|
/* reset firmware waking vector */
|
|
|
|
acpi_set_firmware_waking_vector((acpi_physical_address) 0);
|
|
|
|
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_end - Finish up suspend sequence.
|
|
|
|
*/
|
|
|
|
static void acpi_pm_end(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* This is necessary in case acpi_pm_finish() is not called during a
|
|
|
|
* failing transition to a sleep state.
|
|
|
|
*/
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S0;
|
2008-08-12 02:20:22 +00:00
|
|
|
acpi_sleep_tts_switch(acpi_target_sleep_state);
|
2008-06-12 21:24:06 +00:00
|
|
|
}
|
2008-10-23 19:46:43 +00:00
|
|
|
#else /* !CONFIG_ACPI_SLEEP */
|
|
|
|
#define acpi_target_sleep_state ACPI_STATE_S0
|
2008-10-22 18:58:43 +00:00
|
|
|
#endif /* CONFIG_ACPI_SLEEP */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void do_suspend_lowlevel(void);
|
|
|
|
|
|
|
|
static u32 acpi_suspend_states[] = {
|
2005-03-18 21:20:46 +00: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 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2007-07-17 20:40:06 +00:00
|
|
|
/**
|
2008-04-23 22:02:52 +00:00
|
|
|
* acpi_suspend_begin - Set the target system sleep state to the state
|
2007-07-17 20:40:06 +00:00
|
|
|
* associated with given @pm_state, if supported.
|
|
|
|
*/
|
2008-04-23 22:02:52 +00:00
|
|
|
static int acpi_suspend_begin(suspend_state_t pm_state)
|
2007-07-17 20:40:06 +00:00
|
|
|
{
|
|
|
|
u32 acpi_state = acpi_suspend_states[pm_state];
|
|
|
|
int error = 0;
|
|
|
|
|
2010-07-23 20:59:09 +00:00
|
|
|
error = nvs_nosave ? 0 : suspend_nvs_alloc();
|
2010-05-28 20:32:15 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2007-07-17 20:40:06 +00:00
|
|
|
if (sleep_states[acpi_state]) {
|
|
|
|
acpi_target_sleep_state = acpi_state;
|
2008-08-12 02:20:22 +00:00
|
|
|
acpi_sleep_tts_switch(acpi_target_sleep_state);
|
2007-07-17 20:40:06 +00:00
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "ACPI does not support this state: %d\n",
|
|
|
|
pm_state);
|
|
|
|
error = -ENOSYS;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
2008-04-23 22:02:52 +00:00
|
|
|
* acpi_suspend_enter - Actually enter a sleep state.
|
2007-07-17 20:40:06 +00:00
|
|
|
* @pm_state: ignored
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-07-24 09:58:39 +00: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 22:20:36 +00:00
|
|
|
* It's unfortunate, but it works. Please fix if you're feeling frisky.
|
|
|
|
*/
|
2008-04-23 22:02:52 +00:00
|
|
|
static int acpi_suspend_enter(suspend_state_t pm_state)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
unsigned long flags = 0;
|
2007-07-17 20:40:06 +00:00
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
|
|
|
/* Do arch specific saving of state. */
|
2007-07-24 09:58:39 +00:00
|
|
|
if (acpi_state == ACPI_STATE_S3) {
|
2005-04-16 22:20:36 +00:00
|
|
|
int error = acpi_save_state_mem();
|
2007-07-17 20:40:06 +00:00
|
|
|
|
2008-01-07 23:07:39 +00:00
|
|
|
if (error)
|
2005-04-16 22:20:36 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2007-07-17 20:40:06 +00:00
|
|
|
switch (acpi_state) {
|
|
|
|
case ACPI_STATE_S1:
|
2005-04-16 22:20:36 +00:00
|
|
|
barrier();
|
|
|
|
status = acpi_enter_sleep_state(acpi_state);
|
|
|
|
break;
|
|
|
|
|
2007-07-17 20:40:06 +00:00
|
|
|
case ACPI_STATE_S3:
|
2005-04-16 22:20:36 +00:00
|
|
|
do_suspend_lowlevel();
|
|
|
|
break;
|
|
|
|
}
|
2006-04-27 09:25:00 +00:00
|
|
|
|
2010-05-11 17:49:25 +00:00
|
|
|
/* This violates the spec but is required for bug compatibility. */
|
|
|
|
acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
|
2008-11-26 22:53:13 +00:00
|
|
|
|
2008-01-07 23:05:21 +00:00
|
|
|
/* Reprogram control registers and execute _BFS */
|
|
|
|
acpi_leave_sleep_state_prep(acpi_state);
|
|
|
|
|
2008-02-05 18:27:12 +00:00
|
|
|
/* ACPI 3.0 specs (P62) says that it's the responsibility
|
2006-04-27 09:25:00 +00:00
|
|
|
* 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);
|
|
|
|
|
2007-06-20 01:17:58 +00:00
|
|
|
/*
|
|
|
|
* Disable and clear GPE status before interrupt is enabled. Some GPEs
|
|
|
|
* (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
|
|
|
|
* acpi_leave_sleep_state will reenable specific GPEs later
|
|
|
|
*/
|
2008-12-16 08:57:46 +00:00
|
|
|
acpi_disable_all_gpes();
|
2010-04-08 23:39:40 +00:00
|
|
|
/* Allow EC transactions to happen. */
|
2010-04-08 23:40:38 +00:00
|
|
|
acpi_ec_unblock_transactions_early();
|
2007-06-20 01:17:58 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
printk(KERN_DEBUG "Back to C!\n");
|
|
|
|
|
2007-07-17 20:40:06 +00:00
|
|
|
/* restore processor state */
|
2007-07-24 09:58:39 +00:00
|
|
|
if (acpi_state == ACPI_STATE_S3)
|
2005-04-16 22:20:36 +00:00
|
|
|
acpi_restore_state_mem();
|
|
|
|
|
2010-05-28 20:32:15 +00:00
|
|
|
suspend_nvs_restore();
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
2008-04-23 22:02:52 +00:00
|
|
|
static int acpi_suspend_state_valid(suspend_state_t pm_state)
|
2005-10-30 23:00:01 +00:00
|
|
|
{
|
2007-04-30 22:09:54 +00:00
|
|
|
u32 acpi_state;
|
2005-10-30 23:00:01 +00:00
|
|
|
|
2007-04-30 22:09:54 +00: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 23:00:01 +00:00
|
|
|
}
|
|
|
|
|
2010-11-16 13:14:02 +00:00
|
|
|
static const struct platform_suspend_ops acpi_suspend_ops = {
|
2008-04-23 22:02:52 +00:00
|
|
|
.valid = acpi_suspend_state_valid,
|
|
|
|
.begin = acpi_suspend_begin,
|
2009-04-19 18:08:42 +00:00
|
|
|
.prepare_late = acpi_pm_prepare,
|
2008-04-23 22:02:52 +00:00
|
|
|
.enter = acpi_suspend_enter,
|
2010-07-01 22:14:57 +00:00
|
|
|
.wake = acpi_pm_finish,
|
2008-06-12 21:24:06 +00:00
|
|
|
.end = acpi_pm_end,
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_suspend_begin_old - Set the target system sleep state to the
|
|
|
|
* state associated with given @pm_state, if supported, and
|
|
|
|
* execute the _PTS control method. This function is used if the
|
|
|
|
* pre-ACPI 2.0 suspend ordering has been requested.
|
|
|
|
*/
|
|
|
|
static int acpi_suspend_begin_old(suspend_state_t pm_state)
|
|
|
|
{
|
|
|
|
int error = acpi_suspend_begin(pm_state);
|
|
|
|
if (!error)
|
|
|
|
error = __acpi_pm_prepare();
|
2010-07-01 22:14:09 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
|
|
|
|
* been requested.
|
|
|
|
*/
|
2010-11-16 13:14:02 +00:00
|
|
|
static const struct platform_suspend_ops acpi_suspend_ops_old = {
|
2008-06-12 21:24:06 +00:00
|
|
|
.valid = acpi_suspend_state_valid,
|
|
|
|
.begin = acpi_suspend_begin_old,
|
2010-07-01 22:14:09 +00:00
|
|
|
.prepare_late = acpi_pm_pre_suspend,
|
2008-04-23 22:02:52 +00:00
|
|
|
.enter = acpi_suspend_enter,
|
2010-07-01 22:14:57 +00:00
|
|
|
.wake = acpi_pm_finish,
|
2008-06-12 21:24:06 +00:00
|
|
|
.end = acpi_pm_end,
|
|
|
|
.recover = acpi_pm_finish,
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2008-07-24 04:28:43 +00:00
|
|
|
|
|
|
|
static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
old_suspend_ordering = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-09-24 20:46:14 +00:00
|
|
|
static int __init init_nvs_nosave(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
acpi_nvs_nosave();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-24 04:28:43 +00:00
|
|
|
static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
|
|
|
|
{
|
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "Abit KN9 (nForce4 variant)",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
|
|
|
|
},
|
|
|
|
},
|
2008-10-14 20:54:06 +00:00
|
|
|
{
|
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "HP xw4600 Workstation",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
|
|
|
|
},
|
|
|
|
},
|
2008-11-26 22:53:13 +00:00
|
|
|
{
|
2009-02-11 18:11:22 +00:00
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
|
|
|
|
},
|
|
|
|
},
|
2009-03-16 02:13:44 +00:00
|
|
|
{
|
2009-03-18 08:36:25 +00:00
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "Panasonic CF51-2L",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR,
|
|
|
|
"Matsushita Electric Industrial Co.,Ltd."),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
|
|
|
|
},
|
|
|
|
},
|
2010-09-24 20:46:14 +00:00
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VGN-SR11M",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Everex StepNote Series",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
|
|
|
|
},
|
|
|
|
},
|
2010-10-17 19:01:21 +00:00
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VPCEB1Z1E",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
|
|
|
|
},
|
|
|
|
},
|
2010-12-12 20:10:42 +00:00
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VGN-NW130D",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
|
|
|
|
},
|
|
|
|
},
|
2011-01-06 22:37:01 +00:00
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Averatec AV1020-ED2",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
|
|
|
|
},
|
|
|
|
},
|
2008-07-24 04:28:43 +00:00
|
|
|
{},
|
|
|
|
};
|
2007-07-29 21:27:18 +00:00
|
|
|
#endif /* CONFIG_SUSPEND */
|
|
|
|
|
2007-07-29 21:24:36 +00:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2008-07-24 04:28:41 +00:00
|
|
|
static unsigned long s4_hardware_signature;
|
|
|
|
static struct acpi_table_facs *facs;
|
|
|
|
static bool nosigcheck;
|
|
|
|
|
|
|
|
void __init acpi_no_s4_hw_signature(void)
|
|
|
|
{
|
|
|
|
nosigcheck = true;
|
|
|
|
}
|
|
|
|
|
2008-01-07 23:08:44 +00:00
|
|
|
static int acpi_hibernation_begin(void)
|
2007-10-18 10:04:42 +00:00
|
|
|
{
|
2008-10-26 19:52:15 +00:00
|
|
|
int error;
|
|
|
|
|
2010-07-23 20:59:09 +00:00
|
|
|
error = nvs_nosave ? 0 : suspend_nvs_alloc();
|
2008-10-26 19:52:15 +00:00
|
|
|
if (!error) {
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S4;
|
|
|
|
acpi_sleep_tts_switch(acpi_target_sleep_state);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-09 09:33:18 +00:00
|
|
|
static int acpi_hibernation_enter(void)
|
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
unsigned long flags = 0;
|
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
/* This shouldn't return. If it returns, we have a problem */
|
|
|
|
status = acpi_enter_sleep_state(ACPI_STATE_S4);
|
2008-01-07 23:05:21 +00:00
|
|
|
/* Reprogram control registers and execute _BFS */
|
|
|
|
acpi_leave_sleep_state_prep(ACPI_STATE_S4);
|
2007-05-09 09:33:18 +00:00
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
2007-10-18 10:04:55 +00:00
|
|
|
static void acpi_hibernation_leave(void)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* If ACPI is not enabled by the BIOS and the boot kernel, we need to
|
|
|
|
* enable it here.
|
|
|
|
*/
|
|
|
|
acpi_enable();
|
2008-01-07 23:05:21 +00:00
|
|
|
/* Reprogram control registers and execute _BFS */
|
|
|
|
acpi_leave_sleep_state_prep(ACPI_STATE_S4);
|
2008-07-24 04:28:41 +00:00
|
|
|
/* Check the hardware signature */
|
|
|
|
if (facs && s4_hardware_signature != facs->hardware_signature) {
|
|
|
|
printk(KERN_EMERG "ACPI: Hardware changed while hibernated, "
|
|
|
|
"cannot resume!\n");
|
|
|
|
panic("ACPI S4 hardware signature mismatch");
|
|
|
|
}
|
2008-10-26 19:52:15 +00:00
|
|
|
/* Restore the NVS memory area */
|
2010-05-28 20:32:14 +00:00
|
|
|
suspend_nvs_restore();
|
2010-04-08 23:39:40 +00:00
|
|
|
/* Allow EC transactions to happen. */
|
2010-04-08 23:40:38 +00:00
|
|
|
acpi_ec_unblock_transactions_early();
|
2007-10-18 10:04:55 +00:00
|
|
|
}
|
|
|
|
|
2010-04-08 23:39:40 +00:00
|
|
|
static void acpi_pm_thaw(void)
|
2010-03-04 00:52:58 +00:00
|
|
|
{
|
2010-04-08 23:40:38 +00:00
|
|
|
acpi_ec_unblock_transactions();
|
2008-12-16 08:57:46 +00:00
|
|
|
acpi_enable_all_runtime_gpes();
|
2007-05-09 09:33:18 +00:00
|
|
|
}
|
|
|
|
|
2010-11-09 20:48:49 +00:00
|
|
|
static const struct platform_hibernation_ops acpi_hibernation_ops = {
|
2008-06-12 21:24:06 +00:00
|
|
|
.begin = acpi_hibernation_begin,
|
|
|
|
.end = acpi_pm_end,
|
2010-07-01 22:14:09 +00:00
|
|
|
.pre_snapshot = acpi_pm_prepare,
|
2010-05-28 20:32:15 +00:00
|
|
|
.finish = acpi_pm_finish,
|
2008-06-12 21:24:06 +00:00
|
|
|
.prepare = acpi_pm_prepare,
|
|
|
|
.enter = acpi_hibernation_enter,
|
|
|
|
.leave = acpi_hibernation_leave,
|
2010-04-08 23:39:40 +00:00
|
|
|
.pre_restore = acpi_pm_freeze,
|
|
|
|
.restore_cleanup = acpi_pm_thaw,
|
2008-06-12 21:24:06 +00:00
|
|
|
};
|
2008-01-07 23:08:44 +00:00
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
/**
|
|
|
|
* acpi_hibernation_begin_old - Set the target system sleep state to
|
|
|
|
* ACPI_STATE_S4 and execute the _PTS control method. This
|
|
|
|
* function is used if the pre-ACPI 2.0 suspend ordering has been
|
|
|
|
* requested.
|
|
|
|
*/
|
|
|
|
static int acpi_hibernation_begin_old(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 08:47:30 +00:00
|
|
|
{
|
2008-08-12 02:20:22 +00:00
|
|
|
int error;
|
|
|
|
/*
|
|
|
|
* The _TTS object should always be evaluated before the _PTS object.
|
|
|
|
* When the old_suspended_ordering is true, the _PTS object is
|
|
|
|
* evaluated in the acpi_sleep_prepare.
|
|
|
|
*/
|
|
|
|
acpi_sleep_tts_switch(ACPI_STATE_S4);
|
|
|
|
|
|
|
|
error = acpi_sleep_prepare(ACPI_STATE_S4);
|
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 08:47:30 +00:00
|
|
|
|
2008-10-26 19:52:15 +00:00
|
|
|
if (!error) {
|
2010-07-23 20:59:09 +00:00
|
|
|
if (!nvs_nosave)
|
2010-05-28 20:32:14 +00:00
|
|
|
error = suspend_nvs_alloc();
|
2008-10-26 19:52:15 +00:00
|
|
|
if (!error)
|
|
|
|
acpi_target_sleep_state = ACPI_STATE_S4;
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
/*
|
|
|
|
* The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
|
|
|
|
* been requested.
|
|
|
|
*/
|
2010-11-09 20:48:49 +00:00
|
|
|
static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
|
2008-06-12 21:24:06 +00:00
|
|
|
.begin = acpi_hibernation_begin_old,
|
|
|
|
.end = acpi_pm_end,
|
2010-07-01 22:14:09 +00:00
|
|
|
.pre_snapshot = acpi_pm_pre_suspend,
|
2010-04-08 23:39:40 +00:00
|
|
|
.prepare = acpi_pm_freeze,
|
2010-05-28 20:32:15 +00:00
|
|
|
.finish = acpi_pm_finish,
|
2007-05-09 09:33:18 +00:00
|
|
|
.enter = acpi_hibernation_enter,
|
2007-10-18 10:04:55 +00:00
|
|
|
.leave = acpi_hibernation_leave,
|
2010-04-08 23:39:40 +00:00
|
|
|
.pre_restore = acpi_pm_freeze,
|
|
|
|
.restore_cleanup = acpi_pm_thaw,
|
2008-06-12 21:24:06 +00:00
|
|
|
.recover = acpi_pm_finish,
|
2007-05-09 09:33:18 +00:00
|
|
|
};
|
2008-06-12 21:24:06 +00:00
|
|
|
#endif /* CONFIG_HIBERNATION */
|
2007-05-09 09:33:18 +00:00
|
|
|
|
2007-07-29 21:27:18 +00: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;
|
|
|
|
}
|
|
|
|
|
2011-02-10 23:06:54 +00:00
|
|
|
#ifdef CONFIG_PM
|
2007-07-17 20:40:25 +00:00
|
|
|
/**
|
|
|
|
* acpi_pm_device_sleep_state - return preferred power state of ACPI device
|
|
|
|
* in the system sleep state given by %acpi_target_sleep_state
|
2008-06-04 23:15:40 +00:00
|
|
|
* @dev: device to examine; its driver model wakeup flags control
|
|
|
|
* whether it should be able to wake up the system
|
2007-07-17 20:40:25 +00:00
|
|
|
* @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.
|
|
|
|
*/
|
|
|
|
|
2008-06-04 23:15:40 +00:00
|
|
|
int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
|
2007-07-17 20:40:25 +00:00
|
|
|
{
|
|
|
|
acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
|
|
|
|
struct acpi_device *adev;
|
|
|
|
char acpi_method[] = "_SxD";
|
2008-10-10 06:22:59 +00:00
|
|
|
unsigned long long d_min, d_max;
|
2007-07-17 20:40:25 +00:00
|
|
|
|
|
|
|
if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
|
2007-08-23 07:01:13 +00:00
|
|
|
printk(KERN_DEBUG "ACPI handle has no context!\n");
|
2007-07-17 20:40:25 +00: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 ||
|
2010-10-14 21:24:13 +00:00
|
|
|
(device_may_wakeup(dev) &&
|
2007-07-17 20:40:25 +00:00
|
|
|
adev->wakeup.sleep_state <= acpi_target_sleep_state)) {
|
2008-01-10 23:10:38 +00:00
|
|
|
acpi_status status;
|
|
|
|
|
2007-07-17 20:40:25 +00:00
|
|
|
acpi_method[3] = 'W';
|
2008-01-10 23:10:38 +00:00
|
|
|
status = acpi_evaluate_integer(handle, acpi_method, NULL,
|
|
|
|
&d_max);
|
|
|
|
if (ACPI_FAILURE(status)) {
|
2010-10-14 21:24:13 +00:00
|
|
|
if (acpi_target_sleep_state != ACPI_STATE_S0 ||
|
|
|
|
status != AE_NOT_FOUND)
|
|
|
|
d_max = d_min;
|
2008-01-10 23:10:38 +00:00
|
|
|
} else if (d_max < d_min) {
|
|
|
|
/* Warn the user of the broken DSDT */
|
|
|
|
printk(KERN_WARNING "ACPI: Wrong value from %s\n",
|
|
|
|
acpi_method);
|
|
|
|
/* Sanitize it */
|
2007-07-17 20:40:25 +00:00
|
|
|
d_min = d_max;
|
2008-01-10 23:10:38 +00:00
|
|
|
}
|
2007-07-17 20:40:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (d_min_p)
|
|
|
|
*d_min_p = d_min;
|
|
|
|
return d_max;
|
|
|
|
}
|
2011-02-10 23:06:54 +00:00
|
|
|
#endif /* CONFIG_PM */
|
2008-07-07 01:34:48 +00:00
|
|
|
|
2010-10-14 21:24:13 +00:00
|
|
|
#ifdef CONFIG_PM_SLEEP
|
2008-07-07 01:34:48 +00:00
|
|
|
/**
|
|
|
|
* acpi_pm_device_sleep_wake - enable or disable the system wake-up
|
|
|
|
* capability of given device
|
|
|
|
* @dev: device to handle
|
|
|
|
* @enable: 'true' - enable, 'false' - disable the wake-up capability
|
|
|
|
*/
|
|
|
|
int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
|
|
|
|
{
|
|
|
|
acpi_handle handle;
|
|
|
|
struct acpi_device *adev;
|
2009-09-08 21:13:49 +00:00
|
|
|
int error;
|
2008-07-07 01:34:48 +00:00
|
|
|
|
PCI / ACPI PM: Propagate wake-up enable for devices w/o ACPI support
Some PCI devices (not PCI Express), like PCI add-on cards, can
generate PME#, but they don't have any special platform wake-up
support. For this reason, even if they generate PME# to wake up the
system from a sleep state, wake-up events are not generated by the
platform.
It turns out that, at least on some systems, PCI bridges and the PCI
host bridge have ACPI GPEs associated with them that, if enabled to
generate wake-up events, allow the system to wake up if one of the
add-on devices asserts PME# while the system is in a sleep state.
Following this observation, if a PCI device without direct ACPI
wake-up support is prepared to wake up the system during a transition
into a sleep state (eg. suspend to RAM), try to configure the bridges
on the path from the device to the root bridge to wake-up the system.
Reviewed-by: Matthew Garrett <mjg59@srcf.ucam.org>
Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Signed-off-by: Jesse Barnes <jbarnes@virtuousgeek.org>
2009-09-08 21:16:24 +00:00
|
|
|
if (!device_can_wakeup(dev))
|
2008-07-07 01:34:48 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
handle = DEVICE_ACPI_HANDLE(dev);
|
|
|
|
if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
|
2009-09-08 21:13:49 +00:00
|
|
|
dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__);
|
2008-07-07 01:34:48 +00:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2010-06-24 23:18:39 +00:00
|
|
|
error = enable ?
|
|
|
|
acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
|
|
|
|
acpi_disable_wakeup_device_power(adev);
|
2009-09-08 21:13:49 +00:00
|
|
|
if (!error)
|
|
|
|
dev_info(dev, "wake-up capability %s by ACPI\n",
|
|
|
|
enable ? "enabled" : "disabled");
|
|
|
|
|
|
|
|
return error;
|
2008-07-07 01:34:48 +00:00
|
|
|
}
|
2010-10-14 21:24:13 +00:00
|
|
|
#endif /* CONFIG_PM_SLEEP */
|
2007-07-17 20:40:25 +00:00
|
|
|
|
2007-09-20 17:32:35 +00:00
|
|
|
static void acpi_power_off_prepare(void)
|
|
|
|
{
|
|
|
|
/* Prepare to power off the system */
|
|
|
|
acpi_sleep_prepare(ACPI_STATE_S5);
|
2008-12-16 08:57:46 +00:00
|
|
|
acpi_disable_all_gpes();
|
2007-09-20 17:32:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_power_off(void)
|
|
|
|
{
|
|
|
|
/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
|
2009-02-04 16:03:07 +00:00
|
|
|
printk(KERN_DEBUG "%s called\n", __func__);
|
2007-09-20 17:32:35 +00:00
|
|
|
local_irq_disable();
|
|
|
|
acpi_enter_sleep_state(ACPI_STATE_S5);
|
|
|
|
}
|
|
|
|
|
2009-04-18 03:32:20 +00:00
|
|
|
/*
|
|
|
|
* ACPI 2.0 created the optional _GTS and _BFS,
|
|
|
|
* but industry adoption has been neither rapid nor broad.
|
|
|
|
*
|
|
|
|
* Linux gets into trouble when it executes poorly validated
|
|
|
|
* paths through the BIOS, so disable _GTS and _BFS by default,
|
|
|
|
* but do speak up and offer the option to enable them.
|
|
|
|
*/
|
2010-10-19 01:47:25 +00:00
|
|
|
static void __init acpi_gts_bfs_check(void)
|
2009-04-18 03:32:20 +00:00
|
|
|
{
|
|
|
|
acpi_handle dummy;
|
|
|
|
|
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__GTS, &dummy)))
|
|
|
|
{
|
|
|
|
printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n");
|
|
|
|
printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, "
|
|
|
|
"please notify linux-acpi@vger.kernel.org\n");
|
|
|
|
}
|
|
|
|
if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__BFS, &dummy)))
|
|
|
|
{
|
|
|
|
printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n");
|
|
|
|
printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, "
|
|
|
|
"please notify linux-acpi@vger.kernel.org\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-10 06:32:16 +00:00
|
|
|
int __init acpi_sleep_init(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-07-29 21:27:18 +00:00
|
|
|
acpi_status status;
|
|
|
|
u8 type_a, type_b;
|
|
|
|
#ifdef CONFIG_SUSPEND
|
2005-03-18 21:20:46 +00:00
|
|
|
int i = 0;
|
2008-07-24 04:28:43 +00:00
|
|
|
|
|
|
|
dmi_check_system(acpisleep_dmi_table);
|
2007-07-29 21:27:18 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if (acpi_disabled)
|
|
|
|
return 0;
|
|
|
|
|
2007-09-20 20:27:44 +00:00
|
|
|
sleep_states[ACPI_STATE_S0] = 1;
|
|
|
|
printk(KERN_INFO PREFIX "(supports S0");
|
|
|
|
|
2007-07-29 21:27:18 +00:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2007-09-20 20:27:44 +00:00
|
|
|
for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
|
2005-04-16 22:20:36 +00:00
|
|
|
status = acpi_get_sleep_type_data(i, &type_a, &type_b);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
|
|
|
sleep_states[i] = 1;
|
|
|
|
printk(" S%d", i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-06-12 21:24:06 +00:00
|
|
|
suspend_set_ops(old_suspend_ordering ?
|
|
|
|
&acpi_suspend_ops_old : &acpi_suspend_ops);
|
2007-07-29 21:27:18 +00:00
|
|
|
#endif
|
2007-05-09 09:33:18 +00:00
|
|
|
|
2007-07-29 21:24:36 +00:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2007-07-29 21:27:18 +00:00
|
|
|
status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
|
|
|
|
if (ACPI_SUCCESS(status)) {
|
2008-06-12 21:24:06 +00:00
|
|
|
hibernation_set_ops(old_suspend_ordering ?
|
|
|
|
&acpi_hibernation_ops_old : &acpi_hibernation_ops);
|
2007-07-29 21:27:18 +00:00
|
|
|
sleep_states[ACPI_STATE_S4] = 1;
|
2007-09-20 17:32:35 +00:00
|
|
|
printk(" S4");
|
2008-07-24 04:28:41 +00:00
|
|
|
if (!nosigcheck) {
|
2008-12-16 08:57:46 +00:00
|
|
|
acpi_get_table(ACPI_SIG_FACS, 1,
|
2008-07-24 04:28:41 +00:00
|
|
|
(struct acpi_table_header **)&facs);
|
|
|
|
if (facs)
|
|
|
|
s4_hardware_signature =
|
|
|
|
facs->hardware_signature;
|
|
|
|
}
|
2007-07-29 21:27:18 +00:00
|
|
|
}
|
2007-05-09 09:33:18 +00:00
|
|
|
#endif
|
2007-09-20 17:32:35 +00: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");
|
2008-08-12 02:20:22 +00:00
|
|
|
/*
|
|
|
|
* Register the tts_notifier to reboot notifier list so that the _TTS
|
|
|
|
* object can also be evaluated when the system enters S5.
|
|
|
|
*/
|
|
|
|
register_reboot_notifier(&tts_notifier);
|
2009-04-18 03:32:20 +00:00
|
|
|
acpi_gts_bfs_check();
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|