/*      $NetBSD: gftty.c,v 1.5 2025/12/11 07:25:11 andvar Exp $ */

/*-     
 * Copyright (c) 2023, 2024 The NetBSD Foundation, Inc.
 * All rights reserved.
 *              
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe.
 *      
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met: 
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *              
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */     

/*
 * Support for the Goldfish virtual TTY.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: gftty.c,v 1.5 2025/12/11 07:25:11 andvar Exp $");

#include <sys/param.h>
#include <sys/conf.h>
#include <sys/fcntl.h>
#include <sys/systm.h>
#include <sys/bus.h>
#include <sys/device.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/tty.h>

#include <uvm/uvm_extern.h>

#include <dev/cons.h>

#include <dev/goldfish/gfttyvar.h>

#include "ioconf.h"

/*
 * Goldfish TTY registers.
 */
#define GFTTY_PUT_CHAR          0x00    /* 8 bit output value */
#define GFTTY_BYTES_READY       0x04    /* number of input bytes available */
#define GFTTY_CMD               0x08    /* command */
#define GFTTY_DATA_PTR          0x10    /* DMA pointer */
#define GFTTY_DATA_LEN          0x14    /* DMA length */
#define GFTTY_DATA_PTR_HIGH     0x18    /* DMA pointer (64-bit) */
#define GFTTY_VERSION           0x20    /* TTY version */

#define CMD_INT_DISABLE         0x00
#define CMD_INT_ENABLE          0x01
#define CMD_WRITE_BUFFER        0x02
#define CMD_READ_BUFFER         0x03

#define REG_READ0(c, r)         \
        bus_space_read_4((c)->c_bst, (c)->c_bsh, (r))
#define REG_WRITE0(c, r, v)     \
        bus_space_write_4((c)->c_bst, (c)->c_bsh, (r), (v))

#define REG_READ(sc, r)         REG_READ0((sc)->sc_config, (r))
#define REG_WRITE(sc, r, v)     REG_WRITE0((sc)->sc_config, (r), (v))

static int      gftty_cngetc(dev_t);
static void     gftty_cnputc(dev_t, int);
static void     gftty_cnpollc(dev_t, int);

static struct gftty_config gftty_cnconfig;
static struct cnm_state gftty_cnmagic_state;
static struct consdev gftty_consdev = {
        .cn_getc  = gftty_cngetc,
        .cn_putc  = gftty_cnputc,
        .cn_pollc = gftty_cnpollc,
        .cn_dev   = NODEV,
        .cn_pri   = CN_NORMAL,
};

static dev_type_open(gftty_open);
static dev_type_close(gftty_close);
static dev_type_read(gftty_read);
static dev_type_write(gftty_write);
static dev_type_ioctl(gftty_ioctl);
static dev_type_stop(gftty_stop);
static dev_type_tty(gftty_tty);
static dev_type_poll(gftty_poll);

const struct cdevsw gftty_cdevsw = {
        .d_open     = gftty_open,
        .d_close    = gftty_close,
        .d_read     = gftty_read,
        .d_write    = gftty_write,
        .d_ioctl    = gftty_ioctl,
        .d_stop     = gftty_stop,
        .d_tty      = gftty_tty,
        .d_poll     = gftty_poll,
        .d_mmap     = nommap,
        .d_kqfilter = ttykqfilter,
        .d_discard  = nodiscard,
        .d_flag     = D_TTY,
};

static void     gftty_start(struct tty *);
static int      gftty_param_locked(struct tty *, struct termios *);
static int      gftty_param(struct tty *, struct termios *);

static void     gftty_softrx(void *);

#define GFTTY_UNIT(x)           minor(x)
#define GFTTY_DMASIZE           (64 * 1024)     /* XXX TTY_MAXQSIZE */
#define GFTTY_MAXSEGS           ((GFTTY_DMASIZE / PAGE_SIZE) + 1)
#define GFTTY_RXBUFSIZE         128
#define GFTTY_RXBUFALLOC        (128 << 1)

