/*      $NetBSD: sc16is7xxi2c.c,v 1.3 2025/12/01 14:56:02 brad Exp $    */

/*
 * Copyright (c) 2025 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: sc16is7xxi2c.c,v 1.3 2025/12/01 14:56:02 brad Exp $");

/*
 * I2C frontend driver for the SC16IS7xx UART bridge.
 * The heavy lifting is done by the general sc16is7xx(4)
 * driver and the com(4) backend.
 */

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

#include <dev/i2c/i2cvar.h>
#include <dev/spi/spivar.h>
#include <dev/ic/sc16is7xxreg.h>
#include <dev/ic/sc16is7xxvar.h>

struct sc16is7xx_i2c_softc {
        struct sc16is7xx_sc sc_sc16is7xx;
        i2c_tag_t sc_tag;
        i2c_addr_t sc_addr;
};

#define SC16IS7XX_TO_I2C(sc)    \
        container_of((sc), struct sc16is7xx_i2c_softc, sc_sc16is7xx)

static int sc16is7xxi2c_poke(i2c_tag_t, i2c_addr_t, bool);
static int sc16is7xxi2c_match(device_t, cfdata_t, void *);
static void sc16is7xxi2c_attach(device_t, device_t, void *);
static int sc16is7xxi2c_detach(device_t, int);

CFATTACH_DECL_NEW(sc16is7xxi2c, sizeof(struct sc16is7xx_i2c_softc),
    sc16is7xxi2c_match, sc16is7xxi2c_attach, sc16is7xxi2c_detach, NULL);

static int
sc16is7xxi2c_read_register_direct(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg,
    int channel, uint8_t *buf, size_t blen)
{
        int error;
        uint8_t xreg;

        xreg = (reg << 3) | (channel << 1);

        error = iic_acquire_bus(tag, 0);
        if (error == 0) {
                error = iic_exec(tag, I2C_OP_READ_WITH_STOP, addr, &xreg, 1,
                    buf, blen, 0);
        }
        iic_release_bus(tag, 0);

        return error;
}

static int
sc16is7xxi2c_write_register_direct(i2c_tag_t tag, i2c_addr_t addr, uint8_t reg,
    int channel, uint8_t *buf, size_t blen)
{
        int error;
        uint8_t xreg;

        xreg = (reg << 3) | (channel << 1);

        error = iic_acquire_bus(tag, 0);
        if (error == 0) {
                error = iic_exec(tag, I2C_OP_WRITE_WITH_STOP, addr, &xreg, 1,
                    buf, blen, 0);
        }
        iic_release_bus(tag, 0);

        return error;
}
/* Use these after the hand off to the general driver happens */

static int
sc16is7xxi2c_read_register(struct sc16is7xx_sc *sc, uint8_t reg, int channel,
    uint8_t *buf, size_t blen)
{
        struct sc16is7xx_i2c_softc *isc = SC16IS7XX_TO_I2C(sc);
        int error;

        KASSERT(blen > 0);

        error = sc16is7xxi2c_read_register_direct(isc->sc_tag, isc->sc_addr,
            reg, channel, buf, blen);

        return error;
}

static int
sc16is7xxi2c_write_register(struct sc16is7xx_sc *sc, uint8_t reg, int channel,
    uint8_t *buf, size_t blen)
{
        struct sc16is7xx_i2c_softc *isc = SC16IS7XX_TO_I2C(sc);
        int error;

        KASSERT(blen > 0);

        error = sc16is7xxi2c_write_register_direct(isc->sc_tag, isc->sc_addr,
            reg, channel, buf, blen);

        return error;
}

static void
sc16is7xxi2c_copy_handles(struct sc16is7xx_sc *sc, struct com_regs *regs)
{
        regs->cr_cookie = sc;
}

static const struct sc16is7xx_accessfuncs sc16is7xx_i2c_accessfuncs = {
        .read_reg = sc16is7xxi2c_read_register,
        .write_reg = sc16is7xxi2c_write_register,
        .copy_handles = sc16is7xxi2c_copy_handles,
};
/* These will be used by dev/ic/com.c, conform to what is expected */

static uint8_t
sc16is7xx_i2c_com_read_1(struct com_regs *regs, u_int reg)
{
        struct sc16is7xx_sc *sc = (struct sc16is7xx_sc *)regs->cr_cookie;
        struct sc16is7xx_i2c_softc *isc = SC16IS7XX_TO_I2C(sc);
        uint8_t buf;
        int error;

        if (regs->cr_has_errored)
                return 0;

        error = sc16is7xxi2c_read_register_direct(isc->sc_tag, isc->sc_addr,
            reg, regs->cr_channel, &buf, 1);

        if (!error)
                return buf;

        if (error) {
                device_printf(sc->sc_dev, "sc16is7xx_i2c_com_read_1: error=%d\n",error);
                regs->cr_has_errored = true;
                mutex_enter(&sc->sc_thread_mutex);
                if (sc->sc_thread_state != SC16IS7XX_THREAD_GPIO) {
                        sc->sc_thread_state = SC16IS7XX_THREAD_STALLED;
                        cv_signal(&sc->sc_threadvar);
                }
                mutex_exit(&sc->sc_thread_mutex);
        }

        return 0;
}

