/*      $NetBSD: ser.c,v 1.86 2022/10/26 23:38:06 riastradh Exp $ */

/*
 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * 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.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 *      @(#)ser.c       7.12 (Berkeley) 6/27/91
 */
/*
 * XXX This file needs major cleanup it will never service more than one
 * XXX unit.
 */

#include "opt_amigacons.h"
#include "opt_ddb.h"
#include "opt_kgdb.h"

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ser.c,v 1.86 2022/10/26 23:38:06 riastradh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/ioctl.h>
#include <sys/device.h>
#include <sys/tty.h>
#include <sys/proc.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/kernel.h>
#include <sys/syslog.h>
#include <sys/queue.h>
#include <sys/conf.h>
#include <sys/kauth.h>
#include <machine/cpu.h>
#include <amiga/amiga/device.h>
#include <amiga/dev/serreg.h>
#include <amiga/amiga/custom.h>
#include <amiga/amiga/cia.h>
#include <amiga/amiga/cc.h>

#include <dev/cons.h>

#include <ddb/db_active.h>

#include "ser.h"
#if NSER > 0

void serattach(device_t, device_t, void *);
int sermatch(device_t, cfdata_t, void *);

struct ser_softc {
        struct tty *ser_tty;
};

CFATTACH_DECL_NEW(ser, sizeof(struct ser_softc),
    sermatch, serattach, NULL, NULL);

extern struct cfdriver ser_cd;

dev_type_open(seropen);
dev_type_close(serclose);
dev_type_read(serread);
dev_type_write(serwrite);
dev_type_ioctl(serioctl);
dev_type_stop(serstop);
dev_type_tty(sertty);
dev_type_poll(serpoll);

const struct cdevsw ser_cdevsw = {
        .d_open = seropen,
        .d_close = serclose,
        .d_read = serread,
        .d_write = serwrite,
        .d_ioctl = serioctl,
        .d_stop = serstop,
        .d_tty = sertty,
        .d_poll = serpoll,
        .d_mmap = nommap,
        .d_kqfilter = ttykqfilter,
        .d_discard = nodiscard,
        .d_flag = D_TTY
};

#ifndef SEROBUF_SIZE
#define SEROBUF_SIZE 32
#endif
#ifndef SERIBUF_SIZE
#define SERIBUF_SIZE 512
#endif

#define splser() spl5()

void    serstart(struct tty *);
void    ser_shutdown(struct ser_softc *);
int     serparam(struct tty *, struct termios *);
void    serintr(void);
int     serhwiflow(struct tty *, int);
int     sermctl(dev_t dev, int, int);
void    ser_fastint(void);
void    sereint(int);
static  void ser_putchar(struct tty *, u_short);
void    ser_outintr(void);
void    sercnprobe(struct consdev *);
void    sercninit(struct consdev *);
void    serinit(int);
int     sercngetc(dev_t dev);
void    sercnputc(dev_t, int);
void    sercnpollc(dev_t, int);

int     nser = NSER;
#ifdef SERCONSOLE
int     serconsole = 0;
#else
int     serconsole = -1;
#endif
int     serconsinit;
int     serdefaultrate = TTYDEF_SPEED;
int     serswflags;

struct  vbl_node ser_vbl_node;
struct  tty ser_cons;
struct  tty *ser_tty;

static u_short serbuf[SERIBUF_SIZE];
static u_short *sbrpt = serbuf;
static u_short *sbwpt = serbuf;
static u_short sbcnt;
static u_short sbovfl;
static u_char serdcd;

/*
 * Since this UART is not particularly bright (to put it nicely), we'll
 * have to do parity stuff on our own.  This table contains the 8th bit
 * in 7bit character mode, for even parity.  If you want odd parity,
 * flip the bit.  (for generation of the table, see genpar.c)
 */

u_char  even_parity[] = {
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
        0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
        1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
};

/*
 * Since we don't get interrupts for changes on the modem control line,
 * we'll have to fake them by comparing current settings to the settings
 * we remembered on last invocation.
 */

u_char  last_ciab_pra;

extern int ser_open_speed;      /* current speed of open serial device */

#ifdef KGDB
#include <machine/remote-sl.h>

