sleep.c

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