reactos/drivers/bus/acpi/acpica/executer/exnames.c

   1 /******************************************************************************
   2  *
   3  * Module Name: exnames - interpreter/scanner name load/execute
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2015, Intel Corp.
  12  * All rights reserved.
  13  *
  14  * 2. License
  15  *
  16  * 2.1. This is your license from Intel Corp. under its intellectual property
  17  * rights. You may have additional license terms from the party that provided
  18  * you this software, covering your right to use that party's intellectual
  19  * property rights.
  20  *
  21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22  * copy of the source code appearing in this file ("Covered Code") an
  23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25  * make derivatives, distribute, use and display any portion of the Covered
  26  * Code in any form, with the right to sublicense such rights; and
  27  *
  28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29  * license (with the right to sublicense), under only those claims of Intel
  30  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31  * offer to sell, and import the Covered Code and derivative works thereof
  32  * solely to the minimum extent necessary to exercise the above copyright
  33  * license, and in no event shall the patent license extend to any additions
  34  * to or modifications of the Original Intel Code. No other license or right
  35  * is granted directly or by implication, estoppel or otherwise;
  36  *
  37  * The above copyright and patent license is granted only if the following
  38  * conditions are met:
  39  *
  40  * 3. Conditions
  41  *
  42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43  * Redistribution of source code of any substantial portion of the Covered
  44  * Code or modification with rights to further distribute source must include
  45  * the above Copyright Notice, the above License, this list of Conditions,
  46  * and the following Disclaimer and Export Compliance provision. In addition,
  47  * Licensee must cause all Covered Code to which Licensee contributes to
  48  * contain a file documenting the changes Licensee made to create that Covered
  49  * Code and the date of any change. Licensee must include in that file the
  50  * documentation of any changes made by any predecessor Licensee. Licensee
  51  * must include a prominent statement that the modification is derived,
  52  * directly or indirectly, from Original Intel Code.
  53  *
  54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55  * Redistribution of source code of any substantial portion of the Covered
  56  * Code or modification without rights to further distribute source must
  57  * include the following Disclaimer and Export Compliance provision in the
  58  * documentation and/or other materials provided with distribution. In
  59  * addition, Licensee may not authorize further sublicense of source of any
  60  * portion of the Covered Code, and must include terms to the effect that the
  61  * license from Licensee to its licensee is limited to the intellectual
  62  * property embodied in the software Licensee provides to its licensee, and
  63  * not to intellectual property embodied in modifications its licensee may
  64  * make.
  65  *
  66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67  * substantial portion of the Covered Code or modification must reproduce the
  68  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69  * provision in the documentation and/or other materials provided with the
  70  * distribution.
  71  *
  72  * 3.4. Intel retains all right, title, and interest in and to the Original
  73  * Intel Code.
  74  *
  75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77  * other dealings in products derived from or relating to the Covered Code
  78  * without prior written authorization from Intel.
  79  *
  80  * 4. Disclaimer and Export Compliance
  81  *
  82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
  85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
  86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
  87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88  * PARTICULAR PURPOSE.
  89  *
  90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
  96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97  * LIMITED REMEDY.
  98  *
  99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 100  * software or system incorporating such software without first obtaining any
 101  * required license or other approval from the U. S. Department of Commerce or
 102  * any other agency or department of the United States Government. In the
 103  * event Licensee exports any such software from the United States or
 104  * re-exports any such software from a foreign destination, Licensee shall
 105  * ensure that the distribution and export/re-export of the software is in
 106  * compliance with all laws, regulations, orders, or other restrictions of the
 107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 108  * any of its subsidiaries will export/re-export any technical data, process,
 109  * software, or service, directly or indirectly, to any country for which the
 110  * United States government or any agency thereof requires an export license,
 111  * other governmental approval, or letter of assurance, without first obtaining
 112  * such license, approval or letter.
 113  *
 114  *****************************************************************************/
 115
 116 #include "acpi.h"
 117 #include "accommon.h"
 118 #include "acinterp.h"
 119 #include "amlcode.h"
 120
 121 #define _COMPONENT          ACPI_EXECUTER
 122         ACPI_MODULE_NAME    ("exnames")
 123
 124 /* Local prototypes */
 125
 126 static char *
 127 AcpiExAllocateNameString (
 128     UINT32                  PrefixCount,
 129     UINT32                  NumNameSegs);
 130
 131 static ACPI_STATUS
 132 AcpiExNameSegment (
 133     UINT8                   **InAmlAddress,
 134     char                    *NameString);
 135
 136
 137 /*******************************************************************************
 138  *
 139  * FUNCTION:    AcpiExAllocateNameString
 140  *
 141  * PARAMETERS:  PrefixCount         - Count of parent levels. Special cases:
 142  *                                    (-1)==root,  0==none
 143  *              NumNameSegs         - count of 4-character name segments
 144  *
 145  * RETURN:      A pointer to the allocated string segment. This segment must
 146  *              be deleted by the caller.
 147  *
 148  * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
 149  *              string is long enough, and set up prefix if any.
 150  *
 151  ******************************************************************************/
 152
 153 static char *
 154 AcpiExAllocateNameString (
 155     UINT32                  PrefixCount,
 156     UINT32                  NumNameSegs)
 157 {
 158     char                    *TempPtr;
 159     char                    *NameString;
 160     UINT32                   SizeNeeded;
 161
 162     ACPI_FUNCTION_TRACE (ExAllocateNameString);
 163
 164
 165     /*
 166      * Allow room for all \ and ^ prefixes, all segments and a MultiNamePrefix.
 167      * Also, one byte for the null terminator.
 168      * This may actually be somewhat longer than needed.
 169      */
 170     if (PrefixCount == ACPI_UINT32_MAX)
 171     {
 172         /* Special case for root */
 173
 174         SizeNeeded = 1 + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1;
 175     }
 176     else
 177     {
 178         SizeNeeded = PrefixCount + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1;
 179     }
 180
 181     /*
 182      * Allocate a buffer for the name.
 183      * This buffer must be deleted by the caller!
 184      */
 185     NameString = ACPI_ALLOCATE (SizeNeeded);
 186     if (!NameString)
 187     {
 188         ACPI_ERROR ((AE_INFO,
 189             "Could not allocate size %u", SizeNeeded));
 190         return_PTR (NULL);
 191     }
 192
 193     TempPtr = NameString;
 194
 195     /* Set up Root or Parent prefixes if needed */
 196
 197     if (PrefixCount == ACPI_UINT32_MAX)
 198     {
 199         *TempPtr++ = AML_ROOT_PREFIX;
 200     }
 201     else
 202     {
 203         while (PrefixCount--)
 204         {
 205             *TempPtr++ = AML_PARENT_PREFIX;
 206         }
 207     }
 208
 209
 210     /* Set up Dual or Multi prefixes if needed */
 211
 212     if (NumNameSegs > 2)
 213     {
 214         /* Set up multi prefixes   */
 215
 216         *TempPtr++ = AML_MULTI_NAME_PREFIX_OP;
 217         *TempPtr++ = (char) NumNameSegs;
 218     }
 219     else if (2 == NumNameSegs)
 220     {
 221         /* Set up dual prefixes */
 222
 223         *TempPtr++ = AML_DUAL_NAME_PREFIX;
 224     }
 225
 226     /*
 227      * Terminate string following prefixes. AcpiExNameSegment() will
 228      * append the segment(s)
 229      */
 230     *TempPtr = 0;
 231
 232     return_PTR (NameString);
 233 }
 234
 235 /*******************************************************************************
 236  *
 237  * FUNCTION:    AcpiExNameSegment
 238  *
 239  * PARAMETERS:  InAmlAddress    - Pointer to the name in the AML code
 240  *              NameString      - Where to return the name. The name is appended
 241  *                                to any existing string to form a namepath
 242  *
 243  * RETURN:      Status
 244  *
 245  * DESCRIPTION: Extract an ACPI name (4 bytes) from the AML byte stream
 246  *
 247  ******************************************************************************/
 248
 249 static ACPI_STATUS
 250 AcpiExNameSegment (
 251     UINT8                   **InAmlAddress,
 252     char                    *NameString)
 253 {
 254     char                    *AmlAddress = (void *) *InAmlAddress;
 255     ACPI_STATUS             Status = AE_OK;
 256     UINT32                  Index;
 257     char                    CharBuf[5];
 258
 259
 260     ACPI_FUNCTION_TRACE (ExNameSegment);
 261
 262
 263     /*
 264      * If first character is a digit, then we know that we aren't looking at a
 265      * valid name segment
 266      */
 267     CharBuf[0] = *AmlAddress;
 268
 269     if ('0' <= CharBuf[0] && CharBuf[0] <= '9')
 270     {
 271         ACPI_ERROR ((AE_INFO, "Invalid leading digit: %c", CharBuf[0]));
 272         return_ACPI_STATUS (AE_CTRL_PENDING);
 273     }
 274
 275     ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Bytes from stream:\n"));
 276
 277     for (Index = 0;
 278         (Index < ACPI_NAME_SIZE) && (AcpiUtValidAcpiChar (*AmlAddress, 0));
 279         Index++)
 280     {
 281         CharBuf[Index] = *AmlAddress++;
 282         ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "%c\n", CharBuf[Index]));
 283     }
 284
 285
 286     /* Valid name segment  */
 287
 288     if (Index == 4)
 289     {
 290         /* Found 4 valid characters */
 291
 292         CharBuf[4] = '\0';
 293
 294         if (NameString)
 295         {
 296             ACPI_STRCAT (NameString, CharBuf);
 297             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
 298                 "Appended to - %s\n", NameString));
 299         }
 300         else
 301         {
 302             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
 303                 "No Name string - %s\n", CharBuf));
 304         }
 305     }
 306     else if (Index == 0)
 307     {
 308         /*
 309          * First character was not a valid name character,
 310          * so we are looking at something other than a name.
 311          */
 312         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 313             "Leading character is not alpha: %02Xh (not a name)\n",
 314             CharBuf[0]));
 315         Status = AE_CTRL_PENDING;
 316     }
 317     else
 318     {
 319         /*
 320          * Segment started with one or more valid characters, but fewer than
 321          * the required 4
 322          */
 323         Status = AE_AML_BAD_NAME;
 324         ACPI_ERROR ((AE_INFO,
 325             "Bad character 0x%02x in name, at %p",
 326             *AmlAddress, AmlAddress));
 327     }
 328
 329     *InAmlAddress = ACPI_CAST_PTR (UINT8, AmlAddress);
 330     return_ACPI_STATUS (Status);
 331 }
 332
 333
 334 /*******************************************************************************
 335  *
 336  * FUNCTION:    AcpiExGetNameString
 337  *
 338  * PARAMETERS:  DataType            - Object type to be associated with this
 339  *                                    name
 340  *              InAmlAddress        - Pointer to the namestring in the AML code
 341  *              OutNameString       - Where the namestring is returned
 342  *              OutNameLength       - Length of the returned string
 343  *
 344  * RETURN:      Status, namestring and length
 345  *
 346  * DESCRIPTION: Extract a full namepath from the AML byte stream,
 347  *              including any prefixes.
 348  *
 349  ******************************************************************************/
 350
 351 ACPI_STATUS
 352 AcpiExGetNameString (
 353     ACPI_OBJECT_TYPE        DataType,
 354     UINT8                   *InAmlAddress,
 355     char                    **OutNameString,
 356     UINT32                  *OutNameLength)
 357 {
 358     ACPI_STATUS             Status = AE_OK;
 359     UINT8                   *AmlAddress = InAmlAddress;
 360     char                    *NameString = NULL;
 361     UINT32                  NumSegments;
 362     UINT32                  PrefixCount = 0;
 363     BOOLEAN                 HasPrefix = FALSE;
 364
 365
 366     ACPI_FUNCTION_TRACE_PTR (ExGetNameString, AmlAddress);
 367
 368
 369     if (ACPI_TYPE_LOCAL_REGION_FIELD == DataType   ||
 370         ACPI_TYPE_LOCAL_BANK_FIELD == DataType     ||
 371         ACPI_TYPE_LOCAL_INDEX_FIELD == DataType)
 372     {
 373         /* Disallow prefixes for types associated with FieldUnit names */
 374
 375         NameString = AcpiExAllocateNameString (0, 1);
 376         if (!NameString)
 377         {
 378             Status = AE_NO_MEMORY;
 379         }
 380         else
 381         {
 382             Status = AcpiExNameSegment (&AmlAddress, NameString);
 383         }
 384     }
 385     else
 386     {
 387         /*
 388          * DataType is not a field name.
 389          * Examine first character of name for root or parent prefix operators
 390          */
 391         switch (*AmlAddress)
 392         {
 393         case AML_ROOT_PREFIX:
 394
 395             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "RootPrefix(\\) at %p\n",
 396                 AmlAddress));
 397
 398             /*
 399              * Remember that we have a RootPrefix --
 400              * see comment in AcpiExAllocateNameString()
 401              */
 402             AmlAddress++;
 403             PrefixCount = ACPI_UINT32_MAX;
 404             HasPrefix = TRUE;
 405             break;
 406
 407         case AML_PARENT_PREFIX:
 408
 409             /* Increment past possibly multiple parent prefixes */
 410
 411             do
 412             {
 413                 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "ParentPrefix (^) at %p\n",
 414                     AmlAddress));
 415
 416                 AmlAddress++;
 417                 PrefixCount++;
 418
 419             } while (*AmlAddress == AML_PARENT_PREFIX);
 420
 421             HasPrefix = TRUE;
 422             break;
 423
 424         default:
 425
 426             /* Not a prefix character */
 427
 428             break;
 429         }
 430
 431         /* Examine first character of name for name segment prefix operator */
 432
 433         switch (*AmlAddress)
 434         {
 435         case AML_DUAL_NAME_PREFIX:
 436
 437             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "DualNamePrefix at %p\n",
 438                 AmlAddress));
 439
 440             AmlAddress++;
 441             NameString = AcpiExAllocateNameString (PrefixCount, 2);
 442             if (!NameString)
 443             {
 444                 Status = AE_NO_MEMORY;
 445                 break;
 446             }
 447
 448             /* Indicate that we processed a prefix */
 449
 450             HasPrefix = TRUE;
 451
 452             Status = AcpiExNameSegment (&AmlAddress, NameString);
 453             if (ACPI_SUCCESS (Status))
 454             {
 455                 Status = AcpiExNameSegment (&AmlAddress, NameString);
 456             }
 457             break;
 458
 459         case AML_MULTI_NAME_PREFIX_OP:
 460
 461             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "MultiNamePrefix at %p\n",
 462                 AmlAddress));
 463
 464             /* Fetch count of segments remaining in name path */
 465
 466             AmlAddress++;
 467             NumSegments = *AmlAddress;
 468
 469             NameString = AcpiExAllocateNameString (PrefixCount, NumSegments);
 470             if (!NameString)
 471             {
 472                 Status = AE_NO_MEMORY;
 473                 break;
 474             }
 475
 476             /* Indicate that we processed a prefix */
 477
 478             AmlAddress++;
 479             HasPrefix = TRUE;
 480
 481             while (NumSegments &&
 482                     (Status = AcpiExNameSegment (&AmlAddress, NameString)) ==
 483                         AE_OK)
 484             {
 485                 NumSegments--;
 486             }
 487
 488             break;
 489
 490         case 0:
 491
 492             /* NullName valid as of 8-12-98 ASL/AML Grammar Update */
 493
 494             if (PrefixCount == ACPI_UINT32_MAX)
 495             {
 496                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 497                     "NameSeg is \"\\\" followed by NULL\n"));
 498             }
 499
 500             /* Consume the NULL byte */
 501
 502             AmlAddress++;
 503             NameString = AcpiExAllocateNameString (PrefixCount, 0);
 504             if (!NameString)
 505             {
 506                 Status = AE_NO_MEMORY;
 507                 break;
 508             }
 509
 510             break;
 511
 512         default:
 513
 514             /* Name segment string */
 515
 516             NameString = AcpiExAllocateNameString (PrefixCount, 1);
 517             if (!NameString)
 518             {
 519                 Status = AE_NO_MEMORY;
 520                 break;
 521             }
 522
 523             Status = AcpiExNameSegment (&AmlAddress, NameString);
 524             break;
 525         }
 526     }
 527
 528     if (AE_CTRL_PENDING == Status && HasPrefix)
 529     {
 530         /* Ran out of segments after processing a prefix */
 531
 532         ACPI_ERROR ((AE_INFO,
 533             "Malformed Name at %p", NameString));
 534         Status = AE_AML_BAD_NAME;
 535     }
 536
 537     if (ACPI_FAILURE (Status))
 538     {
 539         if (NameString)
 540         {
 541             ACPI_FREE (NameString);
 542         }
 543         return_ACPI_STATUS (Status);
 544     }
 545
 546     *OutNameString = NameString;
 547     *OutNameLength = (UINT32) (AmlAddress - InAmlAddress);
 548
 549     return_ACPI_STATUS (Status);
 550 }