/*      $NetBSD: si70xx.c,v 1.12 2025/01/23 19:13:19 brad Exp $ */

/*
 * Copyright (c) 2017 Brad Spencer <brad@anduin.eldar.org>
 *
 * 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 DISCLAIMS 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: si70xx.c,v 1.12 2025/01/23 19:13:19 brad Exp $");

/*
  Driver for the Silicon Labs SI7013/SI7020/SI7021, HTU21D and SHT21
*/

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/sysctl.h>
#include <sys/mutex.h>

#include <dev/sysmon/sysmonvar.h>
#include <dev/i2c/i2cvar.h>
#include <dev/i2c/si70xxreg.h>
#include <dev/i2c/si70xxvar.h>


static uint8_t  si70xx_crc(uint8_t *, size_t);
static int      si70xx_poke(i2c_tag_t, i2c_addr_t, bool);
static int      si70xx_match(device_t, cfdata_t, void *);
static void     si70xx_attach(device_t, device_t, void *);
static int      si70xx_detach(device_t, int);
static void     si70xx_refresh(struct sysmon_envsys *, envsys_data_t *);
static int      si70xx_update_status(struct si70xx_sc *);
static int      si70xx_set_heateron(struct si70xx_sc *);
static int      si70xx_set_resolution(struct si70xx_sc *, size_t);
static int      si70xx_set_heatervalue(struct si70xx_sc *, size_t);
static int      si70xx_verify_sysctl(SYSCTLFN_ARGS);
static int      si70xx_verify_sysctl_resolution(SYSCTLFN_ARGS);
static int      si70xx_verify_sysctl_heateron(SYSCTLFN_ARGS);
static int      si70xx_verify_sysctl_heatervalue(SYSCTLFN_ARGS);

#define SI70XX_DEBUG
#ifdef SI70XX_DEBUG
#define DPRINTF(s, l, x) \
    do { \
        if (l <= s->sc_si70xxdebug) \
            printf x; \
    } while (/*CONSTCOND*/0)
#else
#define DPRINTF(s, l, x)
#endif

CFATTACH_DECL_NEW(si70xxtemp, sizeof(struct si70xx_sc),
    si70xx_match, si70xx_attach, si70xx_detach, NULL);

static struct si70xx_sensor si70xx_sensors[] = {
        {
                .desc = "humidity",
                .type = ENVSYS_SRELHUMIDITY,
        },
        {
                .desc = "temperature",
                .type = ENVSYS_STEMP,
        }
};

static struct si70xx_resolution si70xx_resolutions[] = {
        {
                .text = "12bit/14bit",
                .num = 0x00,
        },
        {
                .text = "8bit/12bit",
                .num = 0x01,
        },
        {
                .text = "10bit/13bit",
                .num = 0x80,
        },
        {
                .text = "11bit/11bit",
                .num = 0x81,
        }
};

static const char si70xx_resolution_names[] =
    "12bit/14bit, 8bit/12bit, 10bit/13bit, 11bit/11bit";

static const int si70xx_heatervalues[] = {
    0xdeadbeef, 0x00, 0x01, 0x02, 0x04, 0x08, 0x0f
};

int 
si70xx_verify_sysctl(SYSCTLFN_ARGS)
{
        int error, t;
        struct sysctlnode node;

        node = *rnode;
        t = *(int *)rnode->sysctl_data;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        if (t < 0)
                return EINVAL;

        *(int *)rnode->sysctl_data = t;

        return 0;
}

int 
si70xx_verify_sysctl_resolution(SYSCTLFN_ARGS)
{
        char buf[SI70XX_RES_NAME];
        struct si70xx_sc *sc;
        struct sysctlnode node;
        int error = 0;
        size_t i;

        node = *rnode;
        sc = node.sysctl_data;
        (void) memcpy(buf, sc->sc_resolution, SI70XX_RES_NAME);
        node.sysctl_data = buf;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        for (i = 0; i < __arraycount(si70xx_resolutions); i++) {
                if (memcmp(node.sysctl_data, si70xx_resolutions[i].text,
                    SI70XX_RES_NAME) == 0)
                        break;
        }

        if (i == __arraycount(si70xx_resolutions))
                return EINVAL;
        (void) memcpy(sc->sc_resolution, node.sysctl_data, SI70XX_RES_NAME);

        error = si70xx_set_resolution(sc, i);

        return error;
}

