ACPI_STATUS
AcpiNsGetNode (
ACPI_NAMESPACE_NODE *PrefixNode,
const char *Pathname,
UINT32 Flags,
ACPI_NAMESPACE_NODE **ReturnNode)
{
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE_PTR (NsGetNode, ACPI_CAST_PTR (char, Pathname));
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiNsGetNodeUnlocked (PrefixNode, Pathname,
Flags, ReturnNode);
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiExOpcode_1A_0T_1R (
ACPI_WALK_STATE *WalkState)
{
ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
ACPI_OPERAND_OBJECT *TempDesc;
ACPI_OPERAND_OBJECT *ReturnDesc = NULL;
ACPI_STATUS Status = AE_OK;
UINT32 Type;
UINT64 Value;
ACPI_FUNCTION_TRACE_STR (ExOpcode_1A_0T_1R,
AcpiPsGetOpcodeName (WalkState->Opcode));
/* Examine the AML opcode */
switch (WalkState->Opcode)
{
case AML_LNOT_OP: /* LNot (Operand) */
ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
if (!ReturnDesc)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/*
* Set result to ONES (TRUE) if Value == 0. Note:
* ReturnDesc->Integer.Value is initially == 0 (FALSE) from above.
*/
if (!Operand[0]->Integer.Value)
{
ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
}
break;
case AML_DECREMENT_OP: /* Decrement (Operand) */
case AML_INCREMENT_OP: /* Increment (Operand) */
/*
* Create a new integer. Can't just get the base integer and
* increment it because it may be an Arg or Field.
*/
ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
if (!ReturnDesc)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
/*
* Since we are expecting a Reference operand, it can be either a
* NS Node or an internal object.
*/
TempDesc = Operand[0];
if (ACPI_GET_DESCRIPTOR_TYPE (TempDesc) == ACPI_DESC_TYPE_OPERAND)
{
/* Internal reference object - prevent deletion */
AcpiUtAddReference (TempDesc);
}
/*
* Convert the Reference operand to an Integer (This removes a
* reference on the Operand[0] object)
*
* NOTE: We use LNOT_OP here in order to force resolution of the
* reference operand to an actual integer.
*/
Status = AcpiExResolveOperands (AML_LNOT_OP, &TempDesc, WalkState);
if (ACPI_FAILURE (Status))
{
ACPI_EXCEPTION ((AE_INFO, Status,
"While resolving operands for [%s]",
AcpiPsGetOpcodeName (WalkState->Opcode)));
goto Cleanup;
}
/*
* TempDesc is now guaranteed to be an Integer object --
* Perform the actual increment or decrement
*/
if (WalkState->Opcode == AML_INCREMENT_OP)
{
ReturnDesc->Integer.Value = TempDesc->Integer.Value + 1;
}
else
{
ReturnDesc->Integer.Value = TempDesc->Integer.Value - 1;
}
/* Finished with this Integer object */
AcpiUtRemoveReference (TempDesc);
/*
* Store the result back (indirectly) through the original
* Reference object
*/
Status = AcpiExStore (ReturnDesc, Operand[0], WalkState);
break;
case AML_OBJECT_TYPE_OP: /* ObjectType (SourceObject) */
/*
* Note: The operand is not resolved at this point because we want to
* get the associated object, not its value. For example, we don't
* want to resolve a FieldUnit to its value, we want the actual
* FieldUnit object.
*/
/* Get the type of the base object */
Status = AcpiExResolveMultiple (WalkState, Operand[0], &Type, NULL);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/* Allocate a descriptor to hold the type. */
ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) Type);
if (!ReturnDesc)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
break;
case AML_SIZE_OF_OP: /* SizeOf (SourceObject) */
/*
* Note: The operand is not resolved at this point because we want to
* get the associated object, not its value.
*/
/* Get the base object */
Status = AcpiExResolveMultiple (
WalkState, Operand[0], &Type, &TempDesc);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/*
* The type of the base object must be integer, buffer, string, or
* package. All others are not supported.
*
* NOTE: Integer is not specifically supported by the ACPI spec,
* but is supported implicitly via implicit operand conversion.
* rather than bother with conversion, we just use the byte width
* global (4 or 8 bytes).
*/
switch (Type)
{
case ACPI_TYPE_INTEGER:
Value = AcpiGbl_IntegerByteWidth;
break;
case ACPI_TYPE_STRING:
Value = TempDesc->String.Length;
break;
case ACPI_TYPE_BUFFER:
/* Buffer arguments may not be evaluated at this point */
Status = AcpiDsGetBufferArguments (TempDesc);
Value = TempDesc->Buffer.Length;
break;
case ACPI_TYPE_PACKAGE:
/* Package arguments may not be evaluated at this point */
Status = AcpiDsGetPackageArguments (TempDesc);
Value = TempDesc->Package.Count;
break;
default:
ACPI_ERROR ((AE_INFO,
"Operand must be Buffer/Integer/String/Package"
" - found type %s",
AcpiUtGetTypeName (Type)));
Status = AE_AML_OPERAND_TYPE;
goto Cleanup;
}
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/*
* Now that we have the size of the object, create a result
* object to hold the value
*/
ReturnDesc = AcpiUtCreateIntegerObject (Value);
if (!ReturnDesc)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
break;
case AML_REF_OF_OP: /* RefOf (SourceObject) */
Status = AcpiExGetObjectReference (
Operand[0], &ReturnDesc, WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
break;
case AML_DEREF_OF_OP: /* DerefOf (ObjReference | String) */
/* Check for a method local or argument, or standalone String */
if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
{
TempDesc = AcpiNsGetAttachedObject (
(ACPI_NAMESPACE_NODE *) Operand[0]);
if (TempDesc &&
((TempDesc->Common.Type == ACPI_TYPE_STRING) ||
(TempDesc->Common.Type == ACPI_TYPE_LOCAL_REFERENCE)))
{
Operand[0] = TempDesc;
AcpiUtAddReference (TempDesc);
}
else
{
Status = AE_AML_OPERAND_TYPE;
goto Cleanup;
}
}
else
{
switch ((Operand[0])->Common.Type)
{
case ACPI_TYPE_LOCAL_REFERENCE:
/*
* This is a DerefOf (LocalX | ArgX)
*
* Must resolve/dereference the local/arg reference first
*/
switch (Operand[0]->Reference.Class)
{
case ACPI_REFCLASS_LOCAL:
case ACPI_REFCLASS_ARG:
/* Set Operand[0] to the value of the local/arg */
Status = AcpiDsMethodDataGetValue (
Operand[0]->Reference.Class,
Operand[0]->Reference.Value,
WalkState, &TempDesc);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
/*
* Delete our reference to the input object and
* point to the object just retrieved
*/
AcpiUtRemoveReference (Operand[0]);
Operand[0] = TempDesc;
break;
case ACPI_REFCLASS_REFOF:
/* Get the object to which the reference refers */
TempDesc = Operand[0]->Reference.Object;
AcpiUtRemoveReference (Operand[0]);
Operand[0] = TempDesc;
break;
default:
/* Must be an Index op - handled below */
break;
}
break;
case ACPI_TYPE_STRING:
break;
default:
Status = AE_AML_OPERAND_TYPE;
goto Cleanup;
}
}
if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) != ACPI_DESC_TYPE_NAMED)
{
if ((Operand[0])->Common.Type == ACPI_TYPE_STRING)
{
/*
* This is a DerefOf (String). The string is a reference
* to a named ACPI object.
*
* 1) Find the owning Node
* 2) Dereference the node to an actual object. Could be a
* Field, so we need to resolve the node to a value.
*/
Status = AcpiNsGetNodeUnlocked (WalkState->ScopeInfo->Scope.Node,
Operand[0]->String.Pointer,
ACPI_NS_SEARCH_PARENT,
ACPI_CAST_INDIRECT_PTR (
ACPI_NAMESPACE_NODE, &ReturnDesc));
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
Status = AcpiExResolveNodeToValue (
ACPI_CAST_INDIRECT_PTR (
ACPI_NAMESPACE_NODE, &ReturnDesc),
WalkState);
goto Cleanup;
}
}
/* Operand[0] may have changed from the code above */
if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) == ACPI_DESC_TYPE_NAMED)
{
/*
* This is a DerefOf (ObjectReference)
* Get the actual object from the Node (This is the dereference).
* This case may only happen when a LocalX or ArgX is
* dereferenced above.
*/
ReturnDesc = AcpiNsGetAttachedObject (
(ACPI_NAMESPACE_NODE *) Operand[0]);
AcpiUtAddReference (ReturnDesc);
}
else
{
/*
* This must be a reference object produced by either the
* Index() or RefOf() operator
*/
switch (Operand[0]->Reference.Class)
{
case ACPI_REFCLASS_INDEX:
/*
* The target type for the Index operator must be
* either a Buffer or a Package
*/
switch (Operand[0]->Reference.TargetType)
{
case ACPI_TYPE_BUFFER_FIELD:
TempDesc = Operand[0]->Reference.Object;
/*
* Create a new object that contains one element of the
* buffer -- the element pointed to by the index.
*
* NOTE: index into a buffer is NOT a pointer to a
* sub-buffer of the main buffer, it is only a pointer to a
* single element (byte) of the buffer!
*
* Since we are returning the value of the buffer at the
* indexed location, we don't need to add an additional
* reference to the buffer itself.
*/
ReturnDesc = AcpiUtCreateIntegerObject ((UINT64)
TempDesc->Buffer.Pointer[Operand[0]->Reference.Value]);
if (!ReturnDesc)
{
Status = AE_NO_MEMORY;
goto Cleanup;
}
break;
case ACPI_TYPE_PACKAGE:
/*
* Return the referenced element of the package. We must
* add another reference to the referenced object, however.
*/
ReturnDesc = *(Operand[0]->Reference.Where);
if (!ReturnDesc)
{
/*
* Element is NULL, do not allow the dereference.
* This provides compatibility with other ACPI
* implementations.
*/
return_ACPI_STATUS (AE_AML_UNINITIALIZED_ELEMENT);
}
AcpiUtAddReference (ReturnDesc);
break;
default:
ACPI_ERROR ((AE_INFO,
"Unknown Index TargetType 0x%X in reference object %p",
Operand[0]->Reference.TargetType, Operand[0]));
Status = AE_AML_OPERAND_TYPE;
goto Cleanup;
}
break;
case ACPI_REFCLASS_REFOF:
ReturnDesc = Operand[0]->Reference.Object;
if (ACPI_GET_DESCRIPTOR_TYPE (ReturnDesc) ==
ACPI_DESC_TYPE_NAMED)
{
ReturnDesc = AcpiNsGetAttachedObject (
(ACPI_NAMESPACE_NODE *) ReturnDesc);
if (!ReturnDesc)
{
break;
}
/*
* June 2013:
* BufferFields/FieldUnits require additional resolution
*/
switch (ReturnDesc->Common.Type)
{
case ACPI_TYPE_BUFFER_FIELD:
case ACPI_TYPE_LOCAL_REGION_FIELD:
case ACPI_TYPE_LOCAL_BANK_FIELD:
case ACPI_TYPE_LOCAL_INDEX_FIELD:
Status = AcpiExReadDataFromField (
WalkState, ReturnDesc, &TempDesc);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
ReturnDesc = TempDesc;
break;
default:
/* Add another reference to the object */
AcpiUtAddReference (ReturnDesc);
break;
}
}
break;
default:
ACPI_ERROR ((AE_INFO,
"Unknown class in reference(%p) - 0x%2.2X",
Operand[0], Operand[0]->Reference.Class));
Status = AE_TYPE;
goto Cleanup;
}
}
break;
default:
ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
WalkState->Opcode));
Status = AE_AML_BAD_OPCODE;
goto Cleanup;
}
Cleanup:
/* Delete return object on error */
if (ACPI_FAILURE (Status))
{
AcpiUtRemoveReference (ReturnDesc);
}
/* Save return object on success */
else
{
WalkState->ResultObj = ReturnDesc;
}
return_ACPI_STATUS (Status);
}
ACPI_STATUS
AcpiExLoadTableOp (
ACPI_WALK_STATE *WalkState,
ACPI_OPERAND_OBJECT **ReturnDesc)
{
ACPI_STATUS Status;
ACPI_OPERAND_OBJECT **Operand = &WalkState->Operands[0];
ACPI_NAMESPACE_NODE *ParentNode;
ACPI_NAMESPACE_NODE *StartNode;
ACPI_NAMESPACE_NODE *ParameterNode = NULL;
ACPI_OPERAND_OBJECT *DdbHandle;
UINT32 TableIndex;
ACPI_FUNCTION_TRACE (ExLoadTableOp);
/* Find the ACPI table in the RSDT/XSDT */
AcpiExExitInterpreter ();
Status = AcpiTbFindTable (
Operand[0]->String.Pointer,
Operand[1]->String.Pointer,
Operand[2]->String.Pointer, &TableIndex);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
if (Status != AE_NOT_FOUND)
{
return_ACPI_STATUS (Status);
}
/* Table not found, return an Integer=0 and AE_OK */
DdbHandle = AcpiUtCreateIntegerObject ((UINT64) 0);
if (!DdbHandle)
{
return_ACPI_STATUS (AE_NO_MEMORY);
}
*ReturnDesc = DdbHandle;
return_ACPI_STATUS (AE_OK);
}
/* Default nodes */
StartNode = WalkState->ScopeInfo->Scope.Node;
ParentNode = AcpiGbl_RootNode;
/* RootPath (optional parameter) */
if (Operand[3]->String.Length > 0)
{
/*
* Find the node referenced by the RootPathString. This is the
* location within the namespace where the table will be loaded.
*/
Status = AcpiNsGetNodeUnlocked (StartNode,
Operand[3]->String.Pointer, ACPI_NS_SEARCH_PARENT,
&ParentNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/* ParameterPath (optional parameter) */
if (Operand[4]->String.Length > 0)
{
if ((Operand[4]->String.Pointer[0] != AML_ROOT_PREFIX) &&
(Operand[4]->String.Pointer[0] != AML_PARENT_PREFIX))
{
/*
* Path is not absolute, so it will be relative to the node
* referenced by the RootPathString (or the NS root if omitted)
*/
StartNode = ParentNode;
}
/* Find the node referenced by the ParameterPathString */
Status = AcpiNsGetNodeUnlocked (StartNode,
Operand[4]->String.Pointer, ACPI_NS_SEARCH_PARENT,
&ParameterNode);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
}
/* Load the table into the namespace */
ACPI_INFO (("Dynamic OEM Table Load:"));
AcpiExExitInterpreter ();
Status = AcpiTbLoadTable (TableIndex, ParentNode);
AcpiExEnterInterpreter ();
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
Status = AcpiExAddTable (TableIndex, &DdbHandle);
if (ACPI_FAILURE (Status))
{
return_ACPI_STATUS (Status);
}
/* Parameter Data (optional) */
if (ParameterNode)
{
/* Store the parameter data into the optional parameter object */
Status = AcpiExStore (Operand[5],
ACPI_CAST_PTR (ACPI_OPERAND_OBJECT, ParameterNode), WalkState);
if (ACPI_FAILURE (Status))
{
(void) AcpiExUnloadTable (DdbHandle);
AcpiUtRemoveReference (DdbHandle);
return_ACPI_STATUS (Status);
}
}
*ReturnDesc = DdbHandle;
return_ACPI_STATUS (Status);
}
