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

   1 /*******************************************************************************
   2  *
   3  * Module Name: utmisc - common utility procedures
   4  *              $Revision: 97 $
   5  *
   6  ******************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2003, 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     UINT32                  i;
 395
 396
 397     ACPI_FUNCTION_ENTRY ();
 398
 399
 400     for (i = 0; i < ACPI_NAME_SIZE; i++)
 401     {
 402         if (!((NamePtr[i] == '_') ||
 403               (NamePtr[i] >= 'A' && NamePtr[i] <= 'Z') ||
 404               (NamePtr[i] >= '0' && NamePtr[i] <= '9')))
 405         {
 406             return (FALSE);
 407         }
 408     }
 409
 410     return (TRUE);
 411 }
 412
 413
 414 /*******************************************************************************
 415  *
 416  * FUNCTION:    AcpiUtValidAcpiCharacter
 417  *
 418  * PARAMETERS:  Character           - The character to be examined
 419  *
 420  * RETURN:      1 if Character may appear in a name, else 0
 421  *
 422  * DESCRIPTION: Check for a printable character
 423  *
 424  ******************************************************************************/
 425
 426 BOOLEAN
 427 AcpiUtValidAcpiCharacter (
 428     char                    Character)
 429 {
 430
 431     ACPI_FUNCTION_ENTRY ();
 432
 433     return ((BOOLEAN)   ((Character == '_') ||
 434                         (Character >= 'A' && Character <= 'Z') ||
 435                         (Character >= '0' && Character <= '9')));
 436 }
 437
 438
 439 /*******************************************************************************
 440  *
 441  * FUNCTION:    AcpiUtStrtoul64
 442  *
 443  * PARAMETERS:  String          - Null terminated string
 444  *              Terminater      - Where a pointer to the terminating byte is returned
 445  *              Base            - Radix of the string
 446  *
 447  * RETURN:      Converted value
 448  *
 449  * DESCRIPTION: Convert a string into an unsigned value.
 450  *
 451  ******************************************************************************/
 452 #define NEGATIVE    1
 453 #define POSITIVE    0
 454
 455 ACPI_STATUS
 456 AcpiUtStrtoul64 (
 457     char                    *String,
 458     UINT32                  Base,
 459     ACPI_INTEGER            *RetInteger)
 460 {
 461     UINT32                  Index;
 462     ACPI_INTEGER            ReturnValue = 0;
 463     ACPI_STATUS             Status = AE_OK;
 464     ACPI_INTEGER            Dividend;
 465     ACPI_INTEGER            Quotient;
 466
 467
 468     *RetInteger = 0;
 469
 470     switch (Base)
 471     {
 472     case 0:
 473     case 8:
 474     case 10:
 475     case 16:
 476         break;
 477
 478     default:
 479         /*
 480          * The specified Base parameter is not in the domain of
 481          * this function:
 482          */
 483         return (AE_BAD_PARAMETER);
 484     }
 485
 486     /*
 487      * skip over any white space in the buffer:
 488      */
 489     while (ACPI_IS_SPACE (*String) || *String == '\t')
 490     {
 491         ++String;
 492     }
 493
 494     /*
 495      * If the input parameter Base is zero, then we need to
 496      * determine if it is octal, decimal, or hexadecimal:
 497      */
 498     if (Base == 0)
 499     {
 500         if (*String == '0')
 501         {
 502             if (ACPI_TOLOWER (*(++String)) == 'x')
 503             {
 504                 Base = 16;
 505                 ++String;
 506             }
 507             else
 508             {
 509                 Base = 8;
 510             }
 511         }
 512         else
 513         {
 514             Base = 10;
 515         }
 516     }
 517
 518     /*
 519      * For octal and hexadecimal bases, skip over the leading
 520      * 0 or 0x, if they are present.
 521      */
 522     if (Base == 8 && *String == '0')
 523     {
 524         String++;
 525     }
 526
 527     if (Base == 16 &&
 528         *String == '0' &&
 529         ACPI_TOLOWER (*(++String)) == 'x')
 530     {
 531         String++;
 532     }
 533
 534     /* Main loop: convert the string to an unsigned long */
 535
 536     while (*String)
 537     {
 538         if (ACPI_IS_DIGIT (*String))
 539         {
 540             Index = ((UINT8) *String) - '0';
 541         }
 542         else
 543         {
 544             Index = (UINT8) ACPI_TOUPPER (*String);
 545             if (ACPI_IS_UPPER ((char) Index))
 546             {
 547                 Index = Index - 'A' + 10;
 548             }
 549             else
 550             {
 551                 goto ErrorExit;
 552             }
 553         }
 554
 555         if (Index >= Base)
 556         {
 557             goto ErrorExit;
 558         }
 559
 560         /* Check to see if value is out of range: */
 561
 562         Dividend = ACPI_INTEGER_MAX - (ACPI_INTEGER) Index;
 563         (void) AcpiUtShortDivide (&Dividend, Base, &Quotient, NULL);
 564         if (ReturnValue > Quotient)
 565         {
 566             goto ErrorExit;
 567         }
 568
 569         ReturnValue *= Base;
 570         ReturnValue += Index;
 571         ++String;
 572     }
 573
 574     *RetInteger = ReturnValue;
 575     return (Status);
 576
 577
 578 ErrorExit:
 579     switch (Base)
 580     {
 581     case 8:
 582         Status = AE_BAD_OCTAL_CONSTANT;
 583         break;
 584
 585     case 10:
 586         Status = AE_BAD_DECIMAL_CONSTANT;
 587         break;
 588
 589     case 16:
 590         Status = AE_BAD_HEX_CONSTANT;
 591         break;
 592
 593     default:
 594         /* Base validated above */
 595         break;
 596     }
 597
 598     return (Status);
 599 }
 600
 601
 602 /*******************************************************************************
 603  *
 604  * FUNCTION:    AcpiUtStrupr
 605  *
 606  * PARAMETERS:  SrcString       - The source string to convert to
 607  *
 608  * RETURN:      SrcString
 609  *
 610  * DESCRIPTION: Convert string to uppercase
 611  *
 612  ******************************************************************************/
 613
 614 char *
 615 AcpiUtStrupr (
 616     char                    *SrcString)
 617 {
 618     char                    *String;
 619
 620
 621     ACPI_FUNCTION_ENTRY ();
 622
 623
 624     /* Walk entire string, uppercasing the letters */
 625
 626     for (String = SrcString; *String; )
 627     {
 628         *String = (char) ACPI_TOUPPER (*String);
 629         String++;
 630     }
 631
 632     return (SrcString);
 633 }
 634
 635 /*******************************************************************************
 636  *
 637  * FUNCTION:    AcpiUtMutexInitialize
 638  *
 639  * PARAMETERS:  None.
 640  *
 641  * RETURN:      Status
 642  *
 643  * DESCRIPTION: Create the system mutex objects.
 644  *
 645  ******************************************************************************/
 646
 647 ACPI_STATUS
 648 AcpiUtMutexInitialize (
 649     void)
 650 {
 651     UINT32                  i;
 652     ACPI_STATUS             Status;
 653
 654
 655     ACPI_FUNCTION_TRACE ("UtMutexInitialize");
 656
 657
 658     /*
 659      * Create each of the predefined mutex objects
 660      */
 661     for (i = 0; i < NUM_MUTEX; i++)
 662     {
 663         Status = AcpiUtCreateMutex (i);
 664         if (ACPI_FAILURE (Status))
 665         {
 666             return_ACPI_STATUS (Status);
 667         }
 668     }
 669
 670
 671     Status = AcpiOsCreateLock (&AcpiGbl_GpeLock);
 672
 673     return_ACPI_STATUS (AE_OK);
 674 }
 675
 676
 677 /*******************************************************************************
 678  *
 679  * FUNCTION:    AcpiUtMutexTerminate
 680  *
 681  * PARAMETERS:  None.
 682  *
 683  * RETURN:      None.
 684  *
 685  * DESCRIPTION: Delete all of the system mutex objects.
 686  *
 687  ******************************************************************************/
 688
 689 void
 690 AcpiUtMutexTerminate (
 691     void)
 692 {
 693     UINT32                  i;
 694
 695
 696     ACPI_FUNCTION_TRACE ("UtMutexTerminate");
 697
 698
 699     /*
 700      * Delete each predefined mutex object
 701      */
 702     for (i = 0; i < NUM_MUTEX; i++)
 703     {
 704         (void) AcpiUtDeleteMutex (i);
 705     }
 706
 707     AcpiOsDeleteLock (AcpiGbl_GpeLock);
 708     return_VOID;
 709 }
 710
 711
 712 /*******************************************************************************
 713  *
 714  * FUNCTION:    AcpiUtCreateMutex
 715  *
 716  * PARAMETERS:  MutexID         - ID of the mutex to be created
 717  *
 718  * RETURN:      Status
 719  *
 720  * DESCRIPTION: Create a mutex object.
 721  *
 722  ******************************************************************************/
 723
 724 ACPI_STATUS
 725 AcpiUtCreateMutex (
 726     ACPI_MUTEX_HANDLE       MutexId)
 727 {
 728     ACPI_STATUS             Status = AE_OK;
 729
 730
 731     ACPI_FUNCTION_TRACE_U32 ("UtCreateMutex", MutexId);
 732
 733
 734     if (MutexId > MAX_MUTEX)
 735     {
 736         return_ACPI_STATUS (AE_BAD_PARAMETER);
 737     }
 738
 739     if (!AcpiGbl_MutexInfo[MutexId].Mutex)
 740     {
 741         Status = AcpiOsCreateSemaphore (1, 1,
 742                         &AcpiGbl_MutexInfo[MutexId].Mutex);
 743         AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 744         AcpiGbl_MutexInfo[MutexId].UseCount = 0;
 745     }
 746
 747     return_ACPI_STATUS (Status);
 748 }
 749
 750
 751 /*******************************************************************************
 752  *
 753  * FUNCTION:    AcpiUtDeleteMutex
 754  *
 755  * PARAMETERS:  MutexID         - ID of the mutex to be deleted
 756  *
 757  * RETURN:      Status
 758  *
 759  * DESCRIPTION: Delete a mutex object.
 760  *
 761  ******************************************************************************/
 762
 763 ACPI_STATUS
 764 AcpiUtDeleteMutex (
 765     ACPI_MUTEX_HANDLE       MutexId)
 766 {
 767     ACPI_STATUS             Status;
 768
 769
 770     ACPI_FUNCTION_TRACE_U32 ("UtDeleteMutex", MutexId);
 771
 772
 773     if (MutexId > MAX_MUTEX)
 774     {
 775         return_ACPI_STATUS (AE_BAD_PARAMETER);
 776     }
 777
 778     Status = AcpiOsDeleteSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex);
 779
 780     AcpiGbl_MutexInfo[MutexId].Mutex = NULL;
 781     AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 782
 783     return_ACPI_STATUS (Status);
 784 }
 785
 786
 787 /*******************************************************************************
 788  *
 789  * FUNCTION:    AcpiUtAcquireMutex
 790  *
 791  * PARAMETERS:  MutexID         - ID of the mutex to be acquired
 792  *
 793  * RETURN:      Status
 794  *
 795  * DESCRIPTION: Acquire a mutex object.
 796  *
 797  ******************************************************************************/
 798
 799 ACPI_STATUS
 800 AcpiUtAcquireMutex (
 801     ACPI_MUTEX_HANDLE       MutexId)
 802 {
 803     ACPI_STATUS             Status;
 804     UINT32                  i;
 805     UINT32                  ThisThreadId;
 806
 807
 808     ACPI_FUNCTION_NAME ("UtAcquireMutex");
 809
 810
 811     if (MutexId > MAX_MUTEX)
 812     {
 813         return (AE_BAD_PARAMETER);
 814     }
 815
 816     ThisThreadId = AcpiOsGetThreadId ();
 817
 818     /*
 819      * Deadlock prevention.  Check if this thread owns any mutexes of value
 820      * greater than or equal to this one.  If so, the thread has violated
 821      * the mutex ordering rule.  This indicates a coding error somewhere in
 822      * the ACPI subsystem code.
 823      */
 824     for (i = MutexId; i < MAX_MUTEX; i++)
 825     {
 826         if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId)
 827         {
 828             if (i == MutexId)
 829             {
 830                 ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 831                         "Mutex [%s] already acquired by this thread [%X]\n",
 832                         AcpiUtGetMutexName (MutexId), ThisThreadId));
 833
 834                 return (AE_ALREADY_ACQUIRED);
 835             }
 836
 837             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 838                     "Invalid acquire order: Thread %X owns [%s], wants [%s]\n",
 839                     ThisThreadId, AcpiUtGetMutexName (i),
 840                     AcpiUtGetMutexName (MutexId)));
 841
 842             return (AE_ACQUIRE_DEADLOCK);
 843         }
 844     }
 845
 846     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
 847                 "Thread %X attempting to acquire Mutex [%s]\n",
 848                 ThisThreadId, AcpiUtGetMutexName (MutexId)));
 849
 850     Status = AcpiOsWaitSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex,
 851                                     1, ACPI_WAIT_FOREVER);
 852     if (ACPI_SUCCESS (Status))
 853     {
 854         ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X acquired Mutex [%s]\n",
 855                     ThisThreadId, AcpiUtGetMutexName (MutexId)));
 856
 857         AcpiGbl_MutexInfo[MutexId].UseCount++;
 858         AcpiGbl_MutexInfo[MutexId].OwnerId = ThisThreadId;
 859     }
 860     else
 861     {
 862         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not acquire Mutex [%s] %s\n",
 863                     ThisThreadId, AcpiUtGetMutexName (MutexId),
 864                     AcpiFormatException (Status)));
 865     }
 866
 867     return (Status);
 868 }
 869
 870
 871 /*******************************************************************************
 872  *
 873  * FUNCTION:    AcpiUtReleaseMutex
 874  *
 875  * PARAMETERS:  MutexID         - ID of the mutex to be released
 876  *
 877  * RETURN:      Status
 878  *
 879  * DESCRIPTION: Release a mutex object.
 880  *
 881  ******************************************************************************/
 882
 883 ACPI_STATUS
 884 AcpiUtReleaseMutex (
 885     ACPI_MUTEX_HANDLE       MutexId)
 886 {
 887     ACPI_STATUS             Status;
 888     UINT32                  i;
 889     UINT32                  ThisThreadId;
 890
 891
 892     ACPI_FUNCTION_NAME ("UtReleaseMutex");
 893
 894
 895     ThisThreadId = AcpiOsGetThreadId ();
 896     ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX,
 897         "Thread %X releasing Mutex [%s]\n", ThisThreadId,
 898         AcpiUtGetMutexName (MutexId)));
 899
 900     if (MutexId > MAX_MUTEX)
 901     {
 902         return (AE_BAD_PARAMETER);
 903     }
 904
 905     /*
 906      * Mutex must be acquired in order to release it!
 907      */
 908     if (AcpiGbl_MutexInfo[MutexId].OwnerId == ACPI_MUTEX_NOT_ACQUIRED)
 909     {
 910         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 911                 "Mutex [%s] is not acquired, cannot release\n",
 912                 AcpiUtGetMutexName (MutexId)));
 913
 914         return (AE_NOT_ACQUIRED);
 915     }
 916
 917     /*
 918      * Deadlock prevention.  Check if this thread owns any mutexes of value
 919      * greater than this one.  If so, the thread has violated the mutex
 920      * ordering rule.  This indicates a coding error somewhere in
 921      * the ACPI subsystem code.
 922      */
 923     for (i = MutexId; i < MAX_MUTEX; i++)
 924     {
 925         if (AcpiGbl_MutexInfo[i].OwnerId == ThisThreadId)
 926         {
 927             if (i == MutexId)
 928             {
 929                 continue;
 930             }
 931
 932             ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 933                     "Invalid release order: owns [%s], releasing [%s]\n",
 934                     AcpiUtGetMutexName (i), AcpiUtGetMutexName (MutexId)));
 935
 936             return (AE_RELEASE_DEADLOCK);
 937         }
 938     }
 939
 940     /* Mark unlocked FIRST */
 941
 942     AcpiGbl_MutexInfo[MutexId].OwnerId = ACPI_MUTEX_NOT_ACQUIRED;
 943
 944     Status = AcpiOsSignalSemaphore (AcpiGbl_MutexInfo[MutexId].Mutex, 1);
 945
 946     if (ACPI_FAILURE (Status))
 947     {
 948         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "Thread %X could not release Mutex [%s] %s\n",
 949                     ThisThreadId, AcpiUtGetMutexName (MutexId),
 950                     AcpiFormatException (Status)));
 951     }
 952     else
 953     {
 954         ACPI_DEBUG_PRINT ((ACPI_DB_MUTEX, "Thread %X released Mutex [%s]\n",
 955                     ThisThreadId, AcpiUtGetMutexName (MutexId)));
 956     }
 957
 958     return (Status);
 959 }
 960
 961
 962 /*******************************************************************************
 963  *
 964  * FUNCTION:    AcpiUtCreateUpdateStateAndPush
 965  *
 966  * PARAMETERS:  *Object         - Object to be added to the new state
 967  *              Action          - Increment/Decrement
 968  *              StateList       - List the state will be added to
 969  *
 970  * RETURN:      None
 971  *
 972  * DESCRIPTION: Create a new state and push it
 973  *
 974  ******************************************************************************/
 975
 976 ACPI_STATUS
 977 AcpiUtCreateUpdateStateAndPush (
 978     ACPI_OPERAND_OBJECT     *Object,
 979     UINT16                  Action,
 980     ACPI_GENERIC_STATE      **StateList)
 981 {
 982     ACPI_GENERIC_STATE       *State;
 983
 984
 985     ACPI_FUNCTION_ENTRY ();
 986
 987
 988     /* Ignore null objects; these are expected */
 989
 990     if (!Object)
 991     {
 992         return (AE_OK);
 993     }
 994
 995     State = AcpiUtCreateUpdateState (Object, Action);
 996     if (!State)
 997     {
 998         return (AE_NO_MEMORY);
 999     }
1000
1001     AcpiUtPushGenericState (StateList, State);
1002     return (AE_OK);
1003 }
1004
1005
1006 /*******************************************************************************
1007  *
1008  * FUNCTION:    AcpiUtCreatePkgStateAndPush
1009  *
1010  * PARAMETERS:  *Object         - Object to be added to the new state
1011  *              Action          - Increment/Decrement
1012  *              StateList       - List the state will be added to
1013  *
1014  * RETURN:      None
1015  *
1016  * DESCRIPTION: Create a new state and push it
1017  *
1018  ******************************************************************************/
1019
1020 ACPI_STATUS
1021 AcpiUtCreatePkgStateAndPush (
1022     void                    *InternalObject,
1023     void                    *ExternalObject,
1024     UINT16                  Index,
1025     ACPI_GENERIC_STATE      **StateList)
1026 {
1027     ACPI_GENERIC_STATE       *State;
1028
1029
1030     ACPI_FUNCTION_ENTRY ();
1031
1032
1033     State = AcpiUtCreatePkgState (InternalObject, ExternalObject, Index);
1034     if (!State)
1035     {
1036         return (AE_NO_MEMORY);
1037     }
1038
1039     AcpiUtPushGenericState (StateList, State);
1040     return (AE_OK);
1041 }
1042
1043
1044 /*******************************************************************************
1045  *
1046  * FUNCTION:    AcpiUtPushGenericState
1047  *
1048  * PARAMETERS:  ListHead            - Head of the state stack
1049  *              State               - State object to push
1050  *
1051  * RETURN:      Status
1052  *
1053  * DESCRIPTION: Push a state object onto a state stack
1054  *
1055  ******************************************************************************/
1056
1057 void
1058 AcpiUtPushGenericState (
1059     ACPI_GENERIC_STATE      **ListHead,
1060     ACPI_GENERIC_STATE      *State)
1061 {
1062     ACPI_FUNCTION_TRACE ("UtPushGenericState");
1063
1064
1065     /* Push the state object onto the front of the list (stack) */
1066
1067     State->Common.Next = *ListHead;
1068     *ListHead = State;
1069
1070     return_VOID;
1071 }
1072
1073
1074 /*******************************************************************************
1075  *
1076  * FUNCTION:    AcpiUtPopGenericState
1077  *
1078  * PARAMETERS:  ListHead            - Head of the state stack
1079  *
1080  * RETURN:      Status
1081  *
1082  * DESCRIPTION: Pop a state object from a state stack
1083  *
1084  ******************************************************************************/
1085
1086 ACPI_GENERIC_STATE *
1087 AcpiUtPopGenericState (
1088     ACPI_GENERIC_STATE      **ListHead)
1089 {
1090     ACPI_GENERIC_STATE      *State;
1091
1092
1093     ACPI_FUNCTION_TRACE ("UtPopGenericState");
1094
1095
1096     /* Remove the state object at the head of the list (stack) */
1097
1098     State = *ListHead;
1099     if (State)
1100     {
1101         /* Update the list head */
1102
1103         *ListHead = State->Common.Next;
1104     }
1105
1106     return_PTR (State);
1107 }
1108
1109
1110 /*******************************************************************************
1111  *
1112  * FUNCTION:    AcpiUtCreateGenericState
1113  *
1114  * PARAMETERS:  None
1115  *
1116  * RETURN:      Status
1117  *
1118  * DESCRIPTION: Create a generic state object.  Attempt to obtain one from
1119  *              the global state cache;  If none available, create a new one.
1120  *
1121  ******************************************************************************/
1122
1123 ACPI_GENERIC_STATE *
1124 AcpiUtCreateGenericState (void)
1125 {
1126     ACPI_GENERIC_STATE      *State;
1127
1128
1129     ACPI_FUNCTION_ENTRY ();
1130
1131
1132     State = AcpiUtAcquireFromCache (ACPI_MEM_LIST_STATE);
1133
1134     /* Initialize */
1135
1136     if (State)
1137     {
1138         State->Common.DataType = ACPI_DESC_TYPE_STATE;
1139     }
1140
1141     return (State);
1142 }
1143
1144
1145 /*******************************************************************************
1146  *
1147  * FUNCTION:    AcpiUtCreateThreadState
1148  *
1149  * PARAMETERS:  None
1150  *
1151  * RETURN:      Thread State
1152  *
1153  * DESCRIPTION: Create a "Thread State" - a flavor of the generic state used
1154  *              to track per-thread info during method execution
1155  *
1156  ******************************************************************************/
1157
1158 ACPI_THREAD_STATE *
1159 AcpiUtCreateThreadState (
1160     void)
1161 {
1162     ACPI_GENERIC_STATE      *State;
1163
1164
1165     ACPI_FUNCTION_TRACE ("UtCreateThreadState");
1166
1167
1168     /* Create the generic state object */
1169
1170     State = AcpiUtCreateGenericState ();
1171     if (!State)
1172     {
1173         return_PTR (NULL);
1174     }
1175
1176     /* Init fields specific to the update struct */
1177
1178     State->Common.DataType = ACPI_DESC_TYPE_STATE_THREAD;
1179     State->Thread.ThreadId = AcpiOsGetThreadId ();
1180
1181     return_PTR ((ACPI_THREAD_STATE *) State);
1182 }
1183
1184
1185 /*******************************************************************************
1186  *
1187  * FUNCTION:    AcpiUtCreateUpdateState
1188  *
1189  * PARAMETERS:  Object              - Initial Object to be installed in the
1190  *                                    state
1191  *              Action              - Update action to be performed
1192  *
1193  * RETURN:      Status
1194  *
1195  * DESCRIPTION: Create an "Update State" - a flavor of the generic state used
1196  *              to update reference counts and delete complex objects such
1197  *              as packages.
1198  *
1199  ******************************************************************************/
1200
1201 ACPI_GENERIC_STATE *
1202 AcpiUtCreateUpdateState (
1203     ACPI_OPERAND_OBJECT     *Object,
1204     UINT16                  Action)
1205 {
1206     ACPI_GENERIC_STATE      *State;
1207
1208
1209     ACPI_FUNCTION_TRACE_PTR ("UtCreateUpdateState", Object);
1210
1211
1212     /* Create the generic state object */
1213
1214     State = AcpiUtCreateGenericState ();
1215     if (!State)
1216     {
1217         return_PTR (NULL);
1218     }
1219
1220     /* Init fields specific to the update struct */
1221
1222     State->Common.DataType = ACPI_DESC_TYPE_STATE_UPDATE;
1223     State->Update.Object = Object;
1224     State->Update.Value  = Action;
1225
1226     return_PTR (State);
1227 }
1228
1229
1230 /*******************************************************************************
1231  *
1232  * FUNCTION:    AcpiUtCreatePkgState
1233  *
1234  * PARAMETERS:  Object              - Initial Object to be installed in the
1235  *                                    state
1236  *              Action              - Update action to be performed
1237  *
1238  * RETURN:      Status
1239  *
1240  * DESCRIPTION: Create a "Package State"
1241  *
1242  ******************************************************************************/
1243
1244 ACPI_GENERIC_STATE *
1245 AcpiUtCreatePkgState (
1246     void                    *InternalObject,
1247     void                    *ExternalObject,
1248     UINT16                  Index)
1249 {
1250     ACPI_GENERIC_STATE      *State;
1251
1252
1253     ACPI_FUNCTION_TRACE_PTR ("UtCreatePkgState", InternalObject);
1254
1255
1256     /* Create the generic state object */
1257
1258     State = AcpiUtCreateGenericState ();
1259     if (!State)
1260     {
1261         return_PTR (NULL);
1262     }
1263
1264     /* Init fields specific to the update struct */
1265
1266     State->Common.DataType  = ACPI_DESC_TYPE_STATE_PACKAGE;
1267     State->Pkg.SourceObject = (ACPI_OPERAND_OBJECT *) InternalObject;
1268     State->Pkg.DestObject   = ExternalObject;
1269     State->Pkg.Index        = Index;
1270     State->Pkg.NumPackages  = 1;
1271
1272     return_PTR (State);
1273 }
1274
1275
1276 /*******************************************************************************
1277  *
1278  * FUNCTION:    AcpiUtCreateControlState
1279  *
1280  * PARAMETERS:  None
1281  *
1282  * RETURN:      Status
1283  *
1284  * DESCRIPTION: Create a "Control State" - a flavor of the generic state used
1285  *              to support nested IF/WHILE constructs in the AML.
1286  *
1287  ******************************************************************************/
1288
1289 ACPI_GENERIC_STATE *
1290 AcpiUtCreateControlState (
1291     void)
1292 {
1293     ACPI_GENERIC_STATE      *State;
1294
1295
1296     ACPI_FUNCTION_TRACE ("UtCreateControlState");
1297
1298
1299     /* Create the generic state object */
1300
1301     State = AcpiUtCreateGenericState ();
1302     if (!State)
1303     {
1304         return_PTR (NULL);
1305     }
1306
1307     /* Init fields specific to the control struct */
1308
1309     State->Common.DataType  = ACPI_DESC_TYPE_STATE_CONTROL;
1310     State->Common.State     = ACPI_CONTROL_CONDITIONAL_EXECUTING;
1311
1312     return_PTR (State);
1313 }
1314
1315
1316 /*******************************************************************************
1317  *
1318  * FUNCTION:    AcpiUtDeleteGenericState
1319  *
1320  * PARAMETERS:  State               - The state object to be deleted
1321  *
1322  * RETURN:      Status
1323  *
1324  * DESCRIPTION: Put a state object back into the global state cache.  The object
1325  *              is not actually freed at this time.
1326  *
1327  ******************************************************************************/
1328
1329 void
1330 AcpiUtDeleteGenericState (
1331     ACPI_GENERIC_STATE      *State)
1332 {
1333     ACPI_FUNCTION_TRACE ("UtDeleteGenericState");
1334
1335
1336     AcpiUtReleaseToCache (ACPI_MEM_LIST_STATE, State);
1337     return_VOID;
1338 }
1339
1340
1341 /*******************************************************************************
1342  *
1343  * FUNCTION:    AcpiUtDeleteGenericStateCache
1344  *
1345  * PARAMETERS:  None
1346  *
1347  * RETURN:      Status
1348  *
1349  * DESCRIPTION: Purge the global state object cache.  Used during subsystem
1350  *              termination.
1351  *
1352  ******************************************************************************/
1353
1354 void
1355 AcpiUtDeleteGenericStateCache (
1356     void)
1357 {
1358     ACPI_FUNCTION_TRACE ("UtDeleteGenericStateCache");
1359
1360
1361     AcpiUtDeleteGenericCache (ACPI_MEM_LIST_STATE);
1362     return_VOID;
1363 }
1364
1365
1366 /*******************************************************************************
1367  *
1368  * FUNCTION:    AcpiUtWalkPackageTree
1369  *
1370  * PARAMETERS:  ObjDesc         - The Package object on which to resolve refs
1371  *
1372  * RETURN:      Status
1373  *
1374  * DESCRIPTION: Walk through a package
1375  *
1376  ******************************************************************************/
1377
1378 ACPI_STATUS
1379 AcpiUtWalkPackageTree (
1380     ACPI_OPERAND_OBJECT     *SourceObject,
1381     void                    *TargetObject,
1382     ACPI_PKG_CALLBACK       WalkCallback,
1383     void                    *Context)
1384 {
1385     ACPI_STATUS             Status = AE_OK;
1386     ACPI_GENERIC_STATE      *StateList = NULL;
1387     ACPI_GENERIC_STATE      *State;
1388     UINT32                  ThisIndex;
1389     ACPI_OPERAND_OBJECT     *ThisSourceObj;
1390
1391
1392     ACPI_FUNCTION_TRACE ("UtWalkPackageTree");
1393
1394
1395     State = AcpiUtCreatePkgState (SourceObject, TargetObject, 0);
1396     if (!State)
1397     {
1398         return_ACPI_STATUS (AE_NO_MEMORY);
1399     }
1400
1401     while (State)
1402     {
1403         /* Get one element of the package */
1404
1405         ThisIndex     = State->Pkg.Index;
1406         ThisSourceObj = (ACPI_OPERAND_OBJECT *)
1407                         State->Pkg.SourceObject->Package.Elements[ThisIndex];
1408
1409         /*
1410          * Check for:
1411          * 1) An uninitialized package element.  It is completely
1412          *    legal to declare a package and leave it uninitialized
1413          * 2) Not an internal object - can be a namespace node instead
1414          * 3) Any type other than a package.  Packages are handled in else
1415          *    case below.
1416          */
1417         if ((!ThisSourceObj) ||
1418             (ACPI_GET_DESCRIPTOR_TYPE (ThisSourceObj) != ACPI_DESC_TYPE_OPERAND) ||
1419             (ACPI_GET_OBJECT_TYPE (ThisSourceObj) != ACPI_TYPE_PACKAGE))
1420         {
1421             Status = WalkCallback (ACPI_COPY_TYPE_SIMPLE, ThisSourceObj,
1422                                     State, Context);
1423             if (ACPI_FAILURE (Status))
1424             {
1425                 return_ACPI_STATUS (Status);
1426             }
1427
1428             State->Pkg.Index++;
1429             while (State->Pkg.Index >= State->Pkg.SourceObject->Package.Count)
1430             {
1431                 /*
1432                  * We've handled all of the objects at this level,  This means
1433                  * that we have just completed a package.  That package may
1434                  * have contained one or more packages itself.
1435                  *
1436                  * Delete this state and pop the previous state (package).
1437                  */
1438                 AcpiUtDeleteGenericState (State);
1439                 State = AcpiUtPopGenericState (&StateList);
1440
1441                 /* Finished when there are no more states */
1442
1443                 if (!State)
1444                 {
1445                     /*
1446                      * We have handled all of the objects in the top level
1447                      * package just add the length of the package objects
1448                      * and exit
1449                      */
1450                     return_ACPI_STATUS (AE_OK);
1451                 }
1452
1453                 /*
1454                  * Go back up a level and move the index past the just
1455                  * completed package object.
1456                  */
1457                 State->Pkg.Index++;
1458             }
1459         }
1460         else
1461         {
1462             /* This is a subobject of type package */
1463
1464             Status = WalkCallback (ACPI_COPY_TYPE_PACKAGE, ThisSourceObj,
1465                                         State, Context);
1466             if (ACPI_FAILURE (Status))
1467             {
1468                 return_ACPI_STATUS (Status);
1469             }
1470
1471             /*
1472              * Push the current state and create a new one
1473              * The callback above returned a new target package object.
1474              */
1475             AcpiUtPushGenericState (&StateList, State);
1476             State = AcpiUtCreatePkgState (ThisSourceObj,
1477                                             State->Pkg.ThisTargetObj, 0);
1478             if (!State)
1479             {
1480                 return_ACPI_STATUS (AE_NO_MEMORY);
1481             }
1482         }
1483     }
1484
1485     /* We should never get here */
1486
1487     return_ACPI_STATUS (AE_AML_INTERNAL);
1488 }
1489
1490
1491 /*******************************************************************************
1492  *
1493  * FUNCTION:    AcpiUtGenerateChecksum
1494  *
1495  * PARAMETERS:  Buffer          - Buffer to be scanned
1496  *              Length          - number of bytes to examine
1497  *
1498  * RETURN:      checksum
1499  *
1500  * DESCRIPTION: Generate a checksum on a raw buffer
1501  *
1502  ******************************************************************************/
1503
1504 UINT8
1505 AcpiUtGenerateChecksum (
1506     UINT8                   *Buffer,
1507     UINT32                  Length)
1508 {
1509     UINT32                  i;
1510     signed char             Sum = 0;
1511
1512
1513     for (i = 0; i < Length; i++)
1514     {
1515         Sum = (signed char) (Sum + Buffer[i]);
1516     }
1517
1518     return ((UINT8) (0 - Sum));
1519 }
1520
1521
1522 /*******************************************************************************
1523  *
1524  * FUNCTION:    AcpiUtGetResourceEndTag
1525  *
1526  * PARAMETERS:  ObjDesc         - The resource template buffer object
1527  *
1528  * RETURN:      Pointer to the end tag
1529  *
1530  * DESCRIPTION: Find the END_TAG resource descriptor in a resource template
1531  *
1532  ******************************************************************************/
1533
1534
1535 UINT8 *
1536 AcpiUtGetResourceEndTag (
1537     ACPI_OPERAND_OBJECT     *ObjDesc)
1538 {
1539     UINT8                   BufferByte;
1540     UINT8                   *Buffer;
1541     UINT8                   *EndBuffer;
1542
1543
1544     Buffer    = ObjDesc->Buffer.Pointer;
1545     EndBuffer = Buffer + ObjDesc->Buffer.Length;
1546
1547     while (Buffer < EndBuffer)
1548     {
1549         BufferByte = *Buffer;
1550         if (BufferByte & ACPI_RDESC_TYPE_MASK)
1551         {
1552             /* Large Descriptor - Length is next 2 bytes */
1553
1554             Buffer += ((*(Buffer+1) | (*(Buffer+2) << 8)) + 3);
1555         }
1556         else
1557         {
1558             /* Small Descriptor.  End Tag will be found here */
1559
1560             if ((BufferByte & ACPI_RDESC_SMALL_MASK) == ACPI_RDESC_TYPE_END_TAG)
1561             {
1562                 /* Found the end tag descriptor, all done. */
1563
1564                 return (Buffer);
1565             }
1566
1567             /* Length is in the header */
1568
1569             Buffer += ((BufferByte & 0x07) + 1);
1570         }
1571     }
1572
1573     /* End tag not found */
1574
1575     return (NULL);
1576 }
1577
1578
1579 /*******************************************************************************
1580  *
1581  * FUNCTION:    AcpiUtReportError
1582  *
1583  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1584  *              LineNumber          - Caller's line number (for error output)
1585  *              ComponentId         - Caller's component ID (for error output)
1586  *              Message             - Error message to use on failure
1587  *
1588  * RETURN:      None
1589  *
1590  * DESCRIPTION: Print error message
1591  *
1592  ******************************************************************************/
1593
1594 void
1595 AcpiUtReportError (
1596     char                    *ModuleName,
1597     UINT32                  LineNumber,
1598     UINT32                  ComponentId)
1599 {
1600
1601
1602     AcpiOsPrintf ("%8s-%04d: *** Error: ", ModuleName, LineNumber);
1603 }
1604
1605
1606 /*******************************************************************************
1607  *
1608  * FUNCTION:    AcpiUtReportWarning
1609  *
1610  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1611  *              LineNumber          - Caller's line number (for error output)
1612  *              ComponentId         - Caller's component ID (for error output)
1613  *              Message             - Error message to use on failure
1614  *
1615  * RETURN:      None
1616  *
1617  * DESCRIPTION: Print warning message
1618  *
1619  ******************************************************************************/
1620
1621 void
1622 AcpiUtReportWarning (
1623     char                    *ModuleName,
1624     UINT32                  LineNumber,
1625     UINT32                  ComponentId)
1626 {
1627
1628     AcpiOsPrintf ("%8s-%04d: *** Warning: ", ModuleName, LineNumber);
1629 }
1630
1631
1632 /*******************************************************************************
1633  *
1634  * FUNCTION:    AcpiUtReportInfo
1635  *
1636  * PARAMETERS:  ModuleName          - Caller's module name (for error output)
1637  *              LineNumber          - Caller's line number (for error output)
1638  *              ComponentId         - Caller's component ID (for error output)
1639  *              Message             - Error message to use on failure
1640  *
1641  * RETURN:      None
1642  *
1643  * DESCRIPTION: Print information message
1644  *
1645  ******************************************************************************/
1646
1647 void
1648 AcpiUtReportInfo (
1649     char                    *ModuleName,
1650     UINT32                  LineNumber,
1651     UINT32                  ComponentId)
1652 {
1653
1654     AcpiOsPrintf ("%8s-%04d: *** Info: ", ModuleName, LineNumber);
1655 }
1656
1657