drivers/acpi/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 #include <linux/delay.h>
  12 #include <linux/irq.h>
  13 #include <linux/dmi.h>
  14 #include <linux/device.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/suspend.h>
  17 #include <linux/reboot.h>
  18 #include <linux/acpi.h>
  19 #include <linux/module.h>
  20 #include <linux/syscore_ops.h>
  21 #include <asm/io.h>
  22 #include <trace/events/power.h>
  23
  24 #include "internal.h"
  25 #include "sleep.h"
  26
  27 /*
  28  * Some HW-full platforms do not have _S5, so they may need
  29  * to leverage efi power off for a shutdown.
  30  */
  31 bool acpi_no_s5;
  32 static u8 sleep_states[ACPI_S_STATE_COUNT];
  33
  34 static void acpi_sleep_tts_switch(u32 acpi_state)
  35 {
  36         acpi_status status;
  37
  38         status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
  39         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
  40                 /*
  41                  * OS can't evaluate the _TTS object correctly. Some warning
  42                  * message will be printed. But it won't break anything.
  43                  */
  44                 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
  45         }
  46 }
  47
  48 static int tts_notify_reboot(struct notifier_block *this,
  49                         unsigned long code, void *x)
  50 {
  51         acpi_sleep_tts_switch(ACPI_STATE_S5);
  52         return NOTIFY_DONE;
  53 }
  54
  55 static struct notifier_block tts_notifier = {
  56         .notifier_call  = tts_notify_reboot,
  57         .next           = NULL,
  58         .priority       = 0,
  59 };
  60
  61 static int acpi_sleep_prepare(u32 acpi_state)
  62 {
  63 #ifdef CONFIG_ACPI_SLEEP
  64         /* do we have a wakeup address for S2 and S3? */
  65         if (acpi_state == ACPI_STATE_S3) {
  66                 if (!acpi_wakeup_address)
  67                         return -EFAULT;
  68                 acpi_set_waking_vector(acpi_wakeup_address);
  69
  70         }
  71         ACPI_FLUSH_CPU_CACHE();
  72 #endif
  73         printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
  74                 acpi_state);
  75         acpi_enable_wakeup_devices(acpi_state);
  76         acpi_enter_sleep_state_prep(acpi_state);
  77         return 0;
  78 }
  79
  80 bool acpi_sleep_state_supported(u8 sleep_state)
  81 {
  82         acpi_status status;
  83         u8 type_a, type_b;
  84
  85         status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
  86         return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
  87                 || (acpi_gbl_FADT.sleep_control.address
  88                         && acpi_gbl_FADT.sleep_status.address));
  89 }
  90
  91 #ifdef CONFIG_ACPI_SLEEP
  92 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
  93
  94 u32 acpi_target_system_state(void)
  95 {
  96         return acpi_target_sleep_state;
  97 }
  98 EXPORT_SYMBOL_GPL(acpi_target_system_state);
  99
 100 static bool pwr_btn_event_pending;
 101
 102 /*
 103  * The ACPI specification wants us to save NVS memory regions during hibernation
 104  * and to restore them during the subsequent resume.  Windows does that also for
 105  * suspend to RAM.  However, it is known that this mechanism does not work on
 106  * all machines, so we allow the user to disable it with the help of the
 107  * 'acpi_sleep=nonvs' kernel command line option.
 108  */
 109 static bool nvs_nosave;
 110
 111 void __init acpi_nvs_nosave(void)
 112 {
 113         nvs_nosave = true;
 114 }
 115
 116 /*
 117  * The ACPI specification wants us to save NVS memory regions during hibernation
 118  * but says nothing about saving NVS during S3.  Not all versions of Windows
 119  * save NVS on S3 suspend either, and it is clear that not all systems need
 120  * NVS to be saved at S3 time.  To improve suspend/resume time, allow the
 121  * user to disable saving NVS on S3 if their system does not require it, but
 122  * continue to save/restore NVS for S4 as specified.
 123  */
 124 static bool nvs_nosave_s3;
 125
 126 void __init acpi_nvs_nosave_s3(void)
 127 {
 128         nvs_nosave_s3 = true;
 129 }
 130
 131 static int __init init_nvs_save_s3(const struct dmi_system_id *d)
 132 {
 133         nvs_nosave_s3 = false;
 134         return 0;
 135 }
 136
 137 /*
 138  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
 139  * user to request that behavior by using the 'acpi_old_suspend_ordering'
 140  * kernel command line option that causes the following variable to be set.
 141  */
 142 static bool old_suspend_ordering;
 143
 144 void __init acpi_old_suspend_ordering(void)
 145 {
 146         old_suspend_ordering = true;
 147 }
 148
 149 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
 150 {
 151         acpi_old_suspend_ordering();
 152         return 0;
 153 }
 154
 155 static int __init init_nvs_nosave(const struct dmi_system_id *d)
 156 {
 157         acpi_nvs_nosave();
 158         return 0;
 159 }
 160
 161 static bool acpi_sleep_no_lps0;
 162
 163 static int __init init_no_lps0(const struct dmi_system_id *d)
 164 {
 165         acpi_sleep_no_lps0 = true;
 166         return 0;
 167 }
 168
 169 static const struct dmi_system_id acpisleep_dmi_table[] __initconst = {
 170         {
 171         .callback = init_old_suspend_ordering,
 172         .ident = "Abit KN9 (nForce4 variant)",
 173         .matches = {
 174                 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
 175                 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
 176                 },
 177         },
 178         {
 179         .callback = init_old_suspend_ordering,
 180         .ident = "HP xw4600 Workstation",
 181         .matches = {
 182                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 183                 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
 184                 },
 185         },
 186         {
 187         .callback = init_old_suspend_ordering,
 188         .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
 189         .matches = {
 190                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
 191                 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
 192                 },
 193         },
 194         {
 195         .callback = init_old_suspend_ordering,
 196         .ident = "Panasonic CF51-2L",
 197         .matches = {
 198                 DMI_MATCH(DMI_BOARD_VENDOR,
 199                                 "Matsushita Electric Industrial Co.,Ltd."),
 200                 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
 201                 },
 202         },
 203         {
 204         .callback = init_nvs_nosave,
 205         .ident = "Sony Vaio VGN-FW41E_H",
 206         .matches = {
 207                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 208                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
 209                 },
 210         },
 211         {
 212         .callback = init_nvs_nosave,
 213         .ident = "Sony Vaio VGN-FW21E",
 214         .matches = {
 215                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 216                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
 217                 },
 218         },
 219         {
 220         .callback = init_nvs_nosave,
 221         .ident = "Sony Vaio VGN-FW21M",
 222         .matches = {
 223                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 224                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
 225                 },
 226         },
 227         {
 228         .callback = init_nvs_nosave,
 229         .ident = "Sony Vaio VPCEB17FX",
 230         .matches = {
 231                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 232                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
 233                 },
 234         },
 235         {
 236         .callback = init_nvs_nosave,
 237         .ident = "Sony Vaio VGN-SR11M",
 238         .matches = {
 239                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 240                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
 241                 },
 242         },
 243         {
 244         .callback = init_nvs_nosave,
 245         .ident = "Everex StepNote Series",
 246         .matches = {
 247                 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
 248                 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
 249                 },
 250         },
 251         {
 252         .callback = init_nvs_nosave,
 253         .ident = "Sony Vaio VPCEB1Z1E",
 254         .matches = {
 255                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 256                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
 257                 },
 258         },
 259         {
 260         .callback = init_nvs_nosave,
 261         .ident = "Sony Vaio VGN-NW130D",
 262         .matches = {
 263                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 264                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
 265                 },
 266         },
 267         {
 268         .callback = init_nvs_nosave,
 269         .ident = "Sony Vaio VPCCW29FX",
 270         .matches = {
 271                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 272                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
 273                 },
 274         },
 275         {
 276         .callback = init_nvs_nosave,
 277         .ident = "Averatec AV1020-ED2",
 278         .matches = {
 279                 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
 280                 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
 281                 },
 282         },
 283         {
 284         .callback = init_old_suspend_ordering,
 285         .ident = "Asus A8N-SLI DELUXE",
 286         .matches = {
 287                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 288                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
 289                 },
 290         },
 291         {
 292         .callback = init_old_suspend_ordering,
 293         .ident = "Asus A8N-SLI Premium",
 294         .matches = {
 295                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 296                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
 297                 },
 298         },
 299         {
 300         .callback = init_nvs_nosave,
 301         .ident = "Sony Vaio VGN-SR26GN_P",
 302         .matches = {
 303                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 304                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
 305                 },
 306         },
 307         {
 308         .callback = init_nvs_nosave,
 309         .ident = "Sony Vaio VPCEB1S1E",
 310         .matches = {
 311                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 312                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
 313                 },
 314         },
 315         {
 316         .callback = init_nvs_nosave,
 317         .ident = "Sony Vaio VGN-FW520F",
 318         .matches = {
 319                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 320                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
 321                 },
 322         },
 323         {
 324         .callback = init_nvs_nosave,
 325         .ident = "Asus K54C",
 326         .matches = {
 327                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 328                 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
 329                 },
 330         },
 331         {
 332         .callback = init_nvs_nosave,
 333         .ident = "Asus K54HR",
 334         .matches = {
 335                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 336                 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
 337                 },
 338         },
 339         {
 340         .callback = init_nvs_save_s3,
 341         .ident = "Asus 1025C",
 342         .matches = {
 343                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
 344                 DMI_MATCH(DMI_PRODUCT_NAME, "1025C"),
 345                 },
 346         },
 347         /*
 348          * https://bugzilla.kernel.org/show_bug.cgi?id=189431
 349          * Lenovo G50-45 is a platform later than 2012, but needs nvs memory
 350          * saving during S3.
 351          */
 352         {
 353         .callback = init_nvs_save_s3,
 354         .ident = "Lenovo G50-45",
 355         .matches = {
 356                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 357                 DMI_MATCH(DMI_PRODUCT_NAME, "80E3"),
 358                 },
 359         },
 360         /*
 361          * https://bugzilla.kernel.org/show_bug.cgi?id=196907
 362          * Some Dell XPS13 9360 cannot do suspend-to-idle using the Low Power
 363          * S0 Idle firmware interface.
 364          */
 365         {
 366         .callback = init_no_lps0,
 367         .ident = "Dell XPS13 9360",
 368         .matches = {
 369                 DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
 370                 DMI_MATCH(DMI_PRODUCT_NAME, "XPS 13 9360"),
 371                 },
 372         },
 373         /*
 374          * ThinkPad X1 Tablet(2016) cannot do suspend-to-idle using
 375          * the Low Power S0 Idle firmware interface (see
 376          * https://bugzilla.kernel.org/show_bug.cgi?id=199057).
 377          */
 378         {
 379         .callback = init_no_lps0,
 380         .ident = "ThinkPad X1 Tablet(2016)",
 381         .matches = {
 382                 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
 383                 DMI_MATCH(DMI_PRODUCT_NAME, "20GGA00L00"),
 384                 },
 385         },
 386         {},
 387 };
 388
 389 static bool ignore_blacklist;
 390
 391 void __init acpi_sleep_no_blacklist(void)
 392 {
 393         ignore_blacklist = true;
 394 }
 395
 396 static void __init acpi_sleep_dmi_check(void)
 397 {
 398         if (ignore_blacklist)
 399                 return;
 400
 401         if (dmi_get_bios_year() >= 2012)
 402                 acpi_nvs_nosave_s3();
 403
 404         dmi_check_system(acpisleep_dmi_table);
 405 }
 406
 407 /**
 408  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
 409  */
 410 static int acpi_pm_freeze(void)
 411 {
 412         acpi_disable_all_gpes();
 413         acpi_os_wait_events_complete();
 414         acpi_ec_block_transactions();
 415         return 0;
 416 }
 417
 418 /**
 419  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
 420  */
 421 static int acpi_pm_pre_suspend(void)
 422 {
 423         acpi_pm_freeze();
 424         return suspend_nvs_save();
 425 }
 426
 427 /**
 428  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
 429  *
 430  *      If necessary, set the firmware waking vector and do arch-specific
 431  *      nastiness to get the wakeup code to the waking vector.
 432  */
 433 static int __acpi_pm_prepare(void)
 434 {
 435         int error = acpi_sleep_prepare(acpi_target_sleep_state);
 436         if (error)
 437                 acpi_target_sleep_state = ACPI_STATE_S0;
 438
 439         return error;
 440 }
 441
 442 /**
 443  *      acpi_pm_prepare - Prepare the platform to enter the target sleep
 444  *              state and disable the GPEs.
 445  */
 446 static int acpi_pm_prepare(void)
 447 {
 448         int error = __acpi_pm_prepare();
 449         if (!error)
 450                 error = acpi_pm_pre_suspend();
 451
 452         return error;
 453 }
 454
 455 /**
 456  *      acpi_pm_finish - Instruct the platform to leave a sleep state.
 457  *
 458  *      This is called after we wake back up (or if entering the sleep state
 459  *      failed).
 460  */
 461 static void acpi_pm_finish(void)
 462 {
 463         struct acpi_device *pwr_btn_adev;
 464         u32 acpi_state = acpi_target_sleep_state;
 465
 466         acpi_ec_unblock_transactions();
 467         suspend_nvs_free();
 468
 469         if (acpi_state == ACPI_STATE_S0)
 470                 return;
 471
 472         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
 473                 acpi_state);
 474         acpi_disable_wakeup_devices(acpi_state);
 475         acpi_leave_sleep_state(acpi_state);
 476
 477         /* reset firmware waking vector */
 478         acpi_set_waking_vector(0);
 479
 480         acpi_target_sleep_state = ACPI_STATE_S0;
 481
 482         acpi_resume_power_resources();
 483
 484         /* If we were woken with the fixed power button, provide a small
 485          * hint to userspace in the form of a wakeup event on the fixed power
 486          * button device (if it can be found).
 487          *
 488          * We delay the event generation til now, as the PM layer requires
 489          * timekeeping to be running before we generate events. */
 490         if (!pwr_btn_event_pending)
 491                 return;
 492
 493         pwr_btn_event_pending = false;
 494         pwr_btn_adev = acpi_dev_get_first_match_dev(ACPI_BUTTON_HID_POWERF,
 495                                                     NULL, -1);
 496         if (pwr_btn_adev) {
 497                 pm_wakeup_event(&pwr_btn_adev->dev, 0);
 498                 acpi_dev_put(pwr_btn_adev);
 499         }
 500 }
 501
 502 /**
 503  * acpi_pm_start - Start system PM transition.
 504  */
 505 static void acpi_pm_start(u32 acpi_state)
 506 {
 507         acpi_target_sleep_state = acpi_state;
 508         acpi_sleep_tts_switch(acpi_target_sleep_state);
 509         acpi_scan_lock_acquire();
 510 }
 511
 512 /**
 513  * acpi_pm_end - Finish up system PM transition.
 514  */
 515 static void acpi_pm_end(void)
 516 {
 517         acpi_turn_off_unused_power_resources();
 518         acpi_scan_lock_release();
 519         /*
 520          * This is necessary in case acpi_pm_finish() is not called during a
 521          * failing transition to a sleep state.
 522          */
 523         acpi_target_sleep_state = ACPI_STATE_S0;
 524         acpi_sleep_tts_switch(acpi_target_sleep_state);
 525 }
 526 #else /* !CONFIG_ACPI_SLEEP */
 527 #define acpi_target_sleep_state ACPI_STATE_S0
 528 #define acpi_sleep_no_lps0      (false)
 529 static inline void acpi_sleep_dmi_check(void) {}
 530 #endif /* CONFIG_ACPI_SLEEP */
 531
 532 #ifdef CONFIG_SUSPEND
 533 static u32 acpi_suspend_states[] = {
 534         [PM_SUSPEND_ON] = ACPI_STATE_S0,
 535         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
 536         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
 537         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 538 };
 539
 540 /**
 541  *      acpi_suspend_begin - Set the target system sleep state to the state
 542  *              associated with given @pm_state, if supported.
 543  */
 544 static int acpi_suspend_begin(suspend_state_t pm_state)
 545 {
 546         u32 acpi_state = acpi_suspend_states[pm_state];
 547         int error;
 548
 549         error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
 550         if (error)
 551                 return error;
 552
 553         if (!sleep_states[acpi_state]) {
 554                 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
 555                 return -ENOSYS;
 556         }
 557         if (acpi_state > ACPI_STATE_S1)
 558                 pm_set_suspend_via_firmware();
 559
 560         acpi_pm_start(acpi_state);
 561         return 0;
 562 }
 563
 564 /**
 565  *      acpi_suspend_enter - Actually enter a sleep state.
 566  *      @pm_state: ignored
 567  *
 568  *      Flush caches and go to sleep. For STR we have to call arch-specific
 569  *      assembly, which in turn call acpi_enter_sleep_state().
 570  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
 571  */
 572 static int acpi_suspend_enter(suspend_state_t pm_state)
 573 {
 574         acpi_status status = AE_OK;
 575         u32 acpi_state = acpi_target_sleep_state;
 576         int error;
 577
 578         ACPI_FLUSH_CPU_CACHE();
 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(PREFIX "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
 640 static 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
 656 static 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  */
 671 static 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  */
 684 static 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
 694 static bool s2idle_in_progress;
 695 static bool s2idle_wakeup;
 696
 697 /*
 698  * On platforms supporting the Low Power S0 Idle interface there is an ACPI
 699  * device object with the PNP0D80 compatible device ID (System Power Management
 700  * Controller) and a specific _DSM method under it.  That method, if present,
 701  * can be used to indicate to the platform that the OS is transitioning into a
 702  * low-power state in which certain types of activity are not desirable or that
 703  * it is leaving such a state, which allows the platform to adjust its operation
 704  * mode accordingly.
 705  */
 706 static const struct acpi_device_id lps0_device_ids[] = {
 707         {"PNP0D80", },
 708         {"", },
 709 };
 710
 711 #define ACPI_LPS0_DSM_UUID      "c4eb40a0-6cd2-11e2-bcfd-0800200c9a66"
 712
 713 #define ACPI_LPS0_GET_DEVICE_CONSTRAINTS        1
 714 #define ACPI_LPS0_SCREEN_OFF    3
 715 #define ACPI_LPS0_SCREEN_ON     4
 716 #define ACPI_LPS0_ENTRY         5
 717 #define ACPI_LPS0_EXIT          6
 718
 719 static acpi_handle lps0_device_handle;
 720 static guid_t lps0_dsm_guid;
 721 static char lps0_dsm_func_mask;
 722
 723 /* Device constraint entry structure */
 724 struct lpi_device_info {
 725         char *name;
 726         int enabled;
 727         union acpi_object *package;
 728 };
 729
 730 /* Constraint package structure */
 731 struct lpi_device_constraint {
 732         int uid;
 733         int min_dstate;
 734         int function_states;
 735 };
 736
 737 struct lpi_constraints {
 738         acpi_handle handle;
 739         int min_dstate;
 740 };
 741
 742 static struct lpi_constraints *lpi_constraints_table;
 743 static int lpi_constraints_table_size;
 744
 745 static void lpi_device_get_constraints(void)
 746 {
 747         union acpi_object *out_obj;
 748         int i;
 749
 750         out_obj = acpi_evaluate_dsm_typed(lps0_device_handle, &lps0_dsm_guid,
 751                                           1, ACPI_LPS0_GET_DEVICE_CONSTRAINTS,
 752                                           NULL, ACPI_TYPE_PACKAGE);
 753
 754         acpi_handle_debug(lps0_device_handle, "_DSM function 1 eval %s\n",
 755                           out_obj ? "successful" : "failed");
 756
 757         if (!out_obj)
 758                 return;
 759
 760         lpi_constraints_table = kcalloc(out_obj->package.count,
 761                                         sizeof(*lpi_constraints_table),
 762                                         GFP_KERNEL);
 763         if (!lpi_constraints_table)
 764                 goto free_acpi_buffer;
 765
 766         acpi_handle_debug(lps0_device_handle, "LPI: constraints list begin:\n");
 767
 768         for (i = 0; i < out_obj->package.count; i++) {
 769                 struct lpi_constraints *constraint;
 770                 acpi_status status;
 771                 union acpi_object *package = &out_obj->package.elements[i];
 772                 struct lpi_device_info info = { };
 773                 int package_count = 0, j;
 774
 775                 if (!package)
 776                         continue;
 777
 778                 for (j = 0; j < package->package.count; ++j) {
 779                         union acpi_object *element =
 780                                         &(package->package.elements[j]);
 781
 782                         switch (element->type) {
 783                         case ACPI_TYPE_INTEGER:
 784                                 info.enabled = element->integer.value;
 785                                 break;
 786                         case ACPI_TYPE_STRING:
 787                                 info.name = element->string.pointer;
 788                                 break;
 789                         case ACPI_TYPE_PACKAGE:
 790                                 package_count = element->package.count;
 791                                 info.package = element->package.elements;
 792                                 break;
 793                         }
 794                 }
 795
 796                 if (!info.enabled || !info.package || !info.name)
 797                         continue;
 798
 799                 constraint = &lpi_constraints_table[lpi_constraints_table_size];
 800
 801                 status = acpi_get_handle(NULL, info.name, &constraint->handle);
 802                 if (ACPI_FAILURE(status))
 803                         continue;
 804
 805                 acpi_handle_debug(lps0_device_handle,
 806                                   "index:%d Name:%s\n", i, info.name);
 807
 808                 constraint->min_dstate = -1;
 809
 810                 for (j = 0; j < package_count; ++j) {
 811                         union acpi_object *info_obj = &info.package[j];
 812                         union acpi_object *cnstr_pkg;
 813                         union acpi_object *obj;
 814                         struct lpi_device_constraint dev_info;
 815
 816                         switch (info_obj->type) {
 817                         case ACPI_TYPE_INTEGER:
 818                                 /* version */
 819                                 break;
 820                         case ACPI_TYPE_PACKAGE:
 821                                 if (info_obj->package.count < 2)
 822                                         break;
 823
 824                                 cnstr_pkg = info_obj->package.elements;
 825                                 obj = &cnstr_pkg[0];
 826                                 dev_info.uid = obj->integer.value;
 827                                 obj = &cnstr_pkg[1];
 828                                 dev_info.min_dstate = obj->integer.value;
 829
 830                                 acpi_handle_debug(lps0_device_handle,
 831                                         "uid:%d min_dstate:%s\n",
 832                                         dev_info.uid,
 833                                         acpi_power_state_string(dev_info.min_dstate));
 834
 835                                 constraint->min_dstate = dev_info.min_dstate;
 836                                 break;
 837                         }
 838                 }
 839
 840                 if (constraint->min_dstate < 0) {
 841                         acpi_handle_debug(lps0_device_handle,
 842                                           "Incomplete constraint defined\n");
 843                         continue;
 844                 }
 845
 846                 lpi_constraints_table_size++;
 847         }
 848
 849         acpi_handle_debug(lps0_device_handle, "LPI: constraints list end\n");
 850
 851 free_acpi_buffer:
 852         ACPI_FREE(out_obj);
 853 }
 854
 855 static void lpi_check_constraints(void)
 856 {
 857         int i;
 858
 859         for (i = 0; i < lpi_constraints_table_size; ++i) {
 860                 acpi_handle handle = lpi_constraints_table[i].handle;
 861                 struct acpi_device *adev;
 862
 863                 if (!handle || acpi_bus_get_device(handle, &adev))
 864                         continue;
 865
 866                 acpi_handle_debug(handle,
 867                         "LPI: required min power state:%s current power state:%s\n",
 868                         acpi_power_state_string(lpi_constraints_table[i].min_dstate),
 869                         acpi_power_state_string(adev->power.state));
 870
 871                 if (!adev->flags.power_manageable) {
 872                         acpi_handle_info(handle, "LPI: Device not power manageable\n");
 873                         lpi_constraints_table[i].handle = NULL;
 874                         continue;
 875                 }
 876
 877                 if (adev->power.state < lpi_constraints_table[i].min_dstate)
 878                         acpi_handle_info(handle,
 879                                 "LPI: Constraint not met; min power state:%s current power state:%s\n",
 880                                 acpi_power_state_string(lpi_constraints_table[i].min_dstate),
 881                                 acpi_power_state_string(adev->power.state));
 882         }
 883 }
 884
 885 static void acpi_sleep_run_lps0_dsm(unsigned int func)
 886 {
 887         union acpi_object *out_obj;
 888
 889         if (!(lps0_dsm_func_mask & (1 << func)))
 890                 return;
 891
 892         out_obj = acpi_evaluate_dsm(lps0_device_handle, &lps0_dsm_guid, 1, func, NULL);
 893         ACPI_FREE(out_obj);
 894
 895         acpi_handle_debug(lps0_device_handle, "_DSM function %u evaluation %s\n",
 896                           func, out_obj ? "successful" : "failed");
 897 }
 898
 899 static int lps0_device_attach(struct acpi_device *adev,
 900                               const struct acpi_device_id *not_used)
 901 {
 902         union acpi_object *out_obj;
 903
 904         if (lps0_device_handle)
 905                 return 0;
 906
 907         if (acpi_sleep_no_lps0) {
 908                 acpi_handle_info(adev->handle,
 909                                  "Low Power S0 Idle interface disabled\n");
 910                 return 0;
 911         }
 912
 913         if (!(acpi_gbl_FADT.flags & ACPI_FADT_LOW_POWER_S0))
 914                 return 0;
 915
 916         guid_parse(ACPI_LPS0_DSM_UUID, &lps0_dsm_guid);
 917         /* Check if the _DSM is present and as expected. */
 918         out_obj = acpi_evaluate_dsm(adev->handle, &lps0_dsm_guid, 1, 0, NULL);
 919         if (out_obj && out_obj->type == ACPI_TYPE_BUFFER) {
 920                 char bitmask = *(char *)out_obj->buffer.pointer;
 921
 922                 lps0_dsm_func_mask = bitmask;
 923                 lps0_device_handle = adev->handle;
 924                 /*
 925                  * Use suspend-to-idle by default if the default
 926                  * suspend mode was not set from the command line.
 927                  */
 928                 if (mem_sleep_default > PM_SUSPEND_MEM)
 929                         mem_sleep_current = PM_SUSPEND_TO_IDLE;
 930
 931                 acpi_handle_debug(adev->handle, "_DSM function mask: 0x%x\n",
 932                                   bitmask);
 933
 934                 acpi_ec_mark_gpe_for_wake();
 935         } else {
 936                 acpi_handle_debug(adev->handle,
 937                                   "_DSM function 0 evaluation failed\n");
 938         }
 939         ACPI_FREE(out_obj);
 940
 941         lpi_device_get_constraints();
 942
 943         return 0;
 944 }
 945
 946 static struct acpi_scan_handler lps0_handler = {
 947         .ids = lps0_device_ids,
 948         .attach = lps0_device_attach,
 949 };
 950
 951 static int acpi_s2idle_begin(void)
 952 {
 953         acpi_scan_lock_acquire();
 954         s2idle_in_progress = true;
 955         return 0;
 956 }
 957
 958 static int acpi_s2idle_prepare(void)
 959 {
 960         if (lps0_device_handle) {
 961                 acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_OFF);
 962                 acpi_sleep_run_lps0_dsm(ACPI_LPS0_ENTRY);
 963
 964                 acpi_ec_set_gpe_wake_mask(ACPI_GPE_ENABLE);
 965         }
 966
 967         if (acpi_sci_irq_valid())
 968                 enable_irq_wake(acpi_sci_irq);
 969
 970         acpi_enable_wakeup_devices(ACPI_STATE_S0);
 971
 972         /* Change the configuration of GPEs to avoid spurious wakeup. */
 973         acpi_enable_all_wakeup_gpes();
 974         acpi_os_wait_events_complete();
 975
 976         s2idle_wakeup = true;
 977         return 0;
 978 }
 979
 980 static void acpi_s2idle_wake(void)
 981 {
 982         if (!lps0_device_handle)
 983                 return;
 984
 985         if (pm_debug_messages_on)
 986                 lpi_check_constraints();
 987
 988         /*
 989          * If IRQD_WAKEUP_ARMED is set for the SCI at this point, the SCI has
 990          * not triggered while suspended, so bail out.
 991          */
 992         if (!acpi_sci_irq_valid() ||
 993             irqd_is_wakeup_armed(irq_get_irq_data(acpi_sci_irq)))
 994                 return;
 995
 996         /*
 997          * If there are EC events to process, the wakeup may be a spurious one
 998          * coming from the EC.
 999          */
1000         if (acpi_ec_dispatch_gpe()) {
1001                 /*
1002                  * Cancel the wakeup and process all pending events in case
1003                  * there are any wakeup ones in there.
1004                  *
1005                  * Note that if any non-EC GPEs are active at this point, the
1006                  * SCI will retrigger after the rearming below, so no events
1007                  * should be missed by canceling the wakeup here.
1008                  */
1009                 pm_system_cancel_wakeup();
1010                 /*
1011                  * The EC driver uses the system workqueue and an additional
1012                  * special one, so those need to be flushed too.
1013                  */
1014                 acpi_os_wait_events_complete(); /* synchronize EC GPE processing */
1015                 acpi_ec_flush_work();
1016                 acpi_os_wait_events_complete(); /* synchronize Notify handling */
1017         }
1018
1019         rearm_wake_irq(acpi_sci_irq);
1020 }
1021
1022 static void acpi_s2idle_restore(void)
1023 {
1024         s2idle_wakeup = false;
1025
1026         acpi_enable_all_runtime_gpes();
1027
1028         acpi_disable_wakeup_devices(ACPI_STATE_S0);
1029
1030         if (acpi_sci_irq_valid())
1031                 disable_irq_wake(acpi_sci_irq);
1032
1033         if (lps0_device_handle) {
1034                 acpi_ec_set_gpe_wake_mask(ACPI_GPE_DISABLE);
1035
1036                 acpi_sleep_run_lps0_dsm(ACPI_LPS0_EXIT);
1037                 acpi_sleep_run_lps0_dsm(ACPI_LPS0_SCREEN_ON);
1038         }
1039 }
1040
1041 static void acpi_s2idle_end(void)
1042 {
1043         s2idle_in_progress = false;
1044         acpi_scan_lock_release();
1045 }
1046
1047 static const struct platform_s2idle_ops acpi_s2idle_ops = {
1048         .begin = acpi_s2idle_begin,
1049         .prepare = acpi_s2idle_prepare,
1050         .wake = acpi_s2idle_wake,
1051         .restore = acpi_s2idle_restore,
1052         .end = acpi_s2idle_end,
1053 };
1054
1055 static void acpi_sleep_suspend_setup(void)
1056 {
1057         int i;
1058
1059         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
1060                 if (acpi_sleep_state_supported(i))
1061                         sleep_states[i] = 1;
1062
1063         suspend_set_ops(old_suspend_ordering ?
1064                 &acpi_suspend_ops_old : &acpi_suspend_ops);
1065
1066         acpi_scan_add_handler(&lps0_handler);
1067         s2idle_set_ops(&acpi_s2idle_ops);
1068 }
1069
1070 #else /* !CONFIG_SUSPEND */
1071 #define s2idle_in_progress      (false)
1072 #define s2idle_wakeup           (false)
1073 #define lps0_device_handle      (NULL)
1074 static inline void acpi_sleep_suspend_setup(void) {}
1075 #endif /* !CONFIG_SUSPEND */
1076
1077 bool acpi_s2idle_wakeup(void)
1078 {
1079         return s2idle_wakeup;
1080 }
1081
1082 bool acpi_sleep_no_ec_events(void)
1083 {
1084         return !s2idle_in_progress || !lps0_device_handle;
1085 }
1086
1087 #ifdef CONFIG_PM_SLEEP
1088 static u32 saved_bm_rld;
1089
1090 static int  acpi_save_bm_rld(void)
1091 {
1092         acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
1093         return 0;
1094 }
1095
1096 static void  acpi_restore_bm_rld(void)
1097 {
1098         u32 resumed_bm_rld = 0;
1099
1100         acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
1101         if (resumed_bm_rld == saved_bm_rld)
1102                 return;
1103
1104         acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
1105 }
1106
1107 static struct syscore_ops acpi_sleep_syscore_ops = {
1108         .suspend = acpi_save_bm_rld,
1109         .resume = acpi_restore_bm_rld,
1110 };
1111
1112 static void acpi_sleep_syscore_init(void)
1113 {
1114         register_syscore_ops(&acpi_sleep_syscore_ops);
1115 }
1116 #else
1117 static inline void acpi_sleep_syscore_init(void) {}
1118 #endif /* CONFIG_PM_SLEEP */
1119
1120 #ifdef CONFIG_HIBERNATION
1121 static unsigned long s4_hardware_signature;
1122 static struct acpi_table_facs *facs;
1123 static bool nosigcheck;
1124
1125 void __init acpi_no_s4_hw_signature(void)
1126 {
1127         nosigcheck = true;
1128 }
1129
1130 static int acpi_hibernation_begin(pm_message_t stage)
1131 {
1132         if (!nvs_nosave) {
1133                 int error = suspend_nvs_alloc();
1134                 if (error)
1135                         return error;
1136         }
1137
1138         if (stage.event == PM_EVENT_HIBERNATE)
1139                 pm_set_suspend_via_firmware();
1140
1141         acpi_pm_start(ACPI_STATE_S4);
1142         return 0;
1143 }
1144
1145 static int acpi_hibernation_enter(void)
1146 {
1147         acpi_status status = AE_OK;
1148
1149         ACPI_FLUSH_CPU_CACHE();
1150
1151         /* This shouldn't return.  If it returns, we have a problem */
1152         status = acpi_enter_sleep_state(ACPI_STATE_S4);
1153         /* Reprogram control registers */
1154         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
1155
1156         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
1157 }
1158
1159 static void acpi_hibernation_leave(void)
1160 {
1161         pm_set_resume_via_firmware();
1162         /*
1163          * If ACPI is not enabled by the BIOS and the boot kernel, we need to
1164          * enable it here.
1165          */
1166         acpi_enable();
1167         /* Reprogram control registers */
1168         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
1169         /* Check the hardware signature */
1170         if (facs && s4_hardware_signature != facs->hardware_signature)
1171                 pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
1172         /* Restore the NVS memory area */
1173         suspend_nvs_restore();
1174         /* Allow EC transactions to happen. */
1175         acpi_ec_unblock_transactions();
1176 }
1177
1178 static void acpi_pm_thaw(void)
1179 {
1180         acpi_ec_unblock_transactions();
1181         acpi_enable_all_runtime_gpes();
1182 }
1183
1184 static const struct platform_hibernation_ops acpi_hibernation_ops = {
1185         .begin = acpi_hibernation_begin,
1186         .end = acpi_pm_end,
1187         .pre_snapshot = acpi_pm_prepare,
1188         .finish = acpi_pm_finish,
1189         .prepare = acpi_pm_prepare,
1190         .enter = acpi_hibernation_enter,
1191         .leave = acpi_hibernation_leave,
1192         .pre_restore = acpi_pm_freeze,
1193         .restore_cleanup = acpi_pm_thaw,
1194 };
1195
1196 /**
1197  *      acpi_hibernation_begin_old - Set the target system sleep state to
1198  *              ACPI_STATE_S4 and execute the _PTS control method.  This
1199  *              function is used if the pre-ACPI 2.0 suspend ordering has been
1200  *              requested.
1201  */
1202 static int acpi_hibernation_begin_old(pm_message_t stage)
1203 {
1204         int error;
1205         /*
1206          * The _TTS object should always be evaluated before the _PTS object.
1207          * When the old_suspended_ordering is true, the _PTS object is
1208          * evaluated in the acpi_sleep_prepare.
1209          */
1210         acpi_sleep_tts_switch(ACPI_STATE_S4);
1211
1212         error = acpi_sleep_prepare(ACPI_STATE_S4);
1213         if (error)
1214                 return error;
1215
1216         if (!nvs_nosave) {
1217                 error = suspend_nvs_alloc();
1218                 if (error)
1219                         return error;
1220         }
1221
1222         if (stage.event == PM_EVENT_HIBERNATE)
1223                 pm_set_suspend_via_firmware();
1224
1225         acpi_target_sleep_state = ACPI_STATE_S4;
1226         acpi_scan_lock_acquire();
1227         return 0;
1228 }
1229
1230 /*
1231  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
1232  * been requested.
1233  */
1234 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
1235         .begin = acpi_hibernation_begin_old,
1236         .end = acpi_pm_end,
1237         .pre_snapshot = acpi_pm_pre_suspend,
1238         .prepare = acpi_pm_freeze,
1239         .finish = acpi_pm_finish,
1240         .enter = acpi_hibernation_enter,
1241         .leave = acpi_hibernation_leave,
1242         .pre_restore = acpi_pm_freeze,
1243         .restore_cleanup = acpi_pm_thaw,
1244         .recover = acpi_pm_finish,
1245 };
1246
1247 static void acpi_sleep_hibernate_setup(void)
1248 {
1249         if (!acpi_sleep_state_supported(ACPI_STATE_S4))
1250                 return;
1251
1252         hibernation_set_ops(old_suspend_ordering ?
1253                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
1254         sleep_states[ACPI_STATE_S4] = 1;
1255         if (nosigcheck)
1256                 return;
1257
1258         acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
1259         if (facs)
1260                 s4_hardware_signature = facs->hardware_signature;
1261 }
1262 #else /* !CONFIG_HIBERNATION */
1263 static inline void acpi_sleep_hibernate_setup(void) {}
1264 #endif /* !CONFIG_HIBERNATION */
1265
1266 static void acpi_power_off_prepare(void)
1267 {
1268         /* Prepare to power off the system */
1269         acpi_sleep_prepare(ACPI_STATE_S5);
1270         acpi_disable_all_gpes();
1271         acpi_os_wait_events_complete();
1272 }
1273
1274 static void acpi_power_off(void)
1275 {
1276         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
1277         printk(KERN_DEBUG "%s called\n", __func__);
1278         local_irq_disable();
1279         acpi_enter_sleep_state(ACPI_STATE_S5);
1280 }
1281
1282 int __init acpi_sleep_init(void)
1283 {
1284         char supported[ACPI_S_STATE_COUNT * 3 + 1];
1285         char *pos = supported;
1286         int i;
1287
1288         acpi_sleep_dmi_check();
1289
1290         sleep_states[ACPI_STATE_S0] = 1;
1291
1292         acpi_sleep_syscore_init();
1293         acpi_sleep_suspend_setup();
1294         acpi_sleep_hibernate_setup();
1295
1296         if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
1297                 sleep_states[ACPI_STATE_S5] = 1;
1298                 pm_power_off_prepare = acpi_power_off_prepare;
1299                 pm_power_off = acpi_power_off;
1300         } else {
1301                 acpi_no_s5 = true;
1302         }
1303
1304         supported[0] = 0;
1305         for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
1306                 if (sleep_states[i])
1307                         pos += sprintf(pos, " S%d", i);
1308         }
1309         pr_info(PREFIX "(supports%s)\n", supported);
1310
1311         /*
1312          * Register the tts_notifier to reboot notifier list so that the _TTS
1313          * object can also be evaluated when the system enters S5.
1314          */
1315         register_reboot_notifier(&tts_notifier);
1316         return 0;
1317 }