static ACPI_STATUS
get_device_by_hid_callback(ACPI_HANDLE object, UINT32 depth, void* context,
void** _returnValue)
{
uint32* counter = (uint32*)context;
ACPI_BUFFER buffer;
TRACE("get_device_by_hid_callback %p, %d, %p\n", object, depth, context);
*_returnValue = NULL;
if (counter[0] == counter[1]) {
buffer.Length = 254;
buffer.Pointer = malloc(255);
if (checkAndLogFailure(AcpiGetName(object, ACPI_FULL_PATHNAME, &buffer),
"Failed to find device")) {
free(buffer.Pointer);
return AE_CTRL_TERMINATE;
}
((char*)buffer.Pointer)[buffer.Length] = '\0';
*_returnValue = buffer.Pointer;
return AE_CTRL_TERMINATE;
}
counter[1]++;
return AE_OK;
}
status_t
get_name(acpi_handle handle, uint32 nameType, char* returnedName,
size_t bufferLength)
{
ACPI_BUFFER buffer = {bufferLength, (void*)returnedName};
return AcpiGetName(handle, nameType, &buffer) == AE_OK ? B_OK : B_ERROR;
}
status_t
get_next_entry(uint32 objectType, const char *base, char *result,
size_t length, void **counter)
{
ACPI_HANDLE parent, child, newChild;
ACPI_BUFFER buffer;
ACPI_STATUS status;
TRACE("get_next_entry %ld, %s\n", objectType, base);
if (base == NULL || !strcmp(base, "\\")) {
parent = ACPI_ROOT_OBJECT;
} else {
status = AcpiGetHandle(NULL, (ACPI_STRING)base, &parent);
if (status != AE_OK)
return B_ENTRY_NOT_FOUND;
}
child = *counter;
status = AcpiGetNextObject(objectType, parent, child, &newChild);
if (status != AE_OK)
return B_ENTRY_NOT_FOUND;
*counter = newChild;
buffer.Length = length;
buffer.Pointer = result;
status = AcpiGetName(newChild, ACPI_FULL_PATHNAME, &buffer);
if (status != AE_OK)
return B_NO_MEMORY; /* Corresponds to AE_BUFFER_OVERFLOW */
return B_OK;
}
/*
* Fetch the short name associated with an ACPI handle and save it in the
* passed in buffer.
*/
static ACPI_STATUS
acpi_short_name(ACPI_HANDLE handle, char *buffer, size_t buflen)
{
ACPI_BUFFER buf;
buf.Length = buflen;
buf.Pointer = buffer;
return (AcpiGetName(handle, ACPI_SINGLE_NAME, &buf));
}
static PyObject *acpi_object_to_python(ACPI_OBJECT *obj)
{
if (obj == NULL)
return Py_BuildValue("");
switch(obj->Type) {
case ACPI_TYPE_ANY:
return Py_BuildValue("");
case ACPI_TYPE_INTEGER:
return Py_BuildValue("IK", ACPI_TYPE_INTEGER, obj->Integer.Value);
case ACPI_TYPE_STRING:
return Py_BuildValue("Is#", ACPI_TYPE_STRING, obj->String.Pointer, obj->String.Length);
case ACPI_TYPE_BUFFER:
return Py_BuildValue("Is#", ACPI_TYPE_BUFFER, obj->Buffer.Pointer, obj->Buffer.Length);
case ACPI_TYPE_PACKAGE:
{
U32 ndx;
PyObject *pkg = PyTuple_New(obj->Package.Count);
for (ndx = 0; ndx < obj->Package.Count; ndx++) {
PyObject *elem = acpi_object_to_python(&obj->Package.Elements[ndx]);
if (!elem) {
Py_XDECREF(pkg);
return NULL;
}
PyTuple_SET_ITEM(pkg, ndx, elem);
}
return Py_BuildValue("IN", ACPI_TYPE_PACKAGE, pkg);
}
case ACPI_TYPE_POWER:
return Py_BuildValue("I(II)", ACPI_TYPE_POWER, obj->PowerResource.SystemLevel, obj->PowerResource.ResourceOrder);
case ACPI_TYPE_PROCESSOR:
return Py_BuildValue("I(IkI)", ACPI_TYPE_PROCESSOR, obj->Processor.ProcId, obj->Processor.PblkAddress, obj->Processor.PblkLength);
case ACPI_TYPE_LOCAL_REFERENCE:
{
ACPI_BUFFER Path = { .Length = ACPI_ALLOCATE_BUFFER, .Pointer = NULL };
PyObject *ret;
if (obj->Reference.Handle)
if (ACPI_FAILURE(AcpiGetName(obj->Reference.Handle, ACPI_FULL_PATHNAME, &Path)))
return PyErr_Format(PyExc_RuntimeError,
"Could not get name from ACPI local reference");
ret = Py_BuildValue("I(IN)", ACPI_TYPE_LOCAL_REFERENCE, obj->Reference.ActualType, Path.Pointer ? Py_BuildValue("s", Path.Pointer) : Py_BuildValue(""));
ACPI_FREE(Path.Pointer);
return ret;
}
default:
return PyErr_Format(PyExc_RuntimeError,
"Unable to parse the ACPI object returned from acpi_object_to_python on unhandled ACPI_OBJECT_TYPE %u.",
obj->Type);
}
}
static void
acpi_notify_handler (ACPI_HANDLE Device,
UINT32 Value,
void *Context)
{
ACPI_BUFFER Path;
ACPI_STATUS Status;
DLOG ("ACPI: acpi_notify_handler (0x%p, 0x%X)\n", Device, Value);
Status = AcpiGetName (Device, ACPI_FULL_PATHNAME, &Path);
if (ACPI_SUCCESS (Status)) {
DLOG (" DeviceName=%s\n", Path.Pointer);
}
}
static void
acpi_util_eval_error(ACPI_HANDLE h, ACPI_STRING p, ACPI_STATUS s)
{
#ifdef ACPI_DEBUG_OUTPUT
char prefix[80] = {'\0'};
ACPI_BUFFER buffer = {sizeof(prefix), prefix};
AcpiGetName(h, ACPI_FULL_PATHNAME, &buffer);
ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluate [%s.%s]: %s\n",
(char *) prefix, p, AcpiFormatException(s)));
#else
return;
#endif
}
bool hasChild(ACPI_HANDLE parent, const char *path) {
ACPI_HANDLE child = nullptr;
while(true) {
ACPI_STATUS status = AcpiGetNextObject(ACPI_TYPE_ANY, parent, child, &child);
if(status == AE_NOT_FOUND)
return false;
ACPICA_CHECK(status);
acpi::ScopedBuffer buffer;
ACPICA_CHECK(AcpiGetName(child, ACPI_SINGLE_NAME, buffer.get()));
if(!strcmp(static_cast<char *>(buffer.data()), path))
return true;
}
}
/**
* radeon_atpx_detect - detect whether we have PX
*
* Check if we have a PX system (all asics).
* Returns true if we have a PX system, false if not.
*/
static bool radeon_atpx_detect(void)
{
char acpi_method_name[255] = { 0 };
ACPI_BUFFER buffer = {sizeof(acpi_method_name), acpi_method_name};
struct pci_dev *pdev = NULL;
bool has_atpx = false;
int vga_count = 0;
while ((pdev = pci_get_class(PCI_CLASS_DISPLAY_VGA << 8, pdev)) != NULL) {
vga_count++;
has_atpx |= (radeon_atpx_pci_probe_handle(pdev) == true);
}
if (has_atpx && vga_count == 2) {
AcpiGetName(radeon_atpx_priv.atpx.handle, ACPI_FULL_PATHNAME, &buffer);
DRM_INFO("VGA switcheroo: detected switching method %s handle\n",
acpi_method_name);
radeon_atpx_priv.atpx_detected = true;
return true;
}
return false;
}
void
AcpiDbDisplayGpes (
void)
{
ACPI_GPE_BLOCK_INFO *GpeBlock;
ACPI_GPE_XRUPT_INFO *GpeXruptInfo;
ACPI_GPE_EVENT_INFO *GpeEventInfo;
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
char *GpeType;
ACPI_GPE_NOTIFY_INFO *Notify;
UINT32 GpeIndex;
UINT32 Block = 0;
UINT32 i;
UINT32 j;
UINT32 Count;
char Buffer[80];
ACPI_BUFFER RetBuf;
ACPI_STATUS Status;
RetBuf.Length = sizeof (Buffer);
RetBuf.Pointer = Buffer;
Block = 0;
/* Walk the GPE lists */
GpeXruptInfo = AcpiGbl_GpeXruptListHead;
while (GpeXruptInfo)
{
GpeBlock = GpeXruptInfo->GpeBlockListHead;
while (GpeBlock)
{
Status = AcpiGetName (GpeBlock->Node,
ACPI_FULL_PATHNAME_NO_TRAILING, &RetBuf);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not convert name to pathname\n");
}
if (GpeBlock->Node == AcpiGbl_FadtGpeDevice)
{
GpeType = "FADT-defined GPE block";
}
else
{
GpeType = "GPE Block Device";
}
AcpiOsPrintf (
"\nBlock %u - Info %p DeviceNode %p [%s] - %s\n",
Block, GpeBlock, GpeBlock->Node, Buffer, GpeType);
AcpiOsPrintf (
" Registers: %u (%u GPEs)\n",
GpeBlock->RegisterCount, GpeBlock->GpeCount);
AcpiOsPrintf (
" GPE range: 0x%X to 0x%X on interrupt %u\n",
GpeBlock->BlockBaseNumber,
GpeBlock->BlockBaseNumber + (GpeBlock->GpeCount - 1),
GpeXruptInfo->InterruptNumber);
AcpiOsPrintf (
" RegisterInfo: %p Status %8.8X%8.8X Enable %8.8X%8.8X\n",
GpeBlock->RegisterInfo,
ACPI_FORMAT_UINT64 (
GpeBlock->RegisterInfo->StatusAddress.Address),
ACPI_FORMAT_UINT64 (
GpeBlock->RegisterInfo->EnableAddress.Address));
AcpiOsPrintf (" EventInfo: %p\n", GpeBlock->EventInfo);
/* Examine each GPE Register within the block */
for (i = 0; i < GpeBlock->RegisterCount; i++)
{
GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
AcpiOsPrintf (
" Reg %u: (GPE %.2X-%.2X) "
"RunEnable %2.2X WakeEnable %2.2X"
" Status %8.8X%8.8X Enable %8.8X%8.8X\n",
i, GpeRegisterInfo->BaseGpeNumber,
GpeRegisterInfo->BaseGpeNumber +
(ACPI_GPE_REGISTER_WIDTH - 1),
GpeRegisterInfo->EnableForRun,
GpeRegisterInfo->EnableForWake,
ACPI_FORMAT_UINT64 (
GpeRegisterInfo->StatusAddress.Address),
ACPI_FORMAT_UINT64 (
GpeRegisterInfo->EnableAddress.Address));
/* Now look at the individual GPEs in this byte register */
for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
{
GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
if (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags) ==
ACPI_GPE_DISPATCH_NONE)
{
/* This GPE is not used (no method or handler), ignore it */
continue;
}
AcpiOsPrintf (
" GPE %.2X: %p RunRefs %2.2X Flags %2.2X (",
GpeBlock->BlockBaseNumber + GpeIndex, GpeEventInfo,
GpeEventInfo->RuntimeCount, GpeEventInfo->Flags);
/* Decode the flags byte */
if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
{
AcpiOsPrintf ("Level, ");
}
else
{
AcpiOsPrintf ("Edge, ");
}
if (GpeEventInfo->Flags & ACPI_GPE_CAN_WAKE)
{
AcpiOsPrintf ("CanWake, ");
}
else
{
AcpiOsPrintf ("RunOnly, ");
}
switch (ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags))
{
case ACPI_GPE_DISPATCH_NONE:
AcpiOsPrintf ("NotUsed");
break;
case ACPI_GPE_DISPATCH_METHOD:
AcpiOsPrintf ("Method");
break;
case ACPI_GPE_DISPATCH_HANDLER:
AcpiOsPrintf ("Handler");
break;
case ACPI_GPE_DISPATCH_NOTIFY:
Count = 0;
Notify = GpeEventInfo->Dispatch.NotifyList;
while (Notify)
{
Count++;
Notify = Notify->Next;
}
AcpiOsPrintf ("Implicit Notify on %u devices",
Count);
break;
case ACPI_GPE_DISPATCH_RAW_HANDLER:
AcpiOsPrintf ("RawHandler");
break;
default:
AcpiOsPrintf ("UNKNOWN: %X",
ACPI_GPE_DISPATCH_TYPE (GpeEventInfo->Flags));
break;
}
AcpiOsPrintf (")\n");
}
}
Block++;
GpeBlock = GpeBlock->Next;
}
GpeXruptInfo = GpeXruptInfo->Next;
}
}
void
AcpiDbDecodeAndDisplayObject (
char *Target,
char *OutputType)
{
void *ObjPtr;
ACPI_NAMESPACE_NODE *Node;
ACPI_OPERAND_OBJECT *ObjDesc;
UINT32 Display = DB_BYTE_DISPLAY;
char Buffer[80];
ACPI_BUFFER RetBuf;
ACPI_STATUS Status;
UINT32 Size;
if (!Target)
{
return;
}
/* Decode the output type */
if (OutputType)
{
AcpiUtStrupr (OutputType);
if (OutputType[0] == 'W')
{
Display = DB_WORD_DISPLAY;
}
else if (OutputType[0] == 'D')
{
Display = DB_DWORD_DISPLAY;
}
else if (OutputType[0] == 'Q')
{
Display = DB_QWORD_DISPLAY;
}
}
RetBuf.Length = sizeof (Buffer);
RetBuf.Pointer = Buffer;
/* Differentiate between a number and a name */
if ((Target[0] >= 0x30) && (Target[0] <= 0x39))
{
ObjPtr = AcpiDbGetPointer (Target);
if (!AcpiOsReadable (ObjPtr, 16))
{
AcpiOsPrintf (
"Address %p is invalid in this address space\n",
ObjPtr);
return;
}
/* Decode the object type */
switch (ACPI_GET_DESCRIPTOR_TYPE (ObjPtr))
{
case ACPI_DESC_TYPE_NAMED:
/* This is a namespace Node */
if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_NAMESPACE_NODE)))
{
AcpiOsPrintf (
"Cannot read entire Named object at address %p\n",
ObjPtr);
return;
}
Node = ObjPtr;
goto DumpNode;
case ACPI_DESC_TYPE_OPERAND:
/* This is a ACPI OPERAND OBJECT */
if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_OPERAND_OBJECT)))
{
AcpiOsPrintf (
"Cannot read entire ACPI object at address %p\n",
ObjPtr);
return;
}
AcpiUtDebugDumpBuffer (ObjPtr, sizeof (ACPI_OPERAND_OBJECT),
Display, ACPI_UINT32_MAX);
AcpiExDumpObjectDescriptor (ObjPtr, 1);
break;
case ACPI_DESC_TYPE_PARSER:
/* This is a Parser Op object */
if (!AcpiOsReadable (ObjPtr, sizeof (ACPI_PARSE_OBJECT)))
{
AcpiOsPrintf (
"Cannot read entire Parser object at address %p\n",
ObjPtr);
return;
}
AcpiUtDebugDumpBuffer (ObjPtr, sizeof (ACPI_PARSE_OBJECT),
Display, ACPI_UINT32_MAX);
AcpiDbDumpParserDescriptor ((ACPI_PARSE_OBJECT *) ObjPtr);
break;
default:
/* Is not a recognizeable object */
AcpiOsPrintf (
"Not a known ACPI internal object, descriptor type %2.2X\n",
ACPI_GET_DESCRIPTOR_TYPE (ObjPtr));
Size = 16;
if (AcpiOsReadable (ObjPtr, 64))
{
Size = 64;
}
/* Just dump some memory */
AcpiUtDebugDumpBuffer (ObjPtr, Size, Display, ACPI_UINT32_MAX);
break;
}
return;
}
/* The parameter is a name string that must be resolved to a Named obj */
Node = AcpiDbLocalNsLookup (Target);
if (!Node)
{
return;
}
DumpNode:
/* Now dump the NS node */
Status = AcpiGetName (Node, ACPI_FULL_PATHNAME_NO_TRAILING, &RetBuf);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not convert name to pathname\n");
}
else
{
AcpiOsPrintf ("Object (%p) Pathname: %s\n",
Node, (char *) RetBuf.Pointer);
}
if (!AcpiOsReadable (Node, sizeof (ACPI_NAMESPACE_NODE)))
{
AcpiOsPrintf ("Invalid Named object at address %p\n", Node);
return;
}
AcpiUtDebugDumpBuffer ((void *) Node, sizeof (ACPI_NAMESPACE_NODE),
Display, ACPI_UINT32_MAX);
AcpiExDumpNamespaceNode (Node, 1);
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
AcpiOsPrintf ("\nAttached Object (%p):\n", ObjDesc);
if (!AcpiOsReadable (ObjDesc, sizeof (ACPI_OPERAND_OBJECT)))
{
AcpiOsPrintf ("Invalid internal ACPI Object at address %p\n",
ObjDesc);
return;
}
AcpiUtDebugDumpBuffer ((void *) ObjDesc,
sizeof (ACPI_OPERAND_OBJECT), Display, ACPI_UINT32_MAX);
AcpiExDumpObjectDescriptor (ObjDesc, 1);
}
}
void
AeMiscellaneousTests (
void)
{
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_STATUS Status;
ACPI_STATISTICS Stats;
ACPI_HANDLE Handle;
#if (!ACPI_REDUCED_HARDWARE)
UINT32 LockHandle1;
UINT32 LockHandle2;
ACPI_VENDOR_UUID Uuid =
{0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
#endif /* !ACPI_REDUCED_HARDWARE */
Status = AcpiGetHandle (NULL, "\\", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
if (AcpiGbl_DoInterfaceTests)
{
/*
* Tests for AcpiLoadTable and AcpiUnloadParentTable
*/
/* Attempt unload of DSDT, should fail */
Status = AcpiGetHandle (NULL, "\\_SB_", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_STATUS (AcpiUnloadParentTable, Status, AE_TYPE);
/* Load and unload SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
Status = AcpiGetHandle (NULL, "\\_T96", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_OK (AcpiUnloadParentTable, Status);
/* Re-load SSDT4 */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt4Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
/* Unload and re-load SSDT2 (SSDT2 is in the XSDT) */
Status = AcpiGetHandle (NULL, "\\_T99", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiUnloadParentTable (Handle);
ACPI_CHECK_OK (AcpiUnloadParentTable, Status);
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt2Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
/* Load OEM9 table (causes table override) */
Status = AcpiLoadTable ((ACPI_TABLE_HEADER *) Ssdt3Code);
ACPI_CHECK_OK (AcpiLoadTable, Status);
}
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
AeMutexInterfaces ();
AeTestSleepData ();
/* Test _OSI install/remove */
Status = AcpiInstallInterface ("");
ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
ACPI_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
ACPI_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
ACPI_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
ACPI_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
ACPI_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
ACPI_CHECK_OK (AcpiInstallInterface, Status);
/* Test _OSI execution */
Status = ExecuteOSI ("Extended Address Space Descriptor", ACPI_UINT64_MAX);
ACPI_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("Windows 2001", ACPI_UINT64_MAX);
ACPI_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
ACPI_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (ACPI_ROOT_OBJECT,
ACPI_FULL_PATHNAME_NO_TRAILING, &ReturnBuf);
ACPI_CHECK_OK (AcpiGetName, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
ACPI_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
ACPI_CHECK_OK (AcpiGetStatistics, Status);
#if (!ACPI_REDUCED_HARDWARE)
Status = AcpiInstallGlobalEventHandler (AeGlobalEventHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGlobalEventHandler, Status);
/* If Hardware Reduced flag is set, we are all done */
if (AcpiGbl_ReducedHardware)
{
return;
}
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
ACPI_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
ACPI_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
ACPI_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
ACPI_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5,
ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiGetHandle (NULL, "\\_SB", &Handle);
ACPI_CHECK_OK (AcpiGetHandle, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 5);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetGpeWakeMask (NULL, 5, ACPI_GPE_ENABLE);
ACPI_CHECK_OK (AcpiSetGpeWakeMask, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 6);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (ACPI_ROOT_OBJECT, NULL, 6);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiSetupGpeForWake (Handle, NULL, 9);
ACPI_CHECK_OK (AcpiSetupGpeForWake, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
/* GPE block 1 */
Status = AcpiInstallGpeHandler (NULL, 101,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
ACPI_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 101);
ACPI_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 101);
ACPI_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
/* Here is where the GPEs are actually "enabled" */
Status = AcpiUpdateAllGpes ();
ACPI_CHECK_OK (AcpiUpdateAllGpes, Status);
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
ACPI_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
ACPI_CHECK_OK (AcpiReleaseGlobalLock, Status);
#endif /* !ACPI_REDUCED_HARDWARE */
}
void
AeMiscellaneousTests (
void)
{
ACPI_HANDLE Handle;
ACPI_BUFFER ReturnBuf;
char Buffer[32];
ACPI_VENDOR_UUID Uuid = {0, {ACPI_INIT_UUID (0,0,0,0,0,0,0,0,0,0,0)}};
ACPI_STATUS Status;
UINT32 LockHandle1;
UINT32 LockHandle2;
ACPI_STATISTICS Stats;
AeHardwareInterfaces ();
AeGenericRegisters ();
AeSetupConfiguration (Ssdt3Code);
AeTestBufferArgument();
AeTestPackageArgument ();
Status = AcpiInstallInterface ("");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_BAD_PARAMETER);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = AcpiInstallInterface ("TestString");
AE_CHECK_STATUS (AcpiInstallInterface, Status, AE_ALREADY_EXISTS);
Status = AcpiRemoveInterface ("Windows 2006");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("TestString");
AE_CHECK_OK (AcpiRemoveInterface, Status);
Status = AcpiRemoveInterface ("XXXXXX");
AE_CHECK_STATUS (AcpiRemoveInterface, Status, AE_NOT_EXIST);
Status = AcpiInstallInterface ("AnotherTestString");
AE_CHECK_OK (AcpiInstallInterface, Status);
Status = ExecuteOSI ("Windows 2001", 0xFFFFFFFF);
AE_CHECK_OK (ExecuteOSI, Status);
Status = ExecuteOSI ("MichiganTerminalSystem", 0);
AE_CHECK_OK (ExecuteOSI, Status);
ReturnBuf.Length = 32;
ReturnBuf.Pointer = Buffer;
Status = AcpiGetName (AcpiGbl_RootNode, ACPI_FULL_PATHNAME, &ReturnBuf);
AE_CHECK_OK (AcpiGetName, Status);
Status = AcpiEnableEvent (ACPI_EVENT_GLOBAL, 0);
AE_CHECK_OK (AcpiEnableEvent, Status);
/*
* GPEs: Handlers, enable/disable, etc.
*/
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiRemoveGpeHandler (NULL, 0, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_DISABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiSetGpe (NULL, 0, ACPI_GPE_ENABLE);
AE_CHECK_OK (AcpiSetGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 1, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 1);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 2, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 2);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 3, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 4, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 5, ACPI_GPE_EDGE_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiInstallGpeHandler (NULL, 0x19, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x19);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiInstallGpeHandler (NULL, 0x62, ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiDisableGpe (NULL, 0x62);
AE_CHECK_OK (AcpiDisableGpe, Status);
AfInstallGpeBlock ();
Status = AcpiGetHandle (NULL, "RSRC", &Handle);
if (ACPI_SUCCESS (Status))
{
ReturnBuf.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiGetVendorResource (Handle, "_CRS", &Uuid, &ReturnBuf);
if (ACPI_SUCCESS (Status))
{
AcpiOsFree (ReturnBuf.Pointer);
}
}
/* Test global lock */
Status = AcpiAcquireGlobalLock (0xFFFF, &LockHandle1);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiAcquireGlobalLock (0x5, &LockHandle2);
AE_CHECK_OK (AcpiAcquireGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle1);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
Status = AcpiReleaseGlobalLock (LockHandle2);
AE_CHECK_OK (AcpiReleaseGlobalLock, Status);
/* Get Devices */
Status = AcpiGetDevices (NULL, AeGetDevices, NULL, NULL);
AE_CHECK_OK (AcpiGetDevices, Status);
Status = AcpiGetStatistics (&Stats);
AE_CHECK_OK (AcpiGetStatistics, Status);
}
} else {
ACPI_DEBUG("No MCFG table found -> no PCIe enhanced configuration\n");
err = b->tx_vtbl.get_pcie_confspace_response(b, NOP_CONT,
ACPI_ERR_NO_MCFG_TABLE, 0, 0, 0, 0);
}
assert(err_is_ok(err));
}
static void get_path_name(ACPI_HANDLE handle, char* name, size_t len)
{
ACPI_BUFFER buf = { .Length = len, .Pointer = name };
ACPI_STATUS s;
s = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf);
assert(ACPI_SUCCESS(s));
}
static void read_irq_table(struct acpi_binding* b, char* pathname,
acpi_pci_address_t addr, uint8_t bus)
{
ACPI_DEBUG("read_irq_table: %s\n", pathname);
errval_t err;
ACPI_STATUS as;
ACPI_HANDLE handle;
as = AcpiGetHandle(NULL, pathname, &handle);
if (ACPI_SUCCESS(as)) {
ACPI_HANDLE child;
void
AcpiDbDisplayGpes (
void)
{
ACPI_GPE_BLOCK_INFO *GpeBlock;
ACPI_GPE_XRUPT_INFO *GpeXruptInfo;
ACPI_GPE_EVENT_INFO *GpeEventInfo;
ACPI_GPE_REGISTER_INFO *GpeRegisterInfo;
UINT32 GpeIndex;
UINT32 Block = 0;
UINT32 i;
UINT32 j;
char Buffer[80];
ACPI_BUFFER RetBuf;
ACPI_STATUS Status;
RetBuf.Length = sizeof (Buffer);
RetBuf.Pointer = Buffer;
Block = 0;
/* Walk the GPE lists */
GpeXruptInfo = AcpiGbl_GpeXruptListHead;
while (GpeXruptInfo)
{
GpeBlock = GpeXruptInfo->GpeBlockListHead;
while (GpeBlock)
{
Status = AcpiGetName (GpeBlock->Node, ACPI_FULL_PATHNAME, &RetBuf);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not convert name to pathname\n");
}
AcpiOsPrintf ("\nBlock %d - Info %p DeviceNode %p [%s]\n",
Block, GpeBlock, GpeBlock->Node, Buffer);
AcpiOsPrintf (" Registers: %u (%u GPEs)\n",
GpeBlock->RegisterCount,
ACPI_MUL_8 (GpeBlock->RegisterCount));
AcpiOsPrintf (" GPE range: 0x%X to 0x%X\n",
GpeBlock->BlockBaseNumber,
GpeBlock->BlockBaseNumber +
(GpeBlock->RegisterCount * 8) -1);
AcpiOsPrintf (
" RegisterInfo: %p Status %8.8X%8.8X Enable %8.8X%8.8X\n",
GpeBlock->RegisterInfo,
ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->StatusAddress.Address),
ACPI_FORMAT_UINT64 (GpeBlock->RegisterInfo->EnableAddress.Address));
AcpiOsPrintf (" EventInfo: %p\n", GpeBlock->EventInfo);
/* Examine each GPE Register within the block */
for (i = 0; i < GpeBlock->RegisterCount; i++)
{
GpeRegisterInfo = &GpeBlock->RegisterInfo[i];
AcpiOsPrintf (
" Reg %u: WakeEnable %2.2X, RunEnable %2.2X Status %8.8X%8.8X Enable %8.8X%8.8X\n",
i, GpeRegisterInfo->EnableForWake,
GpeRegisterInfo->EnableForRun,
ACPI_FORMAT_UINT64 (GpeRegisterInfo->StatusAddress.Address),
ACPI_FORMAT_UINT64 (GpeRegisterInfo->EnableAddress.Address));
/* Now look at the individual GPEs in this byte register */
for (j = 0; j < ACPI_GPE_REGISTER_WIDTH; j++)
{
GpeIndex = (i * ACPI_GPE_REGISTER_WIDTH) + j;
GpeEventInfo = &GpeBlock->EventInfo[GpeIndex];
if (!(GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK))
{
/* This GPE is not used (no method or handler) */
continue;
}
AcpiOsPrintf (
" GPE %.3X: %p Flags %2.2X: ",
GpeBlock->BlockBaseNumber + GpeIndex,
GpeEventInfo,
GpeEventInfo->Flags);
if (GpeEventInfo->Flags & ACPI_GPE_LEVEL_TRIGGERED)
{
AcpiOsPrintf ("Level, ");
}
else
{
AcpiOsPrintf ("Edge, ");
}
switch (GpeEventInfo->Flags & ACPI_GPE_TYPE_MASK)
{
case ACPI_GPE_TYPE_WAKE:
AcpiOsPrintf ("WakeOnly: ");
break;
case ACPI_GPE_TYPE_RUNTIME:
AcpiOsPrintf (" RunOnly: ");
break;
case ACPI_GPE_TYPE_WAKE_RUN:
AcpiOsPrintf (" WakeRun: ");
break;
default:
AcpiOsPrintf (" NotUsed: ");
break;
}
if (GpeEventInfo->Flags & ACPI_GPE_WAKE_ENABLED)
{
AcpiOsPrintf ("[Wake 1 ");
}
else
{
AcpiOsPrintf ("[Wake 0 ");
}
if (GpeEventInfo->Flags & ACPI_GPE_RUN_ENABLED)
{
AcpiOsPrintf ("Run 1], ");
}
else
{
AcpiOsPrintf ("Run 0], ");
}
switch (GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK)
{
case ACPI_GPE_DISPATCH_NOT_USED:
AcpiOsPrintf ("NotUsed");
break;
case ACPI_GPE_DISPATCH_HANDLER:
AcpiOsPrintf ("Handler");
break;
case ACPI_GPE_DISPATCH_METHOD:
AcpiOsPrintf ("Method");
break;
default:
AcpiOsPrintf ("UNKNOWN: %X",
GpeEventInfo->Flags & ACPI_GPE_DISPATCH_MASK);
break;
}
AcpiOsPrintf ("\n");
}
}
Block++;
GpeBlock = GpeBlock->Next;
}
GpeXruptInfo = GpeXruptInfo->Next;
}
}
ACPI_STATUS
DisplayOneDevice (ACPI_HANDLE ObjHandle, UINT32 Level, void *Context,
void **RetVal)
{
ACPI_STATUS Status;
ACPI_DEVICE_INFO *Info;
ACPI_BUFFER Path;
ACPI_BUFFER Result;
ACPI_OBJECT Obj;
char Buffer[256];
uint8 prt_buf[1024];
ACPI_BUFFER Prt = { .Length = sizeof (prt_buf), .Pointer = prt_buf };
ACPI_PCI_ROUTING_TABLE *prtd;
uint32 addr=0;
uint32 fun = 0;
bool pcibus=FALSE;
u8 busnum;
Path.Length = sizeof (Buffer);
Path.Pointer = Buffer;
Status = AcpiGetName (ObjHandle, ACPI_FULL_PATHNAME, &Path);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 ("%s: \n", Path.Pointer);
}
Status = AcpiGetObjectInfo (ObjHandle, &Info);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" ");
if (Info->Flags & ACPI_PCI_ROOT_BRIDGE) {
DLOG_COM1 (" PCI_ROOT");
busnum = 0;
pcibus = TRUE;
}
if (Info->Valid & ACPI_VALID_STA)
DLOG_COM1 (" STA %.8X", Info->CurrentStatus);
if (Info->Valid & ACPI_VALID_ADR) {
DLOG_COM1 (" ADR %.8X", Info->Address);
addr = Info->Address >> 16;
fun = Info->Address & 0x7;
}
if (Info->Valid & ACPI_VALID_HID)
DLOG_COM1 (" HID %s", Info->HardwareId.String);
if (Info->Valid & ACPI_VALID_UID)
DLOG_COM1 (" UID %s", Info->UniqueId.String);
if (Info->Valid & ACPI_VALID_CID)
DLOG_COM1 (" CID");
ACPI_FREE (Info);
}
Result.Length = sizeof (Obj);
Result.Pointer = &Obj;
Status =
AcpiEvaluateObjectTyped (ObjHandle, "_DDN", NULL, &Result,
ACPI_TYPE_STRING);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" DDN=%s", Obj.String.Pointer);
}
Result.Length = sizeof (Obj);
Result.Pointer = &Obj;
Status =
AcpiEvaluateObjectTyped (ObjHandle, "_STR", NULL, &Result,
ACPI_TYPE_STRING);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" STR=%s", Obj.String.Pointer);
}
Result.Length = sizeof (Obj);
Result.Pointer = &Obj;
Status =
AcpiEvaluateObjectTyped (ObjHandle, "_MLS", NULL, &Result,
ACPI_TYPE_STRING);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" MLS=%s", Obj.String.Pointer);
}
Status =
AcpiEvaluateObjectTyped (ObjHandle, "_BBN", NULL, &Result,
ACPI_TYPE_INTEGER);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" BBN=%d", Obj.Integer.Value);
} else if (Status != AE_NOT_FOUND)
DLOG_COM1 (" bbnERR=%d", Status);
Status =
AcpiEvaluateObjectTyped (ObjHandle, "_PXM", NULL, &Result,
ACPI_TYPE_INTEGER);
if (ACPI_SUCCESS (Status)) {
DLOG_COM1 (" PXM=%d", Obj.Integer.Value);
} else if (Status != AE_NOT_FOUND)
DLOG_COM1 (" pxmERR=%d", Status);
DLOG_COM1 ("\n");
for (;;) {
Status = AcpiGetIrqRoutingTable (ObjHandle, &Prt);
if (ACPI_FAILURE (Status)) {
if (Status == AE_BUFFER_OVERFLOW) {
DLOG_COM1 ("AcpiGetIrqRoutingTable failed: BUFFER OVERFLOW\n");
}
break;
} else break;
}
if (ACPI_SUCCESS (Status)) {
int i;
/* Check if ObjHandle refers to a non-root PCI bus */
if (READ (0, addr, fun, 0, dword) != 0xFFFFFFFF) {
u8 hdrtype = READ (0, addr, fun, 0x0E, byte);
if ((hdrtype & 0x7F) == 1) {
/* PCI-to-PCI bridge headerType == 1 */
busnum = READ (0, addr, fun, 0x19, byte);
//busnum = READ (0, addr, fun, 0x1A, byte);
DLOG_COM1 (" bus=0x%.02X\n", busnum);
pcibus = TRUE;
}
}
for (i=0;i<sizeof(prt_buf);) {
pci_irq_t irq;
prtd = (ACPI_PCI_ROUTING_TABLE *)(&prt_buf[i]);
if (prtd->Length == 0) break;
if (pcibus) {
irq.pin = prtd->Pin + 1; /* ACPI numbers pins from 0 */
irq.gsi = 0;
}
if (prtd->Source[0]) {
DLOG_COM1 (" PRT entry: len=%d pin=%d addr=%p srcidx=0x%x src=%s\n",
prtd->Length,
prtd->Pin,
(uint32)prtd->Address,
prtd->SourceIndex,
&prtd->Source[0]);
GetLnkInfo (&prtd->Source[0], &irq);
} else {
DLOG_COM1 (" PRT entry: len=%d pin=%d addr=%p fixed IRQ=0x%x\n",
prtd->Length,
prtd->Pin,
(uint32)prtd->Address,
prtd->SourceIndex);
irq.gsi = prtd->SourceIndex;
irq.polarity = POLARITY_DEFAULT;
irq.trigger = TRIGGER_DEFAULT;
}
if (pcibus && irq.gsi != 0)
pci_irq_register (&irq);
i+=prtd->Length;
}
}
#if 0
ACPI_STATUS DisplayResource (ACPI_RESOURCE *Resource, void *Context);
DLOG_COM1 (" _PRS:\n");
AcpiWalkResources (ObjHandle, "_PRS", DisplayResource, NULL);
DLOG_COM1 (" _CRS:\n");
AcpiWalkResources (ObjHandle, "_CRS", DisplayResource, NULL);
#endif
return AE_OK;
}