int 
si70xx_verify_sysctl_heateron(SYSCTLFN_ARGS)
{
        int             error;
        bool            t;
        struct si70xx_sc *sc;
        struct sysctlnode node;

        node = *rnode;
        sc = node.sysctl_data;
        t = sc->sc_heateron;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return error;

        sc->sc_heateron = t;
        error = si70xx_set_heateron(sc);

        return error;
}

int 
si70xx_verify_sysctl_heatervalue(SYSCTLFN_ARGS)
{
        int             error = 0, t;
        struct si70xx_sc *sc;
        struct sysctlnode node;

        node = *rnode;
        sc = node.sysctl_data;
        t = sc->sc_heaterval;
        node.sysctl_data = &t;
        error = sysctl_lookup(SYSCTLFN_CALL(&node));
        if (error || newp == NULL)
                return (error);

        if (t < 1 || t >= __arraycount(si70xx_heatervalues))
                return (EINVAL);

        sc->sc_heaterval = t;
        error = si70xx_set_heatervalue(sc, t);

        return error;
}

static uint8_t
si70xx_dir(uint8_t cmd, size_t len)
{
        switch (cmd) {
        case SI70XX_READ_USER_REG_1:
        case SI70XX_READ_HEATER_REG:
        case SI70XX_READ_ID_PT1A:
        case SI70XX_READ_ID_PT1B:
        case SI70XX_READ_ID_PT2A:
        case SI70XX_READ_ID_PT2B:
        case SI70XX_READ_FW_VERA:
        case SI70XX_READ_FW_VERB:
        case SI70XX_MEASURE_RH_HOLD:
        case SI70XX_MEASURE_TEMP_HOLD:
                return I2C_OP_READ_WITH_STOP;
        case SI70XX_WRITE_USER_REG_1:
        case SI70XX_WRITE_HEATER_REG:
        case SI70XX_RESET:
                return I2C_OP_WRITE_WITH_STOP;
        case SI70XX_MEASURE_RH_NOHOLD:
        case SI70XX_MEASURE_TEMP_NOHOLD:
                return len == 0 ? I2C_OP_WRITE : I2C_OP_READ_WITH_STOP;
        default:
                panic("%s: bad command %#x\n", __func__, cmd);
                return 0;
        }
}

static int
si70xx_cmd(i2c_tag_t tag, i2c_addr_t addr, uint8_t *cmd,
    uint8_t clen, uint8_t *buf, size_t blen)
{
        uint8_t dir;
        if (clen == 0)
                dir = blen == 0 ? I2C_OP_READ : I2C_OP_READ_WITH_STOP;
        else
                dir = si70xx_dir(cmd[0], blen);

        if (dir == I2C_OP_READ || dir == I2C_OP_READ_WITH_STOP)
                memset(buf, 0, blen);

        return iic_exec(tag, dir, addr, cmd, clen, buf, blen, 0);
}

static int
si70xx_cmd0(struct si70xx_sc *sc, uint8_t *buf, size_t blen)
{
        return si70xx_cmd(sc->sc_tag, sc->sc_addr, NULL, 0, buf, blen);
}

static int
si70xx_cmd1(struct si70xx_sc *sc, uint8_t cmd, uint8_t *buf, size_t blen)
{
        return si70xx_cmd(sc->sc_tag, sc->sc_addr, &cmd, 1, buf, blen);
}

static int
si70xx_cmd2(struct si70xx_sc *sc, uint8_t cmd1, uint8_t cmd2, uint8_t *buf,
    size_t blen)
{
        uint8_t cmd[] = { cmd1, cmd2 };
        return si70xx_cmd(sc->sc_tag, sc->sc_addr, cmd, __arraycount(cmd),
            buf, blen);
}

static int
si70xx_set_heateron(struct si70xx_sc * sc)
{
        int error;
        uint8_t userregister;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                DPRINTF(sc, 2, ("%s:%s: Failed to acquire bus: %d\n",
                    device_xname(sc->sc_dev), __func__, error));
                return error;
        }

        error = si70xx_cmd1(sc, SI70XX_READ_USER_REG_1, &userregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to read user register 1: %d\n",
                    device_xname(sc->sc_dev), error));
                goto out;
        }

        DPRINTF(sc, 2, ("%s:%s: reg 1 values before: %#x\n",
            device_xname(sc->sc_dev), __func__, userregister));
        if (sc->sc_heateron) {
                userregister |= SI70XX_HTRE_MASK;
        } else {
                userregister &= ~SI70XX_HTRE_MASK;
        }
        DPRINTF(sc, 2, ("%s:%s: user reg 1 values after: %#x\n",
            device_xname(sc->sc_dev), __func__, userregister));

        error = si70xx_cmd1(sc, SI70XX_WRITE_USER_REG_1, &userregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to write user register 1: %d\n",
                    device_xname(sc->sc_dev), error));
        }
