1 // SPDX-License-Identifier: GPL-2.0-only
3 * sleep.c - ACPI sleep support.
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
11 #define pr_fmt(fmt) "ACPI: PM: " fmt
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>
24 #include <trace/events/power.h>
30 * Some HW-full platforms do not have _S5, so they may need
31 * to leverage efi power off for a shutdown.
34 static u8 sleep_states[ACPI_S_STATE_COUNT];
36 static void acpi_sleep_tts_switch(u32 acpi_state)
40 status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
41 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
43 * OS can't evaluate the _TTS object correctly. Some warning
44 * message will be printed. But it won't break anything.
46 pr_notice("Failure in evaluating _TTS object\n");
50 static int tts_notify_reboot(struct notifier_block *this,
51 unsigned long code, void *x)
53 acpi_sleep_tts_switch(ACPI_STATE_S5);
57 static struct notifier_block tts_notifier = {
58 .notifier_call = tts_notify_reboot,
63 static int acpi_sleep_prepare(u32 acpi_state)
65 #ifdef CONFIG_ACPI_SLEEP
66 unsigned long acpi_wakeup_address;
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)
73 acpi_set_waking_vector(acpi_wakeup_address);
76 ACPI_FLUSH_CPU_CACHE();
78 pr_info("Preparing to enter system sleep state S%d\n", acpi_state);
79 acpi_enable_wakeup_devices(acpi_state);
80 acpi_enter_sleep_state_prep(acpi_state);
84 bool acpi_sleep_state_supported(u8 sleep_state)
89 status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
90 return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
91 || (acpi_gbl_FADT.sleep_control.address
92 && acpi_gbl_FADT.sleep_status.address));
95 #ifdef CONFIG_ACPI_SLEEP
96 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
98 u32 acpi_target_system_state(void)
100 return acpi_target_sleep_state;
102 EXPORT_SYMBOL_GPL(acpi_target_system_state);
104 static bool pwr_btn_event_pending;
107 * The ACPI specification wants us to save NVS memory regions during hibernation
108 * and to restore them during the subsequent resume. Windows does that also for
109 * suspend to RAM. However, it is known that this mechanism does not work on
110 * all machines, so we allow the user to disable it with the help of the
111 * 'acpi_sleep=nonvs' kernel command line option.
113 static bool nvs_nosave;
115 void __init acpi_nvs_nosave(void)
121 * The ACPI specification wants us to save NVS memory regions during hibernation
122 * but says nothing about saving NVS during S3. Not all versions of Windows
123 * save NVS on S3 suspend either, and it is clear that not all systems need
124 * NVS to be saved at S3 time. To improve suspend/resume time, allow the
125 * user to disable saving NVS on S3 if their system does not require it, but
126 * continue to save/restore NVS for S4 as specified.
128 static bool nvs_nosave_s3;
130 void __init acpi_nvs_nosave_s3(void)
132 nvs_nosave_s3 = true;
135 static int __init init_nvs_save_s3(const struct dmi_system_id *d)
137 nvs_nosave_s3 = false;
142 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
143 * user to request that behavior by using the 'acpi_old_suspend_ordering'
144 * kernel command line option that causes the following variable to be set.
146 static bool old_suspend_ordering;
148 void __init acpi_old_suspend_ordering(void)
150 old_suspend_ordering = true;
153 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
155 acpi_old_suspend_ordering();
159 static int __init init_nvs_nosave(const struct dmi_system_id *d)
165 bool acpi_sleep_default_s3;
167 static int __init init_default_s3(const struct dmi_system_id *d)
169 acpi_sleep_default_s3 = true;
173 static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {
175 .callback = init_old_suspend_ordering,
176 .ident = "Abit KN9 (nForce4 variant)",
178 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
179 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
183 .callback = init_old_suspend_ordering,
184 .ident = "HP xw4600 Workstation",
186 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
187 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
191 .callback = init_old_suspend_ordering,
192 .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
194 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
195 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
199 .callback = init_old_suspend_ordering,
200 .ident = "Panasonic CF51-2L",
202 DMI_MATCH(DMI_BOARD_VENDOR,
203 "Matsushita Electric Industrial Co.,Ltd."),
204 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
208 .callback = init_nvs_nosave,
209 .ident = "Sony Vaio VGN-FW41E_H",
211 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
212 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
216 .callback = init_nvs_nosave,
217 .ident = "Sony Vaio VGN-FW21E",
219 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
220 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
224 .callback = init_nvs_nosave,
225 .ident = "Sony Vaio VGN-FW21M",
227 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
228 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
232 .callback = init_nvs_nosave,
233 .ident = "Sony Vaio VPCEB17FX",
235 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
236 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
240 .callback = init_nvs_nosave,
241 .ident = "Sony Vaio VGN-SR11M",
243 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
244 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
248 .callback = init_nvs_nosave,
249 .ident = "Everex StepNote Series",
251 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
252 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
256 .callback = init_nvs_nosave,
257 .ident = "Sony Vaio VPCEB1Z1E",
259 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
260 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
264 .callback = init_nvs_nosave,
265 .ident = "Sony Vaio VGN-NW130D",
267 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
268 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
272 .callback = init_nvs_nosave,
273 .ident = "Sony Vaio VPCCW29FX",
275 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
276 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
280 .callback = init_nvs_nosave,
281 .ident = "Averatec AV1020-ED2",
283 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
284 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
288 .callback = init_old_suspend_ordering,
289 .ident = "Asus A8N-SLI DELUXE",
291 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
292 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
296 .callback = init_old_suspend_ordering,
297 .ident = "Asus A8N-SLI Premium",
299 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
300 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
304 .callback = init_nvs_nosave,
305 .ident = "Sony Vaio VGN-SR26GN_P",
307 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
308 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
312 .callback = init_nvs_nosave,
313 .ident = "Sony Vaio VPCEB1S1E",
315 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
316 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
320 .callback = init_nvs_nosave,
321 .ident = "Sony Vaio VGN-FW520F",
323 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
324 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
328 .callback = init_nvs_nosave,
329 .ident = "Asus K54C",
331 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
332 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
336 .callback = init_nvs_nosave,
337 .ident = "Asus K54HR",
339 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
340 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
344 .callback = init_nvs_save_s3,
345 .ident = "Asus 1025C",
347 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
348 DMI_MATCH(DMI_PRODUCT_NAME, "1025C"),
352 * https://bugzilla.kernel.org/show_bug.cgi?id=189431
353 * Lenovo G50-45 is a platform later than 2012, but needs nvs memory
357 .callback = init_nvs_save_s3,
358 .ident = "Lenovo G50-45",
360 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
361 DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
365 .callback = init_nvs_save_s3,
366 .ident = "Lenovo G40-45",
368 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
369 DMI_MATCH(DMI_PRODUCT_NAME, "80E1"),
373 * ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using
374 * the Low Power S0 Idle firmware interface (see
375 * https://bugzilla.kernel.org/show_bug.cgi?id=199057).
378 .callback = init_default_s3,
379 .ident = "ThinkPad X1 Tablet(2016)",
381 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
382 DMI_MATCH(DMI_PRODUCT_NAME, "20GGA00L00"),
386 * ASUS B1400CEAE hangs on resume from suspend (see
387 * https://bugzilla.kernel.org/show_bug.cgi?id=215742).
390 .callback = init_default_s3,
391 .ident = "ASUS B1400CEAE",
393 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
394 DMI_MATCH(DMI_PRODUCT_NAME, "ASUS EXPERTBOOK B1400CEAE"),
400 static bool ignore_blacklist;
402 void __init acpi_sleep_no_blacklist(void)
404 ignore_blacklist = true;
407 static void __init acpi_sleep_dmi_check(void)
409 if (ignore_blacklist)
412 if (dmi_get_bios_year() >= 2012)
413 acpi_nvs_nosave_s3();
415 dmi_check_system(acpisleep_dmi_table);
419 * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
421 static int acpi_pm_freeze(void)
423 acpi_disable_all_gpes();
424 acpi_os_wait_events_complete();
425 acpi_ec_block_transactions();
430 * acpi_pm_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
432 static int acpi_pm_pre_suspend(void)
435 return suspend_nvs_save();
439 * __acpi_pm_prepare - Prepare the platform to enter the target state.
441 * If necessary, set the firmware waking vector and do arch-specific
442 * nastiness to get the wakeup code to the waking vector.
444 static int __acpi_pm_prepare(void)
446 int error = acpi_sleep_prepare(acpi_target_sleep_state);
448 acpi_target_sleep_state = ACPI_STATE_S0;
454 * acpi_pm_prepare - Prepare the platform to enter the target sleep
455 * state and disable the GPEs.
457 static int acpi_pm_prepare(void)
459 int error = __acpi_pm_prepare();
461 error = acpi_pm_pre_suspend();
467 * acpi_pm_finish - Instruct the platform to leave a sleep state.
469 * This is called after we wake back up (or if entering the sleep state
472 static void acpi_pm_finish(void)
474 struct acpi_device *pwr_btn_adev;
475 u32 acpi_state = acpi_target_sleep_state;
477 acpi_ec_unblock_transactions();
480 if (acpi_state == ACPI_STATE_S0)
483 pr_info("Waking up from system sleep state S%d\n", acpi_state);
484 acpi_disable_wakeup_devices(acpi_state);
485 acpi_leave_sleep_state(acpi_state);
487 /* reset firmware waking vector */
488 acpi_set_waking_vector(0);
490 acpi_target_sleep_state = ACPI_STATE_S0;
492 acpi_resume_power_resources();
494 /* If we were woken with the fixed power button, provide a small
495 * hint to userspace in the form of a wakeup event on the fixed power
496 * button device (if it can be found).
498 * We delay the event generation til now, as the PM layer requires
499 * timekeeping to be running before we generate events. */
500 if (!pwr_btn_event_pending)
503 pwr_btn_event_pending = false;
504 pwr_btn_adev = acpi_dev_get_first_match_dev(ACPI_BUTTON_HID_POWERF,
507 pm_wakeup_event(&pwr_btn_adev->dev, 0);
508 acpi_dev_put(pwr_btn_adev);
513 * acpi_pm_start - Start system PM transition.
515 static void acpi_pm_start(u32 acpi_state)
517 acpi_target_sleep_state = acpi_state;
518 acpi_sleep_tts_switch(acpi_target_sleep_state);
519 acpi_scan_lock_acquire();
523 * acpi_pm_end - Finish up system PM transition.
525 static void acpi_pm_end(void)
527 acpi_turn_off_unused_power_resources();
528 acpi_scan_lock_release();
530 * This is necessary in case acpi_pm_finish() is not called during a
531 * failing transition to a sleep state.
533 acpi_target_sleep_state = ACPI_STATE_S0;
534 acpi_sleep_tts_switch(acpi_target_sleep_state);
536 #else /* !CONFIG_ACPI_SLEEP */
537 #define sleep_no_lps0 (1)
538 #define acpi_target_sleep_state ACPI_STATE_S0
539 #define acpi_sleep_default_s3 (1)
540 static inline void acpi_sleep_dmi_check(void) {}
541 #endif /* CONFIG_ACPI_SLEEP */
543 #ifdef CONFIG_SUSPEND
544 static u32 acpi_suspend_states[] = {
545 [PM_SUSPEND_ON] = ACPI_STATE_S0,
546 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
547 [PM_SUSPEND_MEM] = ACPI_STATE_S3,
548 [PM_SUSPEND_MAX] = ACPI_STATE_S5
552 * acpi_suspend_begin - Set the target system sleep state to the state
553 * associated with given @pm_state, if supported.
555 static int acpi_suspend_begin(suspend_state_t pm_state)
557 u32 acpi_state = acpi_suspend_states[pm_state];
560 error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
564 if (!sleep_states[acpi_state]) {
565 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
568 if (acpi_state > ACPI_STATE_S1)
569 pm_set_suspend_via_firmware();
571 acpi_pm_start(acpi_state);
576 * acpi_suspend_enter - Actually enter a sleep state.
579 * Flush caches and go to sleep. For STR we have to call arch-specific
580 * assembly, which in turn call acpi_enter_sleep_state().
581 * It's unfortunate, but it works. Please fix if you're feeling frisky.
583 static int acpi_suspend_enter(suspend_state_t pm_state)
585 acpi_status status = AE_OK;
586 u32 acpi_state = acpi_target_sleep_state;
589 ACPI_FLUSH_CPU_CACHE();
591 trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
592 switch (acpi_state) {
595 status = acpi_enter_sleep_state(acpi_state);
599 if (!acpi_suspend_lowlevel)
601 error = acpi_suspend_lowlevel();
604 pr_info("Low-level resume complete\n");
605 pm_set_resume_via_firmware();
608 trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
610 /* This violates the spec but is required for bug compatibility. */
611 acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
613 /* Reprogram control registers */
614 acpi_leave_sleep_state_prep(acpi_state);
616 /* ACPI 3.0 specs (P62) says that it's the responsibility
617 * of the OSPM to clear the status bit [ implying that the
618 * POWER_BUTTON event should not reach userspace ]
620 * However, we do generate a small hint for userspace in the form of
621 * a wakeup event. We flag this condition for now and generate the
622 * event later, as we're currently too early in resume to be able to
623 * generate wakeup events.
625 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
626 acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
628 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
630 if (pwr_btn_status & ACPI_EVENT_FLAG_STATUS_SET) {
631 acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
633 pwr_btn_event_pending = true;
638 * Disable and clear GPE status before interrupt is enabled. Some GPEs
639 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
640 * acpi_leave_sleep_state will reenable specific GPEs later
642 acpi_disable_all_gpes();
643 /* Allow EC transactions to happen. */
644 acpi_ec_unblock_transactions();
646 suspend_nvs_restore();
648 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
651 static int acpi_suspend_state_valid(suspend_state_t pm_state)
657 case PM_SUSPEND_STANDBY:
659 acpi_state = acpi_suspend_states[pm_state];
661 return sleep_states[acpi_state];
667 static const struct platform_suspend_ops acpi_suspend_ops = {
668 .valid = acpi_suspend_state_valid,
669 .begin = acpi_suspend_begin,
670 .prepare_late = acpi_pm_prepare,
671 .enter = acpi_suspend_enter,
672 .wake = acpi_pm_finish,
677 * acpi_suspend_begin_old - Set the target system sleep state to the
678 * state associated with given @pm_state, if supported, and
679 * execute the _PTS control method. This function is used if the
680 * pre-ACPI 2.0 suspend ordering has been requested.
682 static int acpi_suspend_begin_old(suspend_state_t pm_state)
684 int error = acpi_suspend_begin(pm_state);
686 error = __acpi_pm_prepare();
692 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
695 static const struct platform_suspend_ops acpi_suspend_ops_old = {
696 .valid = acpi_suspend_state_valid,
697 .begin = acpi_suspend_begin_old,
698 .prepare_late = acpi_pm_pre_suspend,
699 .enter = acpi_suspend_enter,
700 .wake = acpi_pm_finish,
702 .recover = acpi_pm_finish,
705 static bool s2idle_wakeup;
707 int acpi_s2idle_begin(void)
709 acpi_scan_lock_acquire();
713 int acpi_s2idle_prepare(void)
715 if (acpi_sci_irq_valid()) {
716 enable_irq_wake(acpi_sci_irq);
717 acpi_ec_set_gpe_wake_mask(ACPI_GPE_ENABLE);
720 acpi_enable_wakeup_devices(ACPI_STATE_S0);
722 /* Change the configuration of GPEs to avoid spurious wakeup. */
723 acpi_enable_all_wakeup_gpes();
724 acpi_os_wait_events_complete();
726 s2idle_wakeup = true;
730 bool acpi_s2idle_wake(void)
732 if (!acpi_sci_irq_valid())
733 return pm_wakeup_pending();
735 while (pm_wakeup_pending()) {
737 * If IRQD_WAKEUP_ARMED is set for the SCI at this point, the
738 * SCI has not triggered while suspended, so bail out (the
739 * wakeup is pending anyway and the SCI is not the source of
742 if (irqd_is_wakeup_armed(irq_get_irq_data(acpi_sci_irq))) {
743 pm_pr_dbg("Wakeup unrelated to ACPI SCI\n");
748 * If the status bit of any enabled fixed event is set, the
749 * wakeup is regarded as valid.
751 if (acpi_any_fixed_event_status_set()) {
752 pm_pr_dbg("ACPI fixed event wakeup\n");
756 /* Check wakeups from drivers sharing the SCI. */
757 if (acpi_check_wakeup_handlers()) {
758 pm_pr_dbg("ACPI custom handler wakeup\n");
762 /* Check non-EC GPE wakeups and dispatch the EC GPE. */
763 if (acpi_ec_dispatch_gpe()) {
764 pm_pr_dbg("ACPI non-EC GPE wakeup\n");
769 * Cancel the SCI wakeup and process all pending events in case
770 * there are any wakeup ones in there.
772 * Note that if any non-EC GPEs are active at this point, the
773 * SCI will retrigger after the rearming below, so no events
774 * should be missed by canceling the wakeup here.
776 pm_system_cancel_wakeup();
777 acpi_os_wait_events_complete();
780 * The SCI is in the "suspended" state now and it cannot produce
781 * new wakeup events till the rearming below, so if any of them
782 * are pending here, they must be resulting from the processing
783 * of EC events above or coming from somewhere else.
785 if (pm_wakeup_pending()) {
786 pm_pr_dbg("Wakeup after ACPI Notify sync\n");
790 pm_wakeup_clear(acpi_sci_irq);
791 rearm_wake_irq(acpi_sci_irq);
797 void acpi_s2idle_restore(void)
800 * Drain pending events before restoring the working-state configuration
803 acpi_os_wait_events_complete(); /* synchronize GPE processing */
804 acpi_ec_flush_work(); /* flush the EC driver's workqueues */
805 acpi_os_wait_events_complete(); /* synchronize Notify handling */
807 s2idle_wakeup = false;
809 acpi_enable_all_runtime_gpes();
811 acpi_disable_wakeup_devices(ACPI_STATE_S0);
813 if (acpi_sci_irq_valid()) {
814 acpi_ec_set_gpe_wake_mask(ACPI_GPE_DISABLE);
815 disable_irq_wake(acpi_sci_irq);
819 void acpi_s2idle_end(void)
821 acpi_scan_lock_release();
824 static const struct platform_s2idle_ops acpi_s2idle_ops = {
825 .begin = acpi_s2idle_begin,
826 .prepare = acpi_s2idle_prepare,
827 .wake = acpi_s2idle_wake,
828 .restore = acpi_s2idle_restore,
829 .end = acpi_s2idle_end,
832 void __weak acpi_s2idle_setup(void)
834 s2idle_set_ops(&acpi_s2idle_ops);
837 static void acpi_sleep_suspend_setup(void)
841 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
842 if (acpi_sleep_state_supported(i))
845 suspend_set_ops(old_suspend_ordering ?
846 &acpi_suspend_ops_old : &acpi_suspend_ops);
851 #else /* !CONFIG_SUSPEND */
852 #define s2idle_wakeup (false)
853 static inline void acpi_sleep_suspend_setup(void) {}
854 #endif /* !CONFIG_SUSPEND */
856 bool acpi_s2idle_wakeup(void)
858 return s2idle_wakeup;
861 #ifdef CONFIG_PM_SLEEP
862 static u32 saved_bm_rld;
864 static int acpi_save_bm_rld(void)
866 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
870 static void acpi_restore_bm_rld(void)
872 u32 resumed_bm_rld = 0;
874 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
875 if (resumed_bm_rld == saved_bm_rld)
878 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
881 static struct syscore_ops acpi_sleep_syscore_ops = {
882 .suspend = acpi_save_bm_rld,
883 .resume = acpi_restore_bm_rld,
886 static void acpi_sleep_syscore_init(void)
888 register_syscore_ops(&acpi_sleep_syscore_ops);
891 static inline void acpi_sleep_syscore_init(void) {}
892 #endif /* CONFIG_PM_SLEEP */
894 #ifdef CONFIG_HIBERNATION
895 static unsigned long s4_hardware_signature;
896 static struct acpi_table_facs *facs;
897 static bool nosigcheck;
899 void __init acpi_no_s4_hw_signature(void)
904 static int acpi_hibernation_begin(pm_message_t stage)
907 int error = suspend_nvs_alloc();
912 if (stage.event == PM_EVENT_HIBERNATE)
913 pm_set_suspend_via_firmware();
915 acpi_pm_start(ACPI_STATE_S4);
919 static int acpi_hibernation_enter(void)
921 acpi_status status = AE_OK;
923 ACPI_FLUSH_CPU_CACHE();
925 /* This shouldn't return. If it returns, we have a problem */
926 status = acpi_enter_sleep_state(ACPI_STATE_S4);
927 /* Reprogram control registers */
928 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
930 return ACPI_SUCCESS(status) ? 0 : -EFAULT;
933 static void acpi_hibernation_leave(void)
935 pm_set_resume_via_firmware();
937 * If ACPI is not enabled by the BIOS and the boot kernel, we need to
941 /* Reprogram control registers */
942 acpi_leave_sleep_state_prep(ACPI_STATE_S4);
943 /* Check the hardware signature */
944 if (facs && s4_hardware_signature != facs->hardware_signature)
945 pr_crit("Hardware changed while hibernated, success doubtful!\n");
946 /* Restore the NVS memory area */
947 suspend_nvs_restore();
948 /* Allow EC transactions to happen. */
949 acpi_ec_unblock_transactions();
952 static void acpi_pm_thaw(void)
954 acpi_ec_unblock_transactions();
955 acpi_enable_all_runtime_gpes();
958 static const struct platform_hibernation_ops acpi_hibernation_ops = {
959 .begin = acpi_hibernation_begin,
961 .pre_snapshot = acpi_pm_prepare,
962 .finish = acpi_pm_finish,
963 .prepare = acpi_pm_prepare,
964 .enter = acpi_hibernation_enter,
965 .leave = acpi_hibernation_leave,
966 .pre_restore = acpi_pm_freeze,
967 .restore_cleanup = acpi_pm_thaw,
971 * acpi_hibernation_begin_old - Set the target system sleep state to
972 * ACPI_STATE_S4 and execute the _PTS control method. This
973 * function is used if the pre-ACPI 2.0 suspend ordering has been
976 static int acpi_hibernation_begin_old(pm_message_t stage)
980 * The _TTS object should always be evaluated before the _PTS object.
981 * When the old_suspended_ordering is true, the _PTS object is
982 * evaluated in the acpi_sleep_prepare.
984 acpi_sleep_tts_switch(ACPI_STATE_S4);
986 error = acpi_sleep_prepare(ACPI_STATE_S4);
991 error = suspend_nvs_alloc();
996 if (stage.event == PM_EVENT_HIBERNATE)
997 pm_set_suspend_via_firmware();
999 acpi_target_sleep_state = ACPI_STATE_S4;
1000 acpi_scan_lock_acquire();
1005 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
1008 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
1009 .begin = acpi_hibernation_begin_old,
1011 .pre_snapshot = acpi_pm_pre_suspend,
1012 .prepare = acpi_pm_freeze,
1013 .finish = acpi_pm_finish,
1014 .enter = acpi_hibernation_enter,
1015 .leave = acpi_hibernation_leave,
1016 .pre_restore = acpi_pm_freeze,
1017 .restore_cleanup = acpi_pm_thaw,
1018 .recover = acpi_pm_finish,
1021 static void acpi_sleep_hibernate_setup(void)
1023 if (!acpi_sleep_state_supported(ACPI_STATE_S4))
1026 hibernation_set_ops(old_suspend_ordering ?
1027 &acpi_hibernation_ops_old : &acpi_hibernation_ops);
1028 sleep_states[ACPI_STATE_S4] = 1;
1032 acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
1034 s4_hardware_signature = facs->hardware_signature;
1036 #else /* !CONFIG_HIBERNATION */
1037 static inline void acpi_sleep_hibernate_setup(void) {}
1038 #endif /* !CONFIG_HIBERNATION */
1040 static void acpi_power_off_prepare(void)
1042 /* Prepare to power off the system */
1043 acpi_sleep_prepare(ACPI_STATE_S5);
1044 acpi_disable_all_gpes();
1045 acpi_os_wait_events_complete();
1048 static void acpi_power_off(void)
1050 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
1051 pr_debug("%s called\n", __func__);
1052 local_irq_disable();
1053 acpi_enter_sleep_state(ACPI_STATE_S5);
1056 int __init acpi_sleep_init(void)
1058 char supported[ACPI_S_STATE_COUNT * 3 + 1];
1059 char *pos = supported;
1062 acpi_sleep_dmi_check();
1064 sleep_states[ACPI_STATE_S0] = 1;
1066 acpi_sleep_syscore_init();
1067 acpi_sleep_suspend_setup();
1068 acpi_sleep_hibernate_setup();
1070 if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
1071 sleep_states[ACPI_STATE_S5] = 1;
1072 pm_power_off_prepare = acpi_power_off_prepare;
1073 pm_power_off = acpi_power_off;
1079 for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
1080 if (sleep_states[i])
1081 pos += sprintf(pos, " S%d", i);
1083 pr_info("(supports%s)\n", supported);
1086 * Register the tts_notifier to reboot notifier list so that the _TTS
1087 * object can also be evaluated when the system enters S5.
1089 register_reboot_notifier(&tts_notifier);