drivers/acpi/sleep.c

   1 /*
   2  * sleep.c - ACPI sleep support.
   3  *
   4  * Copyright (c) 2005 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
   5  * Copyright (c) 2004 David Shaohua Li <shaohua.li@intel.com>
   6  * Copyright (c) 2000-2003 Patrick Mochel
   7  * Copyright (c) 2003 Open Source Development Lab
   8  *
   9  * This file is released under the GPLv2.
  10  *
  11  */
  12
  13 #include <linux/delay.h>
  14 #include <linux/irq.h>
  15 #include <linux/dmi.h>
  16 #include <linux/device.h>
  17 #include <linux/suspend.h>
  18 #include <linux/reboot.h>
  19 #include <linux/acpi.h>
  20 #include <linux/module.h>
  21 #include <asm/io.h>
  22 #include <trace/events/power.h>
  23
  24 #include "internal.h"
  25 #include "sleep.h"
  26
  27 static u8 sleep_states[ACPI_S_STATE_COUNT];
  28
  29 static void acpi_sleep_tts_switch(u32 acpi_state)
  30 {
  31         acpi_status status;
  32
  33         status = acpi_execute_simple_method(NULL, "\\_TTS", acpi_state);
  34         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
  35                 /*
  36                  * OS can't evaluate the _TTS object correctly. Some warning
  37                  * message will be printed. But it won't break anything.
  38                  */
  39                 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
  40         }
  41 }
  42
  43 static int tts_notify_reboot(struct notifier_block *this,
  44                         unsigned long code, void *x)
  45 {
  46         acpi_sleep_tts_switch(ACPI_STATE_S5);
  47         return NOTIFY_DONE;
  48 }
  49
  50 static struct notifier_block tts_notifier = {
  51         .notifier_call  = tts_notify_reboot,
  52         .next           = NULL,
  53         .priority       = 0,
  54 };
  55
  56 static int acpi_sleep_prepare(u32 acpi_state)
  57 {
  58 #ifdef CONFIG_ACPI_SLEEP
  59         /* do we have a wakeup address for S2 and S3? */
  60         if (acpi_state == ACPI_STATE_S3) {
  61                 if (!acpi_wakeup_address)
  62                         return -EFAULT;
  63                 acpi_set_firmware_waking_vector(acpi_wakeup_address);
  64
  65         }
  66         ACPI_FLUSH_CPU_CACHE();
  67 #endif
  68         printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
  69                 acpi_state);
  70         acpi_enable_wakeup_devices(acpi_state);
  71         acpi_enter_sleep_state_prep(acpi_state);
  72         return 0;
  73 }
  74
  75 static bool acpi_sleep_state_supported(u8 sleep_state)
  76 {
  77         acpi_status status;
  78         u8 type_a, type_b;
  79
  80         status = acpi_get_sleep_type_data(sleep_state, &type_a, &type_b);
  81         return ACPI_SUCCESS(status) && (!acpi_gbl_reduced_hardware
  82                 || (acpi_gbl_FADT.sleep_control.address
  83                         && acpi_gbl_FADT.sleep_status.address));
  84 }
  85
  86 #ifdef CONFIG_ACPI_SLEEP
  87 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
  88
  89 u32 acpi_target_system_state(void)
  90 {
  91         return acpi_target_sleep_state;
  92 }
  93 EXPORT_SYMBOL_GPL(acpi_target_system_state);
  94
  95 static bool pwr_btn_event_pending;
  96
  97 /*
  98  * The ACPI specification wants us to save NVS memory regions during hibernation
  99  * and to restore them during the subsequent resume.  Windows does that also for
 100  * suspend to RAM.  However, it is known that this mechanism does not work on
 101  * all machines, so we allow the user to disable it with the help of the
 102  * 'acpi_sleep=nonvs' kernel command line option.
 103  */
 104 static bool nvs_nosave;
 105
 106 void __init acpi_nvs_nosave(void)
 107 {
 108         nvs_nosave = true;
 109 }
 110
 111 /*
 112  * The ACPI specification wants us to save NVS memory regions during hibernation
 113  * but says nothing about saving NVS during S3.  Not all versions of Windows
 114  * save NVS on S3 suspend either, and it is clear that not all systems need
 115  * NVS to be saved at S3 time.  To improve suspend/resume time, allow the
 116  * user to disable saving NVS on S3 if their system does not require it, but
 117  * continue to save/restore NVS for S4 as specified.
 118  */
 119 static bool nvs_nosave_s3;
 120
 121 void __init acpi_nvs_nosave_s3(void)
 122 {
 123         nvs_nosave_s3 = true;
 124 }
 125
 126 /*
 127  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
 128  * user to request that behavior by using the 'acpi_old_suspend_ordering'
 129  * kernel command line option that causes the following variable to be set.
 130  */
 131 static bool old_suspend_ordering;
 132
 133 void __init acpi_old_suspend_ordering(void)
 134 {
 135         old_suspend_ordering = true;
 136 }
 137
 138 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
 139 {
 140         acpi_old_suspend_ordering();
 141         return 0;
 142 }
 143
 144 static int __init init_nvs_nosave(const struct dmi_system_id *d)
 145 {
 146         acpi_nvs_nosave();
 147         return 0;
 148 }
 149
 150 static struct dmi_system_id acpisleep_dmi_table[] __initdata = {
 151         {
 152         .callback = init_old_suspend_ordering,
 153         .ident = "Abit KN9 (nForce4 variant)",
 154         .matches = {
 155                 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
 156                 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
 157                 },
 158         },
 159         {
 160         .callback = init_old_suspend_ordering,
 161         .ident = "HP xw4600 Workstation",
 162         .matches = {
 163                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 164                 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
 165                 },
 166         },
 167         {
 168         .callback = init_old_suspend_ordering,
 169         .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
 170         .matches = {
 171                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
 172                 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
 173                 },
 174         },
 175         {
 176         .callback = init_old_suspend_ordering,
 177         .ident = "Panasonic CF51-2L",
 178         .matches = {
 179                 DMI_MATCH(DMI_BOARD_VENDOR,
 180                                 "Matsushita Electric Industrial Co.,Ltd."),
 181                 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
 182                 },
 183         },
 184         {
 185         .callback = init_nvs_nosave,
 186         .ident = "Sony Vaio VGN-FW41E_H",
 187         .matches = {
 188                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 189                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW41E_H"),
 190                 },
 191         },
 192         {
 193         .callback = init_nvs_nosave,
 194         .ident = "Sony Vaio VGN-FW21E",
 195         .matches = {
 196                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 197                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
 198                 },
 199         },
 200         {
 201         .callback = init_nvs_nosave,
 202         .ident = "Sony Vaio VGN-FW21M",
 203         .matches = {
 204                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 205                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21M"),
 206                 },
 207         },
 208         {
 209         .callback = init_nvs_nosave,
 210         .ident = "Sony Vaio VPCEB17FX",
 211         .matches = {
 212                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 213                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
 214                 },
 215         },
 216         {
 217         .callback = init_nvs_nosave,
 218         .ident = "Sony Vaio VGN-SR11M",
 219         .matches = {
 220                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 221                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
 222                 },
 223         },
 224         {
 225         .callback = init_nvs_nosave,
 226         .ident = "Everex StepNote Series",
 227         .matches = {
 228                 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
 229                 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
 230                 },
 231         },
 232         {
 233         .callback = init_nvs_nosave,
 234         .ident = "Sony Vaio VPCEB1Z1E",
 235         .matches = {
 236                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 237                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
 238                 },
 239         },
 240         {
 241         .callback = init_nvs_nosave,
 242         .ident = "Sony Vaio VGN-NW130D",
 243         .matches = {
 244                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 245                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
 246                 },
 247         },
 248         {
 249         .callback = init_nvs_nosave,
 250         .ident = "Sony Vaio VPCCW29FX",
 251         .matches = {
 252                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 253                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
 254                 },
 255         },
 256         {
 257         .callback = init_nvs_nosave,
 258         .ident = "Averatec AV1020-ED2",
 259         .matches = {
 260                 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
 261                 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
 262                 },
 263         },
 264         {
 265         .callback = init_old_suspend_ordering,
 266         .ident = "Asus A8N-SLI DELUXE",
 267         .matches = {
 268                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 269                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
 270                 },
 271         },
 272         {
 273         .callback = init_old_suspend_ordering,
 274         .ident = "Asus A8N-SLI Premium",
 275         .matches = {
 276                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 277                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
 278                 },
 279         },
 280         {
 281         .callback = init_nvs_nosave,
 282         .ident = "Sony Vaio VGN-SR26GN_P",
 283         .matches = {
 284                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 285                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
 286                 },
 287         },
 288         {
 289         .callback = init_nvs_nosave,
 290         .ident = "Sony Vaio VPCEB1S1E",
 291         .matches = {
 292                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 293                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1S1E"),
 294                 },
 295         },
 296         {
 297         .callback = init_nvs_nosave,
 298         .ident = "Sony Vaio VGN-FW520F",
 299         .matches = {
 300                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 301                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
 302                 },
 303         },
 304         {
 305         .callback = init_nvs_nosave,
 306         .ident = "Asus K54C",
 307         .matches = {
 308                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 309                 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
 310                 },
 311         },
 312         {
 313         .callback = init_nvs_nosave,
 314         .ident = "Asus K54HR",
 315         .matches = {
 316                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 317                 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
 318                 },
 319         },
 320         {},
 321 };
 322
 323 static void acpi_sleep_dmi_check(void)
 324 {
 325         int year;
 326
 327         if (dmi_get_date(DMI_BIOS_DATE, &year, NULL, NULL) && year >= 2012)
 328                 acpi_nvs_nosave_s3();
 329
 330         dmi_check_system(acpisleep_dmi_table);
 331 }
 332
 333 /**
 334  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
 335  */
 336 static int acpi_pm_freeze(void)
 337 {
 338         acpi_disable_all_gpes();
 339         acpi_os_wait_events_complete();
 340         acpi_ec_block_transactions();
 341         return 0;
 342 }
 343
 344 /**
 345  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
 346  */
 347 static int acpi_pm_pre_suspend(void)
 348 {
 349         acpi_pm_freeze();
 350         return suspend_nvs_save();
 351 }
 352
 353 /**
 354  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
 355  *
 356  *      If necessary, set the firmware waking vector and do arch-specific
 357  *      nastiness to get the wakeup code to the waking vector.
 358  */
 359 static int __acpi_pm_prepare(void)
 360 {
 361         int error = acpi_sleep_prepare(acpi_target_sleep_state);
 362         if (error)
 363                 acpi_target_sleep_state = ACPI_STATE_S0;
 364
 365         return error;
 366 }
 367
 368 /**
 369  *      acpi_pm_prepare - Prepare the platform to enter the target sleep
 370  *              state and disable the GPEs.
 371  */
 372 static int acpi_pm_prepare(void)
 373 {
 374         int error = __acpi_pm_prepare();
 375         if (!error)
 376                 error = acpi_pm_pre_suspend();
 377
 378         return error;
 379 }
 380
 381 static int find_powerf_dev(struct device *dev, void *data)
 382 {
 383         struct acpi_device *device = to_acpi_device(dev);
 384         const char *hid = acpi_device_hid(device);
 385
 386         return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
 387 }
 388
 389 /**
 390  *      acpi_pm_finish - Instruct the platform to leave a sleep state.
 391  *
 392  *      This is called after we wake back up (or if entering the sleep state
 393  *      failed).
 394  */
 395 static void acpi_pm_finish(void)
 396 {
 397         struct device *pwr_btn_dev;
 398         u32 acpi_state = acpi_target_sleep_state;
 399
 400         acpi_ec_unblock_transactions();
 401         suspend_nvs_free();
 402
 403         if (acpi_state == ACPI_STATE_S0)
 404                 return;
 405
 406         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
 407                 acpi_state);
 408         acpi_disable_wakeup_devices(acpi_state);
 409         acpi_leave_sleep_state(acpi_state);
 410
 411         /* reset firmware waking vector */
 412         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
 413
 414         acpi_target_sleep_state = ACPI_STATE_S0;
 415
 416         acpi_resume_power_resources();
 417
 418         /* If we were woken with the fixed power button, provide a small
 419          * hint to userspace in the form of a wakeup event on the fixed power
 420          * button device (if it can be found).
 421          *
 422          * We delay the event generation til now, as the PM layer requires
 423          * timekeeping to be running before we generate events. */
 424         if (!pwr_btn_event_pending)
 425                 return;
 426
 427         pwr_btn_event_pending = false;
 428         pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
 429                                       find_powerf_dev);
 430         if (pwr_btn_dev) {
 431                 pm_wakeup_event(pwr_btn_dev, 0);
 432                 put_device(pwr_btn_dev);
 433         }
 434 }
 435
 436 /**
 437  * acpi_pm_start - Start system PM transition.
 438  */
 439 static void acpi_pm_start(u32 acpi_state)
 440 {
 441         acpi_target_sleep_state = acpi_state;
 442         acpi_sleep_tts_switch(acpi_target_sleep_state);
 443         acpi_scan_lock_acquire();
 444 }
 445
 446 /**
 447  * acpi_pm_end - Finish up system PM transition.
 448  */
 449 static void acpi_pm_end(void)
 450 {
 451         acpi_scan_lock_release();
 452         /*
 453          * This is necessary in case acpi_pm_finish() is not called during a
 454          * failing transition to a sleep state.
 455          */
 456         acpi_target_sleep_state = ACPI_STATE_S0;
 457         acpi_sleep_tts_switch(acpi_target_sleep_state);
 458 }
 459 #else /* !CONFIG_ACPI_SLEEP */
 460 #define acpi_target_sleep_state ACPI_STATE_S0
 461 static inline void acpi_sleep_dmi_check(void) {}
 462 #endif /* CONFIG_ACPI_SLEEP */
 463
 464 #ifdef CONFIG_SUSPEND
 465 static u32 acpi_suspend_states[] = {
 466         [PM_SUSPEND_ON] = ACPI_STATE_S0,
 467         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
 468         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
 469         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 470 };
 471
 472 /**
 473  *      acpi_suspend_begin - Set the target system sleep state to the state
 474  *              associated with given @pm_state, if supported.
 475  */
 476 static int acpi_suspend_begin(suspend_state_t pm_state)
 477 {
 478         u32 acpi_state = acpi_suspend_states[pm_state];
 479         int error;
 480
 481         error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
 482         if (error)
 483                 return error;
 484
 485         if (!sleep_states[acpi_state]) {
 486                 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
 487                 return -ENOSYS;
 488         }
 489
 490         acpi_pm_start(acpi_state);
 491         return 0;
 492 }
 493
 494 /**
 495  *      acpi_suspend_enter - Actually enter a sleep state.
 496  *      @pm_state: ignored
 497  *
 498  *      Flush caches and go to sleep. For STR we have to call arch-specific
 499  *      assembly, which in turn call acpi_enter_sleep_state().
 500  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
 501  */
 502 static int acpi_suspend_enter(suspend_state_t pm_state)
 503 {
 504         acpi_status status = AE_OK;
 505         u32 acpi_state = acpi_target_sleep_state;
 506         int error;
 507
 508         ACPI_FLUSH_CPU_CACHE();
 509
 510         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
 511         switch (acpi_state) {
 512         case ACPI_STATE_S1:
 513                 barrier();
 514                 status = acpi_enter_sleep_state(acpi_state);
 515                 break;
 516
 517         case ACPI_STATE_S3:
 518                 if (!acpi_suspend_lowlevel)
 519                         return -ENOSYS;
 520                 error = acpi_suspend_lowlevel();
 521                 if (error)
 522                         return error;
 523                 pr_info(PREFIX "Low-level resume complete\n");
 524                 break;
 525         }
 526         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
 527
 528         /* This violates the spec but is required for bug compatibility. */
 529         acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
 530
 531         /* Reprogram control registers */
 532         acpi_leave_sleep_state_prep(acpi_state);
 533
 534         /* ACPI 3.0 specs (P62) says that it's the responsibility
 535          * of the OSPM to clear the status bit [ implying that the
 536          * POWER_BUTTON event should not reach userspace ]
 537          *
 538          * However, we do generate a small hint for userspace in the form of
 539          * a wakeup event. We flag this condition for now and generate the
 540          * event later, as we're currently too early in resume to be able to
 541          * generate wakeup events.
 542          */
 543         if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
 544                 acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
 545
 546                 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
 547
 548                 if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
 549                         acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
 550                         /* Flag for later */
 551                         pwr_btn_event_pending = true;
 552                 }
 553         }
 554
 555         /*
 556          * Disable and clear GPE status before interrupt is enabled. Some GPEs
 557          * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
 558          * acpi_leave_sleep_state will reenable specific GPEs later
 559          */
 560         acpi_disable_all_gpes();
 561         /* Allow EC transactions to happen. */
 562         acpi_ec_unblock_transactions_early();
 563
 564         suspend_nvs_restore();
 565
 566         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 567 }
 568
 569 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 570 {
 571         u32 acpi_state;
 572
 573         switch (pm_state) {
 574         case PM_SUSPEND_ON:
 575         case PM_SUSPEND_STANDBY:
 576         case PM_SUSPEND_MEM:
 577                 acpi_state = acpi_suspend_states[pm_state];
 578
 579                 return sleep_states[acpi_state];
 580         default:
 581                 return 0;
 582         }
 583 }
 584
 585 static const struct platform_suspend_ops acpi_suspend_ops = {
 586         .valid = acpi_suspend_state_valid,
 587         .begin = acpi_suspend_begin,
 588         .prepare_late = acpi_pm_prepare,
 589         .enter = acpi_suspend_enter,
 590         .wake = acpi_pm_finish,
 591         .end = acpi_pm_end,
 592 };
 593
 594 /**
 595  *      acpi_suspend_begin_old - Set the target system sleep state to the
 596  *              state associated with given @pm_state, if supported, and
 597  *              execute the _PTS control method.  This function is used if the
 598  *              pre-ACPI 2.0 suspend ordering has been requested.
 599  */
 600 static int acpi_suspend_begin_old(suspend_state_t pm_state)
 601 {
 602         int error = acpi_suspend_begin(pm_state);
 603         if (!error)
 604                 error = __acpi_pm_prepare();
 605
 606         return error;
 607 }
 608
 609 /*
 610  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 611  * been requested.
 612  */
 613 static const struct platform_suspend_ops acpi_suspend_ops_old = {
 614         .valid = acpi_suspend_state_valid,
 615         .begin = acpi_suspend_begin_old,
 616         .prepare_late = acpi_pm_pre_suspend,
 617         .enter = acpi_suspend_enter,
 618         .wake = acpi_pm_finish,
 619         .end = acpi_pm_end,
 620         .recover = acpi_pm_finish,
 621 };
 622
 623 static int acpi_freeze_begin(void)
 624 {
 625         acpi_scan_lock_acquire();
 626         return 0;
 627 }
 628
 629 static void acpi_freeze_end(void)
 630 {
 631         acpi_scan_lock_release();
 632 }
 633
 634 static const struct platform_freeze_ops acpi_freeze_ops = {
 635         .begin = acpi_freeze_begin,
 636         .end = acpi_freeze_end,
 637 };
 638
 639 static void acpi_sleep_suspend_setup(void)
 640 {
 641         int i;
 642
 643         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
 644                 if (acpi_sleep_state_supported(i))
 645                         sleep_states[i] = 1;
 646
 647         suspend_set_ops(old_suspend_ordering ?
 648                 &acpi_suspend_ops_old : &acpi_suspend_ops);
 649         freeze_set_ops(&acpi_freeze_ops);
 650 }
 651
 652 #else /* !CONFIG_SUSPEND */
 653 static inline void acpi_sleep_suspend_setup(void) {}
 654 #endif /* !CONFIG_SUSPEND */
 655
 656 #ifdef CONFIG_HIBERNATION
 657 static unsigned long s4_hardware_signature;
 658 static struct acpi_table_facs *facs;
 659 static bool nosigcheck;
 660
 661 void __init acpi_no_s4_hw_signature(void)
 662 {
 663         nosigcheck = true;
 664 }
 665
 666 static int acpi_hibernation_begin(void)
 667 {
 668         int error;
 669
 670         error = nvs_nosave ? 0 : suspend_nvs_alloc();
 671         if (!error)
 672                 acpi_pm_start(ACPI_STATE_S4);
 673
 674         return error;
 675 }
 676
 677 static int acpi_hibernation_enter(void)
 678 {
 679         acpi_status status = AE_OK;
 680
 681         ACPI_FLUSH_CPU_CACHE();
 682
 683         /* This shouldn't return.  If it returns, we have a problem */
 684         status = acpi_enter_sleep_state(ACPI_STATE_S4);
 685         /* Reprogram control registers */
 686         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 687
 688         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 689 }
 690
 691 static void acpi_hibernation_leave(void)
 692 {
 693         /*
 694          * If ACPI is not enabled by the BIOS and the boot kernel, we need to
 695          * enable it here.
 696          */
 697         acpi_enable();
 698         /* Reprogram control registers */
 699         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 700         /* Check the hardware signature */
 701         if (facs && s4_hardware_signature != facs->hardware_signature)
 702                 pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
 703         /* Restore the NVS memory area */
 704         suspend_nvs_restore();
 705         /* Allow EC transactions to happen. */
 706         acpi_ec_unblock_transactions_early();
 707 }
 708
 709 static void acpi_pm_thaw(void)
 710 {
 711         acpi_ec_unblock_transactions();
 712         acpi_enable_all_runtime_gpes();
 713 }
 714
 715 static const struct platform_hibernation_ops acpi_hibernation_ops = {
 716         .begin = acpi_hibernation_begin,
 717         .end = acpi_pm_end,
 718         .pre_snapshot = acpi_pm_prepare,
 719         .finish = acpi_pm_finish,
 720         .prepare = acpi_pm_prepare,
 721         .enter = acpi_hibernation_enter,
 722         .leave = acpi_hibernation_leave,
 723         .pre_restore = acpi_pm_freeze,
 724         .restore_cleanup = acpi_pm_thaw,
 725 };
 726
 727 /**
 728  *      acpi_hibernation_begin_old - Set the target system sleep state to
 729  *              ACPI_STATE_S4 and execute the _PTS control method.  This
 730  *              function is used if the pre-ACPI 2.0 suspend ordering has been
 731  *              requested.
 732  */
 733 static int acpi_hibernation_begin_old(void)
 734 {
 735         int error;
 736         /*
 737          * The _TTS object should always be evaluated before the _PTS object.
 738          * When the old_suspended_ordering is true, the _PTS object is
 739          * evaluated in the acpi_sleep_prepare.
 740          */
 741         acpi_sleep_tts_switch(ACPI_STATE_S4);
 742
 743         error = acpi_sleep_prepare(ACPI_STATE_S4);
 744
 745         if (!error) {
 746                 if (!nvs_nosave)
 747                         error = suspend_nvs_alloc();
 748                 if (!error) {
 749                         acpi_target_sleep_state = ACPI_STATE_S4;
 750                         acpi_scan_lock_acquire();
 751                 }
 752         }
 753         return error;
 754 }
 755
 756 /*
 757  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 758  * been requested.
 759  */
 760 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
 761         .begin = acpi_hibernation_begin_old,
 762         .end = acpi_pm_end,
 763         .pre_snapshot = acpi_pm_pre_suspend,
 764         .prepare = acpi_pm_freeze,
 765         .finish = acpi_pm_finish,
 766         .enter = acpi_hibernation_enter,
 767         .leave = acpi_hibernation_leave,
 768         .pre_restore = acpi_pm_freeze,
 769         .restore_cleanup = acpi_pm_thaw,
 770         .recover = acpi_pm_finish,
 771 };
 772
 773 static void acpi_sleep_hibernate_setup(void)
 774 {
 775         if (!acpi_sleep_state_supported(ACPI_STATE_S4))
 776                 return;
 777
 778         hibernation_set_ops(old_suspend_ordering ?
 779                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
 780         sleep_states[ACPI_STATE_S4] = 1;
 781         if (nosigcheck)
 782                 return;
 783
 784         acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
 785         if (facs)
 786                 s4_hardware_signature = facs->hardware_signature;
 787 }
 788 #else /* !CONFIG_HIBERNATION */
 789 static inline void acpi_sleep_hibernate_setup(void) {}
 790 #endif /* !CONFIG_HIBERNATION */
 791
 792 int acpi_suspend(u32 acpi_state)
 793 {
 794         suspend_state_t states[] = {
 795                 [1] = PM_SUSPEND_STANDBY,
 796                 [3] = PM_SUSPEND_MEM,
 797                 [5] = PM_SUSPEND_MAX
 798         };
 799
 800         if (acpi_state < 6 && states[acpi_state])
 801                 return pm_suspend(states[acpi_state]);
 802         if (acpi_state == 4)
 803                 return hibernate();
 804         return -EINVAL;
 805 }
 806
 807 static void acpi_power_off_prepare(void)
 808 {
 809         /* Prepare to power off the system */
 810         acpi_sleep_prepare(ACPI_STATE_S5);
 811         acpi_disable_all_gpes();
 812 }
 813
 814 static void acpi_power_off(void)
 815 {
 816         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
 817         printk(KERN_DEBUG "%s called\n", __func__);
 818         local_irq_disable();
 819         acpi_enter_sleep_state(ACPI_STATE_S5);
 820 }
 821
 822 int __init acpi_sleep_init(void)
 823 {
 824         char supported[ACPI_S_STATE_COUNT * 3 + 1];
 825         char *pos = supported;
 826         int i;
 827
 828         acpi_sleep_dmi_check();
 829
 830         sleep_states[ACPI_STATE_S0] = 1;
 831
 832         acpi_sleep_suspend_setup();
 833         acpi_sleep_hibernate_setup();
 834
 835         if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
 836                 sleep_states[ACPI_STATE_S5] = 1;
 837                 pm_power_off_prepare = acpi_power_off_prepare;
 838                 pm_power_off = acpi_power_off;
 839         }
 840
 841         supported[0] = 0;
 842         for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
 843                 if (sleep_states[i])
 844                         pos += sprintf(pos, " S%d", i);
 845         }
 846         pr_info(PREFIX "(supports%s)\n", supported);
 847
 848         /*
 849          * Register the tts_notifier to reboot notifier list so that the _TTS
 850          * object can also be evaluated when the system enters S5.
 851          */
 852         register_reboot_notifier(&tts_notifier);
 853         return 0;
 854 }