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