/* $NetBSD: sht3x.c,v 1.10 2025/01/23 19:14:46 brad Exp $ */
/*
* Copyright (c) 2021 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: sht3x.c,v 1.10 2025/01/23 19:14:46 brad Exp $");
/*
Driver for the Sensirion SHT30/SHT31/SHT35
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/module.h>
#include <sys/conf.h>
#include <sys/sysctl.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/kthread.h>
#include <sys/pool.h>
#include <sys/kmem.h>
#include <dev/sysmon/sysmonvar.h>
#include <dev/i2c/i2cvar.h>
#include <dev/i2c/sht3xreg.h>
#include <dev/i2c/sht3xvar.h>
static int sht3x_take_break(void *, bool);
static int sht3x_get_status_register(void *, uint16_t *, bool);
static int sht3x_clear_status_register(void *, bool);
static uint8_t sht3x_crc(uint8_t *, size_t);
static int sht3x_cmdr(struct sht3x_sc *, uint16_t, uint8_t *, size_t);
static int sht3x_poke(i2c_tag_t, i2c_addr_t, bool);
static int sht3x_match(device_t, cfdata_t, void *);
static void sht3x_attach(device_t, device_t, void *);
static int sht3x_detach(device_t, int);
static void sht3x_refresh(struct sysmon_envsys *, envsys_data_t *);
static int sht3x_verify_sysctl(SYSCTLFN_ARGS);
static int sht3x_verify_sysctl_heateron(SYSCTLFN_ARGS);
static int sht3x_verify_sysctl_modes(SYSCTLFN_ARGS);
static int sht3x_verify_sysctl_repeatability(SYSCTLFN_ARGS);
static int sht3x_verify_sysctl_rate(SYSCTLFN_ARGS);
static int sht3x_set_heater(struct sht3x_sc *);
static void sht3x_thread(void *);
static int sht3x_init_periodic_measurement(void *, int *);
static void sht3x_take_periodic_measurement(void *);
static void sht3x_start_thread(void *);
static void sht3x_stop_thread(void *);
static int sht3x_activate(device_t, enum devact);
#define SHT3X_DEBUG
#ifdef SHT3X_DEBUG
#define DPRINTF(s, l, x) \
do { \
if (l <= s->sc_sht3xdebug) \
printf x; \
} while (/*CONSTCOND*/0)
#else
#define DPRINTF(s, l, x)
#endif
CFATTACH_DECL_NEW(sht3xtemp, sizeof(struct sht3x_sc),
sht3x_match, sht3x_attach, sht3x_detach, sht3x_activate);
extern struct cfdriver sht3xtemp_cd;
static dev_type_open(sht3xopen);
static dev_type_read(sht3xread);
static dev_type_close(sht3xclose);
const struct cdevsw sht3x_cdevsw = {
.d_open = sht3xopen,
.d_close = sht3xclose,
.d_read = sht3xread,
.d_write = nowrite,
.d_ioctl = noioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = D_OTHER
};
static struct sht3x_sensor sht3x_sensors[] = {
{
.desc = "humidity",
.type = ENVSYS_SRELHUMIDITY,
},
{
.desc = "temperature",
.type = ENVSYS_STEMP,
}
};
/* The typical delays are MOSTLY documented in the datasheet for the chip.
There is no need to be very accurate with these, just rough estimates
will work fine.
*/
static struct sht3x_timing sht3x_timings[] = {
{
.cmd = SHT3X_SOFT_RESET,
.typicaldelay = 3000,
},
{
.cmd = SHT3X_GET_STATUS_REGISTER,
.typicaldelay = 100,
},
{
.cmd = SHT3X_BREAK,
.typicaldelay = 100,
},
{
.cmd = SHT3X_CLEAR_STATUS_REGISTER,
.typicaldelay = 100,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_CS_HIGH,
.typicaldelay = 15000,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_CS_MEDIUM,
.typicaldelay = 6000,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_CS_LOW,
.typicaldelay = 4000,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_HIGH,
.typicaldelay = 15000,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_MEDIUM,
.typicaldelay = 6000,
},
{
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_LOW,
.typicaldelay = 4000,
},
{
.cmd = SHT3X_WRITE_HIGH_ALERT_SET,
.typicaldelay = 5000,
},
{
.cmd = SHT3X_WRITE_HIGH_ALERT_CLEAR,
.typicaldelay = 5000,
},
{
.cmd = SHT3X_WRITE_LOW_ALERT_SET,
.typicaldelay = 5000,
},
{
.cmd = SHT3X_WRITE_LOW_ALERT_CLEAR,
.typicaldelay = 5000,
},
{
.cmd = SHT3X_READ_SERIAL_NUMBER,
.typicaldelay = 500,
}
};
/* In single shot mode, find the command */
static struct sht3x_repeatability sht3x_repeatability_ss[] = {
{
.text = "high",
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_HIGH,
.cscmd = SHT3X_MEASURE_REPEATABILITY_CS_HIGH,
},
{
.text = "medium",
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_MEDIUM,
.cscmd = SHT3X_MEASURE_REPEATABILITY_CS_MEDIUM,
},
{
.text = "low",
.cmd = SHT3X_MEASURE_REPEATABILITY_NOCS_LOW,
.cscmd = SHT3X_MEASURE_REPEATABILITY_CS_LOW,
}
};
/* For periodic, look at the repeatability and the rate.
* ART is a bit fake here, as the repeatability is not really
* used.
*/
static struct sht3x_periodic sht3x_periodic_rate[] = {
{
.repeatability = "high",
.rate = "0.5mps",
.sdelay = 1000,
.cmd = SHT3X_HALF_MPS_HIGH,
},
{
.repeatability = "medium",
.rate = "0.5mps",
.sdelay = 1000,
.cmd = SHT3X_HALF_MPS_MEDIUM,
},
{
.repeatability = "low",
.rate = "0.5mps",
.sdelay = 1000,
.cmd = SHT3X_HALF_MPS_LOW,
},
{
.repeatability = "high",
.rate = "1.0mps",
.sdelay = 500,
.cmd = SHT3X_ONE_MPS_HIGH,
},
{
.repeatability = "medium",
.rate = "1.0mps",
.sdelay = 500,
.cmd = SHT3X_ONE_MPS_MEDIUM,
},
{
.repeatability = "low",
.rate = "1.0mps",
.sdelay = 500,
.cmd = SHT3X_ONE_MPS_LOW,
},
{
.repeatability = "high",
.rate = "2.0mps",
.sdelay = 250,
.cmd = SHT3X_TWO_MPS_HIGH,
},
{
.repeatability = "medium",
.rate = "2.0mps",
.sdelay = 250,
.cmd = SHT3X_TWO_MPS_MEDIUM,
},
{
.repeatability = "low",
.rate = "2.0mps",
.sdelay = 250,
.cmd = SHT3X_TWO_MPS_LOW,
},
{
.repeatability = "high",
.rate = "4.0mps",
.sdelay = 100,
.cmd = SHT3X_FOUR_MPS_HIGH,
},
{
.repeatability = "medium",
.rate = "4.0mps",
.sdelay = 100,
.cmd = SHT3X_FOUR_MPS_MEDIUM,
},
{
.repeatability = "low",
.rate = "4.0mps",
.sdelay = 100,
.cmd = SHT3X_FOUR_MPS_LOW,
},
{
.repeatability = "high",
.rate = "10.0mps",
.sdelay = 50,
.cmd = SHT3X_TEN_MPS_HIGH,
},
{
.repeatability = "medium",
.rate = "10.0mps",
.sdelay = 50,
.cmd = SHT3X_FOUR_MPS_MEDIUM,
},
{
.repeatability = "low",
.rate = "10.0mps",
.sdelay = 50,
.cmd = SHT3X_FOUR_MPS_LOW,
},
{
.repeatability = "high",
.rate = "ART",
.sdelay = 100,
.cmd = SHT3X_ART_ENABLE,
},
{
.repeatability = "medium",
.rate = "ART",
.sdelay = 100,
.cmd = SHT3X_ART_ENABLE,
},
{
.repeatability = "low",
.rate = "ART",
.sdelay = 100,
.cmd = SHT3X_ART_ENABLE,
}
};
static const char sht3x_rate_names[] =
"0.5mps, 1.0mps, 2.0mps, 4.0mps, 10.0mps, ART";
static const char sht3x_mode_names[] =
"single-shot, periodic";
static const char sht3x_repeatability_names[] =
"high, medium, low";
static int
sht3x_take_break(void *aux, bool have_bus)
{
struct sht3x_sc *sc;
sc = aux;
int error = 0;
if (! have_bus) {
error = iic_acquire_bus(sc->sc_tag, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Could not acquire iic bus for "
"breaking %d\n", device_xname(sc->sc_dev), error));
goto out;
}
}
error = sht3x_cmdr(sc, SHT3X_BREAK, NULL, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Error breaking: %d\n",
device_xname(sc->sc_dev), error));
}
out:
if (! have_bus) {
iic_release_bus(sc->sc_tag, 0);
}
sc->sc_isperiodic = false;
strlcpy(sc->sc_mode, "single-shot", SHT3X_MODE_NAME);
return error;
}
static int
sht3x_get_status_register(void *aux, uint16_t *reg, bool have_bus)
{
struct sht3x_sc *sc = aux;
uint8_t buf[3];
int error;
if (! have_bus) {
error = iic_acquire_bus(sc->sc_tag, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Could not acquire iic bus for "
"getting status %d\n", device_xname(sc->sc_dev),
error));
return error;
}
}
error = sht3x_cmdr(sc, SHT3X_GET_STATUS_REGISTER, buf, 3);
if (error) {
DPRINTF(sc, 2, ("%s: Error getting status: %d\n",
device_xname(sc->sc_dev), error));
goto out;
}
uint8_t c = sht3x_crc(&buf[0], 2);
if (c == buf[2]) {
*reg = buf[0] << 8 | buf[1];
} else {
error = EINVAL;
}
out:
if (! have_bus) {
iic_release_bus(sc->sc_tag, 0);
}
return error;
}
static int
sht3x_clear_status_register(void *aux, bool have_bus)
{
struct sht3x_sc *sc = aux;
int error;
if (! have_bus) {
error = iic_acquire_bus(sc->sc_tag, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Could not acquire iic bus for "
"clearing status %d\n", device_xname(sc->sc_dev),
error));
return error;
}
}
error = sht3x_cmdr(sc, SHT3X_CLEAR_STATUS_REGISTER, NULL, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Error clear status register: %d\n",
device_xname(sc->sc_dev), error));
}
if (! have_bus) {
iic_release_bus(sc->sc_tag, 0);
}
return error;
}
void
sht3x_thread(void *aux)
{
struct sht3x_sc *sc = aux;
int error, rv;
int sdelay = 100;
mutex_enter(&sc->sc_threadmutex);
while (!sc->sc_stopping && !sc->sc_dying) {
if (sc->sc_initperiodic) {
error = sht3x_init_periodic_measurement(sc, &sdelay);
if (error) {
DPRINTF(sc, 2, ("%s: Error initing periodic "
"measurement in thread: %d\n",
device_xname(sc->sc_dev), error));
}
sc->sc_initperiodic = false;
}
rv = cv_timedwait(&sc->sc_condvar, &sc->sc_threadmutex,
mstohz(sdelay));
if (rv == EWOULDBLOCK && !sc->sc_stopping &&
!sc->sc_initperiodic && !sc->sc_dying) {
sht3x_take_periodic_measurement(sc);
}
}
mutex_exit(&sc->sc_threadmutex);
kthread_exit(0);
}
int
sht3x_init_periodic_measurement(void *aux, int *sdelay)
{
struct sht3x_sc *sc = aux;
size_t i;
int error;
uint16_t r;
for (i = 0; i < __arraycount(sht3x_periodic_rate); i++) {
if (strncmp(sc->sc_repeatability,
sht3x_periodic_rate[i].repeatability, SHT3X_REP_NAME) == 0 &&
strncmp(sc->sc_periodic_rate, sht3x_periodic_rate[i].rate,
SHT3X_RATE_NAME) == 0)
{
r = sht3x_periodic_rate[i].cmd;
*sdelay = sht3x_periodic_rate[i].sdelay;
break;
}
}
if (i == __arraycount(sht3x_periodic_rate)) {
*sdelay = 100;
return ENODEV;
}
DPRINTF(sc, 2, ("%s: Would init with: %x\n",
device_xname(sc->sc_dev), r));
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 initing: "
" %d\n", device_xname(sc->sc_dev), error));
goto outm;
}
error = sht3x_take_break(sc, true);
if (error) {
DPRINTF(sc, 2, ("%s: Could not acquire iic bus for initing: "
" %d\n", device_xname(sc->sc_dev), error));
goto out;
}
error = sht3x_cmdr(sc, r, NULL, 0);
if (error) {
DPRINTF(sc, 2,
("%s: Error sending periodic measurement command: %d\n",
device_xname(sc->sc_dev), error));
goto out;
}
sc->sc_isperiodic = true;
strlcpy(sc->sc_mode, "periodic", SHT3X_MODE_NAME);
out:
iic_release_bus(sc->sc_tag, 0);
outm:
mutex_exit(&sc->sc_mutex);
return error;
}
static void
sht3x_take_periodic_measurement(void *aux)
{
struct sht3x_sc *sc = aux;
int error;
struct sht3x_read_q *pp;
uint8_t rawbuf[MAX(sizeof(sc->sc_pbuffer), sizeof(pp->measurement))];
uint16_t status_reg;
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 getting "
"periodic data: %d\n", device_xname(sc->sc_dev), error));
goto out;
}
error = sht3x_get_status_register(sc, &status_reg, true);
if (error) {
DPRINTF(sc, 2,
("%s: Error getting status register periodic: %d\n",
device_xname(sc->sc_dev), error));
goto err;
}
if (status_reg & SHT3X_RESET_DETECTED) {
aprint_error_dev(sc->sc_dev, "Reset detected in periodic mode. "
"Heater may have been reset.\n");
delay(3000);
sht3x_take_break(sc, true);
sht3x_clear_status_register(sc, true);
sc->sc_heateron = status_reg & SHT3X_HEATER_STATUS;
sc->sc_initperiodic = true;
} else {
int data_error = sht3x_cmdr(sc, SHT3X_PERIODIC_FETCH_DATA,
rawbuf, sizeof(rawbuf));
/*
* EIO is actually expected if the poll interval is faster
* than the rate that the sensor is set to. Unfortunately,
* this will also mess with the ability to detect an actual
* problem with the sensor in periodic mode, so we do the best
* we can here.
*/
if (data_error) {
if (data_error != EIO) {
DPRINTF(sc, 2, ("%s: Error sending periodic "
"fetch command: %d\n",
device_xname(sc->sc_dev), data_error));
}
goto err;
}
}
iic_release_bus(sc->sc_tag, 0);
/*
* If there was no errors from anything then the data should be
* valid.
*/
DPRINTF(sc, 2, ("%s: Raw periodic: %x%x - %x -- %x%x - %x\n",
device_xname(sc->sc_dev), rawbuf[0], rawbuf[1], rawbuf[2],
rawbuf[3], rawbuf[4], rawbuf[5]));
memcpy(sc->sc_pbuffer, rawbuf, sizeof(sc->sc_pbuffer));
if (sc->sc_opened) {
mutex_enter(&sc->sc_read_mutex);
pp = pool_cache_get(sc->sc_readpool, PR_NOWAIT);
if (pp == NULL) {
aprint_error_dev(sc->sc_dev,
"Could not allocate memory for pool read\n");
} else {
memcpy(pp->measurement, rawbuf, sizeof(pp->measurement));
DPRINTF(sc, 4, ("%s: Queue insert\n",
device_xname(sc->sc_dev)));
SIMPLEQ_INSERT_HEAD(&sc->sc_read_queue, pp, read_q);
}
cv_signal(&sc->sc_condreadready);
mutex_exit(&sc->sc_read_mutex);
}
out:
mutex_exit(&sc->sc_mutex);
return;
err:
/*
* We are only going to worry about errors when it was not related
* to actually getting data. That is a likely indicator of a problem
* with the sensor.
*/
DPRINTF(sc, 2, ("%s: Raw periodic with error: %x%x - %x -- "
"%x%x - %x -- %d\n", device_xname(sc->sc_dev), rawbuf[0], rawbuf[1],
rawbuf[2], rawbuf[3], rawbuf[4], rawbuf[5], error));
iic_release_bus(sc->sc_tag, 0);
if (error != 0) {
memcpy(sc->sc_pbuffer, "dedbef", sizeof(sc->sc_pbuffer));
}
mutex_exit(&sc->sc_mutex);
}
static void
sht3x_stop_thread(void *aux)
{
struct sht3x_sc *sc;
sc = aux;
if (!sc->sc_isperiodic) {
return;
}
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);
sht3x_take_break(sc,false);
mutex_exit(&sc->sc_mutex);
}
static void
sht3x_start_thread(void *aux)
{
struct sht3x_sc *sc;
sc = aux;
int error;
error = kthread_create(PRI_NONE, KTHREAD_MUSTJOIN, NULL,
sht3x_thread, sc, &sc->sc_thread, "%s", device_xname(sc->sc_dev));
if (error) {
DPRINTF(sc, 2, ("%s: Unable to create measurement thread: %d\n",
device_xname(sc->sc_dev), error));
}
}
int
sht3x_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
sht3x_verify_sysctl_heateron(SYSCTLFN_ARGS)
{
int error;
bool t;
struct sht3x_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 = sht3x_set_heater(sc);
return error;
}
static int
sht3x_set_heater(struct sht3x_sc *sc)
{
int error = 0;
uint16_t cmd;
mutex_enter(&sc->sc_mutex);
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));
goto out;
}
if (sc->sc_heateron) {
cmd = SHT3X_HEATER_ENABLE;
} else {
cmd = SHT3X_HEATER_DISABLE;
}
error = sht3x_cmdr(sc, cmd, NULL, 0);
iic_release_bus(sc->sc_tag,0);
out:
mutex_exit(&sc->sc_mutex);
return error;
}
int
sht3x_verify_sysctl_modes(SYSCTLFN_ARGS)
{
char buf[SHT3X_MODE_NAME];
struct sht3x_sc *sc;
struct sysctlnode node;
bool is_ss = false;
bool is_periodic = false;
int error;
node = *rnode;
sc = node.sysctl_data;
(void) memcpy(buf, sc->sc_mode, SHT3X_MODE_NAME);
node.sysctl_data = buf;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
if (sc->sc_opened) {
return EINVAL;
}
is_ss = strncmp(node.sysctl_data, "single-shot", SHT3X_MODE_NAME) == 0;
is_periodic = strncmp(node.sysctl_data, "periodic", SHT3X_MODE_NAME)
== 0;
if (!is_ss && !is_periodic) {
return EINVAL;
}
(void) memcpy(sc->sc_mode, node.sysctl_data, SHT3X_MODE_NAME);
if (is_ss) {
sht3x_stop_thread(sc);
sc->sc_stopping = false;
sc->sc_initperiodic = false;
sc->sc_isperiodic = false;
}
if (is_periodic) {
sc->sc_stopping = false;
sc->sc_initperiodic = true;
sc->sc_isperiodic = true;
sht3x_start_thread(sc);
}
return 0;
}
int
sht3x_verify_sysctl_repeatability(SYSCTLFN_ARGS)
{
char buf[SHT3X_REP_NAME];
struct sht3x_sc *sc;
struct sysctlnode node;
int error;
size_t i;
node = *rnode;
sc = node.sysctl_data;
(void) memcpy(buf, sc->sc_repeatability, SHT3X_REP_NAME);
node.sysctl_data = buf;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
for (i = 0; i < __arraycount(sht3x_repeatability_ss); i++) {
if (strncmp(node.sysctl_data, sht3x_repeatability_ss[i].text,
SHT3X_REP_NAME) == 0) {
break;
}
}
if (i == __arraycount(sht3x_repeatability_ss))
return EINVAL;
(void) memcpy(sc->sc_repeatability, node.sysctl_data, SHT3X_REP_NAME);
if (sc->sc_isperiodic) {
sc->sc_initperiodic = true;
}
return error;
}
int
sht3x_verify_sysctl_rate(SYSCTLFN_ARGS)
{
char buf[SHT3X_RATE_NAME];
struct sht3x_sc *sc;
struct sysctlnode node;
int error;
size_t i;
node = *rnode;
sc = node.sysctl_data;
(void) memcpy(buf, sc->sc_periodic_rate, SHT3X_RATE_NAME);
node.sysctl_data = buf;
error = sysctl_lookup(SYSCTLFN_CALL(&node));
if (error || newp == NULL)
return error;
for (i = 0; i < __arraycount(sht3x_periodic_rate); i++) {
if (strncmp(node.sysctl_data, sht3x_periodic_rate[i].rate,
SHT3X_RATE_NAME) == 0) {
break;
}
}
if (i == __arraycount(sht3x_periodic_rate))
return EINVAL;
(void) memcpy(sc->sc_periodic_rate, node.sysctl_data, SHT3X_RATE_NAME);
if (sc->sc_isperiodic) {
sc->sc_initperiodic = true;
}
return error;
}
static int
sht3x_cmddelay(uint16_t cmd)
{
size_t i;
for (i = 0; i < __arraycount(sht3x_timings); i++) {
if (cmd == sht3x_timings[i].cmd) {
break;
}
}
if (i == __arraycount(sht3x_timings)) {
return -1;
}
return sht3x_timings[i].typicaldelay;
}
static int
sht3x_cmd(i2c_tag_t tag, i2c_addr_t addr, uint16_t *cmd,
uint8_t clen, uint8_t *buf, size_t blen, int readattempts)
{
int error;
int cmddelay;
uint8_t cmd8[2];
/* All commands are two bytes and must be in a proper order */
KASSERT(clen == 2);
cmd8[0] = cmd[0] >> 8;
cmd8[1] = cmd[0] & 0x00ff;
if (cmd[0] == SHT3X_MEASURE_REPEATABILITY_CS_HIGH ||
cmd[0] == SHT3X_MEASURE_REPEATABILITY_CS_MEDIUM ||
cmd[0] == SHT3X_MEASURE_REPEATABILITY_CS_LOW) {
error = iic_exec(tag, I2C_OP_READ_WITH_STOP, addr, &cmd8[0], clen,
buf, blen, 0);
} else {
error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &cmd8[0], clen,
NULL, 0, 0);
if (error)
return error;
cmddelay = sht3x_cmddelay(cmd[0]);
if (cmddelay != -1) {
delay(cmddelay);
}
/* Not all commands return anything */
if (blen == 0) {
return 0;
}
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
sht3x_cmdr(struct sht3x_sc *sc, uint16_t cmd, uint8_t *buf, size_t blen)
{
return sht3x_cmd(sc->sc_tag, sc->sc_addr, &cmd, 2, buf, blen,
sc->sc_readattempts);
}
static uint8_t
sht3x_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
sht3x_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
uint16_t reg = SHT3X_GET_STATUS_REGISTER;
uint8_t buf[3];
int error;
error = sht3x_cmd(tag, addr, ®, 2, buf, 3, 10);
if (matchdebug) {
printf("poke X 1: %d\n", error);
}
return error;
}
static int
sht3x_sysctl_init(struct sht3x_sc *sc)
{
int error;
const struct sysctlnode *cnode;
int sysctlroot_num;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
0, CTLTYPE_NODE, device_xname(sc->sc_dev),
SYSCTL_DESCR("sht3x controls"), NULL, 0, NULL, 0, CTL_HW,
CTL_CREATE, CTL_EOL)) != 0)
return error;
sysctlroot_num = cnode->sysctl_num;
#ifdef SHT3X_DEBUG
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
SYSCTL_DESCR("Debug level"), sht3x_verify_sysctl, 0,
&sc->sc_sht3xdebug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
CTL_EOL)) != 0)
return error;
#endif
if ((error = sysctl_createv(&sc->sc_sht3xlog, 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_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_INT, "readattempts",
SYSCTL_DESCR("The number of times to attempt to read the values"),
sht3x_verify_sysctl, 0, &sc->sc_readattempts, 0, CTL_HW,
sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READONLY, CTLTYPE_STRING, "modes",
SYSCTL_DESCR("Valid modes"), 0, 0,
__UNCONST(sht3x_mode_names),
sizeof(sht3x_mode_names) + 1,
CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_STRING, "mode",
SYSCTL_DESCR("Mode for measurement collection"),
sht3x_verify_sysctl_modes, 0, (void *) sc,
SHT3X_MODE_NAME, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READONLY, CTLTYPE_STRING, "repeatabilities",
SYSCTL_DESCR("Valid repeatability values"), 0, 0,
__UNCONST(sht3x_repeatability_names),
sizeof(sht3x_repeatability_names) + 1,
CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_STRING, "repeatability",
SYSCTL_DESCR("Repeatability of RH and Temp"),
sht3x_verify_sysctl_repeatability, 0, (void *) sc,
SHT3X_REP_NAME, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READONLY, CTLTYPE_STRING, "rates",
SYSCTL_DESCR("Valid periodic rates"), 0, 0,
__UNCONST(sht3x_rate_names),
sizeof(sht3x_rate_names) + 1,
CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_STRING, "rate",
SYSCTL_DESCR("Rate for periodic measurements"),
sht3x_verify_sysctl_rate, 0, (void *) sc,
SHT3X_RATE_NAME, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_sht3xlog, 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_sht3xlog, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_BOOL, "heateron",
SYSCTL_DESCR("Heater on"), sht3x_verify_sysctl_heateron, 0,
(void *)sc, 0, CTL_HW, sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
return 0;
}
static int
sht3x_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;
if (matchdebug) {
printf("Looking at ia_addr: %x\n",ia->ia_addr);
}
/* indirect config - check for configured address */
if (ia->ia_addr != SHT3X_TYPICAL_ADDR_1 &&
ia->ia_addr != SHT3X_TYPICAL_ADDR_2)
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 = sht3x_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
sht3x_attach(device_t parent, device_t self, void *aux)
{
struct sht3x_sc *sc;
struct i2c_attach_args *ia;
int error, i;
int ecount = 0;
uint8_t buf[6];
uint32_t serialnumber;
uint8_t sncrcpt1, sncrcpt2;
ia = aux;
sc = device_private(self);
sc->sc_dev = self;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
sc->sc_sht3xdebug = 0;
strlcpy(sc->sc_mode, "single-shot", SHT3X_MODE_NAME);
sc->sc_isperiodic = false;
strlcpy(sc->sc_repeatability, "high", SHT3X_REP_NAME);
strlcpy(sc->sc_periodic_rate, "1.0mps", SHT3X_RATE_NAME);
sc->sc_readattempts = 10;
sc->sc_ignorecrc = false;
sc->sc_heateron = false;
sc->sc_sme = NULL;
sc->sc_stopping = false;
sc->sc_initperiodic = false;
sc->sc_opened = false;
sc->sc_clockstretch = false;
sc->sc_dying = false;
sc->sc_readpoolname = NULL;
aprint_normal("\n");
mutex_init(&sc->sc_dying_mutex, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_read_mutex, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_threadmutex, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
cv_init(&sc->sc_condvar, "sht3xcv");
cv_init(&sc->sc_condreadready, "sht3xread");
cv_init(&sc->sc_cond_dying, "sht3xdie");
sc->sc_numsensors = __arraycount(sht3x_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 = sht3x_sysctl_init(sc)) != 0) {
aprint_error_dev(self, "Can't setup sysctl tree (%d)\n", error);
goto out;
}
sc->sc_readpoolname = kmem_asprintf("sht3xrp%d",device_unit(self));
sc->sc_readpool = pool_cache_init(sizeof(struct sht3x_read_q), 0, 0, 0,
sc->sc_readpoolname, NULL, IPL_VM, NULL, NULL, NULL);
pool_cache_sethiwat(sc->sc_readpool,100);
SIMPLEQ_INIT(&sc->sc_read_queue);
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 = sht3x_cmdr(sc, SHT3X_SOFT_RESET, NULL, 0);
if (error != 0)
aprint_error_dev(self, "Reset failed: %d\n", error);
error = sht3x_clear_status_register(sc, true);
if (error) {
aprint_error_dev(self, "Failed to clear status register: %d\n",
error);
ecount++;
}
uint16_t status_reg;
error = sht3x_get_status_register(sc, &status_reg, true);
if (error) {
aprint_error_dev(self, "Failed to read status register: %d\n",
error);
ecount++;
}
DPRINTF(sc, 2, ("%s: read status register values: %04x\n",
device_xname(sc->sc_dev), status_reg));
error = sht3x_cmdr(sc, SHT3X_READ_SERIAL_NUMBER, buf, 6);
if (error) {
aprint_error_dev(self, "Failed to read serial number: %d\n",
error);
ecount++;
}
sncrcpt1 = sht3x_crc(&buf[0],2);
sncrcpt2 = sht3x_crc(&buf[3],2);
serialnumber = (buf[0] << 24) | (buf[1] << 16) | (buf[3] << 8) | buf[4];
DPRINTF(sc, 2, ("%s: read serial number values: %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], sncrcpt1, sncrcpt2));
iic_release_bus(sc->sc_tag, 0);
if (error != 0) {
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, sht3x_sensors[i].desc,
sizeof(sc->sc_sensors[i].desc));
sc->sc_sensors[i].units = sht3x_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 = sht3x_refresh;
DPRINTF(sc, 2, ("sht3x_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;
}
/*
* There is no documented way to ask the chip what version it is. This
* is likely fine as the only apparent difference is in how precise the
* measurements will be. The actual conversation with the chip is
* identical no matter which one you are talking to.
*/
aprint_normal_dev(self, "Sensirion SHT30/SHT31/SHT35, "
"Serial number: %x%s", serialnumber,
(sncrcpt1 == buf[2] && sncrcpt2 == buf[5]) ? "\n" : " (bad crc)\n");
return;
out:
sysmon_envsys_destroy(sc->sc_sme);
sc->sc_sme = NULL;
}
static uint16_t
sht3x_compute_measure_command_ss(const char *repeatability, bool clockstretch)
{
int i;
uint16_t r;
for (i = 0; i < __arraycount(sht3x_repeatability_ss); i++) {
if (strncmp(repeatability, sht3x_repeatability_ss[i].text,
SHT3X_REP_NAME) == 0) {
if (clockstretch)
r = sht3x_repeatability_ss[i].cscmd;
else
r = sht3x_repeatability_ss[i].cmd;
break;
}
}
if (i == __arraycount(sht3x_repeatability_ss))
panic("Single-shot could not find command for "
"repeatability: %s\n", repeatability);
return r;
}
/*
* The documented conversion calculations for the raw values are as follows:
*
* %RH = (-6 + 125 * rawvalue / 65535)
*
* T in Celsius = (-45 + 175 * rawvalue / 65535)
*
* It follows then:
*
* T in Kelvin = (228.15 + 175 * rawvalue / 65535)
*
* given the relationship between Celsius and Kelvin
*
* What follows reorders the calculation a bit and scales it up to avoid
* the use of any floating point. All that would really have to happen
* is a scale up to 10^6 for the sysenv framework, which wants
* temperature in micro-kelvin and percent relative humidity scaled up
* 10^6, but since this conversion uses 64 bits due to intermediate
* values that are bigger than 32 bits the conversion first scales up to
* 10^9 and the scales back down by 10^3 at the end. This preserves some
* precision in the conversion that would otherwise be lost.
*/
static uint64_t
sht3x_compute_temp_from_raw(uint8_t msb, uint8_t lsb) {
uint64_t svalue;
int64_t v1;
uint64_t v2;
uint64_t d1 = 65535;
uint64_t mul1;
uint64_t mul2;
uint64_t div1 = 10000;
uint64_t q;
svalue = msb << 8 | lsb;
v1 = 22815; /* this is scaled up already from 228.15 */
v2 = 175;
mul1 = 10000000000;
mul2 = 100000000;
svalue = svalue * mul1;
v1 = v1 * mul2;
/* Perform the conversion */
q = ((v2 * (svalue / d1)) + v1) / div1;
return q;
}
static uint64_t
sht3x_compute_rh_from_raw(uint8_t msb, uint8_t lsb) {
uint64_t svalue;
int64_t v1;
uint64_t v2;
uint64_t d1 = 65535;
uint64_t mul1;
uint64_t mul2;
uint64_t div1 = 10000;
uint64_t q;
svalue = msb << 8 | lsb;
v1 = 0;
v2 = 100;
mul1 = 10000000000;
mul2 = 10000000000;
svalue = svalue * mul1;
v1 = v1 * mul2;
/* Perform the conversion */
q = ((v2 * (svalue / d1)) + v1) / div1;
return q;
}
static int
sht3x_parse_data(struct sht3x_sc *sc, envsys_data_t *edata, uint8_t *rawdata)
{
uint64_t current_value;
uint8_t *svalptr;
DPRINTF(sc, 2, ("%s: Raw data: %02x%02x %02x - %02x%02x %02x\n",
device_xname(sc->sc_dev), rawdata[0], rawdata[1], rawdata[2],
rawdata[3], rawdata[4], rawdata[5]));
switch (edata->sensor) {
case SHT3X_TEMP_SENSOR:
current_value = sht3x_compute_temp_from_raw(rawdata[0],
rawdata[1]);
svalptr = &rawdata[0];
break;
case SHT3X_HUMIDITY_SENSOR:
current_value = sht3x_compute_rh_from_raw(rawdata[3],
rawdata[4]);
svalptr = &rawdata[3];
break;
default:
DPRINTF(sc, 2, ("%s: bad sensor type %d\n",
device_xname(sc->sc_dev), edata->sensor));
return EINTR;
}
uint8_t testcrc;
/* Fake out the CRC check if being asked to ignore CRC */
if (sc->sc_ignorecrc) {
testcrc = *(svalptr + 2);
} else {
testcrc = sht3x_crc(svalptr, 2);
}
if (*(svalptr + 2) != testcrc) {
DPRINTF(sc, 2, ("%s: Failed to get new status in refresh %d != %d\n",
device_xname(sc->sc_dev), (*svalptr + 2), testcrc));
return EINVAL;
}
edata->value_cur = (uint32_t) current_value;
edata->state = ENVSYS_SVALID;
return 0;
}
static int
sht3x_refresh_periodic(struct sysmon_envsys *sme, envsys_data_t *edata)
{
struct sht3x_sc *sc = sme->sme_cookie;
uint8_t rawdata[sizeof(sc->sc_pbuffer)];
memcpy(rawdata, sc->sc_pbuffer, sizeof(rawdata));
return sht3x_parse_data(sc, edata, rawdata);
}
static int
sht3x_refresh_oneshot(struct sysmon_envsys *sme, envsys_data_t *edata)
{
struct sht3x_sc *sc = sme->sme_cookie;
uint16_t measurement_command_ss;
uint8_t rawdata[sizeof(sc->sc_pbuffer)];
int error;
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));
return error;
}
measurement_command_ss = sht3x_compute_measure_command_ss(
sc->sc_repeatability, sc->sc_clockstretch);
error = sht3x_cmdr(sc, measurement_command_ss, rawdata, sizeof(rawdata));
DPRINTF(sc, 2, ("%s: Status for single-shot measurement cmd %04x "
"Error %d\n", device_xname(sc->sc_dev), measurement_command_ss, error));
if (error == 0) {
error = sht3x_parse_data(sc, edata, rawdata);
}
uint16_t sbuf;
int status_error = sht3x_get_status_register(sc, &sbuf, true);
if (!status_error) {
DPRINTF(sc, 2, ("%s: read status register single-shot: %04x\n",
device_xname(sc->sc_dev), sbuf));
if (sbuf & SHT3X_RESET_DETECTED) {
aprint_error_dev(sc->sc_dev,
"Reset detected in single shot mode. "
"Heater may have been reset\n");
sht3x_clear_status_register(sc, true);
}
sc->sc_heateron = sbuf & SHT3X_HEATER_STATUS;
}
iic_release_bus(sc->sc_tag, 0);
return error;
}
static void
sht3x_refresh(struct sysmon_envsys *sme, envsys_data_t *edata)
{
struct sht3x_sc *sc = sme->sme_cookie;
edata->state = ENVSYS_SINVALID;
mutex_enter(&sc->sc_mutex);
if (sc->sc_isperiodic) {
sht3x_refresh_periodic(sme, edata);
} else {
sht3x_refresh_oneshot(sme, edata);
}
mutex_exit(&sc->sc_mutex);
}
static int
sht3xopen(dev_t dev, int flags, int fmt, struct lwp *l)
{
struct sht3x_sc *sc;
sc = device_lookup_private(&sht3xtemp_cd, minor(dev));
if (!sc)
return ENXIO;
if (sc->sc_opened)
return EBUSY;
mutex_enter(&sc->sc_mutex);
sc->sc_opened = true;
sc->sc_wassingleshot = false;
if (!sc->sc_isperiodic) {
sc->sc_stopping = false;
sc->sc_initperiodic = true;
sc->sc_isperiodic = true;
sc->sc_wassingleshot = true;
sht3x_start_thread(sc);
}
mutex_exit(&sc->sc_mutex);
return 0;
}
static int
sht3xread(dev_t dev, struct uio *uio, int flags)
{
struct sht3x_sc *sc;
struct sht3x_read_q *pp;
int error,any;
sc = device_lookup_private(&sht3xtemp_cd, minor(dev));
if (!sc)
return ENXIO;
while (uio->uio_resid) {
any = 0;
error = 0;
mutex_enter(&sc->sc_read_mutex);
while (any == 0) {
pp = SIMPLEQ_FIRST(&sc->sc_read_queue);
if (pp != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_read_queue, read_q);
any = 1;
break;
}
error = cv_wait_sig(&sc->sc_condreadready,
&sc->sc_read_mutex);
if (sc->sc_dying)
error = EIO;
if (error == 0)
continue;
break;
}
if (any == 1 && error == 0) {
uint8_t *p = pp->measurement;
mutex_exit(&sc->sc_read_mutex);
pool_cache_put(sc->sc_readpool,pp);
DPRINTF(sc,2, ("%s: sending %02x%02x %02x -- %02x%02x "
"%02x -- %x\n", device_xname(sc->sc_dev), p[0],
p[1], p[2], p[3], p[4], p[5],
mutex_owned(&sc->sc_read_mutex)));
if ((error = uiomove(pp->measurement,
sizeof(pp->measurement), uio)) != 0) {
DPRINTF(sc,2, ("%s: send error %d\n",
device_xname(sc->sc_dev), error));
break;
}
} else {
mutex_exit(&sc->sc_read_mutex);
if (error) {
break;
}
}
}
DPRINTF(sc,2, ("%s: loop done: %d\n",device_xname(sc->sc_dev),error));
if (sc->sc_dying) {
DPRINTF(sc, 2, ("%s: Telling all we are almost dead\n",
device_xname(sc->sc_dev)));
mutex_enter(&sc->sc_dying_mutex);
cv_signal(&sc->sc_cond_dying);
mutex_exit(&sc->sc_dying_mutex);
}
return error;
}
static int
sht3xclose(dev_t dev, int flags, int fmt, struct lwp *l)
{
struct sht3x_sc *sc;
struct sht3x_read_q *pp;
sc = device_lookup_private(&sht3xtemp_cd, minor(dev));
if (sc->sc_wassingleshot) {
sht3x_stop_thread(sc);
sc->sc_stopping = false;
sc->sc_initperiodic = false;
sc->sc_isperiodic = false;
}
mutex_enter(&sc->sc_mutex);
/* Drain any read pools */
while ((pp = SIMPLEQ_FIRST(&sc->sc_read_queue)) != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_read_queue, read_q);
pool_cache_put(sc->sc_readpool,pp);
}
/* Say that the device is now free */
sc->sc_opened = false;
mutex_exit(&sc->sc_mutex);
return(0);
}
static int
sht3x_detach(device_t self, int flags)
{
struct sht3x_sc *sc;
struct sht3x_read_q *pp;
sc = device_private(self);
if (sc->sc_isperiodic) {
sht3x_stop_thread(sc);
}
mutex_enter(&sc->sc_mutex);
sc->sc_dying = true;
/* If this is true we are still open, destroy the condvar */
if (sc->sc_opened) {
mutex_enter(&sc->sc_dying_mutex);
mutex_enter(&sc->sc_read_mutex);
cv_signal(&sc->sc_condreadready);
mutex_exit(&sc->sc_read_mutex);
DPRINTF(sc, 2, ("%s: Will wait for anything to exit\n",
device_xname(sc->sc_dev)));
/* In the worst case this will time out after 5 seconds.
* It really should not take that long for the drain / whatever
* to happen
*/
cv_timedwait_sig(&sc->sc_cond_dying,
&sc->sc_dying_mutex, mstohz(5000));
mutex_exit(&sc->sc_dying_mutex);
cv_destroy(&sc->sc_condreadready);
cv_destroy(&sc->sc_cond_dying);
}
/* Drain any read pools */
while ((pp = SIMPLEQ_FIRST(&sc->sc_read_queue)) != NULL) {
SIMPLEQ_REMOVE_HEAD(&sc->sc_read_queue, read_q);
pool_cache_put(sc->sc_readpool,pp);
}
/* Destroy the pool cache now that nothing is using it */
pool_cache_destroy(sc->sc_readpool);
/* Remove the sensors */
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_sht3xlog);
/* Remove the mutex */
mutex_destroy(&sc->sc_mutex);
mutex_destroy(&sc->sc_threadmutex);
mutex_destroy(&sc->sc_read_mutex);
mutex_destroy(&sc->sc_dying_mutex);
/* Free the poolname string */
if (sc->sc_readpoolname != NULL) {
kmem_free(sc->sc_readpoolname,strlen(sc->sc_readpoolname) + 1);
}
return 0;
}
int
sht3x_activate(device_t self, enum devact act)
{
struct sht3x_sc *sc = device_private(self);
switch (act) {
case DVACT_DEACTIVATE:
sc->sc_dying = true;
return 0;
default:
return EOPNOTSUPP;
}
}
MODULE(MODULE_CLASS_DRIVER, sht3xtemp, "iic,sysmon_envsys");
#ifdef _MODULE
#include "ioconf.c"
#endif
static int
sht3xtemp_modcmd(modcmd_t cmd, void *opaque)
{
int error;
#ifdef _MODULE
int bmaj = -1, cmaj = -1;
#endif
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
error = devsw_attach("sht3xtemp", NULL, &bmaj,
&sht3x_cdevsw, &cmaj);
if (error) {
aprint_error("%s: unable to attach devsw\n",
sht3xtemp_cd.cd_name);
return error;
}
error = config_init_component(cfdriver_ioconf_sht3xtemp,
cfattach_ioconf_sht3xtemp, cfdata_ioconf_sht3xtemp);
if (error) {
aprint_error("%s: unable to init component\n",
sht3xtemp_cd.cd_name);
devsw_detach(NULL, &sht3x_cdevsw);
}
return error;
#else
return 0;
#endif
case MODULE_CMD_FINI:
#ifdef _MODULE
error = config_fini_component(cfdriver_ioconf_sht3xtemp,
cfattach_ioconf_sht3xtemp, cfdata_ioconf_sht3xtemp);
devsw_detach(NULL, &sht3x_cdevsw);
return error;
#else
return 0;
#endif
default:
return ENOTTY;
}
}
