1 /****************************************************************************** 2 * 3 * Module Name: dswload2 - Dispatcher second pass namespace load callbacks 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2020, 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 "acpi.h" 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "amlcode.h" 48 #include "acdispat.h" 49 #include "acinterp.h" 50 #include "acnamesp.h" 51 #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 - Where 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 (WalkState->ScopeInfo, 200 BufferPtr, Status); 201 } 202 #else 203 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, 204 BufferPtr, Status); 205 #endif 206 return_ACPI_STATUS (Status); 207 } 208 } 209 210 /* 211 * We must check to make sure that the target is 212 * one of the opcodes that actually opens a scope 213 */ 214 switch (Node->Type) 215 { 216 case ACPI_TYPE_ANY: 217 case ACPI_TYPE_LOCAL_SCOPE: /* Scope */ 218 case ACPI_TYPE_DEVICE: 219 case ACPI_TYPE_POWER: 220 case ACPI_TYPE_PROCESSOR: 221 case ACPI_TYPE_THERMAL: 222 223 /* These are acceptable types */ 224 break; 225 226 case ACPI_TYPE_INTEGER: 227 case ACPI_TYPE_STRING: 228 case ACPI_TYPE_BUFFER: 229 230 /* 231 * These types we will allow, but we will change the type. 232 * This enables some existing code of the form: 233 * 234 * Name (DEB, 0) 235 * Scope (DEB) { ... } 236 */ 237 ACPI_WARNING ((AE_INFO, 238 "Type override - [%4.4s] had invalid type (%s) " 239 "for Scope operator, changed to type ANY", 240 AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type))); 241 242 Node->Type = ACPI_TYPE_ANY; 243 WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY; 244 break; 245 246 case ACPI_TYPE_METHOD: 247 248 /* 249 * Allow scope change to root during execution of module-level 250 * code. Root is typed METHOD during this time. 251 */ 252 if ((Node == AcpiGbl_RootNode) && 253 (WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 254 { 255 break; 256 } 257 258 /*lint -fallthrough */ 259 260 default: 261 262 /* All other types are an error */ 263 264 ACPI_ERROR ((AE_INFO, 265 "Invalid type (%s) for target of " 266 "Scope operator [%4.4s] (Cannot override)", 267 AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node))); 268 269 return_ACPI_STATUS (AE_AML_OPERAND_TYPE); 270 } 271 break; 272 273 default: 274 275 /* All other opcodes */ 276 277 if (Op && Op->Common.Node) 278 { 279 /* This op/node was previously entered into the namespace */ 280 281 Node = Op->Common.Node; 282 283 if (AcpiNsOpensScope (ObjectType)) 284 { 285 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 286 if (ACPI_FAILURE (Status)) 287 { 288 return_ACPI_STATUS (Status); 289 } 290 } 291 292 return_ACPI_STATUS (AE_OK); 293 } 294 295 /* 296 * Enter the named type into the internal namespace. We enter the name 297 * as we go downward in the parse tree. Any necessary subobjects that 298 * involve arguments to the opcode must be created as we go back up the 299 * parse tree later. 300 * 301 * Note: Name may already exist if we are executing a deferred opcode. 302 */ 303 if (WalkState->DeferredNode) 304 { 305 /* This name is already in the namespace, get the node */ 306 307 Node = WalkState->DeferredNode; 308 Status = AE_OK; 309 break; 310 } 311 312 Flags = ACPI_NS_NO_UPSEARCH; 313 if (WalkState->PassNumber == ACPI_IMODE_EXECUTE) 314 { 315 /* Execution mode, node cannot already exist, node is temporary */ 316 317 Flags |= ACPI_NS_ERROR_IF_FOUND; 318 319 if (!(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 320 { 321 Flags |= ACPI_NS_TEMPORARY; 322 } 323 } 324 325 #ifdef ACPI_ASL_COMPILER 326 327 /* 328 * Do not open a scope for AML_EXTERNAL_OP 329 * AcpiNsLookup can open a new scope based on the object type 330 * of this op. AML_EXTERNAL_OP is a declaration rather than a 331 * definition. In the case that this external is a method object, 332 * AcpiNsLookup will open a new scope. However, an AML_EXTERNAL_OP 333 * associated with the ACPI_TYPE_METHOD is a declaration, rather than 334 * a definition. Flags is set to avoid opening a scope for any 335 * AML_EXTERNAL_OP. 336 */ 337 if (WalkState->Opcode == AML_EXTERNAL_OP) 338 { 339 Flags |= ACPI_NS_DONT_OPEN_SCOPE; 340 } 341 #endif 342 343 /* 344 * For name creation opcodes, the full namepath prefix must 345 * exist, except for the final (new) nameseg. 346 */ 347 if (WalkState->OpInfo->Flags & AML_NAMED) 348 { 349 Flags |= ACPI_NS_PREFIX_MUST_EXIST; 350 } 351 352 /* Add new entry or lookup existing entry */ 353 354 Status = AcpiNsLookup (WalkState->ScopeInfo, BufferPtr, ObjectType, 355 ACPI_IMODE_LOAD_PASS2, Flags, WalkState, &Node); 356 357 if (ACPI_SUCCESS (Status) && (Flags & ACPI_NS_TEMPORARY)) 358 { 359 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 360 "***New Node [%4.4s] %p is temporary\n", 361 AcpiUtGetNodeName (Node), Node)); 362 } 363 break; 364 } 365 366 if (ACPI_FAILURE (Status)) 367 { 368 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, 369 BufferPtr, Status); 370 return_ACPI_STATUS (Status); 371 } 372 373 if (!Op) 374 { 375 /* Create a new op */ 376 377 Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml); 378 if (!Op) 379 { 380 return_ACPI_STATUS (AE_NO_MEMORY); 381 } 382 383 /* Initialize the new op */ 384 385 if (Node) 386 { 387 Op->Named.Name = Node->Name.Integer; 388 } 389 *OutOp = Op; 390 } 391 392 /* 393 * Put the Node in the "op" object that the parser uses, so we 394 * can get it again quickly when this scope is closed 395 */ 396 Op->Common.Node = Node; 397 return_ACPI_STATUS (Status); 398 } 399 400 401 /******************************************************************************* 402 * 403 * FUNCTION: AcpiDsLoad2EndOp 404 * 405 * PARAMETERS: WalkState - Current state of the parse tree walk 406 * 407 * RETURN: Status 408 * 409 * DESCRIPTION: Ascending callback used during the loading of the namespace, 410 * both control methods and everything else. 411 * 412 ******************************************************************************/ 413 414 ACPI_STATUS 415 AcpiDsLoad2EndOp ( 416 ACPI_WALK_STATE *WalkState) 417 { 418 ACPI_PARSE_OBJECT *Op; 419 ACPI_STATUS Status = AE_OK; 420 ACPI_OBJECT_TYPE ObjectType; 421 ACPI_NAMESPACE_NODE *Node; 422 ACPI_PARSE_OBJECT *Arg; 423 ACPI_NAMESPACE_NODE *NewNode; 424 UINT32 i; 425 UINT8 RegionSpace; 426 427 428 ACPI_FUNCTION_TRACE (DsLoad2EndOp); 429 430 Op = WalkState->Op; 431 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Opcode [%s] Op %p State %p\n", 432 WalkState->OpInfo->Name, Op, WalkState)); 433 434 /* Check if opcode had an associated namespace object */ 435 436 if (!(WalkState->OpInfo->Flags & AML_NSOBJECT)) 437 { 438 return_ACPI_STATUS (AE_OK); 439 } 440 441 if (Op->Common.AmlOpcode == AML_SCOPE_OP) 442 { 443 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 444 "Ending scope Op=%p State=%p\n", Op, WalkState)); 445 } 446 447 ObjectType = WalkState->OpInfo->ObjectType; 448 449 /* 450 * Get the Node/name from the earlier lookup 451 * (It was saved in the *op structure) 452 */ 453 Node = Op->Common.Node; 454 455 /* 456 * Put the Node on the object stack (Contains the ACPI Name of 457 * this object) 458 */ 459 WalkState->Operands[0] = (void *) Node; 460 WalkState->NumOperands = 1; 461 462 /* Pop the scope stack */ 463 464 if (AcpiNsOpensScope (ObjectType) && 465 (Op->Common.AmlOpcode != AML_INT_METHODCALL_OP)) 466 { 467 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "(%s) Popping scope for Op %p\n", 468 AcpiUtGetTypeName (ObjectType), Op)); 469 470 Status = AcpiDsScopeStackPop (WalkState); 471 if (ACPI_FAILURE (Status)) 472 { 473 goto Cleanup; 474 } 475 } 476 477 /* 478 * Named operations are as follows: 479 * 480 * AML_ALIAS 481 * AML_BANKFIELD 482 * AML_CREATEBITFIELD 483 * AML_CREATEBYTEFIELD 484 * AML_CREATEDWORDFIELD 485 * AML_CREATEFIELD 486 * AML_CREATEQWORDFIELD 487 * AML_CREATEWORDFIELD 488 * AML_DATA_REGION 489 * AML_DEVICE 490 * AML_EVENT 491 * AML_FIELD 492 * AML_INDEXFIELD 493 * AML_METHOD 494 * AML_METHODCALL 495 * AML_MUTEX 496 * AML_NAME 497 * AML_NAMEDFIELD 498 * AML_OPREGION 499 * AML_POWERRES 500 * AML_PROCESSOR 501 * AML_SCOPE 502 * AML_THERMALZONE 503 */ 504 505 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 506 "Create-Load [%s] State=%p Op=%p NamedObj=%p\n", 507 AcpiPsGetOpcodeName (Op->Common.AmlOpcode), WalkState, Op, Node)); 508 509 /* Decode the opcode */ 510 511 Arg = Op->Common.Value.Arg; 512 513 switch (WalkState->OpInfo->Type) 514 { 515 516 case AML_TYPE_CREATE_FIELD: 517 /* 518 * Create the field object, but the field buffer and index must 519 * be evaluated later during the execution phase 520 */ 521 Status = AcpiDsCreateBufferField (Op, WalkState); 522 break; 523 524 case AML_TYPE_NAMED_FIELD: 525 /* 526 * If we are executing a method, initialize the field 527 */ 528 if (WalkState->MethodNode) 529 { 530 Status = AcpiDsInitFieldObjects (Op, WalkState); 531 } 532 533 switch (Op->Common.AmlOpcode) 534 { 535 case AML_INDEX_FIELD_OP: 536 537 Status = AcpiDsCreateIndexField ( 538 Op, (ACPI_HANDLE) Arg->Common.Node, WalkState); 539 break; 540 541 case AML_BANK_FIELD_OP: 542 543 Status = AcpiDsCreateBankField (Op, Arg->Common.Node, WalkState); 544 break; 545 546 case AML_FIELD_OP: 547 548 Status = AcpiDsCreateField (Op, Arg->Common.Node, WalkState); 549 break; 550 551 default: 552 553 /* All NAMED_FIELD opcodes must be handled above */ 554 break; 555 } 556 break; 557 558 case AML_TYPE_NAMED_SIMPLE: 559 560 Status = AcpiDsCreateOperands (WalkState, Arg); 561 if (ACPI_FAILURE (Status)) 562 { 563 goto Cleanup; 564 } 565 566 switch (Op->Common.AmlOpcode) 567 { 568 case AML_PROCESSOR_OP: 569 570 Status = AcpiExCreateProcessor (WalkState); 571 break; 572 573 case AML_POWER_RESOURCE_OP: 574 575 Status = AcpiExCreatePowerResource (WalkState); 576 break; 577 578 case AML_MUTEX_OP: 579 580 Status = AcpiExCreateMutex (WalkState); 581 break; 582 583 case AML_EVENT_OP: 584 585 Status = AcpiExCreateEvent (WalkState); 586 break; 587 588 case AML_ALIAS_OP: 589 590 Status = AcpiExCreateAlias (WalkState); 591 break; 592 593 default: 594 595 /* Unknown opcode */ 596 597 Status = AE_OK; 598 goto Cleanup; 599 } 600 601 /* Delete operands */ 602 603 for (i = 1; i < WalkState->NumOperands; i++) 604 { 605 AcpiUtRemoveReference (WalkState->Operands[i]); 606 WalkState->Operands[i] = NULL; 607 } 608 609 break; 610 611 case AML_TYPE_NAMED_COMPLEX: 612 613 switch (Op->Common.AmlOpcode) 614 { 615 case AML_REGION_OP: 616 case AML_DATA_REGION_OP: 617 618 if (Op->Common.AmlOpcode == AML_REGION_OP) 619 { 620 RegionSpace = (ACPI_ADR_SPACE_TYPE) 621 ((Op->Common.Value.Arg)->Common.Value.Integer); 622 } 623 else 624 { 625 RegionSpace = ACPI_ADR_SPACE_DATA_TABLE; 626 } 627 628 /* 629 * The OpRegion is not fully parsed at this time. The only valid 630 * argument is the SpaceId. (We must save the address of the 631 * AML of the address and length operands) 632 * 633 * If we have a valid region, initialize it. The namespace is 634 * unlocked at this point. 635 * 636 * Need to unlock interpreter if it is locked (if we are running 637 * a control method), in order to allow _REG methods to be run 638 * during AcpiEvInitializeRegion. 639 */ 640 if (WalkState->MethodNode) 641 { 642 /* 643 * Executing a method: initialize the region and unlock 644 * the interpreter 645 */ 646 Status = AcpiExCreateRegion (Op->Named.Data, 647 Op->Named.Length, RegionSpace, WalkState); 648 if (ACPI_FAILURE (Status)) 649 { 650 return_ACPI_STATUS (Status); 651 } 652 } 653 654 Status = AcpiEvInitializeRegion ( 655 AcpiNsGetAttachedObject (Node)); 656 break; 657 658 case AML_NAME_OP: 659 660 Status = AcpiDsCreateNode (WalkState, Node, Op); 661 break; 662 663 case AML_METHOD_OP: 664 /* 665 * MethodOp PkgLength NameString MethodFlags TermList 666 * 667 * Note: We must create the method node/object pair as soon as we 668 * see the method declaration. This allows later pass1 parsing 669 * of invocations of the method (need to know the number of 670 * arguments.) 671 */ 672 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 673 "LOADING-Method: State=%p Op=%p NamedObj=%p\n", 674 WalkState, Op, Op->Named.Node)); 675 676 if (!AcpiNsGetAttachedObject (Op->Named.Node)) 677 { 678 WalkState->Operands[0] = ACPI_CAST_PTR (void, Op->Named.Node); 679 WalkState->NumOperands = 1; 680 681 Status = AcpiDsCreateOperands ( 682 WalkState, Op->Common.Value.Arg); 683 if (ACPI_SUCCESS (Status)) 684 { 685 Status = AcpiExCreateMethod ( 686 Op->Named.Data, Op->Named.Length, WalkState); 687 } 688 689 WalkState->Operands[0] = NULL; 690 WalkState->NumOperands = 0; 691 692 if (ACPI_FAILURE (Status)) 693 { 694 return_ACPI_STATUS (Status); 695 } 696 } 697 break; 698 699 700 default: 701 702 /* All NAMED_COMPLEX opcodes must be handled above */ 703 break; 704 } 705 break; 706 707 case AML_CLASS_INTERNAL: 708 709 /* case AML_INT_NAMEPATH_OP: */ 710 break; 711 712 case AML_CLASS_METHOD_CALL: 713 714 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 715 "RESOLVING-MethodCall: State=%p Op=%p NamedObj=%p\n", 716 WalkState, Op, Node)); 717 718 /* 719 * Lookup the method name and save the Node 720 */ 721 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 722 ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS2, 723 ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, 724 WalkState, &(NewNode)); 725 if (ACPI_SUCCESS (Status)) 726 { 727 /* 728 * Make sure that what we found is indeed a method 729 * We didn't search for a method on purpose, to see if the name 730 * would resolve 731 */ 732 if (NewNode->Type != ACPI_TYPE_METHOD) 733 { 734 Status = AE_AML_OPERAND_TYPE; 735 } 736 737 /* We could put the returned object (Node) on the object stack for 738 * later, but for now, we will put it in the "op" object that the 739 * parser uses, so we can get it again at the end of this scope 740 */ 741 Op->Common.Node = NewNode; 742 } 743 else 744 { 745 ACPI_ERROR_NAMESPACE (WalkState->ScopeInfo, 746 Arg->Common.Value.String, Status); 747 } 748 break; 749 750 751 default: 752 753 break; 754 } 755 756 Cleanup: 757 758 /* Remove the Node pushed at the very beginning */ 759 760 WalkState->Operands[0] = NULL; 761 WalkState->NumOperands = 0; 762 return_ACPI_STATUS (Status); 763 } 764