1 /****************************************************************************** 2 * 3 * Name: hwxfsleep.c - ACPI Hardware Sleep/Wake External Interfaces 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <linux/export.h> 45 #include <acpi/acpi.h> 46 #include "accommon.h" 47 48 #define _COMPONENT ACPI_HARDWARE 49 ACPI_MODULE_NAME("hwxfsleep") 50 51 /* Local prototypes */ 52 static acpi_status acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id); 53 54 /* 55 * Dispatch table used to efficiently branch to the various sleep 56 * functions. 57 */ 58 #define ACPI_SLEEP_FUNCTION_ID 0 59 #define ACPI_WAKE_PREP_FUNCTION_ID 1 60 #define ACPI_WAKE_FUNCTION_ID 2 61 62 /* Legacy functions are optional, based upon ACPI_REDUCED_HARDWARE */ 63 64 static struct acpi_sleep_functions acpi_sleep_dispatch[] = { 65 {ACPI_HW_OPTIONAL_FUNCTION(acpi_hw_legacy_sleep), 66 acpi_hw_extended_sleep}, 67 {ACPI_HW_OPTIONAL_FUNCTION(acpi_hw_legacy_wake_prep), 68 acpi_hw_extended_wake_prep}, 69 {ACPI_HW_OPTIONAL_FUNCTION(acpi_hw_legacy_wake), acpi_hw_extended_wake} 70 }; 71 72 /* 73 * These functions are removed for the ACPI_REDUCED_HARDWARE case: 74 * acpi_set_firmware_waking_vector 75 * acpi_set_firmware_waking_vector64 76 * acpi_enter_sleep_state_s4bios 77 */ 78 79 #if (!ACPI_REDUCED_HARDWARE) 80 /******************************************************************************* 81 * 82 * FUNCTION: acpi_set_firmware_waking_vector 83 * 84 * PARAMETERS: physical_address - 32-bit physical address of ACPI real mode 85 * entry point. 86 * 87 * RETURN: Status 88 * 89 * DESCRIPTION: Sets the 32-bit firmware_waking_vector field of the FACS 90 * 91 ******************************************************************************/ 92 93 acpi_status acpi_set_firmware_waking_vector(u32 physical_address) 94 { 95 ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector); 96 97 98 /* 99 * According to the ACPI specification 2.0c and later, the 64-bit 100 * waking vector should be cleared and the 32-bit waking vector should 101 * be used, unless we want the wake-up code to be called by the BIOS in 102 * Protected Mode. Some systems (for example HP dv5-1004nr) are known 103 * to fail to resume if the 64-bit vector is used. 104 */ 105 106 /* Set the 32-bit vector */ 107 108 acpi_gbl_FACS->firmware_waking_vector = physical_address; 109 110 /* Clear the 64-bit vector if it exists */ 111 112 if ((acpi_gbl_FACS->length > 32) && (acpi_gbl_FACS->version >= 1)) { 113 acpi_gbl_FACS->xfirmware_waking_vector = 0; 114 } 115 116 return_ACPI_STATUS(AE_OK); 117 } 118 119 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector) 120 121 #if ACPI_MACHINE_WIDTH == 64 122 /******************************************************************************* 123 * 124 * FUNCTION: acpi_set_firmware_waking_vector64 125 * 126 * PARAMETERS: physical_address - 64-bit physical address of ACPI protected 127 * mode entry point. 128 * 129 * RETURN: Status 130 * 131 * DESCRIPTION: Sets the 64-bit X_firmware_waking_vector field of the FACS, if 132 * it exists in the table. This function is intended for use with 133 * 64-bit host operating systems. 134 * 135 ******************************************************************************/ 136 acpi_status acpi_set_firmware_waking_vector64(u64 physical_address) 137 { 138 ACPI_FUNCTION_TRACE(acpi_set_firmware_waking_vector64); 139 140 141 /* Determine if the 64-bit vector actually exists */ 142 143 if ((acpi_gbl_FACS->length <= 32) || (acpi_gbl_FACS->version < 1)) { 144 return_ACPI_STATUS(AE_NOT_EXIST); 145 } 146 147 /* Clear 32-bit vector, set the 64-bit X_ vector */ 148 149 acpi_gbl_FACS->firmware_waking_vector = 0; 150 acpi_gbl_FACS->xfirmware_waking_vector = physical_address; 151 return_ACPI_STATUS(AE_OK); 152 } 153 154 ACPI_EXPORT_SYMBOL(acpi_set_firmware_waking_vector64) 155 #endif 156 157 /******************************************************************************* 158 * 159 * FUNCTION: acpi_enter_sleep_state_s4bios 160 * 161 * PARAMETERS: None 162 * 163 * RETURN: Status 164 * 165 * DESCRIPTION: Perform a S4 bios request. 166 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 167 * 168 ******************************************************************************/ 169 acpi_status asmlinkage acpi_enter_sleep_state_s4bios(void) 170 { 171 u32 in_value; 172 acpi_status status; 173 174 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_s4bios); 175 176 /* Clear the wake status bit (PM1) */ 177 178 status = 179 acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS); 180 if (ACPI_FAILURE(status)) { 181 return_ACPI_STATUS(status); 182 } 183 184 status = acpi_hw_clear_acpi_status(); 185 if (ACPI_FAILURE(status)) { 186 return_ACPI_STATUS(status); 187 } 188 189 /* 190 * 1) Disable/Clear all GPEs 191 * 2) Enable all wakeup GPEs 192 */ 193 status = acpi_hw_disable_all_gpes(); 194 if (ACPI_FAILURE(status)) { 195 return_ACPI_STATUS(status); 196 } 197 acpi_gbl_system_awake_and_running = FALSE; 198 199 status = acpi_hw_enable_all_wakeup_gpes(); 200 if (ACPI_FAILURE(status)) { 201 return_ACPI_STATUS(status); 202 } 203 204 ACPI_FLUSH_CPU_CACHE(); 205 206 status = acpi_hw_write_port(acpi_gbl_FADT.smi_command, 207 (u32)acpi_gbl_FADT.s4_bios_request, 8); 208 209 do { 210 acpi_os_stall(ACPI_USEC_PER_MSEC); 211 status = 212 acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value); 213 if (ACPI_FAILURE(status)) { 214 return_ACPI_STATUS(status); 215 } 216 } while (!in_value); 217 218 return_ACPI_STATUS(AE_OK); 219 } 220 221 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_s4bios) 222 #endif /* !ACPI_REDUCED_HARDWARE */ 223 /******************************************************************************* 224 * 225 * FUNCTION: acpi_hw_sleep_dispatch 226 * 227 * PARAMETERS: sleep_state - Which sleep state to enter/exit 228 * function_id - Sleep, wake_prep, or Wake 229 * 230 * RETURN: Status from the invoked sleep handling function. 231 * 232 * DESCRIPTION: Dispatch a sleep/wake request to the appropriate handling 233 * function. 234 * 235 ******************************************************************************/ 236 static acpi_status acpi_hw_sleep_dispatch(u8 sleep_state, u32 function_id) 237 { 238 acpi_status status; 239 struct acpi_sleep_functions *sleep_functions = 240 &acpi_sleep_dispatch[function_id]; 241 242 #if (!ACPI_REDUCED_HARDWARE) 243 244 /* 245 * If the Hardware Reduced flag is set (from the FADT), we must 246 * use the extended sleep registers 247 */ 248 if (acpi_gbl_reduced_hardware || acpi_gbl_FADT.sleep_control.address) { 249 status = sleep_functions->extended_function(sleep_state); 250 } else { 251 /* Legacy sleep */ 252 253 status = sleep_functions->legacy_function(sleep_state); 254 } 255 256 return (status); 257 258 #else 259 /* 260 * For the case where reduced-hardware-only code is being generated, 261 * we know that only the extended sleep registers are available 262 */ 263 status = sleep_functions->extended_function(sleep_state); 264 return (status); 265 266 #endif /* !ACPI_REDUCED_HARDWARE */ 267 } 268 269 /******************************************************************************* 270 * 271 * FUNCTION: acpi_enter_sleep_state_prep 272 * 273 * PARAMETERS: sleep_state - Which sleep state to enter 274 * 275 * RETURN: Status 276 * 277 * DESCRIPTION: Prepare to enter a system sleep state. 278 * This function must execute with interrupts enabled. 279 * We break sleeping into 2 stages so that OSPM can handle 280 * various OS-specific tasks between the two steps. 281 * 282 ******************************************************************************/ 283 284 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state) 285 { 286 acpi_status status; 287 struct acpi_object_list arg_list; 288 union acpi_object arg; 289 u32 sst_value; 290 291 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep); 292 293 status = acpi_get_sleep_type_data(sleep_state, 294 &acpi_gbl_sleep_type_a, 295 &acpi_gbl_sleep_type_b); 296 if (ACPI_FAILURE(status)) { 297 return_ACPI_STATUS(status); 298 } 299 300 /* Execute the _PTS method (Prepare To Sleep) */ 301 302 arg_list.count = 1; 303 arg_list.pointer = &arg; 304 arg.type = ACPI_TYPE_INTEGER; 305 arg.integer.value = sleep_state; 306 307 status = 308 acpi_evaluate_object(NULL, METHOD_PATHNAME__PTS, &arg_list, NULL); 309 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 310 return_ACPI_STATUS(status); 311 } 312 313 /* Setup the argument to the _SST method (System STatus) */ 314 315 switch (sleep_state) { 316 case ACPI_STATE_S0: 317 sst_value = ACPI_SST_WORKING; 318 break; 319 320 case ACPI_STATE_S1: 321 case ACPI_STATE_S2: 322 case ACPI_STATE_S3: 323 sst_value = ACPI_SST_SLEEPING; 324 break; 325 326 case ACPI_STATE_S4: 327 sst_value = ACPI_SST_SLEEP_CONTEXT; 328 break; 329 330 default: 331 sst_value = ACPI_SST_INDICATOR_OFF; /* Default is off */ 332 break; 333 } 334 335 /* 336 * Set the system indicators to show the desired sleep state. 337 * _SST is an optional method (return no error if not found) 338 */ 339 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, sst_value); 340 return_ACPI_STATUS(AE_OK); 341 } 342 343 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep) 344 345 /******************************************************************************* 346 * 347 * FUNCTION: acpi_enter_sleep_state 348 * 349 * PARAMETERS: sleep_state - Which sleep state to enter 350 * 351 * RETURN: Status 352 * 353 * DESCRIPTION: Enter a system sleep state 354 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 355 * 356 ******************************************************************************/ 357 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state) 358 { 359 acpi_status status; 360 361 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state); 362 363 if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) || 364 (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) { 365 ACPI_ERROR((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X", 366 acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b)); 367 return_ACPI_STATUS(AE_AML_OPERAND_VALUE); 368 } 369 370 status = acpi_hw_sleep_dispatch(sleep_state, ACPI_SLEEP_FUNCTION_ID); 371 return_ACPI_STATUS(status); 372 } 373 374 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state) 375 376 /******************************************************************************* 377 * 378 * FUNCTION: acpi_leave_sleep_state_prep 379 * 380 * PARAMETERS: sleep_state - Which sleep state we are exiting 381 * 382 * RETURN: Status 383 * 384 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a 385 * sleep. Called with interrupts DISABLED. 386 * We break wake/resume into 2 stages so that OSPM can handle 387 * various OS-specific tasks between the two steps. 388 * 389 ******************************************************************************/ 390 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state) 391 { 392 acpi_status status; 393 394 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep); 395 396 status = 397 acpi_hw_sleep_dispatch(sleep_state, ACPI_WAKE_PREP_FUNCTION_ID); 398 return_ACPI_STATUS(status); 399 } 400 401 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep) 402 403 /******************************************************************************* 404 * 405 * FUNCTION: acpi_leave_sleep_state 406 * 407 * PARAMETERS: sleep_state - Which sleep state we are exiting 408 * 409 * RETURN: Status 410 * 411 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 412 * Called with interrupts ENABLED. 413 * 414 ******************************************************************************/ 415 acpi_status acpi_leave_sleep_state(u8 sleep_state) 416 { 417 acpi_status status; 418 419 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state); 420 421 status = acpi_hw_sleep_dispatch(sleep_state, ACPI_WAKE_FUNCTION_ID); 422 return_ACPI_STATUS(status); 423 } 424 425 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state) 426