1 /****************************************************************************** 2 * 3 * Module Name: dswload2 - Dispatcher second pass namespace load callbacks 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 #include <contrib/dev/acpica/include/acparser.h> 47 #include <contrib/dev/acpica/include/amlcode.h> 48 #include <contrib/dev/acpica/include/acdispat.h> 49 #include <contrib/dev/acpica/include/acinterp.h> 50 #include <contrib/dev/acpica/include/acnamesp.h> 51 #include <contrib/dev/acpica/include/acevents.h> 52 53 #define _COMPONENT ACPI_DISPATCHER 54 ACPI_MODULE_NAME ("dswload2") 55 56 57 /******************************************************************************* 58 * 59 * FUNCTION: AcpiDsLoad2BeginOp 60 * 61 * PARAMETERS: WalkState - Current state of the parse tree walk 62 * OutOp - Wher to return op if a new one is created 63 * 64 * RETURN: Status 65 * 66 * DESCRIPTION: Descending callback used during the loading of ACPI tables. 67 * 68 ******************************************************************************/ 69 70 ACPI_STATUS 71 AcpiDsLoad2BeginOp ( 72 ACPI_WALK_STATE *WalkState, 73 ACPI_PARSE_OBJECT **OutOp) 74 { 75 ACPI_PARSE_OBJECT *Op; 76 ACPI_NAMESPACE_NODE *Node; 77 ACPI_STATUS Status; 78 ACPI_OBJECT_TYPE ObjectType; 79 char *BufferPtr; 80 UINT32 Flags; 81 82 83 ACPI_FUNCTION_TRACE (DsLoad2BeginOp); 84 85 86 Op = WalkState->Op; 87 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState)); 88 89 if (Op) 90 { 91 if ((WalkState->ControlState) && 92 (WalkState->ControlState->Common.State == 93 ACPI_CONTROL_CONDITIONAL_EXECUTING)) 94 { 95 /* We are executing a while loop outside of a method */ 96 97 Status = AcpiDsExecBeginOp (WalkState, OutOp); 98 return_ACPI_STATUS (Status); 99 } 100 101 /* We only care about Namespace opcodes here */ 102 103 if ((!(WalkState->OpInfo->Flags & AML_NSOPCODE) && 104 (WalkState->Opcode != AML_INT_NAMEPATH_OP)) || 105 (!(WalkState->OpInfo->Flags & AML_NAMED))) 106 { 107 return_ACPI_STATUS (AE_OK); 108 } 109 110 /* Get the name we are going to enter or lookup in the namespace */ 111 112 if (WalkState->Opcode == AML_INT_NAMEPATH_OP) 113 { 114 /* For Namepath op, get the path string */ 115 116 BufferPtr = Op->Common.Value.String; 117 if (!BufferPtr) 118 { 119 /* No name, just exit */ 120 121 return_ACPI_STATUS (AE_OK); 122 } 123 } 124 else 125 { 126 /* Get name from the op */ 127 128 BufferPtr = ACPI_CAST_PTR (char, &Op->Named.Name); 129 } 130 } 131 else 132 { 133 /* Get the namestring from the raw AML */ 134 135 BufferPtr = AcpiPsGetNextNamestring (&WalkState->ParserState); 136 } 137 138 /* Map the opcode into an internal object type */ 139 140 ObjectType = WalkState->OpInfo->ObjectType; 141 142 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 143 "State=%p Op=%p Type=%X\n", WalkState, Op, ObjectType)); 144 145 switch (WalkState->Opcode) 146 { 147 case AML_FIELD_OP: 148 case AML_BANK_FIELD_OP: 149 case AML_INDEX_FIELD_OP: 150 151 Node = NULL; 152 Status = AE_OK; 153 break; 154 155 case AML_INT_NAMEPATH_OP: 156 /* 157 * The NamePath is an object reference to an existing object. 158 * Don't enter the name into the namespace, but look it up 159 * for use later. 160 */ 161 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, 162 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, 163 WalkState, &(Node)); 164 break; 165 166 case AML_SCOPE_OP: 167 168 /* Special case for Scope(\) -> refers to the Root node */ 169 170 if (Op && (Op->Named.Node == AcpiGbl_RootNode)) 171 { 172 Node = Op->Named.Node; 173 174 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 175 if (ACPI_FAILURE (Status)) 176 { 177 return_ACPI_STATUS (Status); 178 } 179 } 180 else 181 { 182 /* 183 * The Path is an object reference to an existing object. 184 * Don't enter the name into the namespace, but look it up 185 * for use later. 186 */ 187 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, 188 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, 189 WalkState, &(Node)); 190 if (ACPI_FAILURE (Status)) 191 { 192 #ifdef ACPI_ASL_COMPILER 193 if (Status == AE_NOT_FOUND) 194 { 195 Status = AE_OK; 196 } 197 else 198 { 199 ACPI_ERROR_NAMESPACE (BufferPtr, Status); 200 } 201 #else 202 ACPI_ERROR_NAMESPACE (BufferPtr, Status); 203 #endif 204 return_ACPI_STATUS (Status); 205 } 206 } 207 208 /* 209 * We must check to make sure that the target is 210 * one of the opcodes that actually opens a scope 211 */ 212 switch (Node->Type) 213 { 214 case ACPI_TYPE_ANY: 215 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */ 216 case ACPI_TYPE_DEVICE: 217 case ACPI_TYPE_POWER: 218 case ACPI_TYPE_PROCESSOR: 219 case ACPI_TYPE_THERMAL: 220 221 /* These are acceptable types */ 222 break; 223 224 case ACPI_TYPE_INTEGER: 225 case ACPI_TYPE_STRING: 226 case ACPI_TYPE_BUFFER: 227 228 /* 229 * These types we will allow, but we will change the type. 230 * This enables some existing code of the form: 231 * 232 * Name (DEB, 0) 233 * Scope (DEB) { ... } 234 */ 235 ACPI_WARNING ((AE_INFO, 236 "Type override - [%4.4s] had invalid type (%s) " 237 "for Scope operator, changed to type ANY", 238 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type))); 239 240 Node->Type = ACPI_TYPE_ANY; 241 WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY; 242 break; 243 244 case ACPI_TYPE_METHOD: 245 246 /* 247 * Allow scope change to root during execution of module-level 248 * code. Root is typed METHOD during this time. 249 */ 250 if ((Node == AcpiGbl_RootNode) && 251 (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 252 { 253 break; 254 } 255 256 /*lint -fallthrough */ 257 258 default: 259 260 /* All other types are an error */ 261 262 ACPI_ERROR ((AE_INFO, 263 "Invalid type (%s) for target of " 264 "Scope operator [%4.4s] (Cannot override)", 265 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node))); 266 267 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 268 } 269 break; 270 271 default: 272 273 /* All other opcodes */ 274 275 if (Op && Op->Common.Node) 276 { 277 /* This op/node was previously entered into the namespace */ 278 279 Node = Op->Common.Node; 280 281 if (AcpiNsOpensScope (ObjectType)) 282 { 283 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 284 if (ACPI_FAILURE (Status)) 285 { 286 return_ACPI_STATUS (Status); 287 } 288 } 289 290 return_ACPI_STATUS (AE_OK); 291 } 292 293 /* 294 * Enter the named type into the internal namespace. We enter the name 295 * as we go downward in the parse tree. Any necessary subobjects that 296 * involve arguments to the opcode must be created as we go back up the 297 * parse tree later. 298 * 299 * Note: Name may already exist if we are executing a deferred opcode. 300 */ 301 if (WalkState->DeferredNode) 302 { 303 /* This name is already in the namespace, get the node */ 304 305 Node = WalkState->DeferredNode; 306 Status = AE_OK; 307 break; 308 } 309 310 Flags = ACPI_NS_NO_UPSEARCH; 311 if (WalkState->PassNumber == ACPI_IMODE_EXECUTE) 312 { 313 /* Execution mode, node cannot already exist, node is temporary */ 314 315 Flags |= ACPI_NS_ERROR_IF_FOUND; 316 317 if (!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 318 { 319 Flags |= ACPI_NS_TEMPORARY; 320 } 321 } 322 323 /* Add new entry or lookup existing entry */ 324 325 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, 326 ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node); 327 328 if (ACPI_SUCCESS (Status) && (Flags & ACPI_NS_TEMPORARY)) 329 { 330 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 331 "***New Node [%4.4s] %p is temporary\n", 332 AcpiUtGetNodeName (Node), Node)); 333 } 334 break; 335 } 336 337 if (ACPI_FAILURE (Status)) 338 { 339 ACPI_ERROR_NAMESPACE (BufferPtr, Status); 340 return_ACPI_STATUS (Status); 341 } 342 343 if (!Op) 344 { 345 /* Create a new op */ 346 347 Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml); 348 if (!Op) 349 { 350 return_ACPI_STATUS (AE_NO_MEMORY); 351 } 352 353 /* Initialize the new op */ 354 355 if (Node) 356 { 357 Op->Named.Name = Node->Name.Integer; 358 } 359 *OutOp = Op; 360 } 361 362 /* 363 * Put the Node in the "op" object that the parser uses, so we 364 * can get it again quickly when this scope is closed 365 */ 366 Op->Common.Node = Node; 367 return_ACPI_STATUS (Status); 368 } 369 370 371 /******************************************************************************* 372 * 373 * FUNCTION: AcpiDsLoad2EndOp 374 * 375 * PARAMETERS: WalkState - Current state of the parse tree walk 376 * 377 * RETURN: Status 378 * 379 * DESCRIPTION: Ascending callback used during the loading of the namespace, 380 * both control methods and everything else. 381 * 382 ******************************************************************************/ 383 384 ACPI_STATUS 385 AcpiDsLoad2EndOp ( 386 ACPI_WALK_STATE *WalkState) 387 { 388 ACPI_PARSE_OBJECT *Op; 389 ACPI_STATUS Status = AE_OK; 390 ACPI_OBJECT_TYPE ObjectType; 391 ACPI_NAMESPACE_NODE *Node; 392 ACPI_PARSE_OBJECT *Arg; 393 ACPI_NAMESPACE_NODE *NewNode; 394 #ifndef ACPI_NO_METHOD_EXECUTION 395 UINT32 i; 396 UINT8 RegionSpace; 397 #endif 398 399 400 ACPI_FUNCTION_TRACE (DsLoad2EndOp); 401 402 Op = WalkState->Op; 403 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n", 404 WalkState->OpInfo->Name, Op, WalkState)); 405 406 /* Check if opcode had an associated namespace object */ 407 408 if (!(WalkState->OpInfo->Flags & AML_NSOBJECT)) 409 { 410 return_ACPI_STATUS (AE_OK); 411 } 412 413 if (Op->Common.AmlOpcode == AML_SCOPE_OP) 414 { 415 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 416 "Ending scope Op=%p State=%p\n", Op, WalkState)); 417 } 418 419 ObjectType = WalkState->OpInfo->ObjectType; 420 421 /* 422 * Get the Node/name from the earlier lookup 423 * (It was saved in the *op structure) 424 */ 425 Node = Op->Common.Node; 426 427 /* 428 * Put the Node on the object stack (Contains the ACPI Name of 429 * this object) 430 */ 431 WalkState->Operands[0] = (void *) Node; 432 WalkState->NumOperands = 1; 433 434 /* Pop the scope stack */ 435 436 if (AcpiNsOpensScope (ObjectType) && 437 (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP)) 438 { 439 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n", 440 AcpiUtGetTypeName (ObjectType), Op)); 441 442 Status = AcpiDsScopeStackPop (WalkState); 443 if (ACPI_FAILURE (Status)) 444 { 445 goto Cleanup; 446 } 447 } 448 449 /* 450 * Named operations are as follows: 451 * 452 * AML_ALIAS 453 * AML_BANKFIELD 454 * AML_CREATEBITFIELD 455 * AML_CREATEBYTEFIELD 456 * AML_CREATEDWORDFIELD 457 * AML_CREATEFIELD 458 * AML_CREATEQWORDFIELD 459 * AML_CREATEWORDFIELD 460 * AML_DATA_REGION 461 * AML_DEVICE 462 * AML_EVENT 463 * AML_FIELD 464 * AML_INDEXFIELD 465 * AML_METHOD 466 * AML_METHODCALL 467 * AML_MUTEX 468 * AML_NAME 469 * AML_NAMEDFIELD 470 * AML_OPREGION 471 * AML_POWERRES 472 * AML_PROCESSOR 473 * AML_SCOPE 474 * AML_THERMALZONE 475 */ 476 477 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 478 "Create-Load [%s] State=%p Op=%p NamedObj=%p\n", 479 AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node)); 480 481 /* Decode the opcode */ 482 483 Arg = Op->Common.Value.Arg; 484 485 switch (WalkState->OpInfo->Type) 486 { 487 #ifndef ACPI_NO_METHOD_EXECUTION 488 489 case AML_TYPE_CREATE_FIELD: 490 /* 491 * Create the field object, but the field buffer and index must 492 * be evaluated later during the execution phase 493 */ 494 Status = AcpiDsCreateBufferField (Op, WalkState); 495 break; 496 497 case AML_TYPE_NAMED_FIELD: 498 /* 499 * If we are executing a method, initialize the field 500 */ 501 if (WalkState->MethodNode) 502 { 503 Status = AcpiDsInitFieldObjects (Op, WalkState); 504 } 505 506 switch (Op->Common.AmlOpcode) 507 { 508 case AML_INDEX_FIELD_OP: 509 510 Status = AcpiDsCreateIndexField (Op, (ACPI_HANDLE) Arg->Common.Node, 511 WalkState); 512 break; 513 514 case AML_BANK_FIELD_OP: 515 516 Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState); 517 break; 518 519 case AML_FIELD_OP: 520 521 Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState); 522 break; 523 524 default: 525 526 /* All NAMED_FIELD opcodes must be handled above */ 527 break; 528 } 529 break; 530 531 case AML_TYPE_NAMED_SIMPLE: 532 533 Status = AcpiDsCreateOperands (WalkState, Arg); 534 if (ACPI_FAILURE (Status)) 535 { 536 goto Cleanup; 537 } 538 539 switch (Op->Common.AmlOpcode) 540 { 541 case AML_PROCESSOR_OP: 542 543 Status = AcpiExCreateProcessor (WalkState); 544 break; 545 546 case AML_POWER_RES_OP: 547 548 Status = AcpiExCreatePowerResource (WalkState); 549 break; 550 551 case AML_MUTEX_OP: 552 553 Status = AcpiExCreateMutex (WalkState); 554 break; 555 556 case AML_EVENT_OP: 557 558 Status = AcpiExCreateEvent (WalkState); 559 break; 560 561 case AML_ALIAS_OP: 562 563 Status = AcpiExCreateAlias (WalkState); 564 break; 565 566 default: 567 568 /* Unknown opcode */ 569 570 Status = AE_OK; 571 goto Cleanup; 572 } 573 574 /* Delete operands */ 575 576 for (i = 1; i < WalkState->NumOperands; i++) 577 { 578 AcpiUtRemoveReference (WalkState->Operands[i]); 579 WalkState->Operands[i] = NULL; 580 } 581 582 break; 583 #endif /* ACPI_NO_METHOD_EXECUTION */ 584 585 case AML_TYPE_NAMED_COMPLEX: 586 587 switch (Op->Common.AmlOpcode) 588 { 589 #ifndef ACPI_NO_METHOD_EXECUTION 590 case AML_REGION_OP: 591 case AML_DATA_REGION_OP: 592 593 if (Op->Common.AmlOpcode == AML_REGION_OP) 594 { 595 RegionSpace = (ACPI_ADR_SPACE_TYPE) 596 ((Op->Common.Value.Arg)->Common.Value.Integer); 597 } 598 else 599 { 600 RegionSpace = ACPI_ADR_SPACE_DATA_TABLE; 601 } 602 603 /* 604 * The OpRegion is not fully parsed at this time. The only valid 605 * argument is the SpaceId. (We must save the address of the 606 * AML of the address and length operands) 607 * 608 * If we have a valid region, initialize it. The namespace is 609 * unlocked at this point. 610 * 611 * Need to unlock interpreter if it is locked (if we are running 612 * a control method), in order to allow _REG methods to be run 613 * during AcpiEvInitializeRegion. 614 */ 615 if (WalkState->MethodNode) 616 { 617 /* 618 * Executing a method: initialize the region and unlock 619 * the interpreter 620 */ 621 Status = AcpiExCreateRegion (Op->Named.Data, Op->Named.Length, 622 RegionSpace, WalkState); 623 if (ACPI_FAILURE (Status)) 624 { 625 return_ACPI_STATUS (Status); 626 } 627 628 AcpiExExitInterpreter (); 629 } 630 631 Status = AcpiEvInitializeRegion (AcpiNsGetAttachedObject (Node), 632 FALSE); 633 if (WalkState->MethodNode) 634 { 635 AcpiExEnterInterpreter (); 636 } 637 638 if (ACPI_FAILURE (Status)) 639 { 640 /* 641 * If AE_NOT_EXIST is returned, it is not fatal 642 * because many regions get created before a handler 643 * is installed for said region. 644 */ 645 if (AE_NOT_EXIST == Status) 646 { 647 Status = AE_OK; 648 } 649 } 650 break; 651 652 case AML_NAME_OP: 653 654 Status = AcpiDsCreateNode (WalkState, Node, Op); 655 break; 656 657 case AML_METHOD_OP: 658 /* 659 * MethodOp PkgLength NameString MethodFlags TermList 660 * 661 * Note: We must create the method node/object pair as soon as we 662 * see the method declaration. This allows later pass1 parsing 663 * of invocations of the method (need to know the number of 664 * arguments.) 665 */ 666 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 667 "LOADING-Method: State=%p Op=%p NamedObj=%p\n", 668 WalkState, Op, Op->Named.Node)); 669 670 if (!AcpiNsGetAttachedObject (Op->Named.Node)) 671 { 672 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node); 673 WalkState->NumOperands = 1; 674 675 Status = AcpiDsCreateOperands (WalkState, Op->Common.Value.Arg); 676 if (ACPI_SUCCESS (Status)) 677 { 678 Status = AcpiExCreateMethod (Op->Named.Data, 679 Op->Named.Length, WalkState); 680 } 681 WalkState->Operands[0] = NULL; 682 WalkState->NumOperands = 0; 683 684 if (ACPI_FAILURE (Status)) 685 { 686 return_ACPI_STATUS (Status); 687 } 688 } 689 break; 690 691 #endif /* ACPI_NO_METHOD_EXECUTION */ 692 693 default: 694 695 /* All NAMED_COMPLEX opcodes must be handled above */ 696 break; 697 } 698 break; 699 700 case AML_CLASS_INTERNAL: 701 702 /* case AML_INT_NAMEPATH_OP: */ 703 break; 704 705 case AML_CLASS_METHOD_CALL: 706 707 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 708 "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n", 709 WalkState, Op, Node)); 710 711 /* 712 * Lookup the method name and save the Node 713 */ 714 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 715 ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2, 716 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, 717 WalkState, &(NewNode)); 718 if (ACPI_SUCCESS (Status)) 719 { 720 /* 721 * Make sure that what we found is indeed a method 722 * We didn't search for a method on purpose, to see if the name 723 * would resolve 724 */ 725 if (NewNode->Type != ACPI_TYPE_METHOD) 726 { 727 Status = AE_AML_OPERAND_TYPE; 728 } 729 730 /* We could put the returned object (Node) on the object stack for 731 * later, but for now, we will put it in the "op" object that the 732 * parser uses, so we can get it again at the end of this scope 733 */ 734 Op->Common.Node = NewNode; 735 } 736 else 737 { 738 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); 739 } 740 break; 741 742 743 default: 744 745 break; 746 } 747 748 Cleanup: 749 750 /* Remove the Node pushed at the very beginning */ 751 752 WalkState->Operands[0] = NULL; 753 WalkState->NumOperands = 0; 754 return_ACPI_STATUS (Status); 755 } 756