out:
        iic_release_bus(sc->sc_tag, 0);
        return error;
}

static int
si70xx_set_resolution(struct si70xx_sc * sc, size_t index)
{
        int error;
        uint8_t userregister;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to acquire bus: %d\n",
                    device_xname(sc->sc_dev), error));
                return error;
        }

        error = si70xx_cmd1(sc, SI70XX_READ_USER_REG_1, &userregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to read user register 1: %d\n",
                    device_xname(sc->sc_dev), error));
                goto out;
        }

        DPRINTF(sc, 2, ("%s:%s: reg 1 values before: %#x\n",
            device_xname(sc->sc_dev), __func__, userregister));
        userregister &= (~SI70XX_RESOLUTION_MASK);
        userregister |= si70xx_resolutions[index].num;
        DPRINTF(sc, 2, ("%s:%s: reg 1 values after: %#x\n",
            device_xname(sc->sc_dev), __func__, userregister));

        error = si70xx_cmd1(sc, SI70XX_WRITE_USER_REG_1, &userregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to write user register 1: %d\n",
                    device_xname(sc->sc_dev), error));
        }
out:
        iic_release_bus(sc->sc_tag, 0);
        return error;
}

static int
si70xx_set_heatervalue(struct si70xx_sc * sc, size_t index)
{
        int error;
        uint8_t heaterregister;

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to acquire bus: %d\n",
                    device_xname(sc->sc_dev), error));
                return error;
        }
        error = si70xx_cmd1(sc, SI70XX_READ_HEATER_REG, &heaterregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to read heater register: %d\n",
                    device_xname(sc->sc_dev), error));
                goto out;
        }

        DPRINTF(sc, 2, ("%s:%s: heater values before: %#x\n",
            device_xname(sc->sc_dev), __func__, heaterregister));
        heaterregister &= ~SI70XX_HEATER_MASK;
        heaterregister |= si70xx_heatervalues[index];
        DPRINTF(sc, 2, ("%s:%s: heater values after: %#x\n",
            device_xname(sc->sc_dev), __func__, heaterregister));

        error = si70xx_cmd1(sc, SI70XX_WRITE_HEATER_REG, &heaterregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to write heater register: %d\n",
                    device_xname(sc->sc_dev), error));
        }
out:
        iic_release_bus(sc->sc_tag, 0);
        return error;
}

static int
si70xx_update_heater(struct si70xx_sc *sc)
{
        size_t i;
        int error;
        uint8_t heaterregister;

        error = si70xx_cmd1(sc, SI70XX_READ_HEATER_REG, &heaterregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to read heater register: %d\n",
                    device_xname(sc->sc_dev), error));
                return error;
        }

        DPRINTF(sc, 2, ("%s: read heater reg values: %02x\n",
            device_xname(sc->sc_dev), heaterregister));

        uint8_t heat = heaterregister & SI70XX_HEATER_MASK;
        for (i = 0; i < __arraycount(si70xx_heatervalues); i++) {
                if (si70xx_heatervalues[i] == heat)
                        break;
        }
        sc->sc_heaterval = i != __arraycount(si70xx_heatervalues) ? i : 0;
        return 0;
}

static int
si70xx_update_user(struct si70xx_sc *sc)
{
        size_t i;
        int error;
        uint8_t userregister;

        error = si70xx_cmd1(sc, SI70XX_READ_USER_REG_1, &userregister, 1);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to read user register 1: %d\n",
                    device_xname(sc->sc_dev), error));
                return error;
        }
        DPRINTF(sc, 2, ("%s: read user reg 1 values: %#x\n",
            device_xname(sc->sc_dev), userregister));

        uint8_t res = userregister & SI70XX_RESOLUTION_MASK;
        for (i = 0; i < __arraycount(si70xx_resolutions); i++) {
                if (si70xx_resolutions[i].num == res)
                        break;
        }

        if (i != __arraycount(si70xx_resolutions)) {
                memcpy(sc->sc_resolution, si70xx_resolutions[i].text,
                    SI70XX_RES_NAME);
        } else {
                snprintf(sc->sc_resolution, SI70XX_RES_NAME, "%02x", res);
        }

        sc->sc_vddok = (userregister & SI70XX_VDDS_MASK) == 0;
        sc->sc_heaterval = userregister & SI70XX_HTRE_MASK;
        return 0;
}

