1 /******************************************************************************
3 * Module Name: dswload - Dispatcher namespace load callbacks
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2011, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include <contrib/dev/acpica/include/amlcode.h>
48 #include <contrib/dev/acpica/include/acdispat.h>
49 #include <contrib/dev/acpica/include/acnamesp.h>
51 #include "aslcompiler.y.h"
53 #define _COMPONENT ACPI_COMPILER
54 ACPI_MODULE_NAME ("aslload")
56 /* Local prototypes */
60 ACPI_PARSE_OBJECT *Op,
61 ACPI_WALK_STATE *WalkState);
64 LdLoadResourceElements (
65 ACPI_PARSE_OBJECT *Op,
66 ACPI_WALK_STATE *WalkState);
70 ACPI_PARSE_OBJECT *Op,
76 ACPI_PARSE_OBJECT *Op,
81 LdCommonNamespaceEnd (
82 ACPI_PARSE_OBJECT *Op,
87 /*******************************************************************************
89 * FUNCTION: LdLoadNamespace
91 * PARAMETERS: RootOp - Root of the parse tree
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.
100 ******************************************************************************/
104 ACPI_PARSE_OBJECT *RootOp)
106 ACPI_WALK_STATE *WalkState;
109 DbgPrint (ASL_DEBUG_OUTPUT, "\nCreating namespace\n\n");
111 /* Create a new walk state */
113 WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
119 /* Walk the entire parse tree, first pass */
121 TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace1Begin,
122 LdCommonNamespaceEnd, WalkState);
124 /* Second pass to handle forward references */
126 TrWalkParseTree (RootOp, ASL_WALK_VISIT_TWICE, LdNamespace2Begin,
127 LdCommonNamespaceEnd, WalkState);
129 /* Dump the namespace if debug is enabled */
131 AcpiNsDumpTables (ACPI_NS_ALL, ACPI_UINT32_MAX);
136 /*******************************************************************************
138 * FUNCTION: LdLoadFieldElements
140 * PARAMETERS: Op - Parent node (Field)
141 * WalkState - Current walk state
145 * DESCRIPTION: Enter the named elements of the field (children of the parent)
146 * into the namespace.
148 ******************************************************************************/
151 LdLoadFieldElements (
152 ACPI_PARSE_OBJECT *Op,
153 ACPI_WALK_STATE *WalkState)
155 ACPI_PARSE_OBJECT *Child = NULL;
156 ACPI_NAMESPACE_NODE *Node;
160 /* Get the first named field element */
162 switch (Op->Asl.AmlOpcode)
164 case AML_BANK_FIELD_OP:
166 Child = UtGetArg (Op, 6);
169 case AML_INDEX_FIELD_OP:
171 Child = UtGetArg (Op, 5);
176 Child = UtGetArg (Op, 4);
180 /* No other opcodes should arrive here */
181 return (AE_BAD_PARAMETER);
184 /* Enter all elements into the namespace */
188 switch (Child->Asl.AmlOpcode)
190 case AML_INT_RESERVEDFIELD_OP:
191 case AML_INT_ACCESSFIELD_OP:
197 Status = AcpiNsLookup (WalkState->ScopeInfo,
198 Child->Asl.Value.String,
199 ACPI_TYPE_LOCAL_REGION_FIELD,
200 ACPI_IMODE_LOAD_PASS1,
201 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
202 ACPI_NS_ERROR_IF_FOUND,
204 if (ACPI_FAILURE (Status))
206 if (Status != AE_ALREADY_EXISTS)
208 AslError (ASL_ERROR, ASL_MSG_CORE_EXCEPTION, Child,
209 Child->Asl.Value.String);
214 * The name already exists in this scope
215 * But continue processing the elements
217 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Child,
218 Child->Asl.Value.String);
222 Child->Asl.Node = Node;
227 Child = Child->Asl.Next;
233 /*******************************************************************************
235 * FUNCTION: LdLoadResourceElements
237 * PARAMETERS: Op - Parent node (Resource Descriptor)
238 * WalkState - Current walk state
242 * DESCRIPTION: Enter the named elements of the resource descriptor (children
243 * of the parent) into the namespace.
245 * NOTE: In the real AML namespace, these named elements never exist. But
246 * we simply use the namespace here as a symbol table so we can look
247 * them up as they are referenced.
249 ******************************************************************************/
252 LdLoadResourceElements (
253 ACPI_PARSE_OBJECT *Op,
254 ACPI_WALK_STATE *WalkState)
256 ACPI_PARSE_OBJECT *InitializerOp = NULL;
257 ACPI_NAMESPACE_NODE *Node;
262 * Enter the resource name into the namespace. Name must not already exist.
263 * This opens a scope, so later field names are guaranteed to be new/unique.
265 Status = AcpiNsLookup (WalkState->ScopeInfo, Op->Asl.Namepath,
266 ACPI_TYPE_LOCAL_RESOURCE, ACPI_IMODE_LOAD_PASS1,
267 ACPI_NS_NO_UPSEARCH | ACPI_NS_ERROR_IF_FOUND,
269 if (ACPI_FAILURE (Status))
271 if (Status == AE_ALREADY_EXISTS)
273 /* Actual node causing the error was saved in ParentMethod */
275 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS,
276 (ACPI_PARSE_OBJECT *) Op->Asl.ParentMethod, Op->Asl.Namepath);
282 Node->Value = (UINT32) Op->Asl.Value.Integer;
287 * Now enter the predefined fields, for easy lookup when referenced
290 InitializerOp = ASL_GET_CHILD_NODE (Op);
291 while (InitializerOp)
294 if (InitializerOp->Asl.ExternalName)
296 Status = AcpiNsLookup (WalkState->ScopeInfo,
297 InitializerOp->Asl.ExternalName,
298 ACPI_TYPE_LOCAL_RESOURCE_FIELD,
299 ACPI_IMODE_LOAD_PASS1,
300 ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE,
302 if (ACPI_FAILURE (Status))
308 * Store the field offset in the namespace node so it
309 * can be used when the field is referenced
311 Node->Value = (UINT32) InitializerOp->Asl.Value.Integer;
312 InitializerOp->Asl.Node = Node;
313 Node->Op = InitializerOp;
315 /* Pass thru the field type (Bitfield or Bytefield) */
317 if (InitializerOp->Asl.CompileFlags & NODE_IS_BIT_OFFSET)
319 Node->Flags |= ANOBJ_IS_BIT_OFFSET;
322 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
329 /*******************************************************************************
331 * FUNCTION: LdNamespace1Begin
333 * PARAMETERS: ASL_WALK_CALLBACK
337 * DESCRIPTION: Descending callback used during the parse tree walk. If this
338 * is a named AML opcode, enter into the namespace
340 ******************************************************************************/
344 ACPI_PARSE_OBJECT *Op,
348 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context;
349 ACPI_NAMESPACE_NODE *Node;
351 ACPI_OBJECT_TYPE ObjectType;
352 ACPI_OBJECT_TYPE ActualObjectType = ACPI_TYPE_ANY;
354 UINT32 Flags = ACPI_NS_NO_UPSEARCH;
355 ACPI_PARSE_OBJECT *Arg;
357 BOOLEAN ForceNewScope = FALSE;
360 ACPI_FUNCTION_NAME (LdNamespace1Begin);
361 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n",
362 Op, Op->Asl.ParseOpName));
366 * We are only interested in opcodes that have an associated name
367 * (or multiple names)
369 switch (Op->Asl.AmlOpcode)
371 case AML_BANK_FIELD_OP:
372 case AML_INDEX_FIELD_OP:
375 Status = LdLoadFieldElements (Op, WalkState);
380 /* All other opcodes go below */
384 /* Check if this object has already been installed in the namespace */
391 Path = Op->Asl.Namepath;
397 /* Map the raw opcode into an internal object type */
399 switch (Op->Asl.ParseOpcode)
403 Arg = Op->Asl.Child; /* Get the NameSeg/NameString node */
404 Arg = Arg->Asl.Next; /* First peer is the object to be associated with the name */
407 * If this name refers to a ResourceTemplate, we will need to open
408 * a new scope so that the resource subfield names can be entered into
409 * the namespace underneath this name
411 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
413 ForceNewScope = TRUE;
416 /* Get the data type associated with the named object, not the name itself */
418 /* Log2 loop to convert from Btype (binary) to Etype (encoded) */
421 for (i = 1; i < Arg->Asl.AcpiBtype; i *= 2)
428 case PARSEOP_EXTERNAL:
431 * "External" simply enters a name and type into the namespace.
432 * We must be careful to not open a new scope, however, no matter
433 * what type the external name refers to (e.g., a method)
435 * first child is name, next child is ObjectType
437 ActualObjectType = (UINT8) Op->Asl.Child->Asl.Next->Asl.Value.Integer;
438 ObjectType = ACPI_TYPE_ANY;
441 * We will mark every new node along the path as "External". This
442 * allows some or all of the nodes to be created later in the ASL
443 * code. Handles cases like this:
445 * External (\_SB_.PCI0.ABCD, IntObj)
454 * Store (\_SB_.PCI0.ABCD, Local0)
457 Flags |= ACPI_NS_EXTERNAL;
460 case PARSEOP_DEFAULT_ARG:
462 if (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC)
464 Status = LdLoadResourceElements (Op, WalkState);
465 return_ACPI_STATUS (Status);
468 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
475 * The name referenced by Scope(Name) must already exist at this point.
476 * In other words, forward references for Scope() are not supported.
477 * The only real reason for this is that the MS interpreter cannot
478 * handle this case. Perhaps someday this case can go away.
480 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_ANY,
481 ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
483 if (ACPI_FAILURE (Status))
485 if (Status == AE_NOT_FOUND)
487 /* The name was not found, go ahead and create it */
489 Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
490 ACPI_TYPE_LOCAL_SCOPE,
491 ACPI_IMODE_LOAD_PASS1, Flags,
495 * However, this is an error -- primarily because the MS
496 * interpreter can't handle a forward reference from the
499 AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op,
500 Op->Asl.ExternalName);
501 AslError (ASL_ERROR, ASL_MSG_SCOPE_FWD_REF, Op,
502 Op->Asl.ExternalName);
506 AslCoreSubsystemError (Op, Status,
507 "Failure from namespace lookup", FALSE);
509 return_ACPI_STATUS (Status);
512 /* We found a node with this name, now check the type */
516 case ACPI_TYPE_LOCAL_SCOPE:
517 case ACPI_TYPE_DEVICE:
518 case ACPI_TYPE_POWER:
519 case ACPI_TYPE_PROCESSOR:
520 case ACPI_TYPE_THERMAL:
522 /* These are acceptable types - they all open a new scope */
525 case ACPI_TYPE_INTEGER:
526 case ACPI_TYPE_STRING:
527 case ACPI_TYPE_BUFFER:
530 * These types we will allow, but we will change the type.
531 * This enables some existing code of the form:
534 * Scope (DEB) { ... }
536 * Which is used to workaround the fact that the MS interpreter
537 * does not allow Scope() forward references.
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);
543 /* Switch the type to scope, open the new scope */
545 Node->Type = ACPI_TYPE_LOCAL_SCOPE;
546 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE,
548 if (ACPI_FAILURE (Status))
550 return_ACPI_STATUS (Status);
556 /* All other types are an error */
558 sprintf (MsgBuffer, "%s [%s]", Op->Asl.ExternalName,
559 AcpiUtGetTypeName (Node->Type));
560 AslError (ASL_ERROR, ASL_MSG_SCOPE_TYPE, Op, MsgBuffer);
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.
567 Node->Type = ACPI_TYPE_LOCAL_SCOPE;
568 Status = AcpiDsScopeStackPush (Node, ACPI_TYPE_LOCAL_SCOPE,
570 if (ACPI_FAILURE (Status))
572 return_ACPI_STATUS (Status);
583 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
588 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Loading name: %s, (%s)\n",
589 Op->Asl.ExternalName, AcpiUtGetTypeName (ObjectType)));
591 /* The name must not already exist */
593 Flags |= ACPI_NS_ERROR_IF_FOUND;
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
601 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
602 ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
603 if (ACPI_FAILURE (Status))
605 if (Status == AE_ALREADY_EXISTS)
607 /* The name already exists in this scope */
609 if (Node->Type == ACPI_TYPE_LOCAL_SCOPE)
611 /* Allow multiple references to the same scope */
613 Node->Type = (UINT8) ObjectType;
616 else if ((Node->Flags & ANOBJ_IS_EXTERNAL) &&
617 (Op->Asl.ParseOpcode != PARSEOP_EXTERNAL))
620 * Allow one create on an object or segment that was
621 * previously declared External
623 Node->Flags &= ~ANOBJ_IS_EXTERNAL;
624 Node->Type = (UINT8) ObjectType;
626 /* Just retyped a node, probably will need to open a scope */
628 if (AcpiNsOpensScope (ObjectType))
630 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
631 if (ACPI_FAILURE (Status))
633 return_ACPI_STATUS (Status);
640 /* Valid error, object already exists */
642 AslError (ASL_ERROR, ASL_MSG_NAME_EXISTS, Op,
643 Op->Asl.ExternalName);
644 return_ACPI_STATUS (AE_OK);
649 AslCoreSubsystemError (Op, Status,
650 "Failure from namespace lookup", FALSE);
651 return_ACPI_STATUS (Status);
657 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
658 if (ACPI_FAILURE (Status))
660 return_ACPI_STATUS (Status);
666 * Point the parse node to the new namespace node, and point
667 * the Node back to the original Parse node
672 /* Set the actual data type if appropriate (EXTERNAL term only) */
674 if (ActualObjectType != ACPI_TYPE_ANY)
676 Node->Type = (UINT8) ActualObjectType;
677 Node->Value = ASL_EXTERNAL_METHOD;
680 if (Op->Asl.ParseOpcode == PARSEOP_METHOD)
683 * Get the method argument count from "Extra" and save
684 * it in the namespace node
686 Node->Value = (UINT32) Op->Asl.Extra;
689 return_ACPI_STATUS (Status);
693 /*******************************************************************************
695 * FUNCTION: LdNamespace2Begin
697 * PARAMETERS: ASL_WALK_CALLBACK
701 * DESCRIPTION: Descending callback used during the pass 2 parse tree walk.
702 * Second pass resolves some forward references.
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.
709 ******************************************************************************/
713 ACPI_PARSE_OBJECT *Op,
717 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context;
719 ACPI_NAMESPACE_NODE *Node;
720 ACPI_OBJECT_TYPE ObjectType;
721 BOOLEAN ForceNewScope = FALSE;
722 ACPI_PARSE_OBJECT *Arg;
724 ACPI_NAMESPACE_NODE *TargetNode;
727 ACPI_FUNCTION_NAME (LdNamespace2Begin);
728 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op %p [%s]\n",
729 Op, Op->Asl.ParseOpName));
732 /* Ignore Ops with no namespace node */
740 /* Get the type to determine if we should push the scope */
742 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) &&
743 (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC))
745 ObjectType = ACPI_TYPE_LOCAL_RESOURCE;
749 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
752 /* Push scope for Resource Templates */
754 if (Op->Asl.ParseOpcode == PARSEOP_NAME)
756 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
758 ForceNewScope = TRUE;
762 /* Push the scope stack */
764 if (ForceNewScope || AcpiNsOpensScope (ObjectType))
766 Status = AcpiDsScopeStackPush (Node, ObjectType, WalkState);
767 if (ACPI_FAILURE (Status))
769 return_ACPI_STATUS (Status);
773 if (Op->Asl.ParseOpcode == PARSEOP_ALIAS)
775 /* Complete the alias node by getting and saving the target node */
777 /* First child is the alias target */
781 /* Get the target pathname */
783 Path = Arg->Asl.Namepath;
786 Status = UtInternalizeName (Arg->Asl.ExternalName, &Path);
787 if (ACPI_FAILURE (Status))
793 /* Get the NS node associated with the target. It must exist. */
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))
800 if (Status == AE_NOT_FOUND)
802 AslError (ASL_ERROR, ASL_MSG_NOT_FOUND, Op,
803 Op->Asl.ExternalName);
806 * The name was not found, go ahead and create it.
807 * This prevents more errors later.
809 Status = AcpiNsLookup (WalkState->ScopeInfo, Path,
811 ACPI_IMODE_LOAD_PASS1, ACPI_NS_NO_UPSEARCH,
816 AslCoreSubsystemError (Op, Status,
817 "Failure from namespace lookup", FALSE);
821 /* Save the target node within the alias node */
823 Node->Object = ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, TargetNode);
830 /*******************************************************************************
832 * FUNCTION: LdCommonNamespaceEnd
834 * PARAMETERS: ASL_WALK_CALLBACK
838 * DESCRIPTION: Ascending callback used during the loading of the namespace,
839 * We only need to worry about managing the scope stack here.
841 ******************************************************************************/
844 LdCommonNamespaceEnd (
845 ACPI_PARSE_OBJECT *Op,
849 ACPI_WALK_STATE *WalkState = (ACPI_WALK_STATE *) Context;
850 ACPI_OBJECT_TYPE ObjectType;
851 BOOLEAN ForceNewScope = FALSE;
854 ACPI_FUNCTION_NAME (LdCommonNamespaceEnd);
857 /* We are only interested in opcodes that have an associated name */
859 if (!Op->Asl.Namepath)
864 /* Get the type to determine if we should pop the scope */
866 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) &&
867 (Op->Asl.CompileFlags == NODE_IS_RESOURCE_DESC))
869 /* TBD: Merge into AcpiDsMapNamedOpcodeToDataType */
871 ObjectType = ACPI_TYPE_LOCAL_RESOURCE;
875 ObjectType = AslMapNamedOpcodeToDataType (Op->Asl.AmlOpcode);
878 /* Pop scope that was pushed for Resource Templates */
880 if (Op->Asl.ParseOpcode == PARSEOP_NAME)
882 if (Op->Asl.CompileFlags & NODE_IS_RESOURCE_DESC)
884 ForceNewScope = TRUE;
888 /* Pop the scope stack */
890 if (ForceNewScope || AcpiNsOpensScope (ObjectType))
892 ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
893 "(%s): Popping scope for Op [%s] %p\n",
894 AcpiUtGetTypeName (ObjectType), Op->Asl.ParseOpName, Op));
896 (void) AcpiDsScopeStackPop (WalkState);