/*      $NetBSD: dz_ebus.c,v 1.10 2019/12/27 06:52:43 msaitoh Exp $     */

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code was written by Alessandro Forin and Neil Pittman
 * at Microsoft Research and contributed to The NetBSD Foundation
 * by Microsoft Corporation.
 *
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: dz_ebus.c,v 1.10 2019/12/27 06:52:43 msaitoh Exp $");

#include "opt_ddb.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/ioctl.h>
#include <sys/tty.h>
#include <sys/proc.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/kernel.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <sys/kauth.h>

#include <machine/bus.h>
#include <machine/emipsreg.h>

#include <dev/cons.h>


#include <emips/ebus/ebusvar.h>
#include <emips/emips/cons.h>
#if 0
#include <emips/emips/machdep.h>
#endif

#include "ioconf.h" /* for dz_cd */

#define DZ_C2I(c)       ((c) << 3)      /* convert controller # to index */
#define DZ_I2C(c)       ((c) >> 3)      /* convert minor to controller # */
#define DZ_PORT(u)      ((u) & 07)      /* extract the port # */

struct  dz_softc {
        device_t        sc_dev;         /* Autoconf blaha */
        struct  evcnt   sc_rintrcnt;    /* receive interrupt counts */
        struct  evcnt   sc_tintrcnt;    /* transmit interrupt counts */
        struct  _Usart  *sc_dr;         /* reg pointers */
        bus_space_tag_t sc_iot;
        bus_space_handle_t sc_ioh;
        int             sc_consline;    /* console line, or -1 */
        int             sc_rxint;       /* Receive interrupt count XXX */
        u_char          sc_brk;         /* Break asserted on some lines */
        u_char          sc_dsr;         /* DSR set bits if no mdm ctrl */
        struct dz_linestate {
                struct  dz_softc *dz_sc;        /* backpointer to softc */
                int             dz_line;        /* channel number */
                struct  tty     *dz_tty;        /* what we work on */
        } sc_dz;
};

void    dzrint(struct dz_softc *, uint32_t);
void    dzxint(struct dz_softc *, uint32_t);

#ifndef TIOCM_BRK
#define TIOCM_BRK               0100000         /* no equivalent */

static void     dzstart(struct tty *);
static int      dzparam(struct tty *, struct termios *);
static unsigned dzmctl(struct dz_softc *sc, int line,
                       int bits, /* one of the TIOCM_xx */
                       int how); /* one of the DMSET/BIS.. */

#include <dev/dec/dzkbdvar.h>
#endif

dev_type_open(dzopen);
dev_type_close(dzclose);
dev_type_read(dzread);
dev_type_write(dzwrite);
dev_type_ioctl(dzioctl);
dev_type_stop(dzstop);
dev_type_tty(dztty);
dev_type_poll(dzpoll);

const struct cdevsw dz_cdevsw = {
        .d_open = dzopen,
        .d_close = dzclose,
        .d_read = dzread,
        .d_write = dzwrite,
        .d_ioctl = dzioctl,
        .d_stop = dzstop,
        .d_tty = dztty,
        .d_poll = dzpoll,
        .d_mmap = nommap,
        .d_kqfilter = ttykqfilter,
        .d_discard = nodiscard,
        .d_flag = D_TTY
};

int
dzopen(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct tty *tp;
        int unit, line;
        struct dz_softc *sc;
        int s, error = 0;

        unit = DZ_I2C(minor(dev));
        sc = device_lookup_private(&dz_cd, unit);
        if (sc == NULL)
                return ENXIO;

        line = DZ_PORT(minor(dev));
        if (line > 0) /* FIXME for more than one line */
                return ENXIO;

        tp = sc->sc_dz.dz_tty;
        if (tp == NULL)
                return ENODEV;
        tp->t_oproc = dzstart;
        tp->t_param = dzparam;
        tp->t_dev   = dev;

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

        if ((tp->t_state & TS_ISOPEN) == 0) {
                ttychars(tp);
                if (tp->t_ispeed == 0) {
                        tp->t_iflag = TTYDEF_IFLAG;
                        tp->t_oflag = TTYDEF_OFLAG;
                        tp->t_cflag = TTYDEF_CFLAG;
                        tp->t_lflag = TTYDEF_LFLAG;
                        tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
                }
                (void)dzparam(tp, &tp->t_termios);
                ttsetwater(tp);
        }
        /* we have no modem control but..*/
        if (dzmctl(sc, line, TIOCM_DTR, DMBIS) & TIOCM_CD)
                tp->t_state |= TS_CARR_ON;
        s = spltty();
        while (!(flag & O_NONBLOCK) && !(tp->t_cflag & CLOCAL) &&
            !(tp->t_state & TS_CARR_ON)) {
                tp->t_wopen++;
                error = ttysleep(tp, &tp->t_rawcv, true, 0);
                tp->t_wopen--;
                if (error)
                        break;
        }
        (void)splx(s);
        if (error)
                return error;
        return (*tp->t_linesw->l_open)(dev, tp);
}