static int
si70xx_update_status(struct si70xx_sc *sc)
{
        int error1 = si70xx_update_user(sc);
        int error2 = 0;
        if (! sc->sc_noheater) {
                error2 = si70xx_update_heater(sc);
        }
        return error1 ? error1 : error2;
}

static  uint8_t
si70xx_crc(uint8_t * data, size_t size)
{
        uint8_t crc = 0;

        for (size_t i = 0; i < size; i++) {
                crc ^= data[i];
                for (size_t j = 8; j > 0; j--) {
                        if (crc & 0x80)
                                crc = (crc << 1) ^ 0x131;
                        else
                                crc <<= 1;
                }
        }
        return crc;
}

static int
si70xx_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
        uint8_t reg = SI70XX_READ_USER_REG_1;
        uint8_t buf;
        int error;

        error = si70xx_cmd(tag, addr, &reg, 1, &buf, 1);
        if (matchdebug) {
                printf("poke X 1: %d\n", error);
        }
        return error;
}

static int
si70xx_sysctl_init(struct si70xx_sc *sc)
{
        int error;
        const struct sysctlnode *cnode;
        int sysctlroot_num;

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            0, CTLTYPE_NODE, device_xname(sc->sc_dev),
            SYSCTL_DESCR("si70xx controls"), NULL, 0, NULL, 0, CTL_HW,
            CTL_CREATE, CTL_EOL)) != 0)
                return error;

        sysctlroot_num = cnode->sysctl_num;

#ifdef SI70XX_DEBUG
        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
            SYSCTL_DESCR("Debug level"), si70xx_verify_sysctl, 0,
            &sc->sc_si70xxdebug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
            CTL_EOL)) != 0)
                return error;

