sys/contrib/dev/acpica-unix-20050211/utilities/utmisc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utmisc - common utility procedures
   4  *              $Revision: 105 $
   5  *
   6  ******************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #define __UTMISC_C__
 119
 120 #include "acpi.h"
 121 #include "acnamesp.h"
 122
 123
 124 #define _COMPONENT          ACPI_UTILITIES
 125         ACPI_MODULE_NAME    ("utmisc")
 126
 127
 128 /*******************************************************************************
 129  *
 130  * FUNCTION:    AcpiUtPrintString
 131  *
 132  * PARAMETERS:  String          - Null terminated ASCII string
 133  *
 134  * RETURN:      None
 135  *
 136  * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
 137  *              sequences.
 138  *
 139  ******************************************************************************/
 140
 141 void
 142 AcpiUtPrintString (
 143     char                    *String,
 144     UINT8                   MaxLength)
 145 {
 146     UINT32                  i;
 147
 148
 149     if (!String)
 150     {
 151         AcpiOsPrintf ("<\"NULL STRING PTR\">");
 152         return;
 153     }
 154
 155     AcpiOsPrintf ("\"");
 156     for (i = 0; String[i] && (i < MaxLength); i++)
 157     {
 158         /* Escape sequences */
 159
 160         switch (String[i])
 161         {
 162         case 0x07:
 163             AcpiOsPrintf ("\\a");        /* BELL */
 164             break;
 165
 166         case 0x08:
 167             AcpiOsPrintf ("\\b");       /* BACKSPACE */
 168             break;
 169
 170         case 0x0C:
 171             AcpiOsPrintf ("\\f");       /* FORMFEED */
 172             break;
 173
 174         case 0x0A:
 175             AcpiOsPrintf ("\\n");       /* LINEFEED */
 176             break;
 177
 178         case 0x0D:
 179             AcpiOsPrintf ("\\r");       /* CARRIAGE RETURN*/
 180             break;
 181
 182         case 0x09:
 183             AcpiOsPrintf ("\\t");       /* HORIZONTAL TAB */
 184             break;
 185
 186         case 0x0B:
 187             AcpiOsPrintf ("\\v");       /* VERTICAL TAB */
 188             break;
 189
 190         case '\'':                      /* Single Quote */
 191         case '\"':                      /* Double Quote */
 192         case '\\':                      /* Backslash */
 193             AcpiOsPrintf ("\\%c", (int) String[i]);
 194             break;
 195
 196         default:
 197
 198             /* Check for printable character or hex escape */
 199
 200             if (ACPI_IS_PRINT (String[i]))
 201             {
 202                 /* This is a normal character */
 203
 204                 AcpiOsPrintf ("%c", (int) String[i]);
 205             }
 206             else
 207             {
 208                 /* All others will be Hex escapes */
 209
 210                 AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]);
 211             }
 212             break;
 213         }
 214     }
 215     AcpiOsPrintf ("\"");
 216
 217     if (i == MaxLength && String[i])
 218     {
 219         AcpiOsPrintf ("...");
 220     }
 221 }
 222
 223
 224 /*******************************************************************************
 225  *
 226  * FUNCTION:    AcpiUtDwordByteSwap
 227  *
 228  * PARAMETERS:  Value           - Value to be converted
 229  *
 230  * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes)
 231  *
 232  ******************************************************************************/
 233
 234 UINT32
 235 AcpiUtDwordByteSwap (
 236     UINT32                  Value)
 237 {
 238     union
 239     {
 240         UINT32              Value;
 241         UINT8               Bytes[4];
 242     } Out;
 243
 244     union
 245     {
 246         UINT32              Value;
 247         UINT8               Bytes[4];
 248     } In;
 249
 250
 251     ACPI_FUNCTION_ENTRY ();
 252
 253
 254     In.Value = Value;
 255
 256     Out.Bytes[0] = In.Bytes[3];
 257     Out.Bytes[1] = In.Bytes[2];
 258     Out.Bytes[2] = In.Bytes[1];
 259     Out.Bytes[3] = In.Bytes[0];
 260
 261     return (Out.Value);
 262 }
 263
 264
 265 /*******************************************************************************
 266  *
 267  * FUNCTION:    AcpiUtSetIntegerWidth
 268  *
 269  * PARAMETERS:  Revision            From DSDT header
 270  *
 271  * RETURN:      None
 272  *
 273  * DESCRIPTION: Set the global integer bit width based upon the revision
 274  *              of the DSDT.  For Revision 1 and 0, Integers are 32 bits.
 275  *              For Revision 2 and above, Integers are 64 bits.  Yes, this
 276  *              makes a difference.
 277  *
 278  ******************************************************************************/
 279
 280 void
 281 AcpiUtSetIntegerWidth (
 282     UINT8                   Revision)
 283 {
 284
 285     if (Revision <= 1)
 286     {
 287         AcpiGbl_IntegerBitWidth    = 32;
 288         AcpiGbl_IntegerNybbleWidth = 8;
 289         AcpiGbl_IntegerByteWidth   = 4;
 290     }
 291     else
 292     {
 293         AcpiGbl_IntegerBitWidth    = 64;
 294         AcpiGbl_IntegerNybbleWidth = 16;
 295         AcpiGbl_IntegerByteWidth   = 8;
 296     }
 297 }
 298
 299
 300 #ifdef ACPI_DEBUG_OUTPUT
 301 /*******************************************************************************
 302  *
 303  * FUNCTION:    AcpiUtDisplayInitPathname
 304  *
 305  * PARAMETERS:  ObjHandle           - Handle whose pathname will be displayed
 306  *              Path                - Additional path string to be appended.
 307  *                                      (NULL if no extra path)
 308  *
 309  * RETURN:      ACPI_STATUS
 310  *
 311  * DESCRIPTION: Display full pathname of an object, DEBUG ONLY
 312  *
 313  ******************************************************************************/
 314
 315 void
 316 AcpiUtDisplayInitPathname (
 317     UINT8                   Type,
 318     ACPI_NAMESPACE_NODE     *ObjHandle,
 319     char                    *Path)
 320 {
 321     ACPI_STATUS             Status;
 322     ACPI_BUFFER             Buffer;
 323
 324
 325     ACPI_FUNCTION_ENTRY ();
 326
 327
 328     /* Only print the path if the appropriate debug level is enabled */
 329
 330     if (!(AcpiDbgLevel & ACPI_LV_INIT_NAMES))
 331     {
 332         return;
 333     }
 334
 335     /* Get the full pathname to the node */
 336
 337     Buffer.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 338     Status = AcpiNsHandleToPathname (ObjHandle, &Buffer);
 339     if (ACPI_FAILURE (Status))
 340     {
 341         return;
 342     }
 343
 344     /* Print what we're doing */
 345
 346     switch (Type)
 347     {
 348     case ACPI_TYPE_METHOD:
 349         AcpiOsPrintf ("Executing    ");
 350         break;
 351
 352     default:
 353         AcpiOsPrintf ("Initializing ");
 354         break;
 355     }
 356
 357     /* Print the object type and pathname */
 358
 359     AcpiOsPrintf ("%-12s  %s", AcpiUtGetTypeName (Type), (char *) Buffer.Pointer);
 360
 361     /* Extra path is used to append names like _STA, _INI, etc. */
 362
 363     if (Path)
 364     {
 365         AcpiOsPrintf (".%s", Path);
 366     }
 367     AcpiOsPrintf ("\n");
 368
 369     ACPI_MEM_FREE (Buffer.Pointer);
 370 }
 371 #endif
 372
 373
 374 /*******************************************************************************
 375  *
 376  * FUNCTION:    AcpiUtValidAcpiName
 377  *
 378  * PARAMETERS:  Character           - The character to be examined
 379  *
 380  * RETURN:      1 if Character may appear in a name, else 0
 381  *
 382  * DESCRIPTION: Check for a valid ACPI name.  Each character must be one of:
 383  *              1) Upper case alpha
 384  *              2) numeric
 385  *              3) underscore
 386  *
 387  ******************************************************************************/
 388
 389 BOOLEAN
 390 AcpiUtValidAcpiName (
 391     UINT32                  Name)
 392 {
 393     char                    *NamePtr = (char *) &Name;
 394     char                    Character;
 395     ACPI_NATIVE_UINT        i;
 396
 397
 398     ACPI_FUNCTION_ENTRY ();
 399
 400
 401     for (i = 0; i < ACPI_NAME_SIZE; i++)
 402     {
 403         Character = *NamePtr;
 404         NamePtr++;
 405
 406         if (!((Character == '_') ||
 407               (Character >= 'A' && Character <= 'Z') ||
 408               (Character >= '0' && Character <= '9')))
 409         {
 410             return (FALSE);
 411         }
 412     }
 413
 414     return (TRUE);
 415 }
 416
 417
 418 /*******************************************************************************
 419  *
 420  * FUNCTION:    AcpiUtValidAcpiCharacter
 421  *
 422  * PARAMETERS:  Character           - The character to be examined
 423  *
 424  * RETURN:      1 if Character may appear in a name, else 0
 425  *
 426  * DESCRIPTION: Check for a printable character
 427  *
 428  ******************************************************************************/
 429
 430 BOOLEAN
 431 AcpiUtValidAcpiCharacter (
 432     char                    Character)
 433 {
 434
 435     ACPI_FUNCTION_ENTRY ();
 436
 437     return ((BOOLEAN)   ((Character == '_') ||
 438                         (Character >= 'A' && Character <= 'Z') ||
 439                         (Character >= '0' && Character <= '9')));
 440 }
 441
 442
 443 /*******************************************************************************
 444  *
 445  * FUNCTION:    AcpiUtStrtoul64
 446  *
 447  * PARAMETERS:  String          - Null terminated string
 448  *              Base            - Radix of the string: 10, 16, or ACPI_ANY_BASE
 449  *              RetInteger      - Where the converted integer is returned
 450  *
 451  * RETURN:      Status and Converted value
 452  *
 453  * DESCRIPTION: Convert a string into an unsigned value.
 454  *              NOTE: Does not support Octal strings, not needed.
 455  *
 456  ******************************************************************************/
 457
 458 ACPI_STATUS
 459 AcpiUtStrtoul64 (
 460     char                    *String,
 461     UINT32                  Base,
 462     ACPI_INTEGER            *RetInteger)
 463 {
 464     UINT32                  ThisDigit;
 465     ACPI_INTEGER            ReturnValue = 0;
 466     ACPI_INTEGER            Quotient;
 467
 468
 469     ACPI_FUNCTION_TRACE ("UtStroul64");
 470
 471
 472     switch (Base)
 473     {
 474     case ACPI_ANY_BASE:
 475     case 10:
 476     case 16:
 477         break;
 478
 479     default:
 480         /* Invalid Base */
 481         return_ACPI_STATUS (AE_BAD_PARAMETER);
 482     }
 483
 484     /* Skip over any white space in the buffer */
 485
 486     while (ACPI_IS_SPACE (*String) || *String == '\t')
 487     {
 488         ++String;
 489     }
 490
 491     /*
 492      * If the input parameter Base is zero, then we need to
 493      * determine if it is decimal or hexadecimal:
 494      */
 495     if (Base == 0)
 496     {
 497         if ((*String == '0') &&
 498             (ACPI_TOLOWER (*(++String)) == 'x'))
 499         {
 500             Base = 16;
 501             ++String;
 502         }
 503         else
 504         {
 505             Base = 10;
 506         }
 507     }
 508
 509     /*
 510      * For hexadecimal base, skip over the leading
 511      * 0 or 0x, if they are present.
 512      */
 513     if (Base == 16 &&
 514         *String == '0' &&
 515         ACPI_TOLOWER (*(++String)) == 'x')
 516     {
 517         String++;
 518     }
 519
 520     /* Any string left? */
 521
 522     if (!(*String))
 523     {
 524         goto ErrorExit;
 525     }
 526
 527     /* Main loop: convert the string to a 64-bit integer */
 528
 529     while (*String)
 530     {
 531         if (ACPI_IS_DIGIT (*String))
 532         {
 533             /* Convert ASCII 0-9 to Decimal value */
 534
 535             ThisDigit = ((UINT8) *String) - '0';
 536         }
 537         else
 538         {
 539             ThisDigit = (UINT8) ACPI_TOUPPER (*String);
 540             if (ACPI_IS_UPPER ((char) ThisDigit))
 541             {
 542                 /* Convert ASCII Hex char to value */
 543
 544                 ThisDigit = ThisDigit - 'A' + 10;
 545             }
 546             else
 547             {
 548                 goto ErrorExit;
 549             }
 550         }
 551
 552         /* Check to see if digit is out of range */
 553
 554         if (ThisDigit >= Base)
 555         {
 556             goto ErrorExit;
 557         }
 558
 559         /* Divide the digit into the correct position */
 560
 561         (void) AcpiUtShortDivide ((ACPI_INTEGER_MAX - (ACPI_INTEGER) ThisDigit),
 562                     Base, &Quotient, NULL);
 563         if (ReturnValue > Quotient)
 564         {
 565             goto ErrorExit;
 566         }
 567
 568         ReturnValue *= Base;
 569         ReturnValue += ThisDigit;
 570         ++String;
 571     }
 572
 573     *RetInteger = ReturnValue;
 574     return_ACPI_STATUS (AE_OK);
 575
 576
 577 ErrorExit:
 578     /* Base was set/validated above */
 579
 580     if (Base == 10)
 581     {
 582         return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
 583     }
 584     else
 585     {
 586         return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
 587     }
 588 }
 589
 590
 591 /*******************************************************************************
 592  *
 593  * FUNCTION:    AcpiUtStrupr
 594  *
 595  * PARAMETERS:  SrcString       - The source string to convert to
 596  *
 597  * RETURN:      SrcString
 598  *
 599  * DESCRIPTION: Convert string to uppercase
 600  *
 601  ******************************************************************************/
 602
 603 char *
 604 AcpiUtStrupr (
 605     char                    *SrcString)
 606 {
 607     char                    *String;
 608
 609
 610     ACPI_FUNCTION_ENTRY ();
 611
 612
 613     /* Walk entire string, uppercasing the letters */
 614
 615     for (String = SrcString; *String; )
 616     {
 617         *String = (char) ACPI_TOUPPER (*String);
 618         String++;
 619     }
 620
 621     return (SrcString);
 622 }
 623
 624
 625 /*******************************************************************************
 626  *
 627  * FUNCTION:    AcpiUtMutexInitialize
 628  *
 629  * PARAMETERS:  None.
 630  *
 631  * RETURN:      Status
 632  *
 633  * DESCRIPTION: Create the system mutex objects.
 634  *
 635  ******************************************************************************/
 636
 637 ACPI_STATUS
 638 AcpiUtMutexInitialize (
 639     void)
 640 {
 641     UINT32                  i;
 642     ACPI_STATUS             Status;
 643
 644
 645     ACPI_FUNCTION_TRACE ("UtMutexInitialize");
 646
 647
 648     /*
 649      * Create each of the predefined mutex objects
 650      */
 651     for (i = 0; i < NUM_MUTEX; i++)
 652     {
 653         Status = AcpiUtCreateMutex (i);
 654         if (ACPI_FAILURE (Status))
 655         {
 656             return_ACPI_STATUS (Status);
 657         }
 658     }
 659
 660     Status = AcpiOsCreateLock (&AcpiGbl_GpeLock);
 661     return_ACPI_STATUS (Status);
 662 }
 663
 664
 665 /*******************************************************************************
 666  *
 667  * FUNCTION:    AcpiUtMutexTerminate
 668  *
 669  * PARAMETERS:  None.
 670  *
 671  * RETURN:      None.
 672  *
 673  * DESCRIPTION: Delete all of the system mutex objects.
 674  *
 675  ******************************************************************************/
 676
 677 void
 678 AcpiUtMutexTerminate (
 679     void)
 680 {
 681     UINT32                  i;
 682
 683
 684     ACPI_FUNCTION_TRACE ("UtMutexTerminate");
 685
 686
 687     /*
 688      * Delete each predefined mutex object
 689      */
 690     for (i = 0; i < NUM_MUTEX; i++)
 691     {
 692         (void) AcpiUtDeleteMutex (i);
 693     }
 694
 695     AcpiOsDeleteLock (AcpiGbl_GpeLock);
 696     return_VOID;
 697 }
 698
 699
 700 /*******************************************************************************
 701  *
 702  * FUNCTION:    AcpiUtCreateMutex
 703  *
 704  * PARAMETERS:  MutexID         - ID of the mutex to be created
 705  *
 706  * RETURN:      Status
 707  *
 708  * DESCRIPTION: Create a mutex object.
 709  *
 710  ******************************************************************************/
 711
 712 ACPI_STATUS
 713 AcpiUtCreateMutex (
 714     ACPI_MUTEX_HANDLE       MutexId)
 715 {
 716     ACPI_STATUS             Status = AE_OK;
 717
 718
 719     ACPI_FUNCTION_TRACE_U32 ("UtCreateMutex", MutexId);
 720
 721
 722     if (MutexId > MAX_MUTEX)
 723     {
 724         return_ACPI_STATUS (AE_BAD_PARAMETER);
 725     }
 726
 727     if (!AcpiGbl_MutexInfo[MutexId].Mutex)
 728     {
 729         Status = AcpiOsCreateSemaphore (1, 1,
 730                         &AcpiGbl_MutexInfo[MutexId].Mutex);
 731         AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 732         AcpiGbl_MutexInfo[MutexId].UseCount = 0;
 733     }
 734
 735     return_ACPI_STATUS (Status);
 736 }
 737
 738
 739 /*******************************************************************************
 740  *
 741  * FUNCTION:    AcpiUtDeleteMutex
 742  *
 743  * PARAMETERS:  MutexID         - ID of the mutex to be deleted
 744  *
 745  * RETURN:      Status
 746  *
 747  * DESCRIPTION: Delete a mutex object.
 748  *
 749  ******************************************************************************/
 750
 751 ACPI_STATUS
 752 AcpiUtDeleteMutex (
 753     ACPI_MUTEX_HANDLE       MutexId)
 754 {
 755     ACPI_STATUS             Status;
 756
 757
 758     ACPI_FUNCTION_TRACE_U32 ("UtDeleteMutex", MutexId);
 759
 760
 761     if (MutexId > MAX_MUTEX)
 762     {
 763         return_ACPI_STATUS (AE_BAD_PARAMETER);
 764     }
 765
 766     Status = AcpiOsDeleteSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex);
 767
 768     AcpiGbl_MutexInfo[MutexId].Mutex = NULL;
 769     AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 770
 771     return_ACPI_STATUS (Status);
 772 }
 773
 774
 775 /*******************************************************************************
 776  *
 777  * FUNCTION:    AcpiUtAcquireMutex
 778  *
 779  * PARAMETERS:  MutexID         - ID of the mutex to be acquired
 780  *
 781  * RETURN:      Status
 782  *
 783  * DESCRIPTION: Acquire a mutex object.
 784  *
 785  ******************************************************************************/
 786
 787 ACPI_STATUS
 788 AcpiUtAcquireMutex (
 789     ACPI_MUTEX_HANDLE       MutexId)
 790 {
 791     ACPI_STATUS             Status;
 792     UINT32                  ThisThreadId;
 793
 794
 795     ACPI_FUNCTION_NAME ("UtAcquireMutex");
 796
 797
 798     if (MutexId > MAX_MUTEX)
 799     {
 800         return (AE_BAD_PARAMETER);
 801     }
 802
 803     ThisThreadId = AcpiOsGetThreadId ();
 804
 805 #ifdef ACPI_MUTEX_DEBUG
 806     {
 807         UINT32                  i;
 808         /*
 809          * Mutex debug code, for internal debugging only.
 810          *
 811          * Deadlock prevention.  Check if this thread owns any mutexes of value
 812          * greater than or equal to this one.  If so, the thread has violated
 813          * the mutex ordering rule.  This indicates a coding error somewhere in
 814          * the ACPI subsystem code.
 815          */
 816         for (i = MutexId; i < MAX_MUTEX; i++)
 817         {
 818             if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId)
 819             {
 820                 if (i == MutexId)
 821                 {
 822                     ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 823                             "Mutex [%s] already acquired by this thread [%X]\n",
 824                             AcpiUtGetMutexName (MutexId), ThisThreadId));
 825
 826                     return (AE_ALREADY_ACQUIRED);
 827                 }
 828
 829                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 830                         "Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
 831                         ThisThreadId, AcpiUtGetMutexName (i),
 832                         AcpiUtGetMutexName (MutexId)));
 833
 834                 return (AE_ACQUIRE_DEADLOCK);
 835             }
 836         }
 837     }
 838 #endif
 839
 840     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
 841                 "Thread %X attempting to acquire Mutex [%s]\n",
 842                 ThisThreadId, AcpiUtGetMutexName (MutexId)));
 843
 844     Status = AcpiOsWaitSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex,
 845                                     1, ACPI_WAIT_FOREVER);
 846     if (ACPI_SUCCESS (Status))
 847     {
 848         ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n",
 849                     ThisThreadId, AcpiUtGetMutexName (MutexId)));
 850
 851         AcpiGbl_MutexInfo[MutexId].UseCount++;
 852         AcpiGbl_MutexInfo[MutexId].OwnerId = ThisThreadId;
 853     }
 854     else
 855     {
 856         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n",
 857                     ThisThreadId, AcpiUtGetMutexName (MutexId),
 858                     AcpiFormatException (Status)));
 859     }
 860
 861     return (Status);
 862 }
 863
 864
 865 /*******************************************************************************
 866  *
 867  * FUNCTION:    AcpiUtReleaseMutex
 868  *
 869  * PARAMETERS:  MutexID         - ID of the mutex to be released
 870  *
 871  * RETURN:      Status
 872  *
 873  * DESCRIPTION: Release a mutex object.
 874  *
 875  ******************************************************************************/
 876
 877 ACPI_STATUS
 878 AcpiUtReleaseMutex (
 879     ACPI_MUTEX_HANDLE       MutexId)
 880 {
 881     ACPI_STATUS             Status;
 882     UINT32                  i;
 883     UINT32                  ThisThreadId;
 884
 885
 886     ACPI_FUNCTION_NAME ("UtReleaseMutex");
 887
 888
 889     ThisThreadId = AcpiOsGetThreadId ();
 890     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
 891         "Thread %X releasing Mutex [%s]\n", ThisThreadId,
 892         AcpiUtGetMutexName (MutexId)));
 893
 894     if (MutexId > MAX_MUTEX)
 895     {
 896         return (AE_BAD_PARAMETER);
 897     }
 898
 899     /*
 900      * Mutex must be acquired in order to release it!
 901      */
 902     if (AcpiGbl_MutexInfo[MutexId].OwnerId == ACPI_MUTEX_NOT_ACQUIRED)
 903     {
 904         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 905                 "Mutex [%s] is not acquired, cannot release\n",
 906                 AcpiUtGetMutexName (MutexId)));
 907
 908         return (AE_NOT_ACQUIRED);
 909     }
 910
 911     /*
 912      * Deadlock prevention.  Check if this thread owns any mutexes of value
 913      * greater than this one.  If so, the thread has violated the mutex
 914      * ordering rule.  This indicates a coding error somewhere in
 915      * the ACPI subsystem code.
 916      */
 917     for (i = MutexId; i < MAX_MUTEX; i++)
 918     {
 919         if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId)
 920         {
 921             if (i == MutexId)
 922             {
 923                 continue;
 924             }
 925
 926             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 927                     "Invalid release order: owns [%s], releasing [%s]\n",
 928                     AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
 929
 930             return (AE_RELEASE_DEADLOCK);
 931         }
 932     }
 933
 934     /* Mark unlocked FIRST */
 935
 936     AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 937
 938     Status = AcpiOsSignalSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex, 1);
 939
 940     if (ACPI_FAILURE (Status))
 941     {
 942         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not release Mutex [%s] %s\n",
 943                     ThisThreadId, AcpiUtGetMutexName (MutexId),
 944                     AcpiFormatException (Status)));
 945     }
 946     else
 947     {
 948         ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n",
 949                     ThisThreadId, AcpiUtGetMutexName (MutexId)));
 950     }
 951
 952     return (Status);
 953 }
 954
 955
 956 /*******************************************************************************
 957  *
 958  * FUNCTION:    AcpiUtCreateUpdateStateAndPush
 959  *
 960  * PARAMETERS:  *Object         - Object to be added to the new state
 961  *              Action          - Increment/Decrement
 962  *              StateList       - List the state will be added to
 963  *
 964  * RETURN:      None
 965  *
 966  * DESCRIPTION: Create a new state and push it
 967  *
 968  ******************************************************************************/
 969
 970 ACPI_STATUS
 971 AcpiUtCreateUpdateStateAndPush (
 972     ACPI_OPERAND_OBJECT     *Object,
 973     UINT16                  Action,
 974     ACPI_GENERIC_STATE      **StateList)
 975 {
 976     ACPI_GENERIC_STATE       *State;
 977
 978
 979     ACPI_FUNCTION_ENTRY ();
 980
 981
 982     /* Ignore null objects; these are expected */
 983
 984     if (!Object)
 985     {
 986         return (AE_OK);
 987     }
 988
 989     State = AcpiUtCreateUpdateState (Object, Action);
 990     if (!State)
 991     {
 992         return (AE_NO_MEMORY);
 993     }
 994
 995     AcpiUtPushGenericState (StateList, State);
 996     return (AE_OK);
 997 }
 998
 999
