void
AcpiDbSendNotify (
char *Name,
UINT32 Value)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
/* Translate name to an Named object */
Node = AcpiDbConvertToNode (Name);
if (!Node)
{
return;
}
/* Dispatch the notify if legal */
if (AcpiEvIsNotifyObject (Node))
{
Status = AcpiEvQueueNotifyRequest (Node, Value);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not queue notify\n");
}
}
else
{
AcpiOsPrintf (
"Named object [%4.4s] Type %s, must be Device/Thermal/Processor type\n",
AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type));
}
}
void
AcpiDbUnloadAcpiTable (
char *ObjectName)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
/* Translate name to an Named object */
Node = AcpiDbConvertToNode (ObjectName);
if (!Node)
{
return;
}
Status = AcpiUnloadParentTable (ACPI_CAST_PTR (ACPI_HANDLE, Node));
if (ACPI_SUCCESS (Status))
{
AcpiOsPrintf ("Parent of [%s] (%p) unloaded and uninstalled\n",
ObjectName, Node);
}
else
{
AcpiOsPrintf ("%s, while unloading parent table of [%s]\n",
AcpiFormatException (Status), ObjectName);
}
}
void
AcpiDbDisplayTemplate (
char *BufferArg)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
ACPI_BUFFER ReturnBuffer;
/* Translate BufferArg to an Named object */
Node = AcpiDbConvertToNode (BufferArg);
if (!Node || (Node == AcpiGbl_RootNode))
{
AcpiOsPrintf ("Invalid argument: %s\n", BufferArg);
return;
}
/* We must have a buffer object */
if (Node->Type != ACPI_TYPE_BUFFER)
{
AcpiOsPrintf ("Not a Buffer object, cannot be a template: %s\n",
BufferArg);
return;
}
ReturnBuffer.Length = ACPI_DEBUG_BUFFER_SIZE;
ReturnBuffer.Pointer = AcpiGbl_DbBuffer;
/* Attempt to convert the raw buffer to a resource list */
Status = AcpiRsCreateResourceList (Node->Object, &ReturnBuffer);
AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
AcpiDbgLevel |= ACPI_LV_RESOURCES;
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf (
"Could not convert Buffer to a resource list: %s, %s\n",
BufferArg, AcpiFormatException (Status));
goto DumpBuffer;
}
/* Now we can dump the resource list */
AcpiRsDumpResourceList (ACPI_CAST_PTR (ACPI_RESOURCE,
ReturnBuffer.Pointer));
DumpBuffer:
AcpiOsPrintf ("\nRaw data buffer:\n");
AcpiUtDebugDumpBuffer ((UINT8 *) Node->Object->Buffer.Pointer,
Node->Object->Buffer.Length,
DB_BYTE_DISPLAY, ACPI_UINT32_MAX);
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
return;
}
ACPI_STATUS
AcpiDbDisassembleMethod (
char *Name)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op;
ACPI_WALK_STATE *WalkState;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Method;
Method = AcpiDbConvertToNode (Name);
if (!Method)
{
return (AE_BAD_PARAMETER);
}
ObjDesc = Method->Object;
Op = AcpiPsCreateScopeOp ();
if (!Op)
{
return (AE_NO_MEMORY);
}
/* Create and initialize a new walk state */
WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);
if (!WalkState)
{
return (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,
ObjDesc->Method.AmlStart,
ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Parse the AML */
WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
Status = AcpiPsParseAml (WalkState);
AcpiDmDisassemble (NULL, Op, 0);
AcpiPsDeleteParseTree (Op);
return (AE_OK);
}
void
AcpiDbDumpNamespace (
char *StartArg,
char *DepthArg)
{
ACPI_HANDLE SubtreeEntry = AcpiGbl_RootNode;
UINT32 MaxDepth = ACPI_UINT32_MAX;
/* No argument given, just start at the root and dump entire namespace */
if (StartArg)
{
SubtreeEntry = AcpiDbConvertToNode (StartArg);
if (!SubtreeEntry)
{
return;
}
/* Now we can check for the depth argument */
if (DepthArg)
{
MaxDepth = strtoul (DepthArg, NULL, 0);
}
}
AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
if (((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Parent)
{
AcpiOsPrintf ("ACPI Namespace (from %4.4s (%p) subtree):\n",
((ACPI_NAMESPACE_NODE *) SubtreeEntry)->Name.Ascii, SubtreeEntry);
}
else
{
AcpiOsPrintf ("ACPI Namespace (from %s):\n",
ACPI_NAMESPACE_ROOT);
}
/* Display the subtree */
AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
AcpiNsDumpObjects (ACPI_TYPE_ANY, ACPI_DISPLAY_SUMMARY, MaxDepth,
ACPI_OWNER_ID_MAX, SubtreeEntry);
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
}
void
AcpiDbDisplayResources (
char *ObjectArg)
{
ACPI_NAMESPACE_NODE *Node;
AcpiDbSetOutputDestination (ACPI_DB_REDIRECTABLE_OUTPUT);
AcpiDbgLevel |= ACPI_LV_RESOURCES;
/* Asterisk means "display resources for all devices" */
if (!ObjectArg || (!strcmp (ObjectArg, "*")))
{
(void) AcpiWalkNamespace (ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
ACPI_UINT32_MAX, AcpiDbDeviceResources, NULL, NULL, NULL);
}
else
{
/* Convert string to object pointer */
Node = AcpiDbConvertToNode (ObjectArg);
if (Node)
{
if (Node->Type != ACPI_TYPE_DEVICE)
{
AcpiOsPrintf (
"%4.4s: Name is not a device object (%s)\n",
Node->Name.Ascii, AcpiUtGetTypeName (Node->Type));
}
else
{
(void) AcpiDbDeviceResources (Node, 0, NULL, NULL);
}
}
}
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
}
void
AcpiDbSendNotify (
char *Name,
UINT32 Value)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status;
/* Translate name to an Named object */
Node = AcpiDbConvertToNode (Name);
if (!Node)
{
return;
}
/* Decode Named object type */
switch (Node->Type)
{
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_THERMAL:
/* Send the notify */
Status = AcpiEvQueueNotifyRequest (Node, Value);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not queue notify\n");
}
break;
default:
AcpiOsPrintf ("Named object is not a device or a thermal object\n");
break;
}
}
ACPI_STATUS
AcpiDbDisassembleMethod (
char *Name)
{
ACPI_STATUS Status;
ACPI_PARSE_OBJECT *Op;
ACPI_WALK_STATE *WalkState;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Method;
Method = AcpiDbConvertToNode (Name);
if (!Method)
{
return (AE_BAD_PARAMETER);
}
if (Method->Type != ACPI_TYPE_METHOD)
{
ACPI_ERROR ((AE_INFO, "%s (%s): Object must be a control method",
Name, AcpiUtGetTypeName (Method->Type)));
return (AE_BAD_PARAMETER);
}
ObjDesc = Method->Object;
Op = AcpiPsCreateScopeOp ();
if (!Op)
{
return (AE_NO_MEMORY);
}
/* Create and initialize a new walk state */
WalkState = AcpiDsCreateWalkState (0, Op, NULL, NULL);
if (!WalkState)
{
return (AE_NO_MEMORY);
}
Status = AcpiDsInitAmlWalk (WalkState, Op, NULL,
ObjDesc->Method.AmlStart,
ObjDesc->Method.AmlLength, NULL, ACPI_IMODE_LOAD_PASS1);
if (ACPI_FAILURE (Status))
{
return (Status);
}
Status = AcpiUtAllocateOwnerId (&ObjDesc->Method.OwnerId);
WalkState->OwnerId = ObjDesc->Method.OwnerId;
/* Push start scope on scope stack and make it current */
Status = AcpiDsScopeStackPush (Method,
Method->Type, WalkState);
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Parse the entire method AML including deferred operators */
WalkState->ParseFlags &= ~ACPI_PARSE_DELETE_TREE;
WalkState->ParseFlags |= ACPI_PARSE_DISASSEMBLE;
Status = AcpiPsParseAml (WalkState);
(void) AcpiDmParseDeferredOps (Op);
/* Now we can disassemble the method */
AcpiGbl_DbOpt_verbose = FALSE;
AcpiDmDisassemble (NULL, Op, 0);
AcpiGbl_DbOpt_verbose = TRUE;
AcpiPsDeleteParseTree (Op);
/* Method cleanup */
AcpiNsDeleteNamespaceSubtree (Method);
AcpiNsDeleteNamespaceByOwner (ObjDesc->Method.OwnerId);
AcpiUtReleaseOwnerId (&ObjDesc->Method.OwnerId);
return (AE_OK);
}
void
AcpiDbSetMethodData (
char *TypeArg,
char *IndexArg,
char *ValueArg)
{
char Type;
UINT32 Index;
UINT32 Value;
ACPI_WALK_STATE *WalkState;
ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_STATUS Status;
ACPI_NAMESPACE_NODE *Node;
/* Validate TypeArg */
AcpiUtStrupr (TypeArg);
Type = TypeArg[0];
if ((Type != 'L') &&
(Type != 'A') &&
(Type != 'N'))
{
AcpiOsPrintf ("Invalid SET operand: %s\n", TypeArg);
return;
}
Value = ACPI_STRTOUL (ValueArg, NULL, 16);
if (Type == 'N')
{
Node = AcpiDbConvertToNode (IndexArg);
if (Node->Type != ACPI_TYPE_INTEGER)
{
AcpiOsPrintf ("Can only set Integer nodes\n");
return;
}
ObjDesc = Node->Object;
ObjDesc->Integer.Value = Value;
return;
}
/* Get the index and value */
Index = ACPI_STRTOUL (IndexArg, NULL, 16);
WalkState = AcpiDsGetCurrentWalkState (AcpiGbl_CurrentWalkList);
if (!WalkState)
{
AcpiOsPrintf ("There is no method currently executing\n");
return;
}
/* Create and initialize the new object */
ObjDesc = AcpiUtCreateIntegerObject ((UINT64) Value);
if (!ObjDesc)
{
AcpiOsPrintf ("Could not create an internal object\n");
return;
}
/* Store the new object into the target */
switch (Type)
{
case 'A':
/* Set a method argument */
if (Index > ACPI_METHOD_MAX_ARG)
{
AcpiOsPrintf ("Arg%u - Invalid argument name\n", Index);
goto Cleanup;
}
Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_ARG, Index, ObjDesc,
WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
ObjDesc = WalkState->Arguments[Index].Object;
AcpiOsPrintf ("Arg%u: ", Index);
AcpiDmDisplayInternalObject (ObjDesc, WalkState);
break;
case 'L':
/* Set a method local */
if (Index > ACPI_METHOD_MAX_LOCAL)
{
AcpiOsPrintf ("Local%u - Invalid local variable name\n", Index);
goto Cleanup;
}
Status = AcpiDsStoreObjectToLocal (ACPI_REFCLASS_LOCAL, Index, ObjDesc,
WalkState);
if (ACPI_FAILURE (Status))
{
goto Cleanup;
}
ObjDesc = WalkState->LocalVariables[Index].Object;
AcpiOsPrintf ("Local%u: ", Index);
AcpiDmDisplayInternalObject (ObjDesc, WalkState);
break;
default:
break;
}
Cleanup:
AcpiUtRemoveReference (ObjDesc);
}
void
AcpiDbDisplayObjectType (
char *Name)
{
ACPI_NAMESPACE_NODE *Node;
ACPI_DEVICE_INFO *Info;
ACPI_STATUS Status;
UINT32 i;
Node = AcpiDbConvertToNode (Name);
if (!Node)
{
return;
}
Status = AcpiGetObjectInfo (ACPI_CAST_PTR (ACPI_HANDLE, Node), &Info);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not get object info, %s\n",
AcpiFormatException (Status));
return;
}
if (Info->Valid & ACPI_VALID_ADR)
{
AcpiOsPrintf ("ADR: %8.8X%8.8X, STA: %8.8X, Flags: %X\n",
ACPI_FORMAT_UINT64 (Info->Address),
Info->CurrentStatus, Info->Flags);
}
if (Info->Valid & ACPI_VALID_SXDS)
{
AcpiOsPrintf ("S1D-%2.2X S2D-%2.2X S3D-%2.2X S4D-%2.2X\n",
Info->HighestDstates[0], Info->HighestDstates[1],
Info->HighestDstates[2], Info->HighestDstates[3]);
}
if (Info->Valid & ACPI_VALID_SXWS)
{
AcpiOsPrintf ("S0W-%2.2X S1W-%2.2X S2W-%2.2X S3W-%2.2X S4W-%2.2X\n",
Info->LowestDstates[0], Info->LowestDstates[1],
Info->LowestDstates[2], Info->LowestDstates[3],
Info->LowestDstates[4]);
}
if (Info->Valid & ACPI_VALID_HID)
{
AcpiOsPrintf ("HID: %s\n", Info->HardwareId.String);
}
if (Info->Valid & ACPI_VALID_UID)
{
AcpiOsPrintf ("UID: %s\n", Info->UniqueId.String);
}
if (Info->Valid & ACPI_VALID_SUB)
{
AcpiOsPrintf ("SUB: %s\n", Info->SubsystemId.String);
}
if (Info->Valid & ACPI_VALID_CID)
{
for (i = 0; i < Info->CompatibleIdList.Count; i++)
{
AcpiOsPrintf ("CID %u: %s\n", i,
Info->CompatibleIdList.Ids[i].String);
}
}
ACPI_FREE (Info);
}