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); }