sys/contrib/dev/acpica/components/dispatcher/dsobject.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsobject - Dispatcher object management routines
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2017, 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  * Alternatively, you may choose to be licensed under the terms of the
 117  * following license:
 118  *
 119  * Redistribution and use in source and binary forms, with or without
 120  * modification, are permitted provided that the following conditions
 121  * are met:
 122  * 1. Redistributions of source code must retain the above copyright
 123  *    notice, this list of conditions, and the following disclaimer,
 124  *    without modification.
 125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 126  *    substantially similar to the "NO WARRANTY" disclaimer below
 127  *    ("Disclaimer") and any redistribution must be conditioned upon
 128  *    including a substantially similar Disclaimer requirement for further
 129  *    binary redistribution.
 130  * 3. Neither the names of the above-listed copyright holders nor the names
 131  *    of any contributors may be used to endorse or promote products derived
 132  *    from this software without specific prior written permission.
 133  *
 134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 145  *
 146  * Alternatively, you may choose to be licensed under the terms of the
 147  * GNU General Public License ("GPL") version 2 as published by the Free
 148  * Software Foundation.
 149  *
 150  *****************************************************************************/
 151
 152 #include <contrib/dev/acpica/include/acpi.h>
 153 #include <contrib/dev/acpica/include/accommon.h>
 154 #include <contrib/dev/acpica/include/acparser.h>
 155 #include <contrib/dev/acpica/include/amlcode.h>
 156 #include <contrib/dev/acpica/include/acdispat.h>
 157 #include <contrib/dev/acpica/include/acnamesp.h>
 158 #include <contrib/dev/acpica/include/acinterp.h>
 159
 160 #define _COMPONENT          ACPI_DISPATCHER
 161         ACPI_MODULE_NAME    ("dsobject")
 162
 163
 164 #ifndef ACPI_NO_METHOD_EXECUTION
 165 /*******************************************************************************
 166  *
 167  * FUNCTION:    AcpiDsBuildInternalObject
 168  *
 169  * PARAMETERS:  WalkState       - Current walk state
 170  *              Op              - Parser object to be translated
 171  *              ObjDescPtr      - Where the ACPI internal object is returned
 172  *
 173  * RETURN:      Status
 174  *
 175  * DESCRIPTION: Translate a parser Op object to the equivalent namespace object
 176  *              Simple objects are any objects other than a package object!
 177  *
 178  ******************************************************************************/
 179
 180 ACPI_STATUS
 181 AcpiDsBuildInternalObject (
 182     ACPI_WALK_STATE         *WalkState,
 183     ACPI_PARSE_OBJECT       *Op,
 184     ACPI_OPERAND_OBJECT     **ObjDescPtr)
 185 {
 186     ACPI_OPERAND_OBJECT     *ObjDesc;
 187     ACPI_STATUS             Status;
 188
 189
 190     ACPI_FUNCTION_TRACE (DsBuildInternalObject);
 191
 192
 193     *ObjDescPtr = NULL;
 194     if (Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP)
 195     {
 196         /*
 197          * This is a named object reference. If this name was
 198          * previously looked up in the namespace, it was stored in
 199          * this op. Otherwise, go ahead and look it up now
 200          */
 201         if (!Op->Common.Node)
 202         {
 203             /* Check if we are resolving a named reference within a package */
 204
 205             if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
 206                 (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
 207             {
 208                 /*
 209                  * We won't resolve package elements here, we will do this
 210                  * after all ACPI tables are loaded into the namespace. This
 211                  * behavior supports both forward references to named objects
 212                  * and external references to objects in other tables.
 213                  */
 214                 goto CreateNewObject;
 215             }
 216             else
 217             {
 218                 Status = AcpiNsLookup (WalkState->ScopeInfo,
 219                     Op->Common.Value.String,
 220                     ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 221                     ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, NULL,
 222                     ACPI_CAST_INDIRECT_PTR (
 223                         ACPI_NAMESPACE_NODE, &(Op->Common.Node)));
 224                 if (ACPI_FAILURE (Status))
 225                 {
 226                     ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo,
 227                         Op->Common.Value.String, Status);
 228                     return_ACPI_STATUS (Status);
 229                 }
 230             }
 231         }
 232     }
 233
 234 CreateNewObject:
 235
 236     /* Create and init a new internal ACPI object */
 237
 238     ObjDesc = AcpiUtCreateInternalObject (
 239         (AcpiPsGetOpcodeInfo (Op->Common.AmlOpcode))->ObjectType);
 240     if (!ObjDesc)
 241     {
 242         return_ACPI_STATUS (AE_NO_MEMORY);
 243     }
 244
 245     Status = AcpiDsInitObjectFromOp (
 246         WalkState, Op, Op->Common.AmlOpcode, &ObjDesc);
 247     if (ACPI_FAILURE (Status))
 248     {
 249         AcpiUtRemoveReference (ObjDesc);
 250         return_ACPI_STATUS (Status);
 251     }
 252
 253     /*
 254      * Handling for unresolved package reference elements.
 255      * These are elements that are namepaths.
 256      */
 257     if ((Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
 258         (Op->Common.Parent->Common.AmlOpcode == AML_VARIABLE_PACKAGE_OP))
 259     {
 260         ObjDesc->Reference.Resolved = TRUE;
 261
 262         if ((Op->Common.AmlOpcode == AML_INT_NAMEPATH_OP) &&
 263             !ObjDesc->Reference.Node)
 264         {
 265             /*
 266              * Name was unresolved above.
 267              * Get the prefix node for later lookup
 268              */
 269             ObjDesc->Reference.Node = WalkState->ScopeInfo->Scope.Node;
 270             ObjDesc->Reference.Aml = Op->Common.Aml;
 271             ObjDesc->Reference.Resolved = FALSE;
 272         }
 273     }
 274
 275     *ObjDescPtr = ObjDesc;
 276     return_ACPI_STATUS (Status);
 277 }
 278
 279
 280 /*******************************************************************************
 281  *
 282  * FUNCTION:    AcpiDsBuildInternalBufferObj
 283  *
 284  * PARAMETERS:  WalkState       - Current walk state
 285  *              Op              - Parser object to be translated
 286  *              BufferLength    - Length of the buffer
 287  *              ObjDescPtr      - Where the ACPI internal object is returned
 288  *
 289  * RETURN:      Status
 290  *
 291  * DESCRIPTION: Translate a parser Op package object to the equivalent
 292  *              namespace object
 293  *
 294  ******************************************************************************/
 295
 296 ACPI_STATUS
 297 AcpiDsBuildInternalBufferObj (
 298     ACPI_WALK_STATE         *WalkState,
 299     ACPI_PARSE_OBJECT       *Op,
 300     UINT32                  BufferLength,
 301     ACPI_OPERAND_OBJECT     **ObjDescPtr)
 302 {
 303     ACPI_PARSE_OBJECT       *Arg;
 304     ACPI_OPERAND_OBJECT     *ObjDesc;
 305     ACPI_PARSE_OBJECT       *ByteList;
 306     UINT32                  ByteListLength = 0;
 307
 308
 309     ACPI_FUNCTION_TRACE (DsBuildInternalBufferObj);
 310
 311
 312     /*
 313      * If we are evaluating a Named buffer object "Name (xxxx, Buffer)".
 314      * The buffer object already exists (from the NS node), otherwise it must
 315      * be created.
 316      */
 317     ObjDesc = *ObjDescPtr;
 318     if (!ObjDesc)
 319     {
 320         /* Create a new buffer object */
 321
 322         ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER);
 323         *ObjDescPtr = ObjDesc;
 324         if (!ObjDesc)
 325         {
 326             return_ACPI_STATUS (AE_NO_MEMORY);
 327         }
 328     }
 329
 330     /*
 331      * Second arg is the buffer data (optional) ByteList can be either
 332      * individual bytes or a string initializer. In either case, a
 333      * ByteList appears in the AML.
 334      */
 335     Arg = Op->Common.Value.Arg;         /* skip first arg */
 336
 337     ByteList = Arg->Named.Next;
 338     if (ByteList)
 339     {
 340         if (ByteList->Common.AmlOpcode != AML_INT_BYTELIST_OP)
 341         {
 342             ACPI_ERROR ((AE_INFO,
 343                 "Expecting bytelist, found AML opcode 0x%X in op %p",
 344                 ByteList->Common.AmlOpcode, ByteList));
 345
 346             AcpiUtRemoveReference (ObjDesc);
 347             return (AE_TYPE);
 348         }
 349
 350         ByteListLength = (UINT32) ByteList->Common.Value.Integer;
 351     }
 352
 353     /*
 354      * The buffer length (number of bytes) will be the larger of:
 355      * 1) The specified buffer length and
 356      * 2) The length of the initializer byte list
 357      */
 358     ObjDesc->Buffer.Length = BufferLength;
 359     if (ByteListLength > BufferLength)
 360     {
 361         ObjDesc->Buffer.Length = ByteListLength;
 362     }
 363
 364     /* Allocate the buffer */
 365
 366     if (ObjDesc->Buffer.Length == 0)
 367     {
 368         ObjDesc->Buffer.Pointer = NULL;
 369         ACPI_DEBUG_PRINT ((ACPI_DB_EXEC,
 370             "Buffer defined with zero length in AML, creating\n"));
 371     }
 372     else
 373     {
 374         ObjDesc->Buffer.Pointer =
 375             ACPI_ALLOCATE_ZEROED (ObjDesc->Buffer.Length);
 376         if (!ObjDesc->Buffer.Pointer)
 377         {
 378             AcpiUtDeleteObjectDesc (ObjDesc);
 379             return_ACPI_STATUS (AE_NO_MEMORY);
 380         }
 381
 382         /* Initialize buffer from the ByteList (if present) */
 383
 384         if (ByteList)
 385         {
 386             memcpy (ObjDesc->Buffer.Pointer, ByteList->Named.Data,
 387                 ByteListLength);
 388         }
 389     }
 390
 391     ObjDesc->Buffer.Flags |= AOPOBJ_DATA_VALID;
 392     Op->Common.Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, ObjDesc);
 393     return_ACPI_STATUS (AE_OK);
 394 }
 395
 396 /*******************************************************************************
 397  *
 398  * FUNCTION:    AcpiDsCreateNode
 399  *
 400  * PARAMETERS:  WalkState       - Current walk state
 401  *              Node            - NS Node to be initialized
 402  *              Op              - Parser object to be translated
 403  *
 404  * RETURN:      Status
 405  *
 406  * DESCRIPTION: Create the object to be associated with a namespace node
 407  *
 408  ******************************************************************************/
 409
 410 ACPI_STATUS
 411 AcpiDsCreateNode (
 412     ACPI_WALK_STATE         *WalkState,
 413     ACPI_NAMESPACE_NODE     *Node,
 414     ACPI_PARSE_OBJECT       *Op)
 415 {
 416     ACPI_STATUS             Status;
 417     ACPI_OPERAND_OBJECT     *ObjDesc;
 418
 419
 420     ACPI_FUNCTION_TRACE_PTR (DsCreateNode, Op);
 421
 422
 423     /*
 424      * Because of the execution pass through the non-control-method
 425      * parts of the table, we can arrive here twice. Only init
 426      * the named object node the first time through
 427      */
 428     if (AcpiNsGetAttachedObject (Node))
 429     {
 430         return_ACPI_STATUS (AE_OK);
 431     }
 432
 433     if (!Op->Common.Value.Arg)
 434     {
 435         /* No arguments, there is nothing to do */
 436
 437         return_ACPI_STATUS (AE_OK);
 438     }
 439
 440     /* Build an internal object for the argument(s) */
 441
 442     Status = AcpiDsBuildInternalObject (
 443         WalkState, Op->Common.Value.Arg, &ObjDesc);
 444     if (ACPI_FAILURE (Status))
 445     {
 446         return_ACPI_STATUS (Status);
 447     }
 448
 449     /* Re-type the object according to its argument */
 450
 451     Node->Type = ObjDesc->Common.Type;
 452
 453     /* Attach obj to node */
 454
 455     Status = AcpiNsAttachObject (Node, ObjDesc, Node->Type);
 456
 457     /* Remove local reference to the object */
 458
 459     AcpiUtRemoveReference (ObjDesc);
 460     return_ACPI_STATUS (Status);
 461 }
 462
 463 #endif /* ACPI_NO_METHOD_EXECUTION */
 464
 465
 466 /*******************************************************************************
 467  *
 468  * FUNCTION:    AcpiDsInitObjectFromOp
 469  *
 470  * PARAMETERS:  WalkState       - Current walk state
 471  *              Op              - Parser op used to init the internal object
 472  *              Opcode          - AML opcode associated with the object
 473  *              RetObjDesc      - Namespace object to be initialized
 474  *
 475  * RETURN:      Status
 476  *
 477  * DESCRIPTION: Initialize a namespace object from a parser Op and its
 478  *              associated arguments. The namespace object is a more compact
 479  *              representation of the Op and its arguments.
 480  *
 481  ******************************************************************************/
 482
 483 ACPI_STATUS
 484 AcpiDsInitObjectFromOp (
 485     ACPI_WALK_STATE         *WalkState,
 486     ACPI_PARSE_OBJECT       *Op,
 487     UINT16                  Opcode,
 488     ACPI_OPERAND_OBJECT     **RetObjDesc)
 489 {
 490     const ACPI_OPCODE_INFO  *OpInfo;
 491     ACPI_OPERAND_OBJECT     *ObjDesc;
 492     ACPI_STATUS             Status = AE_OK;
 493
 494
 495     ACPI_FUNCTION_TRACE (DsInitObjectFromOp);
 496
 497
 498     ObjDesc = *RetObjDesc;
 499     OpInfo = AcpiPsGetOpcodeInfo (Opcode);
 500     if (OpInfo->Class == AML_CLASS_UNKNOWN)
 501     {
 502         /* Unknown opcode */
 503
 504         return_ACPI_STATUS (AE_TYPE);
 505     }
 506
 507     /* Perform per-object initialization */
 508
 509     switch (ObjDesc->Common.Type)
 510     {
 511     case ACPI_TYPE_BUFFER:
 512         /*
 513          * Defer evaluation of Buffer TermArg operand
 514          */
 515         ObjDesc->Buffer.Node = ACPI_CAST_PTR (
 516             ACPI_NAMESPACE_NODE, WalkState->Operands[0]);
 517         ObjDesc->Buffer.AmlStart = Op->Named.Data;
 518         ObjDesc->Buffer.AmlLength = Op->Named.Length;
 519         break;
 520
 521     case ACPI_TYPE_PACKAGE:
 522         /*
 523          * Defer evaluation of Package TermArg operand and all
 524          * package elements. (01/2017): We defer the element
 525          * resolution to allow forward references from the package
 526          * in order to provide compatibility with other ACPI
 527          * implementations.
 528          */
 529         ObjDesc->Package.Node = ACPI_CAST_PTR (
 530             ACPI_NAMESPACE_NODE, WalkState->Operands[0]);
 531
 532         if (!Op->Named.Data)
 533         {
 534             return_ACPI_STATUS (AE_OK);
 535         }
 536
 537         ObjDesc->Package.AmlStart = Op->Named.Data;
 538         ObjDesc->Package.AmlLength = Op->Named.Length;
 539         break;
 540
 541     case ACPI_TYPE_INTEGER:
 542
 543         switch (OpInfo->Type)
 544         {
 545         case AML_TYPE_CONSTANT:
 546             /*
 547              * Resolve AML Constants here - AND ONLY HERE!
 548              * All constants are integers.
 549              * We mark the integer with a flag that indicates that it started
 550              * life as a constant -- so that stores to constants will perform
 551              * as expected (noop). ZeroOp is used as a placeholder for optional
 552              * target operands.
 553              */
 554             ObjDesc->Common.Flags = AOPOBJ_AML_CONSTANT;
 555
 556             switch (Opcode)
 557             {
 558             case AML_ZERO_OP:
 559
 560                 ObjDesc->Integer.Value = 0;
 561                 break;
 562
 563             case AML_ONE_OP:
 564
 565                 ObjDesc->Integer.Value = 1;
 566                 break;
 567
 568             case AML_ONES_OP:
 569
 570                 ObjDesc->Integer.Value = ACPI_UINT64_MAX;
 571
 572                 /* Truncate value if we are executing from a 32-bit ACPI table */
 573
 574 #ifndef ACPI_NO_METHOD_EXECUTION
 575                 (void) AcpiExTruncateFor32bitTable (ObjDesc);
 576 #endif
 577                 break;
 578
 579             case AML_REVISION_OP:
 580
 581                 ObjDesc->Integer.Value = ACPI_CA_VERSION;
 582                 break;
 583
 584             default:
 585
 586                 ACPI_ERROR ((AE_INFO,
 587                     "Unknown constant opcode 0x%X", Opcode));
 588                 Status = AE_AML_OPERAND_TYPE;
 589                 break;
 590             }
 591             break;
 592
 593         case AML_TYPE_LITERAL:
 594
 595             ObjDesc->Integer.Value = Op->Common.Value.Integer;
 596
 597 #ifndef ACPI_NO_METHOD_EXECUTION
 598             if (AcpiExTruncateFor32bitTable (ObjDesc))
 599             {
 600                 /* Warn if we found a 64-bit constant in a 32-bit table */
 601
 602                 ACPI_WARNING ((AE_INFO,
 603                     "Truncated 64-bit constant found in 32-bit table: %8.8X%8.8X => %8.8X",
 604                     ACPI_FORMAT_UINT64 (Op->Common.Value.Integer),
 605                     (UINT32) ObjDesc->Integer.Value));
 606             }
 607 #endif
 608             break;
 609
 610         default:
 611
 612             ACPI_ERROR ((AE_INFO, "Unknown Integer type 0x%X",
 613                 OpInfo->Type));
 614             Status = AE_AML_OPERAND_TYPE;
 615             break;
 616         }
 617         break;
 618
 619     case ACPI_TYPE_STRING:
 620
 621         ObjDesc->String.Pointer = Op->Common.Value.String;
 622         ObjDesc->String.Length = (UINT32) strlen (Op->Common.Value.String);
 623
 624         /*
 625          * The string is contained in the ACPI table, don't ever try
 626          * to delete it
 627          */
 628         ObjDesc->Common.Flags |= AOPOBJ_STATIC_POINTER;
 629         break;
 630
 631     case ACPI_TYPE_METHOD:
 632         break;
 633
 634     case ACPI_TYPE_LOCAL_REFERENCE:
 635
 636         switch (OpInfo->Type)
 637         {
 638         case AML_TYPE_LOCAL_VARIABLE:
 639
 640             /* Local ID (0-7) is (AML opcode - base AML_FIRST_LOCAL_OP) */
 641
 642             ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_LOCAL_OP;
 643             ObjDesc->Reference.Class = ACPI_REFCLASS_LOCAL;
 644
 645 #ifndef ACPI_NO_METHOD_EXECUTION
 646             Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_LOCAL,
 647                 ObjDesc->Reference.Value, WalkState,
 648                 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE,
 649                     &ObjDesc->Reference.Object));
 650 #endif
 651             break;
 652
 653         case AML_TYPE_METHOD_ARGUMENT:
 654
 655             /* Arg ID (0-6) is (AML opcode - base AML_FIRST_ARG_OP) */
 656
 657             ObjDesc->Reference.Value = ((UINT32) Opcode) - AML_FIRST_ARG_OP;
 658             ObjDesc->Reference.Class = ACPI_REFCLASS_ARG;
 659
 660 #ifndef ACPI_NO_METHOD_EXECUTION
 661             Status = AcpiDsMethodDataGetNode (ACPI_REFCLASS_ARG,
 662                 ObjDesc->Reference.Value, WalkState,
 663                 ACPI_CAST_INDIRECT_PTR (ACPI_NAMESPACE_NODE,
 664                     &ObjDesc->Reference.Object));
 665 #endif
 666             break;
 667
 668         default: /* Object name or Debug object */
 669
 670             switch (Op->Common.AmlOpcode)
 671             {
 672             case AML_INT_NAMEPATH_OP:
 673
 674                 /* Node was saved in Op */
 675
 676                 ObjDesc->Reference.Node = Op->Common.Node;
 677                 ObjDesc->Reference.Class = ACPI_REFCLASS_NAME;
 678                 if (Op->Common.Node)
 679                 {
 680                     ObjDesc->Reference.Object = Op->Common.Node->Object;
 681                 }
 682                 break;
 683
 684             case AML_DEBUG_OP:
 685
 686                 ObjDesc->Reference.Class = ACPI_REFCLASS_DEBUG;
 687                 break;
 688
 689             default:
 690
 691                 ACPI_ERROR ((AE_INFO,
 692                     "Unimplemented reference type for AML opcode: 0x%4.4X", Opcode));
 693                 return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 694             }
 695             break;
 696         }
 697         break;
 698
 699     default:
 700
 701         ACPI_ERROR ((AE_INFO, "Unimplemented data type: 0x%X",
 702             ObjDesc->Common.Type));
 703
 704         Status = AE_AML_OPERAND_TYPE;
 705         break;
 706     }
 707
 708     return_ACPI_STATUS (Status);
 709 }