1 2 /****************************************************************************** 3 * 4 * Module Name: exsystem - Interface to OS services 5 * 6 *****************************************************************************/ 7 8 /* 9 * Copyright (C) 2000 - 2011, 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 #define __EXSYSTEM_C__ 46 47 #include "acpi.h" 48 #include "accommon.h" 49 #include "acinterp.h" 50 51 #define _COMPONENT ACPI_EXECUTER 52 ACPI_MODULE_NAME ("exsystem") 53 54 55 /******************************************************************************* 56 * 57 * FUNCTION: AcpiExSystemWaitSemaphore 58 * 59 * PARAMETERS: Semaphore - Semaphore to wait on 60 * Timeout - Max time to wait 61 * 62 * RETURN: Status 63 * 64 * DESCRIPTION: Implements a semaphore wait with a check to see if the 65 * semaphore is available immediately. If it is not, the 66 * interpreter is released before waiting. 67 * 68 ******************************************************************************/ 69 70 ACPI_STATUS 71 AcpiExSystemWaitSemaphore ( 72 ACPI_SEMAPHORE Semaphore, 73 UINT16 Timeout) 74 { 75 ACPI_STATUS Status; 76 77 78 ACPI_FUNCTION_TRACE (ExSystemWaitSemaphore); 79 80 81 Status = AcpiOsWaitSemaphore (Semaphore, 1, ACPI_DO_NOT_WAIT); 82 if (ACPI_SUCCESS (Status)) 83 { 84 return_ACPI_STATUS (Status); 85 } 86 87 if (Status == AE_TIME) 88 { 89 /* We must wait, so unlock the interpreter */ 90 91 AcpiExRelinquishInterpreter (); 92 93 Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout); 94 95 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 96 "*** Thread awake after blocking, %s\n", 97 AcpiFormatException (Status))); 98 99 /* Reacquire the interpreter */ 100 101 AcpiExReacquireInterpreter (); 102 } 103 104 return_ACPI_STATUS (Status); 105 } 106 107 108 /******************************************************************************* 109 * 110 * FUNCTION: AcpiExSystemWaitMutex 111 * 112 * PARAMETERS: Mutex - Mutex to wait on 113 * Timeout - Max time to wait 114 * 115 * RETURN: Status 116 * 117 * DESCRIPTION: Implements a mutex wait with a check to see if the 118 * mutex is available immediately. If it is not, the 119 * interpreter is released before waiting. 120 * 121 ******************************************************************************/ 122 123 ACPI_STATUS 124 AcpiExSystemWaitMutex ( 125 ACPI_MUTEX Mutex, 126 UINT16 Timeout) 127 { 128 ACPI_STATUS Status; 129 130 131 ACPI_FUNCTION_TRACE (ExSystemWaitMutex); 132 133 134 Status = AcpiOsAcquireMutex (Mutex, ACPI_DO_NOT_WAIT); 135 if (ACPI_SUCCESS (Status)) 136 { 137 return_ACPI_STATUS (Status); 138 } 139 140 if (Status == AE_TIME) 141 { 142 /* We must wait, so unlock the interpreter */ 143 144 AcpiExRelinquishInterpreter (); 145 146 Status = AcpiOsAcquireMutex (Mutex, Timeout); 147 148 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, 149 "*** Thread awake after blocking, %s\n", 150 AcpiFormatException (Status))); 151 152 /* Reacquire the interpreter */ 153 154 AcpiExReacquireInterpreter (); 155 } 156 157 return_ACPI_STATUS (Status); 158 } 159 160 161 /******************************************************************************* 162 * 163 * FUNCTION: AcpiExSystemDoStall 164 * 165 * PARAMETERS: HowLong - The amount of time to stall, 166 * in microseconds 167 * 168 * RETURN: Status 169 * 170 * DESCRIPTION: Suspend running thread for specified amount of time. 171 * Note: ACPI specification requires that Stall() does not 172 * relinquish the processor, and delays longer than 100 usec 173 * should use Sleep() instead. We allow stalls up to 255 usec 174 * for compatibility with other interpreters and existing BIOSs. 175 * 176 ******************************************************************************/ 177 178 ACPI_STATUS 179 AcpiExSystemDoStall ( 180 UINT32 HowLong) 181 { 182 ACPI_STATUS Status = AE_OK; 183 184 185 ACPI_FUNCTION_ENTRY (); 186 187 188 if (HowLong > 255) /* 255 microseconds */ 189 { 190 /* 191 * Longer than 255 usec, this is an error 192 * 193 * (ACPI specifies 100 usec as max, but this gives some slack in 194 * order to support existing BIOSs) 195 */ 196 ACPI_ERROR ((AE_INFO, "Time parameter is too large (%u)", 197 HowLong)); 198 Status = AE_AML_OPERAND_VALUE; 199 } 200 else 201 { 202 AcpiOsStall (HowLong); 203 } 204 205 return (Status); 206 } 207 208 209 /******************************************************************************* 210 * 211 * FUNCTION: AcpiExSystemDoSleep 212 * 213 * PARAMETERS: HowLong - The amount of time to sleep, 214 * in milliseconds 215 * 216 * RETURN: None 217 * 218 * DESCRIPTION: Sleep the running thread for specified amount of time. 219 * 220 ******************************************************************************/ 221 222 ACPI_STATUS 223 AcpiExSystemDoSleep ( 224 UINT64 HowLong) 225 { 226 ACPI_FUNCTION_ENTRY (); 227 228 229 /* Since this thread will sleep, we must release the interpreter */ 230 231 AcpiExRelinquishInterpreter (); 232 233 /* 234 * For compatibility with other ACPI implementations and to prevent 235 * accidental deep sleeps, limit the sleep time to something reasonable. 236 */ 237 if (HowLong > ACPI_MAX_SLEEP) 238 { 239 HowLong = ACPI_MAX_SLEEP; 240 } 241 242 AcpiOsSleep (HowLong); 243 244 /* And now we must get the interpreter again */ 245 246 AcpiExReacquireInterpreter (); 247 return (AE_OK); 248 } 249 250 251 /******************************************************************************* 252 * 253 * FUNCTION: AcpiExSystemSignalEvent 254 * 255 * PARAMETERS: ObjDesc - The object descriptor for this op 256 * 257 * RETURN: Status 258 * 259 * DESCRIPTION: Provides an access point to perform synchronization operations 260 * within the AML. 261 * 262 ******************************************************************************/ 263 264 ACPI_STATUS 265 AcpiExSystemSignalEvent ( 266 ACPI_OPERAND_OBJECT *ObjDesc) 267 { 268 ACPI_STATUS Status = AE_OK; 269 270 271 ACPI_FUNCTION_TRACE (ExSystemSignalEvent); 272 273 274 if (ObjDesc) 275 { 276 Status = AcpiOsSignalSemaphore (ObjDesc->Event.OsSemaphore, 1); 277 } 278 279 return_ACPI_STATUS (Status); 280 } 281 282 283 /******************************************************************************* 284 * 285 * FUNCTION: AcpiExSystemWaitEvent 286 * 287 * PARAMETERS: TimeDesc - The 'time to delay' object descriptor 288 * ObjDesc - The object descriptor for this op 289 * 290 * RETURN: Status 291 * 292 * DESCRIPTION: Provides an access point to perform synchronization operations 293 * within the AML. This operation is a request to wait for an 294 * event. 295 * 296 ******************************************************************************/ 297 298 ACPI_STATUS 299 AcpiExSystemWaitEvent ( 300 ACPI_OPERAND_OBJECT *TimeDesc, 301 ACPI_OPERAND_OBJECT *ObjDesc) 302 { 303 ACPI_STATUS Status = AE_OK; 304 305 306 ACPI_FUNCTION_TRACE (ExSystemWaitEvent); 307 308 309 if (ObjDesc) 310 { 311 Status = AcpiExSystemWaitSemaphore (ObjDesc->Event.OsSemaphore, 312 (UINT16) TimeDesc->Integer.Value); 313 } 314 315 return_ACPI_STATUS (Status); 316 } 317 318 319 /******************************************************************************* 320 * 321 * FUNCTION: AcpiExSystemResetEvent 322 * 323 * PARAMETERS: ObjDesc - The object descriptor for this op 324 * 325 * RETURN: Status 326 * 327 * DESCRIPTION: Reset an event to a known state. 328 * 329 ******************************************************************************/ 330 331 ACPI_STATUS 332 AcpiExSystemResetEvent ( 333 ACPI_OPERAND_OBJECT *ObjDesc) 334 { 335 ACPI_STATUS Status = AE_OK; 336 ACPI_SEMAPHORE TempSemaphore; 337 338 339 ACPI_FUNCTION_ENTRY (); 340 341 342 /* 343 * We are going to simply delete the existing semaphore and 344 * create a new one! 345 */ 346 Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0, &TempSemaphore); 347 if (ACPI_SUCCESS (Status)) 348 { 349 (void) AcpiOsDeleteSemaphore (ObjDesc->Event.OsSemaphore); 350 ObjDesc->Event.OsSemaphore = TempSemaphore; 351 } 352 353 return (Status); 354 } 355 356