extern dev_t kgdb_dev;
extern int kgdb_rate;
extern int kgdb_debug_init;
#endif

#ifdef DEBUG
long    fifoin[17];
long    fifoout[17];
long    serintrcount[16];
long    sermintcount[16];
#endif

void    sermint(register int unit);

int
sermatch(device_t parent, cfdata_t cf, void *aux)
{
        static int ser_matched = 0;
        static int ser_matched_real = 0;

        /* Allow only once instance. */
        if (matchname("ser", (char *)aux) == 0)
                return(0);

        if (amiga_realconfig) {
                if (ser_matched_real)
                        return(0);
                ser_matched_real = 1;
        } else {
                if (serconsole != 0)
                        return(0);

                if (ser_matched != 0)
                        return(0);

                ser_matched = 1;
        }
        return(1);
}


void
serattach(device_t parent, device_t self, void *aux)
{
        struct ser_softc *sc;
        struct tty *tp;
        u_short ir;

        sc = device_private(self);

        ir = custom.intenar;
        __USE(ir);
        if (serconsole == 0)
                DELAY(100000);

        ser_vbl_node.function = (void (*) (void *)) sermint;
        add_vbl_function(&ser_vbl_node, SER_VBL_PRIORITY, (void *) 0);
#ifdef KGDB
        if (kgdb_dev == makedev(cdevsw_lookup_major(&ser_cdevsw), 0)) {
                if (serconsole == 0)
                        kgdb_dev = NODEV; /* can't debug over console port */
                else {
                        (void) serinit(kgdb_rate);
                        serconsinit = 1;       /* don't re-init in serputc */
                        if (kgdb_debug_init == 0)
                                printf(" kgdb enabled\n");
                        else {
                                /*
                                 * Print prefix of device name,
                                 * let kgdb_connect print the rest.
                                 */
                                printf("ser0: ");
                                kgdb_connect(1);
                        }
                }
        }
#endif
        /*
         * Need to reset baud rate, etc. of next print so reset serconsinit.
         */
        if (0 == serconsole)
                serconsinit = 0;

        tp = tty_alloc();
        tp->t_oproc = (void (*) (struct tty *)) serstart;
        tp->t_param = serparam;
        tp->t_hwiflow = serhwiflow;
        tty_attach(tp);
        sc->ser_tty = ser_tty = tp;

        if (self)
                printf(": input fifo %d output fifo %d\n", SERIBUF_SIZE,
                    SEROBUF_SIZE);
}


/* ARGSUSED */
int
seropen(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct ser_softc *sc;
        struct tty *tp;
        int unit, error, s, s2;

        error = 0;
        unit = SERUNIT(dev);

        sc = device_lookup_private(&ser_cd, unit);
        if (sc == NULL)
                return (ENXIO);

        /* XXX com.c: insert KGDB check here */

        /* XXX ser.c had: s = spltty(); */

        tp = sc->ser_tty;

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

        s = spltty();

        /*
         * If this is a first open...
         */

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

                tp->t_dev = dev;

                s2 = splser();
                /*
                 * XXX here: hw enable,
                 */
                last_ciab_pra = ciab.pra;

                splx(s2);
                t.c_ispeed = 0;

                /* XXX serconsolerate? */
                t.c_ospeed = TTYDEF_SPEED;
                t.c_cflag = TTYDEF_CFLAG;

                if (serswflags & TIOCFLAG_CLOCAL)
                        t.c_cflag |= CLOCAL;
                if (serswflags & TIOCFLAG_CRTSCTS)
                        t.c_cflag |= CRTSCTS;
                if (serswflags & TIOCFLAG_MDMBUF)
                        t.c_cflag |= MDMBUF;

                /* Make sure serparam() will do something. */
                tp->t_ospeed = 0;
                serparam(tp, &t);
                tp->t_iflag = TTYDEF_IFLAG;
                tp->t_oflag = TTYDEF_OFLAG;
                tp->t_lflag = TTYDEF_LFLAG;
                ttychars(tp);
                ttsetwater(tp);

                s2 = splser();
                (void)sermctl(dev, TIOCM_DTR, DMSET);
                /* clear input ring */
                sbrpt = sbwpt = serbuf;
                sbcnt = 0;
                splx(s2);
        }

        splx(s);

        error = ttyopen(tp, DIALOUT(dev), flag & O_NONBLOCK);
        if (error)
                goto bad;

        error =  tp->t_linesw->l_open(dev, tp);
        if (error)
                goto bad;

        return (0);