#endif

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_BOOL, "clockstretch",
            SYSCTL_DESCR("Use clock stretch commands for measurements"), NULL, 0,
            &sc->sc_clockstretch, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
            CTL_EOL)) != 0)
                return error;

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_INT, "readattempts",
            SYSCTL_DESCR("The number of times to attempt to read the values"),
            si70xx_verify_sysctl, 0, &sc->sc_readattempts, 0, CTL_HW,
            sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                return error;


        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READONLY, CTLTYPE_STRING, "resolutions",
            SYSCTL_DESCR("Valid resolutions"), 0, 0,
            __UNCONST(si70xx_resolution_names),
            sizeof(si70xx_resolution_names) + 1,
            CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                return error;

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_STRING, "resolution",
            SYSCTL_DESCR("Resolution of RH and Temp"),
            si70xx_verify_sysctl_resolution, 0, (void *) sc,
            SI70XX_RES_NAME, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                return error;

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READWRITE, CTLTYPE_BOOL, "ignorecrc",
            SYSCTL_DESCR("Ignore the CRC byte"), NULL, 0, &sc->sc_ignorecrc,
            0, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                return error;

        if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
            CTLFLAG_READONLY, CTLTYPE_BOOL, "vddok",
            SYSCTL_DESCR("Vdd at least 1.9v"), NULL, 0, &sc->sc_vddok, 0,
            CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                return error;

        if (! sc->sc_noheater) {
                if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
                    CTLFLAG_READWRITE, CTLTYPE_BOOL, "heateron",
                    SYSCTL_DESCR("Heater on"), si70xx_verify_sysctl_heateron, 0,
                    (void *)sc, 0, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                        return error;

                if ((error = sysctl_createv(&sc->sc_si70xxlog, 0, NULL, &cnode,
                    CTLFLAG_READWRITE, CTLTYPE_INT, "heaterstrength",
                    SYSCTL_DESCR("Heater strength 1 to 6"),
                    si70xx_verify_sysctl_heatervalue, 0, (void *)sc, 0, CTL_HW,
                    sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
                        return error;
        }

        return 0;
}

static int
si70xx_match(device_t parent, cfdata_t match, void *aux)
{
        struct i2c_attach_args *ia = aux;
        int error, match_result;
        const bool matchdebug = false;

        if (iic_use_direct_match(ia, match, NULL, &match_result))
                return match_result;

        /* indirect config - check for configured address */
        if (ia->ia_addr != SI70XX_TYPICAL_ADDR)
                return 0;

        /*
         * Check to see if something is really at this i2c address. This will
         * keep phantom devices from appearing
         */
        if (iic_acquire_bus(ia->ia_tag, 0) != 0) {
                if (matchdebug)
                        printf("in match acquire bus failed\n");
                return 0;
        }

        error = si70xx_poke(ia->ia_tag, ia->ia_addr, matchdebug);
        iic_release_bus(ia->ia_tag, 0);

        return error == 0 ? I2C_MATCH_ADDRESS_AND_PROBE : 0;
}

static void
si70xx_attach(device_t parent, device_t self, void *aux)
{
        struct si70xx_sc *sc;
        struct i2c_attach_args *ia;
        int error, i;
        int ecount = 0;
        uint8_t buf[8];
        uint8_t testcrcpt1[4];
        uint8_t testcrcpt2[4];
        uint8_t crc1 = 0, crc2 = 0;
        bool validcrcpt1, validcrcpt2;
        uint8_t readcrc1 = 0, readcrc2 = 0;
        uint8_t fwversion = 0, model, heaterregister;

        ia = aux;
        sc = device_private(self);

        sc->sc_dev = self;
        sc->sc_tag = ia->ia_tag;
        sc->sc_addr = ia->ia_addr;
        sc->sc_si70xxdebug = 0;
        sc->sc_clockstretch = false;
        sc->sc_readattempts = 40;
        sc->sc_ignorecrc = false;
        sc->sc_sme = NULL;
        sc->sc_noheater = false;
        sc->sc_nofw = false;

        aprint_normal("\n");

        mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
        sc->sc_numsensors = __arraycount(si70xx_sensors);

        if ((sc->sc_sme = sysmon_envsys_create()) == NULL) {
                aprint_error_dev(self,
                    "Unable to create sysmon structure\n");
                sc->sc_sme = NULL;
                return;
        }

        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                aprint_error_dev(self, "Could not acquire iic bus: %d\n",
                    error);
                goto out;
        }
        error = si70xx_cmd1(sc, SI70XX_RESET, NULL, 0);
        if (error != 0)
                aprint_error_dev(self, "Reset failed: %d\n", error);

        delay(15000);   /* 15 ms max */

        error = si70xx_cmd2(sc, SI70XX_READ_ID_PT1A, SI70XX_READ_ID_PT1B,
            buf, 8);
        if (error) {
                aprint_error_dev(self, "Failed to read first part of ID: %d\n",
                    error);
                ecount++;
        }
        testcrcpt1[0] = buf[0];
        testcrcpt1[1] = buf[2];
        testcrcpt1[2] = buf[4];
        testcrcpt1[3] = buf[6];
        readcrc1 = buf[7];
        crc1 = si70xx_crc(testcrcpt1, 4);
        /* A "real" SI70xx has the CRC cover the entire first part of the
         * serial number.  An HTU21D has the CRC broken out into each
         * part of the serial number.
         */
        validcrcpt1 = (readcrc1 == crc1);
        if (! validcrcpt1) {
                validcrcpt1 = (si70xx_crc(&testcrcpt1[0],1) == buf[1] &&
                    si70xx_crc(&testcrcpt1[1],1) == buf[3] &&
                    si70xx_crc(&testcrcpt1[2],1) == buf[5] &&
                    si70xx_crc(&testcrcpt1[3],1) == buf[7]);
                DPRINTF(sc, 2, ("%s: Part 1 SN CRC was not valid for real type, "
                    "check clone: %d\n", device_xname(sc->sc_dev), validcrcpt1));
        }

        DPRINTF(sc, 2, ("%s: read 1 values: %02x%02x%02x%02x%02x%02x%02x%02x "
            "- %02x -- %d\n", device_xname(sc->sc_dev), buf[0], buf[1],
            buf[2], buf[3], buf[4], buf[5], buf[6], buf[7],
            crc1, validcrcpt1));

        error = si70xx_cmd2(sc, SI70XX_READ_ID_PT2A, SI70XX_READ_ID_PT2B,
            buf, 6);
        if (error != 0) {
                aprint_error_dev(self, "Failed to read second part of ID: %d\n",
                    error);
                ecount++;
        }
        model = testcrcpt2[0] = buf[0];
        testcrcpt2[1] = buf[1];
        testcrcpt2[2] = buf[3];
        testcrcpt2[3] = buf[4];
        readcrc2 = buf[5];
        crc2 = si70xx_crc(testcrcpt2, 4);
        /* It is even stranger for this part of the serial number.  A "real"
         * SI70XX will have a single CRC for the entire second part, but
         * an HTU21D has a CRC for each word in this case.
         *
         * The datasheet actually agrees with the HTU21D case, and not the "real"
         * chip.
         */
        validcrcpt2 = (readcrc2 == crc2);
        if (! validcrcpt2) {
                validcrcpt2 = (si70xx_crc(&testcrcpt2[0],2) == buf[2] &&
                    si70xx_crc(&testcrcpt2[2],2) == buf[5]);
                DPRINTF(sc, 2, ("%s: Part 2 SN CRC was not valid for real type, "
                    "check clone: %d\n", device_xname(sc->sc_dev), validcrcpt2));
        }

        DPRINTF(sc, 2, ("%s: read 2 values: %02x%02x%02x%02x%02x%02x - %02x -- %d\n",
            device_xname(sc->sc_dev), buf[0], buf[1], buf[2],
            buf[3], buf[4], buf[5], crc2, validcrcpt2));

        error = si70xx_cmd2(sc, SI70XX_READ_FW_VERA, SI70XX_READ_FW_VERB,
            buf, 1);

        if (error) {
                aprint_error_dev(self, "Failed to read firmware version: Error %d\n",
                    error);
                sc->sc_nofw = true;
        }
        if (! sc->sc_nofw) {
                fwversion = buf[0];
                DPRINTF(sc, 2, ("%s: read fw values: %#x\n", device_xname(sc->sc_dev),
                    fwversion));
        }

        error = si70xx_cmd1(sc, SI70XX_READ_HEATER_REG, &heaterregister, 1);

        if (error) {
                aprint_error_dev(self, "Failed to read heater register: Error %d\n",
                    error);
                sc->sc_noheater = true;
        }

        error = si70xx_update_status(sc);

        iic_release_bus(sc->sc_tag, 0);

        if ((error = si70xx_sysctl_init(sc)) != 0) {
                aprint_error_dev(self, "Can't setup sysctl tree (%d)\n", error);
                goto out;
        }

        if (error != 0) {
                aprint_error_dev(self, "Failed to update status: %x\n", error);
                aprint_error_dev(self, "Unable to setup device\n");
                goto out;
        }

        for (i = 0; i < sc->sc_numsensors; i++) {
                strlcpy(sc->sc_sensors[i].desc, si70xx_sensors[i].desc,
                    sizeof(sc->sc_sensors[i].desc));

                sc->sc_sensors[i].units = si70xx_sensors[i].type;
                sc->sc_sensors[i].state = ENVSYS_SINVALID;

                DPRINTF(sc, 2, ("%s: registering sensor %d (%s)\n", __func__, i,
                    sc->sc_sensors[i].desc));

                error = sysmon_envsys_sensor_attach(sc->sc_sme,
                    &sc->sc_sensors[i]);
                if (error) {
                        aprint_error_dev(self,
                            "Unable to attach sensor %d: %d\n", i, error);
                        sc->sc_sme = NULL;
                        goto out;
                }
        }

        sc->sc_sme->sme_name = device_xname(sc->sc_dev);
        sc->sc_sme->sme_cookie = sc;
        sc->sc_sme->sme_refresh = si70xx_refresh;

        DPRINTF(sc, 2, ("si70xx_attach: registering with envsys\n"));

        if (sysmon_envsys_register(sc->sc_sme)) {
                aprint_error_dev(self,
                        "unable to register with sysmon\n");
                sysmon_envsys_destroy(sc->sc_sme);
                sc->sc_sme = NULL;
                return;
        }

        char modelstr[64];
        switch (model) {
        case 0:
        case 0xff:
                snprintf(modelstr, sizeof(modelstr), "Engineering Sample");
                break;
        case 13:
        case 20:
        case 21:
                snprintf(modelstr, sizeof(modelstr), "SI70%d", model);
                break;
        default:
                snprintf(modelstr, sizeof(modelstr), "Unknown model %d (maybe an HTU21D)", model);
                break;
        }

        const char *fwversionstr;
        switch (fwversion) {
        case 0xff:
                fwversionstr = "1.0";
                break;
        case 0x20:
                fwversionstr = "2.0";
                break;
        default:
                fwversionstr = "unknown";
                break;
        }

        aprint_normal_dev(self, "Silicon Labs Model: %s, "
            "Firmware version: %s, "
            "Serial number: %02x%02x%02x%02x%02x%02x%02x%02x%s",
            modelstr, fwversionstr, testcrcpt1[0], testcrcpt1[1],
            testcrcpt1[2], testcrcpt1[3], testcrcpt2[0], testcrcpt2[1],
            testcrcpt2[2], testcrcpt2[3],
            (validcrcpt1 && validcrcpt2) ? "\n" : " (bad crc)\n");
        return;
out:
        sysmon_envsys_destroy(sc->sc_sme);
        sc->sc_sme = NULL;
}

static int
si70xx_exec(struct si70xx_sc *sc, uint8_t cmd, envsys_data_t *edata)
{
        int error;
        int xdelay;
        const char *name;
        int64_t mul, offs;
        uint8_t buf[3];

        switch (cmd) {
        case SI70XX_MEASURE_RH_NOHOLD:
        case SI70XX_MEASURE_RH_HOLD:
                /*
                 * The published conversion for RH is: %RH =
                 * ((125 * RHCODE) / 65536) - 6
                 * 
                 * The sysmon infrastructure for RH wants %RH *
                 * 10^6 The result will fit in 32 bits, but
                 * the intermediate values will not.
                 */
                mul = 125000000;
                offs = -6000000;
                /*
                 * Conversion times for %RH in ms
                 * 
                 *              Typical Max
                 * 12-bit       10.0    12.0
                 * 11-bit        5.8     7.0
                 * 10-bit        3.7     4.5
                 *  8-bit        2.6     3.1
                 * 
                 * A call to read %RH will also read temperature.  The
                 * conversion time will be the amount of time above
                 * plus the amount of time for temperature below
                 */
                xdelay = 10500;
                name = "RH";
                break;
        case SI70XX_MEASURE_TEMP_NOHOLD:
        case SI70XX_MEASURE_TEMP_HOLD:
                /*
                 * The published conversion for temp is:
                 * degree C = ((175.72 * TEMPCODE) / 65536) -
                 * 46.85
                 * 
                 * The sysmon infrastructure for temp wants
                 * microkelvin.  This is simple, as degree C
                 * converts directly with K with simple
                 * addition. The result will fit in 32 bits,
                 * but the intermediate values will not.
                 */
                mul = 175720000;
                offs = 226300000;
                /*
                 * Conversion times for temperature in ms
                 * 
                 *              Typical Max
                 * 14-bit       7.0     10.8
                 * 13-bit       4.0      6.2
                 * 12-bit       2.4      3.8
                 * 11-bit       1.5      2.4
                 */
                xdelay = 4750;
                name = "TEMP";
                break;
        default:
                return EINVAL;
        }

        if (sc->sc_clockstretch) {
                error = si70xx_cmd1(sc, cmd, buf, sizeof(buf));
                if (error) {
                        DPRINTF(sc, 2, ("%s: Failed to read HOLD %s %d %d\n",
                            device_xname(sc->sc_dev), name, 1, error));
                        return error;
                }
        } else {
                error = si70xx_cmd1(sc, cmd, NULL, 0);
                if (error) {
                        DPRINTF(sc, 2, ("%s: Failed to read NO HOLD %s %d %d\n",
                            device_xname(sc->sc_dev), name, 1, error));
                        return error;
                }

                /*
                 * It will probably be at least this long... we would
                 * not have to do this sort of thing if clock
                 * stretching worked.  Even this is a problem for the
                 * RPI without a patch to remove a [apparently] not
                 * needed KASSERT()
                 */
                delay(xdelay);

                for (int aint = 0; aint < sc->sc_readattempts; aint++) {
                        error = si70xx_cmd0(sc, buf, sizeof(buf));
                        if (error == 0)
                                break;
                        DPRINTF(sc, 2, ("%s: Failed to read NO HOLD RH"
                            " %d %d\n", device_xname(sc->sc_dev), 2, error));
                        delay(1000);
                }
        }

        DPRINTF(sc, 2, ("%s: %s values: %02x%02x%02x - %02x\n",
            device_xname(sc->sc_dev), name, buf[0], buf[1], buf[2],
            si70xx_crc(buf, 2)));

        uint8_t crc;
        if (sc->sc_ignorecrc) {
                crc = buf[2];
        } else {
                crc = si70xx_crc(buf, 2);
        }

        if (crc != buf[2]) {
                DPRINTF(sc, 2, ("%s: Bad CRC for %s: %#x and %#x\n",
                    device_xname(sc->sc_dev), name, crc, buf[2]));
                return EINVAL;
        }

        uint16_t val16 = (buf[0] << 8) | buf[1];
        uint64_t val64 = ((mul * val16) >> 16) + offs;
        DPRINTF(sc, 2, ("%s: %s calculated values: %x %#jx\n",
            device_xname(sc->sc_dev), name, val16, (uintmax_t)val64));
        edata->value_cur = (uint32_t) val64;
        edata->state = ENVSYS_SVALID;
        return 0;
}

static void
si70xx_refresh(struct sysmon_envsys * sme, envsys_data_t * edata)
{
        struct si70xx_sc *sc;
        int             error;

        sc = sme->sme_cookie;
        edata->state = ENVSYS_SINVALID;

        mutex_enter(&sc->sc_mutex);
        error = iic_acquire_bus(sc->sc_tag, 0);
        if (error) {
                DPRINTF(sc, 2, ("%s: Could not acquire i2c bus: %x\n",
                    device_xname(sc->sc_dev), error));
                goto out;
        }
        error = si70xx_update_status(sc);
        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to update status in refresh %d\n",
                    device_xname(sc->sc_dev), error));
                goto out1;
        }
        switch (edata->sensor) {
        case SI70XX_HUMIDITY_SENSOR:
                if (sc->sc_clockstretch)
                        error = si70xx_exec(sc, SI70XX_MEASURE_RH_HOLD, edata);
                else
                        error = si70xx_exec(sc, SI70XX_MEASURE_RH_NOHOLD, edata);
                break;

        case SI70XX_TEMP_SENSOR:
                if (sc->sc_clockstretch)
                        error = si70xx_exec(sc, SI70XX_MEASURE_TEMP_HOLD, edata);
                else
                        error = si70xx_exec(sc, SI70XX_MEASURE_TEMP_NOHOLD, edata);
                break;
        default:
                error = EINVAL;
                break;
        }

        if (error) {
                DPRINTF(sc, 2, ("%s: Failed to get new status in refresh %d\n",
                    device_xname(sc->sc_dev), error));
        }