static void
gftty_reset_rxptrs(struct gftty_softc *sc)
{
        sc->sc_rxpos = 0;
        sc->sc_rxcur = 0;
        sc->sc_rxbuf = sc->sc_rxbufs[sc->sc_rxcur];
        sc->sc_rxaddr = sc->sc_rxaddrs[sc->sc_rxcur];
}

/*
 * gftty_attach --
 *      Attach a Goldfish virtual TTY.
 */
void
gftty_attach(struct gftty_softc *sc)
{
        device_t self = sc->sc_dev;
        int error;
        bool is_console;

        aprint_naive("\n");
        aprint_normal(": Google Goldfish TTY\n");

        /* If we got here without a config, we're the console. */
        if ((is_console = (sc->sc_config == NULL))) {
                KASSERT(gftty_is_console(sc));
                sc->sc_config = &gftty_cnconfig;
                aprint_normal_dev(sc->sc_dev, "console\n");
        }

        if (sc->sc_config->c_version == 0) {
                aprint_normal_dev(self,
                    "WARNING: version 0 device -- uncharted territory!\n");
        }

        /* Register our Rx soft interrupt. */
        sc->sc_rx_si = softint_establish(SOFTINT_SERIAL, gftty_softrx, sc);
        if (sc->sc_rx_si == NULL) {
                aprint_error_dev(self,
                    "Unable to register software interrupt.\n");
                return;
        }

        error = bus_dmamap_create(sc->sc_dmat, GFTTY_DMASIZE,
            GFTTY_MAXSEGS, GFTTY_DMASIZE, 0, BUS_DMA_WAITOK,
            &sc->sc_tx_dma);
        if (error != 0) {
                aprint_error_dev(self,
                    "unable to create Tx DMA map, error %d.\n", error);
                return;
        }
        error = bus_dmamap_create(sc->sc_dmat, GFTTY_RXBUFALLOC,
            1, GFTTY_RXBUFALLOC, 0, BUS_DMA_WAITOK,
            &sc->sc_rx_dma);
        if (error != 0) {
                aprint_error_dev(self,
                    "unable to create Rx DMA map, error %d.\n", error);
                bus_dmamap_destroy(sc->sc_dmat, sc->sc_tx_dma);
                sc->sc_tx_dma = NULL;
                return;
        }

        sc->sc_rxbuf = kmem_zalloc(GFTTY_RXBUFALLOC, KM_SLEEP);
        error = bus_dmamap_load(sc->sc_dmat, sc->sc_rx_dma,
            sc->sc_rxbuf, GFTTY_RXBUFALLOC, NULL, BUS_DMA_WAITOK);
        if (error != 0) {
                aprint_error_dev(self,
                    "unable to load Rx DMA map, error %d.\n", error);
                kmem_free(sc->sc_rxbuf, GFTTY_RXBUFALLOC);
                bus_dmamap_destroy(sc->sc_dmat, sc->sc_rx_dma);
                sc->sc_rx_dma = NULL;
                bus_dmamap_destroy(sc->sc_dmat, sc->sc_tx_dma);
                sc->sc_tx_dma = NULL;
                return;
        }
        sc->sc_rxbufs[0] = sc->sc_rxbuf;
        sc->sc_rxbufs[1] = sc->sc_rxbufs[0] + GFTTY_RXBUFSIZE;
        if (sc->sc_config->c_version == 0) {
                sc->sc_rxaddrs[0] = (bus_addr_t)sc->sc_rxbufs[0];
        } else {
                sc->sc_rxaddrs[0] = sc->sc_rx_dma->dm_segs[0].ds_addr;
        }
        sc->sc_rxaddrs[1] = sc->sc_rxaddrs[0] + GFTTY_RXBUFSIZE;
        gftty_reset_rxptrs(sc);

        struct tty *tp = tty_alloc();
        tp->t_oproc = gftty_start;
        tp->t_param = gftty_param;
        tp->t_softc = sc;

        mutex_init(&sc->sc_hwlock, MUTEX_DEFAULT, IPL_TTY);

        if (is_console) {
                /* Locate the major number. */
                int maj = cdevsw_lookup_major(&gftty_cdevsw);
                tp->t_dev = cn_tab->cn_dev = makedev(maj, device_unit(self));
        }

        mutex_spin_enter(&tty_lock);
        sc->sc_tty = tp;
        mutex_spin_exit(&tty_lock);

        tty_attach(tp);
}

