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 */ 33 bool acpi_no_s5; 34 static u8 sleep_states[ACPI_S_STATE_COUNT]; 35 36 static 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 50 static 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 57 static 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 67 static 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 87 bool 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 99 static u32 acpi_target_sleep_state = ACPI_STATE_S0; 100 101 u32 acpi_target_system_state(void) 102 { 103 return acpi_target_sleep_state; 104 } 105 EXPORT_SYMBOL_GPL(acpi_target_system_state); 106 107 static 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 */ 116 static bool nvs_nosave; 117 118 void __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 */ 131 static bool nvs_nosave_s3; 132 133 void __init acpi_nvs_nosave_s3(void) 134 { 135 nvs_nosave_s3 = true; 136 } 137 138 static 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 */ 149 static bool old_suspend_ordering; 150 151 void __init acpi_old_suspend_ordering(void) 152 { 153 old_suspend_ordering = true; 154 } 155 156 static int __init init_old_suspend_ordering(const struct dmi_system_id *d) 157 { 158 acpi_old_suspend_ordering(); 159 return 0; 160 } 161 162 static int __init init_nvs_nosave(const struct dmi_system_id *d) 163 { 164 acpi_nvs_nosave(); 165 return 0; 166 } 167 168 bool acpi_sleep_default_s3; 169 170 static int __init init_default_s3(const struct dmi_system_id *d) 171 { 172 acpi_sleep_default_s3 = true; 173 return 0; 174 } 175 176 static 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 413 static bool ignore_blacklist; 414 415 void __init acpi_sleep_no_blacklist(void) 416 { 417 ignore_blacklist = true; 418 } 419 420 static 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 */ 434 static 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 */ 445 static 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 */ 457 static 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 */ 470 static 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 */ 485 static 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 */ 529 static 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 */ 539 static 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) 554 static inline void acpi_sleep_dmi_check(void) {} 555 #endif /* CONFIG_ACPI_SLEEP */ 556 557 #ifdef CONFIG_SUSPEND 558 static 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 */ 570 static 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 */ 598 static 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 672 static 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 688 static 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 */ 704 static 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 */ 717 static 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 727 static bool s2idle_wakeup; 728 729 int acpi_s2idle_begin(void) 730 { 731 acpi_scan_lock_acquire(); 732 return 0; 733 } 734 735 int 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 758 bool 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 821 void 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 843 void acpi_s2idle_end(void) 844 { 845 acpi_scan_lock_release(); 846 } 847 848 static 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 856 void __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 864 static 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) 884 static inline void acpi_sleep_suspend_setup(void) {} 885 #endif /* !CONFIG_SUSPEND */ 886 887 bool acpi_s2idle_wakeup(void) 888 { 889 return s2idle_wakeup; 890 } 891 892 #ifdef CONFIG_PM_SLEEP 893 static u32 saved_bm_rld; 894 895 static 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 901 static 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 912 static const struct syscore_ops acpi_sleep_syscore_ops = { 913 .suspend = acpi_save_bm_rld, 914 .resume = acpi_restore_bm_rld, 915 }; 916 917 static struct syscore acpi_sleep_syscore = { 918 .ops = &acpi_sleep_syscore_ops, 919 }; 920 921 static void acpi_sleep_syscore_init(void) 922 { 923 register_syscore(&acpi_sleep_syscore); 924 } 925 #else 926 static inline void acpi_sleep_syscore_init(void) {} 927 #endif /* CONFIG_PM_SLEEP */ 928 929 #ifdef CONFIG_HIBERNATION 930 static unsigned long s4_hardware_signature; 931 static struct acpi_table_facs *facs; 932 int acpi_check_s4_hw_signature = -1; /* Default behaviour is just to warn */ 933 934 static 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 949 static 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 961 static 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 980 static void acpi_pm_thaw(void) 981 { 982 acpi_ec_unblock_transactions(); 983 acpi_enable_all_runtime_gpes(); 984 } 985 986 static 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 */ 1005 static 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 */ 1037 static 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 1050 static 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 */ 1082 static inline void acpi_sleep_hibernate_setup(void) {} 1083 #endif /* !CONFIG_HIBERNATION */ 1084 1085 static 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 1094 static 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 1103 int __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 } 1153