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>
|
2014-09-29 18:29:01 -06:00
|
|
|
#include <linux/interrupt.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/suspend.h>
|
2008-08-11 20:20:22 -06:00
|
|
|
#include <linux/reboot.h>
|
2011-02-14 16:42:46 -07:00
|
|
|
#include <linux/acpi.h>
|
2012-03-20 20:58:46 -06:00
|
|
|
#include <linux/module.h>
|
2007-09-20 11:32:35 -06:00
|
|
|
#include <asm/io.h>
|
2014-06-06 06:40:17 -06:00
|
|
|
#include <trace/events/power.h>
|
2007-09-20 11:32:35 -06:00
|
|
|
|
2009-03-13 12:08:26 -06:00
|
|
|
#include "internal.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "sleep.h"
|
|
|
|
|
2010-10-18 19:47:25 -06:00
|
|
|
static u8 sleep_states[ACPI_S_STATE_COUNT];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-11 20:20:22 -06:00
|
|
|
static void acpi_sleep_tts_switch(u32 acpi_state)
|
|
|
|
{
|
2013-06-28 10:24:39 -06:00
|
|
|
acpi_status status;
|
2008-08-11 20:20:22 -06:00
|
|
|
|
2013-06-28 10:24:39 -06:00
|
|
|
status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
|
2008-08-11 20:20:22 -06:00
|
|
|
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 16:10:57 -07:00
|
|
|
static int acpi_sleep_prepare(u32 acpi_state)
|
2007-09-24 06:33:21 -06:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
|
|
|
/* do we have a wakeup address for S2 and S3? */
|
|
|
|
if (acpi_state == ACPI_STATE_S3) {
|
2012-05-30 03:33:41 -06:00
|
|
|
if (!acpi_wakeup_address)
|
2007-09-24 06:33:21 -06:00
|
|
|
return -EFAULT;
|
2012-05-30 03:33:41 -06:00
|
|
|
acpi_set_firmware_waking_vector(acpi_wakeup_address);
|
2007-09-24 06:33:21 -06:00
|
|
|
|
|
|
|
}
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
#endif
|
2008-01-07 16:10:57 -07:00
|
|
|
printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
|
|
|
|
acpi_state);
|
2010-07-06 20:09:38 -06:00
|
|
|
acpi_enable_wakeup_devices(acpi_state);
|
2007-09-24 06:33:21 -06:00
|
|
|
acpi_enter_sleep_state_prep(acpi_state);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-03-13 15:11:39 -06:00
|
|
|
static bool acpi_sleep_state_supported(u8 sleep_state)
|
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
u8 type_a, type_b;
|
|
|
|
|
|
|
|
status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
|
|
|
|
return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
|
|
|
|
|| (acpi_gbl_FADT.sleep_control.address
|
|
|
|
&& acpi_gbl_FADT.sleep_status.address));
|
|
|
|
}
|
|
|
|
|
2008-10-22 12:58:43 -06:00
|
|
|
#ifdef CONFIG_ACPI_SLEEP
|
2010-12-07 07:52:25 -07:00
|
|
|
static u32 acpi_target_sleep_state = ACPI_STATE_S0;
|
2012-11-01 18:40:53 -06:00
|
|
|
|
|
|
|
u32 acpi_target_system_state(void)
|
|
|
|
{
|
|
|
|
return acpi_target_sleep_state;
|
|
|
|
}
|
2014-05-08 15:22:15 -06:00
|
|
|
EXPORT_SYMBOL_GPL(acpi_target_system_state);
|
2012-11-01 18:40:53 -06:00
|
|
|
|
2012-07-23 13:01:02 -06:00
|
|
|
static bool pwr_btn_event_pending;
|
2010-12-07 07:52:25 -07:00
|
|
|
|
2010-07-23 14:59:09 -06: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;
|
|
|
|
}
|
|
|
|
|
2012-10-26 05:39:15 -06:00
|
|
|
/*
|
|
|
|
* The ACPI specification wants us to save NVS memory regions during hibernation
|
|
|
|
* but says nothing about saving NVS during S3. Not all versions of Windows
|
|
|
|
* save NVS on S3 suspend either, and it is clear that not all systems need
|
|
|
|
* NVS to be saved at S3 time. To improve suspend/resume time, allow the
|
|
|
|
* user to disable saving NVS on S3 if their system does not require it, but
|
|
|
|
* continue to save/restore NVS for S4 as specified.
|
|
|
|
*/
|
|
|
|
static bool nvs_nosave_s3;
|
|
|
|
|
|
|
|
void __init acpi_nvs_nosave_s3(void)
|
|
|
|
{
|
|
|
|
nvs_nosave_s3 = true;
|
|
|
|
}
|
|
|
|
|
2008-06-12 15:24:06 -06: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;
|
|
|
|
}
|
|
|
|
|
2012-11-30 04:57:03 -07:00
|
|
|
static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
acpi_old_suspend_ordering();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __init init_nvs_nosave(const struct dmi_system_id *d)
|
|
|
|
{
|
|
|
|
acpi_nvs_nosave();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-07 05:46:57 -06:00
|
|
|
static struct dmi_system_id acpisleep_dmi_table[] __initdata = {
|
2012-11-30 04:57:03 -07:00
|
|
|
{
|
|
|
|
.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)"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.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"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.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"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.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"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
2013-02-04 17:16:29 -07:00
|
|
|
.ident = "Sony Vaio VGN-FW41E_H",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
2012-11-30 04:57:03 -07:00
|
|
|
.ident = "Sony Vaio VGN-FW21E",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
2013-03-11 13:16:34 -06:00
|
|
|
.ident = "Sony Vaio VGN-FW21M",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
2012-11-30 04:57:03 -07:00
|
|
|
.ident = "Sony Vaio VPCEB17FX",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.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"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VPCEB1Z1E",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VGN-NW130D",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VPCCW29FX",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Averatec AV1020-ED2",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "Asus A8N-SLI DELUXE",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_old_suspend_ordering,
|
|
|
|
.ident = "Asus A8N-SLI Premium",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
|
|
|
|
DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VGN-SR26GN_P",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VPCEB1S1E",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Sony Vaio VGN-FW520F",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Asus K54C",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.callback = init_nvs_nosave,
|
|
|
|
.ident = "Asus K54HR",
|
|
|
|
.matches = {
|
|
|
|
DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
|
|
|
|
DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
{},
|
|
|
|
};
|
|
|
|
|
2015-01-23 01:12:06 -07:00
|
|
|
static void __init acpi_sleep_dmi_check(void)
|
2012-11-30 04:57:03 -07:00
|
|
|
{
|
2014-07-23 00:42:33 -06:00
|
|
|
int year;
|
|
|
|
|
|
|
|
if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2012)
|
|
|
|
acpi_nvs_nosave_s3();
|
|
|
|
|
2012-11-30 04:57:03 -07:00
|
|
|
dmi_check_system(acpisleep_dmi_table);
|
|
|
|
}
|
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
/**
|
2010-04-08 17:39:40 -06:00
|
|
|
* acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
|
2008-06-12 15:24:06 -06:00
|
|
|
*/
|
2010-04-08 17:39:40 -06:00
|
|
|
static int acpi_pm_freeze(void)
|
2008-06-12 15:24:06 -06:00
|
|
|
{
|
2008-12-16 01:57:46 -07:00
|
|
|
acpi_disable_all_gpes();
|
2012-05-22 02:43:49 -06:00
|
|
|
acpi_os_wait_events_complete();
|
2010-04-08 17:40:38 -06:00
|
|
|
acpi_ec_block_transactions();
|
2008-06-12 15:24:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-07-01 16:14:09 -06:00
|
|
|
/**
|
|
|
|
* acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
|
|
|
|
*/
|
|
|
|
static int acpi_pm_pre_suspend(void)
|
|
|
|
{
|
|
|
|
acpi_pm_freeze();
|
2011-01-06 17:42:31 -07:00
|
|
|
return suspend_nvs_save();
|
2010-07-01 16:14:09 -06:00
|
|
|
}
|
|
|
|
|
2008-06-12 15:24:06 -06: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 16:14:09 -06:00
|
|
|
|
2008-06-12 15:24:06 -06: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-06 17:42:31 -07:00
|
|
|
error = acpi_pm_pre_suspend();
|
2010-04-08 17:39:40 -06:00
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-05-09 17:08:43 -06:00
|
|
|
static int find_powerf_dev(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct acpi_device *device = to_acpi_device(dev);
|
|
|
|
const char *hid = acpi_device_hid(device);
|
|
|
|
|
|
|
|
return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
|
|
|
|
}
|
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
/**
|
|
|
|
* 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)
|
|
|
|
{
|
2012-05-09 17:08:43 -06:00
|
|
|
struct device *pwr_btn_dev;
|
2008-06-12 15:24:06 -06:00
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
|
|
|
|
2010-06-11 23:15:40 -06:00
|
|
|
acpi_ec_unblock_transactions();
|
2011-01-19 14:27:55 -07:00
|
|
|
suspend_nvs_free();
|
2010-05-28 14:32:15 -06:00
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
if (acpi_state == ACPI_STATE_S0)
|
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
|
|
|
|
acpi_state);
|
2010-07-06 20:09:38 -06:00
|
|
|
acpi_disable_wakeup_devices(acpi_state);
|
2008-06-12 15:24:06 -06: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;
|
2012-05-09 17:08:43 -06:00
|
|
|
|
2013-01-17 06:11:06 -07:00
|
|
|
acpi_resume_power_resources();
|
|
|
|
|
2012-05-09 17:08:43 -06:00
|
|
|
/* If we were woken with the fixed power button, provide a small
|
|
|
|
* hint to userspace in the form of a wakeup event on the fixed power
|
|
|
|
* button device (if it can be found).
|
|
|
|
*
|
|
|
|
* We delay the event generation til now, as the PM layer requires
|
|
|
|
* timekeeping to be running before we generate events. */
|
|
|
|
if (!pwr_btn_event_pending)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pwr_btn_event_pending = false;
|
|
|
|
pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
|
|
|
|
find_powerf_dev);
|
|
|
|
if (pwr_btn_dev) {
|
|
|
|
pm_wakeup_event(pwr_btn_dev, 0);
|
|
|
|
put_device(pwr_btn_dev);
|
|
|
|
}
|
2008-06-12 15:24:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-08-19 17:42:32 -06:00
|
|
|
* acpi_pm_start - Start system PM transition.
|
|
|
|
*/
|
|
|
|
static void acpi_pm_start(u32 acpi_state)
|
|
|
|
{
|
|
|
|
acpi_target_sleep_state = acpi_state;
|
|
|
|
acpi_sleep_tts_switch(acpi_target_sleep_state);
|
|
|
|
acpi_scan_lock_acquire();
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* acpi_pm_end - Finish up system PM transition.
|
2008-06-12 15:24:06 -06:00
|
|
|
*/
|
|
|
|
static void acpi_pm_end(void)
|
|
|
|
{
|
2013-08-19 17:42:32 -06:00
|
|
|
acpi_scan_lock_release();
|
2008-06-12 15:24:06 -06:00
|
|
|
/*
|
|
|
|
* 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-11 20:20:22 -06:00
|
|
|
acpi_sleep_tts_switch(acpi_target_sleep_state);
|
2008-06-12 15:24:06 -06:00
|
|
|
}
|
2008-10-23 13:46:43 -06:00
|
|
|
#else /* !CONFIG_ACPI_SLEEP */
|
|
|
|
#define acpi_target_sleep_state ACPI_STATE_S0
|
2012-11-30 04:57:03 -07:00
|
|
|
static inline void acpi_sleep_dmi_check(void) {}
|
2008-10-22 12:58:43 -06:00
|
|
|
#endif /* CONFIG_ACPI_SLEEP */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2005-04-16 16:20:36 -06:00
|
|
|
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
|
|
|
};
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
/**
|
2008-04-23 16:02:52 -06:00
|
|
|
* acpi_suspend_begin - Set the target system sleep state to the state
|
2007-07-17 14:40:06 -06:00
|
|
|
* associated with given @pm_state, if supported.
|
|
|
|
*/
|
2008-04-23 16:02:52 -06:00
|
|
|
static int acpi_suspend_begin(suspend_state_t pm_state)
|
2007-07-17 14:40:06 -06:00
|
|
|
{
|
|
|
|
u32 acpi_state = acpi_suspend_states[pm_state];
|
2013-08-19 17:42:32 -06:00
|
|
|
int error;
|
2007-07-17 14:40:06 -06:00
|
|
|
|
2012-10-26 05:39:15 -06:00
|
|
|
error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
|
2010-05-28 14:32:15 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2013-08-19 17:42:32 -06:00
|
|
|
if (!sleep_states[acpi_state]) {
|
|
|
|
pr_err("ACPI does not support sleep state S%u\n", acpi_state);
|
|
|
|
return -ENOSYS;
|
2007-07-17 14:40:06 -06:00
|
|
|
}
|
2013-08-19 17:42:32 -06:00
|
|
|
|
|
|
|
acpi_pm_start(acpi_state);
|
|
|
|
return 0;
|
2007-07-17 14:40:06 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/**
|
2008-04-23 16:02:52 -06:00
|
|
|
* acpi_suspend_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.
|
|
|
|
*/
|
2008-04-23 16:02:52 -06:00
|
|
|
static int acpi_suspend_enter(suspend_state_t pm_state)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
2007-07-17 14:40:06 -06:00
|
|
|
u32 acpi_state = acpi_target_sleep_state;
|
2011-02-08 15:42:09 -07:00
|
|
|
int error;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
2014-06-06 06:40:17 -06:00
|
|
|
trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
|
2007-07-17 14:40:06 -06:00
|
|
|
switch (acpi_state) {
|
|
|
|
case ACPI_STATE_S1:
|
2005-04-16 16:20:36 -06:00
|
|
|
barrier();
|
2012-07-26 18:08:54 -06:00
|
|
|
status = acpi_enter_sleep_state(acpi_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
|
2007-07-17 14:40:06 -06:00
|
|
|
case ACPI_STATE_S3:
|
2013-05-14 11:09:16 -06:00
|
|
|
if (!acpi_suspend_lowlevel)
|
|
|
|
return -ENOSYS;
|
2011-02-08 15:42:22 -07:00
|
|
|
error = acpi_suspend_lowlevel();
|
2011-02-08 15:42:09 -07:00
|
|
|
if (error)
|
|
|
|
return error;
|
2011-02-08 15:41:57 -07:00
|
|
|
pr_info(PREFIX "Low-level resume complete\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2014-06-06 06:40:17 -06:00
|
|
|
trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
|
2006-04-27 03:25:00 -06:00
|
|
|
|
2010-05-11 11:49:25 -06:00
|
|
|
/* This violates the spec but is required for bug compatibility. */
|
|
|
|
acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
|
2008-11-26 15:53:13 -07:00
|
|
|
|
2012-07-26 18:08:54 -06:00
|
|
|
/* Reprogram control registers */
|
|
|
|
acpi_leave_sleep_state_prep(acpi_state);
|
2008-01-07 16:05:21 -07:00
|
|
|
|
2008-02-05 11:27:12 -07:00
|
|
|
/* ACPI 3.0 specs (P62) says that it's the responsibility
|
2006-04-27 03:25:00 -06:00
|
|
|
* of the OSPM to clear the status bit [ implying that the
|
|
|
|
* POWER_BUTTON event should not reach userspace ]
|
2012-05-09 17:08:43 -06:00
|
|
|
*
|
|
|
|
* However, we do generate a small hint for userspace in the form of
|
|
|
|
* a wakeup event. We flag this condition for now and generate the
|
|
|
|
* event later, as we're currently too early in resume to be able to
|
|
|
|
* generate wakeup events.
|
2006-04-27 03:25:00 -06:00
|
|
|
*/
|
2012-05-09 17:08:43 -06:00
|
|
|
if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
|
2013-11-20 15:45:51 -07:00
|
|
|
acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
|
2012-05-09 17:08:43 -06:00
|
|
|
|
|
|
|
acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
|
|
|
|
|
|
|
|
if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
|
|
|
|
acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
|
|
|
|
/* Flag for later */
|
|
|
|
pwr_btn_event_pending = true;
|
|
|
|
}
|
|
|
|
}
|
2006-04-27 03:25:00 -06:00
|
|
|
|
2007-06-19 19:17:58 -06: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 01:57:46 -07:00
|
|
|
acpi_disable_all_gpes();
|
2010-04-08 17:39:40 -06:00
|
|
|
/* Allow EC transactions to happen. */
|
2010-04-08 17:40:38 -06:00
|
|
|
acpi_ec_unblock_transactions_early();
|
2007-06-19 19:17:58 -06:00
|
|
|
|
2010-05-28 14:32:15 -06:00
|
|
|
suspend_nvs_restore();
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
2008-04-23 16:02:52 -06:00
|
|
|
static int acpi_suspend_state_valid(suspend_state_t pm_state)
|
2005-10-30 16:00:01 -07:00
|
|
|
{
|
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
|
|
|
}
|
|
|
|
|
2010-11-16 06:14:02 -07:00
|
|
|
static const struct platform_suspend_ops acpi_suspend_ops = {
|
2008-04-23 16:02:52 -06:00
|
|
|
.valid = acpi_suspend_state_valid,
|
|
|
|
.begin = acpi_suspend_begin,
|
2009-04-19 12:08:42 -06:00
|
|
|
.prepare_late = acpi_pm_prepare,
|
2008-04-23 16:02:52 -06:00
|
|
|
.enter = acpi_suspend_enter,
|
2010-07-01 16:14:57 -06:00
|
|
|
.wake = acpi_pm_finish,
|
2008-06-12 15:24:06 -06: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 16:14:09 -06:00
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
|
|
|
|
* been requested.
|
|
|
|
*/
|
2010-11-16 06:14:02 -07:00
|
|
|
static const struct platform_suspend_ops acpi_suspend_ops_old = {
|
2008-06-12 15:24:06 -06:00
|
|
|
.valid = acpi_suspend_state_valid,
|
|
|
|
.begin = acpi_suspend_begin_old,
|
2010-07-01 16:14:09 -06:00
|
|
|
.prepare_late = acpi_pm_pre_suspend,
|
2008-04-23 16:02:52 -06:00
|
|
|
.enter = acpi_suspend_enter,
|
2010-07-01 16:14:57 -06:00
|
|
|
.wake = acpi_pm_finish,
|
2008-06-12 15:24:06 -06:00
|
|
|
.end = acpi_pm_end,
|
|
|
|
.recover = acpi_pm_finish,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2013-01-17 06:11:09 -07:00
|
|
|
|
2014-05-15 15:29:57 -06:00
|
|
|
static int acpi_freeze_begin(void)
|
|
|
|
{
|
|
|
|
acpi_scan_lock_acquire();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-09-29 18:29:01 -06:00
|
|
|
static int acpi_freeze_prepare(void)
|
|
|
|
{
|
|
|
|
acpi_enable_all_wakeup_gpes();
|
2014-12-01 15:51:13 -07:00
|
|
|
acpi_os_wait_events_complete();
|
2014-09-29 18:29:01 -06:00
|
|
|
enable_irq_wake(acpi_gbl_FADT.sci_interrupt);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_freeze_restore(void)
|
|
|
|
{
|
|
|
|
disable_irq_wake(acpi_gbl_FADT.sci_interrupt);
|
|
|
|
acpi_enable_all_runtime_gpes();
|
|
|
|
}
|
|
|
|
|
2014-05-15 15:29:57 -06:00
|
|
|
static void acpi_freeze_end(void)
|
|
|
|
{
|
|
|
|
acpi_scan_lock_release();
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct platform_freeze_ops acpi_freeze_ops = {
|
|
|
|
.begin = acpi_freeze_begin,
|
2014-09-29 18:29:01 -06:00
|
|
|
.prepare = acpi_freeze_prepare,
|
|
|
|
.restore = acpi_freeze_restore,
|
2014-05-15 15:29:57 -06:00
|
|
|
.end = acpi_freeze_end,
|
|
|
|
};
|
|
|
|
|
2013-01-17 06:11:09 -07:00
|
|
|
static void acpi_sleep_suspend_setup(void)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2014-03-13 15:11:39 -06:00
|
|
|
for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
|
|
|
|
if (acpi_sleep_state_supported(i))
|
2013-01-17 06:11:09 -07:00
|
|
|
sleep_states[i] = 1;
|
|
|
|
|
|
|
|
suspend_set_ops(old_suspend_ordering ?
|
|
|
|
&acpi_suspend_ops_old : &acpi_suspend_ops);
|
2014-05-15 15:29:57 -06:00
|
|
|
freeze_set_ops(&acpi_freeze_ops);
|
2013-01-17 06:11:09 -07:00
|
|
|
}
|
2014-05-15 15:29:57 -06:00
|
|
|
|
2013-01-17 06:11:09 -07:00
|
|
|
#else /* !CONFIG_SUSPEND */
|
|
|
|
static inline void acpi_sleep_suspend_setup(void) {}
|
|
|
|
#endif /* !CONFIG_SUSPEND */
|
2007-07-29 15:27:18 -06:00
|
|
|
|
2007-07-29 15:24:36 -06:00
|
|
|
#ifdef CONFIG_HIBERNATION
|
2008-07-23 22:28:41 -06: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 16:08:44 -07:00
|
|
|
static int acpi_hibernation_begin(void)
|
2007-10-18 04:04:42 -06:00
|
|
|
{
|
2008-10-26 13:52:15 -06:00
|
|
|
int error;
|
|
|
|
|
2010-07-23 14:59:09 -06:00
|
|
|
error = nvs_nosave ? 0 : suspend_nvs_alloc();
|
2013-08-19 17:42:32 -06:00
|
|
|
if (!error)
|
|
|
|
acpi_pm_start(ACPI_STATE_S4);
|
2008-10-26 13:52:15 -06:00
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2007-05-09 03:33:18 -06:00
|
|
|
static int acpi_hibernation_enter(void)
|
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
|
|
|
|
ACPI_FLUSH_CPU_CACHE();
|
|
|
|
|
|
|
|
/* This shouldn't return. If it returns, we have a problem */
|
2012-07-26 18:08:54 -06:00
|
|
|
status = acpi_enter_sleep_state(ACPI_STATE_S4);
|
|
|
|
/* Reprogram control registers */
|
|
|
|
acpi_leave_sleep_state_prep(ACPI_STATE_S4);
|
2007-05-09 03:33:18 -06:00
|
|
|
|
|
|
|
return ACPI_SUCCESS(status) ? 0 : -EFAULT;
|
|
|
|
}
|
|
|
|
|
2007-10-18 04:04:55 -06: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();
|
2012-07-26 18:08:54 -06:00
|
|
|
/* Reprogram control registers */
|
|
|
|
acpi_leave_sleep_state_prep(ACPI_STATE_S4);
|
2008-07-23 22:28:41 -06:00
|
|
|
/* Check the hardware signature */
|
2014-01-10 02:51:53 -07:00
|
|
|
if (facs && s4_hardware_signature != facs->hardware_signature)
|
|
|
|
pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
|
2008-10-26 13:52:15 -06:00
|
|
|
/* Restore the NVS memory area */
|
2010-05-28 14:32:14 -06:00
|
|
|
suspend_nvs_restore();
|
2010-04-08 17:39:40 -06:00
|
|
|
/* Allow EC transactions to happen. */
|
2010-04-08 17:40:38 -06:00
|
|
|
acpi_ec_unblock_transactions_early();
|
2007-10-18 04:04:55 -06:00
|
|
|
}
|
|
|
|
|
2010-04-08 17:39:40 -06:00
|
|
|
static void acpi_pm_thaw(void)
|
2010-03-03 17:52:58 -07:00
|
|
|
{
|
2010-04-08 17:40:38 -06:00
|
|
|
acpi_ec_unblock_transactions();
|
2008-12-16 01:57:46 -07:00
|
|
|
acpi_enable_all_runtime_gpes();
|
2007-05-09 03:33:18 -06:00
|
|
|
}
|
|
|
|
|
2010-11-09 13:48:49 -07:00
|
|
|
static const struct platform_hibernation_ops acpi_hibernation_ops = {
|
2008-06-12 15:24:06 -06:00
|
|
|
.begin = acpi_hibernation_begin,
|
|
|
|
.end = acpi_pm_end,
|
2010-07-01 16:14:09 -06:00
|
|
|
.pre_snapshot = acpi_pm_prepare,
|
2010-05-28 14:32:15 -06:00
|
|
|
.finish = acpi_pm_finish,
|
2008-06-12 15:24:06 -06:00
|
|
|
.prepare = acpi_pm_prepare,
|
|
|
|
.enter = acpi_hibernation_enter,
|
|
|
|
.leave = acpi_hibernation_leave,
|
2010-04-08 17:39:40 -06:00
|
|
|
.pre_restore = acpi_pm_freeze,
|
|
|
|
.restore_cleanup = acpi_pm_thaw,
|
2008-06-12 15:24:06 -06:00
|
|
|
};
|
2008-01-07 16:08:44 -07:00
|
|
|
|
2008-06-12 15:24:06 -06: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 02:47:30 -06:00
|
|
|
{
|
2008-08-11 20:20:22 -06: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 02:47:30 -06:00
|
|
|
|
2008-10-26 13:52:15 -06:00
|
|
|
if (!error) {
|
2010-07-23 14:59:09 -06:00
|
|
|
if (!nvs_nosave)
|
2010-05-28 14:32:14 -06:00
|
|
|
error = suspend_nvs_alloc();
|
2013-08-19 17:42:32 -06:00
|
|
|
if (!error) {
|
2008-10-26 13:52:15 -06:00
|
|
|
acpi_target_sleep_state = ACPI_STATE_S4;
|
2013-08-19 17:42:32 -06:00
|
|
|
acpi_scan_lock_acquire();
|
|
|
|
}
|
2008-10-26 13:52:15 -06:00
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2008-06-12 15:24:06 -06:00
|
|
|
/*
|
|
|
|
* The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
|
|
|
|
* been requested.
|
|
|
|
*/
|
2010-11-09 13:48:49 -07:00
|
|
|
static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
|
2008-06-12 15:24:06 -06:00
|
|
|
.begin = acpi_hibernation_begin_old,
|
|
|
|
.end = acpi_pm_end,
|
2010-07-01 16:14:09 -06:00
|
|
|
.pre_snapshot = acpi_pm_pre_suspend,
|
2010-04-08 17:39:40 -06:00
|
|
|
.prepare = acpi_pm_freeze,
|
2010-05-28 14:32:15 -06:00
|
|
|
.finish = acpi_pm_finish,
|
2007-05-09 03:33:18 -06:00
|
|
|
.enter = acpi_hibernation_enter,
|
2007-10-18 04:04:55 -06:00
|
|
|
.leave = acpi_hibernation_leave,
|
2010-04-08 17:39:40 -06:00
|
|
|
.pre_restore = acpi_pm_freeze,
|
|
|
|
.restore_cleanup = acpi_pm_thaw,
|
2008-06-12 15:24:06 -06:00
|
|
|
.recover = acpi_pm_finish,
|
2007-05-09 03:33:18 -06:00
|
|
|
};
|
2013-01-17 06:11:09 -07:00
|
|
|
|
|
|
|
static void acpi_sleep_hibernate_setup(void)
|
|
|
|
{
|
2014-03-13 15:11:39 -06:00
|
|
|
if (!acpi_sleep_state_supported(ACPI_STATE_S4))
|
2013-01-17 06:11:09 -07:00
|
|
|
return;
|
|
|
|
|
|
|
|
hibernation_set_ops(old_suspend_ordering ?
|
|
|
|
&acpi_hibernation_ops_old : &acpi_hibernation_ops);
|
|
|
|
sleep_states[ACPI_STATE_S4] = 1;
|
|
|
|
if (nosigcheck)
|
|
|
|
return;
|
|
|
|
|
|
|
|
acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
|
|
|
|
if (facs)
|
|
|
|
s4_hardware_signature = facs->hardware_signature;
|
|
|
|
}
|
|
|
|
#else /* !CONFIG_HIBERNATION */
|
|
|
|
static inline void acpi_sleep_hibernate_setup(void) {}
|
|
|
|
#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-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);
|
2008-12-16 01:57:46 -07:00
|
|
|
acpi_disable_all_gpes();
|
2014-12-01 15:51:13 -07:00
|
|
|
acpi_os_wait_events_complete();
|
2007-09-20 11:32:35 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void acpi_power_off(void)
|
|
|
|
{
|
|
|
|
/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
|
2009-02-04 09:03:07 -07:00
|
|
|
printk(KERN_DEBUG "%s called\n", __func__);
|
2007-09-20 11:32:35 -06:00
|
|
|
local_irq_disable();
|
2012-07-26 18:08:54 -06:00
|
|
|
acpi_enter_sleep_state(ACPI_STATE_S5);
|
2009-04-17 21:32:20 -06:00
|
|
|
}
|
|
|
|
|
2007-02-09 23:32:16 -07:00
|
|
|
int __init acpi_sleep_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2013-02-22 00:37:36 -07:00
|
|
|
char supported[ACPI_S_STATE_COUNT * 3 + 1];
|
|
|
|
char *pos = supported;
|
|
|
|
int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-11-30 04:57:03 -07:00
|
|
|
acpi_sleep_dmi_check();
|
|
|
|
|
2007-09-20 14:27:44 -06:00
|
|
|
sleep_states[ACPI_STATE_S0] = 1;
|
|
|
|
|
2013-01-17 06:11:09 -07:00
|
|
|
acpi_sleep_suspend_setup();
|
|
|
|
acpi_sleep_hibernate_setup();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2014-03-13 15:11:39 -06:00
|
|
|
if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
|
2007-09-20 11:32:35 -06:00
|
|
|
sleep_states[ACPI_STATE_S5] = 1;
|
|
|
|
pm_power_off_prepare = acpi_power_off_prepare;
|
|
|
|
pm_power_off = acpi_power_off;
|
|
|
|
}
|
2013-02-22 00:37:36 -07:00
|
|
|
|
|
|
|
supported[0] = 0;
|
|
|
|
for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
|
|
|
|
if (sleep_states[i])
|
|
|
|
pos += sprintf(pos, " S%d", i);
|
|
|
|
}
|
|
|
|
pr_info(PREFIX "(supports%s)\n", supported);
|
|
|
|
|
2008-08-11 20:20:22 -06: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);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|