/*
 * gftty_is_console --
 *      Returns true if the specified gftty instance is currently
 *      the console.
 */
bool
gftty_is_console(struct gftty_softc *sc)
{
        if (cn_tab == &gftty_consdev) {
                return device_getprop_bool(sc->sc_dev, "is-console");
        }
        return false;
}

/*
 * gftty_init_config --
 *      Initialize a config structure.
 */
static void
gftty_init_config(struct gftty_config *c, bus_space_tag_t bst,
    bus_space_handle_t bsh)
{
        c->c_bst = bst;
        c->c_bsh = bsh;
        c->c_version = REG_READ0(c, GFTTY_VERSION);
}

/*
 * gftty_alloc_config --
 *      Allocate a config structure, initialize it, and assign
 *      it to this device.
 */
void
gftty_alloc_config(struct gftty_softc *sc, bus_space_tag_t bst,
    bus_space_handle_t bsh)
{
        struct gftty_config *c = kmem_zalloc(sizeof(*c), KM_SLEEP);

        gftty_init_config(c, bst, bsh);
        sc->sc_config = c;
}

/*
 * gftty_set_buffer --
 *      Set the buffer address / length for an I/O operation.
 */
static void
gftty_set_buffer(struct gftty_config *c, bus_addr_t addr, bus_size_t size)
{
        REG_WRITE0(c, GFTTY_DATA_PTR, BUS_ADDR_LO32(addr));
        if (sizeof(bus_addr_t) == 8) {
                REG_WRITE0(c, GFTTY_DATA_PTR_HIGH, BUS_ADDR_HI32(addr));
        }
        REG_WRITE0(c, GFTTY_DATA_LEN, (uint32_t)size);
}

/*
 * gftty_flush --
 *      Flush input bytes.
 */
static bool
gftty_flush(struct gftty_softc *sc)
{
        uint32_t count;
        bool claimed = false;

        KASSERT(ttylocked(sc->sc_tty));

        mutex_spin_enter(&sc->sc_hwlock);

        while ((count = REG_READ(sc, GFTTY_BYTES_READY)) != 0) {
                claimed = true;
                if (count > GFTTY_RXBUFALLOC) {
                        count = GFTTY_RXBUFALLOC;
                }
                gftty_set_buffer(sc->sc_config,
                    sc->sc_rx_dma->dm_segs[0].ds_addr, count);
                REG_WRITE(sc, GFTTY_CMD, CMD_READ_BUFFER);
        }

        mutex_spin_exit(&sc->sc_hwlock);

        gftty_reset_rxptrs(sc);

        return claimed;
}

/*
 * gftty_rx --
 *      Receive from the virtual TTY.
 */
