xref: /src/sys/dev/ic/scmd.c

/*	$NetBSD: scmd.c,v 1.3 2022/10/06 19:38:54 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, 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: scmd.c,v 1.3 2022/10/06 19:38:54 andvar Exp $");

/*
 * Common driver for the Sparkfun Serial motor controller.
 * Calls out to specific frontends to move bits.
*/

#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/pool.h>
#include <sys/kmem.h>

#include <dev/i2c/i2cvar.h>
#include <dev/spi/spivar.h>
#include <dev/ic/scmdreg.h>
#include <dev/ic/scmdvar.h>

void		scmd_attach(struct scmd_sc *);
static void	scmd_wait_restart(struct scmd_sc *, bool);
static int	scmd_get_topaddr(struct scmd_sc *);
static int 	scmd_verify_sysctl(SYSCTLFN_ARGS);
static int	scmd_local_read(struct scmd_sc *, uint8_t, uint8_t *);
static int	scmd_remote_read(struct scmd_sc *, int, uint8_t *);
static int	scmd_local_write(struct scmd_sc *, uint8_t, uint8_t);
static int	scmd_remote_write(struct scmd_sc *, int, uint8_t);

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

extern struct cfdriver scmd_cd;

static dev_type_open(scmd_open);
static dev_type_read(scmd_read);
static dev_type_write(scmd_write);
static dev_type_close(scmd_close);
const struct cdevsw scmd_cdevsw = {
	.d_open = scmd_open,
	.d_close = scmd_close,
	.d_read = scmd_read,
	.d_write = scmd_write,
	.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 int
scmd_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
scmd_sysctl_init(struct scmd_sc *sc)
{
	int error;
	const struct sysctlnode *cnode;
	int sysctlroot_num;

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

	sysctlroot_num = cnode->sysctl_num;

#ifdef SCMD_DEBUG
	if ((error = sysctl_createv(&sc->sc_scmdlog, 0, NULL, &cnode,
	    CTLFLAG_READWRITE, CTLTYPE_INT, "debug",
	    SYSCTL_DESCR("Debug level"), scmd_verify_sysctl, 0,
	    &sc->sc_scmddebug, 0, CTL_HW, sysctlroot_num, CTL_CREATE,
	    CTL_EOL)) != 0)
		return error;

#endif

	return 0;
}

/* Restarts and re-enumeration of the device is a little strange.
 * It will take a very long time to complete.  It would be more polite
 * to use a condvar for this wait, but it was noticed that those may
 * not work if done too early in boot and will just hang the boot, so
 * delay is also offered as an option.
 */
static void
scmd_wait_restart(struct scmd_sc *sc, bool usedelay)
{
	int error;
	uint8_t buf = SCMD_HOLE_VALUE;
	int c = 0;

	do {
		if (usedelay) {
			delay(1000000);
		} else {
			mutex_enter(&sc->sc_condmutex);
			cv_timedwait(&sc->sc_condvar, &sc->sc_condmutex,
			    mstohz(1000));
			mutex_exit(&sc->sc_condmutex);
		}

		error = (*(sc->sc_func_read_register))(sc, SCMD_REG_STATUS_1, &buf);

		DPRINTF(sc, 2, ("%s: Read back status after restart: %02x %d\n",
		    device_xname(sc->sc_dev), buf, error));

		c++;
	} while (c <= 20 && buf != 0x00);
}

static int
scmd_get_topaddr(struct scmd_sc *sc)
{
	uint8_t topaddr;
	int error;

	error = (*(sc->sc_func_read_register))(sc, SCMD_REG_SLV_TOP_ADDR, &topaddr);

	if (error) {
		topaddr = 0;
	}
	return topaddr;
}

/* Note that this assumes that you can actually access the device.
 * In at least one case right now, SPI on a Raspberry PI 3, the pins
 * have not been set up to allow SPI to function, but nothing is
 * returned as an error either.  We do the best that can be done right
 * now.
 */
void
scmd_attach(struct scmd_sc *sc)
{
	int error;

	aprint_normal("\n");

	if ((error = scmd_sysctl_init(sc)) != 0) {
		aprint_error_dev(sc->sc_dev, "Can't setup sysctl tree (%d)\n", error);
		goto out;
	}

	error = (*(sc->sc_func_acquire_bus))(sc);
	if (error) {
		aprint_error_dev(sc->sc_dev, "Could not acquire iic bus: %d\n",
		    error);
		goto out;
	}

	error = (*(sc->sc_func_write_register))(sc, SCMD_REG_CONTROL_1, SCMD_CONTROL_1_RESTART);
	if (error != 0)
		aprint_error_dev(sc->sc_dev, "Reset failed: %d\n", error);

	scmd_wait_restart(sc, true);

	sc->sc_topaddr = scmd_get_topaddr(sc);

	DPRINTF(sc, 2, ("%s: Top remote module address: %02x\n",
	    device_xname(sc->sc_dev), sc->sc_topaddr));

	uint8_t fwversion;
	uint8_t id;
	uint8_t pins;

	error = (*(sc->sc_func_read_register))(sc, SCMD_REG_FID, &fwversion);
	if (error) {
		aprint_error_dev(sc->sc_dev, "Read of FID failed: %d\n",
		    error);
		goto out;
	}

	error = (*(sc->sc_func_read_register))(sc, SCMD_REG_ID, &id);
	if (error) {
		aprint_error_dev(sc->sc_dev, "Read of ID failed: %d\n",
		    error);
		goto out;
	}

	error = (*(sc->sc_func_read_register))(sc, SCMD_REG_CONFIG_BITS, &pins);
	if (error) {
		aprint_error_dev(sc->sc_dev, "Read of CONFIG_BITS failed: %d\n",
		    error);
		goto out;
	}

	aprint_normal_dev(sc->sc_dev, "Sparkfun Serial motor controller, "
	    "Firmware version: %02x, ID: %02x%s, Jumper pins: %02x\n",
	    fwversion, id, (id == SCMD_EXPECTED_ID) ? " (expected ID)" : " (unexpected ID)",
	    pins);

 out:
	(*(sc->sc_func_release_bus))(sc);
	if (error != 0) {
		aprint_error_dev(sc->sc_dev, "Unable to setup device\n");
	}

	return;
}

/* This device has the effect of creating a virtual register space of all
 * of the attached modules.  All you have to do is read and write to anything
 * in that space and you can hit the main module and all chained slave modules
 * without having to worry about the view port set up.
 *
 * 0x00 - 0x7E -- the first and main module
 * 0x7F - 0xFD -- the first slaved module
 * ...etc...
 *
 */
static int
scmd_open(dev_t dev, int flags, int fmt, struct lwp *l)
{
	struct scmd_sc *sc;

	sc = device_lookup_private(&scmd_cd, minor(dev));
	if (!sc)
		return ENXIO;

	if (sc->sc_opened)
		return EBUSY;

	/* This is a meaningless assignment to keep GCC from
	 * complaining.
	 */
	sc->sc_func_attach = &scmd_attach;

	mutex_enter(&sc->sc_mutex);
	sc->sc_opened = true;
	mutex_exit(&sc->sc_mutex);

	return 0;
}

static int
scmd_maxregister(int topaddr)
{
	if (topaddr >= SCMD_REMOTE_ADDR_LOW &&
	    topaddr <= SCMD_REMOTE_ADDR_HIGH) {
		int i = (topaddr - SCMD_REMOTE_ADDR_LOW) + 2;
		return (SCMD_REG_SIZE * i) - 1;
	} else {
		return SCMD_LAST_REG;
	}
}

/* Please note that that setting up and using the view port
 * to get access to SCMD devices that are chained off of the main
 * device is not atomic.  Hopefully this all happens fast enough
 * so that nothing can sneak in and mess with the registers.
 */
static int
scmd_set_view_port(struct scmd_sc *sc, int reg)
{
	int err;
	int loc = reg / SCMD_REG_SIZE;
	uint8_t vpi2creg = reg % SCMD_REG_SIZE;
	uint8_t vpi2caddr = (SCMD_REMOTE_ADDR_LOW + loc) - 1;

	DPRINTF(sc, 2, ("%s: View port addr: %02x ; View port register: %02x ; Orig register: %04x\n",
	    device_xname(sc->sc_dev), vpi2caddr, vpi2creg, reg));

	err = (*(sc->sc_func_write_register))(sc, SCMD_REG_REM_ADDR, vpi2caddr);
	if (! err)
		err = (*(sc->sc_func_write_register))(sc, SCMD_REG_REM_OFFSET, vpi2creg);

	return err;
}

/* It is not defined what happens if the Not Defined in the datasheet
 * registers are accessed, so block them.
 */
static int
scmd_local_read(struct scmd_sc *sc, uint8_t reg, uint8_t *buf)
{
	if (SCMD_IS_HOLE(reg)) {
		*buf = SCMD_HOLE_VALUE;
		return 0;
	}

	return (*(sc->sc_func_read_register))(sc, reg, buf);
}

static int
scmd_remote_read(struct scmd_sc *sc, int reg, uint8_t *buf)
{
	int err;
	int c;
	uint8_t b;

	if (SCMD_IS_HOLE(reg % SCMD_REG_SIZE)) {
		*buf = SCMD_HOLE_VALUE;
		return 0;
	}

	err = scmd_set_view_port(sc, reg);
	if (! err) {
		b = 0xff; /* you can write anything here.. it doesn't matter */
		err = (*(sc->sc_func_write_register))(sc, SCMD_REG_REM_READ, b);
		if (! err) {
			/* So ...  there is no way to really know that the data is ready and
			 * there is no way to know if there was an error in the master module reading
			 * the data from the slave module.  The data sheet says wait 5ms.. so do that
			 * and see if the register cleared, but don't wait forever...  I can't see how
			 * it would not be possible to read junk at times.
			 */
			c = 0;
			do {
				delay(5000);
				err = (*(sc->sc_func_read_register))(sc, SCMD_REG_REM_READ, &b);
				c++;
			} while ((c < 10) && (b != 0x00) && (!err));
			/* We can only hope that whatever was read from the slave module is there */
			if (! err)
				err = (*(sc->sc_func_read_register))(sc, SCMD_REG_REM_DATA_RD, buf);
		}
	}

	return err;
}

static int
scmd_read(dev_t dev, struct uio *uio, int flags)
{
	struct scmd_sc *sc;
	int error;

	if ((sc = device_lookup_private(&scmd_cd, minor(dev))) == NULL)
		return ENXIO;

	/* We do not make this an error.  There is nothing wrong with running
	 * off the end here, just return EOF.
	 */
	if (uio->uio_offset > scmd_maxregister(sc->sc_topaddr))
		return 0;

	if ((error = (*(sc->sc_func_acquire_bus))(sc)) != 0)
		return error;

	while (uio->uio_resid &&
	    uio->uio_offset <= scmd_maxregister(sc->sc_topaddr) &&
	    !sc->sc_dying) {
		uint8_t buf;
		int reg_addr = uio->uio_offset;

		if (reg_addr <= SCMD_LAST_REG) {
			if ((error = scmd_local_read(sc, (uint8_t)reg_addr, &buf)) != 0) {
				(*(sc->sc_func_release_bus))(sc);
				aprint_error_dev(sc->sc_dev,
				    "%s: local read failed at 0x%02x: %d\n",
				    __func__, reg_addr, error);
				return error;
			}
		} else {
			if ((error = scmd_remote_read(sc, reg_addr, &buf)) != 0) {
				(*(sc->sc_func_release_bus))(sc);
				aprint_error_dev(sc->sc_dev,
				    "%s: remote read failed at 0x%02x: %d\n",
				    __func__, reg_addr, error);
				return error;
			}
		}

		if (sc->sc_dying)
			break;

		if ((error = uiomove(&buf, 1, uio)) != 0) {
			(*(sc->sc_func_release_bus))(sc);
			return error;
		}
	}

	(*(sc->sc_func_release_bus))(sc);

	if (sc->sc_dying) {
		return EIO;
	}

	return 0;
}

/* Same thing about the undefined registers.  Don't actually allow
 * writes as it is not clear what happens when you do that.
 */
static int
scmd_local_write(struct scmd_sc *sc, uint8_t reg, uint8_t buf)
{
	if (SCMD_IS_HOLE(reg))
		return 0;

	return (*(sc->sc_func_write_register))(sc, reg, buf);
}

static int
scmd_remote_write(struct scmd_sc *sc, int reg, uint8_t buf)
{
	int err;
	int c;
	uint8_t b;

	if (SCMD_IS_HOLE(reg % SCMD_REG_SIZE)) {
		return 0;
	}

	err = scmd_set_view_port(sc, reg);
	if (! err) {
		/* We just sort of send this write off and wait to see if the register
		 * clears.  There really isn't any indication that the data made it to the
		 * slave modules and there really are not any errors reported.
		 */
		err = (*(sc->sc_func_write_register))(sc, SCMD_REG_REM_DATA_WR, buf);
		if (! err) {
			b = 0xff; /* you can write anything here.. it doesn't matter */
			err = (*(sc->sc_func_write_register))(sc, SCMD_REG_REM_WRITE, b);
			if (! err) {
				c = 0;
				do {
					delay(5000);
					err = (*(sc->sc_func_read_register))(sc, SCMD_REG_REM_WRITE, &b);
					c++;
				} while ((c < 10) && (b != 0x00) && (!err));
			}
		}
	}

	return err;
}

static int
scmd_write(dev_t dev, struct uio *uio, int flags)
{
	struct scmd_sc *sc;
	int error;

	if ((sc = device_lookup_private(&scmd_cd, minor(dev))) == NULL)
		return ENXIO;

	/* Same thing as read, this is not considered an error */
	if (uio->uio_offset > scmd_maxregister(sc->sc_topaddr))
		return 0;

	if ((error = (*(sc->sc_func_acquire_bus))(sc)) != 0)
		return error;

	while (uio->uio_resid &&
	    uio->uio_offset <= scmd_maxregister(sc->sc_topaddr) &&
	    !sc->sc_dying) {
		uint8_t buf;
		int reg_addr = uio->uio_offset;

		if ((error = uiomove(&buf, 1, uio)) != 0)
			break;

		if (sc->sc_dying)
			break;

		if (reg_addr <= SCMD_LAST_REG) {
			if ((error = scmd_local_write(sc, (uint8_t)reg_addr, buf)) != 0) {
				(*(sc->sc_func_release_bus))(sc);
				aprint_error_dev(sc->sc_dev,
				    "%s: local write failed at 0x%02x: %d\n",
				    __func__, reg_addr, error);
				return error;
			}

			/* If this was a local command to the control register that
			 * can perform re-enumeration, then do the wait thing.
			 * It is not as important that this be done for remote module
			 * access as the only thing that you could really do there is
			 * a restart and not re-enumeration, which is really what the wait
			 * is all about.
			 */
			if (reg_addr == SCMD_REG_CONTROL_1) {
				scmd_wait_restart(sc, false);

				sc->sc_topaddr = scmd_get_topaddr(sc);
				aprint_normal_dev(sc->sc_dev, "Highest I2C address on expansion bus is: %02x\n",
				    sc->sc_topaddr);
			}
		} else {
			if ((error = scmd_remote_write(sc, reg_addr, buf)) != 0) {
				(*(sc->sc_func_release_bus))(sc);
				aprint_error_dev(sc->sc_dev,
				    "%s: remote write failed at 0x%02x: %d\n",
				    __func__, reg_addr, error);
				return error;
			}
		}
	}

	(*(sc->sc_func_release_bus))(sc);

	if (sc->sc_dying) {
		return EIO;
	}

	return error;
}

static int
scmd_close(dev_t dev, int flags, int fmt, struct lwp *l)
{
	struct scmd_sc *sc;

	sc = device_lookup_private(&scmd_cd, minor(dev));

	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 EIO;
	}

	mutex_enter(&sc->sc_mutex);
	sc->sc_opened = false;
	mutex_exit(&sc->sc_mutex);

	return(0);
}