1000 /*******************************************************************************
1001  *
1002  * FUNCTION:    AcpiUtCreatePkgStateAndPush
1003  *
1004  * PARAMETERS:  *Object         - Object to be added to the new state
1005  *              Action          - Increment/Decrement
1006  *              StateList       - List the state will be added to
1007  *
1008  * RETURN:      None
1009  *
1010  * DESCRIPTION: Create a new state and push it
1011  *
1012  ******************************************************************************/
1013
1014 ACPI_STATUS
1015 AcpiUtCreatePkgStateAndPush (
1016     void                    *InternalObject,
1017     void                    *ExternalObject,
1018     UINT16                  Index,
1019     ACPI_GENERIC_STATE      **StateList)
1020 {
1021     ACPI_GENERIC_STATE       *State;
1022
1023
1024     ACPI_FUNCTION_ENTRY ();
1025
1026
1027     State = AcpiUtCreatePkgState (InternalObject, ExternalObject, Index);
1028     if (!State)
1029     {
1030         return (AE_NO_MEMORY);
1031     }
1032
1033     AcpiUtPushGenericState (StateList, State);
1034     return (AE_OK);
1035 }
1036
1037
1038 /*******************************************************************************
1039  *
1040  * FUNCTION:    AcpiUtPushGenericState
1041  *
1042  * PARAMETERS:  ListHead            - Head of the state stack
1043  *              State               - State object to push
1044  *
1045  * RETURN:      Status
1046  *
1047  * DESCRIPTION: Push a state object onto a state stack
1048  *
1049  ******************************************************************************/
1050
1051 void
1052 AcpiUtPushGenericState (
1053     ACPI_GENERIC_STATE      **ListHead,
1054     ACPI_GENERIC_STATE      *State)
1055 {
1056     ACPI_FUNCTION_TRACE ("UtPushGenericState");
1057
1058
1059     /* Push the state object onto the front of the list (stack) */
1060
1061     State->Common.Next = *ListHead;
1062     *ListHead = State;
1063
1064     return_VOID;
1065 }
1066
1067
1068 /*******************************************************************************
1069  *
1070  * FUNCTION:    AcpiUtPopGenericState
1071  *
1072  * PARAMETERS:  ListHead            - Head of the state stack
1073  *
1074  * RETURN:      Status
1075  *
1076  * DESCRIPTION: Pop a state object from a state stack
1077  *
1078  ******************************************************************************/
1079
1080 ACPI_GENERIC_STATE *
1081 AcpiUtPopGenericState (
1082     ACPI_GENERIC_STATE      **ListHead)
1083 {
1084     ACPI_GENERIC_STATE      *State;
1085
1086
1087     ACPI_FUNCTION_TRACE ("UtPopGenericState");
1088
1089
1090     /* Remove the state object at the head of the list (stack) */
1091
1092     State = *ListHead;
1093     if (State)
1094     {
1095         /* Update the list head */
1096
1097         *ListHead = State->Common.Next;
1098     }
1099
1100     return_PTR (State);
1101 }
1102
1103
1104 /*******************************************************************************
1105  *
1106  * FUNCTION:    AcpiUtCreateGenericState
1107  *
1108  * PARAMETERS:  None
1109  *
1110  * RETURN:      Status
1111  *
1112  * DESCRIPTION: Create a generic state object.  Attempt to obtain one from
1113  *              the global state cache;  If none available, create a new one.
1114  *
1115  ******************************************************************************/
1116
1117 ACPI_GENERIC_STATE *
1118 AcpiUtCreateGenericState (void)
1119 {
1120     ACPI_GENERIC_STATE      *State;
1121
1122
1123     ACPI_FUNCTION_ENTRY ();
1124
1125
1126     State = AcpiUtAcquireFromCache (ACPI_MEM_LIST_STATE);
1127
1128     /* Initialize */
1129
1130     if (State)
1131     {
1132         State->Common.DataType = ACPI_DESC_TYPE_STATE;
1133     }
1134
1135     return (State);
1136 }
1137
1138
1139 /*******************************************************************************
1140  *
1141  * FUNCTION:    AcpiUtCreateThreadState
1142  *
1143  * PARAMETERS:  None
1144  *
1145  * RETURN:      Thread State
1146  *
1147  * DESCRIPTION: Create a "Thread State" - a flavor of the generic state used
1148  *              to track per-thread info during method execution
1149  *
1150  ******************************************************************************/
1151
1152 ACPI_THREAD_STATE *
1153 AcpiUtCreateThreadState (
1154     void)
1155 {
1156     ACPI_GENERIC_STATE      *State;
1157
1158
1159     ACPI_FUNCTION_TRACE ("UtCreateThreadState");
1160
1161
1162     /* Create the generic state object */
1163
1164     State = AcpiUtCreateGenericState ();
1165     if (!State)
1166     {
1167         return_PTR (NULL);
1168     }
1169
1170     /* Init fields specific to the update struct */
1171
1172     State->Common.DataType = ACPI_DESC_TYPE_STATE_THREAD;
1173     State->Thread.ThreadId = AcpiOsGetThreadId ();
1174
1175     return_PTR ((ACPI_THREAD_STATE *) State);
1176 }
1177
1178
1179 /*******************************************************************************
1180  *
1181  * FUNCTION:    AcpiUtCreateUpdateState
1182  *
1183  * PARAMETERS:  Object              - Initial Object to be installed in the
1184  *                                    state
1185  *              Action              - Update action to be performed
1186  *
1187  * RETURN:      Status
1188  *
1189  * DESCRIPTION: Create an "Update State" - a flavor of the generic state used
1190  *              to update reference counts and delete complex objects such
1191  *              as packages.
1192  *
1193  ******************************************************************************/
1194
1195 ACPI_GENERIC_STATE *
1196 AcpiUtCreateUpdateState (
1197     ACPI_OPERAND_OBJECT     *Object,
1198     UINT16                  Action)
1199 {
1200     ACPI_GENERIC_STATE      *State;
1201
1202
1203     ACPI_FUNCTION_TRACE_PTR ("UtCreateUpdateState", Object);
1204
1205
1206     /* Create the generic state object */
1207
1208     State = AcpiUtCreateGenericState ();
1209     if (!State)
1210     {
1211         return_PTR (NULL);
1212     }
1213
1214     /* Init fields specific to the update struct */
1215
1216     State->Common.DataType = ACPI_DESC_TYPE_STATE_UPDATE;
1217     State->Update.Object = Object;
1218     State->Update.Value  = Action;
1219
1220     return_PTR (State);
1221 }
1222
1223
1224 /*******************************************************************************
1225  *
1226  * FUNCTION:    AcpiUtCreatePkgState
1227  *
1228  * PARAMETERS:  Object              - Initial Object to be installed in the
1229  *                                    state
1230  *              Action              - Update action to be performed
1231  *
1232  * RETURN:      Status
1233  *
1234  * DESCRIPTION: Create a "Package State"
1235  *
1236  ******************************************************************************/
1237
1238 ACPI_GENERIC_STATE *
1239 AcpiUtCreatePkgState (
1240     void                    *InternalObject,
1241     void                    *ExternalObject,
1242     UINT16                  Index)
1243 {
1244     ACPI_GENERIC_STATE      *State;
1245
1246
1247     ACPI_FUNCTION_TRACE_PTR ("UtCreatePkgState", InternalObject);
1248
1249
1250     /* Create the generic state object */
1251
1252     State = AcpiUtCreateGenericState ();
1253     if (!State)
1254     {
1255         return_PTR (NULL);
1256     }
1257
1258     /* Init fields specific to the update struct */
1259
1260     State->Common.DataType  = ACPI_DESC_TYPE_STATE_PACKAGE;
1261     State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject;
1262     State->Pkg.DestObject   = ExternalObject;
1263     State->Pkg.Index        = Index;
1264     State->Pkg.NumPackages  = 1;
1265
1266     return_PTR (State);
1267 }
1268
1269
1270 /*******************************************************************************
1271  *
1272  * FUNCTION:    AcpiUtCreateControlState
1273  *
1274  * PARAMETERS:  None
1275  *
1276  * RETURN:      Status
1277  *
1278  * DESCRIPTION: Create a "Control State" - a flavor of the generic state used
1279  *              to support nested IF/WHILE constructs in the AML.
1280  *
1281  ******************************************************************************/
1282
1283 ACPI_GENERIC_STATE *
1284 AcpiUtCreateControlState (
1285     void)
1286 {
1287     ACPI_GENERIC_STATE      *State;
1288
1289
1290     ACPI_FUNCTION_TRACE ("UtCreateControlState");
1291
1292
1293     /* Create the generic state object */
1294
1295     State = AcpiUtCreateGenericState ();
1296     if (!State)
1297     {
1298         return_PTR (NULL);
1299     }
1300
1301     /* Init fields specific to the control struct */
1302
1303     State->Common.DataType  = ACPI_DESC_TYPE_STATE_CONTROL;
1304     State->Common.State     = ACPI_CONTROL_CONDITIONAL_EXECUTING;
1305
1306     return_PTR (State);
1307 }
1308
1309
1310 /*******************************************************************************
1311  *
1312  * FUNCTION:    AcpiUtDeleteGenericState
1313  *
1314  * PARAMETERS:  State               - The state object to be deleted
1315  *
1316  * RETURN:      Status
1317  *
1318  * DESCRIPTION: Put a state object back into the global state cache.  The object
1319  *              is not actually freed at this time.
1320  *
1321  ******************************************************************************/
1322
1323 void
1324 AcpiUtDeleteGenericState (
1325     ACPI_GENERIC_STATE      *State)
1326 {
1327     ACPI_FUNCTION_TRACE ("UtDeleteGenericState");
1328
1329
1330     AcpiUtReleaseToCache (ACPI_MEM_LIST_STATE, State);
1331     return_VOID;
1332 }
1333
1334
1335 #ifdef ACPI_ENABLE_OBJECT_CACHE
1336 /*******************************************************************************
1337  *
1338  * FUNCTION:    AcpiUtDeleteGenericStateCache
1339  *
1340  * PARAMETERS:  None
1341  *
1342  * RETURN:      Status
1343  *
1344  * DESCRIPTION: Purge the global state object cache.  Used during subsystem
1345  *              termination.
1346  *
1347  ******************************************************************************/
1348
1349 void
1350 AcpiUtDeleteGenericStateCache (
1351     void)
1352 {
1353     ACPI_FUNCTION_TRACE ("UtDeleteGenericStateCache");
1354
1355
1356     AcpiUtDeleteGenericCache (ACPI_MEM_LIST_STATE);
1357     return_VOID;
1358 }
1359 #endif
1360
1361
1362 /*******************************************************************************
1363  *
1364  * FUNCTION:    AcpiUtWalkPackageTree
1365  *
1366  * PARAMETERS:  ObjDesc         - The Package object on which to resolve refs
1367  *
1368  * RETURN:      Status
1369  *
1370  * DESCRIPTION: Walk through a package
1371  *
1372  ******************************************************************************/
1373
1374 ACPI_STATUS
1375 AcpiUtWalkPackageTree (
1376     ACPI_OPERAND_OBJECT     *SourceObject,
1377     void                    *TargetObject,
1378     ACPI_PKG_CALLBACK       WalkCallback,
1379     void                    *Context)
1380 {
1381     ACPI_STATUS             Status = AE_OK;
1382     ACPI_GENERIC_STATE      *StateList = NULL;
1383     ACPI_GENERIC_STATE      *State;
1384     UINT32                  ThisIndex;
1385     ACPI_OPERAND_OBJECT     *ThisSourceObj;
1386
1387
1388     ACPI_FUNCTION_TRACE ("UtWalkPackageTree");
1389
1390
1391     State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0);
1392     if (!State)
1393     {
1394         return_ACPI_STATUS (AE_NO_MEMORY);
1395     }
1396
1397     while (State)
1398     {
1399         /* Get one element of the package */
1400
1401         ThisIndex     = State->Pkg.Index;
1402         ThisSourceObj = (ACPI_OPERAND_OBJECT *)
1403                         State->Pkg.SourceObject->Package.Elements[ThisIndex];
1404
1405         /*
1406          * Check for:
1407          * 1) An uninitialized package element.  It is completely
1408          *    legal to declare a package and leave it uninitialized
1409          * 2) Not an internal object - can be a namespace node instead
1410          * 3) Any type other than a package.  Packages are handled in else
1411          *    case below.
1412          */
1413         if ((!ThisSourceObj) ||
1414             (ACPI_GET_DESCRIPTOR_TYPE (ThisSourceObj) != ACPI_DESC_TYPE_OPERAND) ||
1415             (ACPI_GET_OBJECT_TYPE (ThisSourceObj) != ACPI_TYPE_PACKAGE))
1416         {
1417             Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj,
1418                                     State, Context);
1419             if (ACPI_FAILURE (Status))
1420             {
1421                 return_ACPI_STATUS (Status);
1422             }
1423
1424             State->Pkg.Index++;
1425             while (State->Pkg.Index >= State->Pkg.SourceObject->Package.Count)
1426             {
1427                 /*
1428                  * We've handled all of the objects at this level,  This means
1429                  * that we have just completed a package.  That package may
1430                  * have contained one or more packages itself.
1431                  *
1432                  * Delete this state and pop the previous state (package).
1433                  */
1434                 AcpiUtDeleteGenericState (State);
1435                 State = AcpiUtPopGenericState (&StateList);
1436
1437                 /* Finished when there are no more states */
1438
1439                 if (!State)
1440                 {
1441                     /*
1442                      * We have handled all of the objects in the top level
1443                      * package just add the length of the package objects
1444                      * and exit
1445                      */
1446                     return_ACPI_STATUS (AE_OK);
1447                 }
1448
1449                 /*
1450                  * Go back up a level and move the index past the just
1451                  * completed package object.
1452                  */
1453                 State->Pkg.Index++;
1454             }
1455         }
1456         else
1457         {
1458             /* This is a subobject of type package */
1459
1460             Status = WalkCallback (ACPI_COPY_TYPE_PACKAGE, ThisSourceObj,
1461                                         State, Context);
1462             if (ACPI_FAILURE (Status))
1463             {
1464                 return_ACPI_STATUS (Status);
1465             }
1466
1467             /*
1468              * Push the current state and create a new one
1469              * The callback above returned a new target package object.
1470              */
1471             AcpiUtPushGenericState (&StateList, State);
1472             State = AcpiUtCreatePkgState (ThisSourceObj,
1473                                             State->Pkg.ThisTargetObj, 0);
1474             if (!State)
1475             {
1476                 return_ACPI_STATUS (AE_NO_MEMORY);
1477             }
1478         }
1479     }
1480
1481     /* We should never get here */
1482
1483     return_ACPI_STATUS (AE_AML_INTERNAL);
1484 }
1485
1486
1487 /*******************************************************************************
1488  *
1489  * FUNCTION:    AcpiUtGenerateChecksum
1490  *
1491  * PARAMETERS:  Buffer          - Buffer to be scanned
1492  *              Length          - number of bytes to examine
1493  *
1494  * RETURN:      checksum
1495  *
1496  * DESCRIPTION: Generate a checksum on a raw buffer
1497  *
1498  ******************************************************************************/
1499
1500 UINT8
1501 AcpiUtGenerateChecksum (
1502     UINT8                   *Buffer,
1503     UINT32                  Length)
1504 {
1505     UINT32                  i;
1506     signed char             Sum = 0;
1507
1508
1509     for (i = 0; i < Length; i++)
1510     {
1511         Sum = (signed char) (Sum + Buffer[i]);
1512     }
1513
1514     return ((UINT8) (0 - Sum));
1515 }
1516
1517
1518 /*******************************************************************************
1519  *
1520  * FUNCTION:    AcpiUtGetResourceEndTag
1521  *
1522  * PARAMETERS:  ObjDesc         - The resource template buffer object
1523  *
1524  * RETURN:      Pointer to the end tag
1525  *
1526  * DESCRIPTION: Find the END_TAG resource descriptor in a resource template
1527  *
1528  ******************************************************************************/
1529
1530
1531 UINT8 *
1532 AcpiUtGetResourceEndTag (
1533     ACPI_OPERAND_OBJECT     *ObjDesc)
1534 {
1535     UINT8                   BufferByte;
1536     UINT8                   *Buffer;
1537     UINT8                   *EndBuffer;
1538
1539
1540     Buffer    = ObjDesc->Buffer.Pointer;
1541     EndBuffer = Buffer + ObjDesc->Buffer.Length;
1542
1543     while (Buffer < EndBuffer)
1544     {
1545         BufferByte = *Buffer;
1546         if (BufferByte & ACPI_RDESC_TYPE_MASK)
1547         {
1548             /* Large Descriptor - Length is next 2 bytes */
1549
1550             Buffer += ((*(Buffer+1) | (*(Buffer+2) << 8)) + 3);
1551         }
1552         else
1553         {
1554             /* Small Descriptor.  End Tag will be found here */
1555
1556             if ((BufferByte & ACPI_RDESC_SMALL_MASK) == ACPI_RDESC_TYPE_END_TAG)
1557             {
1558                 /* Found the end tag descriptor, all done. */
1559
1560                 return (Buffer);
1561             }
1562
1563             /* Length is in the header */
1564
1565             Buffer += ((BufferByte & 0x07) + 1);
1566         }
1567     }
1568
1569     /* End tag not found */
1570
1571     return (NULL);
1572 }
1573
1574
1575 /*******************************************************************************
1576  *
1577  * FUNCTION:    AcpiUtReportError
1578  *
1579  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1580  *              LineNumber          - Caller's line number (for error output)
1581  *              ComponentId         - Caller's component ID (for error output)
1582  *              Message             - Error message to use on failure
1583  *
1584  * RETURN:      None
1585  *
1586  * DESCRIPTION: Print error message
1587  *
1588  ******************************************************************************/
1589
1590 void
1591 AcpiUtReportError (
1592     char                    *ModuleName,
1593     UINT32                  LineNumber,
1594     UINT32                  ComponentId)
1595 {
1596
1597
1598     AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber);
1599 }
1600
1601
1602 /*******************************************************************************
1603  *
1604  * FUNCTION:    AcpiUtReportWarning
1605  *
1606  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1607  *              LineNumber          - Caller's line number (for error output)
1608  *              ComponentId         - Caller's component ID (for error output)
1609  *              Message             - Error message to use on failure
1610  *
1611  * RETURN:      None
1612  *
1613  * DESCRIPTION: Print warning message
1614  *
1615  ******************************************************************************/
1616
1617 void
1618 AcpiUtReportWarning (
1619     char                    *ModuleName,
1620     UINT32                  LineNumber,
1621     UINT32                  ComponentId)
1622 {
1623
1624     AcpiOsPrintf ("%8s-%04d: *** Warning: ", ModuleName, LineNumber);
1625 }
1626
1627
1628 /*******************************************************************************
1629  *
1630  * FUNCTION:    AcpiUtReportInfo
1631  *
1632  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1633  *              LineNumber          - Caller's line number (for error output)
1634  *              ComponentId         - Caller's component ID (for error output)
1635  *              Message             - Error message to use on failure
1636  *
1637  * RETURN:      None
1638  *
1639  * DESCRIPTION: Print information message
1640  *
1641  ******************************************************************************/
1642
1643 void
1644 AcpiUtReportInfo (
1645     char                    *ModuleName,
1646     UINT32                  LineNumber,
1647     UINT32                  ComponentId)
1648 {
1649
1650     AcpiOsPrintf ("%8s-%04d: *** Info: ", ModuleName, LineNumber);
1651 }
1652
1653