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

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: exnames - interpreter/scanner name load/execute
   5  *
   6  *****************************************************************************/
   7
   8 /*
   9  * Copyright (C) 2000 - 2011, Intel Corp.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions, and the following disclaimer,
  17  *    without modification.
  18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19  *    substantially similar to the "NO WARRANTY" disclaimer below
  20  *    ("Disclaimer") and any redistribution must be conditioned upon
  21  *    including a substantially similar Disclaimer requirement for further
  22  *    binary redistribution.
  23  * 3. Neither the names of the above-listed copyright holders nor the names
  24  *    of any contributors may be used to endorse or promote products derived
  25  *    from this software without specific prior written permission.
  26  *
  27  * Alternatively, this software may be distributed under the terms of the
  28  * GNU General Public License ("GPL") version 2 as published by the Free
  29  * Software Foundation.
  30  *
  31  * NO WARRANTY
  32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  42  * POSSIBILITY OF SUCH DAMAGES.
  43  */
  44
  45 #define __EXNAMES_C__
  46
  47 #include <contrib/dev/acpica/include/acpi.h>
  48 #include <contrib/dev/acpica/include/accommon.h>
  49 #include <contrib/dev/acpica/include/acinterp.h>
  50 #include <contrib/dev/acpica/include/amlcode.h>
  51
  52 #define _COMPONENT          ACPI_EXECUTER
  53         ACPI_MODULE_NAME    ("exnames")
  54
  55 /* Local prototypes */
  56
  57 static char *
  58 AcpiExAllocateNameString (
  59     UINT32                  PrefixCount,
  60     UINT32                  NumNameSegs);
  61
  62 static ACPI_STATUS
  63 AcpiExNameSegment (
  64     UINT8                   **InAmlAddress,
  65     char                    *NameString);
  66
  67
  68 /*******************************************************************************
  69  *
  70  * FUNCTION:    AcpiExAllocateNameString
  71  *
  72  * PARAMETERS:  PrefixCount         - Count of parent levels. Special cases:
  73  *                                    (-1)==root,  0==none
  74  *              NumNameSegs         - count of 4-character name segments
  75  *
  76  * RETURN:      A pointer to the allocated string segment.  This segment must
  77  *              be deleted by the caller.
  78  *
  79  * DESCRIPTION: Allocate a buffer for a name string. Ensure allocated name
  80  *              string is long enough, and set up prefix if any.
  81  *
  82  ******************************************************************************/
  83
  84 static char *
  85 AcpiExAllocateNameString (
  86     UINT32                  PrefixCount,
  87     UINT32                  NumNameSegs)
  88 {
  89     char                    *TempPtr;
  90     char                    *NameString;
  91     UINT32                   SizeNeeded;
  92
  93     ACPI_FUNCTION_TRACE (ExAllocateNameString);
  94
  95
  96     /*
  97      * Allow room for all \ and ^ prefixes, all segments and a MultiNamePrefix.
  98      * Also, one byte for the null terminator.
  99      * This may actually be somewhat longer than needed.
 100      */
 101     if (PrefixCount == ACPI_UINT32_MAX)
 102     {
 103         /* Special case for root */
 104
 105         SizeNeeded = 1 + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1;
 106     }
 107     else
 108     {
 109         SizeNeeded = PrefixCount + (ACPI_NAME_SIZE * NumNameSegs) + 2 + 1;
 110     }
 111
 112     /*
 113      * Allocate a buffer for the name.
 114      * This buffer must be deleted by the caller!
 115      */
 116     NameString = ACPI_ALLOCATE (SizeNeeded);
 117     if (!NameString)
 118     {
 119         ACPI_ERROR ((AE_INFO,
 120             "Could not allocate size %u", SizeNeeded));
 121         return_PTR (NULL);
 122     }
 123
 124     TempPtr = NameString;
 125
 126     /* Set up Root or Parent prefixes if needed */
 127
 128     if (PrefixCount == ACPI_UINT32_MAX)
 129     {
 130         *TempPtr++ = AML_ROOT_PREFIX;
 131     }
 132     else
 133     {
 134         while (PrefixCount--)
 135         {
 136             *TempPtr++ = AML_PARENT_PREFIX;
 137         }
 138     }
 139
 140
 141     /* Set up Dual or Multi prefixes if needed */
 142
 143     if (NumNameSegs > 2)
 144     {
 145         /* Set up multi prefixes   */
 146
 147         *TempPtr++ = AML_MULTI_NAME_PREFIX_OP;
 148         *TempPtr++ = (char) NumNameSegs;
 149     }
 150     else if (2 == NumNameSegs)
 151     {
 152         /* Set up dual prefixes */
 153
 154         *TempPtr++ = AML_DUAL_NAME_PREFIX;
 155     }
 156
 157     /*
 158      * Terminate string following prefixes. AcpiExNameSegment() will
 159      * append the segment(s)
 160      */
 161     *TempPtr = 0;
 162
 163     return_PTR (NameString);
 164 }
 165
 166 /*******************************************************************************
 167  *
 168  * FUNCTION:    AcpiExNameSegment
 169  *
 170  * PARAMETERS:  InAmlAddress    - Pointer to the name in the AML code
 171  *              NameString      - Where to return the name. The name is appended
 172  *                                to any existing string to form a namepath
 173  *
 174  * RETURN:      Status
 175  *
 176  * DESCRIPTION: Extract an ACPI name (4 bytes) from the AML byte stream
 177  *
 178  ******************************************************************************/
 179
 180 static ACPI_STATUS
 181 AcpiExNameSegment (
 182     UINT8                   **InAmlAddress,
 183     char                    *NameString)
 184 {
 185     char                    *AmlAddress = (void *) *InAmlAddress;
 186     ACPI_STATUS             Status = AE_OK;
 187     UINT32                  Index;
 188     char                    CharBuf[5];
 189
 190
 191     ACPI_FUNCTION_TRACE (ExNameSegment);
 192
 193
 194     /*
 195      * If first character is a digit, then we know that we aren't looking at a
 196      * valid name segment
 197      */
 198     CharBuf[0] = *AmlAddress;
 199
 200     if ('0' <= CharBuf[0] && CharBuf[0] <= '9')
 201     {
 202         ACPI_ERROR ((AE_INFO, "Invalid leading digit: %c", CharBuf[0]));
 203         return_ACPI_STATUS (AE_CTRL_PENDING);
 204     }
 205
 206     ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "Bytes from stream:\n"));
 207
 208     for (Index = 0;
 209         (Index < ACPI_NAME_SIZE) && (AcpiUtValidAcpiChar (*AmlAddress, 0));
 210         Index++)
 211     {
 212         CharBuf[Index] = *AmlAddress++;
 213         ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "%c\n", CharBuf[Index]));
 214     }
 215
 216
 217     /* Valid name segment  */
 218
 219     if (Index == 4)
 220     {
 221         /* Found 4 valid characters */
 222
 223         CharBuf[4] = '\0';
 224
 225         if (NameString)
 226         {
 227             ACPI_STRCAT (NameString, CharBuf);
 228             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
 229                 "Appended to - %s\n", NameString));
 230         }
 231         else
 232         {
 233             ACPI_DEBUG_PRINT ((ACPI_DB_NAMES,
 234                 "No Name string - %s\n", CharBuf));
 235         }
 236     }
 237     else if (Index == 0)
 238     {
 239         /*
 240          * First character was not a valid name character,
 241          * so we are looking at something other than a name.
 242          */
 243         ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 244             "Leading character is not alpha: %02Xh (not a name)\n",
 245             CharBuf[0]));
 246         Status = AE_CTRL_PENDING;
 247     }
 248     else
 249     {
 250         /*
 251          * Segment started with one or more valid characters, but fewer than
 252          * the required 4
 253          */
 254         Status = AE_AML_BAD_NAME;
 255         ACPI_ERROR ((AE_INFO,
 256             "Bad character 0x%02x in name, at %p",
 257             *AmlAddress, AmlAddress));
 258     }
 259
 260     *InAmlAddress = ACPI_CAST_PTR (UINT8, AmlAddress);
 261     return_ACPI_STATUS (Status);
 262 }
 263
 264
 265 /*******************************************************************************
 266  *
 267  * FUNCTION:    AcpiExGetNameString
 268  *
 269  * PARAMETERS:  DataType            - Object type to be associated with this
 270  *                                    name
 271  *              InAmlAddress        - Pointer to the namestring in the AML code
 272  *              OutNameString       - Where the namestring is returned
 273  *              OutNameLength       - Length of the returned string
 274  *
 275  * RETURN:      Status, namestring and length
 276  *
 277  * DESCRIPTION: Extract a full namepath from the AML byte stream,
 278  *              including any prefixes.
 279  *
 280  ******************************************************************************/
 281
 282 ACPI_STATUS
 283 AcpiExGetNameString (
 284     ACPI_OBJECT_TYPE        DataType,
 285     UINT8                   *InAmlAddress,
 286     char                    **OutNameString,
 287     UINT32                  *OutNameLength)
 288 {
 289     ACPI_STATUS             Status = AE_OK;
 290     UINT8                   *AmlAddress = InAmlAddress;
 291     char                    *NameString = NULL;
 292     UINT32                  NumSegments;
 293     UINT32                  PrefixCount = 0;
 294     BOOLEAN                 HasPrefix = FALSE;
 295
 296
 297     ACPI_FUNCTION_TRACE_PTR (ExGetNameString, AmlAddress);
 298
 299
 300     if (ACPI_TYPE_LOCAL_REGION_FIELD == DataType   ||
 301         ACPI_TYPE_LOCAL_BANK_FIELD == DataType     ||
 302         ACPI_TYPE_LOCAL_INDEX_FIELD == DataType)
 303     {
 304         /* Disallow prefixes for types associated with FieldUnit names */
 305
 306         NameString = AcpiExAllocateNameString (0, 1);
 307         if (!NameString)
 308         {
 309             Status = AE_NO_MEMORY;
 310         }
 311         else
 312         {
 313             Status = AcpiExNameSegment (&AmlAddress, NameString);
 314         }
 315     }
 316     else
 317     {
 318         /*
 319          * DataType is not a field name.
 320          * Examine first character of name for root or parent prefix operators
 321          */
 322         switch (*AmlAddress)
 323         {
 324         case AML_ROOT_PREFIX:
 325
 326             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "RootPrefix(\\) at %p\n",
 327                 AmlAddress));
 328
 329             /*
 330              * Remember that we have a RootPrefix --
 331              * see comment in AcpiExAllocateNameString()
 332              */
 333             AmlAddress++;
 334             PrefixCount = ACPI_UINT32_MAX;
 335             HasPrefix = TRUE;
 336             break;
 337
 338
 339         case AML_PARENT_PREFIX:
 340
 341             /* Increment past possibly multiple parent prefixes */
 342
 343             do
 344             {
 345                 ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "ParentPrefix (^) at %p\n",
 346                     AmlAddress));
 347
 348                 AmlAddress++;
 349                 PrefixCount++;
 350
 351             } while (*AmlAddress == AML_PARENT_PREFIX);
 352
 353             HasPrefix = TRUE;
 354             break;
 355
 356
 357         default:
 358
 359             /* Not a prefix character */
 360
 361             break;
 362         }
 363
 364         /* Examine first character of name for name segment prefix operator */
 365
 366         switch (*AmlAddress)
 367         {
 368         case AML_DUAL_NAME_PREFIX:
 369
 370             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "DualNamePrefix at %p\n",
 371                 AmlAddress));
 372
 373             AmlAddress++;
 374             NameString = AcpiExAllocateNameString (PrefixCount, 2);
 375             if (!NameString)
 376             {
 377                 Status = AE_NO_MEMORY;
 378                 break;
 379             }
 380
 381             /* Indicate that we processed a prefix */
 382
 383             HasPrefix = TRUE;
 384
 385             Status = AcpiExNameSegment (&AmlAddress, NameString);
 386             if (ACPI_SUCCESS (Status))
 387             {
 388                 Status = AcpiExNameSegment (&AmlAddress, NameString);
 389             }
 390             break;
 391
 392
 393         case AML_MULTI_NAME_PREFIX_OP:
 394
 395             ACPI_DEBUG_PRINT ((ACPI_DB_LOAD, "MultiNamePrefix at %p\n",
 396                 AmlAddress));
 397
 398             /* Fetch count of segments remaining in name path */
 399
 400             AmlAddress++;
 401             NumSegments = *AmlAddress;
 402
 403             NameString = AcpiExAllocateNameString (PrefixCount, NumSegments);
 404             if (!NameString)
 405             {
 406                 Status = AE_NO_MEMORY;
 407                 break;
 408             }
 409
 410             /* Indicate that we processed a prefix */
 411
 412             AmlAddress++;
 413             HasPrefix = TRUE;
 414
 415             while (NumSegments &&
 416                     (Status = AcpiExNameSegment (&AmlAddress, NameString)) ==
 417                         AE_OK)
 418             {
 419                 NumSegments--;
 420             }
 421
 422             break;
 423
 424
 425         case 0:
 426
 427             /* NullName valid as of 8-12-98 ASL/AML Grammar Update */
 428
 429             if (PrefixCount == ACPI_UINT32_MAX)
 430             {
 431                 ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 432                     "NameSeg is \"\\\" followed by NULL\n"));
 433             }
 434
 435             /* Consume the NULL byte */
 436
 437             AmlAddress++;
 438             NameString = AcpiExAllocateNameString (PrefixCount, 0);
 439             if (!NameString)
 440             {
 441                 Status = AE_NO_MEMORY;
 442                 break;
 443             }
 444
 445             break;
 446
 447
 448         default:
 449
 450             /* Name segment string */
 451
 452             NameString = AcpiExAllocateNameString (PrefixCount, 1);
 453             if (!NameString)
 454             {
 455                 Status = AE_NO_MEMORY;
 456                 break;
 457             }
 458
 459             Status = AcpiExNameSegment (&AmlAddress, NameString);
 460             break;
 461         }
 462     }
 463
 464     if (AE_CTRL_PENDING == Status && HasPrefix)
 465     {
 466         /* Ran out of segments after processing a prefix */
 467
 468         ACPI_ERROR ((AE_INFO,
 469             "Malformed Name at %p", NameString));
 470         Status = AE_AML_BAD_NAME;
 471     }
 472
 473     if (ACPI_FAILURE (Status))
 474     {
 475         if (NameString)
 476         {
 477             ACPI_FREE (NameString);
 478         }
 479         return_ACPI_STATUS (Status);
 480     }
 481
 482     *OutNameString = NameString;
 483     *OutNameLength = (UINT32) (AmlAddress - InAmlAddress);
 484
 485     return_ACPI_STATUS (Status);
 486 }
 487
 488