1 /****************************************************************************** 2 * 3 * Name: hwsleep.c - ACPI Hardware Sleep/Wake Support functions for the 4 * original/legacy sleep/PM registers. 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2012, 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 <linux/acpi.h> 47 #include "accommon.h" 48 #include <linux/module.h> 49 50 #define _COMPONENT ACPI_HARDWARE 51 ACPI_MODULE_NAME("hwsleep") 52 53 #if (!ACPI_REDUCED_HARDWARE) /* Entire module */ 54 /******************************************************************************* 55 * 56 * FUNCTION: acpi_hw_legacy_sleep 57 * 58 * PARAMETERS: sleep_state - Which sleep state to enter 59 * 60 * RETURN: Status 61 * 62 * DESCRIPTION: Enter a system sleep state via the legacy FADT PM registers 63 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 64 * 65 ******************************************************************************/ 66 acpi_status acpi_hw_legacy_sleep(u8 sleep_state) 67 { 68 struct acpi_bit_register_info *sleep_type_reg_info; 69 struct acpi_bit_register_info *sleep_enable_reg_info; 70 u32 pm1a_control; 71 u32 pm1b_control; 72 u32 in_value; 73 acpi_status status; 74 75 ACPI_FUNCTION_TRACE(hw_legacy_sleep); 76 77 sleep_type_reg_info = 78 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE); 79 sleep_enable_reg_info = 80 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE); 81 82 /* Clear wake status */ 83 84 status = 85 acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, ACPI_CLEAR_STATUS); 86 if (ACPI_FAILURE(status)) { 87 return_ACPI_STATUS(status); 88 } 89 90 /* Clear all fixed and general purpose status bits */ 91 92 status = acpi_hw_clear_acpi_status(); 93 if (ACPI_FAILURE(status)) { 94 return_ACPI_STATUS(status); 95 } 96 97 /* 98 * 1) Disable/Clear all GPEs 99 * 2) Enable all wakeup GPEs 100 */ 101 status = acpi_hw_disable_all_gpes(); 102 if (ACPI_FAILURE(status)) { 103 return_ACPI_STATUS(status); 104 } 105 acpi_gbl_system_awake_and_running = FALSE; 106 107 status = acpi_hw_enable_all_wakeup_gpes(); 108 if (ACPI_FAILURE(status)) { 109 return_ACPI_STATUS(status); 110 } 111 112 /* Get current value of PM1A control */ 113 114 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, 115 &pm1a_control); 116 if (ACPI_FAILURE(status)) { 117 return_ACPI_STATUS(status); 118 } 119 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 120 "Entering sleep state [S%u]\n", sleep_state)); 121 122 /* Clear the SLP_EN and SLP_TYP fields */ 123 124 pm1a_control &= ~(sleep_type_reg_info->access_bit_mask | 125 sleep_enable_reg_info->access_bit_mask); 126 pm1b_control = pm1a_control; 127 128 /* Insert the SLP_TYP bits */ 129 130 pm1a_control |= 131 (acpi_gbl_sleep_type_a << sleep_type_reg_info->bit_position); 132 pm1b_control |= 133 (acpi_gbl_sleep_type_b << sleep_type_reg_info->bit_position); 134 135 /* 136 * We split the writes of SLP_TYP and SLP_EN to workaround 137 * poorly implemented hardware. 138 */ 139 140 /* Write #1: write the SLP_TYP data to the PM1 Control registers */ 141 142 status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control); 143 if (ACPI_FAILURE(status)) { 144 return_ACPI_STATUS(status); 145 } 146 147 /* Insert the sleep enable (SLP_EN) bit */ 148 149 pm1a_control |= sleep_enable_reg_info->access_bit_mask; 150 pm1b_control |= sleep_enable_reg_info->access_bit_mask; 151 152 /* Flush caches, as per ACPI specification */ 153 154 ACPI_FLUSH_CPU_CACHE(); 155 156 status = acpi_os_prepare_sleep(sleep_state, pm1a_control, 157 pm1b_control); 158 if (ACPI_SKIP(status)) 159 return_ACPI_STATUS(AE_OK); 160 if (ACPI_FAILURE(status)) 161 return_ACPI_STATUS(status); 162 /* Write #2: Write both SLP_TYP + SLP_EN */ 163 164 status = acpi_hw_write_pm1_control(pm1a_control, pm1b_control); 165 if (ACPI_FAILURE(status)) { 166 return_ACPI_STATUS(status); 167 } 168 169 if (sleep_state > ACPI_STATE_S3) { 170 /* 171 * We wanted to sleep > S3, but it didn't happen (by virtue of the 172 * fact that we are still executing!) 173 * 174 * Wait ten seconds, then try again. This is to get S4/S5 to work on 175 * all machines. 176 * 177 * We wait so long to allow chipsets that poll this reg very slowly 178 * to still read the right value. Ideally, this block would go 179 * away entirely. 180 */ 181 acpi_os_stall(10000000); 182 183 status = acpi_hw_register_write(ACPI_REGISTER_PM1_CONTROL, 184 sleep_enable_reg_info-> 185 access_bit_mask); 186 if (ACPI_FAILURE(status)) { 187 return_ACPI_STATUS(status); 188 } 189 } 190 191 /* Wait for transition back to Working State */ 192 193 do { 194 status = 195 acpi_read_bit_register(ACPI_BITREG_WAKE_STATUS, &in_value); 196 if (ACPI_FAILURE(status)) { 197 return_ACPI_STATUS(status); 198 } 199 200 } while (!in_value); 201 202 return_ACPI_STATUS(AE_OK); 203 } 204 205 /******************************************************************************* 206 * 207 * FUNCTION: acpi_hw_legacy_wake_prep 208 * 209 * PARAMETERS: sleep_state - Which sleep state we just exited 210 * 211 * RETURN: Status 212 * 213 * DESCRIPTION: Perform the first state of OS-independent ACPI cleanup after a 214 * sleep. 215 * Called with interrupts ENABLED. 216 * 217 ******************************************************************************/ 218 219 acpi_status acpi_hw_legacy_wake_prep(u8 sleep_state) 220 { 221 acpi_status status; 222 struct acpi_bit_register_info *sleep_type_reg_info; 223 struct acpi_bit_register_info *sleep_enable_reg_info; 224 u32 pm1a_control; 225 u32 pm1b_control; 226 227 ACPI_FUNCTION_TRACE(hw_legacy_wake_prep); 228 229 /* 230 * Set SLP_TYPE and SLP_EN to state S0. 231 * This is unclear from the ACPI Spec, but it is required 232 * by some machines. 233 */ 234 status = acpi_get_sleep_type_data(ACPI_STATE_S0, 235 &acpi_gbl_sleep_type_a, 236 &acpi_gbl_sleep_type_b); 237 if (ACPI_SUCCESS(status)) { 238 sleep_type_reg_info = 239 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_TYPE); 240 sleep_enable_reg_info = 241 acpi_hw_get_bit_register_info(ACPI_BITREG_SLEEP_ENABLE); 242 243 /* Get current value of PM1A control */ 244 245 status = acpi_hw_register_read(ACPI_REGISTER_PM1_CONTROL, 246 &pm1a_control); 247 if (ACPI_SUCCESS(status)) { 248 249 /* Clear the SLP_EN and SLP_TYP fields */ 250 251 pm1a_control &= ~(sleep_type_reg_info->access_bit_mask | 252 sleep_enable_reg_info-> 253 access_bit_mask); 254 pm1b_control = pm1a_control; 255 256 /* Insert the SLP_TYP bits */ 257 258 pm1a_control |= (acpi_gbl_sleep_type_a << 259 sleep_type_reg_info->bit_position); 260 pm1b_control |= (acpi_gbl_sleep_type_b << 261 sleep_type_reg_info->bit_position); 262 263 /* Write the control registers and ignore any errors */ 264 265 (void)acpi_hw_write_pm1_control(pm1a_control, 266 pm1b_control); 267 } 268 } 269 270 return_ACPI_STATUS(status); 271 } 272 273 /******************************************************************************* 274 * 275 * FUNCTION: acpi_hw_legacy_wake 276 * 277 * PARAMETERS: sleep_state - Which sleep state we just exited 278 * 279 * RETURN: Status 280 * 281 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 282 * Called with interrupts ENABLED. 283 * 284 ******************************************************************************/ 285 286 acpi_status acpi_hw_legacy_wake(u8 sleep_state) 287 { 288 acpi_status status; 289 290 ACPI_FUNCTION_TRACE(hw_legacy_wake); 291 292 /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */ 293 294 acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID; 295 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WAKING); 296 297 /* 298 * GPEs must be enabled before _WAK is called as GPEs 299 * might get fired there 300 * 301 * Restore the GPEs: 302 * 1) Disable/Clear all GPEs 303 * 2) Enable all runtime GPEs 304 */ 305 status = acpi_hw_disable_all_gpes(); 306 if (ACPI_FAILURE(status)) { 307 return_ACPI_STATUS(status); 308 } 309 310 status = acpi_hw_enable_all_runtime_gpes(); 311 if (ACPI_FAILURE(status)) { 312 return_ACPI_STATUS(status); 313 } 314 315 /* 316 * Now we can execute _WAK, etc. Some machines require that the GPEs 317 * are enabled before the wake methods are executed. 318 */ 319 acpi_hw_execute_sleep_method(METHOD_PATHNAME__WAK, sleep_state); 320 321 /* 322 * Some BIOS code assumes that WAK_STS will be cleared on resume 323 * and use it to determine whether the system is rebooting or 324 * resuming. Clear WAK_STS for compatibility. 325 */ 326 acpi_write_bit_register(ACPI_BITREG_WAKE_STATUS, 1); 327 acpi_gbl_system_awake_and_running = TRUE; 328 329 /* Enable power button */ 330 331 (void) 332 acpi_write_bit_register(acpi_gbl_fixed_event_info 333 [ACPI_EVENT_POWER_BUTTON]. 334 enable_register_id, ACPI_ENABLE_EVENT); 335 336 (void) 337 acpi_write_bit_register(acpi_gbl_fixed_event_info 338 [ACPI_EVENT_POWER_BUTTON]. 339 status_register_id, ACPI_CLEAR_STATUS); 340 341 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING); 342 return_ACPI_STATUS(status); 343 } 344 345 #endif /* !ACPI_REDUCED_HARDWARE */ 346