bad:
        if (!(tp->t_state & TS_ISOPEN) && tp->t_wopen == 0) {
                ser_shutdown(sc);
        }

        return (error);
}

/*ARGSUSED*/
int
serclose(dev_t dev, int flag, int mode, struct lwp *l)
{
        struct ser_softc *sc;
        struct tty *tp;

        sc = device_lookup_private(&ser_cd, SERUNIT(dev));
        tp = ser_tty;

        /* XXX This is for cons.c, according to com.c */
        if (!(tp->t_state & TS_ISOPEN))
                return (0);

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

        if (!(tp->t_state & TS_ISOPEN) && tp->t_wopen == 0) {
                ser_shutdown(sc);
        }
        return (0);
}

void
ser_shutdown(struct ser_softc *sc)
{
        struct tty *tp = sc->ser_tty;
        int s;

        s = splser();

        custom.adkcon = ADKCONF_UARTBRK;        /* clear break */
#if 0 /* XXX fix: #ifdef KGDB */
        /*
         * do not disable interrupts if debugging
         */
        if (dev != kgdb_dev)
#endif
                custom.intena = INTF_RBF | INTF_TBE;    /* disable interrupts */
        custom.intreq = INTF_RBF | INTF_TBE;            /* clear intr request */

        /*
         * If HUPCL is not set, leave DTR unchanged.
         */
        if (tp->t_cflag & HUPCL) {
                (void)sermctl(tp->t_dev, TIOCM_DTR, DMBIC);
                /*
                 * Idea from dev/ic/com.c:
                 * sleep a bit so that other side will notice, even if we
                 * reopen immediately.
                 */
                (void) tsleep(tp, TTIPRI, ttclos, hz);
        }

#if not_yet
        if (tp != &ser_cons) {
                remove_vbl_function(&ser_vbl_node);
                tty_free(tp);
                ser_tty = (struct tty *) NULL;
        }
#endif
        ser_open_speed = tp->t_ispeed;
        splx(s);
        return;
}

int
serread(dev_t dev, struct uio *uio, int flag)
{
        /* ARGSUSED */

        return ser_tty->t_linesw->l_read(ser_tty, uio, flag);
}

int
serwrite(dev_t dev, struct uio *uio, int flag)
{
        /* ARGSUSED */

        return ser_tty->t_linesw->l_write(ser_tty, uio, flag);
}

int
serpoll(dev_t dev, int events, struct lwp *l)
{
        /* ARGSUSED */

        return ser_tty->t_linesw->l_poll(ser_tty, events, l);
}

struct tty *
sertty(dev_t dev)
{
        /* ARGSUSED */

        return (ser_tty);
}

/*
 * We don't do any processing of data here, so we store the raw code
 * obtained from the uart register.  In theory, 110kBaud gives you
 * 11kcps, so 16k buffer should be more than enough, interrupt
 * latency of 1s should never happen, or something is seriously
 * wrong..
 * buffers moved to above seropen()     -is
 */

/*
 * This is a replacement for the lack of a hardware fifo.  32k should be
 * enough (there's only one unit anyway, so this is not going to
 * accumulate).
 */
void
ser_fastint(void)
{
        /*
         * We're at RBE-level, which is higher than VBL-level which is used
         * to periodically transmit contents of this buffer up one layer,
         * so no spl-raising is necessary.
         */
        u_short code;

        /*
         * This register contains both data and status bits!
         */
        code = custom.serdatr;

        /*
         * Use SERDATF_RBF instead of INTF_RBF; they're equivalent, but
         * we save one (slow) custom chip access.
         */
        if ((code & SERDATRF_RBF) == 0)
                return;

        /*
         * clear interrupt
         */
        custom.intreq = INTF_RBF;

        /*
         * check for buffer overflow.
         */
        if (sbcnt == SERIBUF_SIZE) {
                ++sbovfl;
                return;
        }
        /*
         * store in buffer
         */
        *sbwpt++ = code;
        if (sbwpt == serbuf + SERIBUF_SIZE)
                sbwpt = serbuf;
        ++sbcnt;
        if (sbcnt > SERIBUF_SIZE - 20)
                CLRRTS(ciab.pra);       /* drop RTS if buffer almost full */
}


