ACPI_STATUS
AcpiDsInitAmlWalk (
ACPI_WALK_STATE *WalkState,
ACPI_PARSE_OBJECT *Op,
ACPI_NAMESPACE_NODE *MethodNode,
UINT8 *AmlStart,
UINT32 AmlLength,
ACPI_EVALUATE_INFO *Info,
UINT8 PassNumber)
{
ACPI_STATUS Status;
ACPI_PARSE_STATE *ParserState = &WalkState->ParserState;
ACPI_PARSE_OBJECT *ExtraOp;
ACPI_FUNCTION_TRACE (DsInitAmlWalk);
WalkState->ParserState.Aml =
WalkState->ParserState.AmlStart = AmlStart;
WalkState->ParserState.AmlEnd =
WalkState->ParserState.PkgEnd = AmlStart + AmlLength;
/* The NextOp of the NextWalk will be the beginning of the method */
WalkState->NextOp = NULL;
WalkState->PassNumber = PassNumber;
if (Info)
{
WalkState->Params = Info->Parameters;
WalkState->CallerReturnDesc = &Info->ReturnObject;
}
Status = AcpiPsInitScope (&WalkState->ParserState, Op);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
if (MethodNode)
{
WalkState->ParserState.StartNode = MethodNode;
WalkState->WalkType = ACPI_WALK_METHOD;
WalkState->MethodNode = MethodNode;
WalkState->MethodDesc = AcpiNsGetAttachedObject (MethodNode);
/* Push start scope on scope stack and make it current */
Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Init the method arguments */
Status = AcpiDsMethodDataInitArgs (WalkState->Params,
ACPI_METHOD_NUM_ARGS, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
else
{
/*
* Setup the current scope.
* Find a Named Op that has a namespace node associated with it.
* search upwards from this Op. Current scope is the first
* Op with a namespace node.
*/
ExtraOp = ParserState->StartOp;
while (ExtraOp && !ExtraOp->Common.Node)
{
ExtraOp = ExtraOp->Common.Parent;
}
if (!ExtraOp)
{
ParserState->StartNode = NULL;
}
else
{
ParserState->StartNode = ExtraOp->Common.Node;
}
if (ParserState->StartNode)
{
/* Push start scope on scope stack and make it current */
Status = AcpiDsScopeStackPush (ParserState->StartNode,
ParserState->StartNode->Type, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
}
Status = AcpiDsInitCallbacks (WalkState, PassNumber);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiPsParseAml (
ACPI_PARSE_OBJECT *StartScope,
UINT8 *Aml,
UINT32 AmlSize,
UINT32 ParseFlags,
ACPI_NAMESPACE_NODE *MethodNode,
ACPI_OPERAND_OBJECT **Params,
ACPI_OPERAND_OBJECT **CallerReturnDesc,
ACPI_PARSE_DOWNWARDS DescendingCallback,
ACPI_PARSE_UPWARDS AscendingCallback)
{
ACPI_STATUS Status;
ACPI_PARSE_STATE *ParserState;
ACPI_WALK_STATE *WalkState;
ACPI_WALK_LIST WalkList;
ACPI_WALK_LIST *PrevWalkList = AcpiGbl_CurrentWalkList;
ACPI_OPERAND_OBJECT *ReturnDesc;
ACPI_OPERAND_OBJECT *MthDesc = NULL;
FUNCTION_TRACE ("PsParseAml");
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Entered with Scope=%p Aml=%p size=%lX\n",
StartScope, Aml, AmlSize));
/* Create and initialize a new parser state */
ParserState = AcpiPsCreateState (Aml, AmlSize);
if (!ParserState)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
AcpiPsInitScope (ParserState, StartScope);
if (MethodNode)
{
MthDesc = AcpiNsGetAttachedObject (MethodNode);
}
/* Create and initialize a new walk list */
WalkList.WalkState = NULL;
WalkList.AcquiredMutexList.Prev = NULL;
WalkList.AcquiredMutexList.Next = NULL;
WalkState = AcpiDsCreateWalkState (TABLE_ID_DSDT, ParserState->StartOp,
MthDesc, &WalkList);
if (!WalkState)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
WalkState->MethodNode = MethodNode;
WalkState->ParserState = ParserState;
WalkState->ParseFlags = ParseFlags;
WalkState->DescendingCallback = DescendingCallback;
WalkState->AscendingCallback = AscendingCallback;
/* TBD: [Restructure] TEMP until we pass WalkState to the interpreter
*/
AcpiGbl_CurrentWalkList = &WalkList;
if (MethodNode)
{
ParserState->StartNode = MethodNode;
WalkState->WalkType = WALK_METHOD;
/* Push start scope on scope stack and make it current */
Status = AcpiDsScopeStackPush (MethodNode, ACPI_TYPE_METHOD, WalkState);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Init arguments if this is a control method */
/* TBD: [Restructure] add walkstate as a param */
AcpiDsMethodDataInitArgs (Params, MTH_NUM_ARGS, WalkState);
}
else
{
/* Setup the current scope */
ParserState->StartNode = ParserState->StartOp->Node;
if (ParserState->StartNode)
{
/* Push start scope on scope stack and make it current */
Status = AcpiDsScopeStackPush (ParserState->StartNode,
ParserState->StartNode->Type, WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
}
}
/*
* Execute the walk loop as long as there is a valid Walk State. This
* handles nested control method invocations without recursion.
*/
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "State=%p\n", WalkState));
Status = AE_OK;
while (WalkState)
{
if (ACPI_SUCCESS (Status))
{
Status = AcpiPsParseLoop (WalkState);
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Completed one call to walk loop, State=%p\n", WalkState));
if (Status == AE_CTRL_TRANSFER)
{
/*
* A method call was detected.
* Transfer control to the called control method
*/
Status = AcpiDsCallControlMethod (&WalkList, WalkState, NULL);
/*
* If the transfer to the new method method call worked, a new walk
* state was created -- get it
*/
WalkState = AcpiDsGetCurrentWalkState (&WalkList);
continue;
}
else if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
}
/* We are done with this walk, move on to the parent if any */
WalkState = AcpiDsPopWalkState (&WalkList);
/* Extract return value before we delete WalkState */
ReturnDesc = WalkState->ReturnDesc;
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "ReturnValue=%p, State=%p\n",
WalkState->ReturnDesc, WalkState));
/* Reset the current scope to the beginning of scope stack */
AcpiDsScopeStackClear (WalkState);
/*
* If we just returned from the execution of a control method,
* there's lots of cleanup to do
*/
if ((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) == ACPI_PARSE_EXECUTE)
{
AcpiDsTerminateControlMethod (WalkState);
}
/* Delete this walk state and all linked control states */
AcpiPsCleanupScope (WalkState->ParserState);
ACPI_MEM_FREE (WalkState->ParserState);
AcpiDsDeleteWalkState (WalkState);
/* Check if we have restarted a preempted walk */
WalkState = AcpiDsGetCurrentWalkState (&WalkList);
if (WalkState &&
ACPI_SUCCESS (Status))
{
/* There is another walk state, restart it */
/*
* If the method returned value is not used by the parent,
* The object is deleted
*/
AcpiDsRestartControlMethod (WalkState, ReturnDesc);
WalkState->WalkType |= WALK_METHOD_RESTART;
}
/*
* Just completed a 1st-level method, save the final internal return
* value (if any)
*/
else if (CallerReturnDesc)
{
*CallerReturnDesc = ReturnDesc; /* NULL if no return value */
}
else if (ReturnDesc)
{
/* Caller doesn't want it, must delete it */
AcpiUtRemoveReference (ReturnDesc);
}
}
/* Normal exit */
AcpiExReleaseAllMutexes ((ACPI_OPERAND_OBJECT *) &WalkList.AcquiredMutexList);
AcpiGbl_CurrentWalkList = PrevWalkList;
return_ACPI_STATUS (Status);
Cleanup:
/* Cleanup */
AcpiDsDeleteWalkState (WalkState);
AcpiPsCleanupScope (ParserState);
ACPI_MEM_FREE (ParserState);
AcpiExReleaseAllMutexes ((ACPI_OPERAND_OBJECT *)&WalkList.AcquiredMutexList);
AcpiGbl_CurrentWalkList = PrevWalkList;
return_ACPI_STATUS (Status);
}
