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         dmi_check_system(acpisleep_dmi_table);
 326 }
 327
 328 /**
 329  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
 330  */
 331 static int acpi_pm_freeze(void)
 332 {
 333         acpi_disable_all_gpes();
 334         acpi_os_wait_events_complete();
 335         acpi_ec_block_transactions();
 336         return 0;
 337 }
 338
 339 /**
 340  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
 341  */
 342 static int acpi_pm_pre_suspend(void)
 343 {
 344         acpi_pm_freeze();
 345         return suspend_nvs_save();
 346 }
 347
 348 /**
 349  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
 350  *
 351  *      If necessary, set the firmware waking vector and do arch-specific
 352  *      nastiness to get the wakeup code to the waking vector.
 353  */
 354 static int __acpi_pm_prepare(void)
 355 {
 356         int error = acpi_sleep_prepare(acpi_target_sleep_state);
 357         if (error)
 358                 acpi_target_sleep_state = ACPI_STATE_S0;
 359
 360         return error;
 361 }
 362
 363 /**
 364  *      acpi_pm_prepare - Prepare the platform to enter the target sleep
 365  *              state and disable the GPEs.
 366  */
 367 static int acpi_pm_prepare(void)
 368 {
 369         int error = __acpi_pm_prepare();
 370         if (!error)
 371                 error = acpi_pm_pre_suspend();
 372
 373         return error;
 374 }
 375
 376 static int find_powerf_dev(struct device *dev, void *data)
 377 {
 378         struct acpi_device *device = to_acpi_device(dev);
 379         const char *hid = acpi_device_hid(device);
 380
 381         return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
 382 }
 383
 384 /**
 385  *      acpi_pm_finish - Instruct the platform to leave a sleep state.
 386  *
 387  *      This is called after we wake back up (or if entering the sleep state
 388  *      failed).
 389  */
 390 static void acpi_pm_finish(void)
 391 {
 392         struct device *pwr_btn_dev;
 393         u32 acpi_state = acpi_target_sleep_state;
 394
 395         acpi_ec_unblock_transactions();
 396         suspend_nvs_free();
 397
 398         if (acpi_state == ACPI_STATE_S0)
 399                 return;
 400
 401         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
 402                 acpi_state);
 403         acpi_disable_wakeup_devices(acpi_state);
 404         acpi_leave_sleep_state(acpi_state);
 405
 406         /* reset firmware waking vector */
 407         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
 408
 409         acpi_target_sleep_state = ACPI_STATE_S0;
 410
 411         acpi_resume_power_resources();
 412
 413         /* If we were woken with the fixed power button, provide a small
 414          * hint to userspace in the form of a wakeup event on the fixed power
 415          * button device (if it can be found).
 416          *
 417          * We delay the event generation til now, as the PM layer requires
 418          * timekeeping to be running before we generate events. */
 419         if (!pwr_btn_event_pending)
 420                 return;
 421
 422         pwr_btn_event_pending = false;
 423         pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
 424                                       find_powerf_dev);
 425         if (pwr_btn_dev) {
 426                 pm_wakeup_event(pwr_btn_dev, 0);
 427                 put_device(pwr_btn_dev);
 428         }
 429 }
 430
 431 /**
 432  * acpi_pm_start - Start system PM transition.
 433  */
 434 static void acpi_pm_start(u32 acpi_state)
 435 {
 436         acpi_target_sleep_state = acpi_state;
 437         acpi_sleep_tts_switch(acpi_target_sleep_state);
 438         acpi_scan_lock_acquire();
 439 }
 440
 441 /**
 442  * acpi_pm_end - Finish up system PM transition.
 443  */
 444 static void acpi_pm_end(void)
 445 {
 446         acpi_scan_lock_release();
 447         /*
 448          * This is necessary in case acpi_pm_finish() is not called during a
 449          * failing transition to a sleep state.
 450          */
 451         acpi_target_sleep_state = ACPI_STATE_S0;
 452         acpi_sleep_tts_switch(acpi_target_sleep_state);
 453 }
 454 #else /* !CONFIG_ACPI_SLEEP */
 455 #define acpi_target_sleep_state ACPI_STATE_S0
 456 static inline void acpi_sleep_dmi_check(void) {}
 457 #endif /* CONFIG_ACPI_SLEEP */
 458
 459 #ifdef CONFIG_SUSPEND
 460 static u32 acpi_suspend_states[] = {
 461         [PM_SUSPEND_ON] = ACPI_STATE_S0,
 462         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
 463         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
 464         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 465 };
 466
 467 /**
 468  *      acpi_suspend_begin - Set the target system sleep state to the state
 469  *              associated with given @pm_state, if supported.
 470  */
 471 static int acpi_suspend_begin(suspend_state_t pm_state)
 472 {
 473         u32 acpi_state = acpi_suspend_states[pm_state];
 474         int error;
 475
 476         error = (nvs_nosave || nvs_nosave_s3) ? 0 : suspend_nvs_alloc();
 477         if (error)
 478                 return error;
 479
 480         if (!sleep_states[acpi_state]) {
 481                 pr_err("ACPI does not support sleep state S%u\n", acpi_state);
 482                 return -ENOSYS;
 483         }
 484
 485         acpi_pm_start(acpi_state);
 486         return 0;
 487 }
 488
 489 /**
 490  *      acpi_suspend_enter - Actually enter a sleep state.
 491  *      @pm_state: ignored
 492  *
 493  *      Flush caches and go to sleep. For STR we have to call arch-specific
 494  *      assembly, which in turn call acpi_enter_sleep_state().
 495  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
 496  */
 497 static int acpi_suspend_enter(suspend_state_t pm_state)
 498 {
 499         acpi_status status = AE_OK;
 500         u32 acpi_state = acpi_target_sleep_state;
 501         int error;
 502
 503         ACPI_FLUSH_CPU_CACHE();
 504
 505         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, true);
 506         switch (acpi_state) {
 507         case ACPI_STATE_S1:
 508                 barrier();
 509                 status = acpi_enter_sleep_state(acpi_state);
 510                 break;
 511
 512         case ACPI_STATE_S3:
 513                 if (!acpi_suspend_lowlevel)
 514                         return -ENOSYS;
 515                 error = acpi_suspend_lowlevel();
 516                 if (error)
 517                         return error;
 518                 pr_info(PREFIX "Low-level resume complete\n");
 519                 break;
 520         }
 521         trace_suspend_resume(TPS("acpi_suspend"), acpi_state, false);
 522
 523         /* This violates the spec but is required for bug compatibility. */
 524         acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
 525
 526         /* Reprogram control registers */
 527         acpi_leave_sleep_state_prep(acpi_state);
 528
 529         /* ACPI 3.0 specs (P62) says that it's the responsibility
 530          * of the OSPM to clear the status bit [ implying that the
 531          * POWER_BUTTON event should not reach userspace ]
 532          *
 533          * However, we do generate a small hint for userspace in the form of
 534          * a wakeup event. We flag this condition for now and generate the
 535          * event later, as we're currently too early in resume to be able to
 536          * generate wakeup events.
 537          */
 538         if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
 539                 acpi_event_status pwr_btn_status = ACPI_EVENT_FLAG_DISABLED;
 540
 541                 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
 542
 543                 if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
 544                         acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
 545                         /* Flag for later */
 546                         pwr_btn_event_pending = true;
 547                 }
 548         }
 549
 550         /*
 551          * Disable and clear GPE status before interrupt is enabled. Some GPEs
 552          * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
 553          * acpi_leave_sleep_state will reenable specific GPEs later
 554          */
 555         acpi_disable_all_gpes();
 556         /* Allow EC transactions to happen. */
 557         acpi_ec_unblock_transactions_early();
 558
 559         suspend_nvs_restore();
 560
 561         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 562 }
 563
 564 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 565 {
 566         u32 acpi_state;
 567
 568         switch (pm_state) {
 569         case PM_SUSPEND_ON:
 570         case PM_SUSPEND_STANDBY:
 571         case PM_SUSPEND_MEM:
 572                 acpi_state = acpi_suspend_states[pm_state];
 573
 574                 return sleep_states[acpi_state];
 575         default:
 576                 return 0;
 577         }
 578 }
 579
 580 static const struct platform_suspend_ops acpi_suspend_ops = {
 581         .valid = acpi_suspend_state_valid,
 582         .begin = acpi_suspend_begin,
 583         .prepare_late = acpi_pm_prepare,
 584         .enter = acpi_suspend_enter,
 585         .wake = acpi_pm_finish,
 586         .end = acpi_pm_end,
 587 };
 588
 589 /**
 590  *      acpi_suspend_begin_old - Set the target system sleep state to the
 591  *              state associated with given @pm_state, if supported, and
 592  *              execute the _PTS control method.  This function is used if the
 593  *              pre-ACPI 2.0 suspend ordering has been requested.
 594  */
 595 static int acpi_suspend_begin_old(suspend_state_t pm_state)
 596 {
 597         int error = acpi_suspend_begin(pm_state);
 598         if (!error)
 599                 error = __acpi_pm_prepare();
 600
 601         return error;
 602 }
 603
 604 /*
 605  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 606  * been requested.
 607  */
 608 static const struct platform_suspend_ops acpi_suspend_ops_old = {
 609         .valid = acpi_suspend_state_valid,
 610         .begin = acpi_suspend_begin_old,
 611         .prepare_late = acpi_pm_pre_suspend,
 612         .enter = acpi_suspend_enter,
 613         .wake = acpi_pm_finish,
 614         .end = acpi_pm_end,
 615         .recover = acpi_pm_finish,
 616 };
 617
 618 static int acpi_freeze_begin(void)
 619 {
 620         acpi_scan_lock_acquire();
 621         return 0;
 622 }
 623
 624 static void acpi_freeze_end(void)
 625 {
 626         acpi_scan_lock_release();
 627 }
 628
 629 static const struct platform_freeze_ops acpi_freeze_ops = {
 630         .begin = acpi_freeze_begin,
 631         .end = acpi_freeze_end,
 632 };
 633
 634 static void acpi_sleep_suspend_setup(void)
 635 {
 636         int i;
 637
 638         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++)
 639                 if (acpi_sleep_state_supported(i))
 640                         sleep_states[i] = 1;
 641
 642         suspend_set_ops(old_suspend_ordering ?
 643                 &acpi_suspend_ops_old : &acpi_suspend_ops);
 644         freeze_set_ops(&acpi_freeze_ops);
 645 }
 646
 647 #else /* !CONFIG_SUSPEND */
 648 static inline void acpi_sleep_suspend_setup(void) {}
 649 #endif /* !CONFIG_SUSPEND */
 650
 651 #ifdef CONFIG_HIBERNATION
 652 static unsigned long s4_hardware_signature;
 653 static struct acpi_table_facs *facs;
 654 static bool nosigcheck;
 655
 656 void __init acpi_no_s4_hw_signature(void)
 657 {
 658         nosigcheck = true;
 659 }
 660
 661 static int acpi_hibernation_begin(void)
 662 {
 663         int error;
 664
 665         error = nvs_nosave ? 0 : suspend_nvs_alloc();
 666         if (!error)
 667                 acpi_pm_start(ACPI_STATE_S4);
 668
 669         return error;
 670 }
 671
 672 static int acpi_hibernation_enter(void)
 673 {
 674         acpi_status status = AE_OK;
 675
 676         ACPI_FLUSH_CPU_CACHE();
 677
 678         /* This shouldn't return.  If it returns, we have a problem */
 679         status = acpi_enter_sleep_state(ACPI_STATE_S4);
 680         /* Reprogram control registers */
 681         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 682
 683         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 684 }
 685
 686 static void acpi_hibernation_leave(void)
 687 {
 688         /*
 689          * If ACPI is not enabled by the BIOS and the boot kernel, we need to
 690          * enable it here.
 691          */
 692         acpi_enable();
 693         /* Reprogram control registers */
 694         acpi_leave_sleep_state_prep(ACPI_STATE_S4);
 695         /* Check the hardware signature */
 696         if (facs && s4_hardware_signature != facs->hardware_signature)
 697                 pr_crit("ACPI: Hardware changed while hibernated, success doubtful!\n");
 698         /* Restore the NVS memory area */
 699         suspend_nvs_restore();
 700         /* Allow EC transactions to happen. */
 701         acpi_ec_unblock_transactions_early();
 702 }
 703
 704 static void acpi_pm_thaw(void)
 705 {
 706         acpi_ec_unblock_transactions();
 707         acpi_enable_all_runtime_gpes();
 708 }
 709
 710 static const struct platform_hibernation_ops acpi_hibernation_ops = {
 711         .begin = acpi_hibernation_begin,
 712         .end = acpi_pm_end,
 713         .pre_snapshot = acpi_pm_prepare,
 714         .finish = acpi_pm_finish,
 715         .prepare = acpi_pm_prepare,
 716         .enter = acpi_hibernation_enter,
 717         .leave = acpi_hibernation_leave,
 718         .pre_restore = acpi_pm_freeze,
 719         .restore_cleanup = acpi_pm_thaw,
 720 };
 721
 722 /**
 723  *      acpi_hibernation_begin_old - Set the target system sleep state to
 724  *              ACPI_STATE_S4 and execute the _PTS control method.  This
 725  *              function is used if the pre-ACPI 2.0 suspend ordering has been
 726  *              requested.
 727  */
 728 static int acpi_hibernation_begin_old(void)
 729 {
 730         int error;
 731         /*
 732          * The _TTS object should always be evaluated before the _PTS object.
 733          * When the old_suspended_ordering is true, the _PTS object is
 734          * evaluated in the acpi_sleep_prepare.
 735          */
 736         acpi_sleep_tts_switch(ACPI_STATE_S4);
 737
 738         error = acpi_sleep_prepare(ACPI_STATE_S4);
 739
 740         if (!error) {
 741                 if (!nvs_nosave)
 742                         error = suspend_nvs_alloc();
 743                 if (!error) {
 744                         acpi_target_sleep_state = ACPI_STATE_S4;
 745                         acpi_scan_lock_acquire();
 746                 }
 747         }
 748         return error;
 749 }
 750
 751 /*
 752  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 753  * been requested.
 754  */
 755 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
 756         .begin = acpi_hibernation_begin_old,
 757         .end = acpi_pm_end,
 758         .pre_snapshot = acpi_pm_pre_suspend,
 759         .prepare = acpi_pm_freeze,
 760         .finish = acpi_pm_finish,
 761         .enter = acpi_hibernation_enter,
 762         .leave = acpi_hibernation_leave,
 763         .pre_restore = acpi_pm_freeze,
 764         .restore_cleanup = acpi_pm_thaw,
 765         .recover = acpi_pm_finish,
 766 };
 767
 768 static void acpi_sleep_hibernate_setup(void)
 769 {
 770         if (!acpi_sleep_state_supported(ACPI_STATE_S4))
 771                 return;
 772
 773         hibernation_set_ops(old_suspend_ordering ?
 774                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
 775         sleep_states[ACPI_STATE_S4] = 1;
 776         if (nosigcheck)
 777                 return;
 778
 779         acpi_get_table(ACPI_SIG_FACS, 1, (struct acpi_table_header **)&facs);
 780         if (facs)
 781                 s4_hardware_signature = facs->hardware_signature;
 782 }
 783 #else /* !CONFIG_HIBERNATION */
 784 static inline void acpi_sleep_hibernate_setup(void) {}
 785 #endif /* !CONFIG_HIBERNATION */
 786
 787 int acpi_suspend(u32 acpi_state)
 788 {
 789         suspend_state_t states[] = {
 790                 [1] = PM_SUSPEND_STANDBY,
 791                 [3] = PM_SUSPEND_MEM,
 792                 [5] = PM_SUSPEND_MAX
 793         };
 794
 795         if (acpi_state < 6 && states[acpi_state])
 796                 return pm_suspend(states[acpi_state]);
 797         if (acpi_state == 4)
 798                 return hibernate();
 799         return -EINVAL;
 800 }
 801
 802 static void acpi_power_off_prepare(void)
 803 {
 804         /* Prepare to power off the system */
 805         acpi_sleep_prepare(ACPI_STATE_S5);
 806         acpi_disable_all_gpes();
 807 }
 808
 809 static void acpi_power_off(void)
 810 {
 811         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
 812         printk(KERN_DEBUG "%s called\n", __func__);
 813         local_irq_disable();
 814         acpi_enter_sleep_state(ACPI_STATE_S5);
 815 }
 816
 817 int __init acpi_sleep_init(void)
 818 {
 819         char supported[ACPI_S_STATE_COUNT * 3 + 1];
 820         char *pos = supported;
 821         int i;
 822
 823         acpi_sleep_dmi_check();
 824
 825         sleep_states[ACPI_STATE_S0] = 1;
 826
 827         acpi_sleep_suspend_setup();
 828         acpi_sleep_hibernate_setup();
 829
 830         if (acpi_sleep_state_supported(ACPI_STATE_S5)) {
 831                 sleep_states[ACPI_STATE_S5] = 1;
 832                 pm_power_off_prepare = acpi_power_off_prepare;
 833                 pm_power_off = acpi_power_off;
 834         }
 835
 836         supported[0] = 0;
 837         for (i = 0; i < ACPI_S_STATE_COUNT; i++) {
 838                 if (sleep_states[i])
 839                         pos += sprintf(pos, " S%d", i);
 840         }
 841         pr_info(PREFIX "(supports%s)\n", supported);
 842
 843         /*
 844          * Register the tts_notifier to reboot notifier list so that the _TTS
 845          * object can also be evaluated when the system enters S5.
 846          */
 847         register_reboot_notifier(&tts_notifier);
 848         return 0;
 849 }