1 2 /****************************************************************************** 3 * 4 * Name: hwsleep.c - ACPI Hardware Sleep/Wake Interface 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2008, Intel Corp. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions, and the following disclaimer, 17 * without modification. 18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 19 * substantially similar to the "NO WARRANTY" disclaimer below 20 * ("Disclaimer") and any redistribution must be conditioned upon 21 * including a substantially similar Disclaimer requirement for further 22 * binary redistribution. 23 * 3. Neither the names of the above-listed copyright holders nor the names 24 * of any contributors may be used to endorse or promote products derived 25 * from this software without specific prior written permission. 26 * 27 * Alternatively, this software may be distributed under the terms of the 28 * GNU General Public License ("GPL") version 2 as published by the Free 29 * Software Foundation. 30 * 31 * NO WARRANTY 32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 42 * POSSIBILITY OF SUCH DAMAGES. 43 */ 44 45 #include <acpi/acpi.h> 46 #include "accommon.h" 47 #include "actables.h" 48 49 #define _COMPONENT ACPI_HARDWARE 50 ACPI_MODULE_NAME("hwsleep") 51 52 /******************************************************************************* 53 * 54 * FUNCTION: acpi_set_firmware_waking_vector 55 * 56 * PARAMETERS: physical_address - 32-bit physical address of ACPI real mode 57 * entry point. 58 * 59 * RETURN: Status 60 * 61 * DESCRIPTION: Sets the 32-bit firmware_waking_vector field of the FACS 62 * 63 ******************************************************************************/ 64 acpi_status 65 acpi_set_firmware_waking_vector(u32 physical_address) 66 { 67 ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector); 68 69 70 /* 71 * According to the ACPI specification 2.0c and later, the 64-bit 72 * waking vector should be cleared and the 32-bit waking vector should 73 * be used, unless we want the wake-up code to be called by the BIOS in 74 * Protected Mode. Some systems (for example HP dv5-1004nr) are known 75 * to fail to resume if the 64-bit vector is used. 76 */ 77 78 /* Set the 32-bit vector */ 79 80 acpi_gbl_FACS->firmware_waking_vector = physical_address; 81 82 /* Clear the 64-bit vector if it exists */ 83 84 if ((acpi_gbl_FACS->length > 32) && (acpi_gbl_FACS->version >= 1)) { 85 acpi_gbl_FACS->xfirmware_waking_vector = 0; 86 } 87 88 return_ACPI_STATUS(AE_OK); 89 } 90 91 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector) 92 93 /******************************************************************************* 94 * 95 * FUNCTION: acpi_set_firmware_waking_vector64 96 * 97 * PARAMETERS: physical_address - 64-bit physical address of ACPI protected 98 * mode entry point. 99 * 100 * RETURN: Status 101 * 102 * DESCRIPTION: Sets the 64-bit X_firmware_waking_vector field of the FACS, if 103 * it exists in the table. 104 * 105 ******************************************************************************/ 106 acpi_status 107 acpi_set_firmware_waking_vector64(u64 physical_address) 108 { 109 ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector64); 110 111 112 /* Determine if the 64-bit vector actually exists */ 113 114 if ((acpi_gbl_FACS->length <= 32) || (acpi_gbl_FACS->version < 1)) { 115 return_ACPI_STATUS(AE_NOT_EXIST); 116 } 117 118 /* Clear 32-bit vector, set the 64-bit X_ vector */ 119 120 acpi_gbl_FACS->firmware_waking_vector = 0; 121 acpi_gbl_FACS->xfirmware_waking_vector = physical_address; 122 123 return_ACPI_STATUS(AE_OK); 124 } 125 126 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector64) 127 128 /******************************************************************************* 129 * 130 * FUNCTION: acpi_enter_sleep_state_prep 131 * 132 * PARAMETERS: sleep_state - Which sleep state to enter 133 * 134 * RETURN: Status 135 * 136 * DESCRIPTION: Prepare to enter a system sleep state (see ACPI 2.0 spec p 231) 137 * This function must execute with interrupts enabled. 138 * We break sleeping into 2 stages so that OSPM can handle 139 * various OS-specific tasks between the two steps. 140 * 141 ******************************************************************************/ 142 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state) 143 { 144 acpi_status status; 145 struct acpi_object_list arg_list; 146 union acpi_object arg; 147 148 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep); 149 150 /* 151 * _PSW methods could be run here to enable wake-on keyboard, LAN, etc. 152 */ 153 status = acpi_get_sleep_type_data(sleep_state, 154 &acpi_gbl_sleep_type_a, 155 &acpi_gbl_sleep_type_b); 156 if (ACPI_FAILURE(status)) { 157 return_ACPI_STATUS(status); 158 } 159 160 /* Setup parameter object */ 161 162 arg_list.count = 1; 163 arg_list.pointer = &arg; 164 165 arg.type = ACPI_TYPE_INTEGER; 166 arg.integer.value = sleep_state; 167 168 /* Run the _PTS method */ 169 170 status = acpi_evaluate_object(NULL, METHOD_NAME__PTS, &arg_list, NULL); 171 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 172 return_ACPI_STATUS(status); 173 } 174 175 /* Setup the argument to _SST */ 176 177 switch (sleep_state) { 178 case ACPI_STATE_S0: 179 arg.integer.value = ACPI_SST_WORKING; 180 break; 181 182 case ACPI_STATE_S1: 183 case ACPI_STATE_S2: 184 case ACPI_STATE_S3: 185 arg.integer.value = ACPI_SST_SLEEPING; 186 break; 187 188 case ACPI_STATE_S4: 189 arg.integer.value = ACPI_SST_SLEEP_CONTEXT; 190 break; 191 192 default: 193 arg.integer.value = ACPI_SST_INDICATOR_OFF; /* Default is off */ 194 break; 195 } 196 197 /* 198 * Set the system indicators to show the desired sleep state. 199 * _SST is an optional method (return no error if not found) 200 */ 201 status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL); 202 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 203 ACPI_EXCEPTION((AE_INFO, status, 204 "While executing method _SST")); 205 } 206 207 return_ACPI_STATUS(AE_OK); 208 } 209 210 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep) 211 212 /******************************************************************************* 213 * 214 * FUNCTION: acpi_enter_sleep_state 215 * 216 * PARAMETERS: sleep_state - Which sleep state to enter 217 * 218 * RETURN: Status 219 * 220 * DESCRIPTION: Enter a system sleep state (see ACPI 2.0 spec p 231) 221 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 222 * 223 ******************************************************************************/ 224 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state) 225 { 226 u32 PM1Acontrol; 227 u32 PM1Bcontrol; 228 struct acpi_bit_register_info *sleep_type_reg_info; 229 struct acpi_bit_register_info *sleep_enable_reg_info; 230 u32 in_value; 231 struct acpi_object_list arg_list; 232 union acpi_object arg; 233 acpi_status status; 234 235 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state); 236 237 if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) || 238 (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) { 239 ACPI_ERROR((AE_INFO, "Sleep values out of range: A=%X B=%X", 240 acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b)); 241 return_ACPI_STATUS(AE_AML_OPERAND_VALUE); 242 } 243 244 sleep_type_reg_info = 245 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A); 246 sleep_enable_reg_info = 247 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE); 248 249 /* Clear wake status */ 250 251 status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1); 252 if (ACPI_FAILURE(status)) { 253 return_ACPI_STATUS(status); 254 } 255 256 /* Clear all fixed and general purpose status bits */ 257 258 status = acpi_hw_clear_acpi_status(); 259 if (ACPI_FAILURE(status)) { 260 return_ACPI_STATUS(status); 261 } 262 263 /* 264 * 1) Disable/Clear all GPEs 265 * 2) Enable all wakeup GPEs 266 */ 267 status = acpi_hw_disable_all_gpes(); 268 if (ACPI_FAILURE(status)) { 269 return_ACPI_STATUS(status); 270 } 271 acpi_gbl_system_awake_and_running = FALSE; 272 273 status = acpi_hw_enable_all_wakeup_gpes(); 274 if (ACPI_FAILURE(status)) { 275 return_ACPI_STATUS(status); 276 } 277 278 /* Execute the _GTS method */ 279 280 arg_list.count = 1; 281 arg_list.pointer = &arg; 282 arg.type = ACPI_TYPE_INTEGER; 283 arg.integer.value = sleep_state; 284 285 status = acpi_evaluate_object(NULL, METHOD_NAME__GTS, &arg_list, NULL); 286 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 287 return_ACPI_STATUS(status); 288 } 289 290 /* Get current value of PM1A control */ 291 292 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, &PM1Acontrol); 293 if (ACPI_FAILURE(status)) { 294 return_ACPI_STATUS(status); 295 } 296 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 297 "Entering sleep state [S%d]\n", sleep_state)); 298 299 /* Clear SLP_EN and SLP_TYP fields */ 300 301 PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask | 302 sleep_enable_reg_info->access_bit_mask); 303 PM1Bcontrol = PM1Acontrol; 304 305 /* Insert SLP_TYP bits */ 306 307 PM1Acontrol |= 308 (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position); 309 PM1Bcontrol |= 310 (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position); 311 312 /* 313 * We split the writes of SLP_TYP and SLP_EN to workaround 314 * poorly implemented hardware. 315 */ 316 317 /* Write #1: fill in SLP_TYP data */ 318 319 status = acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL, 320 PM1Acontrol); 321 if (ACPI_FAILURE(status)) { 322 return_ACPI_STATUS(status); 323 } 324 325 status = acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL, 326 PM1Bcontrol); 327 if (ACPI_FAILURE(status)) { 328 return_ACPI_STATUS(status); 329 } 330 331 /* Insert SLP_ENABLE bit */ 332 333 PM1Acontrol |= sleep_enable_reg_info->access_bit_mask; 334 PM1Bcontrol |= sleep_enable_reg_info->access_bit_mask; 335 336 /* Write #2: SLP_TYP + SLP_EN */ 337 338 ACPI_FLUSH_CPU_CACHE(); 339 340 status = acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL, 341 PM1Acontrol); 342 if (ACPI_FAILURE(status)) { 343 return_ACPI_STATUS(status); 344 } 345 346 status = acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL, 347 PM1Bcontrol); 348 if (ACPI_FAILURE(status)) { 349 return_ACPI_STATUS(status); 350 } 351 352 if (sleep_state > ACPI_STATE_S3) { 353 /* 354 * We wanted to sleep > S3, but it didn't happen (by virtue of the 355 * fact that we are still executing!) 356 * 357 * Wait ten seconds, then try again. This is to get S4/S5 to work on 358 * all machines. 359 * 360 * We wait so long to allow chipsets that poll this reg very slowly to 361 * still read the right value. Ideally, this block would go 362 * away entirely. 363 */ 364 acpi_os_stall(10000000); 365 366 status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL, 367 sleep_enable_reg_info-> 368 access_bit_mask); 369 if (ACPI_FAILURE(status)) { 370 return_ACPI_STATUS(status); 371 } 372 } 373 374 /* Wait until we enter sleep state */ 375 376 do { 377 status = acpi_get_register_unlocked(ACPI_BITREG_WAKE_STATUS, 378 &in_value); 379 if (ACPI_FAILURE(status)) { 380 return_ACPI_STATUS(status); 381 } 382 383 /* Spin until we wake */ 384 385 } while (!in_value); 386 387 return_ACPI_STATUS(AE_OK); 388 } 389 390 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state) 391 392 /******************************************************************************* 393 * 394 * FUNCTION: acpi_enter_sleep_state_s4bios 395 * 396 * PARAMETERS: None 397 * 398 * RETURN: Status 399 * 400 * DESCRIPTION: Perform a S4 bios request. 401 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 402 * 403 ******************************************************************************/ 404 acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void) 405 { 406 u32 in_value; 407 acpi_status status; 408 409 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios); 410 411 status = acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1); 412 if (ACPI_FAILURE(status)) { 413 return_ACPI_STATUS(status); 414 } 415 416 status = acpi_hw_clear_acpi_status(); 417 if (ACPI_FAILURE(status)) { 418 return_ACPI_STATUS(status); 419 } 420 421 /* 422 * 1) Disable/Clear all GPEs 423 * 2) Enable all wakeup GPEs 424 */ 425 status = acpi_hw_disable_all_gpes(); 426 if (ACPI_FAILURE(status)) { 427 return_ACPI_STATUS(status); 428 } 429 acpi_gbl_system_awake_and_running = FALSE; 430 431 status = acpi_hw_enable_all_wakeup_gpes(); 432 if (ACPI_FAILURE(status)) { 433 return_ACPI_STATUS(status); 434 } 435 436 ACPI_FLUSH_CPU_CACHE(); 437 438 status = acpi_os_write_port(acpi_gbl_FADT.smi_command, 439 (u32) acpi_gbl_FADT.S4bios_request, 8); 440 441 do { 442 acpi_os_stall(1000); 443 status = acpi_get_register(ACPI_BITREG_WAKE_STATUS, &in_value); 444 if (ACPI_FAILURE(status)) { 445 return_ACPI_STATUS(status); 446 } 447 } while (!in_value); 448 449 return_ACPI_STATUS(AE_OK); 450 } 451 452 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios) 453 454 /******************************************************************************* 455 * 456 * FUNCTION: acpi_leave_sleep_state_prep 457 * 458 * PARAMETERS: sleep_state - Which sleep state we are exiting 459 * 460 * RETURN: Status 461 * 462 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a 463 * sleep. 464 * Called with interrupts DISABLED. 465 * 466 ******************************************************************************/ 467 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state) 468 { 469 struct acpi_object_list arg_list; 470 union acpi_object arg; 471 acpi_status status; 472 struct acpi_bit_register_info *sleep_type_reg_info; 473 struct acpi_bit_register_info *sleep_enable_reg_info; 474 u32 PM1Acontrol; 475 u32 PM1Bcontrol; 476 477 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep); 478 479 /* 480 * Set SLP_TYPE and SLP_EN to state S0. 481 * This is unclear from the ACPI Spec, but it is required 482 * by some machines. 483 */ 484 status = acpi_get_sleep_type_data(ACPI_STATE_S0, 485 &acpi_gbl_sleep_type_a, 486 &acpi_gbl_sleep_type_b); 487 if (ACPI_SUCCESS(status)) { 488 sleep_type_reg_info = 489 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE_A); 490 sleep_enable_reg_info = 491 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE); 492 493 /* Get current value of PM1A control */ 494 495 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, 496 &PM1Acontrol); 497 if (ACPI_SUCCESS(status)) { 498 499 /* Clear SLP_EN and SLP_TYP fields */ 500 501 PM1Acontrol &= ~(sleep_type_reg_info->access_bit_mask | 502 sleep_enable_reg_info-> 503 access_bit_mask); 504 PM1Bcontrol = PM1Acontrol; 505 506 /* Insert SLP_TYP bits */ 507 508 PM1Acontrol |= 509 (acpi_gbl_sleep_type_a << sleep_type_reg_info-> 510 bit_position); 511 PM1Bcontrol |= 512 (acpi_gbl_sleep_type_b << sleep_type_reg_info-> 513 bit_position); 514 515 /* Just ignore any errors */ 516 517 (void)acpi_hw_register_write(ACPI_REGISTER_PM1A_CONTROL, 518 PM1Acontrol); 519 (void)acpi_hw_register_write(ACPI_REGISTER_PM1B_CONTROL, 520 PM1Bcontrol); 521 } 522 } 523 524 /* Execute the _BFS method */ 525 526 arg_list.count = 1; 527 arg_list.pointer = &arg; 528 arg.type = ACPI_TYPE_INTEGER; 529 arg.integer.value = sleep_state; 530 531 status = acpi_evaluate_object(NULL, METHOD_NAME__BFS, &arg_list, NULL); 532 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 533 ACPI_EXCEPTION((AE_INFO, status, "During Method _BFS")); 534 } 535 536 return_ACPI_STATUS(status); 537 } 538 539 /******************************************************************************* 540 * 541 * FUNCTION: acpi_leave_sleep_state 542 * 543 * PARAMETERS: sleep_state - Which sleep state we just exited 544 * 545 * RETURN: Status 546 * 547 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 548 * Called with interrupts ENABLED. 549 * 550 ******************************************************************************/ 551 acpi_status acpi_leave_sleep_state(u8 sleep_state) 552 { 553 struct acpi_object_list arg_list; 554 union acpi_object arg; 555 acpi_status status; 556 557 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state); 558 559 /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */ 560 561 acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID; 562 563 /* Setup parameter object */ 564 565 arg_list.count = 1; 566 arg_list.pointer = &arg; 567 arg.type = ACPI_TYPE_INTEGER; 568 569 /* Ignore any errors from these methods */ 570 571 arg.integer.value = ACPI_SST_WAKING; 572 status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL); 573 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 574 ACPI_EXCEPTION((AE_INFO, status, "During Method _SST")); 575 } 576 577 /* 578 * GPEs must be enabled before _WAK is called as GPEs 579 * might get fired there 580 * 581 * Restore the GPEs: 582 * 1) Disable/Clear all GPEs 583 * 2) Enable all runtime GPEs 584 */ 585 status = acpi_hw_disable_all_gpes(); 586 if (ACPI_FAILURE(status)) { 587 return_ACPI_STATUS(status); 588 } 589 status = acpi_hw_enable_all_runtime_gpes(); 590 if (ACPI_FAILURE(status)) { 591 return_ACPI_STATUS(status); 592 } 593 594 arg.integer.value = sleep_state; 595 status = acpi_evaluate_object(NULL, METHOD_NAME__WAK, &arg_list, NULL); 596 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 597 ACPI_EXCEPTION((AE_INFO, status, "During Method _WAK")); 598 } 599 /* TBD: _WAK "sometimes" returns stuff - do we want to look at it? */ 600 601 /* 602 * Some BIOSes assume that WAK_STS will be cleared on resume and use 603 * it to determine whether the system is rebooting or resuming. Clear 604 * it for compatibility. 605 */ 606 acpi_set_register(ACPI_BITREG_WAKE_STATUS, 1); 607 608 acpi_gbl_system_awake_and_running = TRUE; 609 610 /* Enable power button */ 611 612 (void) 613 acpi_set_register(acpi_gbl_fixed_event_info 614 [ACPI_EVENT_POWER_BUTTON].enable_register_id, 1); 615 616 (void) 617 acpi_set_register(acpi_gbl_fixed_event_info 618 [ACPI_EVENT_POWER_BUTTON].status_register_id, 1); 619 620 arg.integer.value = ACPI_SST_WORKING; 621 status = acpi_evaluate_object(NULL, METHOD_NAME__SST, &arg_list, NULL); 622 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 623 ACPI_EXCEPTION((AE_INFO, status, "During Method _SST")); 624 } 625 626 return_ACPI_STATUS(status); 627 } 628 629 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state) 630