static void
AfInstallGpeBlock (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE Handle;
ACPI_HANDLE Handle2 = NULL;
ACPI_HANDLE Handle3 = NULL;
ACPI_GENERIC_ADDRESS BlockAddress;
ACPI_HANDLE GpeDevice;
Status = AcpiGetHandle (NULL, "\\_GPE", &Handle);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_MEMSET (&BlockAddress, 0, sizeof (ACPI_GENERIC_ADDRESS));
BlockAddress.SpaceId = ACPI_ADR_SPACE_SYSTEM_MEMORY;
BlockAddress.Address = 0x76540000;
Status = AcpiGetHandle (NULL, "\\GPE2", &Handle2);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle2, &BlockAddress, 7, 8);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
Status = AcpiInstallGpeHandler (Handle2, 8,
ACPI_GPE_LEVEL_TRIGGERED, AeGpeHandler, NULL);
AE_CHECK_OK (AcpiInstallGpeHandler, Status);
Status = AcpiEnableGpe (Handle2, 8);
AE_CHECK_OK (AcpiEnableGpe, Status);
Status = AcpiGetGpeDevice (0x30, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (0x42, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount-1, &GpeDevice);
AE_CHECK_OK (AcpiGetGpeDevice, Status);
Status = AcpiGetGpeDevice (AcpiCurrentGpeCount, &GpeDevice);
AE_CHECK_STATUS (AcpiGetGpeDevice, Status, AE_NOT_EXIST);
Status = AcpiRemoveGpeHandler (Handle2, 8, AeGpeHandler);
AE_CHECK_OK (AcpiRemoveGpeHandler, Status);
}
Status = AcpiGetHandle (NULL, "\\GPE3", &Handle3);
if (ACPI_SUCCESS (Status))
{
Status = AcpiInstallGpeBlock (Handle3, &BlockAddress, 8, 11);
AE_CHECK_OK (AcpiInstallGpeBlock, Status);
}
}
static void
AcpiDbTestAllObjects (
void)
{
ACPI_STATUS Status;
/* Install the debugger read-object control method if necessary */
if (!ReadHandle)
{
Status = AcpiInstallMethod (ReadMethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install debugger read method\n",
AcpiFormatException (Status));
return;
}
Status = AcpiGetHandle (NULL, ACPI_DB_READ_METHOD, &ReadHandle);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not obtain handle for debug method %s\n",
ACPI_DB_READ_METHOD);
return;
}
}
/* Install the debugger write-object control method if necessary */
if (!WriteHandle)
{
Status = AcpiInstallMethod (WriteMethodCode);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s, Could not install debugger write method\n",
AcpiFormatException (Status));
return;
}
Status = AcpiGetHandle (NULL, ACPI_DB_WRITE_METHOD, &WriteHandle);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not obtain handle for debug method %s\n",
ACPI_DB_WRITE_METHOD);
return;
}
}
/* Walk the entire namespace, testing each supported named data object */
(void) AcpiWalkNamespace (ACPI_TYPE_ANY, ACPI_ROOT_OBJECT,
ACPI_UINT32_MAX, AcpiDbTestOneObject, NULL, NULL, NULL);
}
/*
* Intialize hot plug control for ACPI mode.
*/
static int
pciehpc_acpi_hpc_init(pcie_hp_ctrl_t *ctrl_p)
{
ACPI_HANDLE pcibus_obj;
int status = AE_ERROR;
ACPI_HANDLE slot_dev_obj;
ACPI_HANDLE hdl;
pciehpc_acpi_t *acpi_p;
uint16_t bus_methods = 0;
uint16_t slot_methods = 0;
/* get the ACPI object for the bus node */
status = acpica_get_handle(ctrl_p->hc_dip, &pcibus_obj);
if (status != AE_OK)
return (DDI_FAILURE);
/* get the ACPI object handle for the child node */
status = AcpiGetNextObject(ACPI_TYPE_DEVICE, pcibus_obj,
NULL, &slot_dev_obj);
if (status != AE_OK)
return (DDI_FAILURE);
/*
* gather the info about the ACPI methods present on the bus node
* and the child nodes.
*/
if (AcpiGetHandle(pcibus_obj, "_OSC", &hdl) == AE_OK)
bus_methods |= PCIEHPC_ACPI_OSC_PRESENT;
if (AcpiGetHandle(pcibus_obj, "_OSHP", &hdl) == AE_OK)
bus_methods |= PCIEHPC_ACPI_OSHP_PRESENT;
if (AcpiGetHandle(pcibus_obj, "_HPX", &hdl) == AE_OK)
bus_methods |= PCIEHPC_ACPI_HPX_PRESENT;
if (AcpiGetHandle(pcibus_obj, "_HPP", &hdl) == AE_OK)
bus_methods |= PCIEHPC_ACPI_HPP_PRESENT;
if (AcpiGetHandle(pcibus_obj, "_DSM", &hdl) == AE_OK)
bus_methods |= PCIEHPC_ACPI_DSM_PRESENT;
if (AcpiGetHandle(slot_dev_obj, "_SUN", &hdl) == AE_OK)
slot_methods |= PCIEHPC_ACPI_SUN_PRESENT;
if (AcpiGetHandle(slot_dev_obj, "_PS0", &hdl) == AE_OK)
slot_methods |= PCIEHPC_ACPI_PS0_PRESENT;
if (AcpiGetHandle(slot_dev_obj, "_EJ0", &hdl) == AE_OK)
slot_methods |= PCIEHPC_ACPI_EJ0_PRESENT;
if (AcpiGetHandle(slot_dev_obj, "_STA", &hdl) == AE_OK)
slot_methods |= PCIEHPC_ACPI_STA_PRESENT;
/* save ACPI object handles, etc. */
acpi_p = kmem_zalloc(sizeof (pciehpc_acpi_t), KM_SLEEP);
acpi_p->bus_obj = pcibus_obj;
acpi_p->slot_dev_obj = slot_dev_obj;
acpi_p->bus_methods = bus_methods;
acpi_p->slot_methods = slot_methods;
ctrl_p->hc_misc_data = acpi_p;
return (DDI_SUCCESS);
}
ACPI_HANDLE
acpi_GetReference(ACPI_HANDLE scope, ACPI_OBJECT *obj)
{
ACPI_HANDLE h;
if (obj == NULL)
return (NULL);
switch (obj->Type) {
case ACPI_TYPE_LOCAL_REFERENCE:
case ACPI_TYPE_ANY:
h = obj->Reference.Handle;
break;
case ACPI_TYPE_STRING:
/*
* The String object usually contains a fully-qualified path, so
* scope can be NULL.
*
* XXX This may not always be the case.
*/
if (ACPI_FAILURE(AcpiGetHandle(scope, obj->String.Pointer, &h)))
h = NULL;
break;
default:
h = NULL;
break;
}
return (h);
}
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;
}
/*
* Examines ACPI node for presence of _PRT object
*
* Returns:
* 0 if no _PRT or error
* 1 if _PRT is present
*/
static int
psm_node_has_prt(ACPI_HANDLE *ah)
{
ACPI_HANDLE rh;
return (AcpiGetHandle(ah, "_PRT", &rh) == AE_OK);
}
void
AcpiNsDumpRootDevices (
void)
{
ACPI_HANDLE SysBusHandle;
ACPI_STATUS Status;
ACPI_FUNCTION_NAME (NsDumpRootDevices);
/* Only dump the table if tracing is enabled */
if (!(ACPI_LV_TABLES & AcpiDbgLevel))
{
return;
}
Status = AcpiGetHandle (NULL, METHOD_NAME__SB_, &SysBusHandle);
if (ACPI_FAILURE (Status))
{
return;
}
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES,
"Display of all devices in the namespace:\n"));
Status = AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, SysBusHandle,
ACPI_UINT32_MAX, ACPI_NS_WALK_NO_UNLOCK,
AcpiNsDumpOneDevice, NULL, NULL, NULL);
}
static status_t
acpi_device_init_driver(device_node *node, void **cookie)
{
ACPI_HANDLE handle;
const char *path = NULL;
uint32 type;
if (gDeviceManager->get_attr_uint32(node, ACPI_DEVICE_TYPE_ITEM, &type, false) != B_OK)
return B_ERROR;
gDeviceManager->get_attr_string(node, ACPI_DEVICE_PATH_ITEM, &path, false);
acpi_device_cookie *device = (acpi_device_cookie*)malloc(sizeof(*device));
if (device == NULL)
return B_NO_MEMORY;
memset(device, 0, sizeof(*device));
if (path != NULL && AcpiGetHandle(NULL, (ACPI_STRING)path, &handle) != AE_OK) {
free(device);
return B_ENTRY_NOT_FOUND;
}
device->handle = handle;
device->path = path != NULL ? strdup(path) : NULL;
device->type = type;
device->node = node;
snprintf(device->name, sizeof(device->name), "acpi_device %s", path);
*cookie = device;
return B_OK;
}
/*
* Look for an ECDT and if we find one, set up default GPE and
* space handlers to catch attempts to access EC space before
* we have a real driver instance in place.
*
* TODO: Some old Gateway laptops need us to fake up an ECDT or
* otherwise attach early so that _REG methods can run.
*/
void
acpi_ec_ecdt_probe(device_t parent)
{
ACPI_TABLE_ECDT *ecdt;
ACPI_STATUS status;
device_t child;
ACPI_HANDLE h;
struct acpi_ec_params *params;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
/* Find and validate the ECDT. */
status = AcpiGetTable(ACPI_SIG_ECDT, 1, (ACPI_TABLE_HEADER **)&ecdt);
if (ACPI_FAILURE(status) ||
ecdt->Control.BitWidth != 8 ||
ecdt->Data.BitWidth != 8) {
return;
}
/* Create the child device with the given unit number. */
child = BUS_ADD_CHILD(parent, parent, 0, "acpi_ec", ecdt->Uid);
if (child == NULL) {
kprintf("%s: can't add child\n", __func__);
return;
}
/* Find and save the ACPI handle for this device. */
status = AcpiGetHandle(NULL, ecdt->Id, &h);
if (ACPI_FAILURE(status)) {
device_delete_child(parent, child);
kprintf("%s: can't get handle\n", __func__);
return;
}
acpi_set_handle(child, h);
/* Set the data and CSR register addresses. */
bus_set_resource(child, SYS_RES_IOPORT, 0, ecdt->Data.Address,
/*count*/1, -1);
bus_set_resource(child, SYS_RES_IOPORT, 1, ecdt->Control.Address,
/*count*/1, -1);
/*
* Store values for the probe/attach routines to use. Store the
* ECDT GPE bit and set the global lock flag according to _GLK.
* Note that it is not perfectly correct to be evaluating a method
* before initializing devices, but in practice this function
* should be safe to call at this point.
*/
params = kmalloc(sizeof(struct acpi_ec_params), M_TEMP, M_WAITOK | M_ZERO);
params->gpe_handle = NULL;
params->gpe_bit = ecdt->Gpe;
params->uid = ecdt->Uid;
acpi_GetInteger(h, "_GLK", ¶ms->glk);
acpi_set_private(child, params);
/* Finish the attach process. */
if (device_probe_and_attach(child) != 0)
device_delete_child(parent, child);
}
static int acpi_pci_bind(struct acpi_device *device)
{
ACPI_STATUS status;
ACPI_HANDLE handle;
struct pci_bus *bus;
struct pci_dev *dev;
dev = acpi_get_pci_dev(device->handle);
if (!dev)
return 0;
device->pci_dev = dev;
dev->acpi_dev = device;
dbgprintf("bind ACPI %s PCI_%x_%x\n", device->pnp.bus_id,
dev->vendor, dev->device);
// pci_acpi_add_pm_notifier(device, dev);
// if (device->wakeup.flags.run_wake)
// device_set_run_wake(&dev->dev, true);
/*
* Install the 'bind' function to facilitate callbacks for
* children of the P2P bridge.
*/
if (dev->subordinate) {
ACPI_DEBUG_PRINT((ACPI_DB_INFO,
"Device %04x:%02x:%02x.%d is a PCI bridge\n",
pci_domain_nr(dev->bus), dev->bus->number,
PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)));
device->ops.bind = acpi_pci_bind;
device->ops.unbind = acpi_pci_unbind;
}
/*
* Evaluate and parse _PRT, if exists. This code allows parsing of
* _PRT objects within the scope of non-bridge devices. Note that
* _PRTs within the scope of a PCI bridge assume the bridge's
* subordinate bus number.
*
* TBD: Can _PRTs exist within the scope of non-bridge PCI devices?
*/
status = AcpiGetHandle(device->handle, METHOD_NAME__PRT, &handle);
if (ACPI_FAILURE(status))
goto out;
if (dev->subordinate)
bus = dev->subordinate;
else
bus = dev->bus;
acpi_pci_irq_add_prt(device->handle, bus);
out:
// pci_dev_put(dev);
return 0;
}
static void
AeDoOneOverride (
char *Pathname,
char *ValueString,
ACPI_OPERAND_OBJECT *ObjDesc,
ACPI_WALK_STATE *WalkState)
{
ACPI_HANDLE Handle;
ACPI_STATUS Status;
UINT64 Value;
AcpiOsPrintf ("Value Override: %s, ", Pathname);
/*
* Get the namespace node associated with the override
* pathname from the init file.
*/
Status = AcpiGetHandle (NULL, Pathname, &Handle);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s\n", AcpiFormatException (Status));
return;
}
/* Extract the 64-bit integer */
Status = AcpiUtStrtoul64 (ValueString,
(ACPI_STRTOUL_BASE16 | ACPI_STRTOUL_64BIT), &Value);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s %s\n", ValueString,
AcpiFormatException (Status));
return;
}
ObjDesc->Integer.Value = Value;
/*
* At the point this function is called, the namespace is fully
* built and initialized. We can simply store the new object to
* the target node.
*/
AcpiExEnterInterpreter ();
Status = AcpiExStore (ObjDesc, Handle, WalkState);
AcpiExExitInterpreter ();
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s\n", AcpiFormatException (Status));
return;
}
AcpiOsPrintf ("New value: 0x%8.8X%8.8X\n",
ACPI_FORMAT_UINT64 (Value));
}
void
GetLnkInfo (char *lnkname, pci_irq_t *irq)
{
ACPI_HANDLE Handle;
ACPI_STATUS Status;
Status = AcpiGetHandle (NULL, lnkname, &Handle);
if (ACPI_SUCCESS (Status)) {
AcpiWalkResources (Handle, "_CRS", GetLnkIrq, (void *) irq);
}
}
void
AcpiDbCreateExecutionThread (
char *MethodNameArg,
char **Arguments,
ACPI_OBJECT_TYPE *Types)
{
ACPI_STATUS Status;
UINT32 i;
memset (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
AcpiGbl_DbMethodInfo.Name = MethodNameArg;
AcpiGbl_DbMethodInfo.InitArgs = 1;
AcpiGbl_DbMethodInfo.Args = AcpiGbl_DbMethodInfo.Arguments;
AcpiGbl_DbMethodInfo.Types = AcpiGbl_DbMethodInfo.ArgTypes;
/* Setup method arguments, up to 7 (0-6) */
for (i = 0; (i < ACPI_METHOD_NUM_ARGS) && *Arguments; i++)
{
AcpiGbl_DbMethodInfo.Arguments[i] = *Arguments;
Arguments++;
AcpiGbl_DbMethodInfo.ArgTypes[i] = *Types;
Types++;
}
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
return;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s Could not get handle for %s\n",
AcpiFormatException (Status), AcpiGbl_DbMethodInfo.Pathname);
return;
}
Status = AcpiOsExecute (OSL_DEBUGGER_EXEC_THREAD,
AcpiDbSingleExecutionThread, &AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
return;
}
AcpiOsPrintf ("\nBackground thread started\n");
}
uint32
get_object_type(const char* path)
{
ACPI_HANDLE handle;
ACPI_OBJECT_TYPE type;
if (AcpiGetHandle(NULL, (ACPI_STRING)path, &handle) != AE_OK)
return B_ENTRY_NOT_FOUND;
AcpiGetType(handle, &type);
return type;
}
static void
acpi_dock_eject_children(device_t dev)
{
ACPI_HANDLE sb_handle;
ACPI_STATUS status;
status = AcpiGetHandle(ACPI_ROOT_OBJECT, "\\_SB_", &sb_handle);
if (ACPI_SUCCESS(status)) {
AcpiWalkNamespace(ACPI_TYPE_DEVICE, sb_handle,
100, acpi_dock_eject_child, &dev, NULL);
}
}
/*
*
* If the interrupt link device is already configured,
* stores polarity and sensitivity in the structure pointed to by
* intr_flagp, and irqno in the value pointed to by pci_irqp.
*
* Returns:
* ACPI_PSM_SUCCESS if the interrupt link device is already configured.
* ACPI_PSM_PARTIAL if configuration is needed.
* ACPI_PSM_FAILURE in case of error.
*
* When two devices share the same interrupt link device, and the
* link device is already configured (i.e. found in the irq cache)
* we need to use the already configured irq instead of reconfiguring
* the link device.
*/
static int
acpi_eval_lnk(dev_info_t *dip, char *lnkname, int *pci_irqp,
iflag_t *intr_flagp, acpi_psm_lnk_t *acpipsmlnkp)
{
ACPI_HANDLE tmpobj;
ACPI_HANDLE lnkobj;
int status;
/*
* Convert the passed-in link device name to a handle
*/
if (AcpiGetHandle(NULL, lnkname, &lnkobj) != AE_OK) {
return (ACPI_PSM_FAILURE);
}
/*
* Assume that the link device is invalid if no _CRS method
* exists, since _CRS method is a required method
*/
if (AcpiGetHandle(lnkobj, "_CRS", &tmpobj) != AE_OK) {
return (ACPI_PSM_FAILURE);
}
ASSERT(acpipsmlnkp != NULL);
acpipsmlnkp->lnkobj = lnkobj;
if ((acpi_get_irq_lnk_cache_ent(lnkobj, pci_irqp, intr_flagp)) ==
ACPI_PSM_SUCCESS) {
PSM_VERBOSE_IRQ((CE_CONT, "!psm: link object found from cache "
" for device %s, instance #%d, irq no %d\n",
ddi_get_name(dip), ddi_get_instance(dip), *pci_irqp));
return (ACPI_PSM_SUCCESS);
} else {
if (acpica_eval_int(lnkobj, "_STA", &status) == AE_OK) {
acpipsmlnkp->device_status = (uchar_t)status;
}
return (ACPI_PSM_PARTIAL);
}
}
static ACPI_STATUS
AcpiUtGetMutexObject (
ACPI_HANDLE Handle,
ACPI_STRING Pathname,
ACPI_OPERAND_OBJECT **RetObj)
{
ACPI_NAMESPACE_NODE *MutexNode;
ACPI_OPERAND_OBJECT *MutexObj;
ACPI_STATUS Status;
/* Parameter validation */
if (!RetObj || (!Handle && !Pathname))
{
return (AE_BAD_PARAMETER);
}
/* Get a the namespace node for the mutex */
MutexNode = Handle;
if (Pathname != NULL)
{
Status = AcpiGetHandle (Handle, Pathname,
ACPI_CAST_PTR (ACPI_HANDLE, &MutexNode));
if (ACPI_FAILURE (Status))
{
return (Status);
}
}
/* Ensure that we actually have a Mutex object */
if (!MutexNode ||
(MutexNode->Type != ACPI_TYPE_MUTEX))
{
return (AE_TYPE);
}
/* Get the low-level mutex object */
MutexObj = AcpiNsGetAttachedObject (MutexNode);
if (!MutexObj)
{
return (AE_NULL_OBJECT);
}
*RetObj = MutexObj;
return (AE_OK);
}
int
acpi_psm_init(char *module_name, int verbose_flags)
{
psm_module_name = module_name;
psm_verbose = verbose_flags;
if (AcpiGetHandle(NULL, "\\_SB", &acpi_sbobj) != AE_OK) {
cmn_err(CE_WARN, "!psm: get _SB failed");
return (ACPI_PSM_FAILURE);
}
mutex_init(&acpi_irq_cache_mutex, NULL, MUTEX_DEFAULT, NULL);
return (ACPI_PSM_SUCCESS);
}
/**
* radeon_atpx_pci_probe_handle - look up the ATPX handle
*
* @pdev: pci device
*
* Look up the ATPX handles (all asics).
* Returns true if the handles are found, false if not.
*/
static bool radeon_atpx_pci_probe_handle(struct pci_dev *pdev)
{
ACPI_HANDLE dhandle, atpx_handle;
ACPI_STATUS status;
dhandle = DEVICE_ACPI_HANDLE(&pdev->dev);
if (!dhandle)
return false;
status = AcpiGetHandle(dhandle, "ATPX", &atpx_handle);
if (ACPI_FAILURE(status))
return false;
radeon_atpx_priv.dhandle = dhandle;
radeon_atpx_priv.atpx.handle = atpx_handle;
return true;
}
static bool
thinkpad_resume(device_t dv PMF_FN_ARGS)
{
ACPI_STATUS rv;
ACPI_HANDLE pubs;
rv = AcpiGetHandle(NULL, "\\_SB.PCI0.LPC.EC.PUBS", &pubs);
if (ACPI_FAILURE(rv))
return true; /* not fatal */
rv = AcpiEvaluateObject(pubs, "_ON", NULL, NULL);
if (ACPI_FAILURE(rv))
aprint_error_dev(dv, "failed to execute PUBS._ON: %s\n",
AcpiFormatException(rv));
return true;
}
static int
acpi_dock_probe(device_t dev)
{
ACPI_HANDLE h, tmp;
h = acpi_get_handle(dev);
if (acpi_disabled("dock") ||
ACPI_FAILURE(AcpiGetHandle(h, "_DCK", &tmp)))
return (ENXIO);
device_set_desc(dev, "ACPI Docking Station");
/*
* XXX Somewhere else in the kernel panics on "sysctl kern" if we
* return a negative value here (reprobe ok).
*/
return (0);
}
/*
* fujitsu_hk_cap:
*
* Returns true if and only if (a) the object handle.path exists and
* (b) this object is a method or has the given type.
*/
static bool
fujitsu_hk_cap(ACPI_HANDLE handle, const char *path, ACPI_OBJECT_TYPE type)
{
ACPI_HANDLE hdl;
ACPI_OBJECT_TYPE typ;
KASSERT(handle != NULL);
if (ACPI_FAILURE(AcpiGetHandle(handle, path, &hdl)))
return false;
if (ACPI_FAILURE(AcpiGetType(hdl, &typ)))
return false;
if (typ != ACPI_TYPE_METHOD && typ != type)
return false;
return true;
}
status_t
get_object(const char* path, acpi_object_type** _returnValue)
{
ACPI_HANDLE handle;
ACPI_BUFFER buffer;
ACPI_STATUS status;
status = AcpiGetHandle(NULL, (ACPI_STRING)path, &handle);
if (status != AE_OK)
return B_ENTRY_NOT_FOUND;
buffer.Pointer = NULL;
buffer.Length = ACPI_ALLOCATE_BUFFER;
status = AcpiEvaluateObject(handle, NULL, NULL, &buffer);
*_returnValue = (acpi_object_type*)buffer.Pointer;
return status == AE_OK ? B_OK : B_ERROR;
}
void
AcpiNsDumpRootDevices (void)
{
ACPI_HANDLE SysBusHandle;
PROC_NAME ("NsDumpRootDevices");
/* Only dump the table if tracing is enabled */
if (!(ACPI_LV_TABLES & AcpiDbgLevel))
{
return;
}
AcpiGetHandle (0, NS_SYSTEM_BUS, &SysBusHandle);
ACPI_DEBUG_PRINT ((ACPI_DB_TABLES, "Display of all devices in the namespace:\n"));
AcpiNsWalkNamespace (ACPI_TYPE_DEVICE, SysBusHandle, ACPI_UINT32_MAX, NS_WALK_NO_UNLOCK,
AcpiNsDumpOneDevice, NULL, NULL);
}
static void
prt_attach_devices(ACPI_PCI_ROUTING_TABLE *entry, void *arg)
{
ACPI_HANDLE handle;
device_t child, pcib;
int error;
/* We only care about entries that reference a link device. */
if (entry->Source == NULL || entry->Source[0] == '\0')
return;
/*
* In practice, we only see SourceIndex's of 0 out in the wild.
* When indices != 0 have been found, they've been bugs in the ASL.
*/
if (entry->SourceIndex != 0)
return;
/* Lookup the associated handle and device. */
pcib = (device_t)arg;
if (ACPI_FAILURE(AcpiGetHandle(ACPI_ROOT_OBJECT, entry->Source, &handle)))
return;
child = acpi_get_device(handle);
if (child == NULL)
return;
/* If the device hasn't been probed yet, force it to do so. */
error = device_probe_and_attach(child);
if (error != 0) {
device_printf(pcib, "failed to force attach of %s\n",
acpi_name(handle));
return;
}
/* Add a reference for a specific bus/device/pin tuple. */
acpi_pci_link_add_reference(child, entry->SourceIndex, pcib,
ACPI_ADR_PCI_SLOT(entry->Address), entry->Pin);
}
status_t
get_device_hid(const char *path, char *hid, size_t bufferLength)
{
ACPI_HANDLE handle;
ACPI_DEVICE_INFO *info;
TRACE("get_device_hid: path %s, hid %s\n", path, hid);
if (AcpiGetHandle(NULL, (ACPI_STRING)path, &handle) != AE_OK)
return B_ENTRY_NOT_FOUND;
if (bufferLength < ACPI_DEVICE_ID_LENGTH)
return B_BUFFER_OVERFLOW;
if (AcpiGetObjectInfo(handle, &info) != AE_OK)
return B_BAD_TYPE;
if ((info->Valid & ACPI_VALID_HID) != 0)
strlcpy(hid, info->HardwareId.String, bufferLength);
else
hid[0] = '\0';
AcpiOsFree(info);
return B_OK;
}
static void
AeMutexInterfaces (
void)
{
ACPI_STATUS Status;
ACPI_HANDLE MutexHandle;
/* Get a handle to an AML mutex */
Status = AcpiGetHandle (NULL, "\\MTX1", &MutexHandle);
if (Status == AE_NOT_FOUND)
{
return;
}
ACPI_CHECK_OK (AcpiGetHandle, Status);
if (ACPI_FAILURE (Status))
{
return;
}
/* Acquire the mutex */
Status = AcpiAcquireMutex (NULL, "\\MTX1", 0xFFFF);
ACPI_CHECK_OK (AcpiAcquireMutex, Status);
if (ACPI_FAILURE (Status))
{
return;
}
/* Release mutex with different parameters */
Status = AcpiReleaseMutex (MutexHandle, NULL);
ACPI_CHECK_OK (AcpiReleaseMutex, Status);
}
static PyObject *bits_acpi_get_object_info(PyObject *self, PyObject *args)
{
char *pathname;
ACPI_HANDLE handle = 0;
ACPI_DEVICE_INFO *info = NULL;
PyObject *ret;
ACPI_DEVICE_INFO *addr;
if (!PyArg_ParseTuple(args, "s", &pathname))
return NULL;
if (acpica_init() != GRUB_ERR_NONE)
return PyErr_Format(PyExc_RuntimeError, "ACPICA module failed to initialize.");
if (ACPI_FAILURE(AcpiGetHandle(NULL, pathname, &handle)) || (handle == 0))
return PyErr_Format(PyExc_RuntimeError, "Couldn't get object handle for \"%s\"", pathname);
if (ACPI_FAILURE(AcpiGetObjectInfo(handle, &info)))
return PyErr_Format(PyExc_RuntimeError, "Couldn't get object info for \"%s\"", pathname);
ret = Py_BuildValue("(s#k)", info, info->InfoSize, info);
ACPI_FREE(info);
return ret;
}
void
AcpiDbCreateExecutionThreads (
char *NumThreadsArg,
char *NumLoopsArg,
char *MethodNameArg)
{
ACPI_STATUS Status;
UINT32 NumThreads;
UINT32 NumLoops;
UINT32 i;
UINT32 Size;
ACPI_MUTEX MainThreadGate;
ACPI_MUTEX ThreadCompleteGate;
ACPI_MUTEX InfoGate;
/* Get the arguments */
NumThreads = ACPI_STRTOUL (NumThreadsArg, NULL, 0);
NumLoops = ACPI_STRTOUL (NumLoopsArg, NULL, 0);
if (!NumThreads || !NumLoops)
{
AcpiOsPrintf ("Bad argument: Threads %X, Loops %X\n",
NumThreads, NumLoops);
return;
}
/*
* Create the semaphore for synchronization of
* the created threads with the main thread.
*/
Status = AcpiOsCreateSemaphore (1, 0, &MainThreadGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization with the main thread, %s\n",
AcpiFormatException (Status));
return;
}
/*
* Create the semaphore for synchronization
* between the created threads.
*/
Status = AcpiOsCreateSemaphore (1, 1, &ThreadCompleteGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization between the created threads, %s\n",
AcpiFormatException (Status));
(void) AcpiOsDeleteSemaphore (MainThreadGate);
return;
}
Status = AcpiOsCreateSemaphore (1, 1, &InfoGate);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Could not create semaphore for synchronization of AcpiGbl_DbMethodInfo, %s\n",
AcpiFormatException (Status));
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (MainThreadGate);
return;
}
ACPI_MEMSET (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
/* Array to store IDs of threads */
AcpiGbl_DbMethodInfo.NumThreads = NumThreads;
Size = sizeof (ACPI_THREAD_ID) * AcpiGbl_DbMethodInfo.NumThreads;
AcpiGbl_DbMethodInfo.Threads = AcpiOsAllocate (Size);
if (AcpiGbl_DbMethodInfo.Threads == NULL)
{
AcpiOsPrintf ("No memory for thread IDs array\n");
(void) AcpiOsDeleteSemaphore (MainThreadGate);
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (InfoGate);
return;
}
ACPI_MEMSET (AcpiGbl_DbMethodInfo.Threads, 0, Size);
/* Setup the context to be passed to each thread */
AcpiGbl_DbMethodInfo.Name = MethodNameArg;
AcpiGbl_DbMethodInfo.Flags = 0;
AcpiGbl_DbMethodInfo.NumLoops = NumLoops;
AcpiGbl_DbMethodInfo.MainThreadGate = MainThreadGate;
AcpiGbl_DbMethodInfo.ThreadCompleteGate = ThreadCompleteGate;
AcpiGbl_DbMethodInfo.InfoGate = InfoGate;
/* Init arguments to be passed to method */
AcpiGbl_DbMethodInfo.InitArgs = 1;
AcpiGbl_DbMethodInfo.Args = AcpiGbl_DbMethodInfo.Arguments;
AcpiGbl_DbMethodInfo.Arguments[0] = AcpiGbl_DbMethodInfo.NumThreadsStr;
AcpiGbl_DbMethodInfo.Arguments[1] = AcpiGbl_DbMethodInfo.IdOfThreadStr;
AcpiGbl_DbMethodInfo.Arguments[2] = AcpiGbl_DbMethodInfo.IndexOfThreadStr;
AcpiGbl_DbMethodInfo.Arguments[3] = NULL;
AcpiGbl_DbMethodInfo.Types = AcpiGbl_DbMethodInfo.ArgTypes;
AcpiGbl_DbMethodInfo.ArgTypes[0] = ACPI_TYPE_INTEGER;
AcpiGbl_DbMethodInfo.ArgTypes[1] = ACPI_TYPE_INTEGER;
AcpiGbl_DbMethodInfo.ArgTypes[2] = ACPI_TYPE_INTEGER;
AcpiDbUint32ToHexString (NumThreads, AcpiGbl_DbMethodInfo.NumThreadsStr);
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
goto CleanupAndExit;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("%s Could not get handle for %s\n",
AcpiFormatException (Status), AcpiGbl_DbMethodInfo.Pathname);
goto CleanupAndExit;
}
/* Create the threads */
AcpiOsPrintf ("Creating %X threads to execute %X times each\n",
NumThreads, NumLoops);
for (i = 0; i < (NumThreads); i++)
{
Status = AcpiOsExecute (OSL_DEBUGGER_THREAD, AcpiDbMethodThread,
&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
break;
}
}
/* Wait for all threads to complete */
(void) AcpiOsWaitSemaphore (MainThreadGate, 1, ACPI_WAIT_FOREVER);
AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
AcpiOsPrintf ("All threads (%X) have completed\n", NumThreads);
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
CleanupAndExit:
/* Cleanup and exit */
(void) AcpiOsDeleteSemaphore (MainThreadGate);
(void) AcpiOsDeleteSemaphore (ThreadCompleteGate);
(void) AcpiOsDeleteSemaphore (InfoGate);
AcpiOsFree (AcpiGbl_DbMethodInfo.Threads);
AcpiGbl_DbMethodInfo.Threads = NULL;
}
void
AcpiDbExecute (
char *Name,
char **Args,
ACPI_OBJECT_TYPE *Types,
UINT32 Flags)
{
ACPI_STATUS Status;
ACPI_BUFFER ReturnObj;
char *NameString;
#ifdef ACPI_DEBUG_OUTPUT
UINT32 PreviousAllocations;
UINT32 Allocations;
/* Memory allocation tracking */
PreviousAllocations = AcpiDbGetOutstandingAllocations ();
#endif
if (*Name == '*')
{
(void) AcpiWalkNamespace (ACPI_TYPE_METHOD, ACPI_ROOT_OBJECT,
ACPI_UINT32_MAX, AcpiDbExecutionWalk, NULL, NULL, NULL);
return;
}
else
{
NameString = ACPI_ALLOCATE (ACPI_STRLEN (Name) + 1);
if (!NameString)
{
return;
}
ACPI_MEMSET (&AcpiGbl_DbMethodInfo, 0, sizeof (ACPI_DB_METHOD_INFO));
ACPI_STRCPY (NameString, Name);
AcpiUtStrupr (NameString);
AcpiGbl_DbMethodInfo.Name = NameString;
AcpiGbl_DbMethodInfo.Args = Args;
AcpiGbl_DbMethodInfo.Types = Types;
AcpiGbl_DbMethodInfo.Flags = Flags;
ReturnObj.Pointer = NULL;
ReturnObj.Length = ACPI_ALLOCATE_BUFFER;
Status = AcpiDbExecuteSetup (&AcpiGbl_DbMethodInfo);
if (ACPI_FAILURE (Status))
{
ACPI_FREE (NameString);
return;
}
/* Get the NS node, determines existence also */
Status = AcpiGetHandle (NULL, AcpiGbl_DbMethodInfo.Pathname,
&AcpiGbl_DbMethodInfo.Method);
if (ACPI_SUCCESS (Status))
{
Status = AcpiDbExecuteMethod (&AcpiGbl_DbMethodInfo, &ReturnObj);
}
ACPI_FREE (NameString);
}
/*
* Allow any handlers in separate threads to complete.
* (Such as Notify handlers invoked from AML executed above).
*/
AcpiOsSleep ((UINT64) 10);
#ifdef ACPI_DEBUG_OUTPUT
/* Memory allocation tracking */
Allocations = AcpiDbGetOutstandingAllocations () - PreviousAllocations;
AcpiDbSetOutputDestination (ACPI_DB_DUPLICATE_OUTPUT);
if (Allocations > 0)
{
AcpiOsPrintf ("0x%X Outstanding allocations after evaluation of %s\n",
Allocations, AcpiGbl_DbMethodInfo.Pathname);
}
#endif
if (ACPI_FAILURE (Status))
{
AcpiOsPrintf ("Evaluation of %s failed with status %s\n",
AcpiGbl_DbMethodInfo.Pathname, AcpiFormatException (Status));
}
else
{
/* Display a return object, if any */
if (ReturnObj.Length)
{
AcpiOsPrintf (
"Evaluation of %s returned object %p, external buffer length %X\n",
AcpiGbl_DbMethodInfo.Pathname, ReturnObj.Pointer,
(UINT32) ReturnObj.Length);
AcpiDbDumpExternalObject (ReturnObj.Pointer, 1);
/* Dump a _PLD buffer if present */
if (ACPI_COMPARE_NAME ((ACPI_CAST_PTR (ACPI_NAMESPACE_NODE,
AcpiGbl_DbMethodInfo.Method)->Name.Ascii), METHOD_NAME__PLD))
{
AcpiDbDumpPldBuffer (ReturnObj.Pointer);
}
}
else
{
AcpiOsPrintf ("No object was returned from evaluation of %s\n",
AcpiGbl_DbMethodInfo.Pathname);
}
}
AcpiDbSetOutputDestination (ACPI_DB_CONSOLE_OUTPUT);
}