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
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
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
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
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
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
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;
}
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");
}
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
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");
}
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
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 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
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
lmtemp_attach(struct device *parent, struct device *self, void *aux)
{
struct lmtemp_softc *sc = (struct lmtemp_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;
printf(": %s", ia->ia_name);
/* If in SHUTDOWN mode, wake it up */
iic_acquire_bus(sc->sc_tag, 0);
cmd = LM75_REG_CONFIG;
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(", fails to respond\n");
return;
}
if (data & LM75_CONFIG_SHUTDOWN) {
data &= ~LM75_CONFIG_SHUTDOWN;
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
printf(", cannot wake up\n");
iic_release_bus(sc->sc_tag, 0);
return;
}
printf(", woken up");
}
iic_release_bus(sc->sc_tag, 0);
sc->sc_model = LM_MODEL_LM75;
sc->sc_bits = 9;
sc->sc_ratio = 500000; /* 0.5 degC for LSB */
if (strcmp(ia->ia_name, "lm77") == 0) {
sc->sc_model = LM_MODEL_LM77;
sc->sc_bits = 13;
} else if (strcmp(ia->ia_name, "lm76") == 0) {
sc->sc_model = LM_MODEL_LM76;
sc->sc_bits = 13;
sc->sc_ratio = 62500; /* 0.0625 degC for LSB */
} else if (strcmp(ia->ia_name, "ds1775") == 0) {
sc->sc_model = LM_MODEL_DS1775;
//sc->sc_bits = DS1755_CONFIG_RESOLUTION(data);
} else if (strcmp(ia->ia_name, "lm75a") == 0) {
/* For simplicity's sake, treat the LM75A as an LM75 */
sc->sc_model = LM_MODEL_LM75A;
}
printf("\n");
/* Initialize sensor data */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor.type = SENSOR_TEMP;
/* Hook into the hw.sensors sysctl */
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor);
sensordev_install(&sc->sc_sensordev);
sensor_task_register(sc, lmtemp_refresh_sensor_data, LM_POLLTIME);
}
void
pcfadc_attach(struct device *parent, struct device *self, void *aux)
{
struct pcfadc_softc *sc = (struct pcfadc_softc *)self;
u_char chanuse[PCF8591_CHANNELS * 4], desc[PCF8591_CHANNELS * 32];
u_char *cp;
u_int8_t junk[PCF8591_CHANNELS + 1];
u_int32_t transinfo[PCF8591_CHANNELS * 4];
struct i2c_attach_args *ia = aux;
int dlen, clen, tlen, node = *(int *)ia->ia_cookie;
u_int i;
if ((dlen = OF_getprop(node, "channels-description", desc,
sizeof(desc))) < 0) {
printf(": couldn't find \"channels-description\" property\n");
return;
}
if (dlen > sizeof(desc) || desc[dlen - 1] != '\0') {
printf(": bad \"channels-description\" property\n");
return;
}
if ((clen = OF_getprop(node, "channels-in-use", chanuse,
sizeof(chanuse))) < 0) {
printf(": couldn't find \"channels-in-use\" property\n");
return;
}
if ((clen % 4) != 0) {
printf(": invalid \"channels-in-use\" length %d\n", clen);
return;
}
sc->sc_nchan = clen / 4;
if (sc->sc_nchan > PCF8591_CHANNELS) {
printf(": invalid number of channels (%d)\n", sc->sc_nchan);
return;
}
if ((tlen = OF_getprop(node, "tables", sc->sc_xlate,
sizeof(sc->sc_xlate))) < 0) {
printf(": couldn't find \"tables\" property\n");
return;
}
/* We only support complete, single width tables */
if (tlen != 256) {
printf(": invalid \"tables\" length %d\n", tlen);
return;
}
if ((tlen = OF_getprop(node, "translation", transinfo,
sizeof(transinfo))) < 0) {
printf(": couldn't find \"translation\" property\n");
return;
}
if (tlen != (sc->sc_nchan * 4 * 4)) {
printf(": invalid \"translation\" length %d\n", tlen);
return;
}
cp = desc;
for (i = 0; i < sc->sc_nchan; i++) {
struct pcfadc_channel *chp = &sc->sc_channels[i];
chp->chan_sensor.type = SENSOR_TEMP;
if (cp >= desc + dlen) {
printf(": invalid \"channels-description\"\n");
return;
}
strlcpy(chp->chan_sensor.desc, cp,
sizeof(chp->chan_sensor.desc));
cp += strlen(cp) + 1;
/*
* We only support input temperature channels, with
* valid channel numbers, and basic (unscaled) translation
*
* XXX TODO: support voltage (type 2) channels and type 4
* (scaled) translation tables
*/
if (chanuse[(i * 4)] > PCF8591_CHANNELS || /* channel # */
chanuse[(i * 4) + 1] != 0 || /* dir == input */
chanuse[(i * 4) + 2] != 1 || /* type == temp */
transinfo[(i * 4)] != 3 || /* xlate == table */
transinfo[(i * 4) + 2] != 0 || /* no xlate offset */
transinfo[(i * 4) + 3] != 0x100) { /* xlate tbl length */
printf(": unsupported sensor %d\n", i);
return;
}
chp->chan_num = chanuse[(i * 4)];
}
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
iic_acquire_bus(sc->sc_tag, 0);
/* Try a read now, so we can fail if it doesn't work */
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr,
NULL, 0, junk, sc->sc_nchan + 1, 0)) {
printf(": read failed\n");
iic_release_bus(sc->sc_tag, 0);
return;
}
iic_release_bus(sc->sc_tag, 0);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < sc->sc_nchan; i++)
if (!(sc->sc_channels[i].chan_sensor.flags & SENSOR_FINVALID))
sensor_attach(&sc->sc_sensordev,
&sc->sc_channels[i].chan_sensor);
if (sensor_task_register(sc, pcfadc_refresh, 5)) {
printf(": unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
adc_attach(struct device *parent, struct device *self, void *aux)
{
struct adc_softc *sc = (struct adc_softc *)self;
struct i2c_attach_args *ia = aux;
u_int8_t cmd, data;
int nsens = 0, i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
printf(": %s", ia->ia_name);
sc->sc_chip = 0;
if (strcmp(ia->ia_name, "ad7417") == 0)
sc->sc_chip = 7417;
if (strcmp(ia->ia_name, "ad7418") == 0)
sc->sc_chip = 7418;
if (sc->sc_chip != 0) {
cmd = AD741X_CONFIG2;
data = 0;
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
printf(", config2 reset failed\n");
return;
}
}
cmd = AD741X_CONFIG;
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
printf(", config reset failed\n");
return;
}
data &= 0xfe;
if (iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0)) {
printf(", config reset failed\n");
return;
}
sc->sc_config = data;
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[ADC_TEMP].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADC_TEMP].desc, "Internal",
sizeof(sc->sc_sensor[ADC_TEMP].desc));
nsens = 1;
if (sc->sc_chip == 7417 || sc->sc_chip == 7418) {
sc->sc_sensor[ADC_ADC0].type = SENSOR_INTEGER;
nsens++;
}
if (sc->sc_chip == 7417 || sc->sc_chip == 7418) {
sc->sc_sensor[ADC_ADC1].type = SENSOR_INTEGER;
sc->sc_sensor[ADC_ADC2].type = SENSOR_INTEGER;
sc->sc_sensor[ADC_ADC3].type = SENSOR_INTEGER;
nsens += 3;
}
if (sensor_task_register(sc, adc_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[0]);
if (sc->sc_chip == 7417 || sc->sc_chip == 7418)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[1]);
if (sc->sc_chip == 7417)
for (i = 2; i < nsens; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
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");
}
void
admtemp_attach(struct device *parent, struct device *self, void *aux)
{
struct admtemp_softc *sc = (struct admtemp_softc *)self;
struct i2c_attach_args *ia = aux;
u_int8_t cmd, data, stat;
int xeon = 0, i;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
if (strcmp(ia->ia_name, "xeontemp") == 0) {
printf(": Xeon");
xeon = 1;
} else
printf(": %s", ia->ia_name);
iic_acquire_bus(sc->sc_tag, 0);
cmd = ADM1021_CONFIG_READ;
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 get control register\n");
return;
}
if (data & ADM1021_CONFIG_RUN) {
cmd = ADM1021_STATUS;
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &stat, sizeof stat, 0)) {
iic_release_bus(sc->sc_tag, 0);
printf(", cannot read status register\n");
return;
}
if ((stat & ADM1021_STATUS_INVAL) == ADM1021_STATUS_INVAL) {
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &stat, sizeof stat, 0)) {
iic_release_bus(sc->sc_tag, 0);
printf(", cannot read status register\n");
return;
}
}
/* means external is dead */
if ((stat & ADM1021_STATUS_INVAL) != ADM1021_STATUS_INVAL &&
(stat & ADM1021_STATUS_NOEXT))
sc->sc_noexternal = 1;
data &= ~ADM1021_CONFIG_RUN;
cmd = ADM1021_CONFIG_WRITE;
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 set control register\n");
return;
}
}
iic_release_bus(sc->sc_tag, 0);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[ADMTEMP_EXT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADMTEMP_EXT].desc,
xeon ? "Xeon" : "External",
sizeof(sc->sc_sensor[ADMTEMP_EXT].desc));
sc->sc_sensor[ADMTEMP_INT].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[ADMTEMP_INT].desc,
xeon ? "Xeon" : "Internal",
sizeof(sc->sc_sensor[ADMTEMP_INT].desc));
if (sensor_task_register(sc, admtemp_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < (sc->sc_noexternal ? 1 : ADMTEMP_NUM_SENSORS); i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
uoakv_attach(struct device *parent, struct device *self, void *aux)
{
struct uoakv_softc *sc = (struct uoakv_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;
struct uoak_softc *scc = &sc->sc_uoak_softc;
int i, err, size, repid;
void *desc;
sc->sc_hdev.sc_intr = uoakv_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
scc->sc_parent = sc;
scc->sc_udev = dev;
scc->sc_hdev = &sc->sc_hdev;
scc->sc_methods = &uoakv_methods;
scc->sc_sensordev = &sc->sc_sensordev;
uhidev_get_report_desc(uha->parent, &desc, &size);
repid = uha->reportid;
scc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
scc->sc_olen = hid_report_size(desc, size, hid_output, repid);
scc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
/* device initialize */
(void)uoak_led_ctrl(scc, OAK_TARGET_RAM, OAK_LED_ON);
err = uoak_set_sample_rate(scc, OAK_TARGET_RAM, UOAKV_SAMPLE_RATE);
if (err) {
printf("%s: could not set sampling rate. exit\n",
sc->sc_hdev.sc_dev.dv_xname);
return;
}
/* query and print device setting */
uoak_get_devinfo(scc);
uoak_print_devinfo(scc);
DPRINTF((" config in RAM\n"));
uoak_get_setting(scc, OAK_TARGET_RAM);
uoak_print_setting(scc, OAK_TARGET_RAM);
#ifdef UOAKV_DEBUG
DPRINTF((" config in FRASH\n"));
uoak_get_setting(scc, OAK_TARGET_FLASH);
uoak_print_setting(scc, OAK_TARGET_FLASH);
#endif
/* attach sensor */
strlcpy(sc->sc_sensordev.xname, sc->sc_hdev.sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
for (i = 0; i < OAK_V_MAXSENSORS; i++)
uoak_sensor_attach(scc, &sc->sc_sensor[i].v, SENSOR_VOLTS_DC);
/* start sensor */
sc->sc_sensortask = sensor_task_register(sc, uoakv_refresh,
UOAKV_REFRESH_PERIOD);
if (sc->sc_sensortask == NULL) {
printf(", unable to register update task\n");
return;
}
sensordev_install(&sc->sc_sensordev);
err = uhidev_open(&sc->sc_hdev);
if (err) {
printf("%s: could not open interrupt pipe, quit\n",
sc->sc_hdev.sc_dev.dv_xname);
return;
}
scc->sc_ibuf = malloc(scc->sc_ilen, M_USBDEV, M_WAITOK);
DPRINTF(("uoakv_attach: complete\n"));
}
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;
}
void
maxds_attach(struct device *parent, struct device *self, void *aux)
{
struct maxds_softc *sc = (struct maxds_softc *)self;
struct i2c_attach_args *ia = aux;
u_int8_t cmd, data;
int i;
printf(": %s", ia->ia_name);
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
iic_acquire_bus(sc->sc_tag, 0);
cmd = DS1631_CONTROL;
if (iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0) == 0) {
if (data & DS1631_CONTROL_1SHOT) {
/*
* 1-Shot mode would require us to write every refresh
* which is stupid. Put us into continuous mode.
*/
data &= ~DS1631_CONTROL_1SHOT;
(void) iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, &data, sizeof data, 0);
//delay(10 * 1000);
printf(", continuous");
goto dostart;
}
if (data & DS1631_CONTROL_DONE) {
dostart:
cmd = DS1631_START;
if (strcmp(ia->ia_name, "ds1624") == 0)
cmd = DS1624_START;
(void) iic_exec(sc->sc_tag, I2C_OP_WRITE_WITH_STOP,
sc->sc_addr, &cmd, sizeof cmd, NULL, 0, 0);
printf(", starting");
}
}
iic_release_bus(sc->sc_tag, 0);
/* Initialize sensor data. */
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[MAXDS_TEMP].type = SENSOR_TEMP;
strlcpy(sc->sc_sensor[MAXDS_TEMP].desc, "Internal",
sizeof(sc->sc_sensor[MAXDS_TEMP].desc));
if (sensor_task_register(sc, maxds_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < MAXDS_NUM_SENSORS; i++)
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
sensordev_install(&sc->sc_sensordev);
printf("\n");
}
void
fintek_attach(struct device *parent, struct device *self, void *aux)
{
struct fintek_softc *sc = (struct fintek_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;
iic_acquire_bus(sc->sc_tag, 0);
cmd = FINTEK_VERSION;
if (fintek_read_reg(sc, cmd, &data, sizeof data))
goto failread;
printf(": F75375 rev %d.%d", data>> 4, data & 0xf);
/*
* It seems the fan in the Thecus n2100 doesn't provide a
* reliable fan count. As a result the automatic fan
* controlling mode that the chip comes up in after reset
* doesn't work reliably. So we have a flag to drive the fan
* at maximum voltage such that the box doesn't overheat.
*/
if (sc->sc_dev.dv_cfdata->cf_flags & FINTEK_OPTION_FULLSPEED)
fintek_fullspeed(sc);
iic_release_bus(sc->sc_tag, 0);
strlcpy(sc->sc_sensordev.xname, sc->sc_dev.dv_xname,
sizeof(sc->sc_sensordev.xname));
sc->sc_sensor[F_VCC].type = SENSOR_VOLTS_DC;
strlcpy(sc->sc_sensor[F_VCC].desc, "Vcc",
sizeof(sc->sc_sensor[F_VCC].desc));
sc->sc_sensor[F_V1].type = SENSOR_VOLTS_DC;
sc->sc_sensor[F_V2].type = SENSOR_VOLTS_DC;
sc->sc_sensor[F_V3].type = SENSOR_VOLTS_DC;
sc->sc_sensor[F_TEMP1].type = SENSOR_TEMP;
sc->sc_sensor[F_TEMP2].type = SENSOR_TEMP;
sc->sc_sensor[F_FAN1].type = SENSOR_FANRPM;
sc->sc_sensor[F_FAN2].type = SENSOR_FANRPM;
if (sensor_task_register(sc, fintek_refresh, 5) == NULL) {
printf(", unable to register update task\n");
return;
}
for (i = 0; i < F_NUM_SENSORS; i++) {
sc->sc_sensor[i].flags &= ~SENSOR_FINVALID;
sensor_attach(&sc->sc_sensordev, &sc->sc_sensor[i]);
}
sensordev_install(&sc->sc_sensordev);
printf("\n");
return;
failread:
printf("unable to read reg %d\n", cmd);
iic_release_bus(sc->sc_tag, 0);
return;
}