void
serintr(void)
{
        int s1, s2, ovfl;
        struct tty *tp = ser_tty;

        /*
         * Make sure we're not interrupted by another
         * vbl, but allow level5 ints
         */
        s1 = spltty();

        /*
         * pass along any accumulated information
         */
        while (sbcnt > 0 && (tp->t_state & TS_TBLOCK) == 0) {
                /*
                 * no collision with ser_fastint()
                 */
                sereint(*sbrpt++);

                ovfl = 0;
                /* lock against ser_fastint() */
                s2 = splser();
                sbcnt--;
                if (sbrpt == serbuf + SERIBUF_SIZE)
                        sbrpt = serbuf;
                if (sbovfl != 0) {
                        ovfl = sbovfl;
                        sbovfl = 0;
                }
                splx(s2);
                if (ovfl != 0)
                        log(LOG_WARNING, "ser0: %d ring buffer overflows.\n",
                            ovfl);
        }
        s2 = splser();
        if (sbcnt == 0 && (tp->t_state & TS_TBLOCK) == 0)
                SETRTS(ciab.pra);       /* start accepting data again */
        splx(s2);
        splx(s1);
}

void
sereint(int stat)
{
        static int break_in_progress = 0;
        struct tty *tp;
        u_char ch;
        int c;

        tp = ser_tty;
        ch = stat & 0xff;
        c = ch;

        if ((tp->t_state & TS_ISOPEN) == 0) {
#ifdef KGDB
                int maj;

                /* we don't care about parity errors */
                maj = cdevsw_lookup_major(&ser_cdevsw);
                if (kgdb_dev == makedev(maj, 0) && c == FRAME_END)
                        kgdb_connect(0);        /* trap into kgdb */
#endif
                return;
        }

        /*
         * Check for break and (if enabled) parity error.
         */
        if ((stat & 0x1ff) == 0) {
                if (break_in_progress)
                        return;

                c = TTY_FE;
                break_in_progress = 1;
#ifdef DDB
                if (serconsole == 0) {
                        if (!db_active) {
                                console_debugger();
                                return;
                        }
                }
#endif
        } else {
                break_in_progress = 0;
                if ((tp->t_cflag & PARENB) &&
                        (((ch >> 7) + even_parity[ch & 0x7f]
                                + !!(tp->t_cflag & PARODD)) & 1))
                        c |= TTY_PE;
        }

        if (stat & SERDATRF_OVRUN)
                log(LOG_WARNING, "ser0: silo overflow\n");

        tp->t_linesw->l_rint(c, tp);
}

/*
 * This interrupt is periodically invoked in the vertical blank
 * interrupt.  It's used to keep track of the modem control lines
 * and (new with the fast_int code) to move accumulated data
 * up into the tty layer.
 */
void
sermint(int unit)
{
        struct tty *tp;
        u_char stat, last, istat;

        tp = ser_tty;
        if (!tp)
                return;

        /*
        if ((tp->t_state & TS_ISOPEN) == 0 || tp->t_wopen == 0) {
                sbrpt = sbwpt = serbuf;
                return;
        }
        */
        /*
         * empty buffer
         */
        serintr();

        stat = ciab.pra;
        last = last_ciab_pra;
        last_ciab_pra = stat;

        /*
         * check whether any interesting signal changed state
         */
        istat = stat ^ last;

        if (istat & serdcd) {
                tp->t_linesw->l_modem(tp, ISDCD(stat));
        }

        if ((istat & CIAB_PRA_CTS) && (tp->t_state & TS_ISOPEN) &&
            (tp->t_cflag & CRTSCTS)) {
#if 0
                /* the line is up and we want to do rts/cts flow control */
                if (ISCTS(stat)) {
                        tp->t_state &= ~TS_TTSTOP;
                        ttstart(tp);
                        /* cause tbe-int if we were stuck there */
                        custom.intreq = INTF_SETCLR | INTF_TBE;
                } else
                        tp->t_state |= TS_TTSTOP;
#else
                /* do this on hardware level, not with tty driver */
                if (ISCTS(stat)) {
                        tp->t_state &= ~TS_TTSTOP;
                        /* cause TBE interrupt */
                        custom.intreq = INTF_SETCLR | INTF_TBE;
                }
#endif
        }
}

