cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

sleep.c (27201B)


      1// SPDX-License-Identifier: GPL-2.0-only
      2/*
      3 * sleep.c - ACPI sleep support.
      4 *
      5 * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
      6 * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
      7 * Copyright (c) 2000-2003 Patrick Mochel
      8 * Copyright (c) 2003 Open Source Development Lab
      9 */
     10
     11#define pr_fmt(fmt) "ACPI: PM: " fmt
     12
     13#include <linux/delay.h>
     14#include <linux/irq.h>
     15#include <linux/dmi.h>
     16#include <linux/device.h>
     17#include <linux/interrupt.h>
     18#include <linux/suspend.h>
     19#include <linux/reboot.h>
     20#include <linux/acpi.h>
     21#include <linux/module.h>
     22#include <linux/syscore_ops.h>
     23#include <asm/io.h>
     24#include <trace/events/power.h>
     25
     26#include "internal.h"
     27#include "sleep.h"
     28
     29/*
     30 * Some HW-full platforms do not have _S5, so they may need
     31 * to leverage efi power off for a shutdown.
     32 */
     33bool acpi_no_s5;
     34static u8 sleep_states[ACPI_S_STATE_COUNT];
     35
     36static void acpi_sleep_tts_switch(u32 acpi_state)
     37{
     38	acpi_status status;
     39
     40	status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
     41	if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
     42		/*
     43		 * OS can't evaluate the _TTS object correctly. Some warning
     44		 * message will be printed. But it won't break anything.
     45		 */
     46		pr_notice("Failure in evaluating _TTS object\n");
     47	}
     48}
     49
     50static int tts_notify_reboot(struct notifier_block *this,
     51			unsigned long code, void *x)
     52{
     53	acpi_sleep_tts_switch(ACPI_STATE_S5);
     54	return NOTIFY_DONE;
     55}
     56
     57static struct notifier_block tts_notifier = {
     58	.notifier_call	= tts_notify_reboot,
     59	.next		= NULL,
     60	.priority	= 0,
     61};
     62
     63static int acpi_sleep_prepare(u32 acpi_state)
     64{
     65#ifdef CONFIG_ACPI_SLEEP
     66	unsigned long acpi_wakeup_address;
     67
     68	/* do we have a wakeup address for S2 and S3? */
     69	if (acpi_state == ACPI_STATE_S3) {
     70		acpi_wakeup_address = acpi_get_wakeup_address();
     71		if (!acpi_wakeup_address)
     72			return -EFAULT;
     73		acpi_set_waking_vector(acpi_wakeup_address);
     74
     75	}
     76#endif
     77	pr_info("Preparing to enter system sleep state S%d\n", acpi_state);
     78	acpi_enable_wakeup_devices(acpi_state);
     79	acpi_enter_sleep_state_prep(acpi_state);
     80	return 0;
     81}
     82
     83bool acpi_sleep_state_supported(u8 sleep_state)
     84{
     85	acpi_status status;
     86	u8 type_a, type_b;
     87
     88	status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
     89	return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
     90		|| (acpi_gbl_FADT.sleep_control.address
     91			&& acpi_gbl_FADT.sleep_status.address));
     92}
     93
     94#ifdef CONFIG_ACPI_SLEEP
     95static u32 acpi_target_sleep_state = ACPI_STATE_S0;
     96
     97u32 acpi_target_system_state(void)
     98{
     99	return acpi_target_sleep_state;
    100}
    101EXPORT_SYMBOL_GPL(acpi_target_system_state);
    102
    103static bool pwr_btn_event_pending;
    104
    105/*
    106 * The ACPI specification wants us to save NVS memory regions during hibernation
    107 * and to restore them during the subsequent resume.  Windows does that also for
    108 * suspend to RAM.  However, it is known that this mechanism does not work on
    109 * all machines, so we allow the user to disable it with the help of the
    110 * 'acpi_sleep=nonvs' kernel command line option.
    111 */
    112static bool nvs_nosave;
    113
    114void __init acpi_nvs_nosave(void)
    115{
    116	nvs_nosave = true;
    117}
    118
    119/*
    120 * The ACPI specification wants us to save NVS memory regions during hibernation
    121 * but says nothing about saving NVS during S3.  Not all versions of Windows
    122 * save NVS on S3 suspend either, and it is clear that not all systems need
    123 * NVS to be saved at S3 time.  To improve suspend/resume time, allow the
    124 * user to disable saving NVS on S3 if their system does not require it, but
    125 * continue to save/restore NVS for S4 as specified.
    126 */
    127static bool nvs_nosave_s3;
    128
    129void __init acpi_nvs_nosave_s3(void)
    130{
    131	nvs_nosave_s3 = true;
    132}
    133
    134static int __init init_nvs_save_s3(const struct dmi_system_id *d)
    135{
    136	nvs_nosave_s3 = false;
    137	return 0;
    138}
    139
    140/*
    141 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
    142 * user to request that behavior by using the 'acpi_old_suspend_ordering'
    143 * kernel command line option that causes the following variable to be set.
    144 */
    145static bool old_suspend_ordering;
    146
    147void __init acpi_old_suspend_ordering(void)
    148{
    149	old_suspend_ordering = true;
    150}
    151
    152static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
    153{
    154	acpi_old_suspend_ordering();
    155	return 0;
    156}
    157
    158static int __init init_nvs_nosave(const struct dmi_system_id *d)
    159{
    160	acpi_nvs_nosave();
    161	return 0;
    162}
    163
    164bool acpi_sleep_default_s3;
    165
    166static int __init init_default_s3(const struct dmi_system_id *d)
    167{
    168	acpi_sleep_default_s3 = true;
    169	return 0;
    170}
    171
    172static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {
    173	{
    174	.callback = init_old_suspend_ordering,
    175	.ident = "Abit KN9 (nForce4 variant)",
    176	.matches = {
    177		DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
    178		DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
    179		},
    180	},
    181	{
    182	.callback = init_old_suspend_ordering,
    183	.ident = "HP xw4600 Workstation",
    184	.matches = {
    185		DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
    186		DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
    187		},
    188	},
    189	{
    190	.callback = init_old_suspend_ordering,
    191	.ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
    192	.matches = {
    193		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
    194		DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
    195		},
    196	},
    197	{
    198	.callback = init_old_suspend_ordering,
    199	.ident = "Panasonic CF51-2L",
    200	.matches = {
    201		DMI_MATCH(DMI_BOARD_VENDOR,
    202				"Matsushita Electric Industrial Co.,Ltd."),
    203		DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
    204		},
    205	},
    206	{
    207	.callback = init_nvs_nosave,
    208	.ident = "Sony Vaio VGN-FW41E_H",
    209	.matches = {
    210		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    211		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
    212		},
    213	},
    214	{
    215	.callback = init_nvs_nosave,
    216	.ident = "Sony Vaio VGN-FW21E",
    217	.matches = {
    218		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    219		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
    220		},
    221	},
    222	{
    223	.callback = init_nvs_nosave,
    224	.ident = "Sony Vaio VGN-FW21M",
    225	.matches = {
    226		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    227		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
    228		},
    229	},
    230	{
    231	.callback = init_nvs_nosave,
    232	.ident = "Sony Vaio VPCEB17FX",
    233	.matches = {
    234		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    235		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
    236		},
    237	},
    238	{
    239	.callback = init_nvs_nosave,
    240	.ident = "Sony Vaio VGN-SR11M",
    241	.matches = {
    242		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    243		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
    244		},
    245	},
    246	{
    247	.callback = init_nvs_nosave,
    248	.ident = "Everex StepNote Series",
    249	.matches = {
    250		DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
    251		DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
    252		},
    253	},
    254	{
    255	.callback = init_nvs_nosave,
    256	.ident = "Sony Vaio VPCEB1Z1E",
    257	.matches = {
    258		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    259		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
    260		},
    261	},
    262	{
    263	.callback = init_nvs_nosave,
    264	.ident = "Sony Vaio VGN-NW130D",
    265	.matches = {
    266		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    267		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
    268		},
    269	},
    270	{
    271	.callback = init_nvs_nosave,
    272	.ident = "Sony Vaio VPCCW29FX",
    273	.matches = {
    274		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    275		DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
    276		},
    277	},
    278	{
    279	.callback = init_nvs_nosave,
    280	.ident = "Averatec AV1020-ED2",
    281	.matches = {
    282		DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
    283		DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
    284		},
    285	},
    286	{
    287	.callback = init_old_suspend_ordering,
    288	.ident = "Asus A8N-SLI DELUXE",
    289	.matches = {
    290		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
    291		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
    292		},
    293	},
    294	{
    295	.callback = init_old_suspend_ordering,
    296	.ident = "Asus A8N-SLI Premium",
    297	.matches = {
    298		DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
    299		DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
    300		},
    301	},
    302	{
    303	.callback = init_nvs_nosave,
    304	.ident = "Sony Vaio VGN-SR26GN_P",
    305	.matches = {
    306		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    307		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
    308		},
    309	},
    310	{
    311	.callback = init_nvs_nosave,
    312	.ident = "Sony Vaio VPCEB1S1E",
    313	.matches = {
    314		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    315		DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
    316		},
    317	},
    318	{
    319	.callback = init_nvs_nosave,
    320	.ident = "Sony Vaio VGN-FW520F",
    321	.matches = {
    322		DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
    323		DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
    324		},
    325	},
    326	{
    327	.callback = init_nvs_nosave,
    328	.ident = "Asus K54C",
    329	.matches = {
    330		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
    331		DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
    332		},
    333	},
    334	{
    335	.callback = init_nvs_nosave,
    336	.ident = "Asus K54HR",
    337	.matches = {
    338		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
    339		DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
    340		},
    341	},
    342	{
    343	.callback = init_nvs_save_s3,
    344	.ident = "Asus 1025C",
    345	.matches = {
    346		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
    347		DMI_MATCH(DMI_PRODUCT_NAME, "1025C"),
    348		},
    349	},
    350	/*
    351	 * https://bugzilla.kernel.org/show_bug.cgi?id=189431
    352	 * Lenovo G50-45 is a platform later than 2012, but needs nvs memory
    353	 * saving during S3.
    354	 */
    355	{
    356	.callback = init_nvs_save_s3,
    357	.ident = "Lenovo G50-45",
    358	.matches = {
    359		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
    360		DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
    361		},
    362	},
    363	/*
    364	 * ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using
    365	 * the Low Power S0 Idle firmware interface (see
    366	 * https://bugzilla.kernel.org/show_bug.cgi?id=199057).
    367	 */
    368	{
    369	.callback = init_default_s3,
    370	.ident = "ThinkPad X1 Tablet(2016)",
    371	.matches = {
    372		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
    373		DMI_MATCH(DMI_PRODUCT_NAME, "20GGA00L00"),
    374		},
    375	},
    376	/*
    377	 * ASUS B1400CEAE hangs on resume from suspend (see
    378	 * https://bugzilla.kernel.org/show_bug.cgi?id=215742).
    379	 */
    380	{
    381	.callback = init_default_s3,
    382	.ident = "ASUS B1400CEAE",
    383	.matches = {
    384		DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
    385		DMI_MATCH(DMI_PRODUCT_NAME, "ASUS EXPERTBOOK B1400CEAE"),
    386		},
    387	},
    388	{},
    389};
    390
    391static bool ignore_blacklist;
    392
    393void __init acpi_sleep_no_blacklist(void)
    394{
    395	ignore_blacklist = true;
    396}
    397
    398static void __init acpi_sleep_dmi_check(void)
    399{
    400	if (ignore_blacklist)
    401		return;
    402
    403	if (dmi_get_bios_year() >= 2012)
    404		acpi_nvs_nosave_s3();
    405
    406	dmi_check_system(acpisleep_dmi_table);
    407}
    408
    409/**
    410 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
    411 */
    412static int acpi_pm_freeze(void)
    413{
    414	acpi_disable_all_gpes();
    415	acpi_os_wait_events_complete();
    416	acpi_ec_block_transactions();
    417	return 0;
    418}
    419
    420/**
    421 * acpi_pm_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
    422 */
    423static int acpi_pm_pre_suspend(void)
    424{
    425	acpi_pm_freeze();
    426	return suspend_nvs_save();
    427}
    428
    429/**
    430 *	__acpi_pm_prepare - Prepare the platform to enter the target state.
    431 *
    432 *	If necessary, set the firmware waking vector and do arch-specific
    433 *	nastiness to get the wakeup code to the waking vector.
    434 */
    435static int __acpi_pm_prepare(void)
    436{
    437	int error = acpi_sleep_prepare(acpi_target_sleep_state);
    438	if (error)
    439		acpi_target_sleep_state = ACPI_STATE_S0;
    440
    441	return error;
    442}
    443
    444/**
    445 *	acpi_pm_prepare - Prepare the platform to enter the target sleep
    446 *		state and disable the GPEs.
    447 */
    448static int acpi_pm_prepare(void)
    449{
    450	int error = __acpi_pm_prepare();
    451	if (!error)
    452		error = acpi_pm_pre_suspend();
    453
    454	return error;
    455}
    456
    457/**
    458 *	acpi_pm_finish - Instruct the platform to leave a sleep state.
    459 *
    460 *	This is called after we wake back up (or if entering the sleep state
    461 *	failed).
    462 */
    463static void acpi_pm_finish(void)
    464{
    465	struct acpi_device *pwr_btn_adev;
    466	u32 acpi_state = acpi_target_sleep_state;
    467
    468	acpi_ec_unblock_transactions();
    469	suspend_nvs_free();
    470
    471	if (acpi_state == ACPI_STATE_S0)
    472		return;
    473
    474	pr_info("Waking up from system sleep state S%d\n", acpi_state);
    475	acpi_disable_wakeup_devices(acpi_state);
    476	acpi_leave_sleep_state(acpi_state);
    477
    478	/* reset firmware waking vector */
    479	acpi_set_waking_vector(0);
    480
    481	acpi_target_sleep_state = ACPI_STATE_S0;
    482
    483	acpi_resume_power_resources();
    484
    485	/* If we were woken with the fixed power button, provide a small
    486	 * hint to userspace in the form of a wakeup event on the fixed power
    487	 * button device (if it can be found).
    488	 *
    489	 * We delay the event generation til now, as the PM layer requires
    490	 * timekeeping to be running before we generate events. */
    491	if (!pwr_btn_event_pending)
    492		return;
    493
    494	pwr_btn_event_pending = false;
    495	pwr_btn_adev = acpi_dev_get_first_match_dev(ACPI_BUTTON_HID_POWERF,
    496						    NULL, -1);
    497	if (pwr_btn_adev) {
    498		pm_wakeup_event(&pwr_btn_adev->dev, 0);
    499		acpi_dev_put(pwr_btn_adev);
    500	}
    501}
    502
    503/**
    504 * acpi_pm_start - Start system PM transition.
    505 */
    506static void acpi_pm_start(u32 acpi_state)
    507{
    508	acpi_target_sleep_state = acpi_state;
    509	acpi_sleep_tts_switch(acpi_target_sleep_state);
    510	acpi_scan_lock_acquire();
    511}
    512
    513/**
    514 * acpi_pm_end - Finish up system PM transition.
    515 */
    516static void acpi_pm_end(void)
    517{
    518	acpi_turn_off_unused_power_resources();
    519	acpi_scan_lock_release();
    520	/*
    521	 * This is necessary in case acpi_pm_finish() is not called during a
    522	 * failing transition to a sleep state.
    523	 */
    524	acpi_target_sleep_state = ACPI_STATE_S0;
    525	acpi_sleep_tts_switch(acpi_target_sleep_state);
    526}
    527#else /* !CONFIG_ACPI_SLEEP */
    528#define sleep_no_lps0	(1)
    529#define acpi_target_sleep_state	ACPI_STATE_S0
    530#define acpi_sleep_default_s3	(1)
    531static inline void acpi_sleep_dmi_check(void) {}
    532#endif /* CONFIG_ACPI_SLEEP */
    533
    534#ifdef CONFIG_SUSPEND
    535static u32 acpi_suspend_states[] = {
    536	[PM_SUSPEND_ON] = ACPI_STATE_S0,
    537	[PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
    538	[PM_SUSPEND_MEM] = ACPI_STATE_S3,
    539	[PM_SUSPEND_MAX] = ACPI_STATE_S5
    540};
    541
    542/**
    543 *	acpi_suspend_begin - Set the target system sleep state to the state
    544 *		associated with given @pm_state, if supported.
    545 */
    546static int acpi_suspend_begin(suspend_state_t pm_state)
    547{
    548	u32 acpi_state = acpi_suspend_states[pm_state];
    549	int error;
    550
    551	error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
    552	if (error)
    553		return error;
    554
    555	if (!sleep_states[acpi_state]) {
    556		pr_err("ACPI does not support sleep state S%u\n", acpi_state);
    557		return -ENOSYS;
    558	}
    559	if (acpi_state > ACPI_STATE_S1)
    560		pm_set_suspend_via_firmware();
    561
    562	acpi_pm_start(acpi_state);
    563	return 0;
    564}
    565
    566/**
    567 *	acpi_suspend_enter - Actually enter a sleep state.
    568 *	@pm_state: ignored
    569 *
    570 *	Flush caches and go to sleep. For STR we have to call arch-specific
    571 *	assembly, which in turn call acpi_enter_sleep_state().
    572 *	It's unfortunate, but it works. Please fix if you're feeling frisky.
    573 */
    574static int acpi_suspend_enter(suspend_state_t pm_state)
    575{
    576	acpi_status status = AE_OK;
    577	u32 acpi_state = acpi_target_sleep_state;
    578	int error;
    579
    580	trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
    581	switch (acpi_state) {
    582	case ACPI_STATE_S1:
    583		barrier();
    584		status = acpi_enter_sleep_state(acpi_state);
    585		break;
    586
    587	case ACPI_STATE_S3:
    588		if (!acpi_suspend_lowlevel)
    589			return -ENOSYS;
    590		error = acpi_suspend_lowlevel();
    591		if (error)
    592			return error;
    593		pr_info("Low-level resume complete\n");
    594		pm_set_resume_via_firmware();
    595		break;
    596	}
    597	trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
    598
    599	/* This violates the spec but is required for bug compatibility. */
    600	acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
    601
    602	/* Reprogram control registers */
    603	acpi_leave_sleep_state_prep(acpi_state);
    604
    605	/* ACPI 3.0 specs (P62) says that it's the responsibility
    606	 * of the OSPM to clear the status bit [ implying that the
    607	 * POWER_BUTTON event should not reach userspace ]
    608	 *
    609	 * However, we do generate a small hint for userspace in the form of
    610	 * a wakeup event. We flag this condition for now and generate the
    611	 * event later, as we're currently too early in resume to be able to
    612	 * generate wakeup events.
    613	 */
    614	if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
    615		acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
    616
    617		acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
    618
    619		if (pwr_btn_status & ACPI_EVENT_FLAG_STATUS_SET) {
    620			acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
    621			/* Flag for later */
    622			pwr_btn_event_pending = true;
    623		}
    624	}
    625
    626	/*
    627	 * Disable and clear GPE status before interrupt is enabled. Some GPEs
    628	 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
    629	 * acpi_leave_sleep_state will reenable specific GPEs later
    630	 */
    631	acpi_disable_all_gpes();
    632	/* Allow EC transactions to happen. */
    633	acpi_ec_unblock_transactions();
    634
    635	suspend_nvs_restore();
    636
    637	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
    638}
    639
    640static int acpi_suspend_state_valid(suspend_state_t pm_state)
    641{
    642	u32 acpi_state;
    643
    644	switch (pm_state) {
    645	case PM_SUSPEND_ON:
    646	case PM_SUSPEND_STANDBY:
    647	case PM_SUSPEND_MEM:
    648		acpi_state = acpi_suspend_states[pm_state];
    649
    650		return sleep_states[acpi_state];
    651	default:
    652		return 0;
    653	}
    654}
    655
    656static const struct platform_suspend_ops acpi_suspend_ops = {
    657	.valid = acpi_suspend_state_valid,
    658	.begin = acpi_suspend_begin,
    659	.prepare_late = acpi_pm_prepare,
    660	.enter = acpi_suspend_enter,
    661	.wake = acpi_pm_finish,
    662	.end = acpi_pm_end,
    663};
    664
    665/**
    666 *	acpi_suspend_begin_old - Set the target system sleep state to the
    667 *		state associated with given @pm_state, if supported, and
    668 *		execute the _PTS control method.  This function is used if the
    669 *		pre-ACPI 2.0 suspend ordering has been requested.
    670 */
    671static int acpi_suspend_begin_old(suspend_state_t pm_state)
    672{
    673	int error = acpi_suspend_begin(pm_state);
    674	if (!error)
    675		error = __acpi_pm_prepare();
    676
    677	return error;
    678}
    679
    680/*
    681 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
    682 * been requested.
    683 */
    684static const struct platform_suspend_ops acpi_suspend_ops_old = {
    685	.valid = acpi_suspend_state_valid,
    686	.begin = acpi_suspend_begin_old,
    687	.prepare_late = acpi_pm_pre_suspend,
    688	.enter = acpi_suspend_enter,
    689	.wake = acpi_pm_finish,
    690	.end = acpi_pm_end,
    691	.recover = acpi_pm_finish,
    692};
    693
    694static bool s2idle_wakeup;
    695
    696int acpi_s2idle_begin(void)
    697{
    698	acpi_scan_lock_acquire();
    699	return 0;
    700}
    701
    702int acpi_s2idle_prepare(void)
    703{
    704	if (acpi_sci_irq_valid()) {
    705		enable_irq_wake(acpi_sci_irq);
    706		acpi_ec_set_gpe_wake_mask(ACPI_GPE_ENABLE);
    707	}
    708
    709	acpi_enable_wakeup_devices(ACPI_STATE_S0);
    710
    711	/* Change the configuration of GPEs to avoid spurious wakeup. */
    712	acpi_enable_all_wakeup_gpes();
    713	acpi_os_wait_events_complete();
    714
    715	s2idle_wakeup = true;
    716	return 0;
    717}
    718
    719bool acpi_s2idle_wake(void)
    720{
    721	if (!acpi_sci_irq_valid())
    722		return pm_wakeup_pending();
    723
    724	while (pm_wakeup_pending()) {
    725		/*
    726		 * If IRQD_WAKEUP_ARMED is set for the SCI at this point, the
    727		 * SCI has not triggered while suspended, so bail out (the
    728		 * wakeup is pending anyway and the SCI is not the source of
    729		 * it).
    730		 */
    731		if (irqd_is_wakeup_armed(irq_get_irq_data(acpi_sci_irq))) {
    732			pm_pr_dbg("Wakeup unrelated to ACPI SCI\n");
    733			return true;
    734		}
    735
    736		/*
    737		 * If the status bit of any enabled fixed event is set, the
    738		 * wakeup is regarded as valid.
    739		 */
    740		if (acpi_any_fixed_event_status_set()) {
    741			pm_pr_dbg("ACPI fixed event wakeup\n");
    742			return true;
    743		}
    744
    745		/* Check wakeups from drivers sharing the SCI. */
    746		if (acpi_check_wakeup_handlers()) {
    747			pm_pr_dbg("ACPI custom handler wakeup\n");
    748			return true;
    749		}
    750
    751		/*
    752		 * Check non-EC GPE wakeups and if there are none, cancel the
    753		 * SCI-related wakeup and dispatch the EC GPE.
    754		 */
    755		if (acpi_ec_dispatch_gpe()) {
    756			pm_pr_dbg("ACPI non-EC GPE wakeup\n");
    757			return true;
    758		}
    759
    760		acpi_os_wait_events_complete();
    761
    762		/*
    763		 * The SCI is in the "suspended" state now and it cannot produce
    764		 * new wakeup events till the rearming below, so if any of them
    765		 * are pending here, they must be resulting from the processing
    766		 * of EC events above or coming from somewhere else.
    767		 */
    768		if (pm_wakeup_pending()) {
    769			pm_pr_dbg("Wakeup after ACPI Notify sync\n");
    770			return true;
    771		}
    772
    773		pm_pr_dbg("Rearming ACPI SCI for wakeup\n");
    774
    775		pm_wakeup_clear(acpi_sci_irq);
    776		rearm_wake_irq(acpi_sci_irq);
    777	}
    778
    779	return false;
    780}
    781
    782void acpi_s2idle_restore(void)
    783{
    784	/*
    785	 * Drain pending events before restoring the working-state configuration
    786	 * of GPEs.
    787	 */
    788	acpi_os_wait_events_complete(); /* synchronize GPE processing */
    789	acpi_ec_flush_work(); /* flush the EC driver's workqueues */
    790	acpi_os_wait_events_complete(); /* synchronize Notify handling */
    791
    792	s2idle_wakeup = false;
    793
    794	acpi_enable_all_runtime_gpes();
    795
    796	acpi_disable_wakeup_devices(ACPI_STATE_S0);
    797
    798	if (acpi_sci_irq_valid()) {
    799		acpi_ec_set_gpe_wake_mask(ACPI_GPE_DISABLE);
    800		disable_irq_wake(acpi_sci_irq);
    801	}
    802}
    803
    804void acpi_s2idle_end(void)
    805{
    806	acpi_scan_lock_release();
    807}
    808
    809static const struct platform_s2idle_ops acpi_s2idle_ops = {
    810	.begin = acpi_s2idle_begin,
    811	.prepare = acpi_s2idle_prepare,
    812	.wake = acpi_s2idle_wake,
    813	.restore = acpi_s2idle_restore,
    814	.end = acpi_s2idle_end,
    815};
    816
    817void __weak acpi_s2idle_setup(void)
    818{
    819	s2idle_set_ops(&acpi_s2idle_ops);
    820}
    821
    822static void acpi_sleep_suspend_setup(void)
    823{
    824	bool suspend_ops_needed = false;
    825	int i;
    826
    827	for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
    828		if (acpi_sleep_state_supported(i)) {
    829			sleep_states[i] = 1;
    830			suspend_ops_needed = true;
    831		}
    832
    833	if (suspend_ops_needed)
    834		suspend_set_ops(old_suspend_ordering ?
    835				&acpi_suspend_ops_old : &acpi_suspend_ops);
    836
    837	acpi_s2idle_setup();
    838}
    839
    840#else /* !CONFIG_SUSPEND */
    841#define s2idle_wakeup		(false)
    842static inline void acpi_sleep_suspend_setup(void) {}
    843#endif /* !CONFIG_SUSPEND */
    844
    845bool acpi_s2idle_wakeup(void)
    846{
    847	return s2idle_wakeup;
    848}
    849
    850#ifdef CONFIG_PM_SLEEP
    851static u32 saved_bm_rld;
    852
    853static int  acpi_save_bm_rld(void)
    854{
    855	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
    856	return 0;
    857}
    858
    859static void  acpi_restore_bm_rld(void)
    860{
    861	u32 resumed_bm_rld = 0;
    862
    863	acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
    864	if (resumed_bm_rld == saved_bm_rld)
    865		return;
    866
    867	acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
    868}
    869
    870static struct syscore_ops acpi_sleep_syscore_ops = {
    871	.suspend = acpi_save_bm_rld,
    872	.resume = acpi_restore_bm_rld,
    873};
    874
    875static void acpi_sleep_syscore_init(void)
    876{
    877	register_syscore_ops(&acpi_sleep_syscore_ops);
    878}
    879#else
    880static inline void acpi_sleep_syscore_init(void) {}
    881#endif /* CONFIG_PM_SLEEP */
    882
    883#ifdef CONFIG_HIBERNATION
    884static unsigned long s4_hardware_signature;
    885static struct acpi_table_facs *facs;
    886int acpi_check_s4_hw_signature = -1; /* Default behaviour is just to warn */
    887
    888static int acpi_hibernation_begin(pm_message_t stage)
    889{
    890	if (!nvs_nosave) {
    891		int error = suspend_nvs_alloc();
    892		if (error)
    893			return error;
    894	}
    895
    896	if (stage.event == PM_EVENT_HIBERNATE)
    897		pm_set_suspend_via_firmware();
    898
    899	acpi_pm_start(ACPI_STATE_S4);
    900	return 0;
    901}
    902
    903static int acpi_hibernation_enter(void)
    904{
    905	acpi_status status = AE_OK;
    906
    907	/* This shouldn't return.  If it returns, we have a problem */
    908	status = acpi_enter_sleep_state(ACPI_STATE_S4);
    909	/* Reprogram control registers */
    910	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
    911
    912	return ACPI_SUCCESS(status) ? 0 : -EFAULT;
    913}
    914
    915static void acpi_hibernation_leave(void)
    916{
    917	pm_set_resume_via_firmware();
    918	/*
    919	 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
    920	 * enable it here.
    921	 */
    922	acpi_enable();
    923	/* Reprogram control registers */
    924	acpi_leave_sleep_state_prep(ACPI_STATE_S4);
    925	/* Check the hardware signature */
    926	if (facs && s4_hardware_signature != facs->hardware_signature)
    927		pr_crit("Hardware changed while hibernated, success doubtful!\n");
    928	/* Restore the NVS memory area */
    929	suspend_nvs_restore();
    930	/* Allow EC transactions to happen. */
    931	acpi_ec_unblock_transactions();
    932}
    933
    934static void acpi_pm_thaw(void)
    935{
    936	acpi_ec_unblock_transactions();
    937	acpi_enable_all_runtime_gpes();
    938}
    939
    940static const struct platform_hibernation_ops acpi_hibernation_ops = {
    941	.begin = acpi_hibernation_begin,
    942	.end = acpi_pm_end,
    943	.pre_snapshot = acpi_pm_prepare,
    944	.finish = acpi_pm_finish,
    945	.prepare = acpi_pm_prepare,
    946	.enter = acpi_hibernation_enter,
    947	.leave = acpi_hibernation_leave,
    948	.pre_restore = acpi_pm_freeze,
    949	.restore_cleanup = acpi_pm_thaw,
    950};
    951
    952/**
    953 *	acpi_hibernation_begin_old - Set the target system sleep state to
    954 *		ACPI_STATE_S4 and execute the _PTS control method.  This
    955 *		function is used if the pre-ACPI 2.0 suspend ordering has been
    956 *		requested.
    957 */
    958static int acpi_hibernation_begin_old(pm_message_t stage)
    959{
    960	int error;
    961	/*
    962	 * The _TTS object should always be evaluated before the _PTS object.
    963	 * When the old_suspended_ordering is true, the _PTS object is
    964	 * evaluated in the acpi_sleep_prepare.
    965	 */
    966	acpi_sleep_tts_switch(ACPI_STATE_S4);
    967
    968	error = acpi_sleep_prepare(ACPI_STATE_S4);
    969	if (error)
    970		return error;
    971
    972	if (!nvs_nosave) {
    973		error = suspend_nvs_alloc();
    974		if (error)
    975			return error;
    976	}
    977
    978	if (stage.event == PM_EVENT_HIBERNATE)
    979		pm_set_suspend_via_firmware();
    980
    981	acpi_target_sleep_state = ACPI_STATE_S4;
    982	acpi_scan_lock_acquire();
    983	return 0;
    984}
    985
    986/*
    987 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
    988 * been requested.
    989 */
    990static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
    991	.begin = acpi_hibernation_begin_old,
    992	.end = acpi_pm_end,
    993	.pre_snapshot = acpi_pm_pre_suspend,
    994	.prepare = acpi_pm_freeze,
    995	.finish = acpi_pm_finish,
    996	.enter = acpi_hibernation_enter,
    997	.leave = acpi_hibernation_leave,
    998	.pre_restore = acpi_pm_freeze,
    999	.restore_cleanup = acpi_pm_thaw,
   1000	.recover = acpi_pm_finish,
   1001};
   1002
   1003static void acpi_sleep_hibernate_setup(void)
   1004{
   1005	if (!acpi_sleep_state_supported(ACPI_STATE_S4))
   1006		return;
   1007
   1008	hibernation_set_ops(old_suspend_ordering ?
   1009			&acpi_hibernation_ops_old : &acpi_hibernation_ops);
   1010	sleep_states[ACPI_STATE_S4] = 1;
   1011	if (!acpi_check_s4_hw_signature)
   1012		return;
   1013
   1014	acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
   1015	if (facs) {
   1016		/*
   1017		 * s4_hardware_signature is the local variable which is just
   1018		 * used to warn about mismatch after we're attempting to
   1019		 * resume (in violation of the ACPI specification.)
   1020		 */
   1021		s4_hardware_signature = facs->hardware_signature;
   1022
   1023		if (acpi_check_s4_hw_signature > 0) {
   1024			/*
   1025			 * If we're actually obeying the ACPI specification
   1026			 * then the signature is written out as part of the
   1027			 * swsusp header, in order to allow the boot kernel
   1028			 * to gracefully decline to resume.
   1029			 */
   1030			swsusp_hardware_signature = facs->hardware_signature;
   1031		}
   1032	}
   1033}
   1034#else /* !CONFIG_HIBERNATION */
   1035static inline void acpi_sleep_hibernate_setup(void) {}
   1036#endif /* !CONFIG_HIBERNATION */
   1037
   1038static int acpi_power_off_prepare(struct sys_off_data *data)
   1039{
   1040	/* Prepare to power off the system */
   1041	acpi_sleep_prepare(ACPI_STATE_S5);
   1042	acpi_disable_all_gpes();
   1043	acpi_os_wait_events_complete();
   1044	return NOTIFY_DONE;
   1045}
   1046
   1047static int acpi_power_off(struct sys_off_data *data)
   1048{
   1049	/* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
   1050	pr_debug("%s called\n", __func__);
   1051	local_irq_disable();
   1052	acpi_enter_sleep_state(ACPI_STATE_S5);
   1053	return NOTIFY_DONE;
   1054}
   1055
   1056int __init acpi_sleep_init(void)
   1057{
   1058	char supported[ACPI_S_STATE_COUNT * 3 + 1];
   1059	char *pos = supported;
   1060	int i;
   1061
   1062	acpi_sleep_dmi_check();
   1063
   1064	sleep_states[ACPI_STATE_S0] = 1;
   1065
   1066	acpi_sleep_syscore_init();
   1067	acpi_sleep_suspend_setup();
   1068	acpi_sleep_hibernate_setup();
   1069
   1070	if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
   1071		sleep_states[ACPI_STATE_S5] = 1;
   1072
   1073		register_sys_off_handler(SYS_OFF_MODE_POWER_OFF_PREPARE,
   1074					 SYS_OFF_PRIO_FIRMWARE,
   1075					 acpi_power_off_prepare, NULL);
   1076
   1077		register_sys_off_handler(SYS_OFF_MODE_POWER_OFF,
   1078					 SYS_OFF_PRIO_FIRMWARE,
   1079					 acpi_power_off, NULL);
   1080	} else {
   1081		acpi_no_s5 = true;
   1082	}
   1083
   1084	supported[0] = 0;
   1085	for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
   1086		if (sleep_states[i])
   1087			pos += sprintf(pos, " S%d", i);
   1088	}
   1089	pr_info("(supports%s)\n", supported);
   1090
   1091	/*
   1092	 * Register the tts_notifier to reboot notifier list so that the _TTS
   1093	 * object can also be evaluated when the system enters S5.
   1094	 */
   1095	register_reboot_notifier(&tts_notifier);
   1096	return 0;
   1097}