xref: /src/sys/dev/i2c/sgp40.c

/*	$NetBSD: sgp40.c,v 1.5 2022/05/24 06:28:01 andvar Exp $	*/

/*
 * Copyright (c) 2021 Brad Spencer <brad (at) 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, NEGL`IGENCE 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: sgp40.c,v 1.5 2022/05/24 06:28:01 andvar Exp $");

/*
  Driver for the Sensirion SGP40 MOx gas sensor for air quality
*/

#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 <sys/condvar.h>
#include <sys/kthread.h>

#include <dev/sysmon/sysmonvar.h>
#include <dev/i2c/i2cvar.h>
#include <dev/i2c/sgp40reg.h>
#include <dev/i2c/sgp40var.h>

#include <dev/i2c/sensirion_arch_config.h>
#include <dev/i2c/sensirion_voc_algorithm.h>

static uint8_t 	sgp40_crc(uint8_t *, size_t);
static int      sgp40_cmdr(struct sgp40_sc *, uint16_t, uint8_t *, uint8_t,
    uint8_t *, size_t);
static int 	sgp40_poke(i2c_tag_t, i2c_addr_t, bool);
static int 	sgp40_match(device_t, cfdata_t, void *);
static void 	sgp40_attach(device_t, device_t, void *);
static int 	sgp40_detach(device_t, int);
static void 	sgp40_refresh(struct sysmon_envsys *, envsys_data_t *);
static int 	sgp40_verify_sysctl(SYSCTLFN_ARGS);
static int 	sgp40_verify_temp_sysctl(SYSCTLFN_ARGS);
static int 	sgp40_verify_rh_sysctl(SYSCTLFN_ARGS);
static void     sgp40_thread(void *);
static void     sgp40_stop_thread(void *);
static void     sgp40_take_measurement(void *, VocAlgorithmParams *);

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

CFATTACH_DECL_NEW(sgp40mox, sizeof(struct sgp40_sc),
    sgp40_match, sgp40_attach, sgp40_detach, NULL);

static struct sgp40_sensor sgp40_sensors[] = {
	{
		.desc = "VOC index",
		.type = ENVSYS_INTEGER,
	}
};

static struct sgp40_timing sgp40_timings[] = {
	{
		.cmd = SGP40_MEASURE_RAW,
		.typicaldelay = 25000,
	},
	{
		.cmd = SGP40_MEASURE_TEST,
		.typicaldelay = 240000,
	},
	{
		.cmd = SGP40_HEATER_OFF,
		.typicaldelay = 100,
	},
	{
		.cmd = SGP40_GET_SERIAL_NUMBER,
		.typicaldelay = 100,
	},
	{
		.cmd = SGP40_GET_FEATURESET,
		.typicaldelay = 1000,
	}
};

void
sgp40_thread(void *aux)
{
	struct sgp40_sc *sc = aux;
	int rv;
	VocAlgorithmParams voc_algorithm_params;

	mutex_enter(&sc->sc_threadmutex);

	VocAlgorithm_init(&voc_algorithm_params);

	while (!sc->sc_stopping) {
		rv = cv_timedwait(&sc->sc_condvar, &sc->sc_threadmutex,
		    mstohz(1000));
		if (rv == EWOULDBLOCK && !sc->sc_stopping) {
			sgp40_take_measurement(sc,&voc_algorithm_params);
		}
	}
	mutex_exit(&sc->sc_threadmutex);
	kthread_exit(0);
}

static void
sgp40_stop_thread(void *aux)
{
	struct sgp40_sc *sc;
	sc = aux;
	int error;

	mutex_enter(&sc->sc_threadmutex);
	sc->sc_stopping = true;
	cv_signal(&sc->sc_condvar);
	mutex_exit(&sc->sc_threadmutex);

	/* wait for the thread to exit */
	kthread_join(sc->sc_thread);

	mutex_enter(&sc->sc_mutex);
	error = iic_acquire_bus(sc->sc_tag, 0);
	if (error) {
		DPRINTF(sc, 2, ("%s: Could not acquire iic bus for heater off "
		    "in stop thread: %d\n", device_xname(sc->sc_dev), error));
		goto out;
	}
	error = sgp40_cmdr(sc, SGP40_HEATER_OFF, NULL, 0, NULL, 0);
	if (error) {
		DPRINTF(sc, 2, ("%s: Error turning heater off: %d\n",
		    device_xname(sc->sc_dev), error));
	}
out:
	iic_release_bus(sc->sc_tag, 0);
	mutex_exit(&sc->sc_mutex);
}