MODULE(MODULE_CLASS_DRIVER, scmd, NULL);

#ifdef _MODULE
CFDRIVER_DECL(scmd, DV_DULL, NULL);
#include "ioconf.c"
#endif

static int
scmd_modcmd(modcmd_t cmd, void *opaque)
{
#ifdef _MODULE
	int error = 0;
	int bmaj = -1, cmaj = -1;
#endif

	switch (cmd) {
	case MODULE_CMD_INIT:
#ifdef _MODULE
		error = devsw_attach("scmd", NULL, &bmaj,
		    &scmd_cdevsw, &cmaj);
		if (error) {
			aprint_error("%s: unable to attach devsw: %d\n",
			    scmd_cd.cd_name, error);
			return error;
		}

		error = config_init_component(cfdriver_ioconf_scmd,
		    cfattach_ioconf_scmd, cfdata_ioconf_scmd);
		if (error) {
			aprint_error("%s: unable to init component: %d\n",
			    scmd_cd.cd_name, error);
			devsw_detach(NULL, &scmd_cdevsw);
		}
		return error;
#else
		return 0;
#endif
	case MODULE_CMD_FINI:
#ifdef _MODULE
		error = config_fini_component(cfdriver_ioconf_scmd,
		    cfattach_ioconf_scmd, cfdata_ioconf_scmd);
		devsw_detach(NULL, &scmd_cdevsw);

		return error;
#else
		return 0;
#endif
	default:
		return ENOTTY;
	}
}