sys/contrib/dev/acpica/exsystem.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exsystem - Interface to OS services
   5  *              $Revision: 1.93 $
   6  *
   7  *****************************************************************************/
   8
   9 /******************************************************************************
  10  *
  11  * 1. Copyright Notice
  12  *
  13  * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp.
  14  * All rights reserved.
  15  *
  16  * 2. License
  17  *
  18  * 2.1. This is your license from Intel Corp. under its intellectual property
  19  * rights.  You may have additional license terms from the party that provided
  20  * you this software, covering your right to use that party's intellectual
  21  * property rights.
  22  *
  23  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24  * copy of the source code appearing in this file ("Covered Code") an
  25  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27  * make derivatives, distribute, use and display any portion of the Covered
  28  * Code in any form, with the right to sublicense such rights; and
  29  *
  30  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31  * license (with the right to sublicense), under only those claims of Intel
  32  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33  * offer to sell, and import the Covered Code and derivative works thereof
  34  * solely to the minimum extent necessary to exercise the above copyright
  35  * license, and in no event shall the patent license extend to any additions
  36  * to or modifications of the Original Intel Code.  No other license or right
  37  * is granted directly or by implication, estoppel or otherwise;
  38  *
  39  * The above copyright and patent license is granted only if the following
  40  * conditions are met:
  41  *
  42  * 3. Conditions
  43  *
  44  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45  * Redistribution of source code of any substantial portion of the Covered
  46  * Code or modification with rights to further distribute source must include
  47  * the above Copyright Notice, the above License, this list of Conditions,
  48  * and the following Disclaimer and Export Compliance provision.  In addition,
  49  * Licensee must cause all Covered Code to which Licensee contributes to
  50  * contain a file documenting the changes Licensee made to create that Covered
  51  * Code and the date of any change.  Licensee must include in that file the
  52  * documentation of any changes made by any predecessor Licensee.  Licensee
  53  * must include a prominent statement that the modification is derived,
  54  * directly or indirectly, from Original Intel Code.
  55  *
  56  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57  * Redistribution of source code of any substantial portion of the Covered
  58  * Code or modification without rights to further distribute source must
  59  * include the following Disclaimer and Export Compliance provision in the
  60  * documentation and/or other materials provided with distribution.  In
  61  * addition, Licensee may not authorize further sublicense of source of any
  62  * portion of the Covered Code, and must include terms to the effect that the
  63  * license from Licensee to its licensee is limited to the intellectual
  64  * property embodied in the software Licensee provides to its licensee, and
  65  * not to intellectual property embodied in modifications its licensee may
  66  * make.
  67  *
  68  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69  * substantial portion of the Covered Code or modification must reproduce the
  70  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71  * provision in the documentation and/or other materials provided with the
  72  * distribution.
  73  *
  74  * 3.4. Intel retains all right, title, and interest in and to the Original
  75  * Intel Code.
  76  *
  77  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79  * other dealings in products derived from or relating to the Covered Code
  80  * without prior written authorization from Intel.
  81  *
  82  * 4. Disclaimer and Export Compliance
  83  *
  84  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90  * PARTICULAR PURPOSE.
  91  *
  92  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99  * LIMITED REMEDY.
 100  *
 101  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 102  * software or system incorporating such software without first obtaining any
 103  * required license or other approval from the U. S. Department of Commerce or
 104  * any other agency or department of the United States Government.  In the
 105  * event Licensee exports any such software from the United States or
 106  * re-exports any such software from a foreign destination, Licensee shall
 107  * ensure that the distribution and export/re-export of the software is in
 108  * compliance with all laws, regulations, orders, or other restrictions of the
 109  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 110  * any of its subsidiaries will export/re-export any technical data, process,
 111  * software, or service, directly or indirectly, to any country for which the
 112  * United States government or any agency thereof requires an export license,
 113  * other governmental approval, or letter of assurance, without first obtaining
 114  * such license, approval or letter.
 115  *
 116  *****************************************************************************/
 117
 118 #define __EXSYSTEM_C__
 119
 120 #include <contrib/dev/acpica/acpi.h>
 121 #include <contrib/dev/acpica/acinterp.h>
 122 #include <contrib/dev/acpica/acevents.h>
 123
 124 #define _COMPONENT          ACPI_EXECUTER
 125         ACPI_MODULE_NAME    ("exsystem")
 126
 127
 128 /*******************************************************************************
 129  *
 130  * FUNCTION:    AcpiExSystemWaitSemaphore
 131  *
 132  * PARAMETERS:  Semaphore       - Semaphore to wait on
 133  *              Timeout         - Max time to wait
 134  *
 135  * RETURN:      Status
 136  *
 137  * DESCRIPTION: Implements a semaphore wait with a check to see if the
 138  *              semaphore is available immediately.  If it is not, the
 139  *              interpreter is released before waiting.
 140  *
 141  ******************************************************************************/
 142
 143 ACPI_STATUS
 144 AcpiExSystemWaitSemaphore (
 145     ACPI_SEMAPHORE          Semaphore,
 146     UINT16                  Timeout)
 147 {
 148     ACPI_STATUS             Status;
 149
 150
 151     ACPI_FUNCTION_TRACE (ExSystemWaitSemaphore);
 152
 153
 154     Status = AcpiOsWaitSemaphore (Semaphore, 1, ACPI_DO_NOT_WAIT);
 155     if (ACPI_SUCCESS (Status))
 156     {
 157         return_ACPI_STATUS (Status);
 158     }
 159
 160     if (Status == AE_TIME)
 161     {
 162         /* We must wait, so unlock the interpreter */
 163
 164         AcpiExRelinquishInterpreter ();
 165
 166         Status = AcpiOsWaitSemaphore (Semaphore, 1, Timeout);
 167
 168         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 169             "*** Thread awake after blocking, %s\n",
 170             AcpiFormatException (Status)));
 171
 172         /* Reacquire the interpreter */
 173
 174        AcpiExReacquireInterpreter ();
 175     }
 176
 177     return_ACPI_STATUS (Status);
 178 }
 179
 180
 181 /*******************************************************************************
 182  *
 183  * FUNCTION:    AcpiExSystemWaitMutex
 184  *
 185  * PARAMETERS:  Mutex           - Mutex to wait on
 186  *              Timeout         - Max time to wait
 187  *
 188  * RETURN:      Status
 189  *
 190  * DESCRIPTION: Implements a mutex wait with a check to see if the
 191  *              mutex is available immediately.  If it is not, the
 192  *              interpreter is released before waiting.
 193  *
 194  ******************************************************************************/
 195
 196 ACPI_STATUS
 197 AcpiExSystemWaitMutex (
 198     ACPI_MUTEX              Mutex,
 199     UINT16                  Timeout)
 200 {
 201     ACPI_STATUS             Status;
 202
 203
 204     ACPI_FUNCTION_TRACE (ExSystemWaitMutex);
 205
 206
 207     Status = AcpiOsAcquireMutex (Mutex, ACPI_DO_NOT_WAIT);
 208     if (ACPI_SUCCESS (Status))
 209     {
 210         return_ACPI_STATUS (Status);
 211     }
 212
 213     if (Status == AE_TIME)
 214     {
 215         /* We must wait, so unlock the interpreter */
 216
 217         AcpiExRelinquishInterpreter ();
 218
 219         Status = AcpiOsAcquireMutex (Mutex, Timeout);
 220
 221         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 222             "*** Thread awake after blocking, %s\n",
 223             AcpiFormatException (Status)));
 224
 225         /* Reacquire the interpreter */
 226
 227         AcpiExReacquireInterpreter ();
 228     }
 229
 230     return_ACPI_STATUS (Status);
 231 }
 232
 233
 234 /*******************************************************************************
 235  *
 236  * FUNCTION:    AcpiExSystemDoStall
 237  *
 238  * PARAMETERS:  HowLong         - The amount of time to stall,
 239  *                                in microseconds
 240  *
 241  * RETURN:      Status
 242  *
 243  * DESCRIPTION: Suspend running thread for specified amount of time.
 244  *              Note: ACPI specification requires that Stall() does not
 245  *              relinquish the processor, and delays longer than 100 usec
 246  *              should use Sleep() instead.  We allow stalls up to 255 usec
 247  *              for compatibility with other interpreters and existing BIOSs.
 248  *
 249  ******************************************************************************/
 250
 251 ACPI_STATUS
 252 AcpiExSystemDoStall (
 253     UINT32                  HowLong)
 254 {
 255     ACPI_STATUS             Status = AE_OK;
 256
 257
 258     ACPI_FUNCTION_ENTRY ();
 259
 260
 261     if (HowLong > 255) /* 255 microseconds */
 262     {
 263         /*
 264          * Longer than 255 usec, this is an error
 265          *
 266          * (ACPI specifies 100 usec as max, but this gives some slack in
 267          * order to support existing BIOSs)
 268          */
 269         ACPI_ERROR ((AE_INFO, "Time parameter is too large (%d)",
 270             HowLong));
 271         Status = AE_AML_OPERAND_VALUE;
 272     }
 273     else
 274     {
 275         AcpiOsStall (HowLong);
 276     }
 277
 278     return (Status);
 279 }
 280
 281
 282 /*******************************************************************************
 283  *
 284  * FUNCTION:    AcpiExSystemDoSuspend
 285  *
 286  * PARAMETERS:  HowLong         - The amount of time to suspend,
 287  *                                in milliseconds
 288  *
 289  * RETURN:      None
 290  *
 291  * DESCRIPTION: Suspend running thread for specified amount of time.
 292  *
 293  ******************************************************************************/
 294
 295 ACPI_STATUS
 296 AcpiExSystemDoSuspend (
 297     ACPI_INTEGER            HowLong)
 298 {
 299     ACPI_FUNCTION_ENTRY ();
 300
 301
 302     /* Since this thread will sleep, we must release the interpreter */
 303
 304     AcpiExRelinquishInterpreter ();
 305
 306     AcpiOsSleep (HowLong);
 307
 308     /* And now we must get the interpreter again */
 309
 310     AcpiExReacquireInterpreter ();
 311     return (AE_OK);
 312 }
 313
 314
 315 /*******************************************************************************
 316  *
 317  * FUNCTION:    AcpiExSystemSignalEvent
 318  *
 319  * PARAMETERS:  ObjDesc         - The object descriptor for this op
 320  *
 321  * RETURN:      Status
 322  *
 323  * DESCRIPTION: Provides an access point to perform synchronization operations
 324  *              within the AML.
 325  *
 326  ******************************************************************************/
 327
 328 ACPI_STATUS
 329 AcpiExSystemSignalEvent (
 330     ACPI_OPERAND_OBJECT     *ObjDesc)
 331 {
 332     ACPI_STATUS             Status = AE_OK;
 333
 334
 335     ACPI_FUNCTION_TRACE (ExSystemSignalEvent);
 336
 337
 338     if (ObjDesc)
 339     {
 340         Status = AcpiOsSignalSemaphore (ObjDesc->Event.OsSemaphore, 1);
 341     }
 342
 343     return_ACPI_STATUS (Status);
 344 }
 345
 346
 347 /*******************************************************************************
 348  *
 349  * FUNCTION:    AcpiExSystemWaitEvent
 350  *
 351  * PARAMETERS:  TimeDesc        - The 'time to delay' object descriptor
 352  *              ObjDesc         - The object descriptor for this op
 353  *
 354  * RETURN:      Status
 355  *
 356  * DESCRIPTION: Provides an access point to perform synchronization operations
 357  *              within the AML.  This operation is a request to wait for an
 358  *              event.
 359  *
 360  ******************************************************************************/
 361
 362 ACPI_STATUS
 363 AcpiExSystemWaitEvent (
 364     ACPI_OPERAND_OBJECT     *TimeDesc,
 365     ACPI_OPERAND_OBJECT     *ObjDesc)
 366 {
 367     ACPI_STATUS             Status = AE_OK;
 368
 369
 370     ACPI_FUNCTION_TRACE (ExSystemWaitEvent);
 371
 372
 373     if (ObjDesc)
 374     {
 375         Status = AcpiExSystemWaitSemaphore (ObjDesc->Event.OsSemaphore,
 376                     (UINT16) TimeDesc->Integer.Value);
 377     }
 378
 379     return_ACPI_STATUS (Status);
 380 }
 381
 382
 383 /*******************************************************************************
 384  *
 385  * FUNCTION:    AcpiExSystemResetEvent
 386  *
 387  * PARAMETERS:  ObjDesc         - The object descriptor for this op
 388  *
 389  * RETURN:      Status
 390  *
 391  * DESCRIPTION: Reset an event to a known state.
 392  *
 393  ******************************************************************************/
 394
 395 ACPI_STATUS
 396 AcpiExSystemResetEvent (
 397     ACPI_OPERAND_OBJECT     *ObjDesc)
 398 {
 399     ACPI_STATUS             Status = AE_OK;
 400     ACPI_SEMAPHORE          TempSemaphore;
 401
 402
 403     ACPI_FUNCTION_ENTRY ();
 404
 405
 406     /*
 407      * We are going to simply delete the existing semaphore and
 408      * create a new one!
 409      */
 410     Status = AcpiOsCreateSemaphore (ACPI_NO_UNIT_LIMIT, 0, &TempSemaphore);
 411     if (ACPI_SUCCESS (Status))
 412     {
 413         (void) AcpiOsDeleteSemaphore (ObjDesc->Event.OsSemaphore);
 414         ObjDesc->Event.OsSemaphore = TempSemaphore;
 415     }
 416
 417     return (Status);
 418 }
 419