int
dzclose(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct dz_softc *sc;
        struct tty *tp;
        int unit, line;

        unit = DZ_I2C(minor(dev));
        sc = device_lookup_private(&dz_cd, unit);
        line = DZ_PORT(minor(dev));

        tp = sc->sc_dz.dz_tty;

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

        /* Make sure a BREAK state is not left enabled. */
        (void)dzmctl(sc, line, TIOCM_BRK, DMBIC);

        /* Do a hangup if so required. */
        if ((tp->t_cflag & HUPCL) || tp->t_wopen || !(tp->t_state & TS_ISOPEN))
                (void)dzmctl(sc, line, 0, DMSET);

        return ttyclose(tp);
}

int
dzread(dev_t dev, struct uio *uio, int flag)
{
        struct tty *tp;
        struct dz_softc *sc;

        sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

        tp = sc->sc_dz.dz_tty;
        return (*tp->t_linesw->l_read)(tp, uio, flag);
}

int
dzwrite(dev_t dev, struct uio *uio, int flag)
{
        struct tty *tp;
        struct dz_softc *sc;

        sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

        tp = sc->sc_dz.dz_tty;
        return (*tp->t_linesw->l_write)(tp, uio, flag);
}

/*ARGSUSED*/
int
dzioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        struct  dz_softc *sc;
        struct tty *tp;
        int unit, line;
        int error;

        unit = DZ_I2C(minor(dev));
        line = 0;
        sc = device_lookup_private(&dz_cd, unit);
        tp = sc->sc_dz.dz_tty;

        error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
        if (error >= 0)
                return error;

        error = ttioctl(tp, cmd, data, flag, l);
        if (error >= 0)
                return error;

        switch (cmd) {

        case TIOCSBRK:
                (void)dzmctl(sc, line, TIOCM_BRK, DMBIS);
                break;

        case TIOCCBRK:
                (void)dzmctl(sc, line, TIOCM_BRK, DMBIC);
                break;

        case TIOCSDTR:
                (void)dzmctl(sc, line, TIOCM_DTR, DMBIS);
                break;

        case TIOCCDTR:
                (void)dzmctl(sc, line, TIOCM_DTR, DMBIC);
                break;

        case TIOCMSET:
                (void)dzmctl(sc, line, *(int *)data, DMSET);
                break;

        case TIOCMBIS:
                (void)dzmctl(sc, line, *(int *)data, DMBIS);
                break;

        case TIOCMBIC:
                (void)dzmctl(sc, line, *(int *)data, DMBIC);
                break;

        case TIOCMGET:
                *(int *)data = dzmctl(sc, line, 0, DMGET) & ~TIOCM_BRK;
                break;

        default:
                return EPASSTHROUGH;
        }
        return 0;
}

/*ARGSUSED*/
void
dzstop(struct tty *tp, int flag)
{

        if (tp->t_state & TS_BUSY)
                if (!(tp->t_state & TS_TTSTOP))
                        tp->t_state |= TS_FLUSH;
}

struct tty *
dztty(dev_t dev)
{
        struct dz_softc *sc;
        struct tty *tp;

        sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));
        tp = sc->sc_dz.dz_tty;

        return tp;
}

int
dzpoll(dev_t dev, int events, struct lwp *l)
{
        struct dz_softc *sc;
        struct tty *tp;

        sc = device_lookup_private(&dz_cd, DZ_I2C(minor(dev)));

        tp = sc->sc_dz.dz_tty;
        return (*tp->t_linesw->l_poll)(tp, events, l);
}

