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"); }