From 4e2e9714c65149d74c0d51f529869cbb80f91351 Mon Sep 17 00:00:00 2001 From: briggs Date: Sun, 26 May 1996 19:02:15 +0000 Subject: Missed a few files in the previous updates. --- sys/arch/mac68k/dev/z8530tty.c | 1433 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1433 insertions(+) create mode 100644 sys/arch/mac68k/dev/z8530tty.c (limited to 'sys/arch/mac68k/dev/z8530tty.c') diff --git a/sys/arch/mac68k/dev/z8530tty.c b/sys/arch/mac68k/dev/z8530tty.c new file mode 100644 index 00000000000..fa4cb3274de --- /dev/null +++ b/sys/arch/mac68k/dev/z8530tty.c @@ -0,0 +1,1433 @@ +/* $OpenBSD: z8530tty.c,v 1.1 1996/05/26 19:02:12 briggs Exp $ */ +/* $NetBSD: z8530tty.c,v 1.2 1996/05/23 02:06:53 briggs Exp $ */ + +/* + * Copyright (c) 1994 Gordon W. Ross + * Copyright (c) 1992, 1993 + * The Regents of the University of California. All rights reserved. + * + * This software was developed by the Computer Systems Engineering group + * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and + * contributed to Berkeley. + * + * All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Lawrence Berkeley Laboratory. + * + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. 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. + * + * @(#)zs.c 8.1 (Berkeley) 7/19/93 + */ + +/* + * Zilog Z8530 Dual UART driver (tty interface) + * + * This is the "slave" driver that will be attached to + * the "zsc" driver for plain "tty" async. serial lines. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* #include */ +#include "z8530reg.h" +#include + +#ifdef KGDB +extern int zs_check_kgdb(); +#endif + +/* + * Make this an option variable one can patch. + * But be warned: this must be a power of 2! + */ +int zstty_rbuf_size = ZSTTY_RING_SIZE; + +/* This should usually be 3/4 of ZSTTY_RING_SIZE */ +int zstty_rbuf_hiwat = (ZSTTY_RING_SIZE - (ZSTTY_RING_SIZE >> 2)); + +struct zstty_stats z8530tty_stats; + + +/* Definition of the driver for autoconfig. */ +static int zstty_match(struct device *, void *, void *); +static void zstty_attach(struct device *, struct device *, void *); + +struct cfattach zstty_ca = { + sizeof(struct zstty_softc), zstty_match, zstty_attach +}; + +struct cfdriver zstty_cd = { + NULL, "zstty", DV_TTY +}; + +struct zsops zsops_tty; + +/* Routines called from other code. */ +cdev_decl(zs); /* open, close, read, write, ioctl, stop, ... */ + +static void zsstart __P((struct tty *)); +static int zsparam __P((struct tty *, struct termios *)); +static void zs_modem __P((struct zstty_softc *zst, int onoff)); +static int zshwiflow __P((struct tty *, int)); +static void zs_hwiflow __P((struct zstty_softc *, int)); +static int zsgetbaud __P((register struct zs_chanstate *, + register int *rate, register int *tc, register u_char *rr4, + register u_char *rr11, register u_char *rr14, + register int *source, register int *sourceflag)); + +/* + * zstty_match: how is this zs channel configured? + */ +int +zstty_match(parent, match, aux) + struct device *parent; + void *match, *aux; +{ + struct cfdata *cf = match; + struct zsc_attach_args *args = aux; + + /* Exact match is better than wildcard. */ + if (cf->cf_loc[0] == args->channel) + return 2; + + /* This driver accepts wildcard. */ + if (cf->cf_loc[0] == -1) + return 1; + + return 0; +} + +void +zstty_attach(parent, self, aux) + struct device *parent, *self; + void *aux; + +{ + struct zsc_softc *zsc = (void *) parent; + struct zstty_softc *zst = (void *) self; + struct zsc_attach_args *args = aux; + struct zs_chanstate *cs; + struct cfdata *cf; + struct tty *tp; + int channel, tty_unit; + dev_t dev; + + cf = zst->zst_dev.dv_cfdata; + tty_unit = zst->zst_dev.dv_unit; + channel = args->channel; + cs = &zsc->zsc_cs[channel]; + cs->cs_private = zst; + cs->cs_ops = &zsops_tty; + + zst->zst_cs = cs; + zst->zst_swflags = cf->cf_flags; /* softcar, etc. */ + zst->zst_hwflags = args->hwflags; + + zst->zst_cflag = ZSTTY_DEF_CFLAG; /* set up defaults */ + zst->zst_iflag = TTYDEF_IFLAG; /* an ioctl can change */ + zst->zst_lflag = TTYDEF_LFLAG; /* these values, modifying */ + zst->zst_oflag = TTYDEF_OFLAG; /* initial defaults */ + zst->zst_ispeed = zst->zst_ospeed = cs->cs_defspeed; + /* zst_cc set after tty is malloc'd */ + + dev = makedev(ZSTTY_MAJOR, tty_unit); + + if (zst->zst_swflags) + printf(" flags 0x%x", zst->zst_swflags); + + if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE) + printf(" (console)"); + else { +#ifdef KGDB + /* + * Allow kgdb to "take over" this port. If this port is + * NOT the kgdb port, zs_check_kgdb() will return zero. + * If it IS the kgdb port, it will print "kgdb,...\n" + * and then return non-zero. + */ + if (zs_check_kgdb(cs, dev)) { + /* + * This is the kgdb port (exclusive use) + * so skip the normal attach code. + */ + return; + } +#endif + } + + tp = ttymalloc(); + tp->t_dev = dev; + tp->t_oproc = zsstart; + tp->t_param = zsparam; + tp->t_hwiflow = zshwiflow; + ttychars(tp); + bcopy(tp->t_cc, zst->zst_cc, sizeof(tp->t_cc)); + + zst->zst_tty = tp; + zst->zst_rbhiwat = zstty_rbuf_size; /* impossible value */ + zst->zst_ringmask = zstty_rbuf_size - 1; + zst->zst_rbuf = malloc(zstty_rbuf_size * sizeof(zst->zst_rbuf[0]), + M_DEVBUF, M_WAITOK); + + zstty_mdattach(zsc, zst, cs, tp); /*let the md code customize stuff */ + + if (zst->zst_hwflags & (ZS_HWFLAG_IGCTS | ZS_HWFLAG_IGDCD)) { + printf("\n Ignoring "); + switch (zst->zst_hwflags & (ZS_HWFLAG_IGCTS | ZS_HWFLAG_IGDCD)) { + case ZS_HWFLAG_IGCTS: + printf("CTS line "); break; + case ZS_HWFLAG_IGDCD: + printf("DCD line "); break; + default: + printf("CTS and DCD lines "); + } + } + + printf("\n"); + /* + * Hardware init + */ + if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE) { + /* This unit is the console. */ + zst->zst_swflags |= TIOCFLAG_SOFTCAR; + /* Call _param so interrupts get enabled. */ + bcopy(&zst->zst_termios, &tp->t_termios, sizeof(struct termios)); + /* copy the whole termios in as the first "first open" won't + * do it since the speed != 0 */ + cs->cs_defspeed = zs_getspeed(cs); + tp->t_ispeed = cs->cs_defspeed; + tp->t_ospeed = cs->cs_defspeed; + (void) zsparam(tp, &tp->t_termios); + } else { + /* Not the console; may need reset. */ + int reset, s; + reset = (channel == 0) ? + ZSWR9_A_RESET : ZSWR9_B_RESET; + s = splzs(); + zs_write_reg(cs, 9, reset); + splx(s); + } + + /* + * Initialize state of modem control lines (DTR). + * If softcar is set, turn on DTR now and leave it. + * otherwise, turn off DTR now, and raise in open. + * (Keeps modem from answering too early.) + */ + zs_modem(zst, (zst->zst_swflags & TIOCFLAG_SOFTCAR) ? 1 : 0); +} + + +/* + * Return pointer to our tty. + */ +struct tty * +zstty(dev) + dev_t dev; +{ + struct zstty_softc *zst; + int unit = minor(dev); + +#ifdef DIAGNOSTIC + if (unit >= zstty_cd.cd_ndevs) + panic("zstty"); +#endif + zst = zstty_cd.cd_devs[unit]; + return (zst->zst_tty); +} + + +/* + * Open a zs serial (tty) port. + */ +int +zsopen(dev, flags, mode, p) + dev_t dev; + int flags; + int mode; + struct proc *p; +{ + register struct tty *tp; + register struct zs_chanstate *cs; + struct zstty_softc *zst; + int error, s, unit; + + unit = minor(dev); + if (unit >= zstty_cd.cd_ndevs) + return (ENXIO); + zst = zstty_cd.cd_devs[unit]; + if (zst == NULL) + return (ENXIO); + tp = zst->zst_tty; + cs = zst->zst_cs; + +#ifdef ZSTTYDEBUG + zsprintf("zs_open to channel at %p\n",cs->cs_reg_csr); +#endif + + /* If KGDB took the line, then tp==NULL */ + if (tp == NULL) + return (EBUSY); + + /* It's simpler to do this up here. */ + if (((tp->t_state & (TS_ISOPEN | TS_XCLUDE)) + == (TS_ISOPEN | TS_XCLUDE)) + && (p->p_ucred->cr_uid != 0) ) + { + return (EBUSY); + } + + s = spltty(); + + if ((tp->t_state & TS_ISOPEN) == 0) { + if ((tp->t_ispeed == 0) || (zst->zst_resetdef)) { + /* First open. Executed if either the tty + * was uninitialized, or if we choose to + * reset defaults w/ each open. */ + bcopy(&zst->zst_termios, &tp->t_termios, + sizeof(struct termios)); + if (zst->zst_swflags & TIOCFLAG_CLOCAL) + tp->t_cflag |= CLOCAL; + if (zst->zst_swflags & TIOCFLAG_CRTSCTS) + tp->t_cflag |= CRTSCTS; + if (zst->zst_swflags & TIOCFLAG_MDMBUF) + tp->t_cflag |= MDMBUF; + } + (void) zsparam(tp, &tp->t_termios); + ttsetwater(tp); + /* Flush any pending input. */ + zst->zst_rbget = zst->zst_rbput; + zs_iflush(cs); /* XXX */ + /* Turn on DTR */ + zs_modem(zst, 1); + if (zst->zst_swflags & TIOCFLAG_SOFTCAR) { + tp->t_state |= TS_CARR_ON; + } + } + error = 0; + + /* Wait for carrier. */ +#ifdef ZSTTYDEBUG + zsprintf("wait for carrier...\n"); +#endif + for (;;) { + + if (zst->zst_hwflags & ZS_HWFLAG_IGDCD) { + tp->t_state |= TS_CARR_ON; + break; + } + + /* Might never get status intr if carrier already on. */ + cs->cs_rr0 = zs_read_csr(cs); + if (cs->cs_rr0 & ZSRR0_DCD) { + tp->t_state |= TS_CARR_ON; + break; + } + + if ((tp->t_state & TS_CARR_ON) || + (tp->t_cflag & CLOCAL) || + (flags & O_NONBLOCK) ) + { + break; + } + + tp->t_state |= TS_WOPEN; + error = ttysleep(tp, (caddr_t)&tp->t_rawq, + TTIPRI | PCATCH, ttopen, 0); + if (error) { + if ((tp->t_state & TS_ISOPEN) == 0) { + /* Never get here with softcar */ + zs_modem(zst, 0); + tp->t_state &= ~TS_WOPEN; + ttwakeup(tp); + } + break; + } + } + + splx(s); + +#ifdef ZSTTYDEBUG + zsprintf("...carrier %s\n", + (tp->t_state & TS_CARR_ON) ? "on" : "off"); +#endif + + if (error == 0) + error = linesw[tp->t_line].l_open(dev, tp); + + return (error); +} + +/* + * Close a zs serial port. + */ +int +zsclose(dev, flags, mode, p) + dev_t dev; + int flags; + int mode; + struct proc *p; +{ + struct zstty_softc *zst; + register struct zs_chanstate *cs; + register struct tty *tp; + int hup; + +#ifdef ZSTTYDEBUG + zsprintf("zs_close\n"); +#endif + + zst = zstty_cd.cd_devs[minor(dev)]; + cs = zst->zst_cs; + tp = zst->zst_tty; + + /* XXX This is for cons.c. */ + if ((tp->t_state & TS_ISOPEN) == 0) + return 0; + + (*linesw[tp->t_line].l_close)(tp, flags); + hup = tp->t_cflag & HUPCL; + if (zst->zst_swflags & TIOCFLAG_SOFTCAR) + hup = 0; + if (hup) { + zs_modem(zst, 0); + /* hold low for 1 second */ + (void) tsleep((caddr_t)cs, TTIPRI, ttclos, hz); + } + if (cs->cs_creg[5] & ZSWR5_BREAK) { + zs_break(cs, 0); + } + /* XXX - turn off interrupts? */ + + ttyclose(tp); + return (0); +} + +/* + * Read/write zs serial port. + */ +int +zsread(dev, uio, flags) + dev_t dev; + struct uio *uio; + int flags; +{ + register struct zstty_softc *zst; + register struct tty *tp; + + zst = zstty_cd.cd_devs[minor(dev)]; + tp = zst->zst_tty; + return (linesw[tp->t_line].l_read(tp, uio, flags)); +} + +int +zswrite(dev, uio, flags) + dev_t dev; + struct uio *uio; + int flags; +{ + register struct zstty_softc *zst; + register struct tty *tp; + + zst = zstty_cd.cd_devs[minor(dev)]; + tp = zst->zst_tty; + return (linesw[tp->t_line].l_write(tp, uio, flags)); +} + +#define TIOCFLAG_ALL (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | \ + TIOCFLAG_CRTSCTS | TIOCFLAG_MDMBUF ) + +int +zsioctl(dev, cmd, data, flag, p) + dev_t dev; + u_long cmd; + caddr_t data; + int flag; + struct proc *p; +{ + register struct zstty_softc *zst; + register struct zs_chanstate *cs; + register struct tty *tp; + register int error, tmp; + + zst = zstty_cd.cd_devs[minor(dev)]; + cs = zst->zst_cs; + tp = zst->zst_tty; + + error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); + if (error >= 0) + return (error); + error = ttioctl(tp, cmd, data, flag, p); + if (error >= 0) + return (error); + error = zsmdioctl(tp, cmd, data, flag, p); + if (error >= 0) + return (error); + + switch (cmd) { + + case TIOCSBRK: + zs_break(cs, 1); + break; + + case TIOCCBRK: + zs_break(cs, 0); + break; + + case TIOCGFLAGS: + *(int *)data = zst->zst_swflags; + break; + + case TIOCSFLAGS: + error = suser(p->p_ucred, &p->p_acflag); + if (error != 0) + return (EPERM); + tmp = *(int *)data; + /* Check for random bits... */ + if (tmp & ~TIOCFLAG_ALL) + return(EINVAL); + /* Silently enforce softcar on the console. */ + if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE) + tmp |= TIOCFLAG_SOFTCAR; + /* These flags take effect during open. */ + zst->zst_swflags = tmp; + break; + + case TIOCSDTR: + zs_modem(zst, 1); + break; + + case TIOCCDTR: + zs_modem(zst, 0); + break; + +#if 0 + case SetSafeOpen: + error = suser(p->p_ucred, &p->p_acflag); + if (error != 0) + return (EPERM); + zst->zst_resetdef = 1; + break; + + case ClearSafeOpen: + error = suser(p->p_ucred, &p->p_acflag); + if (error != 0) + return (EPERM); + zst->zst_resetdef = 0; + break; + + case SetOpenDefaults: + error = suser(p->p_ucred, &p->p_acflag); + if (error != 0) + return (EPERM); + bcopy(&tp->t_termios, &zst->zst_termios, \ + sizeof(struct termios)); + break; +#endif + + case TIOCMSET: + case TIOCMBIS: + case TIOCMBIC: + case TIOCMGET: + default: + return (ENOTTY); + } + return (0); +} + +/* + * Start or restart transmission. + */ +static void +zsstart(tp) + register struct tty *tp; +{ + register struct zstty_softc *zst; + register struct zs_chanstate *cs; + register int s, nch; + + zst = zstty_cd.cd_devs[minor(tp->t_dev)]; + cs = zst->zst_cs; + + s = spltty(); + + /* + * If currently active or delaying, no need to do anything. + */ + if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) + goto out; + + /* + * If under CRTSCTS hfc and halted, do nothing + */ + if (tp->t_cflag & CRTSCTS) + if (zst->zst_tx_stopped) + goto out; + + /* + * If there are sleepers, and output has drained below low + * water mark, awaken. + */ + if (tp->t_outq.c_cc <= tp->t_lowat) { + if (tp->t_state & TS_ASLEEP) { + tp->t_state &= ~TS_ASLEEP; + wakeup((caddr_t)&tp->t_outq); + } + selwakeup(&tp->t_wsel); + } + + nch = ndqb(&tp->t_outq, 0); /* XXX */ + if (nch) { + register char *p = tp->t_outq.c_cf; + + /* mark busy, enable tx done interrupts, & send first byte */ + tp->t_state |= TS_BUSY; + (void) splzs(); + + cs->cs_preg[1] |= ZSWR1_TIE; + cs->cs_creg[1] = cs->cs_preg[1]; + zs_write_reg(cs, 1, cs->cs_creg[1]); + zs_write_data(cs, *p); + zst->zst_tba = p + 1; + zst->zst_tbc = nch - 1; + } else { + /* + * Nothing to send, turn off transmit done interrupts. + * This is useful if something is doing polled output. + */ + (void) splzs(); + cs->cs_preg[1] &= ~ZSWR1_TIE; + cs->cs_creg[1] = cs->cs_preg[1]; + zs_write_reg(cs, 1, cs->cs_creg[1]); + } +out: + splx(s); +} + +/* + * Stop output, e.g., for ^S or output flush. + */ +int +zsstop(tp, flag) + struct tty *tp; + int flag; +{ + register struct zstty_softc *zst; + register struct zs_chanstate *cs; + register int s; + + zst = zstty_cd.cd_devs[minor(tp->t_dev)]; + cs = zst->zst_cs; + + s = splzs(); + if (tp->t_state & TS_BUSY) { + /* + * Device is transmitting; must stop it. + */ + zst->zst_tbc = 0; + zst->zst_heldtbc = 0; /* XXX */ + if ((tp->t_state & TS_TTSTOP) == 0) + tp->t_state |= TS_FLUSH; + } + splx(s); + return (0); +} + +#ifndef ZS_TOLERANCE +#define ZS_TOLERANCE 50 +/* 5% in tenths of a % */ +#endif + +/* + * Search through the signal sources in the channel, and + * pick the best one for the baud rate requested. Return + * a -1 if not achievable in tolerance. Otherwise ret 0 + * and fill in the values. + * + * This routine draws inspiration from the Atari port's zs.c + * driver in NetBSD1.1 which did the same type of source switching. + * Tolerance code inspired by comspeed routine in isa/com.c. + * + * By Bill Studenmund, 1996-05-12 + */ +static int +zsgetbaud(cs, rate, tc, rr4, rr11, rr14, source, sourceflag) + register struct zs_chanstate *cs; + register int *rate, *tc, *source, *sourceflag; + register u_char *rr4, *rr11, *rr14; +{ + int i, tc0, tc1, s, sf, rate0, rate1, err, tol; + + s = -1; /* no valid source yet */ + tol = ZS_TOLERANCE; + + /* + * Step through all the sources and see which one matches + * the best. A source has to match BETTER than tol to be chosen. + * Thus if two sources give the same error, the first one will be + * chosen. Also, allow for the possability that one source might run + * both the BRG and the direct divider (i.e. RTxC). + */ + for (i=0; i< cs->cs_clock_count; i++) { + if (cs->cs_clocks[i].clk <= 0) + continue; /* skip non-existant or bad clocks */ + if (cs->cs_clocks[i].flags & ZSC_BRG) { + /* check out BRG at /16 */ + tc1 = BPS_TO_TCONST(cs->cs_clocks[i].clk >> 4, rate[0]); + if (tc1 >= 0) { + rate1 = TCONST_TO_BPS(cs->cs_clocks[i].clk >> 4, tc1); + err = abs(((rate1 - rate[0])*1000)/rate[0]); + if (err < tol) { + tol = err; + s = i; + sf = cs->cs_clocks[i].flags & ~ZSC_DIV; + tc0 = tc1; + rate0 = rate1; + } + } + } + if (cs->cs_clocks[i].flags & ZSC_DIV) { + /* + * Check out either /1, /16, /32, or /64 + * Note: for /1, you'd better be using a synchronized + * clock! + */ + int b0 = cs->cs_clocks[i].clk, e0 = abs(b0-rate[0]); + int b1 = b0 >> 4, e1 = abs(b1-rate[0]); + int b2 = b1 >> 1, e2 = abs(b2-rate[0]); + int b3 = b2 >> 1, e3 = abs(b3-rate[0]); + + if (e0 < e1 && e0 < e2 && e0 < e3) { + err = e0; + rate1 = b0; + tc1 = ZSWR4_CLK_X1; + } else if (e0 > e1 && e1 < e2 && e1 < e3) { + err = e1; + rate1 = b1; + tc1 = ZSWR4_CLK_X16; + } else if (e0 > e2 && e1 > e2 && e2 < e3) { + err = e2; + rate1 = b2; + tc1 = ZSWR4_CLK_X32; + } else { + err = e3; + rate1 = b3; + tc1 = ZSWR4_CLK_X64; + } + + err = (err * 1000)/rate[0]; + if (err < tol) { + tol = err; + s = i; + sf = cs->cs_clocks[i].flags & ~ZSC_BRG; + tc0 = tc1; + rate0 = rate1; + } + } + } +#ifdef ZSTTYDEBUG + zsprintf("Checking for rate %d. Found source #%d.\n",rate[0], s); +#endif + if (s == -1) return (-1); + /* + * Now we have a source, so set it up. + */ + *source = s; + *sourceflag = sf; + rate[0] = rate0; + if (sf & ZSC_BRG) { + *rr4 = ZSWR4_CLK_X16; + *rr11= ZSWR11_RXCLK_BAUD | ZSWR11_TXCLK_BAUD; + if (sf & ZSC_PCLK) { + *rr14 = ZSWR14_BAUD_ENA | ZSWR14_BAUD_FROM_PCLK; + } else { + *rr14 = ZSWR14_BAUD_ENA; + } + *tc = tc0; + } else { + *rr4 = tc0; + if (sf & ZSC_RTXDIV) { + *rr11 = ZSWR11_RXCLK_RTXC | ZSWR11_TXCLK_RTXC; + } else { + *rr11 = ZSWR11_RXCLK_TRXC | ZSWR11_TXCLK_TRXC; + } + *rr14= 0; + *tc = 0xffff; + } +#ifdef ZSTTYDEBUG + zsprintf("Rate is %7d, tc is %7d, source no. %2d, flags %4x\n", \ + *rate, *tc, *source, *sourceflag); + zsprintf("Registers are: 4 %x, 11 %x, 14 %x\n\n", *rr4, *rr11, *rr14); +#endif + return (0); +} + +/* + * Set ZS tty parameters from termios. + * XXX - Should just copy the whole termios after + * making sure all the changes could be done. + * XXX - Only whack the UART when params change... + */ +static int +zsparam(tp, t) + register struct tty *tp; + register struct termios *t; +{ + register struct zstty_softc *zst; + register struct zs_chanstate *cs; + register int s, cflag, hfc; + u_char tmp3, tmp4, tmp5, tmp11, tmp14; + int bps, tconst, src, srcflag; + + zst = zstty_cd.cd_devs[minor(tp->t_dev)]; + cs = zst->zst_cs; + + bps = t->c_ospeed; + if (bps < 0 || (t->c_ispeed && t->c_ispeed != bps)) + return (EINVAL); + if (bps == 0) { + /* stty 0 => drop DTR and RTS */ + zs_modem(zst, 0); + return (0); + } + if (0 > zsgetbaud(cs, &bps, &tconst, &tmp4, &tmp11, &tmp14, + &src, &srcflag)) + return (EINVAL); + + tp->t_ispeed = tp->t_ospeed = bps; + cs->cs_psource = src; + cs->cs_pclk_flag = srcflag; + + cflag = t->c_cflag; + + /* + * Make sure we don't enable hfc on a signal line we're ignoring + * + * As we enable CTS interrupts only if we have CRTSCTS, this code + * also effectivly turns off ZSWR15_CTS_IE. + */ + if (zst->zst_hwflags & ZS_HWFLAG_IGDCD) + cflag &= ~MDMBUF; + if (zst->zst_hwflags & ZS_HWFLAG_IGCTS) + cflag &= ~CRTSCTS; + + tp->t_cflag = cflag; + /* + * Block interrupts so that state will not + * be altered until we are done setting it up. + */ + s = splzs(); + + /* + * Initial values in cs_preg are set before + * our attach routine is called. The master + * interrupt enable is handled by zsc.c + */ + + cs->cs_preg[12] = tconst & 255; + cs->cs_preg[13] = tconst >> 8; + + switch (cflag & CSIZE) { + case CS5: + tmp3 = ZSWR3_RX_5; + tmp5 = ZSWR5_TX_5; + break; + case CS6: + tmp3 = ZSWR3_RX_6; + tmp5 = ZSWR5_TX_6; + break; + case CS7: + tmp3 = ZSWR3_RX_7; + tmp5 = ZSWR5_TX_7; + break; + case CS8: + default: + tmp3 = ZSWR3_RX_8; + tmp5 = ZSWR5_TX_8; + break; + } + + cs->cs_preg[3] = tmp3 | ZSWR3_RX_ENABLE; + cs->cs_preg[5] = tmp5 | ZSWR5_TX_ENABLE | ZSWR5_DTR | ZSWR5_RTS; + + tmp4 |= (cflag & CSTOPB ? ZSWR4_TWOSB : ZSWR4_ONESB); + if ((cflag & PARODD) == 0) + tmp4 |= ZSWR4_EVENP; + if (cflag & PARENB) + tmp4 |= ZSWR4_PARENB; + cs->cs_preg[4] = tmp4; + + /* + * Output hardware flow control on the chip is horrendous: + * if carrier detect drops, the receiver is disabled and if + * CTS drops, the transmitter is stoped IN MID CHARACTER! + * Therefore, do not set the HFC bit, and instead use + * the status interrupts to detect CTS changes. + */ + if (cflag & CRTSCTS) { + zst->zst_rbhiwat = zstty_rbuf_hiwat; + cs->cs_preg[15] |= ZSWR15_CTS_IE; + } else { + zst->zst_rbhiwat = zstty_rbuf_size; /* impossible value */ + cs->cs_preg[15] &= ~ZSWR15_CTS_IE; + } + /* Shouldn't the zst_rbhiwat stuff be if (cflag & CHWFLOW) ? wrs */ + + /* + * Disable DCD interrupts if we've been told to ignore + * the DCD pin. Happens on mac68k because the input line for + * DCD can also be used as a clock input. + */ + if (zst->zst_hwflags & ZS_HWFLAG_IGDCD) + cs->cs_preg[15] &= ~ZSWR15_DCD_IE; + else + cs->cs_preg[15] |= ZSWR15_DCD_IE; + + /* + * now find out which line to change for input flow control. + * Important as some ports (mac68k) don't always have input + * flow control when they have output flow control (RTS actually + * controls buffers on the Xmitter output). + */ + hfc = (cflag & CRTSCTS) ? 1 : 0; + hfc |= (cflag & MDMBUF) ? 2 : 0; + + zst->zst_hwimask = zst->zst_hwimasks[hfc]; + if ((zst->zst_rx_blocked) && (zst->zst_hwimask)) + cs->cs_preg[5] &= ~zst->zst_hwimask; + /* make sure we enforce halted-ness */ + + /* XXX check for loss of output blocking if loosing hwi ability? */ + + /* + * If nothing is being transmitted, set up new current values, + * else mark them as pending. + */ + if (cs->cs_heldchange == 0) { + if (tp->t_state & TS_BUSY) { + zst->zst_heldtbc = zst->zst_tbc; + zst->zst_tbc = 0; + cs->cs_heldchange = 0xFF; + } else { + zs_loadchannelregs(cs); + } + } + splx(s); + /* check for ttstart if lost output flow control? XXX */ + return (0); +} + +/* + * Raise or lower modem control (DTR/RTS) signals. If a character is + * in transmission, the change is deferred. + */ +static void +zs_modem(zst, onoff) + struct zstty_softc *zst; + int onoff; +{ + struct zs_chanstate *cs; + struct tty *tp; + int s, bis, and; + + cs = zst->zst_cs; + tp = zst->zst_tty; + + if (onoff) { + bis = ZSWR5_DTR | ZSWR5_RTS; + and = ~0; + } else { + bis = 0; + and = ~(ZSWR5_DTR | ZSWR5_RTS); + } + s = splzs(); + cs->cs_preg[5] = (cs->cs_preg[5] | bis) & and; + if (cs->cs_heldchange == 0) { + if (tp->t_state & TS_BUSY) { + zst->zst_heldtbc = zst->zst_tbc; + zst->zst_tbc = 0; + cs->cs_heldchange = (1<<5); + } else { + cs->cs_creg[5] = cs->cs_preg[5]; + zs_write_reg(cs, 5, cs->cs_creg[5]); + } + } + splx(s); +} + +/* + * Try to block or unblock input using hardware flow-control. + * This is called by kern/tty.c if MDMBUF|CRTSCTS is set, and + * if this function returns non-zero, the TS_TBLOCK flag will + * be set or cleared according to the "stop" arg passed. + */ +int +zshwiflow(tp, stop) + struct tty *tp; + int stop; +{ + register struct zstty_softc *zst; + int s; + + zst = zstty_cd.cd_devs[minor(tp->t_dev)]; + + /* + * This loop checks to see that we can in fact control input. + * If not, then do little except tell the upper layer the truth. + */ + if (zst->zst_hwimask == 0) + if (stop) + return 0; + else + return 1; /* yes, w/o hwi we can unblock input. ;-) */ + + s = splzs(); + if (stop) { + /* + * The tty layer is asking us to block input. + * If we already did it, just return TRUE. + */ + if (zst->zst_rx_blocked) + goto out; + zst->zst_rx_blocked = 1; + z8530tty_stats.tty_block++; + } else { + /* + * The tty layer is asking us to resume input. + * The input ring is always empty by now. + */ + zst->zst_rx_blocked = 0; + z8530tty_stats.tty_unblock++; + } + zs_hwiflow(zst, stop); + out: + splx(s); + return 1; +} + +/* + * Internal version of zshwiflow + * called at splzs + */ +static void +zs_hwiflow(zst, stop) + register struct zstty_softc *zst; + int stop; +{ + register struct zs_chanstate *cs; + register struct tty *tp; + register int bis, and; + + cs = zst->zst_cs; + tp = zst->zst_tty; + + if (stop) { + /* Block input (Lower RTS) */ + bis = 0; + and = ~zst->zst_hwimask; + } else { + /* Unblock input (Raise RTS) */ + bis = zst->zst_hwimask; + and = ~0; + } + + cs->cs_preg[5] = (cs->cs_preg[5] | bis) & and; + if (cs->cs_heldchange == 0) { + if (tp->t_state & TS_BUSY) { + zst->zst_heldtbc = zst->zst_tbc; + zst->zst_tbc = 0; + cs->cs_heldchange = (1<<5); + } else { + cs->cs_creg[5] = cs->cs_preg[5]; + zs_write_reg(cs, 5, cs->cs_creg[5]); + } + } +} + + +/**************************************************************** + * Interface to the lower layer (zscc) + ****************************************************************/ + +static void zstty_rxint __P((register struct zs_chanstate *)); +static void zstty_txint __P((register struct zs_chanstate *)); +static void zstty_stint __P((register struct zs_chanstate *)); +static void zsoverrun __P((struct zstty_softc *, long *, char *)); +static void zstty_softint __P((struct zs_chanstate *)); +/* + * XXX: need to do input flow-control to avoid ring overrun. + */ + +/* + * receiver ready interrupt. + * called at splzs + */ +static void +zstty_rxint(cs) + register struct zs_chanstate *cs; +{ + register struct zstty_softc *zst; + register int cc, put, put_next, ringmask; + register u_char c, rr0, rr1; + register u_short ch_rr1; + + zst = cs->cs_private; + put = zst->zst_rbput; + ringmask = zst->zst_ringmask; + +nextchar: + + /* + * First read the status, because reading the received char + * destroys the status of this char. + */ + rr1 = zs_read_reg(cs, 1); + c = zs_read_data(cs); + ch_rr1 = (c << 8) | rr1; + + if (ch_rr1 & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) { + /* Clear the receive error. */ + zs_write_csr(cs, ZSWR0_RESET_ERRORS); + } + + /* XXX: Check for the stop character? */ + + zst->zst_rbuf[put] = ch_rr1; + put_next = (put + 1) & ringmask; + + /* Would overrun if increment makes (put==get). */ + if (put_next == zst->zst_rbget) { + zst->zst_rx_overrun = 1; + } else { + /* OK, really increment. */ + put = put_next; + } + + /* Keep reading until the FIFO is empty. */ + rr0 = zs_read_csr(cs); + if (rr0 & ZSRR0_RX_READY) + goto nextchar; + + /* Done reading. */ + zst->zst_rbput = put; + + /* + * If ring is getting too full, try to block input. + */ + cc = put - zst->zst_rbget; + if (cc < 0) + cc += zstty_rbuf_size; + if ((cc > zst->zst_rbhiwat) && (zst->zst_rx_blocked == 0)) { + zst->zst_rx_blocked = 1; + zs_hwiflow(zst, 1); + z8530tty_stats.ring_block++; + } + + /* Ask for softint() call. */ + cs->cs_softreq = 1; +} + +/* + * transmitter ready interrupt. (splzs) + */ +static void +zstty_txint(cs) + register struct zs_chanstate *cs; +{ + register struct zstty_softc *zst; + register int count; + + zst = cs->cs_private; + + /* + * If we suspended output for a "held" change, + * then handle that now and resume. + * Do flow-control changes ASAP. + * When the only change is for flow control, + * avoid hitting other registers, because that + * often makes the stupid zs drop input... + */ + if (cs->cs_heldchange) { + if (cs->cs_heldchange == (1<<5)) { + /* Avoid whacking the chip... */ + cs->cs_creg[5] = cs->cs_preg[5]; + zs_write_reg(cs, 5, cs->cs_creg[5]); + } else + zs_loadchannelregs(cs); + cs->cs_heldchange = 0; + count = zst->zst_heldtbc; + } else + count = zst->zst_tbc; + + /* + * If our transmit buffer still has data, + * just send the next character. + */ + if (count > 0) { + /* Send the next char. */ + zst->zst_tbc = --count; + zs_write_data(cs, *zst->zst_tba); + zst->zst_tba++; + return; + } + + zs_write_csr(cs, ZSWR0_RESET_TXINT); + + /* Ask the softint routine for more output. */ + zst->zst_tx_empty = 1; + cs->cs_softreq = 1; +} + +/* + * status change interrupt. (splzs) + */ +static void +zstty_stint(cs) + register struct zs_chanstate *cs; +{ + register struct zstty_softc *zst; + register struct tty *tp; + register u_char rr0; + + zst = cs->cs_private; + tp = zst->zst_tty; + + rr0 = zs_read_csr(cs); + zs_write_csr(cs, ZSWR0_RESET_STATUS); + + /* + * Check here for console break, so that we can abort + * even when interrupts are locking up the machine. + */ + if ((rr0 & ZSRR0_BREAK) && + (zst->zst_hwflags & ZS_HWFLAG_CONABRT)) + { + zs_abort(zst); + return; + } + + /* + * Need to handle CTS output flow control here. + * Output remains stopped as long as either the + * zst_tx_stopped or TS_TTSTOP flag is set. + * Never restart here; the softint routine will + * do that after things are ready to move. + */ + if (((rr0 & ZSRR0_CTS) == 0) && (tp->t_cflag & CRTSCTS)) { + zst->zst_tbc = 0; + zst->zst_heldtbc = 0; + zst->zst_tx_stopped = 1; + } + + cs->cs_rr0_new = rr0; + zst->zst_st_check = 1; + + /* Ask for softint() call. */ + cs->cs_softreq = 1; +} + +/* + * Print out a ring or fifo overrun error message. + */ +static void +zsoverrun(zst, ptime, what) + struct zstty_softc *zst; + long *ptime; + char *what; +{ + + if (*ptime != time.tv_sec) { + *ptime = time.tv_sec; + log(LOG_WARNING, "%s: %s overrun\n", + zst->zst_dev.dv_xname, what); + } +} + +/* + * Software interrupt. Called at zssoft + * + * The main job to be done here is to empty the input ring + * by passing its contents up to the tty layer. The ring is + * always emptied during this operation, therefore the ring + * must not be larger than the space after "high water" in + * the tty layer, or the tty layer might drop our input. + * + * Note: an "input blockage" condition is assumed to exist if + * EITHER the TS_TBLOCK flag or zst_rx_blocked flag is set. + */ +static void +zstty_softint(cs) + struct zs_chanstate *cs; +{ + register struct zstty_softc *zst; + register struct linesw *line; + register struct tty *tp; + register int get, c, s; + int ringmask, overrun; + register u_short ring_data; + register u_char rr0, delta, flag; + + zst = cs->cs_private; + tp = zst->zst_tty; + line = &linesw[tp->t_line]; + ringmask = zst->zst_ringmask; + overrun = 0; + + /* + * Raise to tty priority while servicing the ring. + */ + s = spltty(); + + if (zst->zst_rx_overrun) { + zst->zst_rx_overrun = 0; + zsoverrun(zst, &zst->zst_rotime, "ring"); + } + + /* + * Copy data from the receive ring into the tty layer. + */ + get = zst->zst_rbget; + while (get != zst->zst_rbput) { + ring_data = zst->zst_rbuf[get]; + get = (get + 1) & ringmask; + + if (ring_data & ZSRR1_DO) + overrun++; + /* low byte of ring_data is rr1 */ + c = (ring_data >> 8) & 0xff; + if (ring_data & ZSRR1_FE) + c |= TTY_FE; + if (ring_data & ZSRR1_PE) + c |= TTY_PE; + + line->l_rint(c, tp); + } + zst->zst_rbget = get; + + /* + * If the overrun flag is set now, it was set while + * copying char/status pairs from the ring, which + * means this was a hardware (fifo) overrun. + */ + if (overrun) { + zsoverrun(zst, &zst->zst_fotime, "fifo"); + } + + /* + * We have emptied the input ring. Maybe unblock input. + * Note: an "input blockage" condition is assumed to exist + * when EITHER zst_rx_blocked or the TS_TBLOCK flag is set, + * so unblock here ONLY if TS_TBLOCK has not been set. + */ + if (zst->zst_rx_blocked && ((tp->t_state & TS_TBLOCK) == 0)) { + (void) splzs(); + zst->zst_rx_blocked = 0; + zs_hwiflow(zst, 0); /* unblock input */ + z8530tty_stats.ring_unblock++; + (void) spltty(); + } + + /* + * Do any deferred work for status interrupts. + * The rr0 was saved in the h/w interrupt to + * avoid another splzs in here. + */ + if (zst->zst_st_check) { + zst->zst_st_check = 0; + + rr0 = cs->cs_rr0_new; + delta = rr0 ^ cs->cs_rr0; + cs->cs_rr0 = rr0; + if ((delta & ZSRR0_DCD) && + ~(zst->zst_hwflags & ZS_HWFLAG_IGDCD)) { + c = ((rr0 & ZSRR0_DCD) != 0); + if ((tp->t_cflag & CHWFLOW) == CHWFLOW) { + flag = 1; + tp->t_cflag &= ~MDMBUF; + } else + flag = 0; + if (line->l_modem(tp, c) == 0) + zs_modem(zst, c); + if (flag) + tp->t_cflag |= MDMBUF; + /* + * The above trick hides MDMBUF from the tty layer + * if we also have CRTSCTS; Used as mac68k takes + * the two of them as meaning do CRTSCTS with DCD + * as the hwi line. Just CRTSCTS doesn't have a + * hwi line. + */ + } + if ((delta & ZSRR0_CTS) && (tp->t_cflag & CRTSCTS)) { + /* + * Only do restart here. Stop is handled + * at the h/w interrupt level. + */ + if (rr0 & ZSRR0_CTS) { + zst->zst_tx_stopped = 0; + tp->t_state &= ~TS_TTSTOP; + (*line->l_start)(tp); + } + } + } + + if (zst->zst_tx_empty) { + zst->zst_tx_empty = 0; + tp->t_state &= ~TS_BUSY; + if (tp->t_state & TS_FLUSH) + tp->t_state &= ~TS_FLUSH; + else + ndflush(&tp->t_outq, zst->zst_tba - + (caddr_t) tp->t_outq.c_cf); + line->l_start(tp); + } + + splx(s); +} + +struct zsops zsops_tty = { + zstty_rxint, /* receive char available */ + zstty_stint, /* external/status */ + zstty_txint, /* xmit buffer empty */ + zstty_softint, /* process software interrupt */ +}; + + -- cgit v1.2.3