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 20 #include <asm/io.h> 21 22 #include <acpi/acpi_bus.h> 23 #include <acpi/acpi_drivers.h> 24 25 #include "internal.h" 26 #include "sleep.h" 27 28 u8 sleep_states[ACPI_S_STATE_COUNT]; 29 30 static void acpi_sleep_tts_switch(u32 acpi_state) 31 { 32 union acpi_object in_arg = { ACPI_TYPE_INTEGER }; 33 struct acpi_object_list arg_list = { 1, &in_arg }; 34 acpi_status status = AE_OK; 35 36 in_arg.integer.value = acpi_state; 37 status = acpi_evaluate_object(NULL, "\\_TTS", &arg_list, NULL); 38 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 39 /* 40 * OS can't evaluate the _TTS object correctly. Some warning 41 * message will be printed. But it won't break anything. 42 */ 43 printk(KERN_NOTICE "Failure in evaluating _TTS object\n"); 44 } 45 } 46 47 static int tts_notify_reboot(struct notifier_block *this, 48 unsigned long code, void *x) 49 { 50 acpi_sleep_tts_switch(ACPI_STATE_S5); 51 return NOTIFY_DONE; 52 } 53 54 static struct notifier_block tts_notifier = { 55 .notifier_call = tts_notify_reboot, 56 .next = NULL, 57 .priority = 0, 58 }; 59 60 static int acpi_sleep_prepare(u32 acpi_state) 61 { 62 #ifdef CONFIG_ACPI_SLEEP 63 /* do we have a wakeup address for S2 and S3? */ 64 if (acpi_state == ACPI_STATE_S3) { 65 if (!acpi_wakeup_address) { 66 return -EFAULT; 67 } 68 acpi_set_firmware_waking_vector( 69 (acpi_physical_address)acpi_wakeup_address); 70 71 } 72 ACPI_FLUSH_CPU_CACHE(); 73 acpi_enable_wakeup_device_prep(acpi_state); 74 #endif 75 printk(KERN_INFO PREFIX "Preparing to enter system sleep state S%d\n", 76 acpi_state); 77 acpi_enter_sleep_state_prep(acpi_state); 78 return 0; 79 } 80 81 #ifdef CONFIG_ACPI_SLEEP 82 static u32 acpi_target_sleep_state = ACPI_STATE_S0; 83 84 /* 85 * ACPI 1.0 wants us to execute _PTS before suspending devices, so we allow the 86 * user to request that behavior by using the 'acpi_old_suspend_ordering' 87 * kernel command line option that causes the following variable to be set. 88 */ 89 static bool old_suspend_ordering; 90 91 void __init acpi_old_suspend_ordering(void) 92 { 93 old_suspend_ordering = true; 94 } 95 96 /** 97 * acpi_pm_disable_gpes - Disable the GPEs. 98 */ 99 static int acpi_pm_disable_gpes(void) 100 { 101 acpi_disable_all_gpes(); 102 return 0; 103 } 104 105 /** 106 * __acpi_pm_prepare - Prepare the platform to enter the target state. 107 * 108 * If necessary, set the firmware waking vector and do arch-specific 109 * nastiness to get the wakeup code to the waking vector. 110 */ 111 static int __acpi_pm_prepare(void) 112 { 113 int error = acpi_sleep_prepare(acpi_target_sleep_state); 114 115 if (error) 116 acpi_target_sleep_state = ACPI_STATE_S0; 117 return error; 118 } 119 120 /** 121 * acpi_pm_prepare - Prepare the platform to enter the target sleep 122 * state and disable the GPEs. 123 */ 124 static int acpi_pm_prepare(void) 125 { 126 int error = __acpi_pm_prepare(); 127 128 if (!error) 129 acpi_disable_all_gpes(); 130 return error; 131 } 132 133 /** 134 * acpi_pm_finish - Instruct the platform to leave a sleep state. 135 * 136 * This is called after we wake back up (or if entering the sleep state 137 * failed). 138 */ 139 static void acpi_pm_finish(void) 140 { 141 u32 acpi_state = acpi_target_sleep_state; 142 143 if (acpi_state == ACPI_STATE_S0) 144 return; 145 146 printk(KERN_INFO PREFIX "Waking up from system sleep state S%d\n", 147 acpi_state); 148 acpi_disable_wakeup_device(acpi_state); 149 acpi_leave_sleep_state(acpi_state); 150 151 /* reset firmware waking vector */ 152 acpi_set_firmware_waking_vector((acpi_physical_address) 0); 153 154 acpi_target_sleep_state = ACPI_STATE_S0; 155 } 156 157 /** 158 * acpi_pm_end - Finish up suspend sequence. 159 */ 160 static void acpi_pm_end(void) 161 { 162 /* 163 * This is necessary in case acpi_pm_finish() is not called during a 164 * failing transition to a sleep state. 165 */ 166 acpi_target_sleep_state = ACPI_STATE_S0; 167 acpi_sleep_tts_switch(acpi_target_sleep_state); 168 } 169 #else /* !CONFIG_ACPI_SLEEP */ 170 #define acpi_target_sleep_state ACPI_STATE_S0 171 #endif /* CONFIG_ACPI_SLEEP */ 172 173 #ifdef CONFIG_SUSPEND 174 extern void do_suspend_lowlevel(void); 175 176 static u32 acpi_suspend_states[] = { 177 [PM_SUSPEND_ON] = ACPI_STATE_S0, 178 [PM_SUSPEND_STANDBY] = ACPI_STATE_S1, 179 [PM_SUSPEND_MEM] = ACPI_STATE_S3, 180 [PM_SUSPEND_MAX] = ACPI_STATE_S5 181 }; 182 183 /** 184 * acpi_suspend_begin - Set the target system sleep state to the state 185 * associated with given @pm_state, if supported. 186 */ 187 static int acpi_suspend_begin(suspend_state_t pm_state) 188 { 189 u32 acpi_state = acpi_suspend_states[pm_state]; 190 int error = 0; 191 192 if (sleep_states[acpi_state]) { 193 acpi_target_sleep_state = acpi_state; 194 acpi_sleep_tts_switch(acpi_target_sleep_state); 195 } else { 196 printk(KERN_ERR "ACPI does not support this state: %d\n", 197 pm_state); 198 error = -ENOSYS; 199 } 200 return error; 201 } 202 203 /** 204 * acpi_suspend_enter - Actually enter a sleep state. 205 * @pm_state: ignored 206 * 207 * Flush caches and go to sleep. For STR we have to call arch-specific 208 * assembly, which in turn call acpi_enter_sleep_state(). 209 * It's unfortunate, but it works. Please fix if you're feeling frisky. 210 */ 211 static int acpi_suspend_enter(suspend_state_t pm_state) 212 { 213 acpi_status status = AE_OK; 214 unsigned long flags = 0; 215 u32 acpi_state = acpi_target_sleep_state; 216 217 ACPI_FLUSH_CPU_CACHE(); 218 219 /* Do arch specific saving of state. */ 220 if (acpi_state == ACPI_STATE_S3) { 221 int error = acpi_save_state_mem(); 222 223 if (error) 224 return error; 225 } 226 227 local_irq_save(flags); 228 acpi_enable_wakeup_device(acpi_state); 229 switch (acpi_state) { 230 case ACPI_STATE_S1: 231 barrier(); 232 status = acpi_enter_sleep_state(acpi_state); 233 break; 234 235 case ACPI_STATE_S3: 236 do_suspend_lowlevel(); 237 break; 238 } 239 240 /* This violates the spec but is required for bug compatibility. */ 241 acpi_write_bit_register(ACPI_BITREG_SCI_ENABLE, 1); 242 243 /* Reprogram control registers and execute _BFS */ 244 acpi_leave_sleep_state_prep(acpi_state); 245 246 /* ACPI 3.0 specs (P62) says that it's the responsibility 247 * of the OSPM to clear the status bit [ implying that the 248 * POWER_BUTTON event should not reach userspace ] 249 */ 250 if (ACPI_SUCCESS(status) && (acpi_state == ACPI_STATE_S3)) 251 acpi_clear_event(ACPI_EVENT_POWER_BUTTON); 252 253 /* 254 * Disable and clear GPE status before interrupt is enabled. Some GPEs 255 * (like wakeup GPE) haven't handler, this can avoid such GPE misfire. 256 * acpi_leave_sleep_state will reenable specific GPEs later 257 */ 258 acpi_disable_all_gpes(); 259 260 local_irq_restore(flags); 261 printk(KERN_DEBUG "Back to C!\n"); 262 263 /* restore processor state */ 264 if (acpi_state == ACPI_STATE_S3) 265 acpi_restore_state_mem(); 266 267 return ACPI_SUCCESS(status) ? 0 : -EFAULT; 268 } 269 270 static int acpi_suspend_state_valid(suspend_state_t pm_state) 271 { 272 u32 acpi_state; 273 274 switch (pm_state) { 275 case PM_SUSPEND_ON: 276 case PM_SUSPEND_STANDBY: 277 case PM_SUSPEND_MEM: 278 acpi_state = acpi_suspend_states[pm_state]; 279 280 return sleep_states[acpi_state]; 281 default: 282 return 0; 283 } 284 } 285 286 static struct platform_suspend_ops acpi_suspend_ops = { 287 .valid = acpi_suspend_state_valid, 288 .begin = acpi_suspend_begin, 289 .prepare_late = acpi_pm_prepare, 290 .enter = acpi_suspend_enter, 291 .wake = acpi_pm_finish, 292 .end = acpi_pm_end, 293 }; 294 295 /** 296 * acpi_suspend_begin_old - Set the target system sleep state to the 297 * state associated with given @pm_state, if supported, and 298 * execute the _PTS control method. This function is used if the 299 * pre-ACPI 2.0 suspend ordering has been requested. 300 */ 301 static int acpi_suspend_begin_old(suspend_state_t pm_state) 302 { 303 int error = acpi_suspend_begin(pm_state); 304 305 if (!error) 306 error = __acpi_pm_prepare(); 307 return error; 308 } 309 310 /* 311 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has 312 * been requested. 313 */ 314 static struct platform_suspend_ops acpi_suspend_ops_old = { 315 .valid = acpi_suspend_state_valid, 316 .begin = acpi_suspend_begin_old, 317 .prepare_late = acpi_pm_disable_gpes, 318 .enter = acpi_suspend_enter, 319 .wake = acpi_pm_finish, 320 .end = acpi_pm_end, 321 .recover = acpi_pm_finish, 322 }; 323 324 static int __init init_old_suspend_ordering(const struct dmi_system_id *d) 325 { 326 old_suspend_ordering = true; 327 return 0; 328 } 329 330 static struct dmi_system_id __initdata acpisleep_dmi_table[] = { 331 { 332 .callback = init_old_suspend_ordering, 333 .ident = "Abit KN9 (nForce4 variant)", 334 .matches = { 335 DMI_MATCH(DMI_BOARD_VENDOR, "http://www.abit.com.tw/"), 336 DMI_MATCH(DMI_BOARD_NAME, "KN9 Series(NF-CK804)"), 337 }, 338 }, 339 { 340 .callback = init_old_suspend_ordering, 341 .ident = "HP xw4600 Workstation", 342 .matches = { 343 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), 344 DMI_MATCH(DMI_PRODUCT_NAME, "HP xw4600 Workstation"), 345 }, 346 }, 347 { 348 .callback = init_old_suspend_ordering, 349 .ident = "Asus Pundit P1-AH2 (M2N8L motherboard)", 350 .matches = { 351 DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTek Computer INC."), 352 DMI_MATCH(DMI_BOARD_NAME, "M2N8L"), 353 }, 354 }, 355 { 356 .callback = init_old_suspend_ordering, 357 .ident = "Panasonic CF51-2L", 358 .matches = { 359 DMI_MATCH(DMI_BOARD_VENDOR, 360 "Matsushita Electric Industrial Co.,Ltd."), 361 DMI_MATCH(DMI_BOARD_NAME, "CF51-2L"), 362 }, 363 }, 364 {}, 365 }; 366 #endif /* CONFIG_SUSPEND */ 367 368 #ifdef CONFIG_HIBERNATION 369 /* 370 * The ACPI specification wants us to save NVS memory regions during hibernation 371 * and to restore them during the subsequent resume. However, it is not certain 372 * if this mechanism is going to work on all machines, so we allow the user to 373 * disable this mechanism using the 'acpi_sleep=s4_nonvs' kernel command line 374 * option. 375 */ 376 static bool s4_no_nvs; 377 378 void __init acpi_s4_no_nvs(void) 379 { 380 s4_no_nvs = true; 381 } 382 383 static unsigned long s4_hardware_signature; 384 static struct acpi_table_facs *facs; 385 static bool nosigcheck; 386 387 void __init acpi_no_s4_hw_signature(void) 388 { 389 nosigcheck = true; 390 } 391 392 static int acpi_hibernation_begin(void) 393 { 394 int error; 395 396 error = s4_no_nvs ? 0 : hibernate_nvs_alloc(); 397 if (!error) { 398 acpi_target_sleep_state = ACPI_STATE_S4; 399 acpi_sleep_tts_switch(acpi_target_sleep_state); 400 } 401 402 return error; 403 } 404 405 static int acpi_hibernation_pre_snapshot(void) 406 { 407 int error = acpi_pm_prepare(); 408 409 if (!error) 410 hibernate_nvs_save(); 411 412 return error; 413 } 414 415 static int acpi_hibernation_enter(void) 416 { 417 acpi_status status = AE_OK; 418 unsigned long flags = 0; 419 420 ACPI_FLUSH_CPU_CACHE(); 421 422 local_irq_save(flags); 423 acpi_enable_wakeup_device(ACPI_STATE_S4); 424 /* This shouldn't return. If it returns, we have a problem */ 425 status = acpi_enter_sleep_state(ACPI_STATE_S4); 426 /* Reprogram control registers and execute _BFS */ 427 acpi_leave_sleep_state_prep(ACPI_STATE_S4); 428 local_irq_restore(flags); 429 430 return ACPI_SUCCESS(status) ? 0 : -EFAULT; 431 } 432 433 static void acpi_hibernation_finish(void) 434 { 435 hibernate_nvs_free(); 436 acpi_pm_finish(); 437 } 438 439 static void acpi_hibernation_leave(void) 440 { 441 /* 442 * If ACPI is not enabled by the BIOS and the boot kernel, we need to 443 * enable it here. 444 */ 445 acpi_enable(); 446 /* Reprogram control registers and execute _BFS */ 447 acpi_leave_sleep_state_prep(ACPI_STATE_S4); 448 /* Check the hardware signature */ 449 if (facs && s4_hardware_signature != facs->hardware_signature) { 450 printk(KERN_EMERG "ACPI: Hardware changed while hibernated, " 451 "cannot resume!\n"); 452 panic("ACPI S4 hardware signature mismatch"); 453 } 454 /* Restore the NVS memory area */ 455 hibernate_nvs_restore(); 456 } 457 458 static int acpi_pm_pre_restore(void) 459 { 460 acpi_disable_all_gpes(); 461 acpi_os_wait_events_complete(NULL); 462 acpi_ec_suspend_transactions(); 463 return 0; 464 } 465 466 static void acpi_pm_restore_cleanup(void) 467 { 468 acpi_ec_resume_transactions(); 469 acpi_enable_all_runtime_gpes(); 470 } 471 472 static struct platform_hibernation_ops acpi_hibernation_ops = { 473 .begin = acpi_hibernation_begin, 474 .end = acpi_pm_end, 475 .pre_snapshot = acpi_hibernation_pre_snapshot, 476 .finish = acpi_hibernation_finish, 477 .prepare = acpi_pm_prepare, 478 .enter = acpi_hibernation_enter, 479 .leave = acpi_hibernation_leave, 480 .pre_restore = acpi_pm_pre_restore, 481 .restore_cleanup = acpi_pm_restore_cleanup, 482 }; 483 484 /** 485 * acpi_hibernation_begin_old - Set the target system sleep state to 486 * ACPI_STATE_S4 and execute the _PTS control method. This 487 * function is used if the pre-ACPI 2.0 suspend ordering has been 488 * requested. 489 */ 490 static int acpi_hibernation_begin_old(void) 491 { 492 int error; 493 /* 494 * The _TTS object should always be evaluated before the _PTS object. 495 * When the old_suspended_ordering is true, the _PTS object is 496 * evaluated in the acpi_sleep_prepare. 497 */ 498 acpi_sleep_tts_switch(ACPI_STATE_S4); 499 500 error = acpi_sleep_prepare(ACPI_STATE_S4); 501 502 if (!error) { 503 if (!s4_no_nvs) 504 error = hibernate_nvs_alloc(); 505 if (!error) 506 acpi_target_sleep_state = ACPI_STATE_S4; 507 } 508 return error; 509 } 510 511 static int acpi_hibernation_pre_snapshot_old(void) 512 { 513 int error = acpi_pm_disable_gpes(); 514 515 if (!error) 516 hibernate_nvs_save(); 517 518 return error; 519 } 520 521 /* 522 * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has 523 * been requested. 524 */ 525 static struct platform_hibernation_ops acpi_hibernation_ops_old = { 526 .begin = acpi_hibernation_begin_old, 527 .end = acpi_pm_end, 528 .pre_snapshot = acpi_hibernation_pre_snapshot_old, 529 .finish = acpi_hibernation_finish, 530 .prepare = acpi_pm_disable_gpes, 531 .enter = acpi_hibernation_enter, 532 .leave = acpi_hibernation_leave, 533 .pre_restore = acpi_pm_pre_restore, 534 .restore_cleanup = acpi_pm_restore_cleanup, 535 .recover = acpi_pm_finish, 536 }; 537 #endif /* CONFIG_HIBERNATION */ 538 539 int acpi_suspend(u32 acpi_state) 540 { 541 suspend_state_t states[] = { 542 [1] = PM_SUSPEND_STANDBY, 543 [3] = PM_SUSPEND_MEM, 544 [5] = PM_SUSPEND_MAX 545 }; 546 547 if (acpi_state < 6 && states[acpi_state]) 548 return pm_suspend(states[acpi_state]); 549 if (acpi_state == 4) 550 return hibernate(); 551 return -EINVAL; 552 } 553 554 #ifdef CONFIG_PM_SLEEP 555 /** 556 * acpi_pm_device_sleep_state - return preferred power state of ACPI device 557 * in the system sleep state given by %acpi_target_sleep_state 558 * @dev: device to examine; its driver model wakeup flags control 559 * whether it should be able to wake up the system 560 * @d_min_p: used to store the upper limit of allowed states range 561 * Return value: preferred power state of the device on success, -ENODEV on 562 * failure (ie. if there's no 'struct acpi_device' for @dev) 563 * 564 * Find the lowest power (highest number) ACPI device power state that 565 * device @dev can be in while the system is in the sleep state represented 566 * by %acpi_target_sleep_state. If @wake is nonzero, the device should be 567 * able to wake up the system from this sleep state. If @d_min_p is set, 568 * the highest power (lowest number) device power state of @dev allowed 569 * in this system sleep state is stored at the location pointed to by it. 570 * 571 * The caller must ensure that @dev is valid before using this function. 572 * The caller is also responsible for figuring out if the device is 573 * supposed to be able to wake up the system and passing this information 574 * via @wake. 575 */ 576 577 int acpi_pm_device_sleep_state(struct device *dev, int *d_min_p) 578 { 579 acpi_handle handle = DEVICE_ACPI_HANDLE(dev); 580 struct acpi_device *adev; 581 char acpi_method[] = "_SxD"; 582 unsigned long long d_min, d_max; 583 584 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 585 printk(KERN_DEBUG "ACPI handle has no context!\n"); 586 return -ENODEV; 587 } 588 589 acpi_method[2] = '0' + acpi_target_sleep_state; 590 /* 591 * If the sleep state is S0, we will return D3, but if the device has 592 * _S0W, we will use the value from _S0W 593 */ 594 d_min = ACPI_STATE_D0; 595 d_max = ACPI_STATE_D3; 596 597 /* 598 * If present, _SxD methods return the minimum D-state (highest power 599 * state) we can use for the corresponding S-states. Otherwise, the 600 * minimum D-state is D0 (ACPI 3.x). 601 * 602 * NOTE: We rely on acpi_evaluate_integer() not clobbering the integer 603 * provided -- that's our fault recovery, we ignore retval. 604 */ 605 if (acpi_target_sleep_state > ACPI_STATE_S0) 606 acpi_evaluate_integer(handle, acpi_method, NULL, &d_min); 607 608 /* 609 * If _PRW says we can wake up the system from the target sleep state, 610 * the D-state returned by _SxD is sufficient for that (we assume a 611 * wakeup-aware driver if wake is set). Still, if _SxW exists 612 * (ACPI 3.x), it should return the maximum (lowest power) D-state that 613 * can wake the system. _S0W may be valid, too. 614 */ 615 if (acpi_target_sleep_state == ACPI_STATE_S0 || 616 (device_may_wakeup(dev) && adev->wakeup.state.enabled && 617 adev->wakeup.sleep_state <= acpi_target_sleep_state)) { 618 acpi_status status; 619 620 acpi_method[3] = 'W'; 621 status = acpi_evaluate_integer(handle, acpi_method, NULL, 622 &d_max); 623 if (ACPI_FAILURE(status)) { 624 d_max = d_min; 625 } else if (d_max < d_min) { 626 /* Warn the user of the broken DSDT */ 627 printk(KERN_WARNING "ACPI: Wrong value from %s\n", 628 acpi_method); 629 /* Sanitize it */ 630 d_min = d_max; 631 } 632 } 633 634 if (d_min_p) 635 *d_min_p = d_min; 636 return d_max; 637 } 638 639 /** 640 * acpi_pm_device_sleep_wake - enable or disable the system wake-up 641 * capability of given device 642 * @dev: device to handle 643 * @enable: 'true' - enable, 'false' - disable the wake-up capability 644 */ 645 int acpi_pm_device_sleep_wake(struct device *dev, bool enable) 646 { 647 acpi_handle handle; 648 struct acpi_device *adev; 649 int error; 650 651 if (!device_can_wakeup(dev)) 652 return -EINVAL; 653 654 handle = DEVICE_ACPI_HANDLE(dev); 655 if (!handle || ACPI_FAILURE(acpi_bus_get_device(handle, &adev))) { 656 dev_dbg(dev, "ACPI handle has no context in %s!\n", __func__); 657 return -ENODEV; 658 } 659 660 if (enable) { 661 error = acpi_enable_wakeup_device_power(adev, 662 acpi_target_sleep_state); 663 if (!error) 664 acpi_enable_gpe(adev->wakeup.gpe_device, 665 adev->wakeup.gpe_number, 666 ACPI_GPE_TYPE_WAKE); 667 } else { 668 acpi_disable_gpe(adev->wakeup.gpe_device, adev->wakeup.gpe_number, 669 ACPI_GPE_TYPE_WAKE); 670 error = acpi_disable_wakeup_device_power(adev); 671 } 672 if (!error) 673 dev_info(dev, "wake-up capability %s by ACPI\n", 674 enable ? "enabled" : "disabled"); 675 676 return error; 677 } 678 #endif 679 680 static void acpi_power_off_prepare(void) 681 { 682 /* Prepare to power off the system */ 683 acpi_sleep_prepare(ACPI_STATE_S5); 684 acpi_disable_all_gpes(); 685 } 686 687 static void acpi_power_off(void) 688 { 689 /* acpi_sleep_prepare(ACPI_STATE_S5) should have already been called */ 690 printk(KERN_DEBUG "%s called\n", __func__); 691 local_irq_disable(); 692 acpi_enable_wakeup_device(ACPI_STATE_S5); 693 acpi_enter_sleep_state(ACPI_STATE_S5); 694 } 695 696 /* 697 * ACPI 2.0 created the optional _GTS and _BFS, 698 * but industry adoption has been neither rapid nor broad. 699 * 700 * Linux gets into trouble when it executes poorly validated 701 * paths through the BIOS, so disable _GTS and _BFS by default, 702 * but do speak up and offer the option to enable them. 703 */ 704 void __init acpi_gts_bfs_check(void) 705 { 706 acpi_handle dummy; 707 708 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__GTS, &dummy))) 709 { 710 printk(KERN_NOTICE PREFIX "BIOS offers _GTS\n"); 711 printk(KERN_NOTICE PREFIX "If \"acpi.gts=1\" improves suspend, " 712 "please notify linux-acpi@vger.kernel.org\n"); 713 } 714 if (ACPI_SUCCESS(acpi_get_handle(ACPI_ROOT_OBJECT, METHOD_NAME__BFS, &dummy))) 715 { 716 printk(KERN_NOTICE PREFIX "BIOS offers _BFS\n"); 717 printk(KERN_NOTICE PREFIX "If \"acpi.bfs=1\" improves resume, " 718 "please notify linux-acpi@vger.kernel.org\n"); 719 } 720 } 721 722 int __init acpi_sleep_init(void) 723 { 724 acpi_status status; 725 u8 type_a, type_b; 726 #ifdef CONFIG_SUSPEND 727 int i = 0; 728 729 dmi_check_system(acpisleep_dmi_table); 730 #endif 731 732 if (acpi_disabled) 733 return 0; 734 735 sleep_states[ACPI_STATE_S0] = 1; 736 printk(KERN_INFO PREFIX "(supports S0"); 737 738 #ifdef CONFIG_SUSPEND 739 for (i = ACPI_STATE_S1; i < ACPI_STATE_S4; i++) { 740 status = acpi_get_sleep_type_data(i, &type_a, &type_b); 741 if (ACPI_SUCCESS(status)) { 742 sleep_states[i] = 1; 743 printk(" S%d", i); 744 } 745 } 746 747 suspend_set_ops(old_suspend_ordering ? 748 &acpi_suspend_ops_old : &acpi_suspend_ops); 749 #endif 750 751 #ifdef CONFIG_HIBERNATION 752 status = acpi_get_sleep_type_data(ACPI_STATE_S4, &type_a, &type_b); 753 if (ACPI_SUCCESS(status)) { 754 hibernation_set_ops(old_suspend_ordering ? 755 &acpi_hibernation_ops_old : &acpi_hibernation_ops); 756 sleep_states[ACPI_STATE_S4] = 1; 757 printk(" S4"); 758 if (!nosigcheck) { 759 acpi_get_table(ACPI_SIG_FACS, 1, 760 (struct acpi_table_header **)&facs); 761 if (facs) 762 s4_hardware_signature = 763 facs->hardware_signature; 764 } 765 } 766 #endif 767 status = acpi_get_sleep_type_data(ACPI_STATE_S5, &type_a, &type_b); 768 if (ACPI_SUCCESS(status)) { 769 sleep_states[ACPI_STATE_S5] = 1; 770 printk(" S5"); 771 pm_power_off_prepare = acpi_power_off_prepare; 772 pm_power_off = acpi_power_off; 773 } 774 printk(")\n"); 775 /* 776 * Register the tts_notifier to reboot notifier list so that the _TTS 777 * object can also be evaluated when the system enters S5. 778 */ 779 register_reboot_notifier(&tts_notifier); 780 acpi_gts_bfs_check(); 781 return 0; 782 } 783