void
dzstart(struct tty *tp)
{
        struct dz_softc *sc;
        struct clist *cl;
        int unit, s;

        unit = DZ_I2C(minor(tp->t_dev));
        sc = device_lookup_private(&dz_cd, unit);

        s = spltty();
        if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) {
                splx(s);
                return;
        }
        cl = &tp->t_outq;
        ttypull(tp);
        if (cl->c_cc == 0) {
                splx(s);
                return;
        }

        tp->t_state |= TS_BUSY;

        /* was idle, get it started */
        dzxint(sc,USI_TXRDY);
        splx(s);
}

static int rclk = 25000000; /* BUGBUGBUGBUG */

static int
dzdivisor(int baudrate)
{
        int act_baud, divisor, error;

        if (baudrate <= 0)
                return 0;

        divisor = (rclk / 8) / (baudrate);
        divisor = (divisor / 2) + (divisor & 1);

        if (divisor <= 0)
                return -1;
        act_baud = rclk / (divisor * 16);

        /* 10 times error in percent: */
        error = ((act_baud - baudrate) * 2000 / baudrate + 1) >> 1;

        /* 3.0% maximum error tolerance: */
        if (error < -30 || error > 30)
                return -1;

        return divisor;
}

static int
dzparam(struct tty *tp, struct termios *t)
{
        struct  dz_softc *sc;
        int cflag = t->c_cflag;
        int unit, line;
        int speed;
        unsigned lpr;
        int s;
        struct _Usart *dzr;

        unit = DZ_I2C(minor(tp->t_dev));
        line = DZ_PORT(minor(tp->t_dev));
        sc = device_lookup_private(&dz_cd, unit);

        /* check requested parameters */
        if (t->c_ispeed != t->c_ospeed)
                return EINVAL;
        speed = dzdivisor(t->c_ispeed);
        if (speed < 0)
                return EINVAL;

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

        {
                /* XXX */
                static int didit = 0;
                if (!didit && t->c_ispeed != 38400)
                        printf("dzparam: c_ispeed %d ignored, keeping 38400\n",
                            t->c_ispeed);
                didit = 1;
        }
        speed = dzdivisor(38400);

        if (speed == 0) {
                (void)dzmctl(sc, line, 0, DMSET);       /* hang up line */
                return 0;
        }

        switch (cflag & CSIZE) {
        case CS5:
                lpr = USC_BPC_5;
                break;
        case CS6:
                lpr = USC_BPC_6;
                break;
        case CS7:
                lpr = USC_BPC_7;
                break;
        default:
                lpr = USC_BPC_8;
                break;
        }
        if (cflag & CSTOPB)
                lpr |= USC_2STOP;

        if (cflag & PARENB) {
                if (cflag & PARODD)
                        lpr |= USC_ODD;
                else
                        lpr |= USC_EVEN;
        } else
                lpr |= USC_NONE;

        s = spltty();

        dzr = sc->sc_dr;

        dzr->Baud = speed;
        dzr->Control = USC_CLKDIV_4 | USC_TXEN | USC_RXEN | lpr;
#define USI_INTRS (USI_RXRDY|USI_RXBRK|USI_OVRE|USI_FRAME|USI_PARE)
        dzr->IntrEnable = USI_INTRS;

        (void)splx(s);
        return 0;
}

static unsigned
dzmctl(struct dz_softc *sc, int line, int bits, int how)
{
        unsigned int mbits;
        int s;
        struct _Usart *dzr;

        mbits = 0;

        s = spltty();

        dzr = sc->sc_dr;

        /* we have no modem control bits (CD,RI,DTR,DSR,..) */
        mbits |= TIOCM_CD;
        mbits |= TIOCM_DTR;

        if (dzr->ChannelStatus & USI_RXBRK)
                mbits |= TIOCM_BRK;

        switch (how) {
        case DMSET:
                mbits = bits;
                break;

        case DMBIS:
                mbits |= bits;
                break;

        case DMBIC:
                mbits &= ~bits;
                break;

        case DMGET:
                (void)splx(s);
                return mbits;
        }

        /* BUGBUG work in progress */
        if (mbits & TIOCM_BRK) {
                sc->sc_brk |= (1 << line);
                dzr->Control |= USC_STTBRK;
        } else {
                sc->sc_brk &= ~(1 << line);
                dzr->Control |= USC_STPBRK;
        }

        (void)splx(s);
        return mbits;
}


