xref: /freebsd/sys/contrib/dev/acpica/compiler/aslload.c (revision 1e413cf93298b5b97441a21d9a50fdcd0ee9945e)
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