1 /****************************************************************************** 2 * 3 * Module Name: dswload - Dispatcher namespace load callbacks 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 #define __ASLLOAD_C__ 45 46 #include "aslcompiler.h" 47 #include "amlcode.h" 48 #include "acdispat.h" 49 #include "acnamesp.h" 50 51 #include "aslcompiler.y.h" 52 53 #define _COMPONENT ACPI_COMPILER 54 ACPI_MODULE_NAME ("aslload") 55 56 /* Local prototypes */ 57 58 static ACPI_STATUS 59 LdLoadFieldElements ( 60 ACPI_PARSE_OBJECT *Op, 61 ACPI_WALK_STATE *WalkState); 62 63 static ACPI_STATUS 64 LdLoadResourceElements ( 65 ACPI_PARSE_OBJECT *Op, 66 ACPI_WALK_STATE *WalkState); 67 68 static ACPI_STATUS 69 LdNamespace1Begin ( 70 ACPI_PARSE_OBJECT *Op, 71 UINT32 Level, 72 void *Context); 73 74 static ACPI_STATUS 75 LdNamespace2Begin ( 76 ACPI_PARSE_OBJECT *Op, 77 UINT32 Level, 78 void *Context); 79 80 static ACPI_STATUS 81 LdCommonNamespaceEnd ( 82 ACPI_PARSE_OBJECT *Op, 83 UINT32 Level, 84 void *Context); 85 86 87 /******************************************************************************* 88 * 89 * FUNCTION: LdLoadNamespace 90 * 91 * PARAMETERS: RootOp - Root of the parse tree 92 * 93 * RETURN: Status 94 * 95 * DESCRIPTION: Perform a walk of the parse tree that in turn loads all of the 96 * named ASL/AML objects into the namespace. The namespace is 97 * constructed in order to resolve named references and references 98 * to named fields within resource templates/descriptors. 99 * 100 ******************************************************************************/ 101 102 ACPI_STATUS 103 LdLoadNamespace ( 104 ACPI_PARSE_OBJECT *RootOp) 105 { 106 ACPI_WALK_STATE *WalkState; 107 108 109 DbgPrint (ASL_DEBUG_OUTPUT, "\nCreating namespace\n\n"); 110 111 /* Create a new walk state */ 112 113 WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL); 114 if (!WalkState) 115 { 116 return (AE_NO_MEMORY); 117 } 118 119 /* Walk the entire parse tree, first pass */ 120 121 TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace1Begin, 122 LdCommonNamespaceEnd, WalkState); 123 124 /* Second pass to handle forward references */ 125 126 TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace2Begin, 127 LdCommonNamespaceEnd, WalkState); 128 129 /* Dump the namespace if debug is enabled */ 130 131 AcpiNsDumpTables (ACPI_NS_ALL, ACPI_UINT32_MAX); 132 return (AE_OK); 133 } 134 135 136 /******************************************************************************* 137 * 138 * FUNCTION: LdLoadFieldElements 139 * 140 * PARAMETERS: Op - Parent node (Field) 141 * WalkState - Current walk state 142 * 143 * RETURN: Status 144 * 145 * DESCRIPTION: Enter the named elements of the field (children of the parent) 146 * into the namespace. 147 * 148 ******************************************************************************/ 149 150 static ACPI_STATUS 151 LdLoadFieldElements ( 152 ACPI_PARSE_OBJECT *Op, 153 ACPI_WALK_STATE *WalkState) 154 { 155 ACPI_PARSE_OBJECT *Child = NULL; 156 ACPI_NAMESPACE_NODE *Node; 157 ACPI_STATUS Status; 158 159 160 /* Get the first named field element */ 161 162 switch (Op->Asl.AmlOpcode) 163 { 164 case AML_BANK_FIELD_OP: 165 166 Child = UtGetArg (Op, 6); 167 break; 168 169 case AML_INDEX_FIELD_OP: 170 171 Child = UtGetArg (Op, 5); 172 break; 173 174 case AML_FIELD_OP: 175 176 Child = UtGetArg (Op, 4); 177 break; 178 179 default: 180 181 /* No other opcodes should arrive here */ 182 183 return (AE_BAD_PARAMETER); 184 } 185 186 /* Enter all elements into the namespace */ 187 188 while (Child) 189 { 190 switch (Child->Asl.AmlOpcode) 191 { 192 case AML_INT_RESERVEDFIELD_OP: 193 case AML_INT_ACCESSFIELD_OP: 194 case AML_INT_CONNECTION_OP: 195 break; 196 197 default: 198 199 Status = AcpiNsLookup (WalkState->ScopeInfo, 200 Child->Asl.Value.String, 201 ACPI_TYPE_LOCAL_REGION_FIELD, 202 ACPI_IMODE_LOAD_PASS1, 203 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | 204 ACPI_NS_ERROR_IF_FOUND, 205 NULL, &Node); 206 if (ACPI_FAILURE (Status)) 207 { 208 if (Status != AE_ALREADY_EXISTS) 209 { 210 AslError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, Child, 211 Child->Asl.Value.String); 212 return (Status); 213 } 214 215 /* 216 * The name already exists in this scope 217 * But continue processing the elements 218 */ 219 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Child, 220 Child->Asl.Value.String); 221 } 222 else 223 { 224 Child->Asl.Node = Node; 225 Node->Op = Child; 226 } 227 break; 228 } 229 230 Child = Child->Asl.Next; 231 } 232 233 return (AE_OK); 234 } 235 236 237 /******************************************************************************* 238 * 239 * FUNCTION: LdLoadResourceElements 240 * 241 * PARAMETERS: Op - Parent node (Resource Descriptor) 242 * WalkState - Current walk state 243 * 244 * RETURN: Status 245 * 246 * DESCRIPTION: Enter the named elements of the resource descriptor (children 247 * of the parent) into the namespace. 248 * 249 * NOTE: In the real AML namespace, these named elements never exist. But 250 * we simply use the namespace here as a symbol table so we can look 251 * them up as they are referenced. 252 * 253 ******************************************************************************/ 254 255 static ACPI_STATUS 256 LdLoadResourceElements ( 257 ACPI_PARSE_OBJECT *Op, 258 ACPI_WALK_STATE *WalkState) 259 { 260 ACPI_PARSE_OBJECT *InitializerOp = NULL; 261 ACPI_NAMESPACE_NODE *Node; 262 ACPI_STATUS Status; 263 264 265 /* 266 * Enter the resource name into the namespace. Name must not already exist. 267 * This opens a scope, so later field names are guaranteed to be new/unique. 268 */ 269 Status = AcpiNsLookup (WalkState->ScopeInfo, Op->Asl.Namepath, 270 ACPI_TYPE_LOCAL_RESOURCE, ACPI_IMODE_LOAD_PASS1, 271 ACPI_NS_NO_UPSEARCH | ACPI_NS_ERROR_IF_FOUND, 272 WalkState, &Node); 273 if (ACPI_FAILURE (Status)) 274 { 275 if (Status == AE_ALREADY_EXISTS) 276 { 277 /* Actual node causing the error was saved in ParentMethod */ 278 279 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, 280 (ACPI_PARSE_OBJECT *) Op->Asl.ParentMethod, Op->Asl.Namepath); 281 return (AE_OK); 282 } 283 return (Status); 284 } 285 286 Node->Value = (UINT32) Op->Asl.Value.Integer; 287 Node->Op = Op; 288 Op->Asl.Node = Node; 289 290 /* 291 * Now enter the predefined fields, for easy lookup when referenced 292 * by the source ASL 293 */ 294 InitializerOp = ASL_GET_CHILD_NODE (Op); 295 while (InitializerOp) 296 { 297 if (InitializerOp->Asl.ExternalName) 298 { 299 Status = AcpiNsLookup (WalkState->ScopeInfo, 300 InitializerOp->Asl.ExternalName, 301 ACPI_TYPE_LOCAL_RESOURCE_FIELD, 302 ACPI_IMODE_LOAD_PASS1, 303 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE, 304 NULL, &Node); 305 if (ACPI_FAILURE (Status)) 306 { 307 return (Status); 308 } 309 310 /* 311 * Store the field offset and length in the namespace node 312 * so it can be used when the field is referenced 313 */ 314 Node->Value = InitializerOp->Asl.Value.Tag.BitOffset; 315 Node->Length = InitializerOp->Asl.Value.Tag.BitLength; 316 InitializerOp->Asl.Node = Node; 317 Node->Op = InitializerOp; 318 } 319 320 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 321 } 322 323 return (AE_OK); 324 } 325 326 327 /******************************************************************************* 328 * 329 * FUNCTION: LdNamespace1Begin 330 * 331 * PARAMETERS: ASL_WALK_CALLBACK 332 * 333 * RETURN: Status 334 * 335 * DESCRIPTION: Descending callback used during the parse tree walk. If this 336 * is a named AML opcode, enter into the namespace 337 * 338 ******************************************************************************/ 339 340 static ACPI_STATUS 341 LdNamespace1Begin ( 342 ACPI_PARSE_OBJECT *Op, 343 UINT32 Level, 344 void *Context) 345 { 346 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context; 347 ACPI_NAMESPACE_NODE *Node; 348 ACPI_STATUS Status; 349 ACPI_OBJECT_TYPE ObjectType; 350 ACPI_OBJECT_TYPE ActualObjectType = ACPI_TYPE_ANY; 351 char *Path; 352 UINT32 Flags = ACPI_NS_NO_UPSEARCH; 353 ACPI_PARSE_OBJECT *Arg; 354 UINT32 i; 355 BOOLEAN ForceNewScope = FALSE; 356 357 358 ACPI_FUNCTION_NAME (LdNamespace1Begin); 359 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n", 360 Op, Op->Asl.ParseOpName)); 361 362 363 /* 364 * We are only interested in opcodes that have an associated name 365 * (or multiple names) 366 */ 367 switch (Op->Asl.AmlOpcode) 368 { 369 case AML_BANK_FIELD_OP: 370 case AML_INDEX_FIELD_OP: 371 case AML_FIELD_OP: 372 373 Status = LdLoadFieldElements (Op, WalkState); 374 return (Status); 375 376 default: 377 378 /* All other opcodes go below */ 379 380 break; 381 } 382 383 /* Check if this object has already been installed in the namespace */ 384 385 if (Op->Asl.Node) 386 { 387 return (AE_OK); 388 } 389 390 Path = Op->Asl.Namepath; 391 if (!Path) 392 { 393 return (AE_OK); 394 } 395 396 /* Map the raw opcode into an internal object type */ 397 398 switch (Op->Asl.ParseOpcode) 399 { 400 case PARSEOP_NAME: 401 402 Arg = Op->Asl.Child; /* Get the NameSeg/NameString node */ 403 Arg = Arg->Asl.Next; /* First peer is the object to be associated with the name */ 404 405 /* 406 * If this name refers to a ResourceTemplate, we will need to open 407 * a new scope so that the resource subfield names can be entered into 408 * the namespace underneath this name 409 */ 410 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 411 { 412 ForceNewScope = TRUE; 413 } 414 415 /* Get the data type associated with the named object, not the name itself */ 416 417 /* Log2 loop to convert from Btype (binary) to Etype (encoded) */ 418 419 ObjectType = 1; 420 for (i = 1; i < Arg->Asl.AcpiBtype; i *= 2) 421 { 422 ObjectType++; 423 } 424 break; 425 426 427 case PARSEOP_EXTERNAL: 428 /* 429 * "External" simply enters a name and type into the namespace. 430 * We must be careful to not open a new scope, however, no matter 431 * what type the external name refers to (e.g., a method) 432 * 433 * first child is name, next child is ObjectType 434 */ 435 ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer; 436 ObjectType = ACPI_TYPE_ANY; 437 438 /* 439 * We will mark every new node along the path as "External". This 440 * allows some or all of the nodes to be created later in the ASL 441 * code. Handles cases like this: 442 * 443 * External (\_SB_.PCI0.ABCD, IntObj) 444 * Scope (_SB_) 445 * { 446 * Device (PCI0) 447 * { 448 * } 449 * } 450 * Method (X) 451 * { 452 * Store (\_SB_.PCI0.ABCD, Local0) 453 * } 454 */ 455 Flags |= ACPI_NS_EXTERNAL; 456 break; 457 458 case PARSEOP_DEFAULT_ARG: 459 460 if (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC) 461 { 462 Status = LdLoadResourceElements (Op, WalkState); 463 return_ACPI_STATUS (Status); 464 } 465 466 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 467 break; 468 469 470 case PARSEOP_SCOPE: 471 /* 472 * The name referenced by Scope(Name) must already exist at this point. 473 * In other words, forward references for Scope() are not supported. 474 * The only real reason for this is that the MS interpreter cannot 475 * handle this case. Perhaps someday this case can go away. 476 */ 477 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY, 478 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, 479 WalkState, &(Node)); 480 if (ACPI_FAILURE (Status)) 481 { 482 if (Status == AE_NOT_FOUND) 483 { 484 /* The name was not found, go ahead and create it */ 485 486 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, 487 ACPI_TYPE_LOCAL_SCOPE, 488 ACPI_IMODE_LOAD_PASS1, Flags, 489 WalkState, &(Node)); 490 if (ACPI_FAILURE (Status)) 491 { 492 return_ACPI_STATUS (Status); 493 } 494 495 /* 496 * However, this is an error -- primarily because the MS 497 * interpreter can't handle a forward reference from the 498 * Scope() operator. 499 */ 500 AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op, 501 Op->Asl.ExternalName); 502 AslError (ASL_ERROR, ASL_MSG_SCOPE_FWD_REF, Op, 503 Op->Asl.ExternalName); 504 goto FinishNode; 505 } 506 507 AslCoreSubsystemError (Op, Status, 508 "Failure from namespace lookup", FALSE); 509 510 return_ACPI_STATUS (Status); 511 } 512 513 /* We found a node with this name, now check the type */ 514 515 switch (Node->Type) 516 { 517 case ACPI_TYPE_LOCAL_SCOPE: 518 case ACPI_TYPE_DEVICE: 519 case ACPI_TYPE_POWER: 520 case ACPI_TYPE_PROCESSOR: 521 case ACPI_TYPE_THERMAL: 522 523 /* These are acceptable types - they all open a new scope */ 524 break; 525 526 case ACPI_TYPE_INTEGER: 527 case ACPI_TYPE_STRING: 528 case ACPI_TYPE_BUFFER: 529 /* 530 * These types we will allow, but we will change the type. 531 * This enables some existing code of the form: 532 * 533 * Name (DEB, 0) 534 * Scope (DEB) { ... } 535 * 536 * Which is used to workaround the fact that the MS interpreter 537 * does not allow Scope() forward references. 538 */ 539 sprintf (MsgBuffer, "%s [%s], changing type to [Scope]", 540 Op->Asl.ExternalName, AcpiUtGetTypeName (Node->Type)); 541 AslError (ASL_REMARK, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer); 542 543 /* Switch the type to scope, open the new scope */ 544 545 Node->Type = ACPI_TYPE_LOCAL_SCOPE; 546 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE, 547 WalkState); 548 if (ACPI_FAILURE (Status)) 549 { 550 return_ACPI_STATUS (Status); 551 } 552 break; 553 554 default: 555 556 /* All other types are an error */ 557 558 sprintf (MsgBuffer, "%s [%s]", Op->Asl.ExternalName, 559 AcpiUtGetTypeName (Node->Type)); 560 AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer); 561 562 /* 563 * However, switch the type to be an actual scope so 564 * that compilation can continue without generating a whole 565 * cascade of additional errors. Open the new scope. 566 */ 567 Node->Type = ACPI_TYPE_LOCAL_SCOPE; 568 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE, 569 WalkState); 570 if (ACPI_FAILURE (Status)) 571 { 572 return_ACPI_STATUS (Status); 573 } 574 break; 575 } 576 577 Status = AE_OK; 578 goto FinishNode; 579 580 581 default: 582 583 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 584 break; 585 } 586 587 588 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Loading name: %s, (%s)\n", 589 Op->Asl.ExternalName, AcpiUtGetTypeName (ObjectType))); 590 591 /* The name must not already exist */ 592 593 Flags |= ACPI_NS_ERROR_IF_FOUND; 594 595 /* 596 * Enter the named type into the internal namespace. We enter the name 597 * as we go downward in the parse tree. Any necessary subobjects that 598 * involve arguments to the opcode must be created as we go back up the 599 * parse tree later. 600 */ 601 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType, 602 ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node); 603 if (ACPI_FAILURE (Status)) 604 { 605 if (Status == AE_ALREADY_EXISTS) 606 { 607 /* The name already exists in this scope */ 608 609 if (Node->Type == ACPI_TYPE_LOCAL_SCOPE) 610 { 611 /* Allow multiple references to the same scope */ 612 613 Node->Type = (UINT8) ObjectType; 614 Status = AE_OK; 615 } 616 else if ((Node->Flags & ANOBJ_IS_EXTERNAL) && 617 (Op->Asl.ParseOpcode != PARSEOP_EXTERNAL)) 618 { 619 /* 620 * Allow one create on an object or segment that was 621 * previously declared External 622 */ 623 Node->Flags &= ~ANOBJ_IS_EXTERNAL; 624 Node->Type = (UINT8) ObjectType; 625 626 /* Just retyped a node, probably will need to open a scope */ 627 628 if (AcpiNsOpensScope (ObjectType)) 629 { 630 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 631 if (ACPI_FAILURE (Status)) 632 { 633 return_ACPI_STATUS (Status); 634 } 635 } 636 Status = AE_OK; 637 } 638 else 639 { 640 /* Valid error, object already exists */ 641 642 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op, 643 Op->Asl.ExternalName); 644 return_ACPI_STATUS (AE_OK); 645 } 646 } 647 else 648 { 649 AslCoreSubsystemError (Op, Status, 650 "Failure from namespace lookup", FALSE); 651 return_ACPI_STATUS (Status); 652 } 653 } 654 655 if (ForceNewScope) 656 { 657 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 658 if (ACPI_FAILURE (Status)) 659 { 660 return_ACPI_STATUS (Status); 661 } 662 } 663 664 FinishNode: 665 /* 666 * Point the parse node to the new namespace node, and point 667 * the Node back to the original Parse node 668 */ 669 Op->Asl.Node = Node; 670 Node->Op = Op; 671 672 /* Set the actual data type if appropriate (EXTERNAL term only) */ 673 674 if (ActualObjectType != ACPI_TYPE_ANY) 675 { 676 Node->Type = (UINT8) ActualObjectType; 677 Node->Value = ASL_EXTERNAL_METHOD; 678 } 679 680 if (Op->Asl.ParseOpcode == PARSEOP_METHOD) 681 { 682 /* 683 * Get the method argument count from "Extra" and save 684 * it in the namespace node 685 */ 686 Node->Value = (UINT32) Op->Asl.Extra; 687 } 688 689 return_ACPI_STATUS (Status); 690 } 691 692 693 /******************************************************************************* 694 * 695 * FUNCTION: LdNamespace2Begin 696 * 697 * PARAMETERS: ASL_WALK_CALLBACK 698 * 699 * RETURN: Status 700 * 701 * DESCRIPTION: Descending callback used during the pass 2 parse tree walk. 702 * Second pass resolves some forward references. 703 * 704 * Notes: 705 * Currently only needs to handle the Alias operator. 706 * Could be used to allow forward references from the Scope() operator, but 707 * the MS interpreter does not allow this, so this compiler does not either. 708 * 709 ******************************************************************************/ 710 711 static ACPI_STATUS 712 LdNamespace2Begin ( 713 ACPI_PARSE_OBJECT *Op, 714 UINT32 Level, 715 void *Context) 716 { 717 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context; 718 ACPI_STATUS Status; 719 ACPI_NAMESPACE_NODE *Node; 720 ACPI_OBJECT_TYPE ObjectType; 721 BOOLEAN ForceNewScope = FALSE; 722 ACPI_PARSE_OBJECT *Arg; 723 char *Path; 724 ACPI_NAMESPACE_NODE *TargetNode; 725 726 727 ACPI_FUNCTION_NAME (LdNamespace2Begin); 728 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n", 729 Op, Op->Asl.ParseOpName)); 730 731 732 /* Ignore Ops with no namespace node */ 733 734 Node = Op->Asl.Node; 735 if (!Node) 736 { 737 return (AE_OK); 738 } 739 740 /* Get the type to determine if we should push the scope */ 741 742 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) && 743 (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)) 744 { 745 ObjectType = ACPI_TYPE_LOCAL_RESOURCE; 746 } 747 else 748 { 749 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 750 } 751 752 /* Push scope for Resource Templates */ 753 754 if (Op->Asl.ParseOpcode == PARSEOP_NAME) 755 { 756 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 757 { 758 ForceNewScope = TRUE; 759 } 760 } 761 762 /* Push the scope stack */ 763 764 if (ForceNewScope || AcpiNsOpensScope (ObjectType)) 765 { 766 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 767 if (ACPI_FAILURE (Status)) 768 { 769 return_ACPI_STATUS (Status); 770 } 771 } 772 773 if (Op->Asl.ParseOpcode == PARSEOP_ALIAS) 774 { 775 /* Complete the alias node by getting and saving the target node */ 776 777 /* First child is the alias target */ 778 779 Arg = Op->Asl.Child; 780 781 /* Get the target pathname */ 782 783 Path = Arg->Asl.Namepath; 784 if (!Path) 785 { 786 Status = UtInternalizeName (Arg->Asl.ExternalName, &Path); 787 if (ACPI_FAILURE (Status)) 788 { 789 return (Status); 790 } 791 } 792 793 /* Get the NS node associated with the target. It must exist. */ 794 795 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY, 796 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT | ACPI_NS_DONT_OPEN_SCOPE, 797 WalkState, &TargetNode); 798 if (ACPI_FAILURE (Status)) 799 { 800 if (Status == AE_NOT_FOUND) 801 { 802 AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op, 803 Op->Asl.ExternalName); 804 805 /* 806 * The name was not found, go ahead and create it. 807 * This prevents more errors later. 808 */ 809 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, 810 ACPI_TYPE_ANY, 811 ACPI_IMODE_LOAD_PASS1, ACPI_NS_NO_UPSEARCH, 812 WalkState, &(Node)); 813 return (AE_OK); 814 } 815 816 AslCoreSubsystemError (Op, Status, 817 "Failure from namespace lookup", FALSE); 818 return (AE_OK); 819 } 820 821 /* Save the target node within the alias node */ 822 823 Node->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode); 824 } 825 826 return (AE_OK); 827 } 828 829 830 /******************************************************************************* 831 * 832 * FUNCTION: LdCommonNamespaceEnd 833 * 834 * PARAMETERS: ASL_WALK_CALLBACK 835 * 836 * RETURN: Status 837 * 838 * DESCRIPTION: Ascending callback used during the loading of the namespace, 839 * We only need to worry about managing the scope stack here. 840 * 841 ******************************************************************************/ 842 843 static ACPI_STATUS 844 LdCommonNamespaceEnd ( 845 ACPI_PARSE_OBJECT *Op, 846 UINT32 Level, 847 void *Context) 848 { 849 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context; 850 ACPI_OBJECT_TYPE ObjectType; 851 BOOLEAN ForceNewScope = FALSE; 852 853 854 ACPI_FUNCTION_NAME (LdCommonNamespaceEnd); 855 856 857 /* We are only interested in opcodes that have an associated name */ 858 859 if (!Op->Asl.Namepath) 860 { 861 return (AE_OK); 862 } 863 864 /* Get the type to determine if we should pop the scope */ 865 866 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) && 867 (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)) 868 { 869 /* TBD: Merge into AcpiDsMapNamedOpcodeToDataType */ 870 871 ObjectType = ACPI_TYPE_LOCAL_RESOURCE; 872 } 873 else 874 { 875 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 876 } 877 878 /* Pop scope that was pushed for Resource Templates */ 879 880 if (Op->Asl.ParseOpcode == PARSEOP_NAME) 881 { 882 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 883 { 884 ForceNewScope = TRUE; 885 } 886 } 887 888 /* Pop the scope stack */ 889 890 if (ForceNewScope || AcpiNsOpensScope (ObjectType)) 891 { 892 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 893 "(%s): Popping scope for Op [%s] %p\n", 894 AcpiUtGetTypeName (ObjectType), Op->Asl.ParseOpName, Op)); 895 896 (void) AcpiDsScopeStackPop (WalkState); 897 } 898 899 return (AE_OK); 900 }