/*      $NetBSD: sc16is7xx_tty.c,v 1.4 2025/12/01 14:56:03 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: sc16is7xx_tty.c,v 1.4 2025/12/01 14:56:03 brad Exp $");

/* TTY specific common driver to the NXP SC16IS7xx UART bridge */

#include <sys/kthread.h>
#include <sys/param.h>
#include <sys/device.h>
#include <sys/tty.h>
#include <sys/systm.h>

#include <sys/bus.h>

#include <dev/ic/sc16is7xxreg.h>
#include <dev/ic/sc16is7xxvar.h>
#include <dev/ic/sc16is7xx_ttyvar.h>

#include <dev/ic/comreg.h>
#include <dev/ic/comvar.h>

static int sc16is7xx_tty_match(device_t, cfdata_t, void *);
static void sc16is7xx_tty_attach(device_t, device_t, void *);
static int sc16is7xx_tty_detach(device_t, int);

CFATTACH_DECL_NEW(sc16is7xx_tty, sizeof(struct sc16is7xx_tty_softc),
    sc16is7xx_tty_match, sc16is7xx_tty_attach, sc16is7xx_tty_detach, NULL);

#define COM_TO_SC16IS7XX(sc)    \
        container_of((sc), struct sc16is7xx_tty_softc, sc_com)

static int
sc16is7xx_tty_enable(struct com_softc *com_sc)
{
        struct sc16is7xx_tty_softc *sc = COM_TO_SC16IS7XX(com_sc);
        struct sc16is7xx_sc *psc = sc->psc;
        int error = 0;
        
        mutex_enter(&psc->sc_thread_mutex);
        
        if (psc->sc_thread_state != SC16IS7XX_THREAD_GPIO &&
            psc->sc_thread_state != SC16IS7XX_THREAD_RUNNING &&
            psc->sc_thread_state != SC16IS7XX_THREAD_EXIT &&
            psc->sc_de_count == 0) {
                if (psc->sc_thread_state == SC16IS7XX_THREAD_STOPPED)
                        error = kthread_create(PRI_SOFTSERIAL, KTHREAD_MUSTJOIN | KTHREAD_MPSAFE, NULL,
                            sc16is7xx_thread, psc, &psc->sc_thread, "%s", device_xname(psc->sc_dev));
                if (error) {
                        aprint_error_dev(psc->sc_dev,
                            "Could not create kernel thread for polling: %d\n",
                            error);
                } else {
                        psc->sc_thread_state = SC16IS7XX_THREAD_RUNNING;
                        cv_signal(&psc->sc_threadvar);
                }
        }

        psc->sc_de_count++;

        KASSERTMSG(psc->sc_de_count >= 0 && psc->sc_de_count <= 2,
            "Disable / Enable count out of bounds: %d\n", psc->sc_de_count);

        com_sc->sc_regs.cr_has_errored = false;

        mutex_exit(&psc->sc_thread_mutex);

        return 0;
}

static void
sc16is7xx_tty_disable(struct com_softc *com_sc)
{
        struct sc16is7xx_tty_softc *sc = COM_TO_SC16IS7XX(com_sc);
        struct sc16is7xx_sc *psc = sc->psc;
        
        mutex_enter(&psc->sc_thread_mutex);
        
        psc->sc_de_count--;

        KASSERTMSG(psc->sc_de_count >= 0 && psc->sc_de_count <= 2,
            "Disable / Enable count out of bounds: %d\n", psc->sc_de_count);

        if (psc->sc_thread_state != SC16IS7XX_THREAD_GPIO &&
            psc->sc_thread_state != SC16IS7XX_THREAD_PAUSED &&
            psc->sc_thread_state != SC16IS7XX_THREAD_EXIT &&
            psc->sc_de_count == 0) {
                psc->sc_thread_state = SC16IS7XX_THREAD_PAUSED;
                cv_signal(&psc->sc_threadvar);
        }

        mutex_exit(&psc->sc_thread_mutex);
        
}

static int
sc16is7xx_tty_match(device_t parent, cfdata_t match, void *aux)
{
        return 1;
}

void
sc16is7xx_tty_attach(device_t parent, device_t self, void *aux)
{
        struct sc16is7xx_tty_attach_args *caa = aux;
        struct sc16is7xx_tty_softc *sc = device_private(self);
        struct sc16is7xx_sc *psc = device_private(parent);

        sc->sc_com.sc_dev = self;
        sc->psc = psc;

        device_setprop_bool(self, "is-console", false);
        device_setprop_bool(self, "force-console", false);

        /* Set and then override the callouts to read and write the registers. */
        com_init_regs(&sc->sc_com.sc_regs, 0, 0, 0);
        sc->sc_com.sc_regs.cr_read = psc->sc_com_funcs->com_read_1;
        sc->sc_com.sc_regs.cr_write = psc->sc_com_funcs->com_write_1;
        sc->sc_com.sc_regs.cr_write_multi = psc->sc_com_funcs->com_write_multi_1;
        sc->sc_com.sc_regs.cr_channel = caa->aa_channel;

        sc->sc_com.enable = &sc16is7xx_tty_enable;
        sc->sc_com.disable = &sc16is7xx_tty_disable;

        psc->sc_funcs->copy_handles(psc, &sc->sc_com.sc_regs);

        /* We will get a 64 byte FIFO and hardware flow control if we use this */
        sc->sc_com.sc_type = COM_TYPE_SC16IS7XX;

        /* The master frequency is pushed down from the bus layer as both
         * channels use the same clock.  However it needs to be set here as
         * com(4) wants it. */
        sc->sc_com.sc_frequency = psc->sc_frequency;

        /* This will always be 0, as the polling will occur at the bus layer,
         * if needed. */
        sc->sc_com.sc_poll_ticks = 0;

        /* Tell com(4) to run in a soft context whenever possible */
        SET(sc->sc_com.sc_hwflags, COM_HW_SOFTIRQ);

        com_attach_subr(&sc->sc_com);

        return;
}

int
sc16is7xx_tty_detach(device_t self, int flags)
{
        int error = 0;

        error = com_detach(self, flags);

        return error;
}