static int
sgp40_compute_temp_comp(int unconverted)
{
	/*
	 * The published algorithm for this conversion is:
	 * (temp_in_celsius + 45) * 65535 / 175
	 *
	 * However, this did not exactly yield the results that
	 * the example in the data sheet, so something a little
	 * different was done.
	 *
	 * (temp_in_celsius + 45) * 65536 / 175
	 *
	 * This was also scaled up by 10^2 and then scaled back to
	 * preserve some precision.  37449 is simply (65536 * 100) / 175
	 * and rounded.
	 */

	return (((unconverted + 45) * 100) * 37449) / 10000;
}

static int
sgp40_compute_rh_comp(int unconverted)
{
	int q;

	/*
	 * The published algorithm for this conversion is:
	 * %rh * 65535 / 100
	 *
	 * However, this did not exactly yield the results that
	 * the example in the data sheet, so something a little
	 * different was done.
	 *
	 * %rh * 65536 / 100
	 *
	 * This was also scaled up by 10^2 and then scaled back to
	 * preserve some precision.  The value is also latched to 65535
	 * as an upper limit.
	 */

	q = ((unconverted * 100) * 65536) / 10000;
	if (q > 65535)
		q = 65535;
	return q;
}

static void
sgp40_take_measurement(void *aux, VocAlgorithmParams* params)
{
	struct sgp40_sc *sc;
	sc = aux;
	uint8_t args[6];
	uint8_t buf[3];
	uint16_t rawmeasurement;
	int error;
	uint8_t crc;
	uint16_t convertedrh, convertedtemp;
	int32_t voc_index;

	mutex_enter(&sc->sc_mutex);
	convertedrh = (uint16_t)sgp40_compute_rh_comp(sc->sc_rhcomp);
	convertedtemp = (uint16_t)sgp40_compute_temp_comp(sc->sc_tempcomp);

	DPRINTF(sc, 2, ("%s: Converted RH and Temp: %04x %04x\n",
	    device_xname(sc->sc_dev), convertedrh, convertedtemp));

	args[0] = convertedrh >> 8;
	args[1] = convertedrh & 0x00ff;
	args[2] = sgp40_crc(&args[0], 2);
	args[3] = convertedtemp >> 8;
	args[4] = convertedtemp & 0x00ff;
	args[5] = sgp40_crc(&args[3], 2);

	/*
	 * The VOC algorithm has a black out time when it first starts to run
	 * and does not return any indicator that is going on, so voc_index
	 * in that case would be 0..  however, that is also a valid response
	 * otherwise, although an unlikely one.
	 */
	error = iic_acquire_bus(sc->sc_tag, 0);
	if (error) {
		DPRINTF(sc, 2, ("%s: Could not acquire iic bus for take "
		    "measurement: %d\n", device_xname(sc->sc_dev), error));
		sc->sc_voc = 0;
		sc->sc_vocvalid = false;
		goto out;
	}

	error = sgp40_cmdr(sc, SGP40_MEASURE_RAW, args, 6, buf, 3);
	iic_release_bus(sc->sc_tag, 0);
	if (error) {
		DPRINTF(sc, 2, ("%s: Failed to get measurement %d\n",
		    device_xname(sc->sc_dev), error));
		goto out;
	}

	crc = sgp40_crc(&buf[0], 2);
	DPRINTF(sc, 2, ("%s: Raw ticks and crc: %02x%02x %02x "
	    "%02x\n", device_xname(sc->sc_dev), buf[0], buf[1],
	    buf[2], crc));
	if (buf[2] != crc)
		goto out;

	rawmeasurement = buf[0] << 8;
	rawmeasurement |= buf[1];
	VocAlgorithm_process(params, rawmeasurement,
	    &voc_index);
	DPRINTF(sc, 2, ("%s: VOC index: %d\n",
	    device_xname(sc->sc_dev), voc_index));
	sc->sc_voc = voc_index;
	sc->sc_vocvalid = true;

	mutex_exit(&sc->sc_mutex);
	return;
out:
	sc->sc_voc = 0;
	sc->sc_vocvalid = false;
	mutex_exit(&sc->sc_mutex);
}

