1 /****************************************************************************** 2 * 3 * Module Name: dswload - Dispatcher namespace load callbacks 4 * $Revision: 1.77 $ 5 * 6 *****************************************************************************/ 7 8 /****************************************************************************** 9 * 10 * 1. Copyright Notice 11 * 12 * Some or all of this work - Copyright (c) 1999 - 2007, Intel Corp. 13 * All rights reserved. 14 * 15 * 2. License 16 * 17 * 2.1. This is your license from Intel Corp. under its intellectual property 18 * rights. You may have additional license terms from the party that provided 19 * you this software, covering your right to use that party's intellectual 20 * property rights. 21 * 22 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23 * copy of the source code appearing in this file ("Covered Code") an 24 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25 * base code distributed originally by Intel ("Original Intel Code") to copy, 26 * make derivatives, distribute, use and display any portion of the Covered 27 * Code in any form, with the right to sublicense such rights; and 28 * 29 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30 * license (with the right to sublicense), under only those claims of Intel 31 * patents that are infringed by the Original Intel Code, to make, use, sell, 32 * offer to sell, and import the Covered Code and derivative works thereof 33 * solely to the minimum extent necessary to exercise the above copyright 34 * license, and in no event shall the patent license extend to any additions 35 * to or modifications of the Original Intel Code. No other license or right 36 * is granted directly or by implication, estoppel or otherwise; 37 * 38 * The above copyright and patent license is granted only if the following 39 * conditions are met: 40 * 41 * 3. Conditions 42 * 43 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44 * Redistribution of source code of any substantial portion of the Covered 45 * Code or modification with rights to further distribute source must include 46 * the above Copyright Notice, the above License, this list of Conditions, 47 * and the following Disclaimer and Export Compliance provision. In addition, 48 * Licensee must cause all Covered Code to which Licensee contributes to 49 * contain a file documenting the changes Licensee made to create that Covered 50 * Code and the date of any change. Licensee must include in that file the 51 * documentation of any changes made by any predecessor Licensee. Licensee 52 * must include a prominent statement that the modification is derived, 53 * directly or indirectly, from Original Intel Code. 54 * 55 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56 * Redistribution of source code of any substantial portion of the Covered 57 * Code or modification without rights to further distribute source must 58 * include the following Disclaimer and Export Compliance provision in the 59 * documentation and/or other materials provided with distribution. In 60 * addition, Licensee may not authorize further sublicense of source of any 61 * portion of the Covered Code, and must include terms to the effect that the 62 * license from Licensee to its licensee is limited to the intellectual 63 * property embodied in the software Licensee provides to its licensee, and 64 * not to intellectual property embodied in modifications its licensee may 65 * make. 66 * 67 * 3.3. Redistribution of Executable. Redistribution in executable form of any 68 * substantial portion of the Covered Code or modification must reproduce the 69 * above Copyright Notice, and the following Disclaimer and Export Compliance 70 * provision in the documentation and/or other materials provided with the 71 * distribution. 72 * 73 * 3.4. Intel retains all right, title, and interest in and to the Original 74 * Intel Code. 75 * 76 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77 * Intel shall be used in advertising or otherwise to promote the sale, use or 78 * other dealings in products derived from or relating to the Covered Code 79 * without prior written authorization from Intel. 80 * 81 * 4. Disclaimer and Export Compliance 82 * 83 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89 * PARTICULAR PURPOSE. 90 * 91 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98 * LIMITED REMEDY. 99 * 100 * 4.3. Licensee shall not export, either directly or indirectly, any of this 101 * software or system incorporating such software without first obtaining any 102 * required license or other approval from the U. S. Department of Commerce or 103 * any other agency or department of the United States Government. In the 104 * event Licensee exports any such software from the United States or 105 * re-exports any such software from a foreign destination, Licensee shall 106 * ensure that the distribution and export/re-export of the software is in 107 * compliance with all laws, regulations, orders, or other restrictions of the 108 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109 * any of its subsidiaries will export/re-export any technical data, process, 110 * software, or service, directly or indirectly, to any country for which the 111 * United States government or any agency thereof requires an export license, 112 * other governmental approval, or letter of assurance, without first obtaining 113 * such license, approval or letter. 114 * 115 *****************************************************************************/ 116 117 #define __ASLLOAD_C__ 118 119 #include <contrib/dev/acpica/compiler/aslcompiler.h> 120 #include <contrib/dev/acpica/amlcode.h> 121 #include <contrib/dev/acpica/acdispat.h> 122 #include <contrib/dev/acpica/acnamesp.h> 123 124 #include "aslcompiler.y.h" 125 126 #define _COMPONENT ACPI_COMPILER 127 ACPI_MODULE_NAME ("aslload") 128 129 /* Local prototypes */ 130 131 static ACPI_STATUS 132 LdLoadFieldElements ( 133 ACPI_PARSE_OBJECT *Op, 134 ACPI_WALK_STATE *WalkState); 135 136 static ACPI_STATUS 137 LdLoadResourceElements ( 138 ACPI_PARSE_OBJECT *Op, 139 ACPI_WALK_STATE *WalkState); 140 141 static ACPI_STATUS 142 LdNamespace1Begin ( 143 ACPI_PARSE_OBJECT *Op, 144 UINT32 Level, 145 void *Context); 146 147 static ACPI_STATUS 148 LdNamespace1End ( 149 ACPI_PARSE_OBJECT *Op, 150 UINT32 Level, 151 void *Context); 152 153 154 /******************************************************************************* 155 * 156 * FUNCTION: LdLoadNamespace 157 * 158 * PARAMETERS: RootOp - Root of the parse tree 159 * 160 * RETURN: Status 161 * 162 * DESCRIPTION: Perform a walk of the parse tree that in turn loads all of the 163 * named ASL/AML objects into the namespace. The namespace is 164 * constructed in order to resolve named references and references 165 * to named fields within resource templates/descriptors. 166 * 167 ******************************************************************************/ 168 169 ACPI_STATUS 170 LdLoadNamespace ( 171 ACPI_PARSE_OBJECT *RootOp) 172 { 173 ACPI_WALK_STATE *WalkState; 174 175 176 DbgPrint (ASL_DEBUG_OUTPUT, "\nCreating namespace\n\n"); 177 178 /* Create a new walk state */ 179 180 WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL); 181 if (!WalkState) 182 { 183 return AE_NO_MEMORY; 184 } 185 186 /* Perform the walk of the parse tree */ 187 188 TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace1Begin, 189 LdNamespace1End, WalkState); 190 191 /* Dump the namespace if debug is enabled */ 192 193 AcpiNsDumpTables (ACPI_NS_ALL, ACPI_UINT32_MAX); 194 return AE_OK; 195 } 196 197 198 /******************************************************************************* 199 * 200 * FUNCTION: LdLoadFieldElements 201 * 202 * PARAMETERS: Op - Parent node (Field) 203 * WalkState - Current walk state 204 * 205 * RETURN: Status 206 * 207 * DESCRIPTION: Enter the named elements of the field (children of the parent) 208 * into the namespace. 209 * 210 ******************************************************************************/ 211 212 static ACPI_STATUS 213 LdLoadFieldElements ( 214 ACPI_PARSE_OBJECT *Op, 215 ACPI_WALK_STATE *WalkState) 216 { 217 ACPI_PARSE_OBJECT *Child = NULL; 218 ACPI_NAMESPACE_NODE *Node; 219 ACPI_STATUS Status; 220 221 222 /* Get the first named field element */ 223 224 switch (Op->Asl.AmlOpcode) 225 { 226 case AML_BANK_FIELD_OP: 227 228 Child = UtGetArg (Op, 6); 229 break; 230 231 case AML_INDEX_FIELD_OP: 232 233 Child = UtGetArg (Op, 5); 234 break; 235 236 case AML_FIELD_OP: 237 238 Child = UtGetArg (Op, 4); 239 break; 240 241 default: 242 /* No other opcodes should arrive here */ 243 return (AE_BAD_PARAMETER); 244 } 245 246 /* Enter all elements into the namespace */ 247 248 while (Child) 249 { 250 switch (Child->Asl.AmlOpcode) 251 { 252 case AML_INT_RESERVEDFIELD_OP: 253 case AML_INT_ACCESSFIELD_OP: 254 255 break; 256 257 default: 258 259 Status = AcpiNsLookup (WalkState->ScopeInfo, 260 Child->Asl.Value.String, 261 ACPI_TYPE_LOCAL_REGION_FIELD, 262 ACPI_IMODE_LOAD_PASS1, 263 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | 264 ACPI_NS_ERROR_IF_FOUND, 265 NULL, &Node); 266 if (ACPI_FAILURE (Status)) 267 { 268 if (Status != AE_ALREADY_EXISTS) 269 { 270 AslError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, Child, 271 Child->Asl.Value.String); 272 return (Status); 273 } 274 275 /* 276 * The name already exists in this scope 277 * But continue processing the elements 278 */ 279 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Child, 280 Child->Asl.Value.String); 281 } 282 else 283 { 284 Child->Asl.Node = Node; 285 Node->Op = Child; 286 } 287 break; 288 } 289 Child = Child->Asl.Next; 290 } 291 return (AE_OK); 292 } 293 294 295 /******************************************************************************* 296 * 297 * FUNCTION: LdLoadResourceElements 298 * 299 * PARAMETERS: Op - Parent node (Resource Descriptor) 300 * WalkState - Current walk state 301 * 302 * RETURN: Status 303 * 304 * DESCRIPTION: Enter the named elements of the resource descriptor (children 305 * of the parent) into the namespace. 306 * 307 * NOTE: In the real AML namespace, these named elements never exist. But 308 * we simply use the namespace here as a symbol table so we can look 309 * them up as they are referenced. 310 * 311 ******************************************************************************/ 312 313 static ACPI_STATUS 314 LdLoadResourceElements ( 315 ACPI_PARSE_OBJECT *Op, 316 ACPI_WALK_STATE *WalkState) 317 { 318 ACPI_PARSE_OBJECT *InitializerOp = NULL; 319 ACPI_NAMESPACE_NODE *Node; 320 ACPI_STATUS Status; 321 322 323 /* 324 * Enter the resource name into the namespace. Name must not already exist. 325 * This opens a scope, so later field names are guaranteed to be new/unique. 326 */ 327 Status = AcpiNsLookup (WalkState->ScopeInfo, Op->Asl.Namepath, 328 ACPI_TYPE_LOCAL_RESOURCE, ACPI_IMODE_LOAD_PASS1, 329 ACPI_NS_NO_UPSEARCH | ACPI_NS_ERROR_IF_FOUND, 330 WalkState, &Node); 331 if (ACPI_FAILURE (Status)) 332 { 333 if (Status == AE_ALREADY_EXISTS) 334 { 335 /* Actual node causing the error was saved in ParentMethod */ 336 337 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, 338 (ACPI_PARSE_OBJECT *) Op->Asl.ParentMethod, Op->Asl.Namepath); 339 return (AE_OK); 340 } 341 return (Status); 342 } 343 344 Node->Value = (UINT32) Op->Asl.Value.Integer; 345 Node->Op = Op; 346 347 /* 348 * Now enter the predefined fields, for easy lookup when referenced 349 * by the source ASL 350 */ 351 InitializerOp = ASL_GET_CHILD_NODE (Op); 352 while (InitializerOp) 353 { 354 355 if (InitializerOp->Asl.ExternalName) 356 { 357 Status = AcpiNsLookup (WalkState->ScopeInfo, 358 InitializerOp->Asl.ExternalName, 359 ACPI_TYPE_LOCAL_RESOURCE_FIELD, 360 ACPI_IMODE_LOAD_PASS1, 361 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE, 362 NULL, &Node); 363 if (ACPI_FAILURE (Status)) 364 { 365 return (Status); 366 } 367 368 /* 369 * Store the field offset in the namespace node so it 370 * can be used when the field is referenced 371 */ 372 Node->Value = (UINT32) InitializerOp->Asl.Value.Integer; 373 InitializerOp->Asl.Node = Node; 374 Node->Op = InitializerOp; 375 376 /* Pass thru the field type (Bitfield or Bytefield) */ 377 378 if (InitializerOp->Asl.CompileFlags & NODE_IS_BIT_OFFSET) 379 { 380 Node->Flags |= ANOBJ_IS_BIT_OFFSET; 381 } 382 } 383 InitializerOp = ASL_GET_PEER_NODE (InitializerOp); 384 } 385 386 return (AE_OK); 387 } 388 389 390 /******************************************************************************* 391 * 392 * FUNCTION: LdNamespace1Begin 393 * 394 * PARAMETERS: ASL_WALK_CALLBACK 395 * 396 * RETURN: Status 397 * 398 * DESCRIPTION: Descending callback used during the parse tree walk. If this 399 * is a named AML opcode, enter into the namespace 400 * 401 ******************************************************************************/ 402 403 static ACPI_STATUS 404 LdNamespace1Begin ( 405 ACPI_PARSE_OBJECT *Op, 406 UINT32 Level, 407 void *Context) 408 { 409 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context; 410 ACPI_NAMESPACE_NODE *Node; 411 ACPI_STATUS Status; 412 ACPI_OBJECT_TYPE ObjectType; 413 ACPI_OBJECT_TYPE ActualObjectType = ACPI_TYPE_ANY; 414 char *Path; 415 UINT32 Flags = ACPI_NS_NO_UPSEARCH; 416 ACPI_PARSE_OBJECT *Arg; 417 UINT32 i; 418 BOOLEAN ForceNewScope = FALSE; 419 420 421 ACPI_FUNCTION_NAME (LdNamespace1Begin); 422 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n", 423 Op, Op->Asl.ParseOpName)); 424 425 426 /* 427 * We are only interested in opcodes that have an associated name 428 * (or multiple names) 429 */ 430 switch (Op->Asl.AmlOpcode) 431 { 432 case AML_BANK_FIELD_OP: 433 case AML_INDEX_FIELD_OP: 434 case AML_FIELD_OP: 435 436 Status = LdLoadFieldElements (Op, WalkState); 437 return (Status); 438 439 default: 440 441 /* All other opcodes go below */ 442 break; 443 } 444 445 /* Check if this object has already been installed in the namespace */ 446 447 if (Op->Asl.Node) 448 { 449 return (AE_OK); 450 } 451 452 Path = Op->Asl.Namepath; 453 if (!Path) 454 { 455 return (AE_OK); 456 } 457 458 /* Map the raw opcode into an internal object type */ 459 460 switch (Op->Asl.ParseOpcode) 461 { 462 case PARSEOP_NAME: 463 464 Arg = Op->Asl.Child; /* Get the NameSeg/NameString node */ 465 Arg = Arg->Asl.Next; /* First peer is the object to be associated with the name */ 466 467 /* 468 * If this name refers to a ResourceTemplate, we will need to open 469 * a new scope so that the resource subfield names can be entered into 470 * the namespace underneath this name 471 */ 472 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 473 { 474 ForceNewScope = TRUE; 475 } 476 477 /* Get the data type associated with the named object, not the name itself */ 478 479 /* Log2 loop to convert from Btype (binary) to Etype (encoded) */ 480 481 ObjectType = 1; 482 for (i = 1; i < Arg->Asl.AcpiBtype; i *= 2) 483 { 484 ObjectType++; 485 } 486 break; 487 488 489 case PARSEOP_EXTERNAL: 490 491 /* 492 * "External" simply enters a name and type into the namespace. 493 * We must be careful to not open a new scope, however, no matter 494 * what type the external name refers to (e.g., a method) 495 * 496 * first child is name, next child is ObjectType 497 */ 498 ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer; 499 ObjectType = ACPI_TYPE_ANY; 500 501 /* 502 * We will mark every new node along the path as "External". This 503 * allows some or all of the nodes to be created later in the ASL 504 * code. Handles cases like this: 505 * 506 * External (\_SB_.PCI0.ABCD, IntObj) 507 * Scope (_SB_) 508 * { 509 * Device (PCI0) 510 * { 511 * } 512 * } 513 * Method (X) 514 * { 515 * Store (\_SB_.PCI0.ABCD, Local0) 516 * } 517 */ 518 Flags |= ACPI_NS_EXTERNAL; 519 break; 520 521 case PARSEOP_DEFAULT_ARG: 522 523 if (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC) 524 { 525 Status = LdLoadResourceElements (Op, WalkState); 526 goto Exit; 527 } 528 529 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 530 break; 531 532 533 case PARSEOP_SCOPE: 534 535 /* 536 * The name referenced by Scope(Name) must already exist at this point. 537 * In other words, forward references for Scope() are not supported. 538 * The only real reason for this is that the MS interpreter cannot 539 * handle this case. Perhaps someday this case can go away. 540 */ 541 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY, 542 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, 543 WalkState, &(Node)); 544 if (ACPI_FAILURE (Status)) 545 { 546 if (Status == AE_NOT_FOUND) 547 { 548 /* The name was not found, go ahead and create it */ 549 550 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, 551 ACPI_TYPE_LOCAL_SCOPE, 552 ACPI_IMODE_LOAD_PASS1, Flags, 553 WalkState, &(Node)); 554 555 /* 556 * However, this is an error -- primarily because the MS 557 * interpreter can't handle a forward reference from the 558 * Scope() operator. 559 */ 560 AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op, 561 Op->Asl.ExternalName); 562 AslError (ASL_ERROR, ASL_MSG_SCOPE_FWD_REF, Op, 563 Op->Asl.ExternalName); 564 goto FinishNode; 565 } 566 567 AslCoreSubsystemError (Op, Status, "Failure from lookup\n", FALSE); 568 goto Exit; 569 } 570 571 /* We found a node with this name, now check the type */ 572 573 switch (Node->Type) 574 { 575 case ACPI_TYPE_LOCAL_SCOPE: 576 case ACPI_TYPE_DEVICE: 577 case ACPI_TYPE_POWER: 578 case ACPI_TYPE_PROCESSOR: 579 case ACPI_TYPE_THERMAL: 580 581 /* These are acceptable types - they all open a new scope */ 582 break; 583 584 case ACPI_TYPE_INTEGER: 585 case ACPI_TYPE_STRING: 586 case ACPI_TYPE_BUFFER: 587 588 /* 589 * These types we will allow, but we will change the type. 590 * This enables some existing code of the form: 591 * 592 * Name (DEB, 0) 593 * Scope (DEB) { ... } 594 * 595 * Which is used to workaround the fact that the MS interpreter 596 * does not allow Scope() forward references. 597 */ 598 sprintf (MsgBuffer, "%s [%s], changing type to [Scope]", 599 Op->Asl.ExternalName, AcpiUtGetTypeName (Node->Type)); 600 AslError (ASL_REMARK, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer); 601 602 /* Switch the type to scope, open the new scope */ 603 604 Node->Type = ACPI_TYPE_LOCAL_SCOPE; 605 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE, 606 WalkState); 607 if (ACPI_FAILURE (Status)) 608 { 609 return_ACPI_STATUS (Status); 610 } 611 break; 612 613 default: 614 615 /* All other types are an error */ 616 617 sprintf (MsgBuffer, "%s [%s]", Op->Asl.ExternalName, 618 AcpiUtGetTypeName (Node->Type)); 619 AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer); 620 621 /* 622 * However, switch the type to be an actual scope so 623 * that compilation can continue without generating a whole 624 * cascade of additional errors. Open the new scope. 625 */ 626 Node->Type = ACPI_TYPE_LOCAL_SCOPE; 627 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE, 628 WalkState); 629 if (ACPI_FAILURE (Status)) 630 { 631 return_ACPI_STATUS (Status); 632 } 633 break; 634 } 635 636 Status = AE_OK; 637 goto FinishNode; 638 639 640 default: 641 642 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 643 break; 644 } 645 646 647 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Loading name: %s, (%s)\n", 648 Op->Asl.ExternalName, AcpiUtGetTypeName (ObjectType))); 649 650 /* The name must not already exist */ 651 652 Flags |= ACPI_NS_ERROR_IF_FOUND; 653 654 /* 655 * Enter the named type into the internal namespace. We enter the name 656 * as we go downward in the parse tree. Any necessary subobjects that 657 * involve arguments to the opcode must be created as we go back up the 658 * parse tree later. 659 */ 660 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType, 661 ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node); 662 if (ACPI_FAILURE (Status)) 663 { 664 if (Status == AE_ALREADY_EXISTS) 665 { 666 /* The name already exists in this scope */ 667 668 if (Node->Type == ACPI_TYPE_LOCAL_SCOPE) 669 { 670 /* Allow multiple references to the same scope */ 671 672 Node->Type = (UINT8) ObjectType; 673 Status = AE_OK; 674 } 675 else if (Node->Flags & ANOBJ_IS_EXTERNAL) 676 { 677 /* 678 * Allow one create on an object or segment that was 679 * previously declared External 680 */ 681 Node->Flags &= ~ANOBJ_IS_EXTERNAL; 682 Node->Type = (UINT8) ObjectType; 683 684 /* Just retyped a node, probably will need to open a scope */ 685 686 if (AcpiNsOpensScope (ObjectType)) 687 { 688 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 689 if (ACPI_FAILURE (Status)) 690 { 691 return_ACPI_STATUS (Status); 692 } 693 } 694 Status = AE_OK; 695 } 696 else 697 { 698 /* Valid error, object already exists */ 699 700 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op, 701 Op->Asl.ExternalName); 702 Status = AE_OK; 703 goto Exit; 704 } 705 } 706 else 707 { 708 AslCoreSubsystemError (Op, Status, 709 "Failure from lookup %s\n", FALSE); 710 goto Exit; 711 } 712 } 713 714 if (ForceNewScope) 715 { 716 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState); 717 if (ACPI_FAILURE (Status)) 718 { 719 return_ACPI_STATUS (Status); 720 } 721 } 722 723 FinishNode: 724 /* 725 * Point the parse node to the new namespace node, and point 726 * the Node back to the original Parse node 727 */ 728 Op->Asl.Node = Node; 729 Node->Op = Op; 730 731 /* Set the actual data type if appropriate (EXTERNAL term only) */ 732 733 if (ActualObjectType != ACPI_TYPE_ANY) 734 { 735 Node->Type = (UINT8) ActualObjectType; 736 Node->Value = ASL_EXTERNAL_METHOD; 737 } 738 739 if (Op->Asl.ParseOpcode == PARSEOP_METHOD) 740 { 741 /* 742 * Get the method argument count from "Extra" and save 743 * it in the namespace node 744 */ 745 Node->Value = (UINT32) Op->Asl.Extra; 746 } 747 748 Exit: 749 return (Status); 750 } 751 752 753 /******************************************************************************* 754 * 755 * FUNCTION: LdNamespace1End 756 * 757 * PARAMETERS: ASL_WALK_CALLBACK 758 * 759 * RETURN: Status 760 * 761 * DESCRIPTION: Ascending callback used during the loading of the namespace, 762 * We only need to worry about managing the scope stack here. 763 * 764 ******************************************************************************/ 765 766 static ACPI_STATUS 767 LdNamespace1End ( 768 ACPI_PARSE_OBJECT *Op, 769 UINT32 Level, 770 void *Context) 771 { 772 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context; 773 ACPI_OBJECT_TYPE ObjectType; 774 BOOLEAN ForceNewScope = FALSE; 775 776 777 ACPI_FUNCTION_NAME (LdNamespace1End); 778 779 780 /* We are only interested in opcodes that have an associated name */ 781 782 if (!Op->Asl.Namepath) 783 { 784 return (AE_OK); 785 } 786 787 /* Get the type to determine if we should pop the scope */ 788 789 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) && 790 (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)) 791 { 792 /* TBD: Merge into AcpiDsMapNamedOpcodeToDataType */ 793 794 ObjectType = ACPI_TYPE_LOCAL_RESOURCE; 795 } 796 else 797 { 798 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode); 799 } 800 801 /* Pop scope that was pushed for Resource Templates */ 802 803 if (Op->Asl.ParseOpcode == PARSEOP_NAME) 804 { 805 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC) 806 { 807 ForceNewScope = TRUE; 808 } 809 } 810 811 /* Pop the scope stack */ 812 813 if (ForceNewScope || AcpiNsOpensScope (ObjectType)) 814 { 815 816 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, 817 "(%s): Popping scope for Op [%s] %p\n", 818 AcpiUtGetTypeName (ObjectType), Op->Asl.ParseOpName, Op)); 819 820 (void) AcpiDsScopeStackPop (WalkState); 821 } 822 823 return (AE_OK); 824 } 825 826 827