reactos/drivers/bus/acpi/acpica/dispatcher/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher namespace load callbacks
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2009, 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 #define __DSWLOAD_C__
 117
 118 #include "acpi.h"
 119 #include "accommon.h"
 120 #include "acparser.h"
 121 #include "amlcode.h"
 122 #include "acdispat.h"
 123 #include "acinterp.h"
 124 #include "acnamesp.h"
 125 #include "acevents.h"
 126
 127 #ifdef ACPI_ASL_COMPILER
 128 #include "acdisasm.h"
 129 #endif
 130
 131 #define _COMPONENT          ACPI_DISPATCHER
 132         ACPI_MODULE_NAME    ("dswload")
 133
 134
 135 /*******************************************************************************
 136  *
 137  * FUNCTION:    AcpiDsInitCallbacks
 138  *
 139  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 140  *              PassNumber      - 1, 2, or 3
 141  *
 142  * RETURN:      Status
 143  *
 144  * DESCRIPTION: Init walk state callbacks
 145  *
 146  ******************************************************************************/
 147
 148 ACPI_STATUS
 149 AcpiDsInitCallbacks (
 150     ACPI_WALK_STATE         *WalkState,
 151     UINT32                  PassNumber)
 152 {
 153
 154     switch (PassNumber)
 155     {
 156     case 1:
 157         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 158                                         ACPI_PARSE_DELETE_TREE;
 159         WalkState->DescendingCallback = AcpiDsLoad1BeginOp;
 160         WalkState->AscendingCallback  = AcpiDsLoad1EndOp;
 161         break;
 162
 163     case 2:
 164         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 165                                         ACPI_PARSE_DELETE_TREE;
 166         WalkState->DescendingCallback = AcpiDsLoad2BeginOp;
 167         WalkState->AscendingCallback  = AcpiDsLoad2EndOp;
 168         break;
 169
 170     case 3:
 171 #ifndef ACPI_NO_METHOD_EXECUTION
 172         WalkState->ParseFlags        |= ACPI_PARSE_EXECUTE  |
 173                                         ACPI_PARSE_DELETE_TREE;
 174         WalkState->DescendingCallback = AcpiDsExecBeginOp;
 175         WalkState->AscendingCallback  = AcpiDsExecEndOp;
 176 #endif
 177         break;
 178
 179     default:
 180         return (AE_BAD_PARAMETER);
 181     }
 182
 183     return (AE_OK);
 184 }
 185
 186
 187 /*******************************************************************************
 188  *
 189  * FUNCTION:    AcpiDsLoad1BeginOp
 190  *
 191  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 192  *              OutOp           - Where to return op if a new one is created
 193  *
 194  * RETURN:      Status
 195  *
 196  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 197  *
 198  ******************************************************************************/
 199
 200 ACPI_STATUS
 201 AcpiDsLoad1BeginOp (
 202     ACPI_WALK_STATE         *WalkState,
 203     ACPI_PARSE_OBJECT       **OutOp)
 204 {
 205     ACPI_PARSE_OBJECT       *Op;
 206     ACPI_NAMESPACE_NODE     *Node;
 207     ACPI_STATUS             Status;
 208     ACPI_OBJECT_TYPE        ObjectType;
 209     char                    *Path;
 210     UINT32                  Flags;
 211
 212
 213     ACPI_FUNCTION_TRACE (DsLoad1BeginOp);
 214
 215
 216     Op = WalkState->Op;
 217     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 218
 219     /* We are only interested in opcodes that have an associated name */
 220
 221     if (Op)
 222     {
 223         if (!(WalkState->OpInfo->Flags & AML_NAMED))
 224         {
 225             *OutOp = Op;
 226             return_ACPI_STATUS (AE_OK);
 227         }
 228
 229         /* Check if this object has already been installed in the namespace */
 230
 231         if (Op->Common.Node)
 232         {
 233             *OutOp = Op;
 234             return_ACPI_STATUS (AE_OK);
 235         }
 236     }
 237
 238     Path = AcpiPsGetNextNamestring (&WalkState->ParserState);
 239
 240     /* Map the raw opcode into an internal object type */
 241
 242     ObjectType = WalkState->OpInfo->ObjectType;
 243
 244     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 245         "State=%p Op=%p [%s]\n", WalkState, Op, AcpiUtGetTypeName (ObjectType)));
 246
 247     switch (WalkState->Opcode)
 248     {
 249     case AML_SCOPE_OP:
 250
 251         /*
 252          * The target name of the Scope() operator must exist at this point so
 253          * that we can actually open the scope to enter new names underneath it.
 254          * Allow search-to-root for single namesegs.
 255          */
 256         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 257                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node));
 258 #ifdef ACPI_ASL_COMPILER
 259         if (Status == AE_NOT_FOUND)
 260         {
 261             /*
 262              * Table disassembly:
 263              * Target of Scope() not found. Generate an External for it, and
 264              * insert the name into the namespace.
 265              */
 266             AcpiDmAddToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0);
 267             Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 268                        ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
 269                        WalkState, &Node);
 270         }
 271 #endif
 272         if (ACPI_FAILURE (Status))
 273         {
 274             ACPI_ERROR_NAMESPACE (Path, Status);
 275             return_ACPI_STATUS (Status);
 276         }
 277
 278         /*
 279          * Check to make sure that the target is
 280          * one of the opcodes that actually opens a scope
 281          */
 282         switch (Node->Type)
 283         {
 284         case ACPI_TYPE_ANY:
 285         case ACPI_TYPE_LOCAL_SCOPE:         /* Scope  */
 286         case ACPI_TYPE_DEVICE:
 287         case ACPI_TYPE_POWER:
 288         case ACPI_TYPE_PROCESSOR:
 289         case ACPI_TYPE_THERMAL:
 290
 291             /* These are acceptable types */
 292             break;
 293
 294         case ACPI_TYPE_INTEGER:
 295         case ACPI_TYPE_STRING:
 296         case ACPI_TYPE_BUFFER:
 297
 298             /*
 299              * These types we will allow, but we will change the type.
 300              * This enables some existing code of the form:
 301              *
 302              *  Name (DEB, 0)
 303              *  Scope (DEB) { ... }
 304              *
 305              * Note: silently change the type here. On the second pass,
 306              * we will report a warning
 307              */
 308             ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 309                 "Type override - [%4.4s] had invalid type (%s) "
 310                 "for Scope operator, changed to type ANY\n",
 311                 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));
 312
 313             Node->Type = ACPI_TYPE_ANY;
 314             WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
 315             break;
 316
 317         default:
 318
 319             /* All other types are an error */
 320
 321             ACPI_ERROR ((AE_INFO,
 322                 "Invalid type (%s) for target of "
 323                 "Scope operator [%4.4s] (Cannot override)",
 324                 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));
 325
 326             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 327         }
 328         break;
 329
 330
 331     default:
 332         /*
 333          * For all other named opcodes, we will enter the name into
 334          * the namespace.
 335          *
 336          * Setup the search flags.
 337          * Since we are entering a name into the namespace, we do not want to
 338          * enable the search-to-root upsearch.
 339          *
 340          * There are only two conditions where it is acceptable that the name
 341          * already exists:
 342          *    1) the Scope() operator can reopen a scoping object that was
 343          *       previously defined (Scope, Method, Device, etc.)
 344          *    2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
 345          *       BufferField, or Package), the name of the object is already
 346          *       in the namespace.
 347          */
 348         if (WalkState->DeferredNode)
 349         {
 350             /* This name is already in the namespace, get the node */
 351
 352             Node = WalkState->DeferredNode;
 353             Status = AE_OK;
 354             break;
 355         }
 356
 357         /*
 358          * If we are executing a method, do not create any namespace objects
 359          * during the load phase, only during execution.
 360          */
 361         if (WalkState->MethodNode)
 362         {
 363             Node = NULL;
 364             Status = AE_OK;
 365             break;
 366         }
 367
 368         Flags = ACPI_NS_NO_UPSEARCH;
 369         if ((WalkState->Opcode != AML_SCOPE_OP) &&
 370             (!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)))
 371         {
 372             Flags |= ACPI_NS_ERROR_IF_FOUND;
 373             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
 374                     AcpiUtGetTypeName (ObjectType)));
 375         }
 376         else
 377         {
 378             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 379                 "[%s] Both Find or Create allowed\n",
 380                     AcpiUtGetTypeName (ObjectType)));
 381         }
 382
 383         /*
 384          * Enter the named type into the internal namespace. We enter the name
 385          * as we go downward in the parse tree. Any necessary subobjects that
 386          * involve arguments to the opcode must be created as we go back up the
 387          * parse tree later.
 388          */
 389         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 390                         ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
 391         if (ACPI_FAILURE (Status))
 392         {
 393             if (Status == AE_ALREADY_EXISTS)
 394             {
 395                 /* The name already exists in this scope */
 396
 397                 if (Node->Flags & ANOBJ_IS_EXTERNAL)
 398                 {
 399                     /*
 400                      * Allow one create on an object or segment that was
 401                      * previously declared External
 402                      */
 403                     Node->Flags &= ~ANOBJ_IS_EXTERNAL;
 404                     Node->Type = (UINT8) ObjectType;
 405
 406                     /* Just retyped a node, probably will need to open a scope */
 407
 408                     if (AcpiNsOpensScope (ObjectType))
 409                     {
 410                         Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 411                         if (ACPI_FAILURE (Status))
 412                         {
 413                             return_ACPI_STATUS (Status);
 414                         }
 415                     }
 416
 417                     Status = AE_OK;
 418                 }
 419             }
 420
 421             if (ACPI_FAILURE (Status))
 422             {
 423                 ACPI_ERROR_NAMESPACE (Path, Status);
 424                 return_ACPI_STATUS (Status);
 425             }
 426         }
 427         break;
 428     }
 429
 430     /* Common exit */
 431
 432     if (!Op)
 433     {
 434         /* Create a new op */
 435
 436         Op = AcpiPsAllocOp (WalkState->Opcode);
 437         if (!Op)
 438         {
 439             return_ACPI_STATUS (AE_NO_MEMORY);
 440         }
 441     }
 442
 443     /* Initialize the op */
 444
 445 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
 446     Op->Named.Path = ACPI_CAST_PTR (UINT8, Path);
 447 #endif
 448
 449     if (Node)
 450     {
 451         /*
 452          * Put the Node in the "op" object that the parser uses, so we
 453          * can get it again quickly when this scope is closed
 454          */
 455         Op->Common.Node = Node;
 456         Op->Named.Name = Node->Name.Integer;
 457     }
 458
 459     AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op);
 460     *OutOp = Op;
 461     return_ACPI_STATUS (Status);
 462 }
 463
 464
 465 /*******************************************************************************
 466  *
 467  * FUNCTION:    AcpiDsLoad1EndOp
 468  *
 469  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 470  *
 471  * RETURN:      Status
 472  *
 473  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 474  *              both control methods and everything else.
 475  *
 476  ******************************************************************************/
 477
 478 ACPI_STATUS
 479 AcpiDsLoad1EndOp (
 480     ACPI_WALK_STATE         *WalkState)
 481 {
 482     ACPI_PARSE_OBJECT       *Op;
 483     ACPI_OBJECT_TYPE        ObjectType;
 484     ACPI_STATUS             Status = AE_OK;
 485
 486
 487     ACPI_FUNCTION_TRACE (DsLoad1EndOp);
 488
 489
 490     Op = WalkState->Op;
 491     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 492
 493     /* We are only interested in opcodes that have an associated name */
 494
 495     if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_FIELD)))
 496     {
 497         return_ACPI_STATUS (AE_OK);
 498     }
 499
 500     /* Get the object type to determine if we should pop the scope */
 501
 502     ObjectType = WalkState->OpInfo->ObjectType;
 503
 504 #ifndef ACPI_NO_METHOD_EXECUTION
 505     if (WalkState->OpInfo->Flags & AML_FIELD)
 506     {
 507         /*
 508          * If we are executing a method, do not create any namespace objects
 509          * during the load phase, only during execution.
 510          */
 511         if (!WalkState->MethodNode)
 512         {
 513             if (WalkState->Opcode == AML_FIELD_OP          ||
 514                 WalkState->Opcode == AML_BANK_FIELD_OP     ||
 515                 WalkState->Opcode == AML_INDEX_FIELD_OP)
 516             {
 517                 Status = AcpiDsInitFieldObjects (Op, WalkState);
 518             }
 519         }
 520         return_ACPI_STATUS (Status);
 521     }
 522
 523     /*
 524      * If we are executing a method, do not create any namespace objects
 525      * during the load phase, only during execution.
 526      */
 527     if (!WalkState->MethodNode)
 528     {
 529         if (Op->Common.AmlOpcode == AML_REGION_OP)
 530         {
 531             Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
 532                         (ACPI_ADR_SPACE_TYPE) ((Op->Common.Value.Arg)->Common.Value.Integer),
 533                         WalkState);
 534             if (ACPI_FAILURE (Status))
 535             {
 536                 return_ACPI_STATUS (Status);
 537             }
 538         }
 539         else if (Op->Common.AmlOpcode == AML_DATA_REGION_OP)
 540         {
 541             Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
 542                         REGION_DATA_TABLE, WalkState);
 543             if (ACPI_FAILURE (Status))
 544             {
 545                 return_ACPI_STATUS (Status);
 546             }
 547         }
 548     }
 549 #endif
 550
 551     if (Op->Common.AmlOpcode == AML_NAME_OP)
 552     {
 553         /* For Name opcode, get the object type from the argument */
 554
 555         if (Op->Common.Value.Arg)
 556         {
 557             ObjectType = (AcpiPsGetOpcodeInfo (
 558                 (Op->Common.Value.Arg)->Common.AmlOpcode))->ObjectType;
 559
 560             /* Set node type if we have a namespace node */
 561
 562             if (Op->Common.Node)
 563             {
 564                 Op->Common.Node->Type = (UINT8) ObjectType;
 565             }
 566         }
 567     }
 568
 569     /*
 570      * If we are executing a method, do not create any namespace objects
 571      * during the load phase, only during execution.
 572      */
 573     if (!WalkState->MethodNode)
 574     {
 575         if (Op->Common.AmlOpcode == AML_METHOD_OP)
 576         {
 577             /*
 578              * MethodOp PkgLength NameString MethodFlags TermList
 579              *
 580              * Note: We must create the method node/object pair as soon as we
 581              * see the method declaration. This allows later pass1 parsing
 582              * of invocations of the method (need to know the number of
 583              * arguments.)
 584              */
 585             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 586                 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
 587                 WalkState, Op, Op->Named.Node));
 588
 589             if (!AcpiNsGetAttachedObject (Op->Named.Node))
 590             {
 591                 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
 592                 WalkState->NumOperands = 1;
 593
 594                 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg);
 595                 if (ACPI_SUCCESS (Status))
 596                 {
 597                     Status = AcpiExCreateMethod (Op->Named.Data,
 598                                         Op->Named.Length, WalkState);
 599                 }
 600
 601                 WalkState->Operands[0] = NULL;
 602                 WalkState->NumOperands = 0;
 603
 604                 if (ACPI_FAILURE (Status))
 605                 {
 606                     return_ACPI_STATUS (Status);
 607                 }
 608             }
 609         }
 610     }
 611
 612     /* Pop the scope stack (only if loading a table) */
 613
 614     if (!WalkState->MethodNode &&
 615         AcpiNsOpensScope (ObjectType))
 616     {
 617         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
 618             AcpiUtGetTypeName (ObjectType), Op));
 619
 620         Status = AcpiDsScopeStackPop (WalkState);
 621     }
 622
 623     return_ACPI_STATUS (Status);
 624 }
 625
 626
 627 /*******************************************************************************
 628  *
 629  * FUNCTION:    AcpiDsLoad2BeginOp
 630  *
 631  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 632  *              OutOp           - Wher to return op if a new one is created
 633  *
 634  * RETURN:      Status
 635  *
 636  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 637  *
 638  ******************************************************************************/
 639
 640 ACPI_STATUS
 641 AcpiDsLoad2BeginOp (
 642     ACPI_WALK_STATE         *WalkState,
 643     ACPI_PARSE_OBJECT       **OutOp)
 644 {
 645     ACPI_PARSE_OBJECT       *Op;
 646     ACPI_NAMESPACE_NODE     *Node;
 647     ACPI_STATUS             Status;
 648     ACPI_OBJECT_TYPE        ObjectType;
 649     char                    *BufferPtr;
 650     UINT32                  Flags;
 651
 652
 653     ACPI_FUNCTION_TRACE (DsLoad2BeginOp);
 654
 655
 656     Op = WalkState->Op;
 657     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 658
 659     if (Op)
 660     {
 661         if ((WalkState->ControlState) &&
 662             (WalkState->ControlState->Common.State ==
 663                 ACPI_CONTROL_CONDITIONAL_EXECUTING))
 664         {
 665             /* We are executing a while loop outside of a method */
 666
 667             Status = AcpiDsExecBeginOp (WalkState, OutOp);
 668             return_ACPI_STATUS (Status);
 669         }
 670
 671         /* We only care about Namespace opcodes here */
 672
 673         if ((!(WalkState->OpInfo->Flags & AML_NSOPCODE)   &&
 674               (WalkState->Opcode != AML_INT_NAMEPATH_OP)) ||
 675             (!(WalkState->OpInfo->Flags & AML_NAMED)))
 676         {
 677             return_ACPI_STATUS (AE_OK);
 678         }
 679
 680         /* Get the name we are going to enter or lookup in the namespace */
 681
 682         if (WalkState->Opcode == AML_INT_NAMEPATH_OP)
 683         {
 684             /* For Namepath op, get the path string */
 685
 686             BufferPtr = Op->Common.Value.String;
 687             if (!BufferPtr)
 688             {
 689                 /* No name, just exit */
 690
 691                 return_ACPI_STATUS (AE_OK);
 692             }
 693         }
 694         else
 695         {
 696             /* Get name from the op */
 697
 698             BufferPtr = ACPI_CAST_PTR (char, &Op->Named.Name);
 699         }
 700     }
 701     else
 702     {
 703         /* Get the namestring from the raw AML */
 704
 705         BufferPtr = AcpiPsGetNextNamestring (&WalkState->ParserState);
 706     }
 707
 708     /* Map the opcode into an internal object type */
 709
 710     ObjectType = WalkState->OpInfo->ObjectType;
 711
 712     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 713         "State=%p Op=%p Type=%X\n", WalkState, Op, ObjectType));
 714
 715     switch (WalkState->Opcode)
 716     {
 717     case AML_FIELD_OP:
 718     case AML_BANK_FIELD_OP:
 719     case AML_INDEX_FIELD_OP:
 720
 721         Node = NULL;
 722         Status = AE_OK;
 723         break;
 724
 725     case AML_INT_NAMEPATH_OP:
 726         /*
 727          * The NamePath is an object reference to an existing object.
 728          * Don't enter the name into the namespace, but look it up
 729          * for use later.
 730          */
 731         Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 732                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 733                         WalkState, &(Node));
 734         break;
 735
 736     case AML_SCOPE_OP:
 737
 738         /* Special case for Scope(\) -> refers to the Root node */
 739
 740         if (Op && (Op->Named.Node == AcpiGbl_RootNode))
 741         {
 742             Node = Op->Named.Node;
 743
 744             Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 745             if (ACPI_FAILURE (Status))
 746             {
 747                 return_ACPI_STATUS (Status);
 748             }
 749         }
 750         else
 751         {
 752             /*
 753              * The Path is an object reference to an existing object.
 754              * Don't enter the name into the namespace, but look it up
 755              * for use later.
 756              */
 757             Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 758                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 759                         WalkState, &(Node));
 760             if (ACPI_FAILURE (Status))
 761             {
 762 #ifdef ACPI_ASL_COMPILER
 763                 if (Status == AE_NOT_FOUND)
 764                 {
 765                     Status = AE_OK;
 766                 }
 767                 else
 768                 {
 769                     ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 770                 }
 771 #else
 772                 ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 773 #endif
 774                 return_ACPI_STATUS (Status);
 775             }
 776         }
 777
 778         /*
 779          * We must check to make sure that the target is
 780          * one of the opcodes that actually opens a scope
 781          */
 782         switch (Node->Type)
 783         {
 784         case ACPI_TYPE_ANY:
 785         case ACPI_TYPE_LOCAL_SCOPE:         /* Scope */
 786         case ACPI_TYPE_DEVICE:
 787         case ACPI_TYPE_POWER:
 788         case ACPI_TYPE_PROCESSOR:
 789         case ACPI_TYPE_THERMAL:
 790
 791             /* These are acceptable types */
 792             break;
 793
 794         case ACPI_TYPE_INTEGER:
 795         case ACPI_TYPE_STRING:
 796         case ACPI_TYPE_BUFFER:
 797
 798             /*
 799              * These types we will allow, but we will change the type.
 800              * This enables some existing code of the form:
 801              *
 802              *  Name (DEB, 0)
 803              *  Scope (DEB) { ... }
 804              */
 805             ACPI_WARNING ((AE_INFO,
 806                 "Type override - [%4.4s] had invalid type (%s) "
 807                 "for Scope operator, changed to type ANY\n",
 808                 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));
 809
 810             Node->Type = ACPI_TYPE_ANY;
 811             WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
 812             break;
 813
 814         default:
 815
 816             /* All other types are an error */
 817
 818             ACPI_ERROR ((AE_INFO,
 819                 "Invalid type (%s) for target of "
 820                 "Scope operator [%4.4s] (Cannot override)",
 821                 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));
 822
 823             return (AE_AML_OPERAND_TYPE);
 824         }
 825         break;
 826
 827     default:
 828
 829         /* All other opcodes */
 830
 831         if (Op && Op->Common.Node)
 832         {
 833             /* This op/node was previously entered into the namespace */
 834
 835             Node = Op->Common.Node;
 836
 837             if (AcpiNsOpensScope (ObjectType))
 838             {
 839                 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 840                 if (ACPI_FAILURE (Status))
 841                 {
 842                     return_ACPI_STATUS (Status);
 843                 }
 844             }
 845
 846             return_ACPI_STATUS (AE_OK);
 847         }
 848
 849         /*
 850          * Enter the named type into the internal namespace. We enter the name
 851          * as we go downward in the parse tree. Any necessary subobjects that
 852          * involve arguments to the opcode must be created as we go back up the
 853          * parse tree later.
 854          *
 855          * Note: Name may already exist if we are executing a deferred opcode.
 856          */
 857         if (WalkState->DeferredNode)
 858         {
 859             /* This name is already in the namespace, get the node */
 860
 861             Node = WalkState->DeferredNode;
 862             Status = AE_OK;
 863             break;
 864         }
 865
 866         Flags = ACPI_NS_NO_UPSEARCH;
 867         if (WalkState->PassNumber == ACPI_IMODE_EXECUTE)
 868         {
 869             /* Execution mode, node cannot already exist, node is temporary */
 870
 871             Flags |= ACPI_NS_ERROR_IF_FOUND;
 872
 873             if (!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
 874             {
 875                 Flags |= ACPI_NS_TEMPORARY;
 876             }
 877         }
 878
 879         /* Add new entry or lookup existing entry */
 880
 881         Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType,
 882                     ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node);
 883
 884         if (ACPI_SUCCESS (Status) && (Flags & ACPI_NS_TEMPORARY))
 885         {
 886             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 887                 "***New Node [%4.4s] %p is temporary\n",
 888                 AcpiUtGetNodeName (Node), Node));
 889         }
 890         break;
 891     }
 892
 893     if (ACPI_FAILURE (Status))
 894     {
 895         ACPI_ERROR_NAMESPACE (BufferPtr, Status);
 896         return_ACPI_STATUS (Status);
 897     }
 898
 899     if (!Op)
 900     {
 901         /* Create a new op */
 902
 903         Op = AcpiPsAllocOp (WalkState->Opcode);
 904         if (!Op)
 905         {
 906             return_ACPI_STATUS (AE_NO_MEMORY);
 907         }
 908
 909         /* Initialize the new op */
 910
 911         if (Node)
 912         {
 913             Op->Named.Name = Node->Name.Integer;
 914         }
 915         *OutOp = Op;
 916     }
 917
 918     /*
 919      * Put the Node in the "op" object that the parser uses, so we
 920      * can get it again quickly when this scope is closed
 921      */
 922     Op->Common.Node = Node;
 923     return_ACPI_STATUS (Status);
 924 }
 925
 926
 927 /*******************************************************************************
 928  *
 929  * FUNCTION:    AcpiDsLoad2EndOp
 930  *
 931  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 932  *
 933  * RETURN:      Status
 934  *
 935  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 936  *              both control methods and everything else.
 937  *
 938  ******************************************************************************/
 939
 940 ACPI_STATUS
 941 AcpiDsLoad2EndOp (
 942     ACPI_WALK_STATE         *WalkState)
 943 {
 944     ACPI_PARSE_OBJECT       *Op;
 945     ACPI_STATUS             Status = AE_OK;
 946     ACPI_OBJECT_TYPE        ObjectType;
 947     ACPI_NAMESPACE_NODE     *Node;
 948     ACPI_PARSE_OBJECT       *Arg;
 949     ACPI_NAMESPACE_NODE     *NewNode;
 950 #ifndef ACPI_NO_METHOD_EXECUTION
 951     UINT32                  i;
 952     UINT8                   RegionSpace;
 953 #endif
 954
 955
 956     ACPI_FUNCTION_TRACE (DsLoad2EndOp);
 957
 958     Op = WalkState->Op;
 959     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n",
 960             WalkState->OpInfo->Name, Op, WalkState));
 961
 962     /* Check if opcode had an associated namespace object */
 963
 964     if (!(WalkState->OpInfo->Flags & AML_NSOBJECT))
 965     {
 966         return_ACPI_STATUS (AE_OK);
 967     }
 968
 969     if (Op->Common.AmlOpcode == AML_SCOPE_OP)
 970     {
 971         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 972             "Ending scope Op=%p State=%p\n", Op, WalkState));
 973     }
 974
 975     ObjectType = WalkState->OpInfo->ObjectType;
 976
 977     /*
 978      * Get the Node/name from the earlier lookup
 979      * (It was saved in the *op structure)
 980      */
 981     Node = Op->Common.Node;
 982
 983     /*
 984      * Put the Node on the object stack (Contains the ACPI Name of
 985      * this object)
 986      */
 987     WalkState->Operands[0] = (void *) Node;
 988     WalkState->NumOperands = 1;
 989
 990     /* Pop the scope stack */
 991
 992     if (AcpiNsOpensScope (ObjectType) &&
 993        (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP))
 994     {
 995         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n",
 996             AcpiUtGetTypeName (ObjectType), Op));
 997
 998         Status = AcpiDsScopeStackPop (WalkState);
 999         if (ACPI_FAILURE (Status))
