1 /****************************************************************************** 2 * 3 * Name: hwesleep.c - ACPI Hardware Sleep/Wake Support functions for the 4 * extended FADT-V5 sleep 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 "accommon.h" 47 48 #define _COMPONENT ACPI_HARDWARE 49 ACPI_MODULE_NAME("hwesleep") 50 51 /******************************************************************************* 52 * 53 * FUNCTION: acpi_hw_execute_sleep_method 54 * 55 * PARAMETERS: method_pathname - Pathname of method to execute 56 * integer_argument - Argument to pass to the method 57 * 58 * RETURN: None 59 * 60 * DESCRIPTION: Execute a sleep/wake related method with one integer argument 61 * and no return value. 62 * 63 ******************************************************************************/ 64 void acpi_hw_execute_sleep_method(char *method_pathname, u32 integer_argument) 65 { 66 struct acpi_object_list arg_list; 67 union acpi_object arg; 68 acpi_status status; 69 70 ACPI_FUNCTION_TRACE(hw_execute_sleep_method); 71 72 /* One argument, integer_argument; No return value expected */ 73 74 arg_list.count = 1; 75 arg_list.pointer = &arg; 76 arg.type = ACPI_TYPE_INTEGER; 77 arg.integer.value = (u64)integer_argument; 78 79 status = acpi_evaluate_object(NULL, method_pathname, &arg_list, NULL); 80 if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { 81 ACPI_EXCEPTION((AE_INFO, status, "While executing method %s", 82 method_pathname)); 83 } 84 85 return_VOID; 86 } 87 88 /******************************************************************************* 89 * 90 * FUNCTION: acpi_hw_extended_sleep 91 * 92 * PARAMETERS: sleep_state - Which sleep state to enter 93 * Flags - ACPI_EXECUTE_GTS to run optional method 94 * 95 * RETURN: Status 96 * 97 * DESCRIPTION: Enter a system sleep state via the extended FADT sleep 98 * registers (V5 FADT). 99 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 100 * 101 ******************************************************************************/ 102 103 acpi_status acpi_hw_extended_sleep(u8 sleep_state, u8 flags) 104 { 105 acpi_status status; 106 u8 sleep_type_value; 107 u64 sleep_status; 108 109 ACPI_FUNCTION_TRACE(hw_extended_sleep); 110 111 /* Extended sleep registers must be valid */ 112 113 if (!acpi_gbl_FADT.sleep_control.address || 114 !acpi_gbl_FADT.sleep_status.address) { 115 return_ACPI_STATUS(AE_NOT_EXIST); 116 } 117 118 /* Clear wake status (WAK_STS) */ 119 120 status = acpi_write(ACPI_X_WAKE_STATUS, &acpi_gbl_FADT.sleep_status); 121 if (ACPI_FAILURE(status)) { 122 return_ACPI_STATUS(status); 123 } 124 125 acpi_gbl_system_awake_and_running = FALSE; 126 127 /* Optionally execute _GTS (Going To Sleep) */ 128 129 if (flags & ACPI_EXECUTE_GTS) { 130 acpi_hw_execute_sleep_method(METHOD_PATHNAME__GTS, sleep_state); 131 } 132 133 /* Flush caches, as per ACPI specification */ 134 135 ACPI_FLUSH_CPU_CACHE(); 136 137 /* 138 * Set the SLP_TYP and SLP_EN bits. 139 * 140 * Note: We only use the first value returned by the \_Sx method 141 * (acpi_gbl_sleep_type_a) - As per ACPI specification. 142 */ 143 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 144 "Entering sleep state [S%u]\n", sleep_state)); 145 146 sleep_type_value = 147 ((acpi_gbl_sleep_type_a << ACPI_X_SLEEP_TYPE_POSITION) & 148 ACPI_X_SLEEP_TYPE_MASK); 149 150 status = acpi_write((sleep_type_value | ACPI_X_SLEEP_ENABLE), 151 &acpi_gbl_FADT.sleep_control); 152 if (ACPI_FAILURE(status)) { 153 return_ACPI_STATUS(status); 154 } 155 156 /* Wait for transition back to Working State */ 157 158 do { 159 status = acpi_read(&sleep_status, &acpi_gbl_FADT.sleep_status); 160 if (ACPI_FAILURE(status)) { 161 return_ACPI_STATUS(status); 162 } 163 164 } while (!(((u8)sleep_status) & ACPI_X_WAKE_STATUS)); 165 166 return_ACPI_STATUS(AE_OK); 167 } 168 169 /******************************************************************************* 170 * 171 * FUNCTION: acpi_hw_extended_wake_prep 172 * 173 * PARAMETERS: sleep_state - Which sleep state we just exited 174 * Flags - ACPI_EXECUTE_BFS to run optional method 175 * 176 * RETURN: Status 177 * 178 * DESCRIPTION: Perform first part of OS-independent ACPI cleanup after 179 * a sleep. Called with interrupts ENABLED. 180 * 181 ******************************************************************************/ 182 183 acpi_status acpi_hw_extended_wake_prep(u8 sleep_state, u8 flags) 184 { 185 acpi_status status; 186 u8 sleep_type_value; 187 188 ACPI_FUNCTION_TRACE(hw_extended_wake_prep); 189 190 status = acpi_get_sleep_type_data(ACPI_STATE_S0, 191 &acpi_gbl_sleep_type_a, 192 &acpi_gbl_sleep_type_b); 193 if (ACPI_SUCCESS(status)) { 194 sleep_type_value = 195 ((acpi_gbl_sleep_type_a << ACPI_X_SLEEP_TYPE_POSITION) & 196 ACPI_X_SLEEP_TYPE_MASK); 197 198 (void)acpi_write((sleep_type_value | ACPI_X_SLEEP_ENABLE), 199 &acpi_gbl_FADT.sleep_control); 200 } 201 202 /* Optionally execute _BFS (Back From Sleep) */ 203 204 if (flags & ACPI_EXECUTE_BFS) { 205 acpi_hw_execute_sleep_method(METHOD_PATHNAME__BFS, sleep_state); 206 } 207 return_ACPI_STATUS(AE_OK); 208 } 209 210 /******************************************************************************* 211 * 212 * FUNCTION: acpi_hw_extended_wake 213 * 214 * PARAMETERS: sleep_state - Which sleep state we just exited 215 * Flags - Reserved, set to zero 216 * 217 * RETURN: Status 218 * 219 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 220 * Called with interrupts ENABLED. 221 * 222 ******************************************************************************/ 223 224 acpi_status acpi_hw_extended_wake(u8 sleep_state, u8 flags) 225 { 226 ACPI_FUNCTION_TRACE(hw_extended_wake); 227 228 /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */ 229 230 acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID; 231 232 /* Execute the wake methods */ 233 234 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WAKING); 235 acpi_hw_execute_sleep_method(METHOD_PATHNAME__WAK, sleep_state); 236 237 /* 238 * Some BIOS code assumes that WAK_STS will be cleared on resume 239 * and use it to determine whether the system is rebooting or 240 * resuming. Clear WAK_STS for compatibility. 241 */ 242 (void)acpi_write(ACPI_X_WAKE_STATUS, &acpi_gbl_FADT.sleep_status); 243 acpi_gbl_system_awake_and_running = TRUE; 244 245 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING); 246 return_ACPI_STATUS(AE_OK); 247 } 248