int
serioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
        register struct tty *tp;
        register int error;

        tp = ser_tty;
        if (!tp)
                return ENXIO;

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

        error = ttioctl(tp, cmd, data, flag, l);
        if (error != EPASSTHROUGH)
                return(error);

        switch (cmd) {
        case TIOCSBRK:
                custom.adkcon = ADKCONF_SETCLR | ADKCONF_UARTBRK;
                break;

        case TIOCCBRK:
                custom.adkcon = ADKCONF_UARTBRK;
                break;

        case TIOCSDTR:
                (void) sermctl(dev, TIOCM_DTR, DMBIS);
                break;

        case TIOCCDTR:
                (void) sermctl(dev, TIOCM_DTR, DMBIC);
                break;

        case TIOCMSET:
                (void) sermctl(dev, *(int *) data, DMSET);
                break;

        case TIOCMBIS:
                (void) sermctl(dev, *(int *) data, DMBIS);
                break;

        case TIOCMBIC:
                (void) sermctl(dev, *(int *) data, DMBIC);
                break;

        case TIOCMGET:
                *(int *)data = sermctl(dev, 0, DMGET);
                break;
        case TIOCGFLAGS:
                *(int *)data = serswflags;
                break;
        case TIOCSFLAGS:
                error = kauth_authorize_device_tty(l->l_cred,
                    KAUTH_DEVICE_TTY_PRIVSET, tp);
                if (error != 0)
                        return(EPERM);

                serswflags = *(int *)data;
                serswflags &= /* only allow valid flags */
                  (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS);
                break;
        default:
                return(EPASSTHROUGH);
        }

        return(0);
}

int
serparam(struct tty *tp, struct termios *t)
{
        int cflag, ospeed = 0;

        if (t->c_ospeed > 0) {
                if (t->c_ospeed < 110)
                        return(EINVAL);
                ospeed = SERBRD(t->c_ospeed);
        }

        if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
                return(EINVAL);

        if (serswflags & TIOCFLAG_SOFTCAR || serconsole == 0) {
                t->c_cflag = (t->c_cflag & ~HUPCL) | CLOCAL;
        }

        /* if no changes, dont do anything. com.c explains why. */
        if (tp->t_ospeed == t->c_ospeed &&
            tp->t_cflag == t->c_cflag)
                return (0);

        cflag = t->c_cflag;

        if (cflag & (CLOCAL | MDMBUF))
                serdcd = 0;
        else
                serdcd = CIAB_PRA_CD;

        /* TODO: support multiple flow control protocols like com.c */

        /*
         * copy to tty
         */
        tp->t_ispeed = t->c_ispeed;
        tp->t_ospeed = t->c_ospeed;
        tp->t_cflag = cflag;
        ser_open_speed = tp->t_ispeed;

        /*
         * enable interrupts
         */
        custom.intena = INTF_SETCLR | INTF_RBF | INTF_TBE;
        last_ciab_pra = ciab.pra;

        if (t->c_ospeed == 0)
                (void)sermctl(tp->t_dev, 0, DMSET);     /* hang up line */
        else {
                /*
                 * (re)enable DTR
                 * and set baud rate. (8 bit mode)
                 */
                (void)sermctl(tp->t_dev, TIOCM_DTR, DMSET);
                custom.serper = (0 << 15) | ospeed;
        }
        (void)tp->t_linesw->l_modem(tp, ISDCD(last_ciab_pra));

        return(0);
}

int serhwiflow(struct tty *tp, int flag)
{
#if 0
        printf ("serhwiflow %d\n", flag);
#endif
        if (flag)
                CLRRTS(ciab.pra);
        else
                SETRTS(ciab.pra);
        return 1;
}

