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 - 2017, 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 * 94 * RETURN: Status 95 * 96 * DESCRIPTION: Enter a system sleep state via the extended FADT sleep 97 * registers (V5 FADT). 98 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED 99 * 100 ******************************************************************************/ 101 102 acpi_status acpi_hw_extended_sleep(u8 sleep_state) 103 { 104 acpi_status status; 105 u8 sleep_control; 106 u64 sleep_status; 107 108 ACPI_FUNCTION_TRACE(hw_extended_sleep); 109 110 /* Extended sleep registers must be valid */ 111 112 if (!acpi_gbl_FADT.sleep_control.address || 113 !acpi_gbl_FADT.sleep_status.address) { 114 return_ACPI_STATUS(AE_NOT_EXIST); 115 } 116 117 /* Clear wake status (WAK_STS) */ 118 119 status = acpi_write((u64)ACPI_X_WAKE_STATUS, 120 &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 /* 128 * Set the SLP_TYP and SLP_EN bits. 129 * 130 * Note: We only use the first value returned by the \_Sx method 131 * (acpi_gbl_sleep_type_a) - As per ACPI specification. 132 */ 133 ACPI_DEBUG_PRINT((ACPI_DB_INIT, 134 "Entering sleep state [S%u]\n", sleep_state)); 135 136 sleep_control = ((acpi_gbl_sleep_type_a << ACPI_X_SLEEP_TYPE_POSITION) & 137 ACPI_X_SLEEP_TYPE_MASK) | ACPI_X_SLEEP_ENABLE; 138 139 /* Flush caches, as per ACPI specification */ 140 141 ACPI_FLUSH_CPU_CACHE(); 142 143 status = acpi_os_enter_sleep(sleep_state, sleep_control, 0); 144 if (status == AE_CTRL_TERMINATE) { 145 return_ACPI_STATUS(AE_OK); 146 } 147 if (ACPI_FAILURE(status)) { 148 return_ACPI_STATUS(status); 149 } 150 151 status = acpi_write((u64)sleep_control, &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 * 175 * RETURN: Status 176 * 177 * DESCRIPTION: Perform first part of OS-independent ACPI cleanup after 178 * a sleep. Called with interrupts ENABLED. 179 * 180 ******************************************************************************/ 181 182 acpi_status acpi_hw_extended_wake_prep(u8 sleep_state) 183 { 184 acpi_status status; 185 u8 sleep_type_value; 186 187 ACPI_FUNCTION_TRACE(hw_extended_wake_prep); 188 189 status = acpi_get_sleep_type_data(ACPI_STATE_S0, 190 &acpi_gbl_sleep_type_a, 191 &acpi_gbl_sleep_type_b); 192 if (ACPI_SUCCESS(status)) { 193 sleep_type_value = 194 ((acpi_gbl_sleep_type_a << ACPI_X_SLEEP_TYPE_POSITION) & 195 ACPI_X_SLEEP_TYPE_MASK); 196 197 (void)acpi_write((u64)(sleep_type_value | ACPI_X_SLEEP_ENABLE), 198 &acpi_gbl_FADT.sleep_control); 199 } 200 201 return_ACPI_STATUS(AE_OK); 202 } 203 204 /******************************************************************************* 205 * 206 * FUNCTION: acpi_hw_extended_wake 207 * 208 * PARAMETERS: sleep_state - Which sleep state we just exited 209 * 210 * RETURN: Status 211 * 212 * DESCRIPTION: Perform OS-independent ACPI cleanup after a sleep 213 * Called with interrupts ENABLED. 214 * 215 ******************************************************************************/ 216 217 acpi_status acpi_hw_extended_wake(u8 sleep_state) 218 { 219 ACPI_FUNCTION_TRACE(hw_extended_wake); 220 221 /* Ensure enter_sleep_state_prep -> enter_sleep_state ordering */ 222 223 acpi_gbl_sleep_type_a = ACPI_SLEEP_TYPE_INVALID; 224 225 /* Execute the wake methods */ 226 227 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WAKING); 228 acpi_hw_execute_sleep_method(METHOD_PATHNAME__WAK, sleep_state); 229 230 /* 231 * Some BIOS code assumes that WAK_STS will be cleared on resume 232 * and use it to determine whether the system is rebooting or 233 * resuming. Clear WAK_STS for compatibility. 234 */ 235 (void)acpi_write((u64)ACPI_X_WAKE_STATUS, &acpi_gbl_FADT.sleep_status); 236 acpi_gbl_system_awake_and_running = TRUE; 237 238 acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING); 239 return_ACPI_STATUS(AE_OK); 240 } 241