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 <linux/pm_runtime.h>
  22
  23 #include <asm/io.h>
  24
  25 #include <acpi/acpi_bus.h>
  26 #include <acpi/acpi_drivers.h>
  27
  28 #include "internal.h"
  29 #include "sleep.h"
  30
  31 u8 wake_sleep_flags = ACPI_NO_OPTIONAL_METHODS;
  32 static unsigned int gts, bfs;
  33 static int set_param_wake_flag(const char *val, struct kernel_param *kp)
  34 {
  35         int ret = param_set_int(val, kp);
  36
  37         if (ret)
  38                 return ret;
  39
  40         if (kp->arg == (const char *)&gts) {
  41                 if (gts)
  42                         wake_sleep_flags |= ACPI_EXECUTE_GTS;
  43                 else
  44                         wake_sleep_flags &= ~ACPI_EXECUTE_GTS;
  45         }
  46         if (kp->arg == (const char *)&bfs) {
  47                 if (bfs)
  48                         wake_sleep_flags |= ACPI_EXECUTE_BFS;
  49                 else
  50                         wake_sleep_flags &= ~ACPI_EXECUTE_BFS;
  51         }
  52         return ret;
  53 }
  54 module_param_call(gts, set_param_wake_flag, param_get_int, &gts, 0644);
  55 module_param_call(bfs, set_param_wake_flag, param_get_int, &bfs, 0644);
  56 MODULE_PARM_DESC(gts, "Enable evaluation of _GTS on suspend.");
  57 MODULE_PARM_DESC(bfs, "Enable evaluation of _BFS on resume".);
  58
  59 static u8 sleep_states[ACPI_S_STATE_COUNT];
  60 static bool pwr_btn_event_pending;
  61
  62 static void acpi_sleep_tts_switch(u32 acpi_state)
  63 {
  64         union acpi_object in_arg = { ACPI_TYPE_INTEGER };
  65         struct acpi_object_list arg_list = { 1, &in_arg };
  66         acpi_status status = AE_OK;
  67
  68         in_arg.integer.value = acpi_state;
  69         status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL);
  70         if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
  71                 /*
  72                  * OS can't evaluate the _TTS object correctly. Some warning
  73                  * message will be printed. But it won't break anything.
  74                  */
  75                 printk(KERN_NOTICE "Failure in evaluating _TTS object\n");
  76         }
  77 }
  78
  79 static int tts_notify_reboot(struct notifier_block *this,
  80                         unsigned long code, void *x)
  81 {
  82         acpi_sleep_tts_switch(ACPI_STATE_S5);
  83         return NOTIFY_DONE;
  84 }
  85
  86 static struct notifier_block tts_notifier = {
  87         .notifier_call  = tts_notify_reboot,
  88         .next           = NULL,
  89         .priority       = 0,
  90 };
  91
  92 static int acpi_sleep_prepare(u32 acpi_state)
  93 {
  94 #ifdef CONFIG_ACPI_SLEEP
  95         /* do we have a wakeup address for S2 and S3? */
  96         if (acpi_state == ACPI_STATE_S3) {
  97                 if (!acpi_wakeup_address)
  98                         return -EFAULT;
  99                 acpi_set_firmware_waking_vector(acpi_wakeup_address);
 100
 101         }
 102         ACPI_FLUSH_CPU_CACHE();
 103 #endif
 104         printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n",
 105                 acpi_state);
 106         acpi_enable_wakeup_devices(acpi_state);
 107         acpi_enter_sleep_state_prep(acpi_state);
 108         return 0;
 109 }
 110
 111 #ifdef CONFIG_ACPI_SLEEP
 112 static u32 acpi_target_sleep_state = ACPI_STATE_S0;
 113
 114 /*
 115  * The ACPI specification wants us to save NVS memory regions during hibernation
 116  * and to restore them during the subsequent resume.  Windows does that also for
 117  * suspend to RAM.  However, it is known that this mechanism does not work on
 118  * all machines, so we allow the user to disable it with the help of the
 119  * 'acpi_sleep=nonvs' kernel command line option.
 120  */
 121 static bool nvs_nosave;
 122
 123 void __init acpi_nvs_nosave(void)
 124 {
 125         nvs_nosave = true;
 126 }
 127
 128 /*
 129  * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the
 130  * user to request that behavior by using the 'acpi_old_suspend_ordering'
 131  * kernel command line option that causes the following variable to be set.
 132  */
 133 static bool old_suspend_ordering;
 134
 135 void __init acpi_old_suspend_ordering(void)
 136 {
 137         old_suspend_ordering = true;
 138 }
 139
 140 /**
 141  * acpi_pm_freeze - Disable the GPEs and suspend EC transactions.
 142  */
 143 static int acpi_pm_freeze(void)
 144 {
 145         acpi_disable_all_gpes();
 146         acpi_os_wait_events_complete(NULL);
 147         acpi_ec_block_transactions();
 148         return 0;
 149 }
 150
 151 /**
 152  * acpi_pre_suspend - Enable wakeup devices, "freeze" EC and save NVS.
 153  */
 154 static int acpi_pm_pre_suspend(void)
 155 {
 156         acpi_pm_freeze();
 157         return suspend_nvs_save();
 158 }
 159
 160 /**
 161  *      __acpi_pm_prepare - Prepare the platform to enter the target state.
 162  *
 163  *      If necessary, set the firmware waking vector and do arch-specific
 164  *      nastiness to get the wakeup code to the waking vector.
 165  */
 166 static int __acpi_pm_prepare(void)
 167 {
 168         int error = acpi_sleep_prepare(acpi_target_sleep_state);
 169         if (error)
 170                 acpi_target_sleep_state = ACPI_STATE_S0;
 171
 172         return error;
 173 }
 174
 175 /**
 176  *      acpi_pm_prepare - Prepare the platform to enter the target sleep
 177  *              state and disable the GPEs.
 178  */
 179 static int acpi_pm_prepare(void)
 180 {
 181         int error = __acpi_pm_prepare();
 182         if (!error)
 183                 error = acpi_pm_pre_suspend();
 184
 185         return error;
 186 }
 187
 188 static int find_powerf_dev(struct device *dev, void *data)
 189 {
 190         struct acpi_device *device = to_acpi_device(dev);
 191         const char *hid = acpi_device_hid(device);
 192
 193         return !strcmp(hid, ACPI_BUTTON_HID_POWERF);
 194 }
 195
 196 /**
 197  *      acpi_pm_finish - Instruct the platform to leave a sleep state.
 198  *
 199  *      This is called after we wake back up (or if entering the sleep state
 200  *      failed).
 201  */
 202 static void acpi_pm_finish(void)
 203 {
 204         struct device *pwr_btn_dev;
 205         u32 acpi_state = acpi_target_sleep_state;
 206
 207         acpi_ec_unblock_transactions();
 208         suspend_nvs_free();
 209
 210         if (acpi_state == ACPI_STATE_S0)
 211                 return;
 212
 213         printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n",
 214                 acpi_state);
 215         acpi_disable_wakeup_devices(acpi_state);
 216         acpi_leave_sleep_state(acpi_state);
 217
 218         /* reset firmware waking vector */
 219         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
 220
 221         acpi_target_sleep_state = ACPI_STATE_S0;
 222
 223         /* If we were woken with the fixed power button, provide a small
 224          * hint to userspace in the form of a wakeup event on the fixed power
 225          * button device (if it can be found).
 226          *
 227          * We delay the event generation til now, as the PM layer requires
 228          * timekeeping to be running before we generate events. */
 229         if (!pwr_btn_event_pending)
 230                 return;
 231
 232         pwr_btn_event_pending = false;
 233         pwr_btn_dev = bus_find_device(&acpi_bus_type, NULL, NULL,
 234                                       find_powerf_dev);
 235         if (pwr_btn_dev) {
 236                 pm_wakeup_event(pwr_btn_dev, 0);
 237                 put_device(pwr_btn_dev);
 238         }
 239 }
 240
 241 /**
 242  *      acpi_pm_end - Finish up suspend sequence.
 243  */
 244 static void acpi_pm_end(void)
 245 {
 246         /*
 247          * This is necessary in case acpi_pm_finish() is not called during a
 248          * failing transition to a sleep state.
 249          */
 250         acpi_target_sleep_state = ACPI_STATE_S0;
 251         acpi_sleep_tts_switch(acpi_target_sleep_state);
 252 }
 253 #else /* !CONFIG_ACPI_SLEEP */
 254 #define acpi_target_sleep_state ACPI_STATE_S0
 255 #endif /* CONFIG_ACPI_SLEEP */
 256
 257 #ifdef CONFIG_SUSPEND
 258 static u32 acpi_suspend_states[] = {
 259         [PM_SUSPEND_ON] = ACPI_STATE_S0,
 260         [PM_SUSPEND_STANDBY] = ACPI_STATE_S1,
 261         [PM_SUSPEND_MEM] = ACPI_STATE_S3,
 262         [PM_SUSPEND_MAX] = ACPI_STATE_S5
 263 };
 264
 265 /**
 266  *      acpi_suspend_begin - Set the target system sleep state to the state
 267  *              associated with given @pm_state, if supported.
 268  */
 269 static int acpi_suspend_begin(suspend_state_t pm_state)
 270 {
 271         u32 acpi_state = acpi_suspend_states[pm_state];
 272         int error = 0;
 273
 274         error = nvs_nosave ? 0 : suspend_nvs_alloc();
 275         if (error)
 276                 return error;
 277
 278         if (sleep_states[acpi_state]) {
 279                 acpi_target_sleep_state = acpi_state;
 280                 acpi_sleep_tts_switch(acpi_target_sleep_state);
 281         } else {
 282                 printk(KERN_ERR "ACPI does not support this state: %d\n",
 283                         pm_state);
 284                 error = -ENOSYS;
 285         }
 286         return error;
 287 }
 288
 289 /**
 290  *      acpi_suspend_enter - Actually enter a sleep state.
 291  *      @pm_state: ignored
 292  *
 293  *      Flush caches and go to sleep. For STR we have to call arch-specific
 294  *      assembly, which in turn call acpi_enter_sleep_state().
 295  *      It's unfortunate, but it works. Please fix if you're feeling frisky.
 296  */
 297 static int acpi_suspend_enter(suspend_state_t pm_state)
 298 {
 299         acpi_status status = AE_OK;
 300         u32 acpi_state = acpi_target_sleep_state;
 301         int error;
 302
 303         ACPI_FLUSH_CPU_CACHE();
 304
 305         switch (acpi_state) {
 306         case ACPI_STATE_S1:
 307                 barrier();
 308                 status = acpi_enter_sleep_state(acpi_state, wake_sleep_flags);
 309                 break;
 310
 311         case ACPI_STATE_S3:
 312                 error = acpi_suspend_lowlevel();
 313                 if (error)
 314                         return error;
 315                 pr_info(PREFIX "Low-level resume complete\n");
 316                 break;
 317         }
 318
 319         /* This violates the spec but is required for bug compatibility. */
 320         acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1);
 321
 322         /* Reprogram control registers and execute _BFS */
 323         acpi_leave_sleep_state_prep(acpi_state, wake_sleep_flags);
 324
 325         /* ACPI 3.0 specs (P62) says that it's the responsibility
 326          * of the OSPM to clear the status bit [ implying that the
 327          * POWER_BUTTON event should not reach userspace ]
 328          *
 329          * However, we do generate a small hint for userspace in the form of
 330          * a wakeup event. We flag this condition for now and generate the
 331          * event later, as we're currently too early in resume to be able to
 332          * generate wakeup events.
 333          */
 334         if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) {
 335                 acpi_event_status pwr_btn_status;
 336
 337                 acpi_get_event_status(ACPI_EVENT_POWER_BUTTON, &pwr_btn_status);
 338
 339                 if (pwr_btn_status & ACPI_EVENT_FLAG_SET) {
 340                         acpi_clear_event(ACPI_EVENT_POWER_BUTTON);
 341                         /* Flag for later */
 342                         pwr_btn_event_pending = true;
 343                 }
 344         }
 345
 346         /*
 347          * Disable and clear GPE status before interrupt is enabled. Some GPEs
 348          * (like wakeup GPE) haven't handler, this can avoid such GPE misfire.
 349          * acpi_leave_sleep_state will reenable specific GPEs later
 350          */
 351         acpi_disable_all_gpes();
 352         /* Allow EC transactions to happen. */
 353         acpi_ec_unblock_transactions_early();
 354
 355         suspend_nvs_restore();
 356
 357         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 358 }
 359
 360 static int acpi_suspend_state_valid(suspend_state_t pm_state)
 361 {
 362         u32 acpi_state;
 363
 364         switch (pm_state) {
 365         case PM_SUSPEND_ON:
 366         case PM_SUSPEND_STANDBY:
 367         case PM_SUSPEND_MEM:
 368                 acpi_state = acpi_suspend_states[pm_state];
 369
 370                 return sleep_states[acpi_state];
 371         default:
 372                 return 0;
 373         }
 374 }
 375
 376 static const struct platform_suspend_ops acpi_suspend_ops = {
 377         .valid = acpi_suspend_state_valid,
 378         .begin = acpi_suspend_begin,
 379         .prepare_late = acpi_pm_prepare,
 380         .enter = acpi_suspend_enter,
 381         .wake = acpi_pm_finish,
 382         .end = acpi_pm_end,
 383 };
 384
 385 /**
 386  *      acpi_suspend_begin_old - Set the target system sleep state to the
 387  *              state associated with given @pm_state, if supported, and
 388  *              execute the _PTS control method.  This function is used if the
 389  *              pre-ACPI 2.0 suspend ordering has been requested.
 390  */
 391 static int acpi_suspend_begin_old(suspend_state_t pm_state)
 392 {
 393         int error = acpi_suspend_begin(pm_state);
 394         if (!error)
 395                 error = __acpi_pm_prepare();
 396
 397         return error;
 398 }
 399
 400 /*
 401  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 402  * been requested.
 403  */
 404 static const struct platform_suspend_ops acpi_suspend_ops_old = {
 405         .valid = acpi_suspend_state_valid,
 406         .begin = acpi_suspend_begin_old,
 407         .prepare_late = acpi_pm_pre_suspend,
 408         .enter = acpi_suspend_enter,
 409         .wake = acpi_pm_finish,
 410         .end = acpi_pm_end,
 411         .recover = acpi_pm_finish,
 412 };
 413
 414 static int __init init_old_suspend_ordering(const struct dmi_system_id *d)
 415 {
 416         old_suspend_ordering = true;
 417         return 0;
 418 }
 419
 420 static int __init init_nvs_nosave(const struct dmi_system_id *d)
 421 {
 422         acpi_nvs_nosave();
 423         return 0;
 424 }
 425
 426 static struct dmi_system_id __initdata acpisleep_dmi_table[] = {
 427         {
 428         .callback = init_old_suspend_ordering,
 429         .ident = "Abit KN9 (nForce4 variant)",
 430         .matches = {
 431                 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"),
 432                 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"),
 433                 },
 434         },
 435         {
 436         .callback = init_old_suspend_ordering,
 437         .ident = "HP xw4600 Workstation",
 438         .matches = {
 439                 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
 440                 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"),
 441                 },
 442         },
 443         {
 444         .callback = init_old_suspend_ordering,
 445         .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)",
 446         .matches = {
 447                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."),
 448                 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"),
 449                 },
 450         },
 451         {
 452         .callback = init_old_suspend_ordering,
 453         .ident = "Panasonic CF51-2L",
 454         .matches = {
 455                 DMI_MATCH(DMI_BOARD_VENDOR,
 456                                 "Matsushita Electric Industrial Co.,Ltd."),
 457                 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"),
 458                 },
 459         },
 460         {
 461         .callback = init_nvs_nosave,
 462         .ident = "Sony Vaio VGN-FW21E",
 463         .matches = {
 464                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 465                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW21E"),
 466                 },
 467         },
 468         {
 469         .callback = init_nvs_nosave,
 470         .ident = "Sony Vaio VPCEB17FX",
 471         .matches = {
 472                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 473                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB17FX"),
 474                 },
 475         },
 476         {
 477         .callback = init_nvs_nosave,
 478         .ident = "Sony Vaio VGN-SR11M",
 479         .matches = {
 480                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 481                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR11M"),
 482                 },
 483         },
 484         {
 485         .callback = init_nvs_nosave,
 486         .ident = "Everex StepNote Series",
 487         .matches = {
 488                 DMI_MATCH(DMI_SYS_VENDOR, "Everex Systems, Inc."),
 489                 DMI_MATCH(DMI_PRODUCT_NAME, "Everex StepNote Series"),
 490                 },
 491         },
 492         {
 493         .callback = init_nvs_nosave,
 494         .ident = "Sony Vaio VPCEB1Z1E",
 495         .matches = {
 496                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 497                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCEB1Z1E"),
 498                 },
 499         },
 500         {
 501         .callback = init_nvs_nosave,
 502         .ident = "Sony Vaio VGN-NW130D",
 503         .matches = {
 504                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 505                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-NW130D"),
 506                 },
 507         },
 508         {
 509         .callback = init_nvs_nosave,
 510         .ident = "Sony Vaio VPCCW29FX",
 511         .matches = {
 512                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 513                 DMI_MATCH(DMI_PRODUCT_NAME, "VPCCW29FX"),
 514                 },
 515         },
 516         {
 517         .callback = init_nvs_nosave,
 518         .ident = "Averatec AV1020-ED2",
 519         .matches = {
 520                 DMI_MATCH(DMI_SYS_VENDOR, "AVERATEC"),
 521                 DMI_MATCH(DMI_PRODUCT_NAME, "1000 Series"),
 522                 },
 523         },
 524         {
 525         .callback = init_old_suspend_ordering,
 526         .ident = "Asus A8N-SLI DELUXE",
 527         .matches = {
 528                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 529                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI DELUXE"),
 530                 },
 531         },
 532         {
 533         .callback = init_old_suspend_ordering,
 534         .ident = "Asus A8N-SLI Premium",
 535         .matches = {
 536                 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer INC."),
 537                 DMI_MATCH(DMI_BOARD_NAME, "A8N-SLI Premium"),
 538                 },
 539         },
 540         {
 541         .callback = init_nvs_nosave,
 542         .ident = "Sony Vaio VGN-SR26GN_P",
 543         .matches = {
 544                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 545                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-SR26GN_P"),
 546                 },
 547         },
 548         {
 549         .callback = init_nvs_nosave,
 550         .ident = "Sony Vaio VGN-FW520F",
 551         .matches = {
 552                 DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
 553                 DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FW520F"),
 554                 },
 555         },
 556         {
 557         .callback = init_nvs_nosave,
 558         .ident = "Asus K54C",
 559         .matches = {
 560                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 561                 DMI_MATCH(DMI_PRODUCT_NAME, "K54C"),
 562                 },
 563         },
 564         {
 565         .callback = init_nvs_nosave,
 566         .ident = "Asus K54HR",
 567         .matches = {
 568                 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
 569                 DMI_MATCH(DMI_PRODUCT_NAME, "K54HR"),
 570                 },
 571         },
 572         {},
 573 };
 574 #endif /* CONFIG_SUSPEND */
 575
 576 #ifdef CONFIG_HIBERNATION
 577 static unsigned long s4_hardware_signature;
 578 static struct acpi_table_facs *facs;
 579 static bool nosigcheck;
 580
 581 void __init acpi_no_s4_hw_signature(void)
 582 {
 583         nosigcheck = true;
 584 }
 585
 586 static int acpi_hibernation_begin(void)
 587 {
 588         int error;
 589
 590         error = nvs_nosave ? 0 : suspend_nvs_alloc();
 591         if (!error) {
 592                 acpi_target_sleep_state = ACPI_STATE_S4;
 593                 acpi_sleep_tts_switch(acpi_target_sleep_state);
 594         }
 595
 596         return error;
 597 }
 598
 599 static int acpi_hibernation_enter(void)
 600 {
 601         acpi_status status = AE_OK;
 602
 603         ACPI_FLUSH_CPU_CACHE();
 604
 605         /* This shouldn't return.  If it returns, we have a problem */
 606         status = acpi_enter_sleep_state(ACPI_STATE_S4, wake_sleep_flags);
 607         /* Reprogram control registers and execute _BFS */
 608         acpi_leave_sleep_state_prep(ACPI_STATE_S4, wake_sleep_flags);
 609
 610         return ACPI_SUCCESS(status) ? 0 : -EFAULT;
 611 }
 612
 613 static void acpi_hibernation_leave(void)
 614 {
 615         /*
 616          * If ACPI is not enabled by the BIOS and the boot kernel, we need to
 617          * enable it here.
 618          */
 619         acpi_enable();
 620         /* Reprogram control registers and execute _BFS */
 621         acpi_leave_sleep_state_prep(ACPI_STATE_S4, wake_sleep_flags);
 622         /* Check the hardware signature */
 623         if (facs && s4_hardware_signature != facs->hardware_signature) {
 624                 printk(KERN_EMERG "ACPI: Hardware changed while hibernated, "
 625                         "cannot resume!\n");
 626                 panic("ACPI S4 hardware signature mismatch");
 627         }
 628         /* Restore the NVS memory area */
 629         suspend_nvs_restore();
 630         /* Allow EC transactions to happen. */
 631         acpi_ec_unblock_transactions_early();
 632 }
 633
 634 static void acpi_pm_thaw(void)
 635 {
 636         acpi_ec_unblock_transactions();
 637         acpi_enable_all_runtime_gpes();
 638 }
 639
 640 static const struct platform_hibernation_ops acpi_hibernation_ops = {
 641         .begin = acpi_hibernation_begin,
 642         .end = acpi_pm_end,
 643         .pre_snapshot = acpi_pm_prepare,
 644         .finish = acpi_pm_finish,
 645         .prepare = acpi_pm_prepare,
 646         .enter = acpi_hibernation_enter,
 647         .leave = acpi_hibernation_leave,
 648         .pre_restore = acpi_pm_freeze,
 649         .restore_cleanup = acpi_pm_thaw,
 650 };
 651
 652 /**
 653  *      acpi_hibernation_begin_old - Set the target system sleep state to
 654  *              ACPI_STATE_S4 and execute the _PTS control method.  This
 655  *              function is used if the pre-ACPI 2.0 suspend ordering has been
 656  *              requested.
 657  */
 658 static int acpi_hibernation_begin_old(void)
 659 {
 660         int error;
 661         /*
 662          * The _TTS object should always be evaluated before the _PTS object.
 663          * When the old_suspended_ordering is true, the _PTS object is
 664          * evaluated in the acpi_sleep_prepare.
 665          */
 666         acpi_sleep_tts_switch(ACPI_STATE_S4);
 667
 668         error = acpi_sleep_prepare(ACPI_STATE_S4);
 669
 670         if (!error) {
 671                 if (!nvs_nosave)
 672                         error = suspend_nvs_alloc();
 673                 if (!error)
 674                         acpi_target_sleep_state = ACPI_STATE_S4;
 675         }
 676         return error;
 677 }
 678
 679 /*
 680  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
 681  * been requested.
 682  */
 683 static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
 684         .begin = acpi_hibernation_begin_old,
 685         .end = acpi_pm_end,
 686         .pre_snapshot = acpi_pm_pre_suspend,
 687         .prepare = acpi_pm_freeze,
 688         .finish = acpi_pm_finish,
 689         .enter = acpi_hibernation_enter,
 690         .leave = acpi_hibernation_leave,
 691         .pre_restore = acpi_pm_freeze,
 692         .restore_cleanup = acpi_pm_thaw,
 693         .recover = acpi_pm_finish,
 694 };
 695 #endif /* CONFIG_HIBERNATION */
 696
 697 int acpi_suspend(u32 acpi_state)
 698 {
 699         suspend_state_t states[] = {
 700                 [1] = PM_SUSPEND_STANDBY,
 701                 [3] = PM_SUSPEND_MEM,
 702                 [5] = PM_SUSPEND_MAX
 703         };
 704
 705         if (acpi_state < 6 && states[acpi_state])
 706                 return pm_suspend(states[acpi_state]);
 707         if (acpi_state == 4)
 708                 return hibernate();
 709         return -EINVAL;
 710 }
 711
 712 #ifdef CONFIG_PM
 713 /**
 714  *      acpi_pm_device_sleep_state - return preferred power state of ACPI device
 715  *              in the system sleep state given by %acpi_target_sleep_state
 716  *      @dev: device to examine; its driver model wakeup flags control
 717  *              whether it should be able to wake up the system
 718  *      @d_min_p: used to store the upper limit of allowed states range
 719  *      Return value: preferred power state of the device on success, -ENODEV on
 720  *              failure (ie. if there's no 'struct acpi_device' for @dev)
 721  *
 722  *      Find the lowest power (highest number) ACPI device power state that
 723  *      device @dev can be in while the system is in the sleep state represented
 724  *      by %acpi_target_sleep_state.  If @wake is nonzero, the device should be
 725  *      able to wake up the system from this sleep state.  If @d_min_p is set,
 726  *      the highest power (lowest number) device power state of @dev allowed
 727  *      in this system sleep state is stored at the location pointed to by it.
 728  *
 729  *      The caller must ensure that @dev is valid before using this function.
 730  *      The caller is also responsible for figuring out if the device is
 731  *      supposed to be able to wake up the system and passing this information
 732  *      via @wake.
 733  */
 734
 735 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p)
 736 {
 737         acpi_handle handle = DEVICE_ACPI_HANDLE(dev);
 738         struct acpi_device *adev;
 739         char acpi_method[] = "_SxD";
 740         unsigned long long d_min, d_max;
 741
 742         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
 743                 printk(KERN_DEBUG "ACPI handle has no context!\n");
 744                 return -ENODEV;
 745         }
 746
 747         acpi_method[2] = '0' + acpi_target_sleep_state;
 748         /*
 749          * If the sleep state is S0, we will return D3, but if the device has
 750          * _S0W, we will use the value from _S0W
 751          */
 752         d_min = ACPI_STATE_D0;
 753         d_max = ACPI_STATE_D3;
 754
 755         /*
 756          * If present, _SxD methods return the minimum D-state (highest power
 757          * state) we can use for the corresponding S-states.  Otherwise, the
 758          * minimum D-state is D0 (ACPI 3.x).
 759          *
 760          * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer
 761          * provided -- that's our fault recovery, we ignore retval.
 762          */
 763         if (acpi_target_sleep_state > ACPI_STATE_S0)
 764                 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min);
 765
 766         /*
 767          * If _PRW says we can wake up the system from the target sleep state,
 768          * the D-state returned by _SxD is sufficient for that (we assume a
 769          * wakeup-aware driver if wake is set).  Still, if _SxW exists
 770          * (ACPI 3.x), it should return the maximum (lowest power) D-state that
 771          * can wake the system.  _S0W may be valid, too.
 772          */
 773         if (acpi_target_sleep_state == ACPI_STATE_S0 ||
 774             (device_may_wakeup(dev) && adev->wakeup.flags.valid &&
 775              adev->wakeup.sleep_state >= acpi_target_sleep_state)) {
 776                 acpi_status status;
 777
 778                 acpi_method[3] = 'W';
 779                 status = acpi_evaluate_integer(handle, acpi_method, NULL,
 780                                                 &d_max);
 781                 if (ACPI_FAILURE(status)) {
 782                         if (acpi_target_sleep_state != ACPI_STATE_S0 ||
 783                             status != AE_NOT_FOUND)
 784                                 d_max = d_min;
 785                 } else if (d_max < d_min) {
 786                         /* Warn the user of the broken DSDT */
 787                         printk(KERN_WARNING "ACPI: Wrong value from %s\n",
 788                                 acpi_method);
 789                         /* Sanitize it */
 790                         d_min = d_max;
 791                 }
 792         }
 793
 794         if (d_min_p)
 795                 *d_min_p = d_min;
 796         return d_max;
 797 }
 798 #endif /* CONFIG_PM */
 799
 800 #ifdef CONFIG_PM_SLEEP
 801 /**
 802  * acpi_pm_device_run_wake - Enable/disable wake-up for given device.
 803  * @phys_dev: Device to enable/disable the platform to wake-up the system for.
 804  * @enable: Whether enable or disable the wake-up functionality.
 805  *
 806  * Find the ACPI device object corresponding to @pci_dev and try to
 807  * enable/disable the GPE associated with it.
 808  */
 809 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable)
 810 {
 811         struct acpi_device *dev;
 812         acpi_handle handle;
 813
 814         if (!device_run_wake(phys_dev))
 815                 return -EINVAL;
 816
 817         handle = DEVICE_ACPI_HANDLE(phys_dev);
 818         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) {
 819                 dev_dbg(phys_dev, "ACPI handle has no context in %s!\n",
 820                         __func__);
 821                 return -ENODEV;
 822         }
 823
 824         if (enable) {
 825                 acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0);
 826                 acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
 827         } else {
 828                 acpi_disable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number);
 829                 acpi_disable_wakeup_device_power(dev);
 830         }
 831
 832         return 0;
 833 }
 834
 835 /**
 836  *      acpi_pm_device_sleep_wake - enable or disable the system wake-up
 837  *                                  capability of given device
 838  *      @dev: device to handle
 839  *      @enable: 'true' - enable, 'false' - disable the wake-up capability
 840  */
 841 int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
 842 {
 843         acpi_handle handle;
 844         struct acpi_device *adev;
 845         int error;
 846
 847         if (!device_can_wakeup(dev))
 848                 return -EINVAL;
 849
 850         handle = DEVICE_ACPI_HANDLE(dev);
 851         if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) {
 852                 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__);
 853                 return -ENODEV;
 854         }
 855
 856         error = enable ?
 857                 acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) :
 858                 acpi_disable_wakeup_device_power(adev);
 859         if (!error)
 860                 dev_info(dev, "wake-up capability %s by ACPI\n",
 861                                 enable ? "enabled" : "disabled");
 862
 863         return error;
 864 }
 865 #endif  /* CONFIG_PM_SLEEP */
 866
 867 static void acpi_power_off_prepare(void)
 868 {
 869         /* Prepare to power off the system */
 870         acpi_sleep_prepare(ACPI_STATE_S5);
 871         acpi_disable_all_gpes();
 872 }
 873
 874 static void acpi_power_off(void)
 875 {
 876         /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */
 877         printk(KERN_DEBUG "%s called\n", __func__);
 878         local_irq_disable();
 879         acpi_enter_sleep_state(ACPI_STATE_S5, wake_sleep_flags);
 880 }
 881
 882 /*
 883  * ACPI 2.0 created the optional _GTS and _BFS,
 884  * but industry adoption has been neither rapid nor broad.
 885  *
 886  * Linux gets into trouble when it executes poorly validated
 887  * paths through the BIOS, so disable _GTS and _BFS by default,
 888  * but do speak up and offer the option to enable them.
 889  */
 890 static void __init acpi_gts_bfs_check(void)
 891 {
 892         acpi_handle dummy;
 893
 894         if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__GTS, &dummy)))
 895         {
 896                 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n");
 897                 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, "
 898                         "please notify linux-acpi@vger.kernel.org\n");
 899         }
 900         if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__BFS, &dummy)))
 901         {
 902                 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n");
 903                 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, "
 904                         "please notify linux-acpi@vger.kernel.org\n");
 905         }
 906 }
 907
 908 int __init acpi_sleep_init(void)
 909 {
 910         acpi_status status;
 911         u8 type_a, type_b;
 912 #ifdef CONFIG_SUSPEND
 913         int i = 0;
 914
 915         dmi_check_system(acpisleep_dmi_table);
 916 #endif
 917
 918         if (acpi_disabled)
 919                 return 0;
 920
 921         sleep_states[ACPI_STATE_S0] = 1;
 922         printk(KERN_INFO PREFIX "(supports S0");
 923
 924 #ifdef CONFIG_SUSPEND
 925         for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) {
 926                 status = acpi_get_sleep_type_data(i, &type_a, &type_b);
 927                 if (ACPI_SUCCESS(status)) {
 928                         sleep_states[i] = 1;
 929                         printk(KERN_CONT " S%d", i);
 930                 }
 931         }
 932
 933         suspend_set_ops(old_suspend_ordering ?
 934                 &acpi_suspend_ops_old : &acpi_suspend_ops);
 935 #endif
 936
 937 #ifdef CONFIG_HIBERNATION
 938         status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b);
 939         if (ACPI_SUCCESS(status)) {
 940                 hibernation_set_ops(old_suspend_ordering ?
 941                         &acpi_hibernation_ops_old : &acpi_hibernation_ops);
 942                 sleep_states[ACPI_STATE_S4] = 1;
 943                 printk(KERN_CONT " S4");
 944                 if (!nosigcheck) {
 945                         acpi_get_table(ACPI_SIG_FACS, 1,
 946                                 (struct acpi_table_header **)&facs);
 947                         if (facs)
 948                                 s4_hardware_signature =
 949                                         facs->hardware_signature;
 950                 }
 951         }
 952 #endif
 953         status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b);
 954         if (ACPI_SUCCESS(status)) {
 955                 sleep_states[ACPI_STATE_S5] = 1;
 956                 printk(KERN_CONT " S5");
 957                 pm_power_off_prepare = acpi_power_off_prepare;
 958                 pm_power_off = acpi_power_off;
 959         }
 960         printk(KERN_CONT ")\n");
 961         /*
 962          * Register the tts_notifier to reboot notifier list so that the _TTS
 963          * object can also be evaluated when the system enters S5.
 964          */
 965         register_reboot_notifier(&tts_notifier);
 966         acpi_gts_bfs_check();
 967         return 0;
 968 }