static bool
gftty_rx(struct gftty_softc *sc)
{
        uint32_t count, avail;
        bool claimed = false;

        KASSERT(ttylocked(sc->sc_tty));

        mutex_spin_enter(&sc->sc_hwlock);

        count = REG_READ(sc, GFTTY_BYTES_READY);
        if (count != 0) {
                claimed = true;
                avail = GFTTY_RXBUFSIZE - sc->sc_rxpos;
                if (count > avail) {
                        /*
                         * Receive what we can, but disable the interrupt
                         * until the buffer can be drained.
                         */
                        REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
                        count = avail;
                }
                if (count != 0) {
                        bus_addr_t syncoff =
                            (sc->sc_rxaddr - sc->sc_rxaddrs[0]) + sc->sc_rxpos;

                        bus_dmamap_sync(sc->sc_dmat, sc->sc_rx_dma,
                            syncoff, count, BUS_DMASYNC_PREREAD);
                        gftty_set_buffer(sc->sc_config,
                            sc->sc_rxaddr + sc->sc_rxpos, count);
                        REG_WRITE(sc, GFTTY_CMD, CMD_READ_BUFFER);
                        sc->sc_rxpos += count;
                        bus_dmamap_sync(sc->sc_dmat, sc->sc_rx_dma,
                            syncoff, count, BUS_DMASYNC_POSTREAD);
                }
                softint_schedule(sc->sc_rx_si);
        }

        mutex_spin_exit(&sc->sc_hwlock);

        return claimed;
}

/*
 * gftty_softrx --
 *      Software interrupt to complete Rx processing.
 */
static void
gftty_softrx(void *v)
{
        struct gftty_softc *sc = v;
        struct tty *tp = sc->sc_tty;
        int i, len;
        char *cp;

        ttylock(tp);
        cp = sc->sc_rxbuf;
        len = sc->sc_rxpos;
        sc->sc_rxcur ^= 1;
        sc->sc_rxbuf = sc->sc_rxbufs[sc->sc_rxcur];
        sc->sc_rxaddr = sc->sc_rxaddrs[sc->sc_rxcur];
        sc->sc_rxpos = 0;
        if (ISSET(tp->t_state, TS_ISOPEN)) {
                REG_WRITE(sc, GFTTY_CMD, CMD_INT_ENABLE);
        }
        ttyunlock(tp);

        for (i = 0; i < len; i++) {
                (*tp->t_linesw->l_rint)(*cp++, tp);
        }
}

/*
 * gftty_intr --
 *      Interrupt service routine.
 */
int
gftty_intr(void *v)
{
        struct gftty_softc *sc = v;
        struct tty *tp = sc->sc_tty;
        bool claimed;

        ttylock(tp);
        if (ISSET(tp->t_state, TS_ISOPEN)) {
                claimed = gftty_rx(sc);
        } else {
                claimed = gftty_flush(sc);
        }
        ttyunlock(tp);

        return claimed;
}

/*
 * gftty_open --
 *      cdevsw open routine.
 */
static int
gftty_open(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
        struct tty *tp;

        if (sc == NULL) {
                return ENXIO;
        }

        mutex_spin_enter(&tty_lock);
        tp = sc->sc_tty;
        mutex_spin_exit(&tty_lock);
        if (tp == NULL) {
                return ENXIO;
        }

        if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)) {
                return EBUSY;
        }

        ttylock(tp);

        if (ISSET(tp->t_state, TS_KERN_ONLY)) {
                ttyunlock(tp);
                return EBUSY;
        }

        tp->t_oproc = gftty_start;
        tp->t_param = gftty_param;
        tp->t_dev = dev;

        if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
                struct termios t;

                ttychars(tp);
                tp->t_iflag = TTYDEF_IFLAG;
                tp->t_oflag = TTYDEF_OFLAG;
                tp->t_lflag = TTYDEF_LFLAG;
                t.c_cflag = TTYDEF_CFLAG;
                t.c_ispeed = t.c_ospeed = TTYDEF_SPEED;
                (void) gftty_param_locked(tp, &t);
                ttsetwater(tp);

                gftty_flush(sc);
                REG_WRITE(sc, GFTTY_CMD, CMD_INT_ENABLE);
        }
        SET(tp->t_state, TS_CARR_ON);

        ttyunlock(tp);

        int error = ttyopen(tp, 0, ISSET(flag, O_NONBLOCK));
        if (error == 0) {
                error = (*tp->t_linesw->l_open)(dev, tp);
                if (error != 0) {
                        ttyclose(tp);
                }
        }

        if (error != 0 &&
            !ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
                REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
        }

        return error;
}