int
sgp40_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
sgp40_verify_temp_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 < -45 || t > 130)
		return EINVAL;

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

	return 0;
}

int
sgp40_verify_rh_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 || t > 100)
		return EINVAL;

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

	return 0;
}

static int
sgp40_cmddelay(uint16_t cmd)
{
	int r = -1;

	for(int i = 0;i < __arraycount(sgp40_timings);i++) {
		if (cmd == sgp40_timings[i].cmd) {
			r = sgp40_timings[i].typicaldelay;
			break;
		}
	}

	if (r == -1) {
		panic("sgp40: Bad command look up in cmd delay: cmd: %d\n",
		    cmd);
	}

	return r;
}

static int
sgp40_cmd(i2c_tag_t tag, i2c_addr_t addr, uint8_t *cmd,
    uint8_t clen, uint8_t *buf, size_t blen, int readattempts)
{
	int error;
	int cmddelay;
	uint16_t cmd16;

	cmd16 = cmd[0] << 8;
	cmd16 = cmd16 | cmd[1];

	error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, cmd, clen, NULL, 0,
	    0);
	if (error)
		return error;

	/*
	 * Every command returns something except for turning the heater off
	 * and the general soft reset which returns nothing.
	 */
	if (cmd16 == SGP40_HEATER_OFF)
		return 0;
	/*
	 * Every command has a particular delay for how long
	 * it typically takes and the max time it will take.
	 */
	cmddelay = sgp40_cmddelay(cmd16);
	delay(cmddelay);

	for (int aint = 0; aint < readattempts; aint++) {
		error = iic_exec(tag, I2C_OP_READ_WITH_STOP, addr, NULL, 0,
		    buf, blen, 0);
		if (error == 0)
			break;
		delay(1000);
	}

	return error;
}

static int
sgp40_cmdr(struct sgp40_sc *sc, uint16_t cmd, uint8_t *extraargs,
    uint8_t argslen, uint8_t *buf, size_t blen)
{
	uint8_t fullcmd[8];
	uint8_t cmdlen;
	int n;

	/*
	 * The biggest documented command + arguments is 8 uint8_t bytes long.
	 * Catch anything that ties to have an arglen more than 6
	 */
	KASSERT(argslen <= 6);

	memset(fullcmd, 0, 8);

	fullcmd[0] = cmd >> 8;
	fullcmd[1] = cmd & 0x00ff;
	cmdlen = 2;

	n = 0;
	while (extraargs != NULL && n < argslen && cmdlen <= 7) {
		fullcmd[cmdlen] = extraargs[n];
		cmdlen++;
		n++;
	}
	DPRINTF(sc, 2, ("%s: Full command and arguments: %02x %02x %02x %02x "
	    "%02x %02x %02x %02x\n",
	    device_xname(sc->sc_dev), fullcmd[0], fullcmd[1],
	    fullcmd[2], fullcmd[3], fullcmd[4], fullcmd[5],
	    fullcmd[6], fullcmd[7]));
	return sgp40_cmd(sc->sc_tag, sc->sc_addr, fullcmd, cmdlen, buf, blen,
	    sc->sc_readattempts);
}

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

	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) ^ 0x31;
			else
				crc <<= 1;
		}
	}
	return crc;
}

static int
sgp40_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
	uint8_t reg[2];
	uint8_t buf[9];
	int error;

	/*
	 * Possible bug...  this command may not work if the chip is not idle,
	 * however, it appears to be used by a lot of other code as a probe.
	 */
	reg[0] = SGP40_GET_SERIAL_NUMBER >> 8;
	reg[1] = SGP40_GET_SERIAL_NUMBER & 0x00ff;

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

