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