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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exutils - interpreter/scanner utilities
   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 __EXUTILS_C__
  46
  47 /*
  48  * DEFINE_AML_GLOBALS is tested in amlcode.h
  49  * to determine whether certain global names should be "defined" or only
  50  * "declared" in the current compilation.  This enhances maintainability
  51  * by enabling a single header file to embody all knowledge of the names
  52  * in question.
  53  *
  54  * Exactly one module of any executable should #define DEFINE_GLOBALS
  55  * before #including the header files which use this convention.  The
  56  * names in question will be defined and initialized in that module,
  57  * and declared as extern in all other modules which #include those
  58  * header files.
  59  */
  60
  61 #define DEFINE_AML_GLOBALS
  62
  63 #include <contrib/dev/acpica/include/acpi.h>
  64 #include <contrib/dev/acpica/include/accommon.h>
  65 #include <contrib/dev/acpica/include/acinterp.h>
  66 #include <contrib/dev/acpica/include/amlcode.h>
  67
  68 #define _COMPONENT          ACPI_EXECUTER
  69         ACPI_MODULE_NAME    ("exutils")
  70
  71 /* Local prototypes */
  72
  73 static UINT32
  74 AcpiExDigitsNeeded (
  75     UINT64                  Value,
  76     UINT32                  Base);
  77
  78
  79 #ifndef ACPI_NO_METHOD_EXECUTION
  80 /*******************************************************************************
  81  *
  82  * FUNCTION:    AcpiExEnterInterpreter
  83  *
  84  * PARAMETERS:  None
  85  *
  86  * RETURN:      None
  87  *
  88  * DESCRIPTION: Enter the interpreter execution region. Failure to enter
  89  *              the interpreter region is a fatal system error. Used in
  90  *              conjunction with ExitInterpreter.
  91  *
  92  ******************************************************************************/
  93
  94 void
  95 AcpiExEnterInterpreter (
  96     void)
  97 {
  98     ACPI_STATUS             Status;
  99
 100
 101     ACPI_FUNCTION_TRACE (ExEnterInterpreter);
 102
 103
 104     Status = AcpiUtAcquireMutex (ACPI_MTX_INTERPRETER);
 105     if (ACPI_FAILURE (Status))
 106     {
 107         ACPI_ERROR ((AE_INFO, "Could not acquire AML Interpreter mutex"));
 108     }
 109
 110     return_VOID;
 111 }
 112
 113
 114 /*******************************************************************************
 115  *
 116  * FUNCTION:    AcpiExReacquireInterpreter
 117  *
 118  * PARAMETERS:  None
 119  *
 120  * RETURN:      None
 121  *
 122  * DESCRIPTION: Reacquire the interpreter execution region from within the
 123  *              interpreter code. Failure to enter the interpreter region is a
 124  *              fatal system error. Used in  conjuction with
 125  *              RelinquishInterpreter
 126  *
 127  ******************************************************************************/
 128
 129 void
 130 AcpiExReacquireInterpreter (
 131     void)
 132 {
 133     ACPI_FUNCTION_TRACE (ExReacquireInterpreter);
 134
 135
 136     /*
 137      * If the global serialized flag is set, do not release the interpreter,
 138      * since it was not actually released by AcpiExRelinquishInterpreter.
 139      * This forces the interpreter to be single threaded.
 140      */
 141     if (!AcpiGbl_AllMethodsSerialized)
 142     {
 143         AcpiExEnterInterpreter ();
 144     }
 145
 146     return_VOID;
 147 }
 148
 149
 150 /*******************************************************************************
 151  *
 152  * FUNCTION:    AcpiExExitInterpreter
 153  *
 154  * PARAMETERS:  None
 155  *
 156  * RETURN:      None
 157  *
 158  * DESCRIPTION: Exit the interpreter execution region. This is the top level
 159  *              routine used to exit the interpreter when all processing has
 160  *              been completed.
 161  *
 162  ******************************************************************************/
 163
 164 void
 165 AcpiExExitInterpreter (
 166     void)
 167 {
 168     ACPI_STATUS             Status;
 169
 170
 171     ACPI_FUNCTION_TRACE (ExExitInterpreter);
 172
 173
 174     Status = AcpiUtReleaseMutex (ACPI_MTX_INTERPRETER);
 175     if (ACPI_FAILURE (Status))
 176     {
 177         ACPI_ERROR ((AE_INFO, "Could not release AML Interpreter mutex"));
 178     }
 179
 180     return_VOID;
 181 }
 182
 183
 184 /*******************************************************************************
 185  *
 186  * FUNCTION:    AcpiExRelinquishInterpreter
 187  *
 188  * PARAMETERS:  None
 189  *
 190  * RETURN:      None
 191  *
 192  * DESCRIPTION: Exit the interpreter execution region, from within the
 193  *              interpreter - before attempting an operation that will possibly
 194  *              block the running thread.
 195  *
 196  * Cases where the interpreter is unlocked internally
 197  *      1) Method to be blocked on a Sleep() AML opcode
 198  *      2) Method to be blocked on an Acquire() AML opcode
 199  *      3) Method to be blocked on a Wait() AML opcode
 200  *      4) Method to be blocked to acquire the global lock
 201  *      5) Method to be blocked waiting to execute a serialized control method
 202  *          that is currently executing
 203  *      6) About to invoke a user-installed opregion handler
 204  *
 205  ******************************************************************************/
 206
 207 void
 208 AcpiExRelinquishInterpreter (
 209     void)
 210 {
 211     ACPI_FUNCTION_TRACE (ExRelinquishInterpreter);
 212
 213
 214     /*
 215      * If the global serialized flag is set, do not release the interpreter.
 216      * This forces the interpreter to be single threaded.
 217      */
 218     if (!AcpiGbl_AllMethodsSerialized)
 219     {
 220         AcpiExExitInterpreter ();
 221     }
 222
 223     return_VOID;
 224 }
 225
 226
 227 /*******************************************************************************
 228  *
 229  * FUNCTION:    AcpiExTruncateFor32bitTable
 230  *
 231  * PARAMETERS:  ObjDesc         - Object to be truncated
 232  *
 233  * RETURN:      none
 234  *
 235  * DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
 236  *              32-bit, as determined by the revision of the DSDT.
 237  *
 238  ******************************************************************************/
 239
 240 void
 241 AcpiExTruncateFor32bitTable (
 242     ACPI_OPERAND_OBJECT     *ObjDesc)
 243 {
 244
 245     ACPI_FUNCTION_ENTRY ();
 246
 247
 248     /*
 249      * Object must be a valid number and we must be executing
 250      * a control method. NS node could be there for AML_INT_NAMEPATH_OP.
 251      */
 252     if ((!ObjDesc) ||
 253         (ACPI_GET_DESCRIPTOR_TYPE (ObjDesc) != ACPI_DESC_TYPE_OPERAND) ||
 254         (ObjDesc->Common.Type != ACPI_TYPE_INTEGER))
 255     {
 256         return;
 257     }
 258
 259     if (AcpiGbl_IntegerByteWidth == 4)
 260     {
 261         /*
 262          * We are running a method that exists in a 32-bit ACPI table.
 263          * Truncate the value to 32 bits by zeroing out the upper 32-bit field
 264          */
 265         ObjDesc->Integer.Value &= (UINT64) ACPI_UINT32_MAX;
 266     }
 267 }
 268
 269
 270 /*******************************************************************************
 271  *
 272  * FUNCTION:    AcpiExAcquireGlobalLock
 273  *
 274  * PARAMETERS:  FieldFlags            - Flags with Lock rule:
 275  *                                      AlwaysLock or NeverLock
 276  *
 277  * RETURN:      None
 278  *
 279  * DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
 280  *              flags specifiy that it is to be obtained before field access.
 281  *
 282  ******************************************************************************/
 283
 284 void
 285 AcpiExAcquireGlobalLock (
 286     UINT32                  FieldFlags)
 287 {
 288     ACPI_STATUS             Status;
 289
 290
 291     ACPI_FUNCTION_TRACE (ExAcquireGlobalLock);
 292
 293
 294     /* Only use the lock if the AlwaysLock bit is set */
 295
 296     if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
 297     {
 298         return_VOID;
 299     }
 300
 301     /* Attempt to get the global lock, wait forever */
 302
 303     Status = AcpiExAcquireMutexObject (ACPI_WAIT_FOREVER,
 304                 AcpiGbl_GlobalLockMutex, AcpiOsGetThreadId ());
 305
 306     if (ACPI_FAILURE (Status))
 307     {
 308         ACPI_EXCEPTION ((AE_INFO, Status,
 309             "Could not acquire Global Lock"));
 310     }
 311
 312     return_VOID;
 313 }
 314
 315
 316 /*******************************************************************************
 317  *
 318  * FUNCTION:    AcpiExReleaseGlobalLock
 319  *
 320  * PARAMETERS:  FieldFlags            - Flags with Lock rule:
 321  *                                      AlwaysLock or NeverLock
 322  *
 323  * RETURN:      None
 324  *
 325  * DESCRIPTION: Release the ACPI hardware Global Lock
 326  *
 327  ******************************************************************************/
 328
 329 void
 330 AcpiExReleaseGlobalLock (
 331     UINT32                  FieldFlags)
 332 {
 333     ACPI_STATUS             Status;
 334
 335
 336     ACPI_FUNCTION_TRACE (ExReleaseGlobalLock);
 337
 338
 339     /* Only use the lock if the AlwaysLock bit is set */
 340
 341     if (!(FieldFlags & AML_FIELD_LOCK_RULE_MASK))
 342     {
 343         return_VOID;
 344     }
 345
 346     /* Release the global lock */
 347
 348     Status = AcpiExReleaseMutexObject (AcpiGbl_GlobalLockMutex);
 349     if (ACPI_FAILURE (Status))
 350     {
 351         /* Report the error, but there isn't much else we can do */
 352
 353         ACPI_EXCEPTION ((AE_INFO, Status,
 354             "Could not release Global Lock"));
 355     }
 356
 357     return_VOID;
 358 }
 359
 360
 361 /*******************************************************************************
 362  *
 363  * FUNCTION:    AcpiExDigitsNeeded
 364  *
 365  * PARAMETERS:  Value           - Value to be represented
 366  *              Base            - Base of representation
 367  *
 368  * RETURN:      The number of digits.
 369  *
 370  * DESCRIPTION: Calculate the number of digits needed to represent the Value
 371  *              in the given Base (Radix)
 372  *
 373  ******************************************************************************/
 374
 375 static UINT32
 376 AcpiExDigitsNeeded (
 377     UINT64                  Value,
 378     UINT32                  Base)
 379 {
 380     UINT32                  NumDigits;
 381     UINT64                  CurrentValue;
 382
 383
 384     ACPI_FUNCTION_TRACE (ExDigitsNeeded);
 385
 386
 387     /* UINT64 is unsigned, so we don't worry about a '-' prefix */
 388
 389     if (Value == 0)
 390     {
 391         return_UINT32 (1);
 392     }
 393
 394     CurrentValue = Value;
 395     NumDigits = 0;
 396
 397     /* Count the digits in the requested base */
 398
 399     while (CurrentValue)
 400     {
 401         (void) AcpiUtShortDivide (CurrentValue, Base, &CurrentValue, NULL);
 402         NumDigits++;
 403     }
 404
 405     return_UINT32 (NumDigits);
 406 }
 407
 408
 409 /*******************************************************************************
 410  *
 411  * FUNCTION:    AcpiExEisaIdToString
 412  *
 413  * PARAMETERS:  CompressedId    - EISAID to be converted
 414  *              OutString       - Where to put the converted string (8 bytes)
 415  *
 416  * RETURN:      None
 417  *
 418  * DESCRIPTION: Convert a numeric EISAID to string representation. Return
 419  *              buffer must be large enough to hold the string. The string
 420  *              returned is always exactly of length ACPI_EISAID_STRING_SIZE
 421  *              (includes null terminator). The EISAID is always 32 bits.
 422  *
 423  ******************************************************************************/
 424
 425 void
 426 AcpiExEisaIdToString (
 427     char                    *OutString,
 428     UINT64                  CompressedId)
 429 {
 430     UINT32                  SwappedId;
 431
 432
 433     ACPI_FUNCTION_ENTRY ();
 434
 435
 436     /* The EISAID should be a 32-bit integer */
 437
 438     if (CompressedId > ACPI_UINT32_MAX)
 439     {
 440         ACPI_WARNING ((AE_INFO,
 441             "Expected EISAID is larger than 32 bits: 0x%8.8X%8.8X, truncating",
 442             ACPI_FORMAT_UINT64 (CompressedId)));
 443     }
 444
 445     /* Swap ID to big-endian to get contiguous bits */
 446
 447     SwappedId = AcpiUtDwordByteSwap ((UINT32) CompressedId);
 448
 449     /* First 3 bytes are uppercase letters. Next 4 bytes are hexadecimal */
 450
 451     OutString[0] = (char) (0x40 + (((unsigned long) SwappedId >> 26) & 0x1F));
 452     OutString[1] = (char) (0x40 + ((SwappedId >> 21) & 0x1F));
 453     OutString[2] = (char) (0x40 + ((SwappedId >> 16) & 0x1F));
 454     OutString[3] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 12);
 455     OutString[4] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 8);
 456     OutString[5] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 4);
 457     OutString[6] = AcpiUtHexToAsciiChar ((UINT64) SwappedId, 0);
 458     OutString[7] = 0;
 459 }
 460
 461
 462 /*******************************************************************************
 463  *
 464  * FUNCTION:    AcpiExIntegerToString
 465  *
 466  * PARAMETERS:  OutString       - Where to put the converted string. At least
 467  *                                21 bytes are needed to hold the largest
 468  *                                possible 64-bit integer.
 469  *              Value           - Value to be converted
 470  *
 471  * RETURN:      None, string
 472  *
 473  * DESCRIPTION: Convert a 64-bit integer to decimal string representation.
 474  *              Assumes string buffer is large enough to hold the string. The
 475  *              largest string is (ACPI_MAX64_DECIMAL_DIGITS + 1).
 476  *
 477  ******************************************************************************/
 478
 479 void
 480 AcpiExIntegerToString (
 481     char                    *OutString,
 482     UINT64                  Value)
 483 {
 484     UINT32                  Count;
 485     UINT32                  DigitsNeeded;
 486     UINT32                  Remainder;
 487
 488
 489     ACPI_FUNCTION_ENTRY ();
 490
 491
 492     DigitsNeeded = AcpiExDigitsNeeded (Value, 10);
 493     OutString[DigitsNeeded] = 0;
 494
 495     for (Count = DigitsNeeded; Count > 0; Count--)
 496     {
 497         (void) AcpiUtShortDivide (Value, 10, &Value, &Remainder);
 498         OutString[Count-1] = (char) ('0' + Remainder);\
 499     }
 500 }
 501
 502 #endif