ACPI_STATUS
AcpiPsCompleteThisOp (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op)
{
ACPI_PARSE_OBJECT *Prev;
ACPI_PARSE_OBJECT *Next;
const ACPI_OPCODE_INFO *ParentInfo;
ACPI_PARSE_OBJECT *ReplacementOp = NULL;
ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_TRACE_PTR (PsCompleteThisOp, Op);
/* Check for null Op, can happen if AML code is corrupt */
if (!Op)
{
return_ACPI_STATUS (AE_OK); /* OK for now */
}
AcpiExStopTraceOpcode (Op, WalkState);
/* Delete this op and the subtree below it if asked to */
if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) != ACPI_PARSE_DELETE_TREE) ||
(WalkState->OpInfo->Class == AML_CLASS_ARGUMENT))
{
return_ACPI_STATUS (AE_OK);
}
/* Make sure that we only delete this subtree */
if (Op->Common.Parent)
{
Prev = Op->Common.Parent->Common.Value.Arg;
if (!Prev)
{
/* Nothing more to do */
goto Cleanup;
}
/*
* Check if we need to replace the operator and its subtree
* with a return value op (placeholder op)
*/
ParentInfo = AcpiPsGetOpcodeInfo (Op->Common.Parent->Common.AmlOpcode);
switch (ParentInfo->Class)
{
case AML_CLASS_CONTROL:
break;
case AML_CLASS_CREATE:
/*
* These opcodes contain TermArg operands. The current
* op must be replaced by a placeholder return op
*/
ReplacementOp = AcpiPsAllocOp (
AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
if (!ReplacementOp)
{
Status = AE_NO_MEMORY;
}
break;
case AML_CLASS_NAMED_OBJECT:
/*
* These opcodes contain TermArg operands. The current
* op must be replaced by a placeholder return op
*/
if ((Op->Common.Parent->Common.AmlOpcode == AML_REGION_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_DATA_REGION_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_BUFFER_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_BANK_FIELD_OP) ||
(Op->Common.Parent->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
{
ReplacementOp = AcpiPsAllocOp (
AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
if (!ReplacementOp)
{
Status = AE_NO_MEMORY;
}
}
else if ((Op->Common.Parent->Common.AmlOpcode == AML_NAME_OP) &&
(WalkState->PassNumber <= ACPI_IMODE_LOAD_PASS2))
{
if ((Op->Common.AmlOpcode == AML_BUFFER_OP) ||
(Op->Common.AmlOpcode == AML_PACKAGE_OP) ||
(Op->Common.AmlOpcode == AML_VAR_PACKAGE_OP))
{
ReplacementOp = AcpiPsAllocOp (Op->Common.AmlOpcode,
Op->Common.Aml);
if (!ReplacementOp)
{
Status = AE_NO_MEMORY;
}
else
{
ReplacementOp->Named.Data = Op->Named.Data;
ReplacementOp->Named.Length = Op->Named.Length;
}
}
}
break;
default:
ReplacementOp = AcpiPsAllocOp (
AML_INT_RETURN_VALUE_OP, Op->Common.Aml);
if (!ReplacementOp)
{
Status = AE_NO_MEMORY;
}
}
/* We must unlink this op from the parent tree */
if (Prev == Op)
{
/* This op is the first in the list */
if (ReplacementOp)
{
ReplacementOp->Common.Parent = Op->Common.Parent;
ReplacementOp->Common.Value.Arg = NULL;
ReplacementOp->Common.Node = Op->Common.Node;
Op->Common.Parent->Common.Value.Arg = ReplacementOp;
ReplacementOp->Common.Next = Op->Common.Next;
}
else
{
Op->Common.Parent->Common.Value.Arg = Op->Common.Next;
}
}
/* Search the parent list */
else while (Prev)
{
/* Traverse all siblings in the parent's argument list */
Next = Prev->Common.Next;
if (Next == Op)
{
if (ReplacementOp)
{
ReplacementOp->Common.Parent = Op->Common.Parent;
ReplacementOp->Common.Value.Arg = NULL;
ReplacementOp->Common.Node = Op->Common.Node;
Prev->Common.Next = ReplacementOp;
ReplacementOp->Common.Next = Op->Common.Next;
Next = NULL;
}
else
{
Prev->Common.Next = Op->Common.Next;
Next = NULL;
}
}
Prev = Next;
}
}
Cleanup:
/* Now we can actually delete the subtree rooted at Op */
AcpiPsDeleteParseTree (Op);
return_ACPI_STATUS (Status);
}
static ACPI_STATUS
AcpiDsExecuteArguments (
ACPI_NAMESPACE_NODE *Node,
ACPI_NAMESPACE_NODE *ScopeNode,
UINT32 AmlLength,
UINT8 *AmlStart)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op;
ACPI_WALK_STATE *WalkState;
ACPI_FUNCTION_TRACE (DsExecuteArguments);
/*
* Allocate a new parser op to be the root of the parsed tree
*/
Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Save the Node for use in AcpiPsParseAml */
Op->Common.Node = ScopeNode;
/* Create and initialize a new parser state */
WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
if (!WalkState)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
goto Cleanup;
}
/* Mark this parse as a deferred opcode */
WalkState->ParseFlags = ACPI_PARSE_DEFERRED_OP;
WalkState->DeferredNode = Node;
/* Pass1: Parse the entire declaration */
Status = AcpiPsParseAml (WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/* Get and init the Op created above */
Op->Common.Node = Node;
AcpiPsDeleteParseTree (Op);
/* Evaluate the deferred arguments */
Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Op->Common.Node = ScopeNode;
/* Create and initialize a new parser state */
WalkState = AcpiDsCreateWalkState (0, NULL, NULL, NULL);
if (!WalkState)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/* Execute the opcode and arguments */
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
AmlLength, NULL, ACPI_IMODE_EXECUTE);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
goto Cleanup;
}
/* Mark this execution as a deferred opcode */
WalkState->DeferredNode = Node;
Status = AcpiPsParseAml (WalkState);
Cleanup:
AcpiPsDeleteParseTree (Op);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiDsLoad1BeginOp (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT **OutOp)
{
ACPI_PARSE_OBJECT *Op;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_OBJECT_TYPE ObjectType;
char *Path;
UINT32 Flags;
ACPI_FUNCTION_TRACE (DsLoad1BeginOp);
Op = WalkState->Op;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "Op=%p State=%p\n", Op, WalkState));
/* We are only interested in opcodes that have an associated name */
if (Op)
{
if (!(WalkState->OpInfo->Flags & AML_NAMED))
{
*OutOp = Op;
return_ACPI_STATUS (AE_OK);
}
/* Check if this object has already been installed in the namespace */
if (Op->Common.Node)
{
*OutOp = Op;
return_ACPI_STATUS (AE_OK);
}
}
Path = AcpiPsGetNextNamestring (&WalkState->ParserState);
/* Map the raw opcode into an internal object type */
ObjectType = WalkState->OpInfo->ObjectType;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"State=%p Op=%p [%s]\n", WalkState, Op,
AcpiUtGetTypeName (ObjectType)));
switch (WalkState->Opcode)
{
case AML_SCOPE_OP:
/*
* The target name of the Scope() operator must exist at this point so
* that we can actually open the scope to enter new names underneath it.
* Allow search-to-root for single namesegs.
*/
Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT, WalkState, &(Node));
#ifdef ACPI_ASL_COMPILER
if (Status == AE_NOT_FOUND)
{
/*
* Table disassembly:
* Target of Scope() not found. Generate an External for it, and
* insert the name into the namespace.
*/
AcpiDmAddOpToExternalList (Op, Path, ACPI_TYPE_DEVICE, 0, 0);
Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT,
WalkState, &Node);
}
#endif
if (ACPI_FAILURE (Status))
{
ACPI_ERROR_NAMESPACE (Path, Status);
return_ACPI_STATUS (Status);
}
/*
* Check to make sure that the target is
* one of the opcodes that actually opens a scope
*/
switch (Node->Type)
{
case ACPI_TYPE_ANY:
case ACPI_TYPE_LOCAL_SCOPE: /* Scope */
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_POWER:
case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL:
/* These are acceptable types */
break;
case ACPI_TYPE_INTEGER:
case ACPI_TYPE_STRING:
case ACPI_TYPE_BUFFER:
/*
* These types we will allow, but we will change the type.
* This enables some existing code of the form:
*
* Name (DEB, 0)
* Scope (DEB) { ... }
*
* Note: silently change the type here. On the second pass,
* we will report a warning
*/
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Type override - [%4.4s] had invalid type (%s) "
"for Scope operator, changed to type ANY\n",
AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type)));
Node->Type = ACPI_TYPE_ANY;
WalkState->ScopeInfo->Common.Value = ACPI_TYPE_ANY;
break;
case ACPI_TYPE_METHOD:
/*
* Allow scope change to root during execution of module-level
* code. Root is typed METHOD during this time.
*/
if ((Node == AcpiGbl_RootNode) &&
(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL))
{
break;
}
/*lint -fallthrough */
default:
/* All other types are an error */
ACPI_ERROR ((AE_INFO,
"Invalid type (%s) for target of "
"Scope operator [%4.4s] (Cannot override)",
AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node)));
return_ACPI_STATUS (AE_AML_OPERAND_TYPE);
}
break;
default:
/*
* For all other named opcodes, we will enter the name into
* the namespace.
*
* Setup the search flags.
* Since we are entering a name into the namespace, we do not want to
* enable the search-to-root upsearch.
*
* There are only two conditions where it is acceptable that the name
* already exists:
* 1) the Scope() operator can reopen a scoping object that was
* previously defined (Scope, Method, Device, etc.)
* 2) Whenever we are parsing a deferred opcode (OpRegion, Buffer,
* BufferField, or Package), the name of the object is already
* in the namespace.
*/
if (WalkState->DeferredNode)
{
/* This name is already in the namespace, get the node */
Node = WalkState->DeferredNode;
Status = AE_OK;
break;
}
/*
* If we are executing a method, do not create any namespace objects
* during the load phase, only during execution.
*/
if (WalkState->MethodNode)
{
Node = NULL;
Status = AE_OK;
break;
}
Flags = ACPI_NS_NO_UPSEARCH;
if ((WalkState->Opcode != AML_SCOPE_OP) &&
(!(WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP)))
{
if (WalkState->NamespaceOverride)
{
Flags |= ACPI_NS_OVERRIDE_IF_FOUND;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Override allowed\n",
AcpiUtGetTypeName (ObjectType)));
}
else
{
Flags |= ACPI_NS_ERROR_IF_FOUND;
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH, "[%s] Cannot already exist\n",
AcpiUtGetTypeName (ObjectType)));
}
}
else
{
ACPI_DEBUG_PRINT ((ACPI_DB_DISPATCH,
"[%s] Both Find or Create allowed\n",
AcpiUtGetTypeName (ObjectType)));
}
/*
* Enter the named type into the internal namespace. We enter the name
* as we go downward in the parse tree. Any necessary subobjects that
* involve arguments to the opcode must be created as we go back up the
* parse tree later.
*/
Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ObjectType,
ACPI_IMODE_LOAD_PASS1, Flags, WalkState, &Node);
if (ACPI_FAILURE (Status))
{
if (Status == AE_ALREADY_EXISTS)
{
/* The name already exists in this scope */
if (Node->Flags & ANOBJ_IS_EXTERNAL)
{
/*
* Allow one create on an object or segment that was
* previously declared External
*/
Node->Flags &= ~ANOBJ_IS_EXTERNAL;
Node->Type = (UINT8) ObjectType;
/* Just retyped a node, probably will need to open a scope */
if (AcpiNsOpensScope (ObjectType))
{
Status = AcpiDsScopeStackPush (
Node, ObjectType, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
Status = AE_OK;
}
}
if (ACPI_FAILURE (Status))
{
ACPI_ERROR_NAMESPACE (Path, Status);
return_ACPI_STATUS (Status);
}
}
break;
}
/* Common exit */
if (!Op)
{
/* Create a new op */
Op = AcpiPsAllocOp (WalkState->Opcode, WalkState->Aml);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
/* Initialize the op */
#if (defined (ACPI_NO_METHOD_EXECUTION) || defined (ACPI_CONSTANT_EVAL_ONLY))
Op->Named.Path = ACPI_CAST_PTR (UINT8, Path);
#endif
if (Node)
{
/*
* Put the Node in the "op" object that the parser uses, so we
* can get it again quickly when this scope is closed
*/
Op->Common.Node = Node;
Op->Named.Name = Node->Name.Integer;
}
AcpiPsAppendArg (AcpiPsGetParentScope (&WalkState->ParserState), Op);
*OutOp = Op;
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsCreateOp (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT **NewOp)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *NamedOp = NULL;
ACPI_PARSE_OBJECT *ParentScope;
UINT8 ArgumentCount;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
Status = AcpiPsGetAmlOpcode (WalkState);
if (Status == AE_CTRL_PARSE_CONTINUE)
{
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
/* Create Op structure and append to parent's argument list */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
Op = AcpiPsAllocOp (WalkState->Opcode);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (WalkState->OpInfo->Flags & AML_NAMED)
{
Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
AcpiPsFreeOp (Op);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
*NewOp = NamedOp;
return_ACPI_STATUS (AE_OK);
}
/* Not a named opcode, just allocate Op and append to parent */
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
if (WalkState->Opcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
AcpiPsAppendArg (ParentScope, Op);
if (ParentScope)
{
OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
if (OpInfo->Flags & AML_HAS_TARGET)
{
ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
if (ParentScope->Common.ArgListLength > ArgumentCount)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
else if (ParentScope->Common.AmlOpcode == AML_INCREMENT_OP)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
WalkState->Op = *NewOp = Op;
Status = WalkState->DescendingCallback (WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_CTRL_PARSE_PENDING;
}
}
return_ACPI_STATUS (Status);
}
ACPI_PARSE_OBJECT *
AcpiPsGetNextArg (
ACPI_PARSE_STATE *ParserState,
UINT32 ArgType,
UINT32 *ArgCount)
{
ACPI_PARSE_OBJECT *Arg = NULL;
ACPI_PARSE_OBJECT *Prev = NULL;
ACPI_PARSE_OBJECT *Field;
UINT32 Subop;
FUNCTION_TRACE_PTR ("PsGetNextArg", ParserState);
switch (ArgType)
{
case ARGP_BYTEDATA:
case ARGP_WORDDATA:
case ARGP_DWORDDATA:
case ARGP_CHARLIST:
case ARGP_NAME:
case ARGP_NAMESTRING:
/* constants, strings, and namestrings are all the same size */
Arg = AcpiPsAllocOp (AML_BYTE_OP);
if (Arg)
{
AcpiPsGetNextSimpleArg (ParserState, ArgType, Arg);
}
break;
case ARGP_PKGLENGTH:
/* package length, nothing returned */
ParserState->PkgEnd = AcpiPsGetNextPackageEnd (ParserState);
break;
case ARGP_FIELDLIST:
if (ParserState->Aml < ParserState->PkgEnd)
{
/* non-empty list */
while (ParserState->Aml < ParserState->PkgEnd)
{
Field = AcpiPsGetNextField (ParserState);
if (!Field)
{
break;
}
if (Prev)
{
Prev->Next = Field;
}
else
{
Arg = Field;
}
Prev = Field;
}
/* skip to End of byte data */
ParserState->Aml = ParserState->PkgEnd;
}
break;
case ARGP_BYTELIST:
if (ParserState->Aml < ParserState->PkgEnd)
{
/* non-empty list */
Arg = AcpiPsAllocOp (AML_INT_BYTELIST_OP);
if (Arg)
{
/* fill in bytelist data */
Arg->Value.Size = (ParserState->PkgEnd - ParserState->Aml);
((ACPI_PARSE2_OBJECT *) Arg)->Data = ParserState->Aml;
}
/* skip to End of byte data */
ParserState->Aml = ParserState->PkgEnd;
}
break;
case ARGP_TARGET:
case ARGP_SUPERNAME:
{
Subop = AcpiPsPeekOpcode (ParserState);
if (Subop == 0 ||
AcpiPsIsLeadingChar (Subop) ||
AcpiPsIsPrefixChar (Subop))
{
/* NullName or NameString */
Arg = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
if (Arg)
{
AcpiPsGetNextNamepath (ParserState, Arg, ArgCount, 0);
}
}
else
{
/* single complex argument, nothing returned */
*ArgCount = 1;
}
}
break;
case ARGP_DATAOBJ:
case ARGP_TERMARG:
/* single complex argument, nothing returned */
*ArgCount = 1;
break;
case ARGP_DATAOBJLIST:
case ARGP_TERMLIST:
case ARGP_OBJLIST:
if (ParserState->Aml < ParserState->PkgEnd)
{
/* non-empty list of variable arguments, nothing returned */
*ArgCount = ACPI_VAR_ARGS;
}
break;
}
return_PTR (Arg);
}
ACPI_STATUS
AcpiDsAutoSerializeMethod (
ACPI_NAMESPACE_NODE *Node,
ACPI_OPERAND_OBJECT *ObjDesc)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op = NULL;
ACPI_WALK_STATE *WalkState;
ACPI_FUNCTION_TRACE_PTR (DsAutoSerializeMethod, Node);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Method auto-serialization parse [%4.4s] %p\n",
AcpiUtGetNodeName (Node), Node));
AcpiExEnterInterpreter ();
/* Create/Init a root op for the method parse tree */
Op = AcpiPsAllocOp (AML_METHOD_OP, ObjDesc->Method.AmlStart);
if (!Op)
{
Status = AE_NO_MEMORY;
goto Unlock;
}
AcpiPsSetName (Op, Node->Name.Integer);
Op->Common.Node = Node;
/* Create and initialize a new walk state */
WalkState = AcpiDsCreateWalkState (Node->OwnerId, NULL, NULL, NULL);
if (!WalkState)
{
AcpiPsFreeOp (Op);
Status = AE_NO_MEMORY;
goto Unlock;
}
Status = AcpiDsInitAmlWalk (WalkState, Op, Node,
ObjDesc->Method.AmlStart, ObjDesc->Method.AmlLength, NULL, 0);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
AcpiPsFreeOp (Op);
return_ACPI_STATUS (Status);
}
WalkState->DescendingCallback = AcpiDsDetectNamedOpcodes;
/* Parse the method, scan for creation of named objects */
Status = AcpiPsParseAml (WalkState);
AcpiPsDeleteParseTree (Op);
Unlock:
AcpiExExitInterpreter ();
return_ACPI_STATUS (Status);
}
void
AcpiPsGetNextNamepath (
ACPI_PARSE_STATE *ParserState,
ACPI_PARSE_OBJECT *Arg,
UINT32 *ArgCount,
BOOLEAN MethodCall)
{
NATIVE_CHAR *Path;
ACPI_PARSE_OBJECT *NameOp;
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *MethodNode = NULL;
ACPI_NAMESPACE_NODE *Node;
ACPI_GENERIC_STATE ScopeInfo;
FUNCTION_TRACE ("PsGetNextNamepath");
Path = AcpiPsGetNextNamestring (ParserState);
if (!Path || !MethodCall)
{
/* Null name case, create a null namepath object */
AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
Arg->Value.Name = Path;
return_VOID;
}
if (MethodCall)
{
/*
* Lookup the name in the internal namespace
*/
ScopeInfo.Scope.Node = NULL;
Node = ParserState->StartNode;
if (Node)
{
ScopeInfo.Scope.Node = Node;
}
/*
* Lookup object. We don't want to add anything new to the namespace
* here, however. So we use MODE_EXECUTE. Allow searching of the
* parent tree, but don't open a new scope -- we just want to lookup the
* object (MUST BE mode EXECUTE to perform upsearch)
*/
Status = AcpiNsLookup (&ScopeInfo, Path, ACPI_TYPE_ANY, IMODE_EXECUTE,
NS_SEARCH_PARENT | NS_DONT_OPEN_SCOPE, NULL,
&Node);
if (ACPI_SUCCESS (Status))
{
if (Node->Type == ACPI_TYPE_METHOD)
{
MethodNode = Node;
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "method - %p Path=%p\n",
MethodNode, Path));
NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
if (NameOp)
{
/* Change arg into a METHOD CALL and attach name to it */
AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
NameOp->Value.Name = Path;
/* Point METHODCALL/NAME to the METHOD Node */
NameOp->Node = MethodNode;
AcpiPsAppendArg (Arg, NameOp);
if (!(ACPI_OPERAND_OBJECT *) MethodNode->Object)
{
return_VOID;
}
*ArgCount = ((ACPI_OPERAND_OBJECT *) MethodNode->Object)->Method.ParamCount;
}
return_VOID;
}
/*
* Else this is normal named object reference.
* Just init the NAMEPATH object with the pathname.
* (See code below)
*/
}
}
/*
* Either we didn't find the object in the namespace, or the object is
* something other than a control method. Just initialize the Op with the
* pathname.
*/
AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
Arg->Value.Name = Path;
return_VOID;
}
ACPI_PARSE_OBJECT *
AcpiPsGetNextField (
ACPI_PARSE_STATE *ParserState)
{
UINT32 AmlOffset = ParserState->Aml -
ParserState->AmlStart;
ACPI_PARSE_OBJECT *Field;
UINT16 Opcode;
UINT32 Name;
FUNCTION_TRACE ("PsGetNextField");
/* determine field type */
switch (GET8 (ParserState->Aml))
{
default:
Opcode = AML_INT_NAMEDFIELD_OP;
break;
case 0x00:
Opcode = AML_INT_RESERVEDFIELD_OP;
ParserState->Aml++;
break;
case 0x01:
Opcode = AML_INT_ACCESSFIELD_OP;
ParserState->Aml++;
break;
}
/* Allocate a new field op */
Field = AcpiPsAllocOp (Opcode);
if (Field)
{
Field->AmlOffset = AmlOffset;
/* Decode the field type */
switch (Opcode)
{
case AML_INT_NAMEDFIELD_OP:
/* Get the 4-character name */
MOVE_UNALIGNED32_TO_32 (&Name, ParserState->Aml);
AcpiPsSetName (Field, Name);
ParserState->Aml += 4;
/* Get the length which is encoded as a package length */
Field->Value.Size = AcpiPsGetNextPackageLength (ParserState);
break;
case AML_INT_RESERVEDFIELD_OP:
/* Get the length which is encoded as a package length */
Field->Value.Size = AcpiPsGetNextPackageLength (ParserState);
break;
case AML_INT_ACCESSFIELD_OP:
/* Get AccessType and AccessAtrib and merge into the field Op */
Field->Value.Integer = ((GET8 (ParserState->Aml) << 8) |
GET8 (ParserState->Aml));
ParserState->Aml += 2;
break;
}
}
return_PTR (Field);
}
void
AcpiPsGetNextNamepath (
ACPI_PARSE_STATE *ParserState,
ACPI_PARSE_OBJECT *Arg,
UINT32 *ArgCount,
BOOLEAN MethodCall)
{
NATIVE_CHAR *Path;
ACPI_PARSE_OBJECT *NameOp;
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *Count;
FUNCTION_TRACE ("PsGetNextNamepath");
Path = AcpiPsGetNextNamestring (ParserState);
if (!Path || !MethodCall)
{
/* Null name case, create a null namepath object */
AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
Arg->Value.Name = Path;
return_VOID;
}
if (AcpiGbl_ParsedNamespaceRoot)
{
/*
* Lookup the name in the parsed namespace
*/
Op = NULL;
if (MethodCall)
{
Op = AcpiPsFind (AcpiPsGetParentScope (ParserState),
Path, AML_METHOD_OP, 0);
}
if (Op)
{
if (Op->Opcode == AML_METHOD_OP)
{
/*
* The name refers to a control method, so this namepath is a
* method invocation. We need to 1) Get the number of arguments
* associated with this method, and 2) Change the NAMEPATH
* object into a METHODCALL object.
*/
Count = AcpiPsGetArg (Op, 0);
if (Count && Count->Opcode == AML_BYTE_OP)
{
NameOp = AcpiPsAllocOp (AML_INT_NAMEPATH_OP);
if (NameOp)
{
/* Change arg into a METHOD CALL and attach the name */
AcpiPsInitOp (Arg, AML_INT_METHODCALL_OP);
NameOp->Value.Name = Path;
/* Point METHODCALL/NAME to the METHOD Node */
NameOp->Node = (ACPI_NAMESPACE_NODE *) Op;
AcpiPsAppendArg (Arg, NameOp);
*ArgCount = (UINT32) Count->Value.Integer &
METHOD_FLAGS_ARG_COUNT;
}
}
return_VOID;
}
/*
* Else this is normal named object reference.
* Just init the NAMEPATH object with the pathname.
* (See code below)
*/
}
}
/*
* Either we didn't find the object in the namespace, or the object is
* something other than a control method. Just initialize the Op with the
* pathname
*/
AcpiPsInitOp (Arg, AML_INT_NAMEPATH_OP);
Arg->Value.Name = Path;
return_VOID;
}
ACPI_STATUS
AcpiPsParseLoop (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op = NULL; /* current op */
const ACPI_OPCODE_INFO *OpInfo;
ACPI_PARSE_OBJECT *Arg = NULL;
ACPI_PARSE2_OBJECT *DeferredOp;
UINT32 ArgCount; /* push for fixed or var args */
UINT32 ArgTypes = 0;
UINT32 AmlOffset;
UINT16 Opcode;
ACPI_PARSE_OBJECT PreOp;
ACPI_PARSE_STATE *ParserState;
UINT8 *AmlOpStart;
FUNCTION_TRACE_PTR ("PsParseLoop", WalkState);
ParserState = WalkState->ParserState;
#ifndef PARSER_ONLY
if (WalkState->WalkType & WALK_METHOD_RESTART)
{
/* We are restarting a preempted control method */
if (AcpiPsHasCompletedScope (ParserState))
{
/*
* We must check if a predicate to an IF or WHILE statement
* was just completed
*/
if ((ParserState->Scope->ParseScope.Op) &&
((ParserState->Scope->ParseScope.Op->Opcode == AML_IF_OP) ||
(ParserState->Scope->ParseScope.Op->Opcode == AML_WHILE_OP)) &&
(WalkState->ControlState) &&
(WalkState->ControlState->Common.State ==
CONTROL_PREDICATE_EXECUTING))
{
/*
* A predicate was just completed, get the value of the
* predicate and branch based on that value
*/
Status = AcpiDsGetPredicateValue (WalkState, NULL, TRUE);
if (ACPI_FAILURE (Status) &&
((Status & AE_CODE_MASK) != AE_CODE_CONTROL))
{
if (Status == AE_AML_NO_RETURN_VALUE)
{
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Invoked method did not return a value, %s\n",
AcpiFormatException (Status)));
}
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR, "GetPredicate Failed, %s\n",
AcpiFormatException (Status)));
return_ACPI_STATUS (Status);
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else if (WalkState->PrevOp)
{
/* We were in the middle of an op */
Op = WalkState->PrevOp;
ArgTypes = WalkState->PrevArgTypes;
}
}
#endif
/*
* Iterative parsing loop, while there is more aml to process:
*/
while ((ParserState->Aml < ParserState->AmlEnd) || (Op))
{
if (!Op)
{
/* Get the next opcode from the AML stream */
AmlOpStart = ParserState->Aml;
AmlOffset = ParserState->Aml - ParserState->AmlStart;
Opcode = AcpiPsPeekOpcode (ParserState);
/*
* First cut to determine what we have found:
* 1) A valid AML opcode
* 2) A name string
* 3) An unknown/invalid opcode
*/
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
switch (ACPI_GET_OP_TYPE (OpInfo))
{
case ACPI_OP_TYPE_OPCODE:
/* Found opcode info, this is a normal opcode */
ParserState->Aml += AcpiPsGetOpcodeSize (Opcode);
ArgTypes = OpInfo->ParseArgs;
break;
case ACPI_OP_TYPE_ASCII:
case ACPI_OP_TYPE_PREFIX:
/*
* Starts with a valid prefix or ASCII char, this is a name
* string. Convert the bare name string to a namepath.
*/
Opcode = AML_INT_NAMEPATH_OP;
ArgTypes = ARGP_NAMESTRING;
break;
case ACPI_OP_TYPE_UNKNOWN:
/* The opcode is unrecognized. Just skip unknown opcodes */
ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
"Found unknown opcode %lX at AML offset %X, ignoring\n",
Opcode, AmlOffset));
DUMP_BUFFER (ParserState->Aml, 128);
/* Assume one-byte bad opcode */
ParserState->Aml++;
continue;
}
/* Create Op structure and append to parent's argument list */
if (OpInfo->Flags & AML_NAMED)
{
PreOp.Value.Arg = NULL;
PreOp.Opcode = Opcode;
while (GET_CURRENT_ARG_TYPE (ArgTypes) != ARGP_NAME)
{
Arg = AcpiPsGetNextArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes),
&ArgCount);
AcpiPsAppendArg (&PreOp, Arg);
INCREMENT_ARG_LIST (ArgTypes);
}
/* We know that this arg is a name, move to next arg */
INCREMENT_ARG_LIST (ArgTypes);
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
Status = WalkState->DescendingCallback (Opcode, NULL, WalkState, &Op);
if (Op == NULL)
{
continue;
}
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (ACPI_FAILURE (Status))
{
goto CloseThisOp;
}
}
AcpiPsAppendArg (Op, PreOp.Value.Arg);
AcpiGbl_Depth++;
if (Op->Opcode == AML_REGION_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Defer final parsing of an OperationRegion body,
* because we don't have enough info in the first pass
* to parse it correctly (i.e., there may be method
* calls within the TermArg elements of the body.
*
* However, we must continue parsing because
* the opregion is not a standalone package --
* we don't know where the end is at this point.
*
* (Length is unknown until parse of the body complete)
*/
DeferredOp->Data = AmlOpStart;
DeferredOp->Length = 0;
}
}
else
{
/* Not a named opcode, just allocate Op and append to parent */
OpInfo = AcpiPsGetOpcodeInfo (Opcode);
Op = AcpiPsAllocOp (Opcode);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
DeferredOp->Data = AmlOpStart;
DeferredOp->Length = 0;
}
AcpiPsAppendArg (AcpiPsGetParentScope (ParserState), Op);
if ((WalkState->DescendingCallback != NULL))
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
Status = WalkState->DescendingCallback (Opcode, Op, WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (ACPI_FAILURE (Status))
{
goto CloseThisOp;
}
}
}
Op->AmlOffset = AmlOffset;
if (OpInfo)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Op=%p Opcode=%4.4lX Aml %p Oft=%5.5lX\n",
Op, Op->Opcode, ParserState->Aml, Op->AmlOffset));
}
}
/* Start ArgCount at zero because we don't know if there are any args yet */
ArgCount = 0;
if (ArgTypes) /* Are there any arguments that must be processed? */
{
/* get arguments */
switch (Op->Opcode)
{
case AML_BYTE_OP: /* AML_BYTEDATA_ARG */
case AML_WORD_OP: /* AML_WORDDATA_ARG */
case AML_DWORD_OP: /* AML_DWORDATA_ARG */
case AML_QWORD_OP: /* AML_QWORDATA_ARG */
case AML_STRING_OP: /* AML_ASCIICHARLIST_ARG */
/* fill in constant or string argument directly */
AcpiPsGetNextSimpleArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes), Op);
break;
case AML_INT_NAMEPATH_OP: /* AML_NAMESTRING_ARG */
AcpiPsGetNextNamepath (ParserState, Op, &ArgCount, 1);
ArgTypes = 0;
break;
default:
/* Op is not a constant or string, append each argument */
while (GET_CURRENT_ARG_TYPE (ArgTypes) && !ArgCount)
{
AmlOffset = ParserState->Aml - ParserState->AmlStart;
Arg = AcpiPsGetNextArg (ParserState,
GET_CURRENT_ARG_TYPE (ArgTypes),
&ArgCount);
if (Arg)
{
Arg->AmlOffset = AmlOffset;
AcpiPsAppendArg (Op, Arg);
}
INCREMENT_ARG_LIST (ArgTypes);
}
/* For a method, save the length and address of the body */
if (Op->Opcode == AML_METHOD_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*/
DeferredOp->Data = ParserState->Aml;
DeferredOp->Length = (UINT32) (ParserState->PkgEnd -
ParserState->Aml);
/*
* Skip body of method. For OpRegions, we must continue
* parsing because the opregion is not a standalone
* package (We don't know where the end is).
*/
ParserState->Aml = ParserState->PkgEnd;
ArgCount = 0;
}
break;
}
}
/*
* Zero ArgCount means that all arguments for this op have been processed
*/
if (!ArgCount)
{
/* completed Op, prepare for next */
OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
if (OpInfo->Flags & AML_NAMED)
{
if (AcpiGbl_Depth)
{
AcpiGbl_Depth--;
}
if (Op->Opcode == AML_REGION_OP)
{
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
/*
* Skip parsing of control method or opregion body,
* because we don't have enough info in the first pass
* to parse them correctly.
*
* Completed parsing an OpRegion declaration, we now
* know the length.
*/
DeferredOp->Length = (UINT32) (ParserState->Aml -
DeferredOp->Data);
}
}
if (OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration (1 for
* Opcode)
*
* BodyLength is unknown until we parse the body
*/
DeferredOp = (ACPI_PARSE2_OBJECT *) Op;
DeferredOp->Length = (UINT32) (ParserState->Aml -
DeferredOp->Data);
}
/* This op complete, notify the dispatcher */
if (WalkState->AscendingCallback != NULL)
{
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
}
CloseThisOp:
/*
* Finished one argument of the containing scope
*/
ParserState->Scope->ParseScope.ArgCount--;
/* Close this Op (may result in parse subtree deletion) */
if (AcpiPsCompleteThisOp (WalkState, Op))
{
Op = NULL;
}
switch (Status)
{
case AE_OK:
break;
case AE_CTRL_TRANSFER:
/*
* We are about to transfer to a called method.
*/
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = ArgTypes;
return_ACPI_STATUS (Status);
break;
case AE_CTRL_END:
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
AcpiPsCompleteThisOp (WalkState, Op);
Op = NULL;
Status = AE_OK;
break;
case AE_CTRL_TERMINATE:
Status = AE_OK;
/* Clean up */
do
{
if (Op)
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
break;
default: /* All other non-AE_OK status */
if (Op == NULL)
{
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
}
WalkState->PrevOp = Op;
WalkState->PrevArgTypes = ArgTypes;
/*
* TEMP:
*/
return_ACPI_STATUS (Status);
break;
}
/* This scope complete? */
if (AcpiPsHasCompletedScope (ParserState))
{
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Popped scope, Op=%p\n", Op));
}
else
{
Op = NULL;
}
}
/* ArgCount is non-zero */
else
{
/* complex argument, push Op and prepare for argument */
AcpiPsPushScope (ParserState, Op, ArgTypes, ArgCount);
Op = NULL;
}
} /* while ParserState->Aml */
/*
* Complete the last Op (if not completed), and clear the scope stack.
* It is easily possible to end an AML "package" with an unbounded number
* of open scopes (such as when several AML blocks are closed with
* sequential closing braces). We want to terminate each one cleanly.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Package complete at Op %p\n", Op));
do
{
if (Op)
{
if (WalkState->AscendingCallback != NULL)
{
Status = WalkState->AscendingCallback (WalkState, Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_OK;
goto CloseThisOp;
}
if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
/* Clean up */
do
{
if (Op)
{
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
else if (ACPI_FAILURE (Status))
{
AcpiPsCompleteThisOp (WalkState, Op);
return_ACPI_STATUS (Status);
}
}
AcpiPsCompleteThisOp (WalkState, Op);
}
AcpiPsPopScope (ParserState, &Op, &ArgTypes, &ArgCount);
} while (Op);
return_ACPI_STATUS (Status);
}
static BOOLEAN
AcpiPsCompleteThisOp (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op)
{
#ifndef PARSER_ONLY
ACPI_PARSE_OBJECT *Prev;
ACPI_PARSE_OBJECT *Next;
const ACPI_OPCODE_INFO *OpInfo;
const ACPI_OPCODE_INFO *ParentInfo;
UINT32 OpcodeClass;
ACPI_PARSE_OBJECT *ReplacementOp = NULL;
FUNCTION_TRACE_PTR ("PsCompleteThisOp", Op);
OpInfo = AcpiPsGetOpcodeInfo (Op->Opcode);
OpcodeClass = ACPI_GET_OP_CLASS (OpInfo);
/* Delete this op and the subtree below it if asked to */
if (((WalkState->ParseFlags & ACPI_PARSE_TREE_MASK) == ACPI_PARSE_DELETE_TREE) &&
(OpcodeClass != OPTYPE_CONSTANT) &&
(OpcodeClass != OPTYPE_LITERAL) &&
(OpcodeClass != OPTYPE_LOCAL_VARIABLE) &&
(OpcodeClass != OPTYPE_METHOD_ARGUMENT) &&
(OpcodeClass != OPTYPE_DATA_TERM) &&
(Op->Opcode != AML_INT_NAMEPATH_OP))
{
/* Make sure that we only delete this subtree */
if (Op->Parent)
{
/*
* Check if we need to replace the operator and its subtree
* with a return value op (placeholder op)
*/
ParentInfo = AcpiPsGetOpcodeInfo (Op->Parent->Opcode);
switch (ACPI_GET_OP_CLASS (ParentInfo))
{
case OPTYPE_CONTROL: /* IF, ELSE, WHILE only */
break;
case OPTYPE_NAMED_OBJECT: /* Scope, method, etc. */
/*
* These opcodes contain TermArg operands. The current
* op must be replace by a placeholder return op
*/
if ((Op->Parent->Opcode == AML_REGION_OP) ||
(Op->Parent->Opcode == AML_CREATE_FIELD_OP) ||
(Op->Parent->Opcode == AML_CREATE_BIT_FIELD_OP) ||
(Op->Parent->Opcode == AML_CREATE_BYTE_FIELD_OP) ||
(Op->Parent->Opcode == AML_CREATE_WORD_FIELD_OP) ||
(Op->Parent->Opcode == AML_CREATE_DWORD_FIELD_OP) ||
(Op->Parent->Opcode == AML_CREATE_QWORD_FIELD_OP))
{
ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP);
if (!ReplacementOp)
{
return_VALUE (FALSE);
}
}
break;
default:
ReplacementOp = AcpiPsAllocOp (AML_INT_RETURN_VALUE_OP);
if (!ReplacementOp)
{
return_VALUE (FALSE);
}
}
/* We must unlink this op from the parent tree */
Prev = Op->Parent->Value.Arg;
if (Prev == Op)
{
/* This op is the first in the list */
if (ReplacementOp)
{
ReplacementOp->Parent = Op->Parent;
ReplacementOp->Value.Arg = NULL;
Op->Parent->Value.Arg = ReplacementOp;
ReplacementOp->Next = Op->Next;
}
else
{
Op->Parent->Value.Arg = Op->Next;
}
}
/* Search the parent list */
else while (Prev)
{
/* Traverse all siblings in the parent's argument list */
Next = Prev->Next;
if (Next == Op)
{
if (ReplacementOp)
{
ReplacementOp->Parent = Op->Parent;
ReplacementOp->Value.Arg = NULL;
Prev->Next = ReplacementOp;
ReplacementOp->Next = Op->Next;
Next = NULL;
}
else
{
Prev->Next = Op->Next;
Next = NULL;
}
}
Prev = Next;
}
}
/* Now we can actually delete the subtree rooted at op */
AcpiPsDeleteParseTree (Op);
return_VALUE (TRUE);
}
return_VALUE (FALSE);
#else
return (FALSE);
#endif
}
ACPI_STATUS
AcpiDsExecuteArguments (
ACPI_NAMESPACE_NODE *Node,
ACPI_NAMESPACE_NODE *ScopeNode,
UINT32 AmlLength,
UINT8 *AmlStart)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op;
ACPI_WALK_STATE *WalkState;
ACPI_PARSE_OBJECT *Arg;
ACPI_FUNCTION_TRACE ("AcpiDsExecuteArguments");
/*
* Allocate a new parser op to be the root of the parsed tree
*/
Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
/* Save the Node for use in AcpiPsParseAml */
Op->Common.Node = ScopeNode;
/* Create and initialize a new parser state */
WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, NULL, NULL, NULL);
if (!WalkState)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
AmlLength, NULL, NULL, 1);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
return_ACPI_STATUS (Status);
}
WalkState->ParseFlags = ACPI_PARSE_DEFERRED_OP;
/* Pass1: Parse the entire declaration */
Status = AcpiPsParseAml (WalkState);
if (ACPI_FAILURE (Status))
{
AcpiPsDeleteParseTree (Op);
return_ACPI_STATUS (Status);
}
/* Get and init the Op created above */
Arg = Op->Common.Value.Arg;
Op->Common.Node = Node;
Arg->Common.Node = Node;
AcpiPsDeleteParseTree (Op);
/* Evaluate the address and length arguments for the Buffer Field */
Op = AcpiPsAllocOp (AML_INT_EVAL_SUBTREE_OP);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Op->Common.Node = ScopeNode;
/* Create and initialize a new parser state */
WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, NULL, NULL, NULL);
if (!WalkState)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL, AmlStart,
AmlLength, NULL, NULL, 3);
if (ACPI_FAILURE (Status))
{
AcpiDsDeleteWalkState (WalkState);
return_ACPI_STATUS (Status);
}
Status = AcpiPsParseAml (WalkState);
AcpiPsDeleteParseTree (Op);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsCreateOp (
ACPI_WALK_STATE *WalkState,
UINT8 *AmlOpStart,
ACPI_PARSE_OBJECT **NewOp)
{
ACPI_STATUS Status = AE_OK;
ACPI_PARSE_OBJECT *Op;
ACPI_PARSE_OBJECT *NamedOp = NULL;
ACPI_PARSE_OBJECT *ParentScope;
UINT8 ArgumentCount;
const ACPI_OPCODE_INFO *OpInfo;
ACPI_FUNCTION_TRACE_PTR (PsCreateOp, WalkState);
Status = AcpiPsGetAmlOpcode (WalkState);
if (Status == AE_CTRL_PARSE_CONTINUE)
{
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Create Op structure and append to parent's argument list */
WalkState->OpInfo = AcpiPsGetOpcodeInfo (WalkState->Opcode);
Op = AcpiPsAllocOp (WalkState->Opcode, AmlOpStart);
if (!Op)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
if (WalkState->OpInfo->Flags & AML_NAMED)
{
Status = AcpiPsBuildNamedOp (WalkState, AmlOpStart, Op, &NamedOp);
AcpiPsFreeOp (Op);
#ifdef ACPI_ASL_COMPILER
if (AcpiGbl_DisasmFlag && WalkState->Opcode == AML_EXTERNAL_OP &&
Status == AE_NOT_FOUND)
{
/*
* If parsing of AML_EXTERNAL_OP's name path fails, then skip
* past this opcode and keep parsing. This is a much better
* alternative than to abort the entire disassembler. At this
* point, the ParserState is at the end of the namepath of the
* external declaration opcode. Setting WalkState->Aml to
* WalkState->ParserState.Aml + 2 moves increments the
* WalkState->Aml past the object type and the paramcount of the
* external opcode.
*/
WalkState->Aml = WalkState->ParserState.Aml + 2;
WalkState->ParserState.Aml = WalkState->Aml;
return_ACPI_STATUS (AE_CTRL_PARSE_CONTINUE);
}
#endif
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
*NewOp = NamedOp;
return_ACPI_STATUS (AE_OK);
}
/* Not a named opcode, just allocate Op and append to parent */
if (WalkState->OpInfo->Flags & AML_CREATE)
{
/*
* Backup to beginning of CreateXXXfield declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
if (WalkState->Opcode == AML_BANK_FIELD_OP)
{
/*
* Backup to beginning of BankField declaration
* BodyLength is unknown until we parse the body
*/
Op->Named.Data = AmlOpStart;
Op->Named.Length = 0;
}
ParentScope = AcpiPsGetParentScope (&(WalkState->ParserState));
AcpiPsAppendArg (ParentScope, Op);
if (ParentScope)
{
OpInfo = AcpiPsGetOpcodeInfo (ParentScope->Common.AmlOpcode);
if (OpInfo->Flags & AML_HAS_TARGET)
{
ArgumentCount = AcpiPsGetArgumentCount (OpInfo->Type);
if (ParentScope->Common.ArgListLength > ArgumentCount)
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
/*
* Special case for both Increment() and Decrement(), where
* the lone argument is both a source and a target.
*/
else if ((ParentScope->Common.AmlOpcode == AML_INCREMENT_OP) ||
(ParentScope->Common.AmlOpcode == AML_DECREMENT_OP))
{
Op->Common.Flags |= ACPI_PARSEOP_TARGET;
}
}
if (WalkState->DescendingCallback != NULL)
{
/*
* Find the object. This will either insert the object into
* the namespace or simply look it up
*/
WalkState->Op = *NewOp = Op;
Status = WalkState->DescendingCallback (WalkState, &Op);
Status = AcpiPsNextParseState (WalkState, Op, Status);
if (Status == AE_CTRL_PENDING)
{
Status = AE_CTRL_PARSE_PENDING;
}
}
return_ACPI_STATUS (Status);
}
