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 *)>s) { 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, >s, 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(); 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 * @d_max_in: specify the lowest allowed states 720 * Return value: preferred power state of the device on success, -ENODEV 721 * (ie. if there's no 'struct acpi_device' for @dev) or -EINVAL on failure 722 * 723 * Find the lowest power (highest number) ACPI device power state that 724 * device @dev can be in while the system is in the sleep state represented 725 * by %acpi_target_sleep_state. If @wake is nonzero, the device should be 726 * able to wake up the system from this sleep state. If @d_min_p is set, 727 * the highest power (lowest number) device power state of @dev allowed 728 * in this system sleep state is stored at the location pointed to by it. 729 * 730 * The caller must ensure that @dev is valid before using this function. 731 * The caller is also responsible for figuring out if the device is 732 * supposed to be able to wake up the system and passing this information 733 * via @wake. 734 */ 735 736 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p, int d_max_in) 737 { 738 acpi_handle handle = DEVICE_ACPI_HANDLE(dev); 739 struct acpi_device *adev; 740 char acpi_method[] = "_SxD"; 741 unsigned long long d_min, d_max; 742 743 if (d_max_in < ACPI_STATE_D0 || d_max_in > ACPI_STATE_D3) 744 return -EINVAL; 745 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 746 printk(KERN_DEBUG "ACPI handle has no context!\n"); 747 return -ENODEV; 748 } 749 750 acpi_method[2] = '0' + acpi_target_sleep_state; 751 /* 752 * If the sleep state is S0, the lowest limit from ACPI is D3, 753 * but if the device has _S0W, we will use the value from _S0W 754 * as the lowest limit from ACPI. Finally, we will constrain 755 * the lowest limit with the specified one. 756 */ 757 d_min = ACPI_STATE_D0; 758 d_max = ACPI_STATE_D3; 759 760 /* 761 * If present, _SxD methods return the minimum D-state (highest power 762 * state) we can use for the corresponding S-states. Otherwise, the 763 * minimum D-state is D0 (ACPI 3.x). 764 * 765 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer 766 * provided -- that's our fault recovery, we ignore retval. 767 */ 768 if (acpi_target_sleep_state > ACPI_STATE_S0) 769 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min); 770 771 /* 772 * If _PRW says we can wake up the system from the target sleep state, 773 * the D-state returned by _SxD is sufficient for that (we assume a 774 * wakeup-aware driver if wake is set). Still, if _SxW exists 775 * (ACPI 3.x), it should return the maximum (lowest power) D-state that 776 * can wake the system. _S0W may be valid, too. 777 */ 778 if (acpi_target_sleep_state == ACPI_STATE_S0 || 779 (device_may_wakeup(dev) && adev->wakeup.flags.valid && 780 adev->wakeup.sleep_state >= acpi_target_sleep_state)) { 781 acpi_status status; 782 783 acpi_method[3] = 'W'; 784 status = acpi_evaluate_integer(handle, acpi_method, NULL, 785 &d_max); 786 if (ACPI_FAILURE(status)) { 787 if (acpi_target_sleep_state != ACPI_STATE_S0 || 788 status != AE_NOT_FOUND) 789 d_max = d_min; 790 } else if (d_max < d_min) { 791 /* Warn the user of the broken DSDT */ 792 printk(KERN_WARNING "ACPI: Wrong value from %s\n", 793 acpi_method); 794 /* Sanitize it */ 795 d_min = d_max; 796 } 797 } 798 799 if (d_max_in < d_min) 800 return -EINVAL; 801 if (d_min_p) 802 *d_min_p = d_min; 803 /* constrain d_max with specified lowest limit (max number) */ 804 if (d_max > d_max_in) { 805 for (d_max = d_max_in; d_max > d_min; d_max--) { 806 if (adev->power.states[d_max].flags.valid) 807 break; 808 } 809 } 810 return d_max; 811 } 812 EXPORT_SYMBOL(acpi_pm_device_sleep_state); 813 #endif /* CONFIG_PM */ 814 815 #ifdef CONFIG_PM_SLEEP 816 /** 817 * acpi_pm_device_run_wake - Enable/disable wake-up for given device. 818 * @phys_dev: Device to enable/disable the platform to wake-up the system for. 819 * @enable: Whether enable or disable the wake-up functionality. 820 * 821 * Find the ACPI device object corresponding to @pci_dev and try to 822 * enable/disable the GPE associated with it. 823 */ 824 int acpi_pm_device_run_wake(struct device *phys_dev, bool enable) 825 { 826 struct acpi_device *dev; 827 acpi_handle handle; 828 829 if (!device_run_wake(phys_dev)) 830 return -EINVAL; 831 832 handle = DEVICE_ACPI_HANDLE(phys_dev); 833 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &dev))) { 834 dev_dbg(phys_dev, "ACPI handle has no context in %s!\n", 835 __func__); 836 return -ENODEV; 837 } 838 839 if (enable) { 840 acpi_enable_wakeup_device_power(dev, ACPI_STATE_S0); 841 acpi_enable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number); 842 } else { 843 acpi_disable_gpe(dev->wakeup.gpe_device, dev->wakeup.gpe_number); 844 acpi_disable_wakeup_device_power(dev); 845 } 846 847 return 0; 848 } 849 EXPORT_SYMBOL(acpi_pm_device_run_wake); 850 851 /** 852 * acpi_pm_device_sleep_wake - enable or disable the system wake-up 853 * capability of given device 854 * @dev: device to handle 855 * @enable: 'true' - enable, 'false' - disable the wake-up capability 856 */ 857 int acpi_pm_device_sleep_wake(struct device *dev, bool enable) 858 { 859 acpi_handle handle; 860 struct acpi_device *adev; 861 int error; 862 863 if (!device_can_wakeup(dev)) 864 return -EINVAL; 865 866 handle = DEVICE_ACPI_HANDLE(dev); 867 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 868 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__); 869 return -ENODEV; 870 } 871 872 error = enable ? 873 acpi_enable_wakeup_device_power(adev, acpi_target_sleep_state) : 874 acpi_disable_wakeup_device_power(adev); 875 if (!error) 876 dev_info(dev, "wake-up capability %s by ACPI\n", 877 enable ? "enabled" : "disabled"); 878 879 return error; 880 } 881 #endif /* CONFIG_PM_SLEEP */ 882 883 static void acpi_power_off_prepare(void) 884 { 885 /* Prepare to power off the system */ 886 acpi_sleep_prepare(ACPI_STATE_S5); 887 acpi_disable_all_gpes(); 888 } 889 890 static void acpi_power_off(void) 891 { 892 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */ 893 printk(KERN_DEBUG "%s called\n", __func__); 894 local_irq_disable(); 895 acpi_enter_sleep_state(ACPI_STATE_S5, wake_sleep_flags); 896 } 897 898 /* 899 * ACPI 2.0 created the optional _GTS and _BFS, 900 * but industry adoption has been neither rapid nor broad. 901 * 902 * Linux gets into trouble when it executes poorly validated 903 * paths through the BIOS, so disable _GTS and _BFS by default, 904 * but do speak up and offer the option to enable them. 905 */ 906 static void __init acpi_gts_bfs_check(void) 907 { 908 acpi_handle dummy; 909 910 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__GTS, &dummy))) 911 { 912 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n"); 913 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, " 914 "please notify linux-acpi@vger.kernel.org\n"); 915 } 916 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_PATHNAME__BFS, &dummy))) 917 { 918 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n"); 919 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, " 920 "please notify linux-acpi@vger.kernel.org\n"); 921 } 922 } 923 924 int __init acpi_sleep_init(void) 925 { 926 acpi_status status; 927 u8 type_a, type_b; 928 #ifdef CONFIG_SUSPEND 929 int i = 0; 930 931 dmi_check_system(acpisleep_dmi_table); 932 #endif 933 934 if (acpi_disabled) 935 return 0; 936 937 sleep_states[ACPI_STATE_S0] = 1; 938 printk(KERN_INFO PREFIX "(supports S0"); 939 940 #ifdef CONFIG_SUSPEND 941 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) { 942 status = acpi_get_sleep_type_data(i, &type_a, &type_b); 943 if (ACPI_SUCCESS(status)) { 944 sleep_states[i] = 1; 945 printk(KERN_CONT " S%d", i); 946 } 947 } 948 949 suspend_set_ops(old_suspend_ordering ? 950 &acpi_suspend_ops_old : &acpi_suspend_ops); 951 #endif 952 953 #ifdef CONFIG_HIBERNATION 954 status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b); 955 if (ACPI_SUCCESS(status)) { 956 hibernation_set_ops(old_suspend_ordering ? 957 &acpi_hibernation_ops_old : &acpi_hibernation_ops); 958 sleep_states[ACPI_STATE_S4] = 1; 959 printk(KERN_CONT " S4"); 960 if (!nosigcheck) { 961 acpi_get_table(ACPI_SIG_FACS, 1, 962 (struct acpi_table_header **)&facs); 963 if (facs) 964 s4_hardware_signature = 965 facs->hardware_signature; 966 } 967 } 968 #endif 969 status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b); 970 if (ACPI_SUCCESS(status)) { 971 sleep_states[ACPI_STATE_S5] = 1; 972 printk(KERN_CONT " S5"); 973 pm_power_off_prepare = acpi_power_off_prepare; 974 pm_power_off = acpi_power_off; 975 } 976 printk(KERN_CONT ")\n"); 977 /* 978 * Register the tts_notifier to reboot notifier list so that the _TTS 979 * object can also be evaluated when the system enters S5. 980 */ 981 register_reboot_notifier(&tts_notifier); 982 acpi_gts_bfs_check(); 983 return 0; 984 } 985