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