/*
 * gftty_close --
 *      cdevsw close routine.
 */
static int
gftty_close(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));

        KASSERT(sc != NULL);

        struct tty *tp = sc->sc_tty;

        ttylock(tp);

        /* XXX This is for cons.c. */
        if (!ISSET(tp->t_state, TS_ISOPEN)) {
                ttyunlock(tp);
                return 0;
        }

        if (ISSET(tp->t_state, TS_KERN_ONLY)) {
                ttyunlock(tp);
                return 0;
        }

        ttyunlock(tp);

        (*tp->t_linesw->l_close)(tp, flag);
        ttyclose(tp);

        ttylock(tp);
        if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
                REG_WRITE(sc, GFTTY_CMD, CMD_INT_DISABLE);
        }
        ttyunlock(tp);

        return 0;
}

/*
 * gftty_read --
 *      cdevsw read routine.
 */
static int
gftty_read(dev_t dev, struct uio *uio, int flag)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));

        KASSERT(sc != NULL);

        struct tty *tp = sc->sc_tty;
        return (*tp->t_linesw->l_read)(tp, uio, flag);
}

/*
 * gftty_write --
 *      cdevsw write routine.
 */
static int
gftty_write(dev_t dev, struct uio *uio, int flag)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));

        KASSERT(sc != NULL);

        struct tty *tp = sc->sc_tty;
        return (*tp->t_linesw->l_write)(tp, uio, flag);
}

/*
 * gftty_poll --
 *      cdevsw poll routine.
 */
static int
gftty_poll(dev_t dev, int events, struct lwp *l)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));

        KASSERT(sc != NULL);

        struct tty *tp = sc->sc_tty;
        return (*tp->t_linesw->l_poll)(tp, events, l);
}

/*
 * gftty_tty --
 *      cdevsw tty routine.
 */
static struct tty *
gftty_tty(dev_t dev)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));
        
        KASSERT(sc != NULL);

        return sc->sc_tty;
}

/*
 * gftty_ioctl --
 *      cdevsw ioctl routine.
 */
static int
gftty_ioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct gftty_softc *sc =
            device_lookup_private(&gftty_cd, GFTTY_UNIT(dev));

        KASSERT(sc != NULL);

        struct tty *tp = sc->sc_tty;
        int error;

        /* Do the line discipline ioctls first. */
        error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
        if (error != EPASSTHROUGH) {
                return error;
        }

        /* Next, the TTY ioctls. */
        error = ttioctl(tp, cmd, data, flag, l);
        if (error != EPASSTHROUGH) {
                return error;
        }

        /* None at this layer. */
        return EPASSTHROUGH;
}

/*
 * gftty_tx --
 *      Transmit a buffer on the virtual TTY using DMA.
 */
static void
gftty_tx(struct gftty_softc *sc, void *buf, size_t len)
{
        int error, i;

        KASSERT(len <= GFTTY_DMASIZE);

        error = bus_dmamap_load(sc->sc_dmat, sc->sc_tx_dma, buf, len,
            NULL, BUS_DMA_NOWAIT);
        if (error) {
                /* XXX report error */
                return;
        }
        bus_dmamap_sync(sc->sc_dmat, sc->sc_tx_dma, 0, len,
            BUS_DMASYNC_PREWRITE);

        mutex_spin_enter(&sc->sc_hwlock);
        for (i = 0; i < sc->sc_tx_dma->dm_nsegs; i++) {
                gftty_set_buffer(sc->sc_config,
                    sc->sc_tx_dma->dm_segs[i].ds_addr,
                    sc->sc_tx_dma->dm_segs[i].ds_len);
                REG_WRITE(sc, GFTTY_CMD, CMD_WRITE_BUFFER);
        }
        mutex_spin_exit(&sc->sc_hwlock);

        bus_dmamap_sync(sc->sc_dmat, sc->sc_tx_dma, 0, len,
            BUS_DMASYNC_POSTWRITE);
        bus_dmamap_unload(sc->sc_dmat, sc->sc_tx_dma);
}