static void
ser_putchar(struct tty *tp, u_short c)
{
        if ((tp->t_cflag & CSIZE) == CS7 || (tp->t_cflag & PARENB))
                c &= 0x7f;

        /*
         * handle parity if necessary
         */
        if (tp->t_cflag & PARENB) {
                if (even_parity[c])
                        c |= 0x80;
                if (tp->t_cflag & PARODD)
                        c ^= 0x80;
        }
        /*
         * add stop bit(s)
         */
        if (tp->t_cflag & CSTOPB)
                c |= 0x300;
        else
                c |= 0x100;

        custom.serdat = c;
}


static u_char ser_outbuf[SEROBUF_SIZE];
static u_char *sob_ptr = ser_outbuf, *sob_end = ser_outbuf;

void
ser_outintr(void)
{
        struct tty *tp;
        int s;

        tp = ser_tty;
        s = spltty();

        if (tp == 0)
                goto out;

        if ((custom.intreqr & INTF_TBE) == 0)
                goto out;

        /*
         * clear interrupt
         */
        custom.intreq = INTF_TBE;

        if (sob_ptr == sob_end) {
                tp->t_state &= ~(TS_BUSY | TS_FLUSH);
                if (tp->t_linesw)
                        tp->t_linesw->l_start(tp);
                else
                        serstart(tp);
                goto out;
        }

        /*
         * Do hardware flow control here.  if the CTS line goes down, don't
         * transmit anything.  That way, we'll be restarted by the periodic
         * interrupt when CTS comes back up.
         */
        if (ISCTS(ciab.pra))
                ser_putchar(tp, *sob_ptr++);
        else
                CLRCTS(last_ciab_pra);  /* Remember that CTS is off */
out:
        splx(s);
}

void
serstart(struct tty *tp)
{
        int cc, s, hiwat;
#ifdef DIAGNOSTIC
        int unit;
#endif

        hiwat = 0;

        if ((tp->t_state & TS_ISOPEN) == 0)
                return;

#ifdef DIAGNOSTIC
        unit = SERUNIT(tp->t_dev);
        if (unit)
                panic("serstart: unit is %d", unit);
#endif

        s = spltty();
        if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP))
                goto out;

        cc = tp->t_outq.c_cc;
        if (!ttypull(tp) || (tp->t_state & TS_BUSY))
                goto out;

        /*
         * We only do bulk transfers if using CTSRTS flow control, not for
         * (probably sloooow) ixon/ixoff devices.
         */
        if ((tp->t_cflag & CRTSCTS) == 0)
                cc = 1;

        /*
         * Limit the amount of output we do in one burst
         * to prevent hogging the CPU.
         */
        if (cc > SEROBUF_SIZE) {
                hiwat++;
                cc = SEROBUF_SIZE;
        }
        cc = q_to_b(&tp->t_outq, ser_outbuf, cc);
        if (cc > 0) {
                tp->t_state |= TS_BUSY;

                sob_ptr = ser_outbuf;
                sob_end = ser_outbuf + cc;

                /*
                 * Get first character out, then have TBE-interrupts blow out
                 * further characters, until buffer is empty, and TS_BUSY gets
                 * cleared.
                 */
                ser_putchar(tp, *sob_ptr++);
        }
out:
        splx(s);
}

/*
 * Stop output on a line.
 */
/*ARGSUSED*/
void
serstop(struct tty *tp, int flag)
{
        int s;

        s = spltty();
        if (tp->t_state & TS_BUSY) {
                if ((tp->t_state & TS_TTSTOP) == 0)
                        tp->t_state |= TS_FLUSH;
        }
        splx(s);
}

