static int
acpi_lid_attach(device_t dev)
{
struct acpi_prw_data prw;
struct acpi_lid_softc *sc;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->lid_dev = dev;
sc->lid_handle = acpi_get_handle(dev);
ACPI_SERIAL_INIT(lid);
/*
* If a system does not get lid events, it may make sense to change
* the type to ACPI_ALL_NOTIFY. Some systems generate both a wake and
* runtime notify in that case though.
*/
AcpiInstallNotifyHandler(sc->lid_handle, ACPI_DEVICE_NOTIFY,
acpi_lid_notify_handler, sc);
/* Enable the GPE for wake/runtime */
acpi_wake_set_enable(dev, 1);
if (acpi_parse_prw(sc->lid_handle, &prw) == 0)
AcpiEnableGpe(prw.gpe_handle, prw.gpe_bit);
return (0);
}
static int
acpi_cmbat_attach(device_t dev)
{
int error;
ACPI_HANDLE handle;
struct acpi_cmbat_softc *sc;
sc = device_get_softc(dev);
handle = acpi_get_handle(dev);
sc->dev = dev;
ACPI_SERIAL_INIT(cmbat);
timespecclear(&sc->bst_lastupdated);
error = acpi_battery_register(dev);
if (error != 0) {
device_printf(dev, "registering battery failed\n");
return (error);
}
/*
* Install a system notify handler in addition to the device notify.
* Toshiba notebook uses this alternate notify for its battery.
*/
AcpiInstallNotifyHandler(handle, ACPI_ALL_NOTIFY,
acpi_cmbat_notify_handler, dev);
AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_cmbat_init_battery, dev);
return (0);
}
int
acpi_battery_register(device_t dev)
{
int error;
error = 0;
ACPI_SERIAL_INIT(battery);
ACPI_SERIAL_BEGIN(battery);
if (!acpi_batteries_initted)
error = acpi_battery_init();
ACPI_SERIAL_END(battery);
return (error);
}
static int
acpi_lid_probe(device_t dev)
{
static char *lid_ids[] = { "PNP0C0D", NULL };
ACPI_SERIAL_INIT(lid);
if (acpi_disabled("lid") ||
ACPI_ID_PROBE(device_get_parent(dev), dev, lid_ids) == NULL)
return (ENXIO);
device_set_desc(dev, "Control Method Lid Switch");
return (0);
}
int
acpi_pcib_attach(device_t dev, ACPI_BUFFER *prt, int busno)
{
device_t child;
ACPI_STATUS status;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
if (!acpi_DeviceIsPresent(dev)) {
/* Caller should already have checked it */
panic("%s device is not present", __func__);
}
ACPI_SERIAL_INIT(pcib);
/*
* Get the PCI interrupt routing table for this bus. If we can't
* get it, this is not an error but may reduce functionality. There
* are several valid bridges in the field that do not have a _PRT, so
* only warn about missing tables if bootverbose is set.
*/
prt->Length = ACPI_ALLOCATE_BUFFER;
status = AcpiGetIrqRoutingTable(acpi_get_handle(dev), prt);
if (ACPI_FAILURE(status) && (bootverbose || status != AE_NOT_FOUND))
device_printf(dev,
"could not get PCI interrupt routing table for %s - %s\n",
acpi_name(acpi_get_handle(dev)), AcpiFormatException(status));
/*
* Attach the PCI bus proper.
*/
if ((child = device_add_child(dev, "pci", busno)) == NULL) {
device_printf(device_get_parent(dev), "couldn't attach pci bus\n");
return_VALUE(ENXIO);
}
/*
* Now go scan the bus.
*/
prt_walk_table(prt, prt_attach_devices, dev);
return_VALUE (bus_generic_attach(dev));
}
static int
acpi_acad_attach(device_t dev)
{
struct acpi_acad_softc *sc;
struct acpi_softc *acpi_sc;
ACPI_HANDLE handle;
int error;
sc = device_get_softc(dev);
handle = acpi_get_handle(dev);
error = acpi_register_ioctl(ACPIIO_ACAD_GET_STATUS, acpi_acad_ioctl, dev);
if (error != 0)
return (error);
ACPI_SERIAL_INIT(acad);
if (device_get_unit(dev) == 0) {
acpi_sc = acpi_device_get_parent_softc(dev);
SYSCTL_ADD_PROC(&acpi_sc->acpi_sysctl_ctx,
SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
OID_AUTO, "acline", CTLTYPE_INT | CTLFLAG_RD,
&sc->status, 0, acpi_acad_sysctl, "I", "");
}
/* Get initial status after whole system is up. */
sc->status = -1;
/*
* Install both system and device notify handlers since the Casio
* FIVA needs them.
*/
AcpiInstallNotifyHandler(handle, ACPI_ALL_NOTIFY,
acpi_acad_notify_handler, dev);
AcpiOsExecute(OSL_NOTIFY_HANDLER, acpi_acad_init_acline, dev);
return (0);
}
static int
acpi_fujitsu_attach(device_t dev)
{
struct acpi_fujitsu_softc *sc;
ACPI_SERIAL_INIT(fujitsu);
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = device_get_softc(dev);
sc->dev = dev;
sc->handle = acpi_get_handle(dev);
/* Install notification handler */
AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
acpi_fujitsu_notify_handler, sc);
/* Snag our default values for the hotkeys / hotkey states. */
ACPI_SERIAL_BEGIN(fujitsu);
if (!acpi_fujitsu_init(sc))
device_printf(dev, "Couldn't initialize hotkey states!\n");
ACPI_SERIAL_END(fujitsu);
return (0);
}
static int
acpi_pci_attach(device_t dev)
{
int busno, domain;
/*
* Since there can be multiple independantly numbered PCI
* busses on systems with multiple PCI domains, we can't use
* the unit number to decide which bus we are probing. We ask
* the parent pcib what our domain and bus numbers are.
*/
busno = pcib_get_bus(dev);
domain = pcib_get_domain(dev);
if (bootverbose) {
device_printf(dev, "domain=%d, physical bus=%d\n",
domain, busno);
}
ACPI_SERIAL_INIT(pci_powerstate);
/*
* First, PCI devices are added as in the normal PCI bus driver.
* Afterwards, the ACPI namespace under the bridge driver is
* walked to save ACPI handles to all the devices that appear in
* the ACPI namespace as immediate descendants of the bridge.
*
* XXX: Sometimes PCI devices show up in the ACPI namespace that
* pci_add_children() doesn't find. We currently just ignore
* these devices.
*/
pci_add_children(dev, domain, busno, sizeof(struct acpi_pci_devinfo));
AcpiWalkNamespace(ACPI_TYPE_DEVICE, acpi_get_handle(dev), 1,
acpi_pci_save_handle, NULL, dev, NULL);
return (bus_generic_attach(dev));
}
static int
acpi_ec_attach(device_t dev)
{
struct acpi_ec_softc *sc;
struct acpi_ec_params *params;
ACPI_STATUS Status;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
/* Fetch/initialize softc (assumes softc is pre-zeroed). */
sc = device_get_softc(dev);
params = acpi_get_private(dev);
sc->ec_dev = dev;
sc->ec_handle = acpi_get_handle(dev);
ACPI_SERIAL_INIT(ec);
/* Retrieve previously probed values via device ivars. */
sc->ec_glk = params->glk;
sc->ec_gpebit = params->gpe_bit;
sc->ec_gpehandle = params->gpe_handle;
sc->ec_uid = params->uid;
sc->ec_suspending = FALSE;
acpi_set_private(dev, NULL);
kfree(params, M_TEMP);
/* Attach bus resources for data and command/status ports. */
sc->ec_data_rid = 0;
sc->ec_data_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
&sc->ec_data_rid, RF_ACTIVE);
if (sc->ec_data_res == NULL) {
device_printf(dev, "can't allocate data port\n");
goto error;
}
sc->ec_data_tag = rman_get_bustag(sc->ec_data_res);
sc->ec_data_handle = rman_get_bushandle(sc->ec_data_res);
sc->ec_csr_rid = 1;
sc->ec_csr_res = bus_alloc_resource_any(sc->ec_dev, SYS_RES_IOPORT,
&sc->ec_csr_rid, RF_ACTIVE);
if (sc->ec_csr_res == NULL) {
device_printf(dev, "can't allocate command/status port\n");
goto error;
}
sc->ec_csr_tag = rman_get_bustag(sc->ec_csr_res);
sc->ec_csr_handle = rman_get_bushandle(sc->ec_csr_res);
/*
* Install a handler for this EC's GPE bit. We want edge-triggered
* behavior.
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching GPE handler\n"));
Status = AcpiInstallGpeHandler(sc->ec_gpehandle, sc->ec_gpebit,
ACPI_GPE_EDGE_TRIGGERED, &EcGpeHandler, sc);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "can't install GPE handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
goto error;
}
/*
* Install address space handler
*/
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "attaching address space handler\n"));
Status = AcpiInstallAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
&EcSpaceHandler, &EcSpaceSetup, sc);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "can't install address space handler for %s - %s\n",
acpi_name(sc->ec_handle), AcpiFormatException(Status));
goto error;
}
/* Enable runtime GPEs for the handler */
Status = AcpiEnableGpe(sc->ec_gpehandle, sc->ec_gpebit);
if (ACPI_FAILURE(Status)) {
device_printf(dev, "AcpiEnableGpe failed: %s\n",
AcpiFormatException(Status));
goto error;
}
ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES, "acpi_ec_attach complete\n"));
return (0);
error:
AcpiRemoveGpeHandler(sc->ec_gpehandle, sc->ec_gpebit, &EcGpeHandler);
AcpiRemoveAddressSpaceHandler(sc->ec_handle, ACPI_ADR_SPACE_EC,
EcSpaceHandler);
if (sc->ec_csr_res)
bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_csr_rid,
sc->ec_csr_res);
if (sc->ec_data_res)
bus_release_resource(sc->ec_dev, SYS_RES_IOPORT, sc->ec_data_rid,
sc->ec_data_res);
return (ENXIO);
}
