* Copyright (c) 2017 Brad Spencer <brad@anduin.eldar.org>

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

/*
* Copyright (c) 2017 Brad Spencer <[email protected]>
*
* 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;
}
}