static void
sc16is7xx_i2c_com_write_1(struct com_regs *regs, u_int reg, uint8_t val)
{
        struct sc16is7xx_sc *sc = (struct sc16is7xx_sc *)regs->cr_cookie;
        struct sc16is7xx_i2c_softc *isc = SC16IS7XX_TO_I2C(sc);
        int error = 0;

        if (regs->cr_has_errored)
                return;

        error = sc16is7xxi2c_write_register_direct(isc->sc_tag, isc->sc_addr,
            reg, regs->cr_channel, &val, 1);

        if (error) {
                device_printf(sc->sc_dev, "sc16is7xx_i2c_com_write_1: error=%d\n",error);
                regs->cr_has_errored = true;
                mutex_enter(&sc->sc_thread_mutex);
                if (sc->sc_thread_state != SC16IS7XX_THREAD_GPIO) {
                        sc->sc_thread_state = SC16IS7XX_THREAD_STALLED;
                        cv_signal(&sc->sc_threadvar);
                }
                mutex_exit(&sc->sc_thread_mutex);
        }
}

static void
sc16is7xx_i2c_com_write_multi_1(struct com_regs *regs, u_int reg, const uint8_t *datap,
    bus_size_t count)
{
        struct sc16is7xx_sc *sc = (struct sc16is7xx_sc *)regs->cr_cookie;
        struct sc16is7xx_i2c_softc *isc = SC16IS7XX_TO_I2C(sc);
        int error = 0;

        if (regs->cr_has_errored)
                return;

        error = sc16is7xxi2c_write_register_direct(isc->sc_tag, isc->sc_addr,
            reg, regs->cr_channel, __UNCONST(datap), count);

        if (error) {
                device_printf(sc->sc_dev, "sc16is7xx_i2c_com_write_multi_1: error=%d\n",error);
                regs->cr_has_errored = true;
                mutex_enter(&sc->sc_thread_mutex);
                if (sc->sc_thread_state != SC16IS7XX_THREAD_GPIO) {
                        sc->sc_thread_state = SC16IS7XX_THREAD_STALLED;
                        cv_signal(&sc->sc_threadvar);
                }
                mutex_exit(&sc->sc_thread_mutex);
        }
}

static const struct sc16is7xx_accessfuncs sc16is7xx_i2c_com_accessfuncs = {
        .com_read_1 = sc16is7xx_i2c_com_read_1,
        .com_write_1 = sc16is7xx_i2c_com_write_1,
        .com_write_multi_1 = sc16is7xx_i2c_com_write_multi_1,
};

static int
sc16is7xxi2c_poke(i2c_tag_t tag, i2c_addr_t addr, bool matchdebug)
{
        uint8_t reg = SC16IS7XX_REGISTER_SPR;
        uint8_t buf[1];
        int error;

        error = sc16is7xxi2c_read_register_direct(tag, addr, reg, 0, buf, 1);
        if (matchdebug) {
                printf("poke addr=%02x, error=%d\n", addr, error);
        }
        return error;
}

static int
sc16is7xxi2c_match(device_t parent, cfdata_t cf, void *aux)
{
        struct i2c_attach_args *ia = aux;
        int error, match_result;
        const bool matchdebug = false;
        bool indirect_found = false;
        int i;

        if (iic_use_direct_match(ia, cf, sc16is7xx_compat_data, &match_result)) {
                return match_result;
        }
        for (i = SC16IS7XX_LOW_I2C_ADDR; i <= SC16IS7XX_HIGH_I2C_ADDR && indirect_found == false; i++) {
                if (ia->ia_addr == i) {
                        if (matchdebug) {
                                printf("sc16is7xxi2c_match possible indirect: ia_addr=%02x, i=%02x\n", ia->ia_addr, i);
                        }
                        indirect_found = true;
                }
        }

        if (!indirect_found)
                return 0;

        /* Check to see if something is really at this i2c address. This will
         * keep phantom devices from appearing */

        error = sc16is7xxi2c_poke(ia->ia_tag, ia->ia_addr, matchdebug);

        return error == 0 ? I2C_MATCH_ADDRESS_AND_PROBE : 0;
}

static void
sc16is7xxi2c_attach(device_t parent, device_t self, void *aux)
{
        struct sc16is7xx_i2c_softc *isc = device_private(self);
        struct sc16is7xx_sc *sc = &isc->sc_sc16is7xx;
        struct i2c_attach_args *ia = aux;

        sc->sc_dev = self;
        sc->sc_funcs = &sc16is7xx_i2c_accessfuncs;
        sc->sc_com_funcs = &sc16is7xx_i2c_com_accessfuncs;

        isc->sc_tag = ia->ia_tag;
        isc->sc_addr = ia->ia_addr;

        sc16is7xx_attach(sc);
}

static int
sc16is7xxi2c_detach(device_t self, int flags)
{
        struct sc16is7xx_i2c_softc *isc = device_private(self);

        return sc16is7xx_detach(&isc->sc_sc16is7xx, flags);
}