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