/*
 * gftty_start --
 *      TTY oproc routine.
 */
static void
gftty_start(struct tty *tp)
{
        struct gftty_softc *sc = tp->t_softc;
        u_char *tbuf;
        int n;

        KASSERT(ttylocked(tp));

        if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP) ||
            ttypull(tp) == 0) {
                return;
        }
        SET(tp->t_state, TS_BUSY);

        /*
         * Drain the output from the ring buffer.  This will normally
         * be one contiguous chunk, but we have to do it in two pieces
         * when the ring wraps.
         */

        n = ndqb(&tp->t_outq, 0);
        tbuf = tp->t_outq.c_cf;
        gftty_tx(sc, tbuf, n);
        ndflush(&tp->t_outq, n);

        if ((n = ndqb(&tp->t_outq, 0)) > 0) {
                tbuf = tp->t_outq.c_cf;
                gftty_tx(sc, tbuf, n);
                ndflush(&tp->t_outq, n);
        }

        CLR(tp->t_state, TS_BUSY);
        /* Come back if there's more to do. */
        if (ttypull(tp)) {
                SET(tp->t_state, TS_TIMEOUT);
                callout_schedule(&tp->t_rstrt_ch, (hz > 128) ? (hz / 128) : 1);
        }
}

/*
 * gftty_stop --
 *      cdevsw stop routine.
 */
static void
gftty_stop(struct tty *tp, int flag)
{
        KASSERT(ttylocked(tp));

        if (ISSET(tp->t_state, TS_BUSY)) {
                if (!ISSET(tp->t_state, TS_TTSTOP)) {
                        SET(tp->t_state, TS_FLUSH);
                }
        }
}

/*
 * gftty_param_locked --
 *      Set TTY parameters.  TTY must be locked.
 */
static int
gftty_param_locked(struct tty *tp, struct termios *t)
{

        KASSERT(ttylocked(tp));

        tp->t_ispeed = t->c_ispeed;
        tp->t_ospeed = t->c_ospeed;
        tp->t_cflag = t->c_cflag;

        return 0;
}

/*
 * gftty_param --
 *      TTY param routine.
 */
static int
gftty_param(struct tty *tp, struct termios *t)
{
        int rv;

        ttylock(tp);
        rv = gftty_param_locked(tp, t);
        ttyunlock(tp);

        return rv;
}

/*
 * gftty console routines.
 */
static int
gftty_cngetc(dev_t dev)
{
        struct gftty_config * const c = &gftty_cnconfig;

        if (REG_READ0(c, GFTTY_BYTES_READY) == 0) {
                return -1;
        }

        /*
         * XXX This is all terrible and should burn to the ground.
         * XXX This device desperately needs to be improved with
         * XXX a GET_CHAR register.
         */
        bus_addr_t addr;
        uint8_t buf[1];

        if (c->c_version == 0) {
                addr = (bus_addr_t)buf;
        } else {
                addr = vtophys((vaddr_t)buf);
        }

        gftty_set_buffer(c, addr, sizeof(buf));
        REG_WRITE0(c, GFTTY_CMD, CMD_READ_BUFFER);

        return buf[0];
}

static void
gftty_cnputc(dev_t dev, int ch)
{
        REG_WRITE0(&gftty_cnconfig, GFTTY_PUT_CHAR, (unsigned char)ch);
}

static void
gftty_cnpollc(dev_t dev, int on)
{
        /* XXX */
}

/*
 * gftty_cnattach --
 *      Attach a Goldfish virtual TTY console.
 */
void
gftty_cnattach(bus_space_tag_t bst, bus_space_handle_t bsh)
{
        gftty_init_config(&gftty_cnconfig, bst, bsh);

        cn_tab = &gftty_consdev;
        cn_init_magic(&gftty_cnmagic_state);
        cn_set_magic("+++++");
}