static int
sgp40_sysctl_init(struct sgp40_sc *sc)
{
	int error;
	const struct sysctlnode *cnode;
	int sysctlroot_num;

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

	sysctlroot_num = cnode->sysctl_num;

#ifdef SGP40_DEBUG
	if ((error = sysctl_createv(&sc->sc_sgp40log, 0, NULL, &cnode,
	    CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
	    SYSCTL_DESCR("Debug level"), sgp40_verify_sysctl, 0,
	    &sc->sc_sgp40debug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
	    CTL_EOL)) != 0)
		return error;

#endif

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

	if ((error = sysctl_createv(&sc->sc_sgp40log, 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_sgp40log, 0, NULL, &cnode,
	    0, CTLTYPE_NODE, "compensation",
	    SYSCTL_DESCR("SGP40 measurement compensations"), NULL, 0, NULL, 0,
	    CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
		return error;
	int compensation_num = cnode->sysctl_num;

	if ((error = sysctl_createv(&sc->sc_sgp40log, 0, NULL, &cnode,
	    CTLFLAG_READWRITE, CTLTYPE_INT, "temperature",
	    SYSCTL_DESCR("Temperature compensation in celsius"),
	    sgp40_verify_temp_sysctl, 0, &sc->sc_tempcomp, 0, CTL_HW,
	    sysctlroot_num, compensation_num, CTL_CREATE, CTL_EOL)) != 0)
		return error;

	if ((error = sysctl_createv(&sc->sc_sgp40log, 0, NULL, &cnode,
	    CTLFLAG_READWRITE, CTLTYPE_INT, "humidity",
	    SYSCTL_DESCR("Humidity compensation in %RH"),
	    sgp40_verify_rh_sysctl, 0, &sc->sc_rhcomp, 0, CTL_HW,
	    sysctlroot_num, compensation_num, CTL_CREATE, CTL_EOL)) != 0)
		return error;

	return 0;
}

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

	if (matchdebug)
		printf("in match\n");

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

	/* indirect config - check for configured address */
	if (ia->ia_addr != SGP40_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 = sgp40_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
sgp40_attach(device_t parent, device_t self, void *aux)
{
	struct sgp40_sc *sc;
	struct i2c_attach_args *ia;
	int error, i;
	int ecount = 0;
	uint8_t buf[9];
	uint8_t tstcrc;
	uint16_t chiptestvalue;
	uint64_t serial_number = 0;
	uint8_t sn_crc1, sn_crc2, sn_crc3, sn_crcv1, sn_crcv2, sn_crcv3;
	uint8_t fs_crc, fs_crcv;
	uint16_t featureset;

	ia = aux;
	sc = device_private(self);

	sc->sc_dev = self;
	sc->sc_tag = ia->ia_tag;
	sc->sc_addr = ia->ia_addr;
	sc->sc_sgp40debug = 0;
	sc->sc_readattempts = 10;
	sc->sc_ignorecrc = false;
	sc->sc_stopping = false;
	sc->sc_voc = 0;
	sc->sc_vocvalid = false;
	sc->sc_tempcomp = SGP40_DEFAULT_TEMP_COMP;
	sc->sc_rhcomp = SGP40_DEFAULT_RH_COMP;
	sc->sc_sme = NULL;

	aprint_normal("\n");

	mutex_init(&sc->sc_threadmutex, MUTEX_DEFAULT, IPL_NONE);
	mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
	cv_init(&sc->sc_condvar, "sgp40cv");
	sc->sc_numsensors = __arraycount(sgp40_sensors);

	if ((sc->sc_sme = sysmon_envsys_create()) == NULL) {
		aprint_error_dev(self,
		    "Unable to create sysmon structure\n");
		sc->sc_sme = NULL;
		return;
	}
	if ((error = sgp40_sysctl_init(sc)) != 0) {
		aprint_error_dev(self, "Can't setup sysctl tree (%d)\n", error);
		goto out;
	}

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

	/*
	 * Usually one would reset the chip here, but that is not possible
	 * without resetting the entire bus, so we won't do that.
	 *
	 * What we will do is make sure that the chip is idle by running the
	 * turn-the-heater command.
	 */

	error = sgp40_cmdr(sc, SGP40_HEATER_OFF, NULL, 0, NULL, 0);
	if (error) {
		aprint_error_dev(self, "Failed to turn off the heater: %d\n",
		    error);
		ecount++;
	}

	error = sgp40_cmdr(sc, SGP40_GET_SERIAL_NUMBER, NULL, 0, buf, 9);
	if (error) {
		aprint_error_dev(self, "Failed to get serial number: %d\n",
		    error);
		ecount++;
	}

	sn_crc1 = sgp40_crc(&buf[0], 2);
	sn_crc2 = sgp40_crc(&buf[3], 2);
	sn_crc3 = sgp40_crc(&buf[6], 2);
	sn_crcv1 = buf[2];
	sn_crcv2 = buf[5];
	sn_crcv3 = buf[8];
	serial_number = buf[0];
	serial_number = (serial_number << 8) | buf[1];
	serial_number = (serial_number << 8) | buf[3];
	serial_number = (serial_number << 8) | buf[4];
	serial_number = (serial_number << 8) | buf[6];
	serial_number = (serial_number << 8) | buf[7];

	DPRINTF(sc, 2, ("%s: raw serial number: %02x %02x %02x %02x %02x %02x "
	    "%02x %02x %02x\n",
	    device_xname(sc->sc_dev), buf[0], buf[1], buf[2], buf[3], buf[4],
	    buf[5], buf[6], buf[7], buf[8]));

	error = sgp40_cmdr(sc, SGP40_GET_FEATURESET, NULL, 0, buf, 3);
	if (error) {
		aprint_error_dev(self, "Failed to get featureset: %d\n",
		    error);
		ecount++;
	}

	fs_crc = sgp40_crc(&buf[0], 2);
	fs_crcv = buf[2];
	featureset = buf[0];
	featureset = (featureset << 8) | buf[1];

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

	error = sgp40_cmdr(sc, SGP40_MEASURE_TEST, NULL, 0, buf, 3);
	if (error) {
		aprint_error_dev(self, "Failed to perform a chip test: %d\n",
		    error);
		ecount++;
	}

	tstcrc = sgp40_crc(&buf[0], 2);

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

	iic_release_bus(sc->sc_tag, 0);
	if (error != 0) {
		aprint_error_dev(self, "Unable to setup device\n");
		goto out;
	}

	chiptestvalue = buf[0] << 8;
	chiptestvalue |= buf[1];

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

		sc->sc_sensors[i].units = sgp40_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);
			goto out;
		}
	}

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

	DPRINTF(sc, 2, ("sgp40_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;
	}

	error = kthread_create(PRI_NONE, KTHREAD_MUSTJOIN, NULL,
	    sgp40_thread, sc, &sc->sc_thread, "%s", device_xname(sc->sc_dev));
	if (error) {
		aprint_error_dev(self,"Unable to create measurement thread\n");
		goto out;
	}

	aprint_normal_dev(self, "Sensirion SGP40, Serial number: %jx%s"
	    "Feature set word: 0x%jx%s%s%s", serial_number,
	    (sn_crc1 == sn_crcv1 && sn_crc2 == sn_crcv2 && sn_crc3 == sn_crcv3)
	    ? ", " : " (bad crc), ",
	    (uintmax_t)featureset,
	    (fs_crc == fs_crcv) ? ", " : " (bad crc), ",
	    (chiptestvalue == SGP40_TEST_RESULTS_ALL_PASSED) ?
		"All chip tests passed" :
	    (chiptestvalue == SGP40_TEST_RESULTS_SOME_FAILED) ?
		"Some chip tests failed" :
	    "Unknown test results",
	    (tstcrc == buf[2]) ? "\n" : " (bad crc)\n");
	return;
out:
	sysmon_envsys_destroy(sc->sc_sme);
	sc->sc_sme = NULL;
}

static void
sgp40_refresh(struct sysmon_envsys * sme, envsys_data_t * edata)
{
	struct sgp40_sc *sc;
	sc = sme->sme_cookie;

	mutex_enter(&sc->sc_mutex);
	if (sc->sc_vocvalid == true) {
		edata->value_cur = (uint32_t)sc->sc_voc;
		edata->state = ENVSYS_SVALID;
	} else {
		edata->state = ENVSYS_SINVALID;
	}
	mutex_exit(&sc->sc_mutex);
}

static int
sgp40_detach(device_t self, int flags)
{
	struct sgp40_sc *sc;

	sc = device_private(self);

	/* stop the measurement thread */
	sgp40_stop_thread(sc);

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

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

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

	return 0;
}

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

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

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

	switch (cmd) {
	case MODULE_CMD_INIT:
#ifdef _MODULE
		return config_init_component(cfdriver_ioconf_sgp40mox,
		    cfattach_ioconf_sgp40mox, cfdata_ioconf_sgp40mox);
#else
		return 0;
#endif
	case MODULE_CMD_FINI:
#ifdef _MODULE
		return config_fini_component(cfdriver_ioconf_sgp40mox,
		      cfattach_ioconf_sgp40mox, cfdata_ioconf_sgp40mox);
#else
		return 0;
#endif
	default:
		return ENOTTY;
	}
}