1000         {
1001             goto Cleanup;
1002         }
1003     }
1004
1005     /*
1006      * Named operations are as follows:
1007      *
1008      * AML_ALIAS
1009      * AML_BANKFIELD
1010      * AML_CREATEBITFIELD
1011      * AML_CREATEBYTEFIELD
1012      * AML_CREATEDWORDFIELD
1013      * AML_CREATEFIELD
1014      * AML_CREATEQWORDFIELD
1015      * AML_CREATEWORDFIELD
1016      * AML_DATA_REGION
1017      * AML_DEVICE
1018      * AML_EVENT
1019      * AML_FIELD
1020      * AML_INDEXFIELD
1021      * AML_METHOD
1022      * AML_METHODCALL
1023      * AML_MUTEX
1024      * AML_NAME
1025      * AML_NAMEDFIELD
1026      * AML_OPREGION
1027      * AML_POWERRES
1028      * AML_PROCESSOR
1029      * AML_SCOPE
1030      * AML_THERMALZONE
1031      */
1032
1033     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1034         "Create-Load [%s] State=%p Op=%p NamedObj=%p\n",
1035         AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node));
1036
1037     /* Decode the opcode */
1038
1039     Arg = Op->Common.Value.Arg;
1040
1041     switch (WalkState->OpInfo->Type)
1042     {
1043 #ifndef ACPI_NO_METHOD_EXECUTION
1044
1045     case AML_TYPE_CREATE_FIELD:
1046         /*
1047          * Create the field object, but the field buffer and index must
1048          * be evaluated later during the execution phase
1049          */
1050         Status = AcpiDsCreateBufferField (Op, WalkState);
1051         break;
1052
1053
1054      case AML_TYPE_NAMED_FIELD:
1055         /*
1056          * If we are executing a method, initialize the field
1057          */
1058         if (WalkState->MethodNode)
1059         {
1060             Status = AcpiDsInitFieldObjects (Op, WalkState);
1061         }
1062
1063         switch (Op->Common.AmlOpcode)
1064         {
1065         case AML_INDEX_FIELD_OP:
1066
1067             Status = AcpiDsCreateIndexField (Op, (ACPI_HANDLE) Arg->Common.Node,
1068                         WalkState);
1069             break;
1070
1071         case AML_BANK_FIELD_OP:
1072
1073             Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState);
1074             break;
1075
1076         case AML_FIELD_OP:
1077
1078             Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState);
1079             break;
1080
1081         default:
1082             /* All NAMED_FIELD opcodes must be handled above */
1083             break;
1084         }
1085         break;
1086
1087
1088      case AML_TYPE_NAMED_SIMPLE:
1089
1090         Status = AcpiDsCreateOperands (WalkState, Arg);
1091         if (ACPI_FAILURE (Status))
1092         {
1093             goto Cleanup;
1094         }
1095
1096         switch (Op->Common.AmlOpcode)
1097         {
1098         case AML_PROCESSOR_OP:
1099
1100             Status = AcpiExCreateProcessor (WalkState);
1101             break;
1102
1103         case AML_POWER_RES_OP:
1104
1105             Status = AcpiExCreatePowerResource (WalkState);
1106             break;
1107
1108         case AML_MUTEX_OP:
1109
1110             Status = AcpiExCreateMutex (WalkState);
1111             break;
1112
1113         case AML_EVENT_OP:
1114
1115             Status = AcpiExCreateEvent (WalkState);
1116             break;
1117
1118
1119         case AML_ALIAS_OP:
1120
1121             Status = AcpiExCreateAlias (WalkState);
1122             break;
1123
1124         default:
1125             /* Unknown opcode */
1126
1127             Status = AE_OK;
1128             goto Cleanup;
1129         }
1130
1131         /* Delete operands */
1132
1133         for (i = 1; i < WalkState->NumOperands; i++)
1134         {
1135             AcpiUtRemoveReference (WalkState->Operands[i]);
1136             WalkState->Operands[i] = NULL;
1137         }
1138
1139         break;
1140 #endif /* ACPI_NO_METHOD_EXECUTION */
1141
1142     case AML_TYPE_NAMED_COMPLEX:
1143
1144         switch (Op->Common.AmlOpcode)
1145         {
1146 #ifndef ACPI_NO_METHOD_EXECUTION
1147         case AML_REGION_OP:
1148         case AML_DATA_REGION_OP:
1149
1150             if (Op->Common.AmlOpcode == AML_REGION_OP)
1151             {
1152                 RegionSpace = (ACPI_ADR_SPACE_TYPE)
1153                       ((Op->Common.Value.Arg)->Common.Value.Integer);
1154             }
1155             else
1156             {
1157                 RegionSpace = REGION_DATA_TABLE;
1158             }
1159
1160             /*
1161              * The OpRegion is not fully parsed at this time. The only valid
1162              * argument is the SpaceId. (We must save the address of the
1163              * AML of the address and length operands)
1164              *
1165              * If we have a valid region, initialize it. The namespace is
1166              * unlocked at this point.
1167              *
1168              * Need to unlock interpreter if it is locked (if we are running
1169              * a control method), in order to allow _REG methods to be run
1170              * during AcpiEvInitializeRegion.
1171              */
1172             if (WalkState->MethodNode)
1173             {
1174                 /*
1175                  * Executing a method: initialize the region and unlock
1176                  * the interpreter
1177                  */
1178                 Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
1179                             RegionSpace, WalkState);
1180                 if (ACPI_FAILURE (Status))
1181                 {
1182                     return (Status);
1183                 }
1184
1185                 AcpiExExitInterpreter ();
1186             }
1187
1188             Status = AcpiEvInitializeRegion (AcpiNsGetAttachedObject (Node),
1189                         FALSE);
1190             if (WalkState->MethodNode)
1191             {
1192                 AcpiExEnterInterpreter ();
1193             }
1194
1195             if (ACPI_FAILURE (Status))
1196             {
1197                 /*
1198                  *  If AE_NOT_EXIST is returned, it is not fatal
1199                  *  because many regions get created before a handler
1200                  *  is installed for said region.
1201                  */
1202                 if (AE_NOT_EXIST == Status)
1203                 {
1204                     Status = AE_OK;
1205                 }
1206             }
1207             break;
1208
1209
1210         case AML_NAME_OP:
1211
1212             Status = AcpiDsCreateNode (WalkState, Node, Op);
1213             break;
1214
1215
1216         case AML_METHOD_OP:
1217             /*
1218              * MethodOp PkgLength NameString MethodFlags TermList
1219              *
1220              * Note: We must create the method node/object pair as soon as we
1221              * see the method declaration. This allows later pass1 parsing
1222              * of invocations of the method (need to know the number of
1223              * arguments.)
1224              */
1225             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1226                 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
1227                 WalkState, Op, Op->Named.Node));
1228
1229             if (!AcpiNsGetAttachedObject (Op->Named.Node))
1230             {
1231                 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
1232                 WalkState->NumOperands = 1;
1233
1234                 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg);
1235                 if (ACPI_SUCCESS (Status))
1236                 {
1237                     Status = AcpiExCreateMethod (Op->Named.Data,
1238                                         Op->Named.Length, WalkState);
1239                 }
1240                 WalkState->Operands[0] = NULL;
1241                 WalkState->NumOperands = 0;
1242
1243                 if (ACPI_FAILURE (Status))
1244                 {
1245                     return_ACPI_STATUS (Status);
1246                 }
1247             }
1248             break;
1249
1250 #endif /* ACPI_NO_METHOD_EXECUTION */
1251
1252         default:
1253             /* All NAMED_COMPLEX opcodes must be handled above */
1254             break;
1255         }
1256         break;
1257
1258
1259     case AML_CLASS_INTERNAL:
1260
1261         /* case AML_INT_NAMEPATH_OP: */
1262         break;
1263
1264
1265     case AML_CLASS_METHOD_CALL:
1266
1267         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
1268             "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n",
1269             WalkState, Op, Node));
1270
1271         /*
1272          * Lookup the method name and save the Node
1273          */
1274         Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String,
1275                         ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2,
1276                         ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE,
1277                         WalkState, &(NewNode));
1278         if (ACPI_SUCCESS (Status))
1279         {
1280             /*
1281              * Make sure that what we found is indeed a method
1282              * We didn't search for a method on purpose, to see if the name
1283              * would resolve
1284              */
1285             if (NewNode->Type != ACPI_TYPE_METHOD)
1286             {
1287                 Status = AE_AML_OPERAND_TYPE;
1288             }
1289
1290             /* We could put the returned object (Node) on the object stack for
1291              * later, but for now, we will put it in the "op" object that the
1292              * parser uses, so we can get it again at the end of this scope
1293              */
1294             Op->Common.Node = NewNode;
1295         }
1296         else
1297         {
1298             ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status);
1299         }
1300         break;
1301
1302
1303     default:
1304         break;
1305     }
1306
1307 Cleanup:
1308
1309     /* Remove the Node pushed at the very beginning */
1310
1311     WalkState->Operands[0] = NULL;
1312     WalkState->NumOperands = 0;
1313     return_ACPI_STATUS (Status);
1314 }
1315
1316