drivers/acpi/components/dispatcher/dswload.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dswload - Dispatcher first pass namespace load callbacks
   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 "acparser.h"
 119 #include "amlcode.h"
 120 #include "acdispat.h"
 121 #include "acinterp.h"
 122 #include "acnamesp.h"
 123
 124 #ifdef ACPI_ASL_COMPILER
 125 #include "acdisasm.h"
 126 #endif
 127
 128 #define _COMPONENT          ACPI_DISPATCHER
 129         ACPI_MODULE_NAME    ("dswload")
 130
 131
 132 /*******************************************************************************
 133  *
 134  * FUNCTION:    AcpiDsInitCallbacks
 135  *
 136  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 137  *              PassNumber      - 1, 2, or 3
 138  *
 139  * RETURN:      Status
 140  *
 141  * DESCRIPTION: Init walk state callbacks
 142  *
 143  ******************************************************************************/
 144
 145 ACPI_STATUS
 146 AcpiDsInitCallbacks (
 147     ACPI_WALK_STATE         *WalkState,
 148     UINT32                  PassNumber)
 149 {
 150
 151     switch (PassNumber)
 152     {
 153     case 0:
 154
 155         /* Parse only - caller will setup callbacks */
 156
 157         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 158                                         ACPI_PARSE_DELETE_TREE |
 159                                         ACPI_PARSE_DISASSEMBLE;
 160         WalkState->DescendingCallback = NULL;
 161         WalkState->AscendingCallback  = NULL;
 162         break;
 163
 164     case 1:
 165
 166         /* Load pass 1 */
 167
 168         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 169                                         ACPI_PARSE_DELETE_TREE;
 170         WalkState->DescendingCallback = AcpiDsLoad1BeginOp;
 171         WalkState->AscendingCallback  = AcpiDsLoad1EndOp;
 172         break;
 173
 174     case 2:
 175
 176         /* Load pass 2 */
 177
 178         WalkState->ParseFlags         = ACPI_PARSE_LOAD_PASS1 |
 179                                         ACPI_PARSE_DELETE_TREE;
 180         WalkState->DescendingCallback = AcpiDsLoad2BeginOp;
 181         WalkState->AscendingCallback  = AcpiDsLoad2EndOp;
 182         break;
 183
 184     case 3:
 185
 186         /* Execution pass */
 187
 188 #ifndef ACPI_NO_METHOD_EXECUTION
 189         WalkState->ParseFlags        |= ACPI_PARSE_EXECUTE  |
 190                                         ACPI_PARSE_DELETE_TREE;
 191         WalkState->DescendingCallback = AcpiDsExecBeginOp;
 192         WalkState->AscendingCallback  = AcpiDsExecEndOp;
 193 #endif
 194         break;
 195
 196     default:
 197
 198         return (AE_BAD_PARAMETER);
 199     }
 200
 201     return (AE_OK);
 202 }
 203
 204
 205 /*******************************************************************************
 206  *
 207  * FUNCTION:    AcpiDsLoad1BeginOp
 208  *
 209  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 210  *              OutOp           - Where to return op if a new one is created
 211  *
 212  * RETURN:      Status
 213  *
 214  * DESCRIPTION: Descending callback used during the loading of ACPI tables.
 215  *
 216  ******************************************************************************/
 217
 218 ACPI_STATUS
 219 AcpiDsLoad1BeginOp (
 220     ACPI_WALK_STATE         *WalkState,
 221     ACPI_PARSE_OBJECT       **OutOp)
 222 {
 223     ACPI_PARSE_OBJECT       *Op;
 224     ACPI_NAMESPACE_NODE     *Node;
 225     ACPI_STATUS             Status;
 226     ACPI_OBJECT_TYPE        ObjectType;
 227     char                    *Path;
 228     UINT32                  Flags;
 229
 230
 231     ACPI_FUNCTION_TRACE (DsLoad1BeginOp);
 232
 233
 234     Op = WalkState->Op;
 235     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 236
 237     /* We are only interested in opcodes that have an associated name */
 238
 239     if (Op)
 240     {
 241         if (!(WalkState->OpInfo->Flags & AML_NAMED))
 242         {
 243             *OutOp = Op;
 244             return_ACPI_STATUS (AE_OK);
 245         }
 246
 247         /* Check if this object has already been installed in the namespace */
 248
 249         if (Op->Common.Node)
 250         {
 251             *OutOp = Op;
 252             return_ACPI_STATUS (AE_OK);
 253         }
 254     }
 255
 256     Path = AcpiPsGetNextNamestring (&WalkState->ParserState);
 257
 258     /* Map the raw opcode into an internal object type */
 259
 260     ObjectType = WalkState->OpInfo->ObjectType;
 261
 262     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 263         "State=%p Op=%p [%s]\n", WalkState, Op, AcpiUtGetTypeName (ObjectType)));
 264
 265     switch (WalkState->Opcode)
 266     {
 267     case AML_SCOPE_OP:
 268         /*
 269          * The target name of the Scope() operator must exist at this point so
 270          * that we can actually open the scope to enter new names underneath it.
 271          * Allow search-to-root for single namesegs.
 272          */
 273         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 274                         ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node));
 275 #ifdef ACPI_ASL_COMPILER
 276         if (Status == AE_NOT_FOUND)
 277         {
 278             /*
 279              * Table disassembly:
 280              * Target of Scope() not found. Generate an External for it, and
 281              * insert the name into the namespace.
 282              */
 283             AcpiDmAddOpToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0, 0);
 284             Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 285                        ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
 286                        WalkState, &Node);
 287         }
 288 #endif
 289         if (ACPI_FAILURE (Status))
 290         {
 291             ACPI_ERROR_NAMESPACE (Path, Status);
 292             return_ACPI_STATUS (Status);
 293         }
 294
 295         /*
 296          * Check to make sure that the target is
 297          * one of the opcodes that actually opens a scope
 298          */
 299         switch (Node->Type)
 300         {
 301         case ACPI_TYPE_ANY:
 302         case ACPI_TYPE_LOCAL_SCOPE:         /* Scope  */
 303         case ACPI_TYPE_DEVICE:
 304         case ACPI_TYPE_POWER:
 305         case ACPI_TYPE_PROCESSOR:
 306         case ACPI_TYPE_THERMAL:
 307
 308             /* These are acceptable types */
 309             break;
 310
 311         case ACPI_TYPE_INTEGER:
 312         case ACPI_TYPE_STRING:
 313         case ACPI_TYPE_BUFFER:
 314             /*
 315              * These types we will allow, but we will change the type.
 316              * This enables some existing code of the form:
 317              *
 318              *  Name (DEB, 0)
 319              *  Scope (DEB) { ... }
 320              *
 321              * Note: silently change the type here. On the second pass,
 322              * we will report a warning
 323              */
 324             ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
 325                 "Type override - [%4.4s] had invalid type (%s) "
 326                 "for Scope operator, changed to type ANY\n",
 327                 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));
 328
 329             Node->Type = ACPI_TYPE_ANY;
 330             WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
 331             break;
 332
 333         case ACPI_TYPE_METHOD:
 334             /*
 335              * Allow scope change to root during execution of module-level
 336              * code. Root is typed METHOD during this time.
 337              */
 338             if ((Node == AcpiGbl_RootNode) &&
 339                 (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
 340             {
 341                 break;
 342             }
 343
 344             /*lint -fallthrough */
 345
 346         default:
 347
 348             /* All other types are an error */
 349
 350             ACPI_ERROR ((AE_INFO,
 351                 "Invalid type (%s) for target of "
 352                 "Scope operator [%4.4s] (Cannot override)",
 353                 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));
 354
 355             return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
 356         }
 357         break;
 358
 359     default:
 360         /*
 361          * For all other named opcodes, we will enter the name into
 362          * the namespace.
 363          *
 364          * Setup the search flags.
 365          * Since we are entering a name into the namespace, we do not want to
 366          * enable the search-to-root upsearch.
 367          *
 368          * There are only two conditions where it is acceptable that the name
 369          * already exists:
 370          *    1) the Scope() operator can reopen a scoping object that was
 371          *       previously defined (Scope, Method, Device, etc.)
 372          *    2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
 373          *       BufferField, or Package), the name of the object is already
 374          *       in the namespace.
 375          */
 376         if (WalkState->DeferredNode)
 377         {
 378             /* This name is already in the namespace, get the node */
 379
 380             Node = WalkState->DeferredNode;
 381             Status = AE_OK;
 382             break;
 383         }
 384
 385         /*
 386          * If we are executing a method, do not create any namespace objects
 387          * during the load phase, only during execution.
 388          */
 389         if (WalkState->MethodNode)
 390         {
 391             Node = NULL;
 392             Status = AE_OK;
 393             break;
 394         }
 395
 396         Flags = ACPI_NS_NO_UPSEARCH;
 397         if ((WalkState->Opcode != AML_SCOPE_OP) &&
 398             (!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)))
 399         {
 400             Flags |= ACPI_NS_ERROR_IF_FOUND;
 401             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
 402                     AcpiUtGetTypeName (ObjectType)));
 403         }
 404         else
 405         {
 406             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 407                 "[%s] Both Find or Create allowed\n",
 408                     AcpiUtGetTypeName (ObjectType)));
 409         }
 410
 411         /*
 412          * Enter the named type into the internal namespace. We enter the name
 413          * as we go downward in the parse tree. Any necessary subobjects that
 414          * involve arguments to the opcode must be created as we go back up the
 415          * parse tree later.
 416          */
 417         Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
 418                         ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
 419         if (ACPI_FAILURE (Status))
 420         {
 421             if (Status == AE_ALREADY_EXISTS)
 422             {
 423                 /* The name already exists in this scope */
 424
 425                 if (Node->Flags & ANOBJ_IS_EXTERNAL)
 426                 {
 427                     /*
 428                      * Allow one create on an object or segment that was
 429                      * previously declared External
 430                      */
 431                     Node->Flags &= ~ANOBJ_IS_EXTERNAL;
 432                     Node->Type = (UINT8) ObjectType;
 433
 434                     /* Just retyped a node, probably will need to open a scope */
 435
 436                     if (AcpiNsOpensScope (ObjectType))
 437                     {
 438                         Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
 439                         if (ACPI_FAILURE (Status))
 440                         {
 441                             return_ACPI_STATUS (Status);
 442                         }
 443                     }
 444
 445                     Status = AE_OK;
 446                 }
 447             }
 448
 449             if (ACPI_FAILURE (Status))
 450             {
 451                 ACPI_ERROR_NAMESPACE (Path, Status);
 452                 return_ACPI_STATUS (Status);
 453             }
 454         }
 455         break;
 456     }
 457
 458     /* Common exit */
 459
 460     if (!Op)
 461     {
 462         /* Create a new op */
 463
 464         Op = AcpiPsAllocOp (WalkState->Opcode);
 465         if (!Op)
 466         {
 467             return_ACPI_STATUS (AE_NO_MEMORY);
 468         }
 469     }
 470
 471     /* Initialize the op */
 472
 473 #if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
 474     Op->Named.Path = ACPI_CAST_PTR (UINT8, Path);
 475 #endif
 476
 477     if (Node)
 478     {
 479         /*
 480          * Put the Node in the "op" object that the parser uses, so we
 481          * can get it again quickly when this scope is closed
 482          */
 483         Op->Common.Node = Node;
 484         Op->Named.Name = Node->Name.Integer;
 485     }
 486
 487     AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op);
 488     *OutOp = Op;
 489     return_ACPI_STATUS (Status);
 490 }
 491
 492
 493 /*******************************************************************************
 494  *
 495  * FUNCTION:    AcpiDsLoad1EndOp
 496  *
 497  * PARAMETERS:  WalkState       - Current state of the parse tree walk
 498  *
 499  * RETURN:      Status
 500  *
 501  * DESCRIPTION: Ascending callback used during the loading of the namespace,
 502  *              both control methods and everything else.
 503  *
 504  ******************************************************************************/
 505
 506 ACPI_STATUS
 507 AcpiDsLoad1EndOp (
 508     ACPI_WALK_STATE         *WalkState)
 509 {
 510     ACPI_PARSE_OBJECT       *Op;
 511     ACPI_OBJECT_TYPE        ObjectType;
 512     ACPI_STATUS             Status = AE_OK;
 513
 514
 515     ACPI_FUNCTION_TRACE (DsLoad1EndOp);
 516
 517
 518     Op = WalkState->Op;
 519     ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
 520
 521     /* We are only interested in opcodes that have an associated name */
 522
 523     if (!(WalkState->OpInfo->Flags & (AML_NAMED | AML_FIELD)))
 524     {
 525         return_ACPI_STATUS (AE_OK);
 526     }
 527
 528     /* Get the object type to determine if we should pop the scope */
 529
 530     ObjectType = WalkState->OpInfo->ObjectType;
 531
 532 #ifndef ACPI_NO_METHOD_EXECUTION
 533     if (WalkState->OpInfo->Flags & AML_FIELD)
 534     {
 535         /*
 536          * If we are executing a method, do not create any namespace objects
 537          * during the load phase, only during execution.
 538          */
 539         if (!WalkState->MethodNode)
 540         {
 541             if (WalkState->Opcode == AML_FIELD_OP          ||
 542                 WalkState->Opcode == AML_BANK_FIELD_OP     ||
 543                 WalkState->Opcode == AML_INDEX_FIELD_OP)
 544             {
 545                 Status = AcpiDsInitFieldObjects (Op, WalkState);
 546             }
 547         }
 548         return_ACPI_STATUS (Status);
 549     }
 550
 551     /*
 552      * If we are executing a method, do not create any namespace objects
 553      * during the load phase, only during execution.
 554      */
 555     if (!WalkState->MethodNode)
 556     {
 557         if (Op->Common.AmlOpcode == AML_REGION_OP)
 558         {
 559             Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
 560                         (ACPI_ADR_SPACE_TYPE) ((Op->Common.Value.Arg)->Common.Value.Integer),
 561                         WalkState);
 562             if (ACPI_FAILURE (Status))
 563             {
 564                 return_ACPI_STATUS (Status);
 565             }
 566         }
 567         else if (Op->Common.AmlOpcode == AML_DATA_REGION_OP)
 568         {
 569             Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length,
 570                         ACPI_ADR_SPACE_DATA_TABLE, WalkState);
 571             if (ACPI_FAILURE (Status))
 572             {
 573                 return_ACPI_STATUS (Status);
 574             }
 575         }
 576     }
 577 #endif
 578
 579     if (Op->Common.AmlOpcode == AML_NAME_OP)
 580     {
 581         /* For Name opcode, get the object type from the argument */
 582
 583         if (Op->Common.Value.Arg)
 584         {
 585             ObjectType = (AcpiPsGetOpcodeInfo (
 586                 (Op->Common.Value.Arg)->Common.AmlOpcode))->ObjectType;
 587
 588             /* Set node type if we have a namespace node */
 589
 590             if (Op->Common.Node)
 591             {
 592                 Op->Common.Node->Type = (UINT8) ObjectType;
 593             }
 594         }
 595     }
 596
 597     /*
 598      * If we are executing a method, do not create any namespace objects
 599      * during the load phase, only during execution.
 600      */
 601     if (!WalkState->MethodNode)
 602     {
 603         if (Op->Common.AmlOpcode == AML_METHOD_OP)
 604         {
 605             /*
 606              * MethodOp PkgLength NameString MethodFlags TermList
 607              *
 608              * Note: We must create the method node/object pair as soon as we
 609              * see the method declaration. This allows later pass1 parsing
 610              * of invocations of the method (need to know the number of
 611              * arguments.)
 612              */
 613             ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
 614                 "LOADING-Method: State=%p Op=%p NamedObj=%p\n",
 615                 WalkState, Op, Op->Named.Node));
 616
 617             if (!AcpiNsGetAttachedObject (Op->Named.Node))
 618             {
 619                 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node);
 620                 WalkState->NumOperands = 1;
 621
 622                 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg);
 623                 if (ACPI_SUCCESS (Status))
 624                 {
 625                     Status = AcpiExCreateMethod (Op->Named.Data,
 626                                         Op->Named.Length, WalkState);
 627                 }
 628
 629                 WalkState->Operands[0] = NULL;
 630                 WalkState->NumOperands = 0;
 631
 632                 if (ACPI_FAILURE (Status))
 633                 {
 634                     return_ACPI_STATUS (Status);
 635                 }
 636             }
 637         }
 638     }
 639
 640     /* Pop the scope stack (only if loading a table) */
 641
 642     if (!WalkState->MethodNode &&
 643         AcpiNsOpensScope (ObjectType))
 644     {
 645         ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s): Popping scope for Op %p\n",
 646             AcpiUtGetTypeName (ObjectType), Op));
 647
 648         Status = AcpiDsScopeStackPop (WalkState);
 649     }
 650
 651     return_ACPI_STATUS (Status);
 652 }