static int
aibs_attach(struct device *dev)
{
struct aibs_softc *sc;
sc = device_get_softc(dev);
sc->sc_dev = dev;
sc->sc_ah = acpi_get_handle(dev);
strlcpy(sc->sc_sensordev.xname, device_get_nameunit(dev),
sizeof(sc->sc_sensordev.xname));
aibs_attach_sif(sc, SENSOR_VOLTS_DC);
aibs_attach_sif(sc, SENSOR_TEMP);
aibs_attach_sif(sc, SENSOR_FANRPM);
if (sc->sc_sensordev.sensors_count == 0) {
device_printf(dev, "no sensors found\n");
return ENXIO;
}
sensor_task_register(sc, aibs_refresh, 5);
sensordev_install(&sc->sc_sensordev);
return 0;
}
void
asmc_attach(struct device *parent, struct device *self, void *aux)
{
struct asmc_softc *sc = (struct asmc_softc *)self;
struct isa_attach_args *ia = aux;
if (bus_space_map(ia->ia_iot, ia->ia_iobase, ia->ia_iosize, 0,
&sc->sc_ioh)) {
printf(": can't map i/o space\n");
return;
}
sc->sc_iot = ia->ia_iot;
printf("\n");
strlcpy(sc->sc_sensor_dev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensor_dev.xname));
if (asmc_init(sc)) {
printf("%s: unable to initialize\n", sc->sc_dev.dv_xname);
bus_space_unmap(ia->ia_iot, ia->ia_iobase, ASMC_IOSIZE);
return;
}
if (!(sc->sc_sensor_task = sensor_task_register(sc, asmc_update, 8))) {
printf("%s: unable to register task\n", sc->sc_dev.dv_xname);
bus_space_unmap(ia->ia_iot, ia->ia_iobase, ASMC_IOSIZE);
return;
}
sensordev_install(&sc->sc_sensor_dev);
}
void
lm_attach(struct lm_softc *sc)
{
u_int i, config;
for (i = 0; i < sizeof(lm_chips) / sizeof(lm_chips[0]); i++)
if (lm_chips[i].chip_match(sc))
break;
/* No point in doing anything if we don't have any sensors. */
if (sc->numsensors == 0)
return;
if (sensor_task_register(sc, lm_refresh, 5)) {
printf("%s: unable to register update task\n",
sc->sc_dev.dv_xname);
return;
}
/* Start the monitoring loop */
config = sc->lm_readreg(sc, LM_CONFIG);
sc->lm_writereg(sc, LM_CONFIG, config | 0x01);
/* Add sensors */
for (i = 0; i < sc->numsensors; ++i)
sensor_attach(&sc->sensordev, &sc->sensors[i]);
sensordev_install(&sc->sensordev);
}
void
owctr_attach(struct device *parent, struct device *self, void *aux)
{
struct owctr_softc *sc = (struct owctr_softc *)self;
struct onewire_attach_args *oa = aux;
sc->sc_onewire = oa->oa_onewire;
sc->sc_rom = oa->oa_rom;
/* Initialize counter sensors */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_counterA.type = SENSOR_INTEGER;
snprintf(sc->sc_counterA.desc, sizeof(sc->sc_counterA.desc),
"Counter A sn %012llx", ONEWIRE_ROM_SN(oa->oa_rom));
sensor_attach(&sc->sc_sensordev, &sc->sc_counterA);
sc->sc_counterB.type = SENSOR_INTEGER;
snprintf(sc->sc_counterB.desc, sizeof(sc->sc_counterB.desc),
"Counter B sn %012llx", ONEWIRE_ROM_SN(oa->oa_rom));
sensor_attach(&sc->sc_sensordev, &sc->sc_counterB);
sc->sc_sensortask = sensor_task_register(sc, owctr_update, 10);
if (sc->sc_sensortask == NULL) {
printf(": unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
rw_init(&sc->sc_lock, sc->sc_dev.dv_xname);
printf("\n");
}
void
acpibat_monitor(struct acpibat_softc *sc)
{
int type;
/* assume _BIF and _BST have been called */
strlcpy(sc->sc_sensdev.xname, DEVNAME(sc),
sizeof(sc->sc_sensdev.xname));
type = sc->sc_bif.bif_power_unit ? SENSOR_AMPHOUR : SENSOR_WATTHOUR;
strlcpy(sc->sc_sens[0].desc, "last full capacity",
sizeof(sc->sc_sens[0].desc));
sc->sc_sens[0].type = type;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[0]);
sc->sc_sens[0].value = sc->sc_bif.bif_last_capacity * 1000;
strlcpy(sc->sc_sens[1].desc, "warning capacity",
sizeof(sc->sc_sens[1].desc));
sc->sc_sens[1].type = type;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[1]);
sc->sc_sens[1].value = sc->sc_bif.bif_warning * 1000;
strlcpy(sc->sc_sens[2].desc, "low capacity",
sizeof(sc->sc_sens[2].desc));
sc->sc_sens[2].type = type;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[2]);
sc->sc_sens[2].value = sc->sc_bif.bif_low * 1000;
strlcpy(sc->sc_sens[3].desc, "voltage", sizeof(sc->sc_sens[3].desc));
sc->sc_sens[3].type = SENSOR_VOLTS_DC;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[3]);
sc->sc_sens[3].value = sc->sc_bif.bif_voltage * 1000;
strlcpy(sc->sc_sens[4].desc, "battery unknown",
sizeof(sc->sc_sens[4].desc));
sc->sc_sens[4].type = SENSOR_INTEGER;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[4]);
sc->sc_sens[4].value = sc->sc_bst.bst_state;
strlcpy(sc->sc_sens[5].desc, "rate", sizeof(sc->sc_sens[5].desc));
sc->sc_sens[5].type =
sc->sc_bif.bif_power_unit ? SENSOR_AMPS : SENSOR_WATTS;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[5]);
sc->sc_sens[5].value = sc->sc_bst.bst_rate * 1000;
strlcpy(sc->sc_sens[6].desc, "remaining capacity",
sizeof(sc->sc_sens[6].desc));
sc->sc_sens[6].type = type;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[6]);
sc->sc_sens[6].value = sc->sc_bst.bst_capacity * 1000;
strlcpy(sc->sc_sens[7].desc, "current voltage",
sizeof(sc->sc_sens[7].desc));
sc->sc_sens[7].type = SENSOR_VOLTS_DC;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[7]);
sc->sc_sens[7].value = sc->sc_bst.bst_voltage * 1000;
sensordev_install(&sc->sc_sensdev);
}
void
sdtemp_attach(struct device *parent, struct device *self, void *aux)
{
struct sdtemp_softc *sc = (struct sdtemp_softc *)self;
struct i2c_attach_args *ia = aux;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
printf(": %s", ia->ia_name);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[JCTEMP_TEMP].type = SENSOR_TEMP;
if (sensor_task_register(sc, sdtemp_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[0]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
aibs_attach(struct device *parent, struct device *self, void *aux)
{
struct aibs_softc *sc = (struct aibs_softc *)self;
struct acpi_attach_args *aa = aux;
sc->sc_acpi = (struct acpi_softc *)parent;
sc->sc_devnode = aa->aaa_node;
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
SIMPLEQ_INIT(&sc->sc_sensorlist);
aibs_probe(sc);
printf("\n");
if (sc->sc_mode)
aibs_attach_new(sc);
else {
aibs_attach_sif(sc, SENSOR_TEMP);
aibs_attach_sif(sc, SENSOR_FANRPM);
aibs_attach_sif(sc, SENSOR_VOLTS_DC);
}
if (sc->sc_sensordev.sensors_count == 0) {
printf("%s: no sensors found\n", DEVNAME(sc));
return;
}
sensordev_install(&sc->sc_sensordev);
aml_register_notify(sc->sc_devnode, aa->aaa_dev,
aibs_notify, sc, ACPIDEV_POLL);
}
void
lisa_attach(struct device *parent, struct device *self, void *aux)
{
struct lisa_softc *sc = (struct lisa_softc *)self;
struct i2c_attach_args *ia = aux;
int i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
printf(": %s", ia->ia_name);
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < LISA_NUM_AXIS; i++) {
strlcpy(sc->sc_sensors[i].desc, lisa_axis[i].name,
sizeof(sc->sc_sensors[i].desc));
sc->sc_sensors[i].type = SENSOR_INTEGER;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]);
}
if (sensor_task_register(sc, lisa_refresh, 1) == NULL) {
printf(", unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
utwitch_attach(struct device *parent, struct device *self, void *aux)
{
struct utwitch_softc *sc = (struct utwitch_softc *)self;
struct usb_attach_arg *uaa = aux;
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
struct usbd_device *dev = uha->parent->sc_udev;
int size, repid, err;
void *desc;
sc->sc_udev = dev;
sc->sc_hdev.sc_intr = utwitch_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
uhidev_get_report_desc(uha->parent, &desc, &size);
repid = uha->reportid;
sc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
sc->sc_olen = hid_report_size(desc, size, hid_output, repid);
sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
err = uhidev_open(&sc->sc_hdev);
if (err) {
printf("utwitch_open: uhidev_open %d\n", err);
return;
}
sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
printf("\n");
/* attach sensor */
strlcpy(sc->sc_sensordev.xname, sc->sc_hdev.sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
/* add BBU sensor */
sc->sc_sensor_val.type = SENSOR_INTEGER;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor_val);
strlcpy(sc->sc_sensor_val.desc, "BBU",
sizeof(sc->sc_sensor_val.desc));
/* add BBU delta sensor */
sc->sc_sensor_delta.type = SENSOR_INTEGER;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor_delta);
strlcpy(sc->sc_sensor_delta.desc, "mBBU/sec",
sizeof(sc->sc_sensor_delta.desc));
sc->sc_sensortask = sensor_task_register(sc, utwitch_refresh, UPDATE_TICK);
if (sc->sc_sensortask == NULL) {
printf(", unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
DPRINTF(("utwitch_attach: complete\n"));
/* init device */ /* XXX */
utwitch_set_mode(sc, 0);
}
void
safte_attach(struct device *parent, struct device *self, void *aux)
{
struct safte_softc *sc = (struct safte_softc *)self;
struct scsi_attach_args *sa = aux;
int i = 0;
sc->sc_link = sa->sa_sc_link;
sa->sa_sc_link->device_softc = sc;
rw_init(&sc->sc_lock, DEVNAME(sc));
printf("\n");
sc->sc_encbuf = NULL;
sc->sc_nsensors = 0;
#if NBIO > 0
sc->sc_nslots = 0;
#endif
if (safte_read_config(sc) != 0) {
printf("%s: unable to read enclosure configuration\n",
DEVNAME(sc));
return;
}
if (sc->sc_nsensors > 0) {
sc->sc_sensortask = sensor_task_register(sc,
safte_read_encstat, 10);
if (sc->sc_sensortask == NULL) {
printf("%s: unable to register update task\n",
DEVNAME(sc));
sc->sc_nsensors = sc->sc_ntemps = 0;
free(sc->sc_sensors, M_DEVBUF);
} else {
for (i = 0; i < sc->sc_nsensors; i++)
sensor_attach(&sc->sc_sensordev,
&sc->sc_sensors[i].se_sensor);
sensordev_install(&sc->sc_sensordev);
}
}
#if NBIO > 0
if (sc->sc_nslots > 0 &&
bio_register(self, safte_ioctl) != 0) {
printf("%s: unable to register ioctl with bio\n", DEVNAME(sc));
sc->sc_nslots = 0;
} else
i++;
#endif
if (i) /* if we're doing something, then preinit encbuf and sensors */
safte_read_encstat(sc);
else {
free(sc->sc_encbuf, M_DEVBUF);
sc->sc_encbuf = NULL;
}
}
void
ykbec_attach(device_t parent, device_t self, void *aux)
{
struct isa_attach_args *ia = aux;
struct ykbec_softc *sc = device_private(self);
int i;
sc->sc_iot = ia->ia_iot;
if (bus_space_map(sc->sc_iot, ia->ia_iobase, ia->ia_iosize, 0,
&sc->sc_ioh)) {
aprint_error(": couldn't map I/O space");
return;
}
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, device_xname(self),
sizeof(sc->sc_sensordev.xname));
if (sensor_task_register(sc, ykbec_refresh, 5) == NULL) {
aprint_error(", unable to register update task\n");
return;
}
#ifdef DEBUG
ykbec_print_bat_info(sc);
#endif
aprint_normal("\n");
for (i = 0; i < YKBEC_NSENSORS; i++) {
sc->sc_sensor[i].type = ykbec_table[i].type;
if (ykbec_table[i].desc)
strlcpy(sc->sc_sensor[i].desc, ykbec_table[i].desc,
sizeof(sc->sc_sensor[i].desc));
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
}
sensordev_install(&sc->sc_sensordev);
#if NAPM > 0
/* make sure we have the apm state initialized before apm attaches */
ykbec_refresh(sc);
apm_setinfohook(ykbec_apminfo);
#endif
#if NPCKBD > 0 || NHIDKBD > 0
timeout_set(&sc->sc_bell_tmo, ykbec_bell_stop, sc);
#if NPCKBD > 0
pckbd_hookup_bell(ykbec_bell, sc);
#endif
#if NHIDKBD > 0
hidkbd_hookup_bell(ykbec_bell, sc);
#endif
#endif
ykbec_sc = sc;
}
int
nmeaopen(dev_t dev, struct tty *tp, struct proc *p)
{
struct nmea *np;
int error;
if (tp->t_line == NMEADISC)
return (ENODEV);
if ((error = suser(p, 0)) != 0)
return (error);
np = malloc(sizeof(struct nmea), M_DEVBUF, M_WAITOK | M_ZERO);
snprintf(np->timedev.xname, sizeof(np->timedev.xname), "nmea%d",
nmea_nxid++);
nmea_count++;
np->time.status = SENSOR_S_UNKNOWN;
np->time.type = SENSOR_TIMEDELTA;
np->time.flags = SENSOR_FINVALID;
sensor_attach(&np->timedev, &np->time);
np->signal.type = SENSOR_INDICATOR;
np->signal.status = SENSOR_S_UNKNOWN;
np->signal.value = 0;
strlcpy(np->signal.desc, "Signal", sizeof(np->signal.desc));
sensor_attach(&np->timedev, &np->signal);
np->latitude.type = SENSOR_ANGLE;
np->latitude.status = SENSOR_S_UNKNOWN;
np->latitude.flags = SENSOR_FINVALID;
np->latitude.value = 0;
strlcpy(np->latitude.desc, "Latitude", sizeof(np->latitude.desc));
sensor_attach(&np->timedev, &np->latitude);
np->longitude.type = SENSOR_ANGLE;
np->longitude.status = SENSOR_S_UNKNOWN;
np->longitude.flags = SENSOR_FINVALID;
np->longitude.value = 0;
strlcpy(np->longitude.desc, "Longitude", sizeof(np->longitude.desc));
sensor_attach(&np->timedev, &np->longitude);
np->sync = 1;
tp->t_sc = (caddr_t)np;
error = linesw[TTYDISC].l_open(dev, tp, p);
if (error) {
free(np, M_DEVBUF, sizeof(*np));
tp->t_sc = NULL;
} else {
sensordev_install(&np->timedev);
timeout_set(&np->nmea_tout, nmea_timeout, np);
}
return (error);
}
void
maxtmp_attach(struct device *parent, struct device *self, void *aux)
{
struct maxtmp_softc *sc = (struct maxtmp_softc *)self;
struct i2c_attach_args *ia = aux;
int i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
if (strcmp(ia->ia_name, "max6642") == 0) {
sc->sc_temp_invalid[0] = MAX6642_TEMP_INVALID;
sc->sc_temp_invalid[1] = MAX6642_TEMP_INVALID;
sc->sc_temp2_mask = MAX6642_TEMP2_MASK;
} else if (strcmp(ia->ia_name, "max6690") == 0 ||
strcmp(ia->ia_name, "max6657") == 0 ||
strcmp(ia->ia_name, "max6658") == 0 ||
strcmp(ia->ia_name, "max6659") == 0) {
sc->sc_temp_invalid[0] = MAX6690_TEMP_INVALID;
sc->sc_temp_invalid[1] = MAX6690_TEMP_INVALID2;
sc->sc_temp2_mask = MAX6690_TEMP2_MASK;
} else {
sc->sc_temp_invalid[0] = LM90_TEMP_INVALID;
sc->sc_temp_invalid[1] = LM90_TEMP_INVALID;
sc->sc_temp2_mask = LM90_TEMP2_MASK;
}
printf(": %s", ia->ia_name);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[MAXTMP_INT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[MAXTMP_INT].desc, "Internal",
sizeof(sc->sc_sensor[MAXTMP_INT].desc));
sc->sc_sensor[MAXTMP_EXT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[MAXTMP_EXT].desc, "External",
sizeof(sc->sc_sensor[MAXTMP_EXT].desc));
if (sensor_task_register(sc, maxtmp_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < MAXTMP_NUM_SENSORS; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
int
mstsopen(dev_t dev, struct tty *tp)
{
struct proc *p = curproc;
struct msts *np;
struct timeval t;
int error;
DPRINTF(("mstsopen\n"));
if (tp->t_line == MSTSDISC)
return ENODEV;
if ((error = suser(p, 0)) != 0)
return error;
np = malloc(sizeof(struct msts), M_DEVBUF, M_WAITOK|M_ZERO);
snprintf(np->timedev.xname, sizeof(np->timedev.xname), "msts%d",
msts_nxid++);
msts_count++;
np->time.status = SENSOR_S_UNKNOWN;
np->time.type = SENSOR_TIMEDELTA;
#ifndef MSTS_DEBUG
np->time.flags = SENSOR_FINVALID;
#endif
sensor_attach(&np->timedev, &np->time);
np->signal.type = SENSOR_PERCENT;
np->signal.status = SENSOR_S_UNKNOWN;
np->signal.value = 100000LL;
np->signal.flags = 0;
strlcpy(np->signal.desc, "Signal", sizeof(np->signal.desc));
sensor_attach(&np->timedev, &np->signal);
np->sync = 1;
tp->t_sc = (caddr_t)np;
error = linesw[TTYDISC].l_open(dev, tp);
if (error) {
free(np, M_DEVBUF);
tp->t_sc = NULL;
} else {
sensordev_install(&np->timedev);
timeout_set(&np->msts_tout, msts_timeout, np);
/* convert timevals to hz */
t.tv_sec = TRUSTTIME;
t.tv_usec = 0;
t_trust = tvtohz(&t);
}
return error;
}
void
admtt_attach(struct device *parent, struct device *self, void *aux)
{
struct admtt_softc *sc = (struct admtt_softc *)self;
struct i2c_attach_args *ia = aux;
u_int8_t cmd, data;
int i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
cmd = ADM1031_FANC;
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
printf(", unable to read fan setting\n");
return;
}
sc->sc_fanmul = 11250/8 * (1 << ADM1024_FANC_VAL(data)) * 60;
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[ADMTT_INT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADMTT_INT].desc, "Internal",
sizeof(sc->sc_sensor[ADMTT_INT].desc));
sc->sc_sensor[ADMTT_EXT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADMTT_EXT].desc, "External",
sizeof(sc->sc_sensor[ADMTT_EXT].desc));
sc->sc_sensor[ADMTT_EXT2].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADMTT_EXT2].desc, "External",
sizeof(sc->sc_sensor[ADMTT_EXT2].desc));
sc->sc_sensor[ADMTT_FAN].type = SENSOR_FANRPM;
sc->sc_sensor[ADMTT_FAN2].type = SENSOR_FANRPM;
if (sensor_task_register(sc, admtt_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < ADMTT_NUM_SENSORS; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
schsio_hwm_init(struct schsio_softc *sc)
{
int i;
/* Set up sensors */
for (i = SCHSIO_SENSOR_FAN1; i < SCHSIO_SENSOR_FAN3 + 1; i++)
sc->sc_sensor[i].type = SENSOR_FANRPM;
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT1].desc, "+2.5V",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT1].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT2].desc, "+1.5V (Vccp)",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT2].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT3].desc, "+3.3V (VCC)",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT3].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT4].desc, "+5V",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT4].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT5].desc, "+12V",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT5].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT6].desc, "+3.3V (VTR)",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT6].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_VOLT7].desc, "+3V (Vbat)",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_VOLT7].desc));
for (i = SCHSIO_SENSOR_VOLT1; i < SCHSIO_SENSOR_VOLT7 + 1; i++)
sc->sc_sensor[i].type = SENSOR_VOLTS_DC;
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_TEMP1].desc, "Internal",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_TEMP1].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_TEMP2].desc, "Remote",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_TEMP2].desc));
strlcpy(sc->sc_sensor[SCHSIO_SENSOR_TEMP3].desc, "Remote",
sizeof(sc->sc_sensor[SCHSIO_SENSOR_TEMP3].desc));
for (i = SCHSIO_SENSOR_TEMP1; i < SCHSIO_SENSOR_TEMP3 + 1; i++)
sc->sc_sensor[i].type = SENSOR_TEMP;
strlcpy(sc->sc_sensordev.xname, DEVNAME(sc),
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < SCHSIO_SENSORS; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
if (sensor_task_register(sc, schsio_hwm_update,
SCHSIO_HWM_INTERVAL) == NULL) {
printf(": unable to register update task");
return;
}
sensordev_install(&sc->sc_sensordev);
}
void
acpitz_attach(struct device *parent, struct device *self, void *aux)
{
struct acpitz_softc *sc = (struct acpitz_softc *)self;
struct acpi_attach_args *aa = aux;
int i;
char name[8];
sc->sc_acpi = (struct acpi_softc *)parent;
sc->sc_devnode = aa->aaa_node->child;
sc->sc_lasttmp = -1;
if ((sc->sc_tmp = acpitz_getreading(sc, "_TMP")) == -1) {
printf(", failed to read _TMP\n");
return;
}
if ((sc->sc_crt = acpitz_getreading(sc, "_CRT")) == -1) {
printf(", no critical temperature defined!\n");
sc->sc_crt = 0;
} else
printf(", critical temperature: %d degC\n",
(sc->sc_crt - 2732) / 10);
for (i = 0; i < ACPITZ_MAX_AC; i++) {
snprintf(name, sizeof name, "_AC%d", i);
sc->sc_ac[i] = acpitz_getreading(sc, name);
sc->sc_ac_stat[0] = -1;
}
sc->sc_hot = acpitz_getreading(sc, "_HOT");
sc->sc_tc1 = acpitz_getreading(sc, "_TC1");
sc->sc_tc2 = acpitz_getreading(sc, "_TC2");
sc->sc_psv = acpitz_getreading(sc, "_PSV");
strlcpy(sc->sc_sensdev.xname, DEVNAME(sc),
sizeof(sc->sc_sensdev.xname));
strlcpy(sc->sc_sens.desc, "zone temperature",
sizeof(sc->sc_sens.desc));
sc->sc_sens.type = SENSOR_TEMP;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens);
sensordev_install(&sc->sc_sensdev);
sc->sc_sens.value = 0;
aml_register_notify(sc->sc_devnode->parent, NULL,
acpitz_notify, sc, ACPIDEV_POLL);
}
void
thmc_attach(struct device *parent, struct device *self, void *aux)
{
struct thmc_softc *sc = (struct thmc_softc *)self;
struct i2c_attach_args *ia = aux;
int numsensors = THMC_NUM_SENSORS;
int i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
printf(": %s", ia->ia_name);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[THMC_TEMP0].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[THMC_TEMP0].desc, "Internal",
sizeof(sc->sc_sensor[THMC_TEMP0].desc));
sc->sc_sensor[THMC_TEMP1].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[THMC_TEMP1].desc, "External",
sizeof(sc->sc_sensor[THMC_TEMP1].desc));
if (strcmp(ia->ia_name, "adm1022") == 0) {
/* Only the adm1022 has a THMC50_TEMP2 sensor */
sc->sc_sensor[THMC_TEMP2].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[THMC_TEMP2].desc, "External",
sizeof(sc->sc_sensor[THMC_TEMP2].desc));
} else {
sc->sc_sensor[THMC_TEMP2].type = -1;
numsensors--;
}
if (sensor_task_register(sc, thmc_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < numsensors; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
int
endrunopen(dev_t dev, struct tty *tp, struct proc *p)
{
struct endrun *np;
int error;
DPRINTF(("endrunopen\n"));
if (tp->t_line == ENDRUNDISC)
return ENODEV;
if ((error = suser(p, 0)) != 0)
return error;
np = malloc(sizeof(struct endrun), M_DEVBUF, M_WAITOK|M_ZERO);
snprintf(np->timedev.xname, sizeof(np->timedev.xname), "endrun%d",
endrun_nxid++);
endrun_count++;
np->time.status = SENSOR_S_UNKNOWN;
np->time.type = SENSOR_TIMEDELTA;
#ifndef ENDRUN_DEBUG
np->time.flags = SENSOR_FINVALID;
#endif
sensor_attach(&np->timedev, &np->time);
np->signal.type = SENSOR_PERCENT;
np->signal.status = SENSOR_S_UNKNOWN;
np->signal.value = 100000LL;
strlcpy(np->signal.desc, "Signal", sizeof(np->signal.desc));
sensor_attach(&np->timedev, &np->signal);
np->sync = SYNC_SCAN;
#ifdef ENDRUN_DEBUG
np->tfom = '0';
#endif
tp->t_sc = (caddr_t)np;
error = linesw[TTYDISC].l_open(dev, tp, p);
if (error) {
free(np, M_DEVBUF, 0);
tp->t_sc = NULL;
} else {
sensordev_install(&np->timedev);
timeout_set(&np->endrun_tout, endrun_timeout, np);
}
return error;
}
void
acpidock_attach(struct device *parent, struct device *self, void *aux)
{
struct acpidock_softc *sc = (struct acpidock_softc *)self;
struct acpi_attach_args *aa = aux;
extern struct aml_node aml_root;
sc->sc_acpi = (struct acpi_softc *)parent;
sc->sc_devnode = aa->aaa_node;
printf(": %s", sc->sc_devnode->name);
acpidock_status(sc);
if (sc->sc_docked == ACPIDOCK_STATUS_DOCKED) {
acpidock_docklock(sc, 1);
acpidock_dockctl(sc, 1);
}
acpidock_status(sc);
printf("%s docked (%d)\n",
sc->sc_docked == ACPIDOCK_STATUS_DOCKED ? "" : " not",
sc->sc_sta);
strlcpy(sc->sc_sensdev.xname, DEVNAME(sc),
sizeof(sc->sc_sensdev.xname));
if (sc->sc_docked)
strlcpy(sc->sc_sens.desc, "docked",
sizeof(sc->sc_sens.desc));
else
strlcpy(sc->sc_sens.desc, "not docked",
sizeof(sc->sc_sens.desc));
sc->sc_sens.type = SENSOR_INDICATOR;
sc->sc_sens.value = sc->sc_docked == ACPIDOCK_STATUS_DOCKED;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens);
sensordev_install(&sc->sc_sensdev);
TAILQ_INIT(&sc->sc_deps_h);
aml_find_node(&aml_root, "_EJD", acpidock_foundejd, sc);
aml_register_notify(sc->sc_devnode, aa->aaa_dev,
acpidock_notify, sc, ACPIDEV_NOPOLL);
}
void
owid_attach(struct device *parent, struct device *self, void *aux)
{
struct owid_softc *sc = (struct owid_softc *)self;
struct onewire_attach_args *oa = aux;
sc->sc_onewire = oa->oa_onewire;
sc->sc_rom = oa->oa_rom;
/* Initialize sensor */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_INTEGER;
sc->sc_sensor.value = ONEWIRE_ROM_SN(sc->sc_rom);
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
static int
km_attach(struct device *dev)
{
struct km_softc *sc;
sc = device_get_softc(dev);
sc->sc_dev = dev;
strlcpy(sc->sc_sensordev.xname, device_get_nameunit(dev),
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_TEMP;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
sensor_task_register(sc, km_refresh, 5);
sensordev_install(&sc->sc_sensordev);
return 0;
}
static int
km_attach(struct device *dev)
{
struct km_softc *sc;
sc = device_get_softc(dev);
sc->sc_dev = dev;
strlcpy(sc->sc_sensordev.xname, device_get_nameunit(dev),
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_TEMP;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
if (sensor_task_register(sc, km_refresh, 5)) {
device_printf(dev, "unable to register update task\n");
return ENXIO;
}
sensordev_install(&sc->sc_sensordev);
return 0;
}
int
it_attach(struct device *dev)
{
struct it_softc *sc = device_get_softc(dev);
int i;
u_int8_t cr;
sc->sc_dev = dev;
sc->sc_iores = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->sc_iorid,
0ul, ~0ul, 8, RF_ACTIVE);
if (sc->sc_iores == NULL) {
device_printf(dev, "can't map i/o space\n");
return 1;
}
sc->sc_iot = rman_get_bustag(sc->sc_iores);
sc->sc_ioh = rman_get_bushandle(sc->sc_iores);
sc->numsensors = IT_NUM_SENSORS;
it_setup_fan(sc, 0, 3);
it_setup_volt(sc, 3, 9);
it_setup_temp(sc, 12, 3);
sensor_task_register(sc, it_refresh, 5);
/* Activate monitoring */
cr = it_readreg(sc, ITD_CONFIG);
cr |= 0x01 | 0x08;
it_writereg(sc, ITD_CONFIG, cr);
/* Initialize sensors */
strlcpy(sc->sensordev.xname, device_get_nameunit(sc->sc_dev),
sizeof(sc->sensordev.xname));
for (i = 0; i < sc->numsensors; ++i)
sensor_attach(&sc->sensordev, &sc->sensors[i]);
sensordev_install(&sc->sensordev);
return 0;
}
void
thinkpad_sensor_attach(struct acpithinkpad_softc *sc)
{
int i;
if (sc->sc_acpi->sc_ec == NULL)
return;
sc->sc_ec = sc->sc_acpi->sc_ec;
/* Add temperature probes */
strlcpy(sc->sc_sensdev.xname, DEVNAME(sc),
sizeof(sc->sc_sensdev.xname));
for (i=0; i<THINKPAD_NTEMPSENSORS; i++) {
sc->sc_sens[i].type = SENSOR_TEMP;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[i]);
}
/* Add fan probe */
sc->sc_sens[i].type = SENSOR_FANRPM;
sensor_attach(&sc->sc_sensdev, &sc->sc_sens[i]);
sensordev_install(&sc->sc_sensdev);
}
void
km_attach(struct device *parent, struct device *self, void *aux)
{
struct km_softc *sc = (struct km_softc *)self;
struct pci_attach_args *pa = aux;
sc->sc_pc = pa->pa_pc;
sc->sc_pcitag = pa->pa_tag;
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_TEMP;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
if (sensor_task_register(sc, km_refresh, 5) == NULL) {
printf(": unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
pcagpio_attach(struct device *parent, struct device *self, void *aux)
{
struct pcagpio_softc *sc = (struct pcagpio_softc *)self;
struct i2c_attach_args *ia = aux;
struct gpiobus_attach_args gba;
int outputs = 0, i, port, bit;
u_int8_t data[PCAGPIO_NPORTS];
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
if (strcmp(ia->ia_name, "pca9555") == 0) {
/* The pca9555 has two 8 bit ports */
sc->sc_regs[0][PCAGPIO_IN] = PCA9555_IN0;
sc->sc_regs[0][PCAGPIO_OUT] = PCA9555_OUT0;
sc->sc_regs[0][PCAGPIO_POLARITY] = PCA9555_POLARITY0;
sc->sc_regs[0][PCAGPIO_CONFIG] = PCA9555_CONFIG0;
sc->sc_regs[1][PCAGPIO_IN] = PCA9555_IN1;
sc->sc_regs[1][PCAGPIO_OUT] = PCA9555_OUT1;
sc->sc_regs[1][PCAGPIO_POLARITY] = PCA9555_POLARITY1;
sc->sc_regs[1][PCAGPIO_CONFIG] = PCA9555_CONFIG1;
sc->sc_npins = 16;
} else {
/* All other supported devices have one 8 bit port */
sc->sc_regs[0][PCAGPIO_IN] = PCA9554_IN;
sc->sc_regs[0][PCAGPIO_OUT] = PCA9554_OUT;
sc->sc_regs[0][PCAGPIO_POLARITY] = PCA9554_POLARITY;
sc->sc_regs[0][PCAGPIO_CONFIG] = PCA9554_CONFIG;
sc->sc_npins = 8;
}
if (pcagpio_init(sc, 0, &data[0]) != 0)
return;
if (sc->sc_npins > 8 && pcagpio_init(sc, 1, &data[1]) != 0)
return;
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < sc->sc_npins; i++) {
port = PCAGPIO_PORT(i);
bit = PCAGPIO_BIT(i);
sc->sc_sensor[i].type = SENSOR_INDICATOR;
if ((sc->sc_control[port] & bit) == 0) {
strlcpy(sc->sc_sensor[i].desc, "out",
sizeof(sc->sc_sensor[i].desc));
outputs++;
} else
strlcpy(sc->sc_sensor[i].desc, "in",
sizeof(sc->sc_sensor[i].desc));
}
if (sensor_task_register(sc, pcagpio_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
#if 0
for (i = 0; i < sc->sc_npins; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
#endif
printf(":");
if (sc->sc_npins - outputs)
printf(" %d inputs", sc->sc_npins - outputs);
if (outputs)
printf(" %d outputs", outputs);
printf("\n");
for (i = 0; i < sc->sc_npins; i++) {
port = PCAGPIO_PORT(i);
bit = PCAGPIO_BIT(i);
sc->sc_gpio_pins[i].pin_num = i;
sc->sc_gpio_pins[i].pin_caps = GPIO_PIN_INPUT | GPIO_PIN_OUTPUT;
if ((sc->sc_control[port] & bit) == 0) {
sc->sc_gpio_pins[i].pin_flags = GPIO_PIN_OUTPUT;
sc->sc_gpio_pins[i].pin_state = data[port] &
bit ? GPIO_PIN_HIGH : GPIO_PIN_LOW;
}
}
/* Create controller tag */
sc->sc_gpio_gc.gp_cookie = sc;
sc->sc_gpio_gc.gp_pin_read = pcagpio_gpio_pin_read;
sc->sc_gpio_gc.gp_pin_write = pcagpio_gpio_pin_write;
sc->sc_gpio_gc.gp_pin_ctl = pcagpio_gpio_pin_ctl;
gba.gba_name = "gpio";
gba.gba_gc = &sc->sc_gpio_gc;
gba.gba_pins = sc->sc_gpio_pins;
gba.gba_npins = sc->sc_npins;
config_found(&sc->sc_dev, &gba, gpiobus_print);
}
void
itherm_attach(struct device *parent, struct device *self, void *aux)
{
struct itherm_softc *sc = (struct itherm_softc *)self;
struct pci_attach_args *pa = aux;
int i;
pcireg_t v;
v = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_MAPREG_START);
v &= PCI_MAPREG_TYPE_MASK | PCI_MAPREG_MEM_TYPE_MASK;
if (pci_mapreg_map(pa, PCI_MAPREG_START,
v, 0, &sc->iot, &sc->ioh, NULL, &sc->size, 0)) {
printf(": can't map mem space\n");
return;
}
sc->sensors[ITHERM_SENSOR_THERMOMETER].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_CORETEMP1].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_CORETEMP2].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_COREENERGY].type = SENSOR_WATTS;
sc->sensors[ITHERM_SENSOR_GPUTEMP].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_MAXPROCTEMP].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_DIMMTEMP1].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_DIMMTEMP2].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_DIMMTEMP3].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_DIMMTEMP4].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_GPUTEMP_ABSOLUTE].type = SENSOR_TEMP;
sc->sensors[ITHERM_SENSOR_PCHTEMP_ABSOLUTE].type = SENSOR_TEMP;
strlcpy(sc->sensors[ITHERM_SENSOR_THERMOMETER].desc,
"Thermometer",
sizeof(sc->sensors[ITHERM_SENSOR_THERMOMETER].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_CORETEMP1].desc,
"Core 1",
sizeof(sc->sensors[ITHERM_SENSOR_CORETEMP1].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_CORETEMP2].desc,
"Core 2",
sizeof(sc->sensors[ITHERM_SENSOR_CORETEMP2].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_COREENERGY].desc,
"CPU power consumption",
sizeof(sc->sensors[ITHERM_SENSOR_COREENERGY].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_GPUTEMP].desc,
"GPU/Memory Controller Temp",
sizeof(sc->sensors[ITHERM_SENSOR_GPUTEMP].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_MAXPROCTEMP].desc,
"CPU/GPU Max temp",
sizeof(sc->sensors[ITHERM_SENSOR_MAXPROCTEMP].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_DIMMTEMP1].desc,
"DIMM 1",
sizeof(sc->sensors[ITHERM_SENSOR_DIMMTEMP1].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_DIMMTEMP2].desc,
"DIMM 2",
sizeof(sc->sensors[ITHERM_SENSOR_DIMMTEMP2].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_DIMMTEMP3].desc,
"DIMM 3",
sizeof(sc->sensors[ITHERM_SENSOR_DIMMTEMP3].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_DIMMTEMP4].desc,
"DIMM 4",
sizeof(sc->sensors[ITHERM_SENSOR_DIMMTEMP4].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_GPUTEMP_ABSOLUTE].desc,
"GPU/Memory controller abs.",
sizeof(sc->sensors[ITHERM_SENSOR_GPUTEMP_ABSOLUTE].desc));
strlcpy(sc->sensors[ITHERM_SENSOR_PCHTEMP_ABSOLUTE].desc,
"PCH abs.",
sizeof(sc->sensors[ITHERM_SENSOR_PCHTEMP_ABSOLUTE].desc));
strlcpy(sc->sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sensordev.xname));
itherm_enable(sc);
for (i = 0; i < ITHERM_NUM_SENSORS; i++)
sensor_attach(&sc->sensordev, &sc->sensors[i]);
sensordev_install(&sc->sensordev);
sensor_task_register(sc, itherm_refresh, ITHERM_REFRESH_INTERVAL);
printf("\n");
return;
}
void
stsec_attach(struct device *parent, struct device *self, void *aux)
{
struct stsec_softc *sc = (struct stsec_softc *)self;
struct i2c_attach_args *ia = (struct i2c_attach_args *)aux;
int rev, sig;
int rc;
uint i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
/*
* Figure out where to get our information, and display microcode
* version for geek value if available.
*/
sc->sc_base = 0;
switch (gdium_revision) {
case 0:
break;
default:
/* read version before sc_base is set */
rc = stsec_read(sc, ST7_VERSION, &rev);
if (rc != 0) {
printf(": can't read microcode revision\n");
return;
}
printf(": revision %d.%d", (rev >> 4) & 0x0f, rev & 0x0f);
sc->sc_base = ST7_VERSION + 1;
break;
}
printf("\n");
/*
* Better trust the ST7 firmware to control charge operation.
*/
rc = stsec_read(sc, ST7_SIGNATURE, &sig);
if (rc != 0) {
printf("%s: can't verify charge policy\n", self->dv_xname);
/* not fatal */
} else {
if (sig != STSIG_EC_CONTROL)
stsec_write(sc, ST7_SIGNATURE, STSIG_EC_CONTROL);
}
/*
* Setup sensors. We use a quite short refresh interval to react
* quickly enough to button presses.
* XXX but we don't do anything on lid or button presses... yet
*/
strlcpy(sc->sc_sensordev.xname, self->dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensors_update_task =
sensor_task_register(sc, stsec_sensors_update, 2);
if (sc->sc_sensors_update_task == NULL) {
printf("%s: can't initialize refresh task\n", self->dv_xname);
return;
}
for (i = 0; i < nitems(sc->sc_sensors); i++) {
sc->sc_sensors[i].type = stsec_sensors_template[i].type;
strlcpy(sc->sc_sensors[i].desc, stsec_sensors_template[i].desc,
sizeof(sc->sc_sensors[i].desc));
sensor_attach(&sc->sc_sensordev, &sc->sc_sensors[i]);
}
sensordev_install(&sc->sc_sensordev);
#if NAPM > 0
/* make sure we have the apm state initialized before apm attaches */
stsec_sensors_update(sc);
apm_setinfohook(stsec_apminfo);
#endif
}
void
tsl_attach(struct device *parent, struct device *self, void *aux)
{
struct tsl_softc *sc = (struct tsl_softc *)self;
struct i2c_attach_args *ia = aux;
u_int8_t cmd, data;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
iic_acquire_bus(sc->sc_tag, 0);
cmd = TSL2560_REG_CONTROL; data = TSL2560_CONTROL_POWER;
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
iic_release_bus(sc->sc_tag, 0);
printf(": power up failed\n");
return;
}
cmd = TSL2560_REG_TIMING;
data = TSL2560_TIMING_GAIN | TSL2560_TIMING_INTEG2;
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
iic_release_bus(sc->sc_tag, 0);
printf(": cannot write timing register\n");
return;
}
cmd = TSL2560_REG_ID;
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
iic_release_bus(sc->sc_tag, 0);
printf(": cannot read ID register\n");
return;
}
iic_release_bus(sc->sc_tag, 0);
switch (data >> 4) {
case 0:
printf(": TSL2560 rev %x", data & 0x0f);
break;
case 1:
printf(": TSL2561 rev %x", data & 0x0f);
break;
default:
printf(": unknown part number %x", data >> 4);
break;
}
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_LUX;
if (sensor_task_register(sc, tsl_refresh, 5) == NULL) {
printf(": unable to register update task\n");
return;
}
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
