sys/contrib/dev/acpica/executer/exsystem.c

   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 <contrib/dev/acpica/include/acpi.h>
  48 #include <contrib/dev/acpica/include/accommon.h>
  49 #include <contrib/dev/acpica/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