void
aps_power(int why, void *arg)
{
struct aps_softc *sc = (struct aps_softc *)arg;
bus_space_tag_t iot = sc->aps_iot;
bus_space_handle_t ioh = sc->aps_ioh;
unsigned char iobuf[16];
if (why != PWR_RESUME) {
timeout_del(&aps_timeout);
return;
}
/*
* Redo the init sequence on resume, because APS is
* as forgetful as it is deaf.
*/
/* get APS mode */
iobuf[APS_CMD] = 0x13;
if (aps_do_io(iot, ioh, iobuf, APS_WRITE_0, APS_READ_1)
|| aps_init(iot, ioh))
printf("aps: failed to wake up\n");
else
timeout_add(&aps_timeout, (5 * hz) / 10);
}
void freakz_init()
{
drvr_init();
mmem_init();
ctimer_init();
mac_init();
nwk_init();
aps_init();
af_init();
zdo_init();
buf_init();
slow_clock_init();
#if (TEST_SIM == 1)
test_app_init();
#endif
}
static int
aps_resume(struct device *dev)
{
struct aps_softc *sc = device_get_softc(dev);
unsigned char iobuf[16];
/*
* Redo the init sequence on resume, because APS is
* as forgetful as it is deaf.
*/
/* get APS mode */
iobuf[APS_CMD] = 0x13;
if (aps_do_io(sc->sc_iores, iobuf, APS_WRITE_0, APS_READ_1)
|| aps_init(sc->sc_iores)) {
device_printf(sc->sc_dev, "failed to wake up\n");
return EIO;
}
sensor_task_register(sc, aps_refresh, 1);
return 0;
}
static bool
aps_resume(device_t dv PMF_FN_ARGS)
{
struct aps_softc *sc = device_private(dv);
/*
* Redo the init sequence on resume, because APS is
* as forgetful as it is deaf.
*/
bus_space_write_1(sc->sc_iot, sc->sc_ioh, APS_INIT, 0x13);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, APS_CMD, 0x01);
bus_space_read_1(sc->sc_iot, sc->sc_ioh, APS_CMD);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, APS_INIT, 0x13);
bus_space_write_1(sc->sc_iot, sc->sc_ioh, APS_CMD, 0x01);
if (aps_mem_read_1(sc->sc_iot, sc->sc_ioh, APS_CMD, 0x00) &&
aps_init(sc))
callout_schedule(&sc->sc_callout, (hz) / 2);
else
aprint_error_dev(dv, "failed to wake up\n");
return true;
}
void
aps_attach(struct device *parent, struct device *self, void *aux)
{
struct aps_softc *sc = (void *)self;
int iobase, i;
bus_space_tag_t iot;
bus_space_handle_t ioh;
struct isa_attach_args *ia = aux;
iobase = ia->ipa_io[0].base;
iot = sc->aps_iot = ia->ia_iot;
if (bus_space_map(iot, iobase, APS_ADDR_SIZE, 0, &sc->aps_ioh)) {
printf(": can't map i/o space\n");
return;
}
ioh = sc->aps_ioh;
printf("\n");
if (aps_init(iot, ioh))
goto out;
sc->sensors[APS_SENSOR_XACCEL].type = SENSOR_INTEGER;
snprintf(sc->sensors[APS_SENSOR_XACCEL].desc,
sizeof(sc->sensors[APS_SENSOR_XACCEL].desc), "X_ACCEL");
sc->sensors[APS_SENSOR_YACCEL].type = SENSOR_INTEGER;
snprintf(sc->sensors[APS_SENSOR_YACCEL].desc,
sizeof(sc->sensors[APS_SENSOR_YACCEL].desc), "Y_ACCEL");
sc->sensors[APS_SENSOR_TEMP1].type = SENSOR_TEMP;
sc->sensors[APS_SENSOR_TEMP2].type = SENSOR_TEMP;
sc->sensors[APS_SENSOR_XVAR].type = SENSOR_INTEGER;
snprintf(sc->sensors[APS_SENSOR_XVAR].desc,
sizeof(sc->sensors[APS_SENSOR_XVAR].desc), "X_VAR");
sc->sensors[APS_SENSOR_YVAR].type = SENSOR_INTEGER;
snprintf(sc->sensors[APS_SENSOR_YVAR].desc,
sizeof(sc->sensors[APS_SENSOR_YVAR].desc), "Y_VAR");
sc->sensors[APS_SENSOR_KBACT].type = SENSOR_INDICATOR;
snprintf(sc->sensors[APS_SENSOR_KBACT].desc,
sizeof(sc->sensors[APS_SENSOR_KBACT].desc), "Keyboard Active");
sc->sensors[APS_SENSOR_MSACT].type = SENSOR_INDICATOR;
snprintf(sc->sensors[APS_SENSOR_MSACT].desc,
sizeof(sc->sensors[APS_SENSOR_MSACT].desc), "Mouse Active");
sc->sensors[APS_SENSOR_LIDOPEN].type = SENSOR_INDICATOR;
snprintf(sc->sensors[APS_SENSOR_LIDOPEN].desc,
sizeof(sc->sensors[APS_SENSOR_LIDOPEN].desc), "Lid Open");
/* stop hiding and report to the authorities */
strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sensordev.xname));
for (i = 0; i < APS_NUM_SENSORS ; i++) {
sensor_attach(&sc->sensordev, &sc->sensors[i]);
}
sensordev_install(&sc->sensordev);
powerhook_establish(aps_power, (void *)sc);
/* Refresh sensor data every 0.5 seconds */
timeout_set(&aps_timeout, aps_refresh, sc);
timeout_add(&aps_timeout, (5 * hz) / 10);
return;
out:
printf("%s: failed to initialize\n", sc->sc_dev.dv_xname);
return;
}
static int
aps_attach(struct device *dev)
{
struct aps_softc *sc = device_get_softc(dev);
sc->sc_dev = dev;
sc->sc_iores = bus_alloc_resource_any(dev, SYS_RES_IOPORT,
&sc->sc_iorid, RF_ACTIVE);
if (sc->sc_iores == NULL) {
device_printf(dev, "can't map i/o space\n");
return ENXIO;
}
if (aps_init(sc->sc_iores)) {
device_printf(dev, "failed to initialise\n");
bus_release_resource(dev, SYS_RES_IOPORT, sc->sc_iorid, sc->sc_iores);
return ENXIO;
}
sc->sensors[APS_SENSOR_XACCEL].type = SENSOR_INTEGER;
ksnprintf(sc->sensors[APS_SENSOR_XACCEL].desc,
sizeof(sc->sensors[APS_SENSOR_XACCEL].desc), "X_ACCEL");
sc->sensors[APS_SENSOR_YACCEL].type = SENSOR_INTEGER;
ksnprintf(sc->sensors[APS_SENSOR_YACCEL].desc,
sizeof(sc->sensors[APS_SENSOR_YACCEL].desc), "Y_ACCEL");
sc->sensors[APS_SENSOR_TEMP1].type = SENSOR_TEMP;
sc->sensors[APS_SENSOR_TEMP2].type = SENSOR_TEMP;
sc->sensors[APS_SENSOR_XVAR].type = SENSOR_INTEGER;
ksnprintf(sc->sensors[APS_SENSOR_XVAR].desc,
sizeof(sc->sensors[APS_SENSOR_XVAR].desc), "X_VAR");
sc->sensors[APS_SENSOR_YVAR].type = SENSOR_INTEGER;
ksnprintf(sc->sensors[APS_SENSOR_YVAR].desc,
sizeof(sc->sensors[APS_SENSOR_YVAR].desc), "Y_VAR");
sc->sensors[APS_SENSOR_KBACT].type = SENSOR_INDICATOR;
ksnprintf(sc->sensors[APS_SENSOR_KBACT].desc,
sizeof(sc->sensors[APS_SENSOR_KBACT].desc), "Keyboard Active");
sc->sensors[APS_SENSOR_MSACT].type = SENSOR_INDICATOR;
ksnprintf(sc->sensors[APS_SENSOR_MSACT].desc,
sizeof(sc->sensors[APS_SENSOR_MSACT].desc), "Mouse Active");
sc->sensors[APS_SENSOR_LIDOPEN].type = SENSOR_INDICATOR;
ksnprintf(sc->sensors[APS_SENSOR_LIDOPEN].desc,
sizeof(sc->sensors[APS_SENSOR_LIDOPEN].desc), "Lid Open");
/* stop hiding and report to the authorities */
strlcpy(sc->sensordev.xname, device_get_nameunit(dev),
sizeof(sc->sensordev.xname));
for (int i = 0; i < APS_NUM_SENSORS ; i++)
sensor_attach(&sc->sensordev, &sc->sensors[i]);
/* Refresh sensor data every 1 second */
/* XXX: a more frequent refresh might be appropriate */
if (sensor_task_register(sc, aps_refresh, 1)) {
device_printf(dev, "unable to register update task\n");
bus_release_resource(dev, SYS_RES_IOPORT, sc->sc_iorid, sc->sc_iores);
return ENXIO;
}
sensordev_install(&sc->sensordev);
return 0;
}
static void
aps_attach(device_t parent, device_t self, void *aux)
{
struct aps_softc *sc = device_private(self);
struct isa_attach_args *ia = aux;
int iobase, i;
sc->sc_iot = ia->ia_iot;
iobase = ia->ia_io[0].ir_addr;
if (bus_space_map(sc->sc_iot, iobase, APS_ADDR_SIZE, 0, &sc->sc_ioh)) {
aprint_error(": can't map i/o space\n");
return;
}
aprint_naive("\n");
aprint_normal("\n");
if (!aps_init(sc)) {
aprint_error_dev(self, "failed to initialise\n");
goto out;
}
/* Initialize sensors */
#define INITDATA(idx, unit, string) \
sc->sc_sensor[idx].units = unit; \
strlcpy(sc->sc_sensor[idx].desc, string, \
sizeof(sc->sc_sensor[idx].desc));
INITDATA(APS_SENSOR_XACCEL, ENVSYS_INTEGER, "X_ACCEL");
INITDATA(APS_SENSOR_YACCEL, ENVSYS_INTEGER, "Y_ACCEL");
INITDATA(APS_SENSOR_TEMP1, ENVSYS_STEMP, "TEMP_1");
INITDATA(APS_SENSOR_TEMP2, ENVSYS_STEMP, "TEMP_2");
INITDATA(APS_SENSOR_XVAR, ENVSYS_INTEGER, "X_VAR");
INITDATA(APS_SENSOR_YVAR, ENVSYS_INTEGER, "Y_VAR");
INITDATA(APS_SENSOR_KBACT, ENVSYS_INDICATOR, "Keyboard Active");
INITDATA(APS_SENSOR_MSACT, ENVSYS_INDICATOR, "Mouse Active");
INITDATA(APS_SENSOR_LIDOPEN, ENVSYS_INDICATOR, "Lid Open");
sc->sc_sme = sysmon_envsys_create();
for (i = 0; i < APS_NUM_SENSORS; i++) {
sc->sc_sensor[i].state = ENVSYS_SVALID;
if (sysmon_envsys_sensor_attach(sc->sc_sme,
&sc->sc_sensor[i])) {
sysmon_envsys_destroy(sc->sc_sme);
goto out;
}
}
/*
* Register with the sysmon_envsys(9) framework.
*/
sc->sc_sme->sme_name = device_xname(self);
sc->sc_sme->sme_flags = SME_DISABLE_REFRESH;
if ((i = sysmon_envsys_register(sc->sc_sme))) {
aprint_error_dev(self,
"unable to register with sysmon (%d)\n", i);
sysmon_envsys_destroy(sc->sc_sme);
goto out;
}
if (!pmf_device_register(self, aps_suspend, aps_resume))
aprint_error_dev(self, "couldn't establish power handler\n");
/* Refresh sensor data every 0.5 seconds */
callout_init(&sc->sc_callout, 0);
callout_setfunc(&sc->sc_callout, aps_refresh, sc);
callout_schedule(&sc->sc_callout, (hz) / 2);
aprint_normal_dev(self, "Thinkpad Active Protection System\n");
return;
out:
bus_space_unmap(sc->sc_iot, sc->sc_ioh, APS_ADDR_SIZE);
}