/* $NetBSD: aht20.c,v 1.1 2022/11/17 19:20:06 brad Exp $ */
/*
* Copyright (c) 2022 Brad Spencer <brad@anduin.eldar.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: aht20.c,v 1.1 2022/11/17 19:20:06 brad Exp $");
/*
Driver for the Guangzhou Aosong AHT20 temperature and humidity sensor
*/
#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/aht20reg.h>
#include <dev/i2c/aht20var.h>
static uint8_t aht20_crc(uint8_t *, size_t);
static int aht20_poke(i2c_tag_t, i2c_addr_t, bool);
static int aht20_match(device_t, cfdata_t, void *);
static void aht20_attach(device_t, device_t, void *);
static int aht20_detach(device_t, int);
static void aht20_refresh(struct sysmon_envsys *, envsys_data_t *);
static int aht20_verify_sysctl(SYSCTLFN_ARGS);
#define AHT20_DEBUG
#ifdef AHT20_DEBUG
#define DPRINTF(s, l, x) \
do { \
if (l <= s->sc_aht20debug) \
printf x; \
} while (/*CONSTCOND*/0)
#else
#define DPRINTF(s, l, x)
#endif
CFATTACH_DECL_NEW(aht20temp, sizeof(struct aht20_sc),
aht20_match, aht20_attach, aht20_detach, NULL);
static struct aht20_sensor aht20_sensors[] = {
{
.desc = "humidity",
.type = ENVSYS_SRELHUMIDITY,
},
{
.desc = "temperature",
.type = ENVSYS_STEMP,
}
};
/*
* The delays are mentioned in the datasheet for the chip, except for
* the get status command.
*/
static struct aht20_timing aht20_timings[] = {
{
.cmd = AHT20_INITIALIZE,
.typicaldelay = 10000,
},
{
.cmd = AHT20_TRIGGER_MEASUREMENT,
.typicaldelay = 80000,
},
{
.cmd = AHT20_GET_STATUS,
.typicaldelay = 5000,
},
{
.cmd = AHT20_SOFT_RESET,
.typicaldelay = 20000,
}
};
int
aht20_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;
}
static int
aht20_cmddelay(uint8_t cmd)
{
int r = -1;
for(int i = 0;i < __arraycount(aht20_timings);i++) {
if (cmd == aht20_timings[i].cmd) {
r = aht20_timings[i].typicaldelay;
break;
}
}
if (r == -1) {
panic("Bad command look up in cmd delay: cmd: %d\n",cmd);
}
return r;
}
static int
aht20_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;
error = iic_exec(tag,I2C_OP_WRITE_WITH_STOP,addr,cmd,clen,NULL,0,0);
/* Every command returns something except for the soft reset and
initialize which returns nothing.
*/
if (error == 0) {
cmddelay = aht20_cmddelay(cmd[0]);
delay(cmddelay);
if (cmd[0] != AHT20_SOFT_RESET &&
cmd[0] != AHT20_INITIALIZE) {
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
aht20_cmdr(struct aht20_sc *sc, uint8_t *cmd, uint8_t clen, uint8_t *buf, size_t blen)
{
KASSERT(clen > 0);
return aht20_cmd(sc->sc_tag, sc->sc_addr, cmd, clen, buf, blen, sc->sc_readattempts);
}
static uint8_t
aht20_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
aht20_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
uint8_t reg = AHT20_GET_STATUS;
uint8_t buf[6];
int error;
error = aht20_cmd(tag, addr, ®, 1, buf, 1, 10);
if (matchdebug) {
printf("poke X 1: %d\n", error);
}
return error;
}
static int
aht20_sysctl_init(struct aht20_sc *sc)
{
int error;
const struct sysctlnode *cnode;
int sysctlroot_num;
if ((error = sysctl_createv(&sc->sc_aht20log, 0, NULL, &cnode,
0, CTLTYPE_NODE, device_xname(sc->sc_dev),
SYSCTL_DESCR("aht20 controls"), NULL, 0, NULL, 0, CTL_HW,
CTL_CREATE, CTL_EOL)) != 0)
return error;
sysctlroot_num = cnode->sysctl_num;
#ifdef AHT20_DEBUG
if ((error = sysctl_createv(&sc->sc_aht20log, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
SYSCTL_DESCR("Debug level"), aht20_verify_sysctl, 0,
&sc->sc_aht20debug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
CTL_EOL)) != 0)
return error;
#endif
if ((error = sysctl_createv(&sc->sc_aht20log, 0, NULL, &cnode,
CTLFLAG_READWRITE, CTLTYPE_INT, "readattempts",
SYSCTL_DESCR("The number of times to attempt to read the values"),
aht20_verify_sysctl, 0, &sc->sc_readattempts, 0, CTL_HW,
sysctlroot_num, CTL_CREATE, CTL_EOL)) != 0)
return error;
if ((error = sysctl_createv(&sc->sc_aht20log, 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;
return 0;
}
static int
aht20_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 != AHT20_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 = aht20_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
aht20_attach(device_t parent, device_t self, void *aux)
{
struct aht20_sc *sc;
struct i2c_attach_args *ia;
uint8_t cmd[1];
int error, i;
ia = aux;
sc = device_private(self);
sc->sc_dev = self;
sc->sc_tag = ia->ia_tag;
sc->sc_addr = ia->ia_addr;
sc->sc_aht20debug = 0;
sc->sc_readattempts = 10;
sc->sc_ignorecrc = false;
sc->sc_sme = NULL;
aprint_normal("\n");
mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, IPL_NONE);
sc->sc_numsensors = __arraycount(aht20_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 = aht20_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;
}
cmd[0] = AHT20_SOFT_RESET;
error = aht20_cmdr(sc, cmd, 1, NULL, 0);
if (error != 0)
aprint_error_dev(self, "Reset failed: %d\n", error);
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, aht20_sensors[i].desc,
sizeof(sc->sc_sensors[i].desc));
sc->sc_sensors[i].units = aht20_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 = aht20_refresh;
DPRINTF(sc, 2, ("aht20_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;
}
aprint_normal_dev(self, "Guangzhou Aosong AHT20\n");
return;
out:
sysmon_envsys_destroy(sc->sc_sme);
sc->sc_sme = NULL;
}
static void
aht20_refresh(struct sysmon_envsys * sme, envsys_data_t * edata)
{
struct aht20_sc *sc;
sc = sme->sme_cookie;
int error;
uint8_t cmd[3];
uint8_t rawdata[7];
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;
}
/*
The documented conversion calculations for the raw values are as follows:
%RH = (Srh / 2^20) * 100%
T in Celsius = ((St / 2^20) * 200) - 50
It follows then:
T in Kelvin = ((St / 2^20) * 200) + 223.15
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.
*/
cmd[0] = AHT20_TRIGGER_MEASUREMENT;
cmd[1] = AHT20_TRIGGER_PARAM1;
cmd[2] = AHT20_TRIGGER_PARAM2;
error = aht20_cmdr(sc, cmd, 3, rawdata, 7);
if (error == 0) {
if (rawdata[0] & AHT20_STATUS_BUSY_MASK) {
aprint_error_dev(sc->sc_dev,
"Chip is busy. Status register: %02x\n",
rawdata[0]);
error = EINVAL;
}
if (error == 0 &&
rawdata[0] & AHT20_STATUS_CAL_MASK) {
uint8_t testcrc;
testcrc = aht20_crc(&rawdata[0],6);
DPRINTF(sc, 2, ("%s: Raw data: STATUS: %02x - RH: %02x %02x - %02x - TEMP: %02x %02x - CRC: %02x -- %02x\n",
device_xname(sc->sc_dev), rawdata[0], rawdata[1], rawdata[2],
rawdata[3], rawdata[4], rawdata[5], rawdata[6], testcrc));
/* This chip splits the %rh and temp raw files ove the 3 byte returned. Since
there is no choice but to get both, split them both apart every time */
uint64_t rawhum;
uint64_t rawtemp;
rawhum = (rawdata[1] << 12) | (rawdata[2] << 4) | ((rawdata[3] & 0xf0) >> 4);
rawtemp = ((rawdata[3] & 0x0f) << 16) | (rawdata[4] << 8) | rawdata[5];
DPRINTF(sc, 2, ("%s: Raw broken data: RH: %04jx (%jd) - TEMP: %04jx (%jd)\n",
device_xname(sc->sc_dev), rawhum, rawhum, rawtemp, rawtemp));
/* Fake out the CRC check if being asked to ignore CRC */
if (sc->sc_ignorecrc) {
testcrc = rawdata[6];
}
if (rawdata[6] == testcrc) {
uint64_t q = 0;
switch (edata->sensor) {
case AHT20_TEMP_SENSOR:
q = (((rawtemp * 1000000000) / 10485760) * 2) + 223150000;
break;
case AHT20_HUMIDITY_SENSOR:
q = (rawhum * 1000000000) / 10485760;
break;
default:
error = EINVAL;
break;
}
DPRINTF(sc, 2, ("%s: Computed sensor: %#jx (%jd)\n",
device_xname(sc->sc_dev), (uintmax_t)q, (uintmax_t)q));
/* The results will fit in 32 bits, so nothing will be lost */
edata->value_cur = (uint32_t) q;
edata->state = ENVSYS_SVALID;
} else {
error = EINVAL;
}
} else {
if (error == 0) {
aprint_error_dev(sc->sc_dev,"Calibration needs to be run on the chip.\n");
cmd[0] = AHT20_INITIALIZE;
cmd[1] = AHT20_INITIALIZE_PARAM1;
cmd[2] = AHT20_INITIALIZE_PARAM2;
error = aht20_cmdr(sc, cmd, 3, NULL, 0);
if (error) {
DPRINTF(sc, 2, ("%s: Calibration failed to run: %d\n",
device_xname(sc->sc_dev), error));
}
}
}
}
if (error) {
DPRINTF(sc, 2, ("%s: Failed to get new status in refresh %d\n",
device_xname(sc->sc_dev), error));
}
iic_release_bus(sc->sc_tag, 0);
out:
mutex_exit(&sc->sc_mutex);
}
static int
aht20_detach(device_t self, int flags)
{
struct aht20_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);
sc->sc_sme = NULL;
}
mutex_exit(&sc->sc_mutex);
/* Remove the sysctl tree */
sysctl_teardown(&sc->sc_aht20log);
/* Remove the mutex */
mutex_destroy(&sc->sc_mutex);
return 0;
}
MODULE(MODULE_CLASS_DRIVER, aht20temp, "iic,sysmon_envsys");
#ifdef _MODULE
#include "ioconf.c"
#endif
static int
aht20temp_modcmd(modcmd_t cmd, void *opaque)
{
switch (cmd) {
case MODULE_CMD_INIT:
#ifdef _MODULE
return config_init_component(cfdriver_ioconf_aht20temp,
cfattach_ioconf_aht20temp, cfdata_ioconf_aht20temp);
#else
return 0;
#endif
case MODULE_CMD_FINI:
#ifdef _MODULE
return config_fini_component(cfdriver_ioconf_aht20temp,
cfattach_ioconf_aht20temp, cfdata_ioconf_aht20temp);
#else
return 0;
#endif
default:
return ENOTTY;
}
}