ACPI_STATUS
AcpiPsParseAml (
ACPI_WALK_STATE *WalkState)
{
ACPI_STATUS Status;
ACPI_THREAD_STATE *Thread;
ACPI_THREAD_STATE *PrevWalkList = AcpiGbl_CurrentWalkList;
ACPI_WALK_STATE *PreviousWalkState;
ACPI_FUNCTION_TRACE (PsParseAml);
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Entered with WalkState=%p Aml=%p size=%X\n",
WalkState, WalkState->ParserState.Aml,
WalkState->ParserState.AmlSize));
if (!WalkState->ParserState.Aml)
{
return_ACPI_STATUS (AE_NULL_OBJECT);
}
/* Create and initialize a new thread state */
Thread = AcpiUtCreateThreadState ();
if (!Thread)
{
if (WalkState->MethodDesc)
{
/* Executing a control method - additional cleanup */
AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
}
AcpiDsDeleteWalkState (WalkState);
return_ACPI_STATUS (AE_NO_MEMORY);
}
WalkState->Thread = Thread;
/*
* If executing a method, the starting SyncLevel is this method's
* SyncLevel
*/
if (WalkState->MethodDesc)
{
WalkState->Thread->CurrentSyncLevel = WalkState->MethodDesc->Method.SyncLevel;
}
AcpiDsPushWalkState (WalkState, Thread);
/*
* This global allows the AML debugger to get a handle to the currently
* executing control method.
*/
AcpiGbl_CurrentWalkList = Thread;
/*
* 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))
{
/*
* The ParseLoop executes AML until the method terminates
* or calls another method.
*/
Status = AcpiPsParseLoop (WalkState);
}
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"Completed one call to walk loop, %s State=%p\n",
AcpiFormatException (Status), WalkState));
if (Status == AE_CTRL_TRANSFER)
{
/*
* A method call was detected.
* Transfer control to the called control method
*/
Status = AcpiDsCallControlMethod (Thread, WalkState, NULL);
if (ACPI_FAILURE (Status))
{
Status = AcpiDsMethodError (Status, WalkState);
}
/*
* If the transfer to the new method method call worked, a new walk
* state was created -- get it
*/
WalkState = AcpiDsGetCurrentWalkState (Thread);
continue;
}
else if (Status == AE_CTRL_TERMINATE)
{
Status = AE_OK;
}
else if ((Status != AE_OK) && (WalkState->MethodDesc))
{
/* Either the method parse or actual execution failed */
ACPI_ERROR_METHOD ("Method parse/execution failed",
WalkState->MethodNode, NULL, Status);
/* Check for possible multi-thread reentrancy problem */
if ((Status == AE_ALREADY_EXISTS) &&
(!(WalkState->MethodDesc->Method.InfoFlags & ACPI_METHOD_SERIALIZED)))
{
/*
* Method is not serialized and tried to create an object
* twice. The probable cause is that the method cannot
* handle reentrancy. Mark as "pending serialized" now, and
* then mark "serialized" when the last thread exits.
*/
WalkState->MethodDesc->Method.InfoFlags |=
ACPI_METHOD_SERIALIZED_PENDING;
}
}
/* We are done with this walk, move on to the parent if any */
WalkState = AcpiDsPopWalkState (Thread);
/* Reset the current scope to the beginning of scope stack */
AcpiDsScopeStackClear (WalkState);
/*
* If we just returned from the execution of a control method or if we
* encountered an error during the method parse phase, there's lots of
* cleanup to do
*/
if (((WalkState->ParseFlags & ACPI_PARSE_MODE_MASK) == ACPI_PARSE_EXECUTE) ||
(ACPI_FAILURE (Status)))
{
AcpiDsTerminateControlMethod (WalkState->MethodDesc, WalkState);
}
/* Delete this walk state and all linked control states */
AcpiPsCleanupScope (&WalkState->ParserState);
PreviousWalkState = WalkState;
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
"ReturnValue=%p, ImplicitValue=%p State=%p\n",
WalkState->ReturnDesc, WalkState->ImplicitReturnObj, WalkState));
/* Check if we have restarted a preempted walk */
WalkState = AcpiDsGetCurrentWalkState (Thread);
if (WalkState)
{
if (ACPI_SUCCESS (Status))
{
/*
* There is another walk state, restart it.
* If the method return value is not used by the parent,
* The object is deleted
*/
if (!PreviousWalkState->ReturnDesc)
{
/*
* In slack mode execution, if there is no return value
* we should implicitly return zero (0) as a default value.
*/
if (AcpiGbl_EnableInterpreterSlack &&
!PreviousWalkState->ImplicitReturnObj)
{
PreviousWalkState->ImplicitReturnObj =
AcpiUtCreateIntegerObject ((UINT64) 0);
if (!PreviousWalkState->ImplicitReturnObj)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
}
/* Restart the calling control method */
Status = AcpiDsRestartControlMethod (WalkState,
PreviousWalkState->ImplicitReturnObj);
}
else
{
/*
* We have a valid return value, delete any implicit
* return value.
*/
AcpiDsClearImplicitReturn (PreviousWalkState);
Status = AcpiDsRestartControlMethod (WalkState,
PreviousWalkState->ReturnDesc);
}
if (ACPI_SUCCESS (Status))
{
WalkState->WalkType |= ACPI_WALK_METHOD_RESTART;
}
}
else
{
/* On error, delete any return object or implicit return */
AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
AcpiDsClearImplicitReturn (PreviousWalkState);
}
}
/*
* Just completed a 1st-level method, save the final internal return
* value (if any)
*/
else if (PreviousWalkState->CallerReturnDesc)
{
if (PreviousWalkState->ImplicitReturnObj)
{
*(PreviousWalkState->CallerReturnDesc) =
PreviousWalkState->ImplicitReturnObj;
}
else
{
/* NULL if no return value */
*(PreviousWalkState->CallerReturnDesc) =
PreviousWalkState->ReturnDesc;
}
}
else
{
if (PreviousWalkState->ReturnDesc)
{
/* Caller doesn't want it, must delete it */
AcpiUtRemoveReference (PreviousWalkState->ReturnDesc);
}
if (PreviousWalkState->ImplicitReturnObj)
{
/* Caller doesn't want it, must delete it */
AcpiUtRemoveReference (PreviousWalkState->ImplicitReturnObj);
}
}
AcpiDsDeleteWalkState (PreviousWalkState);
}
/* Normal exit */
AcpiExReleaseAllMutexes (Thread);
AcpiUtDeleteGenericState (ACPI_CAST_PTR (ACPI_GENERIC_STATE, Thread));
AcpiGbl_CurrentWalkList = PrevWalkList;
return_ACPI_STATUS (Status);
}
acpi_status
acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
char *path,
u32 expected_return_btypes,
union acpi_operand_object **return_desc)
{
struct acpi_evaluate_info *info;
acpi_status status;
u32 return_btype;
ACPI_FUNCTION_TRACE(ut_evaluate_object);
info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
if (!info) {
return_ACPI_STATUS(AE_NO_MEMORY);
}
info->prefix_node = prefix_node;
info->pathname = path;
status = acpi_ns_evaluate(info);
if (ACPI_FAILURE(status)) {
if (status == AE_NOT_FOUND) {
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[%4.4s.%s] was not found\n",
acpi_ut_get_node_name(prefix_node),
path));
} else {
ACPI_ERROR_METHOD("Method execution failed",
prefix_node, path, status);
}
goto cleanup;
}
if (!info->return_object) {
if (expected_return_btypes) {
ACPI_ERROR_METHOD("No object was returned from",
prefix_node, path, AE_NOT_EXIST);
status = AE_NOT_EXIST;
}
goto cleanup;
}
switch ((info->return_object)->common.type) {
case ACPI_TYPE_INTEGER:
return_btype = ACPI_BTYPE_INTEGER;
break;
case ACPI_TYPE_BUFFER:
return_btype = ACPI_BTYPE_BUFFER;
break;
case ACPI_TYPE_STRING:
return_btype = ACPI_BTYPE_STRING;
break;
case ACPI_TYPE_PACKAGE:
return_btype = ACPI_BTYPE_PACKAGE;
break;
default:
return_btype = 0;
break;
}
if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
acpi_ut_remove_reference(info->return_object);
goto cleanup;
}
if (!(expected_return_btypes & return_btype)) {
ACPI_ERROR_METHOD("Return object type is incorrect",
prefix_node, path, AE_TYPE);
ACPI_ERROR((AE_INFO,
"Type returned from %s was incorrect: %s, expected Btypes: 0x%X",
path,
acpi_ut_get_object_type_name(info->return_object),
expected_return_btypes));
acpi_ut_remove_reference(info->return_object);
status = AE_TYPE;
goto cleanup;
}
*return_desc = info->return_object;
cleanup:
ACPI_FREE(info);
return_ACPI_STATUS(status);
}
acpi_status
acpi_ut_evaluate_object(struct acpi_namespace_node * prefix_node,
char *path,
u32 expected_return_btypes,
union acpi_operand_object **return_desc)
{
struct acpi_evaluate_info *info;
acpi_status status;
u32 return_btype;
ACPI_FUNCTION_TRACE(ut_evaluate_object);
/* Allocate the evaluation information block */
info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
if (!info) {
return_ACPI_STATUS(AE_NO_MEMORY);
}
info->prefix_node = prefix_node;
info->pathname = path;
/* Evaluate the object/method */
status = acpi_ns_evaluate(info);
if (ACPI_FAILURE(status)) {
if (status == AE_NOT_FOUND) {
ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
"[%4.4s.%s] was not found\n",
acpi_ut_get_node_name(prefix_node),
path));
} else {
ACPI_ERROR_METHOD("Method execution failed",
prefix_node, path, status);
}
goto cleanup;
}
/* Did we get a return object? */
if (!info->return_object) {
if (expected_return_btypes) {
ACPI_ERROR_METHOD("No object was returned from",
prefix_node, path, AE_NOT_EXIST);
status = AE_NOT_EXIST;
}
goto cleanup;
}
/* Map the return object type to the bitmapped type */
switch ((info->return_object)->common.type) {
case ACPI_TYPE_INTEGER:
return_btype = ACPI_BTYPE_INTEGER;
break;
case ACPI_TYPE_BUFFER:
return_btype = ACPI_BTYPE_BUFFER;
break;
case ACPI_TYPE_STRING:
return_btype = ACPI_BTYPE_STRING;
break;
case ACPI_TYPE_PACKAGE:
return_btype = ACPI_BTYPE_PACKAGE;
break;
default:
return_btype = 0;
break;
}
if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
/*
* We received a return object, but one was not expected. This can
* happen frequently if the "implicit return" feature is enabled.
* Just delete the return object and return AE_OK.
*/
acpi_ut_remove_reference(info->return_object);
goto cleanup;
}
/* Is the return object one of the expected types? */
if (!(expected_return_btypes & return_btype)) {
ACPI_ERROR_METHOD("Return object type is incorrect",
prefix_node, path, AE_TYPE);
ACPI_ERROR((AE_INFO,
"Type returned from %s was incorrect: %s, expected Btypes: 0x%X",
path,
acpi_ut_get_object_type_name(info->return_object),
expected_return_btypes));
/* On error exit, we must delete the return object */
acpi_ut_remove_reference(info->return_object);
status = AE_TYPE;
goto cleanup;
}
/* Object type is OK, return it */
*return_desc = info->return_object;
cleanup:
ACPI_FREE(info);
return_ACPI_STATUS(status);
}
ACPI_STATUS
AcpiUtEvaluateObject (
ACPI_NAMESPACE_NODE *PrefixNode,
char *Path,
UINT32 ExpectedReturnBtypes,
ACPI_OPERAND_OBJECT **ReturnDesc)
{
ACPI_EVALUATE_INFO *Info;
ACPI_STATUS Status;
UINT32 ReturnBtype;
ACPI_FUNCTION_TRACE (UtEvaluateObject);
/* Allocate the evaluation information block */
Info = ACPI_ALLOCATE_ZEROED (sizeof (ACPI_EVALUATE_INFO));
if (!Info)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
Info->PrefixNode = PrefixNode;
Info->Pathname = Path;
/* Evaluate the object/method */
Status = AcpiNsEvaluate (Info);
if (ACPI_FAILURE (Status))
{
if (Status == AE_NOT_FOUND)
{
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "[%4.4s.%s] was not found\n",
AcpiUtGetNodeName (PrefixNode), Path));
}
else
{
ACPI_ERROR_METHOD ("Method execution failed",
PrefixNode, Path, Status);
}
goto Cleanup;
}
/* Did we get a return object? */
if (!Info->ReturnObject)
{
if (ExpectedReturnBtypes)
{
ACPI_ERROR_METHOD ("No object was returned from",
PrefixNode, Path, AE_NOT_EXIST);
Status = AE_NOT_EXIST;
}
goto Cleanup;
}
/* Map the return object type to the bitmapped type */
switch ((Info->ReturnObject)->Common.Type)
{
case ACPI_TYPE_INTEGER:
ReturnBtype = ACPI_BTYPE_INTEGER;
break;
case ACPI_TYPE_BUFFER:
ReturnBtype = ACPI_BTYPE_BUFFER;
break;
case ACPI_TYPE_STRING:
ReturnBtype = ACPI_BTYPE_STRING;
break;
case ACPI_TYPE_PACKAGE:
ReturnBtype = ACPI_BTYPE_PACKAGE;
break;
default:
ReturnBtype = 0;
break;
}
if ((AcpiGbl_EnableInterpreterSlack) &&
(!ExpectedReturnBtypes))
{
/*
* We received a return object, but one was not expected. This can
* happen frequently if the "implicit return" feature is enabled.
* Just delete the return object and return AE_OK.
*/
AcpiUtRemoveReference (Info->ReturnObject);
goto Cleanup;
}
/* Is the return object one of the expected types? */
if (!(ExpectedReturnBtypes & ReturnBtype))
{
ACPI_ERROR_METHOD ("Return object type is incorrect",
PrefixNode, Path, AE_TYPE);
ACPI_ERROR ((AE_INFO,
"Type returned from %s was incorrect: %s, expected Btypes: %X",
Path, AcpiUtGetObjectTypeName (Info->ReturnObject),
ExpectedReturnBtypes));
/* On error exit, we must delete the return object */
AcpiUtRemoveReference (Info->ReturnObject);
Status = AE_TYPE;
goto Cleanup;
}
/* Object type is OK, return it */
*ReturnDesc = Info->ReturnObject;
Cleanup:
ACPI_FREE (Info);
return_ACPI_STATUS (Status);
}