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

/*	$NetBSD: aht20.c,v 1.1 2022/11/17 19:20:06 brad Exp $	*/

/*
 * Copyright (c) 2022 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, 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, &reg, 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;
	}
}