#if defined(DDB)
int dz_ddb = 0;
#endif

/* Receiver Interrupt */

void
dzrint(struct dz_softc *sc, uint32_t csr)
{
        struct tty *tp;
        int cc;
        struct _Usart *dzr;

        sc->sc_rxint++;
        dzr = sc->sc_dr;

        cc = dzr->RxData;
        tp = sc->sc_dz.dz_tty;

        /* clear errors before we print or bail out */
        if (csr & (USI_OVRE|USI_FRAME|USI_PARE))
                dzr->Control = USC_RSTSTA;

        if (!(tp->t_state & TS_ISOPEN)) {
                wakeup(&tp->t_rawq);
                return;
        }

        if (csr & USI_OVRE) {
                log(LOG_WARNING, "%s: silo overflow, line %d\n",
                    device_xname(sc->sc_dev), 0);
        }

        if (csr & USI_FRAME)
                cc |= TTY_FE;
        if (csr & USI_PARE)
                cc |= TTY_PE;

#if defined(DDB)
        /* ^P drops into DDB */
        if (dz_ddb && (cc == 0x10))
                Debugger();
#endif
        (*tp->t_linesw->l_rint)(cc, tp);
}

/* Transmitter Interrupt */

void
dzxint(struct dz_softc *sc, uint32_t csr)
{
        struct tty *tp;
        struct clist *cl;
        int ch;
        struct _Usart *dzr;

        dzr = sc->sc_dr;

        tp = sc->sc_dz.dz_tty;
        cl = &tp->t_outq;
        tp->t_state &= ~TS_BUSY;

        /* Just send out a char if we have one */
        if (cl->c_cc) {
                tp->t_state |= TS_BUSY;
                ch = getc(cl);
                dzr->TxData = ch;
                dzr->IntrEnable = USI_TXRDY;
                return;
        }

        /* Nothing to send; turn off intr */
        dzr->IntrDisable = USI_TXRDY;

        if (tp->t_state & TS_FLUSH)
                tp->t_state &= ~TS_FLUSH;
        else
                ndflush(&tp->t_outq, cl->c_cc);

        (*tp->t_linesw->l_start)(tp);
}

/*
 * Machdep part of the driver
 */
int     dz_ebus_match(device_t, cfdata_t, void *);
void    dz_ebus_attach(device_t, device_t, void *);
int     dz_ebus_intr(void *, void *);

void    dz_ebus_cnsetup(paddr_t);
void    dz_ebus_cninit(struct consdev *);
int     dz_ebus_cngetc(dev_t);
void    dz_ebus_cnputc(dev_t, int);
void    dz_ebus_cnpollc(dev_t, int);

static int      dz_ebus_getmajor(void);

CFATTACH_DECL_NEW(dz_ebus, sizeof(struct dz_softc),
    dz_ebus_match, dz_ebus_attach, NULL, NULL);

struct consdev dz_ebus_consdev = {
        NULL, dz_ebus_cninit, dz_ebus_cngetc, dz_ebus_cnputc,
        dz_ebus_cnpollc, NULL, NULL, NULL, NODEV, CN_NORMAL,
};

/*
 * Points to the console regs. Special mapping until VM is turned on.
 */
struct _Usart *dzcn;

int
dz_ebus_match(device_t parent, cfdata_t cf, void *aux)
{
        struct ebus_attach_args *iba;
        struct _Usart *us;

        iba = aux;

        if (strcmp(iba->ia_name, "dz") != 0)
                return 0;

        us = (struct _Usart *)iba->ia_vaddr;
        if ((us == NULL) ||
            (us->Tag != PMTTAG_USART))
                return 0;

        return 1;
}

