static void acpitz_init_envsys(struct acpitz_softc *sc) { int i; simple_lock_init(&sc->sc_slock); for (i = 0; i < ATZ_NUMSENSORS; i++) { sc->sc_data[i].sensor = sc->sc_info[i].sensor = i; sc->sc_data[i].validflags = ENVSYS_FVALID; sc->sc_info[i].validflags = ENVSYS_FVALID; sc->sc_data[i].warnflags = ENVSYS_WARN_OK; } #define INITDATA(index, unit, string) \ sc->sc_data[index].units = unit; \ sc->sc_info[index].units = unit; \ snprintf(sc->sc_info[index].desc, sizeof(sc->sc_info[index].desc), \ "%s %s", sc->sc_dev.dv_xname, string); INITDATA(ATZ_SENSOR_TEMP, ENVSYS_STEMP, "temperature"); /* hook into sysmon */ sc->sc_sysmon.sme_ranges = acpitz_ranges; sc->sc_sysmon.sme_sensor_info = sc->sc_info; sc->sc_sysmon.sme_sensor_data = sc->sc_data; sc->sc_sysmon.sme_cookie = sc; sc->sc_sysmon.sme_gtredata = acpitz_gtredata; sc->sc_sysmon.sme_streinfo = acpitz_streinfo; sc->sc_sysmon.sme_nsensors = ATZ_NUMSENSORS; sc->sc_sysmon.sme_envsys_version = 1000; if (sysmon_envsys_register(&sc->sc_sysmon)) printf("%s: unable to register with sysmon\n", sc->sc_dev.dv_xname); }
static void axp20x_attach(device_t parent, device_t self, void *aux) { struct axp20x_softc *sc = device_private(self); struct i2c_attach_args *ia = aux; sc->sc_dev = self; sc->sc_i2c = ia->ia_tag; sc->sc_addr = ia->ia_addr; aprint_naive("\n"); aprint_normal("\n"); sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = axp20x_sensors_refresh; sc->sc_sensor_temp.units = ENVSYS_STEMP; sc->sc_sensor_temp.state = ENVSYS_SINVALID; sc->sc_sensor_temp.flags = ENVSYS_FHAS_ENTROPY; snprintf(sc->sc_sensor_temp.desc, sizeof(sc->sc_sensor_temp.desc), "internal temperature"); sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_temp); sysmon_envsys_register(sc->sc_sme); }
static void tmp121temp_attach(device_t parent, device_t self, void *aux) { struct tmp121temp_softc *sc = device_private(self); struct spi_attach_args *sa = aux; aprint_naive(": Temperature Sensor\n"); aprint_normal(": TI TMP121 Temperature Sensor\n"); sc->sc_sh = sa->sa_handle; sc->sc_sme = sysmon_envsys_create(); sc->sc_sensor.units = ENVSYS_STEMP; strlcpy(sc->sc_sensor.desc, device_xname(self), sizeof(sc->sc_sensor.desc)); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) { sysmon_envsys_destroy(sc->sc_sme); return; } sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_refresh = tmp121temp_refresh; sc->sc_sme->sme_cookie = sc; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); } }
void tda_attach(device_t parent, device_t self, void *aux) { struct tda_softc *sc = device_private(self); struct i2c_attach_args *ia = aux; sc->sc_dev = self; sc->sc_tag = ia->ia_tag; sc->sc_addr = ia->ia_addr; aprint_normal(": %s\n", ia->ia_name); aprint_naive(": Environment sensor\n"); /* * Set the fans to maximum speed and save the power levels; * the controller is write-only. */ sc->sc_cfan_speed = sc->sc_sfan_speed = (TDA_FANSPEED_MAX+TDA_FANSPEED_MIN)/2; tda_setspeed(sc); callout_init(&sc->sc_timer, CALLOUT_MPSAFE); callout_reset(&sc->sc_timer, hz*20, tda_timeout, sc); /* Initialise sensor data */ sc->sc_sensor[SENSOR_FAN_CPU].state = ENVSYS_SINVALID; sc->sc_sensor[SENSOR_FAN_CPU].units = ENVSYS_INTEGER; sc->sc_sensor[SENSOR_FAN_CPU].flags = ENVSYS_FMONNOTSUPP; strlcpy(sc->sc_sensor[SENSOR_FAN_CPU].desc, "fan.cpu",sizeof("fan.cpu")); sc->sc_sensor[SENSOR_FAN_SYS].state = ENVSYS_SINVALID; sc->sc_sensor[SENSOR_FAN_SYS].units = ENVSYS_INTEGER; sc->sc_sensor[SENSOR_FAN_SYS].flags = ENVSYS_FMONNOTSUPP; strlcpy(sc->sc_sensor[SENSOR_FAN_SYS].desc, "fan.sys",sizeof("fan.sys")); sc->sc_sme = sysmon_envsys_create(); if (sysmon_envsys_sensor_attach( sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_CPU])) { sysmon_envsys_destroy(sc->sc_sme); aprint_error_dev(self, "unable to attach cpu fan at sysmon\n"); return; } if (sysmon_envsys_sensor_attach( sc->sc_sme, &sc->sc_sensor[SENSOR_FAN_SYS])) { sysmon_envsys_destroy(sc->sc_sme); aprint_error_dev(self, "unable to attach sys fan at sysmon\n"); return; } sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = tda_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); return; } }
static void hytp14_attach(device_t parent, device_t self, void *aux) { struct hytp14_sc *sc = device_private(self); struct i2c_attach_args *ia = aux; int i; sc->sc_dev = self; sc->sc_tag = ia->ia_tag; sc->sc_addr = ia->ia_addr; sc->sc_refresh = 0; sc->sc_valid = ENVSYS_SINVALID; sc->sc_numsensors = __arraycount(hytp14_sensors); if ((sc->sc_sme = sysmon_envsys_create()) == NULL) { aprint_error_dev(sc->sc_dev, "unable to create sysmon structure\n"); return; } for (i = 0; i < sc->sc_numsensors; i++) { strlcpy(sc->sc_sensors[i].desc, hytp14_sensors[i].desc, sizeof sc->sc_sensors[i].desc); sc->sc_sensors[i].units = hytp14_sensors[i].type; sc->sc_sensors[i].state = ENVSYS_SINVALID; DPRINTF(2, ("hytp14_attach: registering sensor %d (%s)\n", i, sc->sc_sensors[i].desc)); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensors[i])) { aprint_error_dev(sc->sc_dev, "unable to attach sensor\n"); sysmon_envsys_destroy(sc->sc_sme); return; } } sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = hytp14_refresh; DPRINTF(2, ("hytp14_attach: registering with envsys\n")); if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(sc->sc_dev, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); return; } aprint_normal(": HYT-221/271/939 humidity and temperature sensor\n"); }
static void thinkpad_sensors_init(thinkpad_softc_t *sc) { int i, j; if (sc->sc_ecdev == NULL) return; /* no chance of this working */ sc->sc_sme = sysmon_envsys_create(); for (i = j = 0; i < THINKPAD_NTEMPSENSORS; i++) { sc->sc_sensor[i].units = ENVSYS_STEMP; sc->sc_sensor[i].state = ENVSYS_SINVALID; sc->sc_sensor[i].flags = ENVSYS_FHAS_ENTROPY; (void)snprintf(sc->sc_sensor[i].desc, sizeof(sc->sc_sensor[i].desc), "temperature %d", i); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i]) != 0) goto fail; } for (i = THINKPAD_NTEMPSENSORS; i < THINKPAD_NSENSORS; i++, j++) { sc->sc_sensor[i].units = ENVSYS_SFANRPM; sc->sc_sensor[i].state = ENVSYS_SINVALID; sc->sc_sensor[i].flags = ENVSYS_FHAS_ENTROPY; (void)snprintf(sc->sc_sensor[i].desc, sizeof(sc->sc_sensor[i].desc), "fan speed %d", j); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i]) != 0) goto fail; } sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = thinkpad_sensors_refresh; if (sysmon_envsys_register(sc->sc_sme) != 0) goto fail; return; fail: aprint_error_dev(sc->sc_dev, "failed to initialize sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); sc->sc_sme = NULL; }
static void asus_attach(device_t parent, device_t self, void *opaque) { struct asus_softc *sc = device_private(self); struct acpi_attach_args *aa = opaque; sc->sc_dev = self; sc->sc_node = aa->aa_node; aprint_naive("\n"); aprint_normal("\n"); asus_init(self); asus_sysctl_setup(sc); sc->sc_smpsw_valid = true; sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_name = PSWITCH_HK_DISPLAY_CYCLE; sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_type = PSWITCH_TYPE_HOTKEY; if (sysmon_pswitch_register(&sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE])) { aprint_error_dev(self, "couldn't register with sysmon\n"); sc->sc_smpsw_valid = false; } if (asus_get_fan_speed(sc, NULL) == false) goto out; sc->sc_sme = sysmon_envsys_create(); strcpy(sc->sc_sensor[ASUS_SENSOR_FAN].desc, "fan"); sc->sc_sensor[ASUS_SENSOR_FAN].units = ENVSYS_SFANRPM; sc->sc_sensor[ASUS_SENSOR_FAN].state = ENVSYS_SINVALID; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[ASUS_SENSOR_FAN]); sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = asus_sensors_refresh; sc->sc_sme->sme_flags = SME_POLL_ONLY; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "couldn't register with envsys\n"); sysmon_envsys_destroy(sc->sc_sme); sc->sc_sme = NULL; } out: (void)pmf_device_register(self, asus_suspend, asus_resume); (void)acpi_register_notify(sc->sc_node, asus_notify_handler); }
static void owtemp_attach(device_t parent, device_t self, void *aux) { struct owtemp_softc *sc = device_private(self); struct onewire_attach_args *oa = aux; aprint_naive("\n"); sc->sc_onewire = oa->oa_onewire; sc->sc_rom = oa->oa_rom; switch(ONEWIRE_ROM_FAMILY_TYPE(sc->sc_rom)) { case ONEWIRE_FAMILY_DS18B20: case ONEWIRE_FAMILY_DS1822: sc->sc_owtemp_decode = owtemp_decode_ds18b20; break; case ONEWIRE_FAMILY_DS1920: sc->sc_owtemp_decode = owtemp_decode_ds1920; break; } sc->sc_sme = sysmon_envsys_create(); /* Initialize sensor */ sc->sc_sensor.units = ENVSYS_STEMP; sc->sc_sensor.state = ENVSYS_SINVALID; (void)strlcpy(sc->sc_sensor.desc, device_xname(self), sizeof(sc->sc_sensor.desc)); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor)) { sysmon_envsys_destroy(sc->sc_sme); return; } /* Hook into system monitor. */ sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = owtemp_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); return; } aprint_normal("\n"); }
static void tps65217pmic_envsys_register(struct tps65217pmic_softc *sc) { int i; sc->sc_sme = sysmon_envsys_create(); /* iterate over all regulators and attach them as sensors */ for(i = 0; i <= SNUM_REGS; i++) { /* set name */ strlcpy(sc->sc_regsensor[i].desc, tps_regulators[i].name, sizeof(sc->sc_regsensor[i].desc)); sc->sc_regsensor[i].units = ENVSYS_SVOLTS_DC; sc->sc_regsensor[i].state = ENVSYS_SINVALID; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_regsensor[i])) aprint_error_dev(sc->sc_dev, "error attaching regulator sensor %d\n", i); } /* attach power source indicators */ strcpy(sc->sc_usbsensor.desc, "USB power source"); /* SNUM_USBSTATUS */ sc->sc_usbsensor.units = ENVSYS_INDICATOR; sc->sc_usbsensor.state = ENVSYS_SINVALID; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_usbsensor)) aprint_error_dev(sc->sc_dev, "error attaching USB power source sensor\n"); strcpy(sc->sc_acsensor.desc, "AC power source"); /* SNUM_ACSTATUS */ sc->sc_acsensor.units = ENVSYS_INDICATOR; sc->sc_acsensor.state = ENVSYS_SINVALID; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_acsensor)) aprint_error_dev(sc->sc_dev, "error attaching AC power source sensor\n"); /* register everything in sysmon */ sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = tps65217pmic_envsys_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(sc->sc_dev, "unable to register in sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); } }
int cac_create_sensors(struct cac_softc *sc) { int i; int nsensors = sc->sc_nunits; sc->sc_sme = sysmon_envsys_create(); sc->sc_sensor = malloc(sizeof(envsys_data_t) * nsensors, M_DEVBUF, M_NOWAIT | M_ZERO); if (sc->sc_sensor == NULL) { aprint_error_dev(sc->sc_dev, "can't allocate envsys_data_t\n"); return(ENOMEM); } for (i = 0; i < nsensors; i++) { sc->sc_sensor[i].units = ENVSYS_DRIVE; sc->sc_sensor[i].state = ENVSYS_SINVALID; sc->sc_sensor[i].value_cur = ENVSYS_DRIVE_EMPTY; /* Enable monitoring for drive state changes */ sc->sc_sensor[i].flags |= ENVSYS_FMONSTCHANGED; /* logical drives */ snprintf(sc->sc_sensor[i].desc, sizeof(sc->sc_sensor[i].desc), "%s:%d", device_xname(sc->sc_dev), i); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) goto out; } sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = cac_sensor_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(sc->sc_dev, "unable to register with sysmon\n"); return(1); } return (0); out: free(sc->sc_sensor, M_DEVBUF); sysmon_envsys_destroy(sc->sc_sme); return EINVAL; }
static void thinkpad_sensors_init(thinkpad_softc_t *sc) { char sname[5] = "TMP?"; char fname[5] = "FAN?"; int i, j, err; if (sc->sc_ecdev == NULL) return; /* no chance of this working */ sc->sc_sme = sysmon_envsys_create(); for (i = 0; i < THINKPAD_NTEMPSENSORS; i++) { sname[3] = '0' + i; strcpy(sc->sc_sensor[i].desc, sname); sc->sc_sensor[i].units = ENVSYS_STEMP; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) aprint_error_dev(sc->sc_dev, "couldn't attach sensor %s\n", sname); } j = i; /* THINKPAD_NTEMPSENSORS */ for (; i < (j + THINKPAD_NFANSENSORS); i++) { fname[3] = '0' + (i - j); strcpy(sc->sc_sensor[i].desc, fname); sc->sc_sensor[i].units = ENVSYS_SFANRPM; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) aprint_error_dev(sc->sc_dev, "couldn't attach sensor %s\n", fname); } sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = thinkpad_sensors_refresh; err = sysmon_envsys_register(sc->sc_sme); if (err) { aprint_error_dev(sc->sc_dev, "couldn't register with sysmon: %d\n", err); sysmon_envsys_destroy(sc->sc_sme); } }
static void omap3_scm_sensor_attach(struct omap3_scm_softc *sc) { uint32_t ctrl; /* Enable single conversion mode */ ctrl = SCM_READ_REG(sc, CONTROL_TEMP_SENSOR); ctrl &= ~CONTROL_TEMP_SENSOR_CONTCONV; SCM_WRITE_REG(sc, CONTROL_TEMP_SENSOR, ctrl); sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_refresh = omap3_scm_sensor_refresh; sc->sc_sensor.units = ENVSYS_STEMP; sc->sc_sensor.state = ENVSYS_SINVALID; sc->sc_sensor.flags = ENVSYS_FHAS_ENTROPY; strlcpy(sc->sc_sensor.desc, "TEMP", sizeof(sc->sc_sensor.desc)); sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor); sysmon_envsys_register(sc->sc_sme); }
static void battery_setup_envsys(struct battery_softc *sc) { int i; sc->sc_sme = sysmon_envsys_create(); INITDATA(BAT_CPU_TEMPERATURE, ENVSYS_STEMP, "CPU temperature"); INITDATA(BAT_AC_PRESENT, ENVSYS_INDICATOR, "AC present"); INITDATA(BAT_PRESENT, ENVSYS_INDICATOR, "Battery present"); INITDATA(BAT_VOLTAGE, ENVSYS_SVOLTS_DC, "Battery voltage"); INITDATA(BAT_CHARGE, ENVSYS_SAMPHOUR, "Battery charge"); INITDATA(BAT_MAX_CHARGE, ENVSYS_SAMPHOUR, "Battery design cap"); INITDATA(BAT_CURRENT, ENVSYS_SAMPS, "Battery current"); INITDATA(BAT_TEMPERATURE, ENVSYS_STEMP, "Battery temperature"); INITDATA(BAT_CHARGING, ENVSYS_BATTERY_CHARGE, "Battery charging"); INITDATA(BAT_FULL, ENVSYS_INDICATOR, "Battery full"); #undef INITDATA for (i = 0; i < BAT_NSENSORS; i++) { if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); return; } } sc->sc_sme->sme_name = sc->sc_dev.dv_xname; sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = battery_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error("%s: unable to register with sysmon\n", sc->sc_dev.dv_xname); sysmon_envsys_destroy(sc->sc_sme); } }
static void vcmbox_attach(device_t parent, device_t self, void *aux) { struct vcmbox_softc *sc = device_private(self); sc->sc_dev = self; aprint_naive("\n"); aprint_normal("\n"); vcmbox_cpufreq_init(sc); sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_refresh = vcmbox_sensor_refresh; sc->sc_sme->sme_get_limits = vcmbox_sensor_get_limits; vcmbox_create_sensors(sc); if (sysmon_envsys_register(sc->sc_sme) == 0) return; aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); }
void uyurex_attach(device_t parent, device_t self, void *aux) { struct uyurex_softc *sc = device_private(self); struct usb_attach_arg *uaa = aux; struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa; usbd_device_handle dev = uha->parent->sc_udev; int size, repid, err; void *desc; sc->sc_udev = dev; sc->sc_hdev.sc_dev = self; sc->sc_hdev.sc_intr = uyurex_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); aprint_normal("\n"); aprint_naive("\n"); err = uhidev_open(&sc->sc_hdev); if (err) { aprint_error_dev(self, "uyurex_open: uhidev_open %d\n", err); return; } sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK); usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_hdev.sc_dev); /* attach sensor */ sc->sc_sme = sysmon_envsys_create(); /* error handling? XXX */ sc->sc_sme->sme_name = device_xname(self); /* add BBU sensor */ sc->sc_sensor_val.units = ENVSYS_INTEGER; sc->sc_sensor_val.state = ENVSYS_SINVALID; sc->sc_sensor_val.flags = ENVSYS_FMONCRITICAL; /* abuse XXX */ strlcpy(sc->sc_sensor_val.desc, "BBU", sizeof(sc->sc_sensor_val.desc)); sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_val); /* add BBU delta sensor */ sc->sc_sensor_delta.units = ENVSYS_INTEGER; sc->sc_sensor_delta.state = ENVSYS_SINVALID; strlcpy(sc->sc_sensor_delta.desc, "mBBU/sec", sizeof(sc->sc_sensor_delta.desc)); sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_delta); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = uyurex_refresh; sc->sc_sme->sme_events_timeout = UPDATE_TICK; sc->sc_sme->sme_flags = SME_INIT_REFRESH; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); } callout_init(&sc->sc_deltach, 0); callout_reset(&sc->sc_deltach, UPDATE_TICK * hz, uyurex_delta, sc); DPRINTF(("uyurex_attach: complete\n")); /* init device */ /* XXX */ uyurex_set_mode(sc, 0); }
void ug2_attach(device_t dv) { struct ug_softc *sc = device_private(dv); uint8_t buf[2]; int i; struct ug2_motherboard_info *ai; struct ug2_sensor_info *si; aprint_normal(": Abit uGuru 2005 system monitor\n"); if (ug2_read(sc, UG2_MISC_BANK, UG2_BOARD_ID, 2, buf) != 2) { aprint_error_dev(dv, "Cannot detect board ID. Using default\n"); buf[0] = UG_MAX_MSB_BOARD; buf[1] = UG_MAX_LSB_BOARD; } if (buf[0] > UG_MAX_MSB_BOARD || buf[1] > UG_MAX_LSB_BOARD || buf[1] < UG_MIN_LSB_BOARD) { aprint_error_dev(dv, "Invalid board ID(%X,%X). Using default\n", buf[0], buf[1]); buf[0] = UG_MAX_MSB_BOARD; buf[1] = UG_MAX_LSB_BOARD; } ai = &ug2_mb[buf[1] - UG_MIN_LSB_BOARD]; aprint_normal_dev(dv, "mainboard %s (%.2X%.2X)\n", ai->name, buf[0], buf[1]); sc->mbsens = (void*)ai->sensors; sc->sc_sme = sysmon_envsys_create(); for (i = 0, si = ai->sensors; si && si->name; si++, i++) { COPYDESCR(sc->sc_sensor[i].desc, si->name); sc->sc_sensor[i].rfact = 1; sc->sc_sensor[i].state = ENVSYS_SVALID; switch (si->type) { case UG2_VOLTAGE_SENSOR: sc->sc_sensor[i].units = ENVSYS_SVOLTS_DC; sc->sc_sensor[i].rfact = UG_RFACT; break; case UG2_TEMP_SENSOR: sc->sc_sensor[i].units = ENVSYS_STEMP; break; case UG2_FAN_SENSOR: sc->sc_sensor[i].units = ENVSYS_SFANRPM; break; default: break; } if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); return; } } #undef COPYDESCR sc->sc_sme->sme_name = device_xname(dv); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = ug2_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(dv, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); } }
static void acpitz_init_envsys(device_t dv) { const int flags = ENVSYS_FMONLIMITS | ENVSYS_FMONNOTSUPP | ENVSYS_FHAS_ENTROPY; struct acpitz_softc *sc = device_private(dv); unsigned int i; sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_name = device_xname(dv); sc->sc_sme->sme_flags = SME_DISABLE_REFRESH; sc->sc_sme->sme_get_limits = acpitz_get_limits; sc->sc_temp_sensor.flags = flags; sc->sc_temp_sensor.units = ENVSYS_STEMP; sc->sc_temp_sensor.state = ENVSYS_SINVALID; memset(sc->sc_temp_sensor.desc, 0, sizeof(sc->sc_temp_sensor.desc)); if (sc->sc_psl) { for (i = 0; sc->sc_psl[i] != NULL; i++) { if (i > 0) strlcat(sc->sc_temp_sensor.desc, "/", sizeof(sc->sc_temp_sensor.desc)); strlcat(sc->sc_temp_sensor.desc, device_xname(sc->sc_psl[i]->ci_dev), sizeof(sc->sc_temp_sensor.desc)); } strlcat(sc->sc_temp_sensor.desc, " ", sizeof(sc->sc_temp_sensor.desc)); } strlcat(sc->sc_temp_sensor.desc, "temperature", sizeof(sc->sc_temp_sensor.desc)); if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_temp_sensor)) goto out; if (sc->sc_have_fan != false) { sc->sc_fan_sensor.flags = flags; sc->sc_fan_sensor.units = ENVSYS_SFANRPM; sc->sc_fan_sensor.state = ENVSYS_SINVALID; (void)strlcpy(sc->sc_fan_sensor.desc, "FAN", sizeof(sc->sc_fan_sensor.desc)); /* Ignore error because fan sensor is optional. */ (void)sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_fan_sensor); } if (sysmon_envsys_register(sc->sc_sme) == 0) return; out: aprint_error_dev(dv, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); sc->sc_sme = NULL; }
static void adm1026_attach(device_t parent, device_t self, void *aux) { struct adm1026_softc *sc = device_private(self); struct i2c_attach_args *ia = aux; prop_dictionary_t props = device_properties(self); uint8_t val, fan_div2; int err, div2_val; sc->sc_tag = ia->ia_tag; sc->sc_address = ia->ia_addr; sc->sc_dev = self; sc->sc_iic_flags = I2C_F_POLL; /* Use polling during autoconf */ sc->sc_multi_read = false; prop_dictionary_get_bool(props, "multi_read", &sc->sc_multi_read); if (prop_dictionary_get_uint8(props, "fan_div2", &fan_div2) != 0) div2_val = fan_div2; else div2_val = -1; (void) adm1026_ident(sc); aprint_normal(": ADM1026 hardware monitor: rev. 0x%x, step. 0x%x\n", ADM1026_REVISION(sc->sc_rev), ADM1026_STEPPING(sc->sc_rev)); /* * Start monitoring if not already monitoring. * Wait 1.8s for the fan readings to stabilise. */ if ((err = adm1026_read_reg(sc, ADM1026_CONF1, &val)) != 0) { aprint_error_dev(sc->sc_dev, ": unable to read conf1\n"); return; } if (!(val & ADM1026_CONF1_MONITOR)) { aprint_normal_dev(sc->sc_dev, ": starting monitoring, waiting 1.8s for readings\n"); val |= ADM1026_CONF1_MONITOR; if ((err = adm1026_write_reg(sc, ADM1026_CONF1, val)) != 0) { aprint_error_dev(sc->sc_dev, ": unable to write conf1\n"); return; } delay(1800000); } sc->sc_cfg[0] = val; sc->sc_sme = sysmon_envsys_create(); sc->sc_nfans = 0; adm1026_setup_fans(sc, div2_val); sc->sc_ntemps = 0; adm1026_setup_temps(sc); adm1026_setup_volts(sc); aprint_normal_dev(self, "%d fans, %d temperatures, %d voltages\n", sc->sc_nfans, sc->sc_ntemps, sc->sc_ntemps == 3 ? 15 : 17); sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = adm1026_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); return; } if (!pmf_device_register(self, adm1026_pmf_suspend, adm1026_pmf_resume)) aprint_error_dev(self, "couldn't establish power handler\n"); sc->sc_iic_flags = 0; /* Drop polling flag */ return; }
static int apple_smc_fan_attach_sensors(struct apple_smc_fan_softc *sc) { uint8_t fan, sensor; char fan_desc_key_name[4 + 1]; struct apple_smc_key *fan_desc_key; struct fan_desc fan_desc; char name[sizeof(fan_desc.fd_name) + 1]; int error; /* Create a sysmon_envsys record, but don't register it yet. */ sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = apple_smc_fan_refresh; /* Create an array of fan sensor records. */ CTASSERT(10 <= (SIZE_MAX / sizeof(sc->sc_fans[0]))); sc->sc_fans = kmem_zalloc((sizeof(sc->sc_fans[0]) * sc->sc_nfans), KM_SLEEP); /* Find all the fans. */ for (fan = 0; fan < sc->sc_nfans; fan++) { /* Format the name of the key for the fan's description. */ (void)snprintf(fan_desc_key_name, sizeof(fan_desc_key_name), "F%"PRIu8"ID", fan); KASSERT(4 == strlen(fan_desc_key_name)); /* Look up the key for this fan's description. */ error = apple_smc_named_key(sc->sc_smc, fan_desc_key_name, APPLE_SMC_TYPE_FANDESC, &fan_desc_key); if (error) { aprint_error_dev(sc->sc_dev, "error identifying fan %"PRIu8": %d\n", fan, error); continue; } /* Read the description of this fan. */ error = apple_smc_read_key(sc->sc_smc, fan_desc_key, &fan_desc, sizeof(fan_desc)); if (error) { aprint_error_dev(sc->sc_dev, "error identifying fan %"PRIu8": %d\n", fan, error); continue; } /* * XXX Do more with the fan description... */ /* Make a null-terminated copy of this fan's description. */ (void)memcpy(name, fan_desc.fd_name, sizeof(fan_desc.fd_name)); name[sizeof(fan_desc.fd_name)] = '\0'; /* Attach all the sensors for this fan. */ for (sensor = 0; sensor < __arraycount(fan_sensors); sensor++) apple_smc_fan_attach_sensor(sc, fan, name, sensor); #if 0 /* XXX sysctl */ /* Attach sysctl knobs to control this fan. */ apple_smc_fan_sysctl_setup_1(sc, fan); #endif } /* Fan sensors are all attached. Register with sysmon_envsys now. */ error = sysmon_envsys_register(sc->sc_sme); if (error) goto fail; /* Success! */ error = 0; goto out; fail: sysmon_envsys_destroy(sc->sc_sme); sc->sc_sme = NULL; out: return error; }
static void wmi_hp_sensor_init(struct wmi_hp_softc *sc) { int sensor; KDASSERT(sc->sc_sme == NULL); KDASSERT(sc->sc_sensor != NULL); (void)memset(sc->sc_sensor, 0, WMI_HP_SENSOR_SIZE); sc->sc_sme = sysmon_envsys_create(); wmi_hp_switch_init(sc); if (wmi_hp_method_read(sc, WMI_HP_METHOD_CMD_HDDTEMP) == true) { sensor = WMI_HP_SENSOR_HDDTEMP; (void)strlcpy(sc->sc_sensor[sensor].desc, "hddtemp", ENVSYS_DESCLEN); sc->sc_sensor[sensor].state = ENVSYS_SVALID; sc->sc_sensor[sensor].units = ENVSYS_STEMP; sc->sc_sensor[sensor].value_cur = sc->sc_val * 1000000 + 273150000; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[sensor]); } if (wmi_hp_method_read(sc, WMI_HP_METHOD_CMD_DISPLAY) == true) { sensor = WMI_HP_SENSOR_DISPLAY; (void)strlcpy(sc->sc_sensor[sensor].desc, "display", ENVSYS_DESCLEN); sc->sc_sensor[sensor].state = ENVSYS_SVALID; sc->sc_sensor[sensor].units = ENVSYS_INDICATOR; sc->sc_sensor[sensor].value_cur = sc->sc_val; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[sensor]); } if (wmi_hp_method_read(sc, WMI_HP_METHOD_CMD_DOCK) == true) { sensor = WMI_HP_SENSOR_DOCK; (void)strlcpy(sc->sc_sensor[sensor].desc, "docking station", ENVSYS_DESCLEN); sc->sc_sensor[sensor].state = ENVSYS_SVALID; sc->sc_sensor[sensor].units = ENVSYS_INDICATOR; sc->sc_sensor[sensor].value_cur = sc->sc_val; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[sensor]); } sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = wmi_hp_sensor_refresh; sc->sc_sme->sme_name = device_xname(sc->sc_dev); if (sysmon_envsys_register(sc->sc_sme) != 0) goto fail; wmi_hp_sensor_switch_update(sc->sc_dev); return; fail: aprint_debug_dev(sc->sc_dev, "failed to initialize sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); kmem_free(sc->sc_sensor, WMI_HP_SENSOR_SIZE); sc->sc_sme = NULL; sc->sc_sensor = NULL; }
/* * Get the base address for the monitoring registers and set up the * sysmon_envsys(9) framework. */ static void smsc_attach(device_t parent, device_t self, void *aux) { struct smsc_softc *sc = device_private(self); struct isa_attach_args *ia = aux; bus_space_handle_t ioh; uint8_t rev, msb, lsb, chipid; unsigned address; int i; sc->sc_iot = ia->ia_iot; aprint_naive("\n"); /* * To attach we need to find the actual Hardware Monitor * I/O address space. */ if (bus_space_map(ia->ia_iot, ia->ia_io[0].ir_addr, 2, 0, &ioh)) { aprint_error(": can't map base i/o space\n"); return; } /* Enter config mode */ bus_space_write_1(ia->ia_iot, ioh, SMSC_ADDR, SMSC_CONFIG_START); /* * While we have the base registers mapped, grab the chip * revision and device ID. */ rev = smsc_readreg(ia->ia_iot, ioh, SMSC_DEVICE_REVISION); chipid = smsc_readreg(ia->ia_iot, ioh, SMSC_DEVICE_ID); /* Select the Hardware Monitor LDN */ smsc_writereg(ia->ia_iot, ioh, SMSC_LOGICAL_DEV_SEL, SMSC_LOGICAL_DEVICE); /* Read the base address for the registers. */ msb = smsc_readreg(ia->ia_iot, ioh, SMSC_IO_BASE_MSB); lsb = smsc_readreg(ia->ia_iot, ioh, SMSC_IO_BASE_LSB); address = (msb << 8) | lsb; /* Exit config mode */ bus_space_write_1(ia->ia_iot, ioh, SMSC_ADDR, SMSC_CONFIG_END); bus_space_unmap(ia->ia_iot, ioh, 2); /* Map the Hardware Monitor I/O space. */ if (bus_space_map(ia->ia_iot, address, 2, 0, &sc->sc_ioh)) { aprint_error(": can't map register i/o space\n"); return; } sc->sc_sme = sysmon_envsys_create(); #define INITSENSOR(index, string, reg, type) \ do { \ strlcpy(sc->sc_sensor[index].desc, string, \ sizeof(sc->sc_sensor[index].desc)); \ sc->sc_sensor[index].units = type; \ sc->sc_regs[index] = reg; \ sc->sc_sensor[index].state = ENVSYS_SVALID; \ } while (/* CONSTCOND */ 0) /* Temperature sensors */ INITSENSOR(0, "Temp0", SMSC_TEMP1, ENVSYS_STEMP); INITSENSOR(1, "Temp1", SMSC_TEMP2, ENVSYS_STEMP); INITSENSOR(2, "Temp2", SMSC_TEMP3, ENVSYS_STEMP); INITSENSOR(3, "Temp3", SMSC_TEMP4, ENVSYS_STEMP); /* Fan sensors */ INITSENSOR(4, "Fan0", SMSC_FAN1_LSB, ENVSYS_SFANRPM); INITSENSOR(5, "Fan1", SMSC_FAN2_LSB, ENVSYS_SFANRPM); INITSENSOR(6, "Fan2", SMSC_FAN3_LSB, ENVSYS_SFANRPM); INITSENSOR(7, "Fan3", SMSC_FAN4_LSB, ENVSYS_SFANRPM); for (i = 0; i < SMSC_MAX_SENSORS; i++) { sc->sc_sensor[i].state = ENVSYS_SINVALID; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); bus_space_unmap(sc->sc_iot, sc->sc_ioh, 2); return; } } sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = smsc_refresh; if ((i = sysmon_envsys_register(sc->sc_sme)) != 0) { aprint_error(": unable to register with sysmon (%d)\n", i); sysmon_envsys_destroy(sc->sc_sme); bus_space_unmap(sc->sc_iot, sc->sc_ioh, 2); return; } switch (chipid) { case SMSC_ID_47B397: aprint_normal(": SMSC LPC47B397 Super I/O"); break; case SMSC_ID_SCH5307NS: aprint_normal(": SMSC SCH5307-NS Super I/O"); break; case SMSC_ID_SCH5317: aprint_normal(": SMSC SCH5317 Super I/O"); break; } aprint_normal(" (rev %u)\n", rev); aprint_normal_dev(self, "Hardware Monitor registers at 0x%04x\n", address); }
static void aps_attach(device_t parent, device_t self, void *aux) { struct aps_softc *sc = device_private(self); struct isa_attach_args *ia = aux; int iobase, i; sc->sc_iot = ia->ia_iot; iobase = ia->ia_io[0].ir_addr; if (bus_space_map(sc->sc_iot, iobase, APS_ADDR_SIZE, 0, &sc->sc_ioh)) { aprint_error(": can't map i/o space\n"); return; } aprint_naive("\n"); aprint_normal("\n"); if (!aps_init(sc)) { aprint_error_dev(self, "failed to initialise\n"); goto out; } /* Initialize sensors */ #define INITDATA(idx, unit, string) \ sc->sc_sensor[idx].units = unit; \ strlcpy(sc->sc_sensor[idx].desc, string, \ sizeof(sc->sc_sensor[idx].desc)); INITDATA(APS_SENSOR_XACCEL, ENVSYS_INTEGER, "X_ACCEL"); INITDATA(APS_SENSOR_YACCEL, ENVSYS_INTEGER, "Y_ACCEL"); INITDATA(APS_SENSOR_TEMP1, ENVSYS_STEMP, "TEMP_1"); INITDATA(APS_SENSOR_TEMP2, ENVSYS_STEMP, "TEMP_2"); INITDATA(APS_SENSOR_XVAR, ENVSYS_INTEGER, "X_VAR"); INITDATA(APS_SENSOR_YVAR, ENVSYS_INTEGER, "Y_VAR"); INITDATA(APS_SENSOR_KBACT, ENVSYS_INDICATOR, "Keyboard Active"); INITDATA(APS_SENSOR_MSACT, ENVSYS_INDICATOR, "Mouse Active"); INITDATA(APS_SENSOR_LIDOPEN, ENVSYS_INDICATOR, "Lid Open"); sc->sc_sme = sysmon_envsys_create(); for (i = 0; i < APS_NUM_SENSORS; i++) { sc->sc_sensor[i].state = ENVSYS_SVALID; if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); goto out; } } /* * Register with the sysmon_envsys(9) framework. */ sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_flags = SME_DISABLE_REFRESH; if ((i = sysmon_envsys_register(sc->sc_sme))) { aprint_error_dev(self, "unable to register with sysmon (%d)\n", i); sysmon_envsys_destroy(sc->sc_sme); goto out; } if (!pmf_device_register(self, aps_suspend, aps_resume)) aprint_error_dev(self, "couldn't establish power handler\n"); /* Refresh sensor data every 0.5 seconds */ callout_init(&sc->sc_callout, 0); callout_setfunc(&sc->sc_callout, aps_refresh, sc); callout_schedule(&sc->sc_callout, (hz) / 2); aprint_normal_dev(self, "Thinkpad Active Protection System\n"); return; out: bus_space_unmap(sc->sc_iot, sc->sc_ioh, APS_ADDR_SIZE); }
static void ecadc_attach(device_t parent, device_t self, void *aux) { struct i2c_attach_args *ia = aux; struct ecadc_softc *sc = device_private(self); u_char term[256]; u_char *cp, *desc; int64_t minv, warnv, crit, num, den; u_int8_t junk[PCF8591_CHANNELS + 1]; envsys_data_t *sensor; int len, error, addr, chan, node = (int)ia->ia_cookie; u_int i; sc->sc_dev = self; if ((len = OF_getprop(node, "thermisters", term, sizeof(term))) < 0) { aprint_error(": couldn't find \"thermisters\" property\n"); return; } if (OF_getprop(node, "cpu-temp-factors", &sc->sc_cpu_xlate[2], sizeof(sc->sc_cpu_xlate) - 2) < 0) { aprint_error(": couldn't find \"cpu-temp-factors\" property\n"); return; } sc->sc_cpu_xlate[0] = sc->sc_cpu_xlate[1] = sc->sc_cpu_xlate[2]; /* Only the Sun Enterprise 450 has these. */ OF_getprop(node, "ps-temp-factors", &sc->sc_ps_xlate[2], sizeof(sc->sc_ps_xlate) - 2); sc->sc_ps_xlate[0] = sc->sc_ps_xlate[1] = sc->sc_ps_xlate[2]; cp = term; while (cp < term + len) { addr = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; chan = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; minv = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; warnv = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; crit = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; num = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; den = cp[0] << 24 | cp[1] << 16 | cp[2] << 8 | cp[3]; cp += 4; desc = cp; while (cp < term + len && *cp++); if (addr != (ia->ia_addr << 1)) continue; if (num == 0 || den == 0) num = den = 1; sc->sc_channels[sc->sc_nchan].chan_num = chan; sensor = &sc->sc_channels[sc->sc_nchan].chan_sensor; sensor->units = ENVSYS_STEMP; sensor->flags |= ENVSYS_FMONLIMITS; sensor->state = ENVSYS_SINVALID; strlcpy(sensor->desc, desc, sizeof(sensor->desc)); if (strncmp(desc, "CPU", 3) == 0) sc->sc_channels[sc->sc_nchan].chan_xlate = sc->sc_cpu_xlate; else if (strncmp(desc, "PS", 2) == 0) sc->sc_channels[sc->sc_nchan].chan_xlate = sc->sc_ps_xlate; else sc->sc_channels[sc->sc_nchan].chan_factor = (1000000 * num) / den; sc->sc_channels[sc->sc_nchan].chan_min = 273150000 + 1000000 * minv; sc->sc_channels[sc->sc_nchan].chan_warn = 273150000 + 1000000 * warnv; sc->sc_channels[sc->sc_nchan].chan_crit = 273150000 + 1000000 * crit; sc->sc_nchan++; } 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)) { aprint_error(": read failed\n"); iic_release_bus(sc->sc_tag, 0); return; } iic_release_bus(sc->sc_tag, 0); /* Hook us into the sysmon_envsys subsystem */ sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = ecadc_refresh; sc->sc_sme->sme_get_limits = ecadc_get_limits; /* Initialize sensor data. */ for (i = 0; i < sc->sc_nchan; i++) sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_channels[i].chan_sensor); error = sysmon_envsys_register(sc->sc_sme); if (error) { aprint_error_dev(self, "error %d registering with sysmon\n", error); sysmon_envsys_destroy(sc->sc_sme); return; } aprint_naive(": Temp Sensors\n"); aprint_normal(": %s Temp Sensors\n", ia->ia_name); }
static int swsensor_init(void *arg) { int error, val = 0; const char *key, *str; prop_dictionary_t pd = (prop_dictionary_t)arg; prop_object_t po, obj; prop_object_iterator_t iter; prop_type_t type; const struct sme_descr_entry *descr; swsensor_sme = sysmon_envsys_create(); if (swsensor_sme == NULL) return ENOTTY; swsensor_sme->sme_name = "swsensor"; swsensor_sme->sme_cookie = &swsensor_edata; swsensor_sme->sme_refresh = swsensor_refresh; swsensor_sme->sme_set_limits = NULL; swsensor_sme->sme_get_limits = NULL; /* Set defaults in case no prop dictionary given */ swsensor_edata.units = ENVSYS_INTEGER; swsensor_edata.flags = 0; sw_sensor_mode = 0; sw_sensor_value = 0; sw_sensor_limit = 0; /* Iterate over the provided dictionary, if any */ if (pd != NULL) { iter = prop_dictionary_iterator(pd); if (iter == NULL) return ENOMEM; while ((obj = prop_object_iterator_next(iter)) != NULL) { key = prop_dictionary_keysym_cstring_nocopy(obj); po = prop_dictionary_get_keysym(pd, obj); type = prop_object_type(po); if (type == PROP_TYPE_NUMBER) val = prop_number_integer_value(po); /* Sensor type/units */ if (strcmp(key, "type") == 0) { if (type == PROP_TYPE_NUMBER) { descr = sme_find_table_entry( SME_DESC_UNITS, val); if (descr == NULL) return EINVAL; swsensor_edata.units = descr->type; continue; } if (type != PROP_TYPE_STRING) return EINVAL; str = prop_string_cstring_nocopy(po); descr = sme_find_table_desc(SME_DESC_UNITS, str); if (descr == NULL) return EINVAL; swsensor_edata.units = descr->type; continue; } /* Sensor flags */ if (strcmp(key, "flags") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; swsensor_edata.flags = val; continue; } /* Sensor limit behavior * 0 - simple sensor, no hw limits * 1 - simple sensor, hw provides initial limit * 2 - complex sensor, hw provides settable * limits and does its own limit checking */ if (strcmp(key, "mode") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; sw_sensor_mode = val; if (sw_sensor_mode > 2) sw_sensor_mode = 2; else if (sw_sensor_mode < 0) sw_sensor_mode = 0; continue; } /* Grab any limit that might be specified */ if (strcmp(key, "limit") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; sw_sensor_limit = val; continue; } /* Grab the initial value */ if (strcmp(key, "value") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; sw_sensor_value = val; continue; } /* Grab value_min and value_max */ if (strcmp(key, "value_min") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; swsensor_edata.value_min = val; swsensor_edata.flags |= ENVSYS_FVALID_MIN; continue; } if (strcmp(key, "value_max") == 0) { if (type != PROP_TYPE_NUMBER) return EINVAL; swsensor_edata.value_max = val; swsensor_edata.flags |= ENVSYS_FVALID_MAX; continue; } /* See if sensor reports percentages vs raw values */ if (strcmp(key, "percentage") == 0) { if (type != PROP_TYPE_BOOL) return EINVAL; if (prop_bool_true(po)) swsensor_edata.flags |= ENVSYS_FPERCENT; continue; } /* Unrecognized dicttionary object */ #ifdef DEBUG printf("%s: unknown attribute %s\n", __func__, key); #endif return EINVAL; } /* while */ prop_object_iterator_release(iter); } /* Initialize limit processing */ if (sw_sensor_mode >= 1) swsensor_sme->sme_get_limits = swsensor_get_limits; if (sw_sensor_mode == 2) swsensor_sme->sme_set_limits = swsensor_set_limits; if (sw_sensor_mode != 0) { swsensor_edata.flags |= ENVSYS_FMONLIMITS; swsensor_get_limits(swsensor_sme, &swsensor_edata, &sw_sensor_deflims, &sw_sensor_defprops); } strlcpy(swsensor_edata.desc, "sensor", ENVSYS_DESCLEN); /* Wait for refresh to validate the sensor value */ swsensor_edata.state = ENVSYS_SINVALID; sw_sensor_state = ENVSYS_SVALID; error = sysmon_envsys_sensor_attach(swsensor_sme, &swsensor_edata); if (error != 0) { aprint_error("sysmon_envsys_sensor_attach failed: %d\n", error); return error; } error = sysmon_envsys_register(swsensor_sme); if (error != 0) { aprint_error("sysmon_envsys_register failed: %d\n", error); return error; } sysctl_swsensor_setup(); aprint_normal("swsensor: initialized\n"); return 0; }
static void pic16lc_attach(device_t parent, device_t self, void *opaque) { struct pic16lc_softc *sc = device_private(self); struct i2c_attach_args *ia = opaque; u_char ver[4]; int i; sc->sc_dev = self; sc->sc_tag = ia->ia_tag; sc->sc_addr = ia->ia_addr; pic16lc = sc; sc->sc_sme = sysmon_envsys_create(); /* initialize CPU sensor */ sc->sc_sensor[XBOX_SENSOR_CPU].units = ENVSYS_STEMP; (void)strlcpy(sc->sc_sensor[XBOX_SENSOR_CPU].desc, "Xbox CPU Temp", sizeof(sc->sc_sensor[XBOX_SENSOR_CPU])); /* initialize board sensor */ sc->sc_sensor[XBOX_SENSOR_BOARD].units = ENVSYS_STEMP; (void)strlcpy(sc->sc_sensor[XBOX_SENSOR_BOARD].desc, "Xbox Board Temp", sizeof(sc->sc_sensor[XBOX_SENSOR_BOARD])); for (i = 0; i < XBOX_NSENSORS; i++) { if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); return; } } /* hook into sysmon */ sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = pic16lc_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); return; } if (iic_acquire_bus(sc->sc_tag, 0) != 0) { aprint_error(": unable to acquire i2c bus\n"); return; } aprint_normal(": Xbox System Management Controller"); /* find the PIC version */ pic16lc_write_1(sc, PIC16LC_REG_VER, 0x00); pic16lc_read_1(sc, PIC16LC_REG_VER, &ver[0]); pic16lc_read_1(sc, PIC16LC_REG_VER, &ver[1]); pic16lc_read_1(sc, PIC16LC_REG_VER, &ver[2]); ver[3] = '\0'; aprint_normal(" (rev. %s)\n", ver); pic16lc_setled(0xff); /* orange */ iic_release_bus(sc->sc_tag, 0); /* disable reset on eject */ pic16lc_write_1(sc, PIC16LC_REG_RESETONEJECT, 0x01); sc->sc_ih = iic_smbus_intr_establish_proc(sc->sc_tag, pic16lc_intr, sc); if (sc->sc_ih == NULL) aprint_error_dev(self, "couldn't establish interrupt\n"); return; }
static void tctrl_sensor_setup(struct tctrl_softc *sc) { int i, error; sc->sc_sme = sysmon_envsys_create(); /* case temperature */ (void)strlcpy(sc->sc_sensor[0].desc, "Case temperature", sizeof(sc->sc_sensor[0].desc)); sc->sc_sensor[0].units = ENVSYS_STEMP; sc->sc_sensor[0].state = ENVSYS_SINVALID; /* battery voltage */ (void)strlcpy(sc->sc_sensor[1].desc, "Internal battery voltage", sizeof(sc->sc_sensor[1].desc)); sc->sc_sensor[1].units = ENVSYS_SVOLTS_DC; sc->sc_sensor[1].state = ENVSYS_SINVALID; /* DC voltage */ (void)strlcpy(sc->sc_sensor[2].desc, "DC-In voltage", sizeof(sc->sc_sensor[2].desc)); sc->sc_sensor[2].units = ENVSYS_SVOLTS_DC; sc->sc_sensor[2].state = ENVSYS_SINVALID; for (i = 0; i < ENVSYS_NUMSENSORS; i++) { if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); return; } } sc->sc_sme->sme_name = device_xname(sc->sc_dev); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = tctrl_refresh; if ((error = sysmon_envsys_register(sc->sc_sme)) != 0) { printf("%s: couldn't register sensors (%d)\n", device_xname(sc->sc_dev), error); sysmon_envsys_destroy(sc->sc_sme); return; } /* now register the power button */ sysmon_task_queue_init(); sc->sc_powerpressed = 0; memset(&sc->sc_sm_pbutton, 0, sizeof(struct sysmon_pswitch)); sc->sc_sm_pbutton.smpsw_name = device_xname(sc->sc_dev); sc->sc_sm_pbutton.smpsw_type = PSWITCH_TYPE_POWER; if (sysmon_pswitch_register(&sc->sc_sm_pbutton) != 0) printf("%s: unable to register power button with sysmon\n", device_xname(sc->sc_dev)); memset(&sc->sc_sm_lid, 0, sizeof(struct sysmon_pswitch)); sc->sc_sm_lid.smpsw_name = device_xname(sc->sc_dev); sc->sc_sm_lid.smpsw_type = PSWITCH_TYPE_LID; if (sysmon_pswitch_register(&sc->sc_sm_lid) != 0) printf("%s: unable to register lid switch with sysmon\n", device_xname(sc->sc_dev)); memset(&sc->sc_sm_ac, 0, sizeof(struct sysmon_pswitch)); sc->sc_sm_ac.smpsw_name = device_xname(sc->sc_dev); sc->sc_sm_ac.smpsw_type = PSWITCH_TYPE_ACADAPTER; if (sysmon_pswitch_register(&sc->sc_sm_ac) != 0) printf("%s: unable to register AC adaptor with sysmon\n", device_xname(sc->sc_dev)); }
static void itesio_isa_attach(device_t parent, device_t self, void *aux) { struct itesio_softc *sc = device_private(self); struct isa_attach_args *ia = aux; int i; uint8_t cr; sc->sc_iot = ia->ia_iot; if (bus_space_map(sc->sc_iot, ia->ia_io[0].ir_addr, 2, 0, &sc->sc_ioh)) { aprint_error(": can't map i/o space\n"); return; } aprint_naive("\n"); /* * Enter to the Super I/O MB PNP mode. */ itesio_enter(sc->sc_iot, sc->sc_ioh); /* * Get info from the Super I/O Global Configuration Registers: * Chip IDs and Device Revision. */ sc->sc_chipid = (itesio_readreg(sc->sc_iot, sc->sc_ioh, ITESIO_CHIPID1) << 8); sc->sc_chipid |= itesio_readreg(sc->sc_iot, sc->sc_ioh, ITESIO_CHIPID2); sc->sc_devrev = (itesio_readreg(sc->sc_iot, sc->sc_ioh, ITESIO_DEVREV) & 0x0f); /* * Select the EC LDN to get the Base Address. */ itesio_writereg(sc->sc_iot, sc->sc_ioh, ITESIO_LDNSEL, ITESIO_EC_LDN); sc->sc_hwmon_baseaddr = (itesio_readreg(sc->sc_iot, sc->sc_ioh, ITESIO_EC_MSB) << 8); sc->sc_hwmon_baseaddr |= itesio_readreg(sc->sc_iot, sc->sc_ioh, ITESIO_EC_LSB); /* * We are done, exit MB PNP mode. */ itesio_exit(sc->sc_iot, sc->sc_ioh); aprint_normal(": iTE IT%4xF Super I/O (rev %d)\n", sc->sc_chipid, sc->sc_devrev); aprint_normal_dev(self, "Hardware Monitor registers at 0x%x\n", sc->sc_hwmon_baseaddr); if (bus_space_map(sc->sc_ec_iot, sc->sc_hwmon_baseaddr, 8, 0, &sc->sc_ec_ioh)) { aprint_error_dev(self, "cannot map hwmon i/o space\n"); goto out2; } sc->sc_hwmon_mapped = true; /* Activate monitoring */ cr = itesio_ecreadreg(sc, ITESIO_EC_CONFIG); SET(cr, 0x01); itesio_ecwritereg(sc, ITESIO_EC_CONFIG, cr); #ifdef notyet /* Enable beep alarms */ cr = itesio_ecreadreg(sc, ITESIO_EC_BEEPEER); SET(cr, 0x02); /* Voltage exceeds limit */ SET(cr, 0x04); /* Temperature exceeds limit */ itesio_ecwritereg(sc, ITESIO_EC_BEEPEER, cr); #endif /* * Initialize and attach sensors. */ itesio_setup_sensors(sc); sc->sc_sme = sysmon_envsys_create(); for (i = 0; i < IT_NUM_SENSORS; i++) { if (sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[i])) { sysmon_envsys_destroy(sc->sc_sme); goto out; } } /* * Hook into the system monitor. */ sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = itesio_refresh; if ((i = sysmon_envsys_register(sc->sc_sme))) { aprint_error_dev(self, "unable to register with sysmon (%d)\n", i); sysmon_envsys_destroy(sc->sc_sme); goto out; } sc->sc_hwmon_enabled = true; if (!pmf_device_register(self, NULL, NULL)) aprint_error_dev(self, "couldn't establish power handler\n"); /* The IT8705 doesn't support the WDT */ if (sc->sc_chipid == ITESIO_ID8705) goto out2; /* * Initialize the watchdog timer. */ sc->sc_smw.smw_name = device_xname(self); sc->sc_smw.smw_cookie = sc; sc->sc_smw.smw_setmode = itesio_wdt_setmode; sc->sc_smw.smw_tickle = itesio_wdt_tickle; sc->sc_smw.smw_period = 60; if (sysmon_wdog_register(&sc->sc_smw)) { aprint_error_dev(self, "unable to register watchdog timer\n"); goto out2; } sc->sc_wdt_enabled = true; aprint_normal_dev(self, "Watchdog Timer present\n"); return; out: bus_space_unmap(sc->sc_ec_iot, sc->sc_ec_ioh, 8); out2: bus_space_unmap(sc->sc_iot, sc->sc_ioh, 2); }