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 * If the Hardware Reduced flag is set (from the FADT), we must 245 * use the extended sleep registers (FADT). Note: As per the ACPI 246 * specification, these extended registers are to be used for HW-reduced 247 * platforms only. They are not general-purpose replacements for the 248 * legacy PM register sleep support. 249 */ 250 if (acpi_gbl_reduced_hardware) { 251 status = sleep_functions->extended_function(sleep_state); 252 } else { 253 /* Legacy sleep */ 254 255 status = sleep_functions->legacy_function(sleep_state); 256 } 257 258 return (status); 259 260 #else 261 /* 262 * For the case where reduced-hardware-only code is being generated, 263 * we know that only the extended sleep registers are available 264 */ 265 status = sleep_functions->extended_function(sleep_state); 266 return (status); 267 268 #endif /* !ACPI_REDUCED_HARDWARE */ 269 } 270 271 /******************************************************************************* 272 * 273 * FUNCTION: acpi_enter_sleep_state_prep 274 * 275 * PARAMETERS: sleep_state - Which sleep state to enter 276 * 277 * RETURN: Status 278 * 279 * DESCRIPTION: Prepare to enter a system sleep state. 280 * This function must execute with interrupts enabled. 281 * We break sleeping into 2 stages so that OSPM can handle 282 * various OS-specific tasks between the two steps. 283 * 284 ******************************************************************************/ 285 286 acpi_status acpi_enter_sleep_state_prep(u8 sleep_state) 287 { 288 acpi_status status; 289 struct acpi_object_list arg_list; 290 union acpi_object arg; 291 u32 sst_value; 292 293 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep); 294 295 status = acpi_get_sleep_type_data(sleep_state, 296 &acpi_gbl_sleep_type_a, 297 &acpi_gbl_sleep_type_b); 298 if (ACPI_FAILURE(status)) { 299 return_ACPI_STATUS(status); 300 } 301 302 /* Execute the _PTS method (Prepare To Sleep) */ 303 304 arg_list.count = 1; 305 arg_list.pointer = &arg; 306 arg.type = ACPI_TYPE_INTEGER; 307 arg.integer.value = sleep_state; 308 309 status = 310 acpi_evaluate_object(NULL, METHOD_PATHNAME__PTS, &arg_list, NULL); 311 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 312 return_ACPI_STATUS(status); 313 } 314 315 /* Setup the argument to the _SST method (System STatus) */ 316 317 switch (sleep_state) { 318 case ACPI_STATE_S0: 319 320 sst_value = ACPI_SST_WORKING; 321 break; 322 323 case ACPI_STATE_S1: 324 case ACPI_STATE_S2: 325 case ACPI_STATE_S3: 326 327 sst_value = ACPI_SST_SLEEPING; 328 break; 329 330 case ACPI_STATE_S4: 331 332 sst_value = ACPI_SST_SLEEP_CONTEXT; 333 break; 334 335 default: 336 337 sst_value = ACPI_SST_INDICATOR_OFF; /* Default is off */ 338 break; 339 } 340 341 /* 342 * Set the system indicators to show the desired sleep state. 343 * _SST is an optional method (return no error if not found) 344 */ 345 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, sst_value); 346 return_ACPI_STATUS(AE_OK); 347 } 348 349 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state_prep) 350 351 /******************************************************************************* 352 * 353 * FUNCTION: acpi_enter_sleep_state 354 * 355 * PARAMETERS: sleep_state - Which sleep state to enter 356 * 357 * RETURN: Status 358 * 359 * DESCRIPTION: Enter a system sleep state 360 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 361 * 362 ******************************************************************************/ 363 acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state) 364 { 365 acpi_status status; 366 367 ACPI_FUNCTION_TRACE(acpi_enter_sleep_state); 368 369 if ((acpi_gbl_sleep_type_a > ACPI_SLEEP_TYPE_MAX) || 370 (acpi_gbl_sleep_type_b > ACPI_SLEEP_TYPE_MAX)) { 371 ACPI_ERROR((AE_INFO, "Sleep values out of range: A=0x%X B=0x%X", 372 acpi_gbl_sleep_type_a, acpi_gbl_sleep_type_b)); 373 return_ACPI_STATUS(AE_AML_OPERAND_VALUE); 374 } 375 376 status = acpi_hw_sleep_dispatch(sleep_state, ACPI_SLEEP_FUNCTION_ID); 377 return_ACPI_STATUS(status); 378 } 379 380 ACPI_EXPORT_SYMBOL(acpi_enter_sleep_state) 381 382 /******************************************************************************* 383 * 384 * FUNCTION: acpi_leave_sleep_state_prep 385 * 386 * PARAMETERS: sleep_state - Which sleep state we are exiting 387 * 388 * RETURN: Status 389 * 390 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a 391 * sleep. Called with interrupts DISABLED. 392 * We break wake/resume into 2 stages so that OSPM can handle 393 * various OS-specific tasks between the two steps. 394 * 395 ******************************************************************************/ 396 acpi_status acpi_leave_sleep_state_prep(u8 sleep_state) 397 { 398 acpi_status status; 399 400 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state_prep); 401 402 status = 403 acpi_hw_sleep_dispatch(sleep_state, ACPI_WAKE_PREP_FUNCTION_ID); 404 return_ACPI_STATUS(status); 405 } 406 407 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state_prep) 408 409 /******************************************************************************* 410 * 411 * FUNCTION: acpi_leave_sleep_state 412 * 413 * PARAMETERS: sleep_state - Which sleep state we are exiting 414 * 415 * RETURN: Status 416 * 417 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 418 * Called with interrupts ENABLED. 419 * 420 ******************************************************************************/ 421 acpi_status acpi_leave_sleep_state(u8 sleep_state) 422 { 423 acpi_status status; 424 425 ACPI_FUNCTION_TRACE(acpi_leave_sleep_state); 426 427 status = acpi_hw_sleep_dispatch(sleep_state, ACPI_WAKE_FUNCTION_ID); 428 return_ACPI_STATUS(status); 429 } 430 431 ACPI_EXPORT_SYMBOL(acpi_leave_sleep_state) 432