void
dz_ebus_attach(device_t parent, device_t self, void *aux)
{
        struct ebus_attach_args *iba;
        struct dz_softc *sc;

        sc = device_private(self);
        iba = aux;

        sc->sc_dev = self;
        sc->sc_dr = (struct _Usart *)iba->ia_vaddr;
#if DEBUG
        printf(" virt=%p ", (void *)sc->sc_dr);
#endif

        printf(": neilsart 1 line");
        ebus_intr_establish(parent, (void *)iba->ia_cookie, IPL_TTY,
            dz_ebus_intr, sc);

        sc->sc_rxint = sc->sc_brk = 0;
        sc->sc_consline = 0;

        /* Initialize our softc structure. Should be done in open? */

        sc->sc_dz.dz_sc = sc;
        sc->sc_dz.dz_line = 0;
        sc->sc_dz.dz_tty = tty_alloc();

        evcnt_attach_dynamic(&sc->sc_rintrcnt, EVCNT_TYPE_INTR, NULL,
            device_xname(self), "rintr");
        evcnt_attach_dynamic(&sc->sc_tintrcnt, EVCNT_TYPE_INTR, NULL,
            device_xname(self), "tintr");

        /* Initialize hw regs */
#if 0
        DZ_WRITE_WORD(dr_csr, DZ_CSR_MSE | DZ_CSR_RXIE | DZ_CSR_TXIE);
        DZ_WRITE_BYTE(dr_dtr, 0);
        DZ_WRITE_BYTE(dr_break, 0);
#endif

        /* Switch the console to virtual mode */
        dzcn = sc->sc_dr;
        /* And test it */
        printf("\n");
}

static int
dz_ebus_getmajor(void)
{
        extern const struct cdevsw dz_cdevsw;
        static int cache = -1;

        if (cache != -1)
                return cache;

        return cache = cdevsw_lookup_major(&dz_cdevsw);
}

int
dz_ebus_intr(void *cookie, void *f)
{
        struct dz_softc *sc;
        struct _Usart *dzr;
        uint32_t csr;

        sc = cookie;
        dzr = sc->sc_dr;

#define USI_INTERRUPTS (USI_INTRS|USI_TXRDY)

        for (; ((csr = (dzr->ChannelStatus & dzr->IntrMask)) &
            USI_INTERRUPTS) != 0;) {
                if ((csr & USI_INTRS) != 0)
                        dzrint(sc, csr);
                if ((csr & USI_TXRDY) != 0)
                        dzxint(sc, csr);
        }

        return 0;
}

void
dz_ebus_cnsetup(paddr_t addr)
{

        dzcn = (struct _Usart *)addr;

#if 0
        /*
         * Initialize enough to xmit/recv via polling.
         * Bootloader might or might not have done it.
         */
        dzcn->Control =
            USC_RXEN |
            USC_TXEN |
            USC_BPC_8 |
            USC_NONE |
            USC_1STOP |
            USC_CLKDIV_4;
        dzcn->Baud = 0x29; /* 38400 */
#endif

        /*
         * Point the console at us
         */
        cn_tab = &dz_ebus_consdev;
        cn_tab->cn_pri = CN_NORMAL;/*CN_REMOTE?*/
        cn_tab->cn_dev = makedev(dz_ebus_getmajor(), 0);
}

void
dz_ebus_cninit(struct consdev *cn)
{
}

int
dz_ebus_cngetc(dev_t dev)
{
        int c, s;

        c = 0;
        s = spltty();

        while ((dzcn->ChannelStatus & USI_RXRDY) == 0)
                DELAY(10);
        c = dzcn->RxData;

        splx(s);
        if (c == 13) /* map cr->ln */
                c = 10;
        return c;
}

int dzflipped = 0;
void
dz_ebus_cnputc(dev_t dev, int ch)
{
        int timeout, s;

        /* Don't hang the machine! */
        timeout = 1 << 15;

        s = spltty();

#if 1
        /* Keep wired to hunt for a bug */
        if (dzcn && (dzcn != (struct _Usart *)0xfff90000)) {
                dzcn = (struct _Usart *)0xfff90000;
                dzflipped++;
        }
#endif

        /* Wait until ready */
        while ((dzcn->ChannelStatus & USI_TXRDY) == 0)
                if (--timeout < 0)
                        break;

        /* Put the character */
        dzcn->TxData = ch;

        splx(s);
}

/*
 * Called before/after going into poll mode
 */
void
dz_ebus_cnpollc(dev_t dev, int on)
{
}