int
sermctl(dev_t dev, int bits, int how)
{
        int s;
        u_char ub = 0;

        /*
         * convert TIOCM* mask into CIA mask
         * which is active low
         */
        if (how != DMGET) {
                ub = 0;
                if (bits & TIOCM_DTR)
                        ub |= CIAB_PRA_DTR;
                if (bits & TIOCM_RTS)
                        ub |= CIAB_PRA_RTS;
                if (bits & TIOCM_CTS)
                        ub |= CIAB_PRA_CTS;
                if (bits & TIOCM_CD)
                        ub |= CIAB_PRA_CD;
                if (bits & TIOCM_RI)
                        ub |= CIAB_PRA_SEL;     /* collision with /dev/par ! */
                if (bits & TIOCM_DSR)
                        ub |= CIAB_PRA_DSR;
        }
        s = spltty();
        switch (how) {
        case DMSET:
                /* invert and set */
                ciab.pra = ~ub;
                break;

        case DMBIC:
                ciab.pra |= ub;
                ub = ~ciab.pra;
                break;

        case DMBIS:
                ciab.pra &= ~ub;
                ub = ~ciab.pra;
                break;

        case DMGET:
                ub = ~ciab.pra;
                break;
        }
        (void)splx(s);

        bits = 0;
        if (ub & CIAB_PRA_DTR)
                bits |= TIOCM_DTR;
        if (ub & CIAB_PRA_RTS)
                bits |= TIOCM_RTS;
        if (ub & CIAB_PRA_CTS)
                bits |= TIOCM_CTS;
        if (ub & CIAB_PRA_CD)
                bits |= TIOCM_CD;
        if (ub & CIAB_PRA_SEL)
                bits |= TIOCM_RI;
        if (ub & CIAB_PRA_DSR)
                bits |= TIOCM_DSR;

        return(bits);
}

/*
 * Following are all routines needed for SER to act as console
 */
void
sercnprobe(struct consdev *cp)
{
        int maj, unit;
#ifdef KGDB
        extern const struct cdevsw ctty_cdevsw;
#endif

        /* locate the major number */
        maj = cdevsw_lookup_major(&ser_cdevsw);


        unit = CONUNIT;                 /* XXX: ick */

        /*
         * initialize required fields
         */
        cp->cn_dev = makedev(maj, unit);
        if (serconsole == unit)
                cp->cn_pri = CN_REMOTE;
        else
                cp->cn_pri = CN_NORMAL;
#ifdef KGDB
        /* XXX */
        if (cdevsw_lookup(kgdb_dev) == &ctty_cdevsw)
                kgdb_dev = makedev(maj, minor(kgdb_dev));
#endif
}

void
sercninit(struct consdev *cp)
{
        int unit;

        unit = SERUNIT(cp->cn_dev);

        serinit(serdefaultrate);
        serconsole = unit;
        serconsinit = 1;
}

void
serinit(int rate)
{
        int s;

        s = splser();
        /*
         * might want to fiddle with the CIA later ???
         */
        custom.serper = (rate>=110 ? SERBRD(rate) : 0);
        splx(s);
}

int
sercngetc(dev_t dev)
{
        u_short stat;
        int c, s;

        s = splser();
        /*
         * poll
         */
        while (((stat = custom.serdatr & 0xffff) & SERDATRF_RBF) == 0)
                ;

        c = stat & 0xff;
        /*
         * clear interrupt
         */
        custom.intreq = INTF_RBF;
        splx(s);

        return(c);
}

/*
 * Console kernel output character routine.
 */
void
sercnputc(dev_t dev, int c)
{
        register int timo;
        int s;

        s = splhigh();

        if (serconsinit == 0) {
                (void)serinit(serdefaultrate);
                serconsinit = 1;
        }

        /*
         * wait for any pending transmission to finish
         */
        timo = 50000;
        while (!(custom.serdatr & SERDATRF_TBE) && --timo);

        /*
         * transmit char.
         */
        custom.serdat = (c & 0xff) | 0x100;

        /*
         * wait for this transmission to complete
         */
        timo = 1500000;
        while (!(custom.serdatr & SERDATRF_TBE) && --timo)
                ;

        /*
         * Wait for the device (my vt100..) to process the data, since we
         * don't do flow-control with cnputc
         */
        for (timo = 0; timo < 30000; timo++)
                ;

        /*
         * We set TBE so that ser_outintr() is called right after to check
         * whether there still are chars to process.
         * We used to clear this, but it hung the tty output if the kernel
         * output a char while userland did on the same serial port.
         */
        custom.intreq = INTF_SETCLR | INTF_TBE;
        splx(s);
}

void
sercnpollc(dev_t dev, int on)
{
}
#endif