Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/i2c/sgp40.c

832 lines
20 KiB
C
Raw Permalink Blame History

/* $NetBSD: sgp40.c,v 1.5 2022/05/24 06:28:01 andvar Exp $ */
/*
* Copyright (c) 2021 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, 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;
}
}
Reference in New Issue View Git Blame Copy Permalink