/* $NetBSD: uthum.c,v 1.16.2.1 2020/01/02 09:42:06 martin Exp $ */ /* $OpenBSD: uthum.c,v 1.6 2010/01/03 18:43:02 deraadt Exp $ */ /* * Copyright (c) 2009 Yojiro UO * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ /* * Driver for TEMPer and TEMPerHUM HID */ #include __KERNEL_RCSID(0, "$NetBSD: uthum.c,v 1.16.2.1 2020/01/02 09:42:06 martin Exp $"); #ifdef _KERNEL_OPT #include "opt_usb.h" #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef UTHUM_DEBUG int uthumdebug = 0; #define DPRINTFN(n, x) do { if (uthumdebug > (n)) printf x; } while (0) #else #define DPRINTFN(n, x) #endif #define DPRINTF(x) DPRINTFN(0, x) /* TEMPerHUM */ #define CMD_DEVTYPE 0x52 /* XXX */ #define CMD_GETDATA 0x48 /* XXX */ #define CMD_GETTEMP 0x54 /* XXX */ static uint8_t cmd_start[8] = { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x02, 0x00 }; static uint8_t cmd_end[8] = { 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 0x00, 0x01, 0x00 }; /* sensors */ #define UTHUM_TEMP 0 #define UTHUM_HUMIDITY 1 #define UTHUM_MAX_SENSORS 2 #define UTHUM_TYPE_UNKNOWN 0 #define UTHUM_TYPE_SHT1x 1 #define UTHUM_TYPE_TEMPER 2 struct uthum_softc { struct uhidev sc_hdev; struct usbd_device * sc_udev; u_char sc_dying; uint16_t sc_flag; int sc_sensortype; /* uhidev parameters */ size_t sc_flen; /* feature report length */ size_t sc_olen; /* output report length */ /* sensor framework */ struct sysmon_envsys *sc_sme; envsys_data_t sc_sensor[UTHUM_MAX_SENSORS]; uint8_t sc_num_sensors; }; const struct usb_devno uthum_devs[] = { /* XXX: various TEMPer variants using same VID/PID */ { USB_VENDOR_TENX, USB_PRODUCT_TENX_TEMPER}, }; #define uthum_lookup(v, p) usb_lookup(uthum_devs, v, p) int uthum_match(device_t, cfdata_t, void *); void uthum_attach(device_t, device_t, void *); void uthum_childdet(device_t, device_t); int uthum_detach(device_t, int); int uthum_activate(device_t, enum devact); int uthum_read_data(struct uthum_softc *, uint8_t, uint8_t *, size_t, int); int uthum_check_sensortype(struct uthum_softc *); int uthum_temper_temp(uint8_t, uint8_t); int uthum_sht1x_temp(uint8_t, uint8_t); int uthum_sht1x_rh(unsigned int, int); void uthum_intr(struct uhidev *, void *, u_int); static void uthum_refresh(struct sysmon_envsys *, envsys_data_t *); CFATTACH_DECL_NEW(uthum, sizeof(struct uthum_softc), uthum_match, uthum_attach, uthum_detach, uthum_activate); int uthum_match(device_t parent, cfdata_t match, void *aux) { struct uhidev_attach_arg *uha = aux; return uthum_lookup(uha->uiaa->uiaa_vendor, uha->uiaa->uiaa_product) != NULL ? UMATCH_VENDOR_PRODUCT : UMATCH_NONE; } void uthum_attach(device_t parent, device_t self, void *aux) { struct uthum_softc *sc = device_private(self); struct uhidev_attach_arg *uha = aux; struct usbd_device *dev = uha->parent->sc_udev; int size, repid; void *desc; sc->sc_udev = dev; sc->sc_hdev.sc_dev = self; sc->sc_hdev.sc_intr = uthum_intr; sc->sc_hdev.sc_parent = uha->parent; sc->sc_hdev.sc_report_id = uha->reportid; sc->sc_num_sensors = 0; aprint_normal("\n"); aprint_naive("\n"); uhidev_get_report_desc(uha->parent, &desc, &size); repid = uha->reportid; sc->sc_olen = hid_report_size(desc, size, hid_output, repid); sc->sc_flen = hid_report_size(desc, size, hid_feature, repid); usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_hdev.sc_dev); if (sc->sc_flen < 32) { /* not sensor interface, just attach */ return; } sc->sc_sensortype = uthum_check_sensortype(sc); /* attach sensor */ sc->sc_sme = sysmon_envsys_create(); sc->sc_sme->sme_name = device_xname(self); switch (sc->sc_sensortype) { case UTHUM_TYPE_SHT1x: (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp", sizeof(sc->sc_sensor[UTHUM_TEMP].desc)); sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP; sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; (void)strlcpy(sc->sc_sensor[UTHUM_HUMIDITY].desc, "relative humidity", sizeof(sc->sc_sensor[UTHUM_HUMIDITY].desc)); sc->sc_sensor[UTHUM_HUMIDITY].units = ENVSYS_INTEGER; sc->sc_sensor[UTHUM_HUMIDITY].value_cur = 0; sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_TEMP]); sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_HUMIDITY]); sc->sc_num_sensors = 2; DPRINTF(("sensor type: SHT1x\n")); break; case UTHUM_TYPE_TEMPER: (void)strlcpy(sc->sc_sensor[UTHUM_TEMP].desc, "temp", sizeof(sc->sc_sensor[UTHUM_TEMP].desc)); sc->sc_sensor[UTHUM_TEMP].units = ENVSYS_STEMP; sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[UTHUM_TEMP]); sc->sc_num_sensors = 1; DPRINTF(("sensor type: TEMPer\n")); break; case UTHUM_TYPE_UNKNOWN: DPRINTF(("sensor type: unknown, give up to attach sensors\n")); default: break; } if (sc->sc_num_sensors > 0) { sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = uthum_refresh; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "unable to register with sysmon\n"); sysmon_envsys_destroy(sc->sc_sme); } } else { sysmon_envsys_destroy(sc->sc_sme); } DPRINTF(("uthum_attach: complete\n")); } int uthum_detach(device_t self, int flags) { struct uthum_softc *sc = device_private(self); int rv = 0; sc->sc_dying = 1; if (sc->sc_num_sensors > 0) { sysmon_envsys_unregister(sc->sc_sme); } usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_hdev.sc_dev); return rv; } int uthum_activate(device_t self, enum devact act) { struct uthum_softc *sc = device_private(self); switch (act) { case DVACT_DEACTIVATE: sc->sc_dying = 1; break; } return 0; } void uthum_intr(struct uhidev *addr, void *ibuf, u_int len) { /* do nothing */ } int uthum_read_data(struct uthum_softc *sc, uint8_t target_cmd, uint8_t *buf, size_t len, int need_delay) { int i; uint8_t cmdbuf[32], report[256]; size_t olen, flen; /* if return buffer is null, do nothing */ if ((buf == NULL) || len == 0) return 0; olen = uimin(sc->sc_olen, sizeof(cmdbuf)); /* issue query */ memset(cmdbuf, 0, sizeof(cmdbuf)); memcpy(cmdbuf, cmd_start, sizeof(cmd_start)); if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, cmdbuf, olen)) return EIO; memset(cmdbuf, 0, sizeof(cmdbuf)); cmdbuf[0] = target_cmd; if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, cmdbuf, olen)) return EIO; memset(cmdbuf, 0, sizeof(cmdbuf)); for (i = 0; i < 7; i++) { if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, cmdbuf, olen)) return EIO; } memcpy(cmdbuf, cmd_end, sizeof(cmd_end)); if (uhidev_set_report(&sc->sc_hdev, UHID_OUTPUT_REPORT, cmdbuf, olen)) return EIO; /* wait if required */ if (need_delay > 1) kpause("uthum", false, (need_delay*hz+999)/1000 + 1, NULL); /* get answer */ flen = uimin(sc->sc_flen, sizeof(report)); if (uhidev_get_report(&sc->sc_hdev, UHID_FEATURE_REPORT, report, flen)) return EIO; memcpy(buf, report, len); return 0; } int uthum_check_sensortype(struct uthum_softc *sc) { uint8_t buf[8]; static uint8_t sht1x_sig0[] = { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 }; static uint8_t sht1x_sig1[] = { 0x57, 0x5a, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 }; static uint8_t temper_sig[] = { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 }; if (uthum_read_data(sc, CMD_DEVTYPE, buf, sizeof(buf), 0) != 0) { DPRINTF(("uthum: read fail\n")); return UTHUM_TYPE_UNKNOWN; } /* * currently we have not enough information about the return value, * therefore, compare full bytes. * TEMPerHUM HID (SHT1x version) will return: * { 0x57, 0x5a, 0x13, 0x00, 0x14, 0x00, 0x53, 0x00 } * { 0x57, 0x5a, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 } * TEMPer HID (TEMPer version) will return: * { 0x57, 0x58, 0x14, 0x00, 0x14, 0x00, 0x53, 0x00 } */ DPRINTF(("uthum: device signature: " "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n", buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7])); if (0 == memcmp(buf, sht1x_sig0, sizeof(sht1x_sig0))) return UTHUM_TYPE_SHT1x; if (0 == memcmp(buf, sht1x_sig1, sizeof(sht1x_sig1))) return UTHUM_TYPE_SHT1x; if (0 == memcmp(buf, temper_sig, sizeof(temper_sig))) return UTHUM_TYPE_TEMPER; return UTHUM_TYPE_UNKNOWN; } static void uthum_refresh(struct sysmon_envsys *sme, envsys_data_t *edata) { struct uthum_softc *sc = sme->sme_cookie; uint8_t buf[8]; unsigned int humidity_tick; int temp, rh; switch (sc->sc_sensortype) { case UTHUM_TYPE_SHT1x: if (uthum_read_data(sc, CMD_GETDATA, buf, sizeof(buf), 1000) != 0) { DPRINTF(("uthum: data read fail\n")); sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SINVALID; return; } DPRINTF(("%s: read SHT1x data " "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n", sc->sc_sme->sme_name, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7])); humidity_tick = (buf[2] * 256 + buf[3]) & 0x0fff; temp = uthum_sht1x_temp(buf[0], buf[1]); rh = uthum_sht1x_rh(humidity_tick, temp); sc->sc_sensor[UTHUM_HUMIDITY].value_cur = rh / 1000; sc->sc_sensor[UTHUM_HUMIDITY].state = ENVSYS_SVALID; break; case UTHUM_TYPE_TEMPER: if (uthum_read_data(sc, CMD_GETTEMP, buf, sizeof(buf), 0) != 0) { DPRINTF(("uthum: data read fail\n")); sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SINVALID; return; } DPRINTF(("%s: read TEMPER data " "0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x 0x%0x\n", sc->sc_sme->sme_name, buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6], buf[7])); temp = uthum_temper_temp(buf[0], buf[1]); break; default: /* do nothing */ return; } sc->sc_sensor[UTHUM_TEMP].value_cur = (temp * 10000) + 273150000; sc->sc_sensor[UTHUM_TEMP].state = ENVSYS_SVALID; } /* return C-degree * 100 value */ int uthum_temper_temp(uint8_t msb, uint8_t lsb) { int val; val = (msb << 8) | lsb; if (val >= 32768) { val = val - 65536; } val = (val * 100) >> 8; return val; } /* return C-degree * 100 value */ int uthum_sht1x_temp(uint8_t msb, uint8_t lsb) { int val; val = ((msb << 8) + lsb) - 4096; return val; } /* return %RH * 1000 */ int uthum_sht1x_rh(unsigned int ticks, int temp) { int rh_l, rh; rh_l = (-40000 + 405 * ticks) - ((7 * ticks * ticks) / 250); rh = ((temp - 2500) * (1 + (ticks >> 7)) + rh_l) / 10; return rh; }