out1:
        iic_release_bus(sc->sc_tag, 0);
out:
        mutex_exit(&sc->sc_mutex);
}

static int
si70xx_detach(device_t self, int flags)
{
        struct si70xx_sc *sc;

        sc = device_private(self);

        mutex_enter(&sc->sc_mutex);

        /* Remove the sensors */
        if (sc->sc_sme != NULL)
                sysmon_envsys_unregister(sc->sc_sme);
        mutex_exit(&sc->sc_mutex);

        /* Remove the sysctl tree */
        sysctl_teardown(&sc->sc_si70xxlog);

        /* Remove the mutex */
        mutex_destroy(&sc->sc_mutex);

        return 0;
}

MODULE(MODULE_CLASS_DRIVER, si70xxtemp, "iic,sysmon_envsys");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
si70xxtemp_modcmd(modcmd_t cmd, void *opaque)
{

        switch (cmd) {
        case MODULE_CMD_INIT:
#ifdef _MODULE
                return config_init_component(cfdriver_ioconf_si70xxtemp,
                    cfattach_ioconf_si70xxtemp, cfdata_ioconf_si70xxtemp);
#else
                return 0;
#endif
        case MODULE_CMD_FINI:
#ifdef _MODULE
                return config_fini_component(cfdriver_ioconf_si70xxtemp,
                      cfattach_ioconf_si70xxtemp, cfdata_ioconf_si70xxtemp);
#else
                return 0;
#endif
        default:
                return ENOTTY;
        }
}