Annotation of sys/dev/ic/z8530tty.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: z8530tty.c,v 1.16 2006/04/27 19:31:44 deraadt Exp $ */
! 2: /* $NetBSD: z8530tty.c,v 1.13 1996/10/16 20:42:14 gwr Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994 Gordon W. Ross
! 6: * Copyright (c) 1992, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * This software was developed by the Computer Systems Engineering group
! 10: * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
! 11: * contributed to Berkeley.
! 12: *
! 13: * All advertising materials mentioning features or use of this software
! 14: * must display the following acknowledgement:
! 15: * This product includes software developed by the University of
! 16: * California, Lawrence Berkeley Laboratory.
! 17: *
! 18: * Redistribution and use in source and binary forms, with or without
! 19: * modification, are permitted provided that the following conditions
! 20: * are met:
! 21: * 1. Redistributions of source code must retain the above copyright
! 22: * notice, this list of conditions and the following disclaimer.
! 23: * 2. Redistributions in binary form must reproduce the above copyright
! 24: * notice, this list of conditions and the following disclaimer in the
! 25: * documentation and/or other materials provided with the distribution.
! 26: * 3. Neither the name of the University nor the names of its contributors
! 27: * may be used to endorse or promote products derived from this software
! 28: * without specific prior written permission.
! 29: *
! 30: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 31: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 32: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 33: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 34: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 35: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 36: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 37: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 38: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 39: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 40: * SUCH DAMAGE.
! 41: *
! 42: * @(#)zs.c 8.1 (Berkeley) 7/19/93
! 43: */
! 44:
! 45: /*
! 46: * Zilog Z8530 Dual UART driver (tty interface)
! 47: *
! 48: * This is the "slave" driver that will be attached to
! 49: * the "zsc" driver for plain "tty" async. serial lines.
! 50: *
! 51: * Credits, history:
! 52: *
! 53: * The original version of this code was the sparc/dev/zs.c driver
! 54: * as distributed with the Berkeley 4.4 Lite release. Since then,
! 55: * Gordon Ross reorganized the code into the current parent/child
! 56: * driver scheme, separating the Sun keyboard and mouse support
! 57: * into independent child drivers.
! 58: *
! 59: * RTS/CTS flow-control support was a collaboration of:
! 60: * Gordon Ross <gwr@netbsd.org>,
! 61: * Bill Studenmund <wrstuden@loki.stanford.edu>
! 62: * Ian Dall <Ian.Dall@dsto.defence.gov.au>
! 63: */
! 64:
! 65: #include <sys/param.h>
! 66: #include <sys/systm.h>
! 67: #include <sys/proc.h>
! 68: #include <sys/device.h>
! 69: #include <sys/conf.h>
! 70: #include <sys/file.h>
! 71: #include <sys/ioctl.h>
! 72: #include <sys/malloc.h>
! 73: #include <sys/tty.h>
! 74: #include <sys/time.h>
! 75: #include <sys/kernel.h>
! 76: #include <sys/syslog.h>
! 77:
! 78: #include <dev/ic/z8530reg.h>
! 79: #include <machine/z8530var.h>
! 80:
! 81: #ifdef KGDB
! 82: extern int zs_check_kgdb();
! 83: #endif
! 84:
! 85: /*
! 86: * Allow the MD var.h to override the default CFLAG so that
! 87: * console messages during boot come out with correct parity.
! 88: */
! 89: #ifndef ZSTTY_DEF_CFLAG
! 90: #define ZSTTY_DEF_CFLAG TTYDEF_CFLAG
! 91: #endif
! 92:
! 93: /*
! 94: * How many input characters we can buffer.
! 95: * The port-specific var.h may override this.
! 96: * Note: must be a power of two!
! 97: */
! 98: #ifndef ZSTTY_RING_SIZE
! 99: #define ZSTTY_RING_SIZE 2048
! 100: #endif
! 101:
! 102: /*
! 103: * Make this an option variable one can patch.
! 104: * But be warned: this must be a power of 2!
! 105: */
! 106: int zstty_rbuf_size = ZSTTY_RING_SIZE;
! 107:
! 108: /* This should usually be 3/4 of ZSTTY_RING_SIZE */
! 109: int zstty_rbuf_hiwat = (ZSTTY_RING_SIZE - (ZSTTY_RING_SIZE >> 2));
! 110:
! 111: struct zstty_softc {
! 112: struct device zst_dev; /* required first: base device */
! 113: struct tty *zst_tty;
! 114: struct zs_chanstate *zst_cs;
! 115:
! 116: int zst_hwflags; /* see z8530var.h */
! 117: int zst_swflags; /* TIOCFLAG_SOFTCAR, ... <ttycom.h> */
! 118:
! 119: /*
! 120: * Printing an overrun error message often takes long enough to
! 121: * cause another overrun, so we only print one per second.
! 122: */
! 123: long zst_rotime; /* time of last ring overrun */
! 124: long zst_fotime; /* time of last fifo overrun */
! 125:
! 126: /*
! 127: * The receive ring buffer.
! 128: */
! 129: int zst_rbget; /* ring buffer `get' index */
! 130: volatile int zst_rbput; /* ring buffer `put' index */
! 131: int zst_ringmask;
! 132: int zst_rbhiwat;
! 133:
! 134: u_short *zst_rbuf; /* rr1, data pairs */
! 135:
! 136: /*
! 137: * The transmit byte count and address are used for pseudo-DMA
! 138: * output in the hardware interrupt code. PDMA can be suspended
! 139: * to get pending changes done; heldtbc is used for this. It can
! 140: * also be stopped for ^S; this sets TS_TTSTOP in tp->t_state.
! 141: */
! 142: int zst_tbc; /* transmit byte count */
! 143: caddr_t zst_tba; /* transmit buffer address */
! 144: int zst_heldtbc; /* held tbc while xmission stopped */
! 145:
! 146: /* Flags to communicate with zstty_softint() */
! 147: volatile char zst_rx_blocked; /* input block at ring */
! 148: volatile char zst_rx_overrun; /* ring overrun */
! 149: volatile char zst_tx_busy; /* working on an output chunk */
! 150: volatile char zst_tx_done; /* done with one output chunk */
! 151: volatile char zst_tx_stopped; /* H/W level stop (lost CTS) */
! 152: volatile char zst_st_check; /* got a status interrupt */
! 153: char pad[2];
! 154: };
! 155:
! 156:
! 157: /* Definition of the driver for autoconfig. */
! 158: static int zstty_match(struct device *, void *, void *);
! 159: static void zstty_attach(struct device *, struct device *, void *);
! 160:
! 161: struct cfattach zstty_ca = {
! 162: sizeof(struct zstty_softc), zstty_match, zstty_attach
! 163: };
! 164:
! 165: struct cfdriver zstty_cd = {
! 166: NULL, "zstty", DV_TTY
! 167: };
! 168:
! 169: struct zsops zsops_tty;
! 170:
! 171: /* Routines called from other code. */
! 172: cdev_decl(zs); /* open, close, read, write, ioctl, stop, ... */
! 173:
! 174: static void zsstart(struct tty *);
! 175: static int zsparam(struct tty *, struct termios *);
! 176: static void zs_modem(struct zstty_softc *zst, int onoff);
! 177: static int zshwiflow(struct tty *, int);
! 178: static void zs_hwiflow(struct zstty_softc *, int);
! 179: static void zstty_rxint(register struct zs_chanstate *);
! 180: static void zstty_txint(register struct zs_chanstate *);
! 181: static void zstty_stint(register struct zs_chanstate *);
! 182: static void zstty_softint(struct zs_chanstate *);
! 183: static void zsoverrun(struct zstty_softc *, long *, char *);
! 184: /*
! 185: * zstty_match: how is this zs channel configured?
! 186: */
! 187: int
! 188: zstty_match(parent, match, aux)
! 189: struct device *parent;
! 190: void *match, *aux;
! 191: {
! 192: struct cfdata *cf = match;
! 193: struct zsc_attach_args *args = aux;
! 194:
! 195: /* Exact match is better than wildcard. */
! 196: if (cf->cf_loc[0] == args->channel)
! 197: return 2;
! 198:
! 199: /* This driver accepts wildcard. */
! 200: if (cf->cf_loc[0] == -1)
! 201: return 1;
! 202:
! 203: return 0;
! 204: }
! 205:
! 206: void
! 207: zstty_attach(parent, self, aux)
! 208: struct device *parent, *self;
! 209: void *aux;
! 210:
! 211: {
! 212: struct zsc_softc *zsc = (void *) parent;
! 213: struct zstty_softc *zst = (void *) self;
! 214: struct zsc_attach_args *args = aux;
! 215: struct zs_chanstate *cs;
! 216: struct cfdata *cf;
! 217: struct tty *tp;
! 218: int channel, tty_unit;
! 219: dev_t dev;
! 220:
! 221: cf = zst->zst_dev.dv_cfdata;
! 222: tty_unit = zst->zst_dev.dv_unit;
! 223: channel = args->channel;
! 224: cs = &zsc->zsc_cs[channel];
! 225: cs->cs_private = zst;
! 226: cs->cs_ops = &zsops_tty;
! 227:
! 228: zst->zst_cs = cs;
! 229: zst->zst_swflags = cf->cf_flags; /* softcar, etc. */
! 230: zst->zst_hwflags = args->hwflags;
! 231: dev = makedev(ZSTTY_MAJOR, tty_unit);
! 232:
! 233: if (zst->zst_swflags)
! 234: printf(" flags 0x%x", zst->zst_swflags);
! 235:
! 236: if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE)
! 237: printf(" (console)");
! 238: else {
! 239: #ifdef KGDB
! 240: /*
! 241: * Allow kgdb to "take over" this port. If this port is
! 242: * NOT the kgdb port, zs_check_kgdb() will return zero.
! 243: * If it IS the kgdb port, it will print "kgdb,...\n"
! 244: * and then return non-zero.
! 245: */
! 246: if (zs_check_kgdb(cs, dev)) {
! 247: /*
! 248: * This is the kgdb port (exclusive use)
! 249: * so skip the normal attach code.
! 250: */
! 251: return;
! 252: }
! 253: #endif
! 254: }
! 255: printf("\n");
! 256:
! 257: tp = ttymalloc();
! 258: tp->t_dev = dev;
! 259: tp->t_oproc = zsstart;
! 260: tp->t_param = zsparam;
! 261: tp->t_hwiflow = zshwiflow;
! 262:
! 263: zst->zst_tty = tp;
! 264: zst->zst_rbhiwat = zstty_rbuf_size; /* impossible value */
! 265: zst->zst_ringmask = zstty_rbuf_size - 1;
! 266: zst->zst_rbuf = malloc(zstty_rbuf_size * sizeof(zst->zst_rbuf[0]),
! 267: M_DEVBUF, M_WAITOK);
! 268:
! 269: /*
! 270: * Hardware init
! 271: */
! 272: if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE) {
! 273: /* This unit is the console. */
! 274: zst->zst_swflags |= TIOCFLAG_SOFTCAR;
! 275: /* Call _param so interrupts get enabled. */
! 276: cs->cs_defspeed = zs_getspeed(cs);
! 277: tp->t_ispeed = cs->cs_defspeed;
! 278: tp->t_ospeed = cs->cs_defspeed;
! 279: tp->t_cflag = ZSTTY_DEF_CFLAG;
! 280: (void) zsparam(tp, &tp->t_termios);
! 281: } else {
! 282: /* Not the console; may need reset. */
! 283: int reset, s;
! 284: reset = (channel == 0) ?
! 285: ZSWR9_A_RESET : ZSWR9_B_RESET;
! 286: s = splzs();
! 287: zs_write_reg(cs, 9, reset);
! 288: splx(s);
! 289: }
! 290:
! 291: /*
! 292: * Initialize state of modem control lines (DTR).
! 293: * If softcar is set, turn on DTR now and leave it.
! 294: * otherwise, turn off DTR now, and raise in open.
! 295: * (Keeps modem from answering too early.)
! 296: */
! 297: zs_modem(zst, (zst->zst_swflags & TIOCFLAG_SOFTCAR) ? 1 : 0);
! 298: }
! 299:
! 300:
! 301: /*
! 302: * Return pointer to our tty.
! 303: */
! 304: struct tty *
! 305: zstty(dev)
! 306: dev_t dev;
! 307: {
! 308: struct zstty_softc *zst;
! 309: int unit = minor(dev);
! 310:
! 311: #ifdef DIAGNOSTIC
! 312: if (unit >= zstty_cd.cd_ndevs)
! 313: panic("zstty");
! 314: #endif
! 315: zst = zstty_cd.cd_devs[unit];
! 316: return (zst->zst_tty);
! 317: }
! 318:
! 319:
! 320: /*
! 321: * Open a zs serial (tty) port.
! 322: */
! 323: int
! 324: zsopen(dev, flags, mode, p)
! 325: dev_t dev;
! 326: int flags;
! 327: int mode;
! 328: struct proc *p;
! 329: {
! 330: register struct tty *tp;
! 331: register struct zs_chanstate *cs;
! 332: struct zstty_softc *zst;
! 333: int error, s, unit;
! 334:
! 335: unit = minor(dev);
! 336: if (unit >= zstty_cd.cd_ndevs)
! 337: return (ENXIO);
! 338: zst = zstty_cd.cd_devs[unit];
! 339: if (zst == NULL)
! 340: return (ENXIO);
! 341: tp = zst->zst_tty;
! 342: cs = zst->zst_cs;
! 343:
! 344: /* If KGDB took the line, then tp==NULL */
! 345: if (tp == NULL)
! 346: return (EBUSY);
! 347:
! 348: /* It's simpler to do this up here. */
! 349: if (((tp->t_state & (TS_ISOPEN | TS_XCLUDE))
! 350: == (TS_ISOPEN | TS_XCLUDE))
! 351: && (p->p_ucred->cr_uid != 0) )
! 352: {
! 353: return (EBUSY);
! 354: }
! 355:
! 356: s = spltty();
! 357:
! 358: if ((tp->t_state & TS_ISOPEN) == 0) {
! 359: /* First open. */
! 360: ttychars(tp);
! 361: tp->t_iflag = TTYDEF_IFLAG;
! 362: tp->t_oflag = TTYDEF_OFLAG;
! 363: tp->t_cflag = ZSTTY_DEF_CFLAG;
! 364: if (zst->zst_swflags & TIOCFLAG_CLOCAL)
! 365: tp->t_cflag |= CLOCAL;
! 366: if (zst->zst_swflags & TIOCFLAG_CRTSCTS)
! 367: tp->t_cflag |= CRTSCTS;
! 368: if (zst->zst_swflags & TIOCFLAG_MDMBUF)
! 369: tp->t_cflag |= MDMBUF;
! 370: tp->t_lflag = TTYDEF_LFLAG;
! 371: tp->t_ispeed = tp->t_ospeed = cs->cs_defspeed;
! 372: (void) zsparam(tp, &tp->t_termios);
! 373: ttsetwater(tp);
! 374: /* Flush any pending input. */
! 375: zst->zst_rbget = zst->zst_rbput;
! 376: zs_iflush(cs); /* XXX */
! 377: /* Turn on DTR */
! 378: zs_modem(zst, 1);
! 379: if (zst->zst_swflags & TIOCFLAG_SOFTCAR) {
! 380: tp->t_state |= TS_CARR_ON;
! 381: }
! 382: }
! 383: error = 0;
! 384:
! 385: /* Wait for carrier. */
! 386: for (;;) {
! 387:
! 388: /* Might never get status intr if carrier already on. */
! 389: cs->cs_rr0 = zs_read_csr(cs);
! 390: if (cs->cs_rr0 & ZSRR0_DCD) {
! 391: tp->t_state |= TS_CARR_ON;
! 392: break;
! 393: }
! 394:
! 395: if ((tp->t_state & TS_CARR_ON) ||
! 396: (tp->t_cflag & CLOCAL) ||
! 397: (flags & O_NONBLOCK) )
! 398: {
! 399: break;
! 400: }
! 401:
! 402: tp->t_state |= TS_WOPEN;
! 403: error = ttysleep(tp, (caddr_t)&tp->t_rawq,
! 404: TTIPRI | PCATCH, ttopen, 0);
! 405: if (error) {
! 406: if ((tp->t_state & TS_ISOPEN) == 0) {
! 407: /* Never get here with softcar */
! 408: zs_modem(zst, 0);
! 409: tp->t_state &= ~TS_WOPEN;
! 410: ttwakeup(tp);
! 411: }
! 412: break;
! 413: }
! 414: }
! 415:
! 416: splx(s);
! 417:
! 418: if (error == 0)
! 419: error = linesw[tp->t_line].l_open(dev, tp);
! 420:
! 421: return (error);
! 422: }
! 423:
! 424: /*
! 425: * Close a zs serial port.
! 426: */
! 427: int
! 428: zsclose(dev, flags, mode, p)
! 429: dev_t dev;
! 430: int flags;
! 431: int mode;
! 432: struct proc *p;
! 433: {
! 434: struct zstty_softc *zst;
! 435: register struct zs_chanstate *cs;
! 436: register struct tty *tp;
! 437: int hup;
! 438:
! 439: zst = zstty_cd.cd_devs[minor(dev)];
! 440: cs = zst->zst_cs;
! 441: tp = zst->zst_tty;
! 442:
! 443: /* XXX This is for cons.c. */
! 444: if ((tp->t_state & TS_ISOPEN) == 0)
! 445: return 0;
! 446:
! 447: (*linesw[tp->t_line].l_close)(tp, flags);
! 448: hup = tp->t_cflag & HUPCL;
! 449: if (zst->zst_swflags & TIOCFLAG_SOFTCAR)
! 450: hup = 0;
! 451: if (hup) {
! 452: zs_modem(zst, 0);
! 453: /* hold low for 1 second */
! 454: (void) tsleep((caddr_t)cs, TTIPRI, ttclos, hz);
! 455: }
! 456: if (cs->cs_creg[5] & ZSWR5_BREAK) {
! 457: zs_break(cs, 0);
! 458: }
! 459: /* XXX - turn off interrupts? */
! 460:
! 461: ttyclose(tp);
! 462: return (0);
! 463: }
! 464:
! 465: /*
! 466: * Read/write zs serial port.
! 467: */
! 468: int
! 469: zsread(dev, uio, flags)
! 470: dev_t dev;
! 471: struct uio *uio;
! 472: int flags;
! 473: {
! 474: register struct zstty_softc *zst;
! 475: register struct tty *tp;
! 476:
! 477: zst = zstty_cd.cd_devs[minor(dev)];
! 478: tp = zst->zst_tty;
! 479: return (linesw[tp->t_line].l_read(tp, uio, flags));
! 480: }
! 481:
! 482: int
! 483: zswrite(dev, uio, flags)
! 484: dev_t dev;
! 485: struct uio *uio;
! 486: int flags;
! 487: {
! 488: register struct zstty_softc *zst;
! 489: register struct tty *tp;
! 490:
! 491: zst = zstty_cd.cd_devs[minor(dev)];
! 492: tp = zst->zst_tty;
! 493: return (linesw[tp->t_line].l_write(tp, uio, flags));
! 494: }
! 495:
! 496: #define TIOCFLAG_ALL (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | \
! 497: TIOCFLAG_CRTSCTS | TIOCFLAG_MDMBUF )
! 498:
! 499: int
! 500: zsioctl(dev, cmd, data, flag, p)
! 501: dev_t dev;
! 502: u_long cmd;
! 503: caddr_t data;
! 504: int flag;
! 505: struct proc *p;
! 506: {
! 507: register struct zstty_softc *zst;
! 508: register struct zs_chanstate *cs;
! 509: register struct tty *tp;
! 510: register int error, tmp;
! 511:
! 512: zst = zstty_cd.cd_devs[minor(dev)];
! 513: cs = zst->zst_cs;
! 514: tp = zst->zst_tty;
! 515:
! 516: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 517: if (error >= 0)
! 518: return (error);
! 519: error = ttioctl(tp, cmd, data, flag, p);
! 520: if (error >= 0)
! 521: return (error);
! 522:
! 523: switch (cmd) {
! 524:
! 525: case TIOCSBRK:
! 526: zs_break(cs, 1);
! 527: break;
! 528:
! 529: case TIOCCBRK:
! 530: zs_break(cs, 0);
! 531: break;
! 532:
! 533: case TIOCGFLAGS:
! 534: *(int *)data = zst->zst_swflags;
! 535: break;
! 536:
! 537: case TIOCSFLAGS:
! 538: error = suser(p, 0);
! 539: if (error != 0)
! 540: return (EPERM);
! 541: tmp = *(int *)data;
! 542: /* Check for random bits... */
! 543: if (tmp & ~TIOCFLAG_ALL)
! 544: return(EINVAL);
! 545: /* Silently enforce softcar on the console. */
! 546: if (zst->zst_hwflags & ZS_HWFLAG_CONSOLE)
! 547: tmp |= TIOCFLAG_SOFTCAR;
! 548: /* These flags take effect during open. */
! 549: zst->zst_swflags = tmp;
! 550: break;
! 551:
! 552: case TIOCSDTR:
! 553: zs_modem(zst, 1);
! 554: break;
! 555:
! 556: case TIOCCDTR:
! 557: zs_modem(zst, 0);
! 558: break;
! 559:
! 560: case TIOCMSET:
! 561: case TIOCMBIS:
! 562: case TIOCMBIC:
! 563: case TIOCMGET:
! 564: default:
! 565: return (ENOTTY);
! 566: }
! 567: return (0);
! 568: }
! 569:
! 570: /*
! 571: * Start or restart transmission.
! 572: */
! 573: static void
! 574: zsstart(tp)
! 575: register struct tty *tp;
! 576: {
! 577: register struct zstty_softc *zst;
! 578: register struct zs_chanstate *cs;
! 579: register int s, nch;
! 580:
! 581: zst = zstty_cd.cd_devs[minor(tp->t_dev)];
! 582: cs = zst->zst_cs;
! 583:
! 584: s = spltty();
! 585:
! 586: /*
! 587: * If currently active or delaying, no need to do anything.
! 588: */
! 589: if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP))
! 590: goto out;
! 591:
! 592: /*
! 593: * If under CRTSCTS hfc and halted, do nothing
! 594: */
! 595: if (tp->t_cflag & CRTSCTS)
! 596: if (zst->zst_tx_stopped)
! 597: goto out;
! 598:
! 599: /*
! 600: * If there are sleepers, and output has drained below low
! 601: * water mark, awaken.
! 602: */
! 603: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 604: if (tp->t_state & TS_ASLEEP) {
! 605: tp->t_state &= ~TS_ASLEEP;
! 606: wakeup((caddr_t)&tp->t_outq);
! 607: }
! 608: selwakeup(&tp->t_wsel);
! 609: }
! 610:
! 611: nch = ndqb(&tp->t_outq, 0); /* XXX */
! 612: (void) splzs();
! 613:
! 614: if (nch) {
! 615: register char *p = tp->t_outq.c_cf;
! 616:
! 617: /* mark busy, enable tx done interrupts, & send first byte */
! 618: tp->t_state |= TS_BUSY;
! 619: zst->zst_tx_busy = 1;
! 620: cs->cs_preg[1] |= ZSWR1_TIE;
! 621: cs->cs_creg[1] = cs->cs_preg[1];
! 622: zs_write_reg(cs, 1, cs->cs_creg[1]);
! 623: zs_write_data(cs, *p);
! 624: zst->zst_tba = p + 1;
! 625: zst->zst_tbc = nch - 1;
! 626: } else {
! 627: /*
! 628: * Nothing to send, turn off transmit done interrupts.
! 629: * This is useful if something is doing polled output.
! 630: */
! 631: cs->cs_preg[1] &= ~ZSWR1_TIE;
! 632: cs->cs_creg[1] = cs->cs_preg[1];
! 633: zs_write_reg(cs, 1, cs->cs_creg[1]);
! 634: }
! 635: out:
! 636: splx(s);
! 637: }
! 638:
! 639: /*
! 640: * Stop output, e.g., for ^S or output flush.
! 641: */
! 642: int
! 643: zsstop(tp, flag)
! 644: struct tty *tp;
! 645: int flag;
! 646: {
! 647: register struct zstty_softc *zst;
! 648: register struct zs_chanstate *cs;
! 649: register int s;
! 650:
! 651: zst = zstty_cd.cd_devs[minor(tp->t_dev)];
! 652: cs = zst->zst_cs;
! 653:
! 654: s = splzs();
! 655: if (tp->t_state & TS_BUSY) {
! 656: /*
! 657: * Device is transmitting; must stop it.
! 658: * Also clear _heldtbc to prevent any
! 659: * flow-control event from resuming.
! 660: */
! 661: zst->zst_tbc = 0;
! 662: zst->zst_heldtbc = 0;
! 663: if ((tp->t_state & TS_TTSTOP) == 0)
! 664: tp->t_state |= TS_FLUSH;
! 665: }
! 666: splx(s);
! 667: return (0);
! 668: }
! 669:
! 670: /*
! 671: * Set ZS tty parameters from termios.
! 672: * XXX - Should just copy the whole termios after
! 673: * making sure all the changes could be done.
! 674: * XXX - Only whack the UART when params change...
! 675: */
! 676: static int
! 677: zsparam(tp, t)
! 678: register struct tty *tp;
! 679: register struct termios *t;
! 680: {
! 681: register struct zstty_softc *zst;
! 682: register struct zs_chanstate *cs;
! 683: register int s, bps, cflag, tconst;
! 684: u_char tmp3, tmp4, tmp5;
! 685:
! 686: zst = zstty_cd.cd_devs[minor(tp->t_dev)];
! 687: cs = zst->zst_cs;
! 688:
! 689: /* XXX: Need to use an MD function for this. */
! 690: bps = t->c_ospeed;
! 691: if (bps < 0 || (t->c_ispeed && t->c_ispeed != bps))
! 692: return (EINVAL);
! 693: if (bps == 0) {
! 694: /* stty 0 => drop DTR and RTS */
! 695: zs_modem(zst, 0);
! 696: return (0);
! 697: }
! 698: tconst = BPS_TO_TCONST(cs->cs_brg_clk, bps);
! 699: if (tconst < 0)
! 700: return (EINVAL);
! 701:
! 702: /* Convert back to make sure we can do it. */
! 703: bps = TCONST_TO_BPS(cs->cs_brg_clk, tconst);
! 704: if (bps != t->c_ospeed)
! 705: return (EINVAL);
! 706: tp->t_ispeed = tp->t_ospeed = bps;
! 707:
! 708: cflag = t->c_cflag;
! 709: tp->t_cflag = cflag;
! 710:
! 711: /*
! 712: * Block interrupts so that state will not
! 713: * be altered until we are done setting it up.
! 714: */
! 715: s = splzs();
! 716:
! 717: /*
! 718: * Initial values in cs_preg are set before
! 719: * our attach routine is called. The master
! 720: * interrupt enable is handled by zsc.c
! 721: */
! 722:
! 723: cs->cs_preg[12] = tconst;
! 724: cs->cs_preg[13] = tconst >> 8;
! 725:
! 726: switch (cflag & CSIZE) {
! 727: case CS5:
! 728: tmp3 = ZSWR3_RX_5;
! 729: tmp5 = ZSWR5_TX_5;
! 730: break;
! 731: case CS6:
! 732: tmp3 = ZSWR3_RX_6;
! 733: tmp5 = ZSWR5_TX_6;
! 734: break;
! 735: case CS7:
! 736: tmp3 = ZSWR3_RX_7;
! 737: tmp5 = ZSWR5_TX_7;
! 738: break;
! 739: case CS8:
! 740: default:
! 741: tmp3 = ZSWR3_RX_8;
! 742: tmp5 = ZSWR5_TX_8;
! 743: break;
! 744: }
! 745:
! 746: cs->cs_preg[3] = tmp3 | ZSWR3_RX_ENABLE;
! 747: cs->cs_preg[5] = tmp5 | ZSWR5_TX_ENABLE | ZSWR5_DTR | ZSWR5_RTS;
! 748:
! 749: tmp4 = ZSWR4_CLK_X16 | (cflag & CSTOPB ? ZSWR4_TWOSB : ZSWR4_ONESB);
! 750: if ((cflag & PARODD) == 0)
! 751: tmp4 |= ZSWR4_EVENP;
! 752: if (cflag & PARENB)
! 753: tmp4 |= ZSWR4_PARENB;
! 754: cs->cs_preg[4] = tmp4;
! 755:
! 756: /*
! 757: * Output hardware flow control on the chip is horrendous:
! 758: * if carrier detect drops, the receiver is disabled.
! 759: * Therefore, NEVER set the HFC bit, and instead use
! 760: * the status interrupts to detect CTS changes.
! 761: */
! 762: if (cflag & CRTSCTS) {
! 763: zst->zst_rbhiwat = zstty_rbuf_hiwat;
! 764: cs->cs_preg[15] |= ZSWR15_CTS_IE;
! 765: } else {
! 766: zst->zst_rbhiwat = zstty_rbuf_size; /* impossible value */
! 767: cs->cs_preg[15] &= ~ZSWR15_CTS_IE;
! 768: }
! 769:
! 770: /*
! 771: * If nothing is being transmitted, set up new current values,
! 772: * else mark them as pending.
! 773: */
! 774: if (cs->cs_heldchange == 0) {
! 775: if (zst->zst_tx_busy) {
! 776: zst->zst_heldtbc = zst->zst_tbc;
! 777: zst->zst_tbc = 0;
! 778: cs->cs_heldchange = 0xFF; /* XXX */
! 779: } else {
! 780: zs_loadchannelregs(cs);
! 781: }
! 782: }
! 783: splx(s);
! 784: return (0);
! 785: }
! 786:
! 787: /*
! 788: * Raise or lower modem control (DTR/RTS) signals. If a character is
! 789: * in transmission, the change is deferred.
! 790: */
! 791: static void
! 792: zs_modem(zst, onoff)
! 793: struct zstty_softc *zst;
! 794: int onoff;
! 795: {
! 796: struct zs_chanstate *cs;
! 797: struct tty *tp;
! 798: int s, bis, and;
! 799:
! 800: cs = zst->zst_cs;
! 801: tp = zst->zst_tty;
! 802:
! 803: if (onoff) {
! 804: bis = ZSWR5_DTR | ZSWR5_RTS;
! 805: and = ~0;
! 806: } else {
! 807: bis = 0;
! 808: and = ~(ZSWR5_DTR | ZSWR5_RTS);
! 809: }
! 810: s = splzs();
! 811: cs->cs_preg[5] = (cs->cs_preg[5] | bis) & and;
! 812: if (cs->cs_heldchange == 0) {
! 813: if (zst->zst_tx_busy) {
! 814: zst->zst_heldtbc = zst->zst_tbc;
! 815: zst->zst_tbc = 0;
! 816: cs->cs_heldchange = (1<<5);
! 817: } else {
! 818: cs->cs_creg[5] = cs->cs_preg[5];
! 819: zs_write_reg(cs, 5, cs->cs_creg[5]);
! 820: }
! 821: }
! 822: splx(s);
! 823: }
! 824:
! 825: /*
! 826: * Try to block or unblock input using hardware flow-control.
! 827: * This is called by kern/tty.c if MDMBUF|CRTSCTS is set, and
! 828: * if this function returns non-zero, the TS_TBLOCK flag will
! 829: * be set or cleared according to the "stop" arg passed.
! 830: */
! 831: int
! 832: zshwiflow(tp, stop)
! 833: struct tty *tp;
! 834: int stop;
! 835: {
! 836: register struct zstty_softc *zst;
! 837: int s;
! 838:
! 839: zst = zstty_cd.cd_devs[minor(tp->t_dev)];
! 840:
! 841: s = splzs();
! 842: if (stop) {
! 843: /*
! 844: * The tty layer is asking us to block input.
! 845: * If we already did it, just return TRUE.
! 846: */
! 847: if (zst->zst_rx_blocked)
! 848: goto out;
! 849: zst->zst_rx_blocked = 1;
! 850: } else {
! 851: /*
! 852: * The tty layer is asking us to resume input.
! 853: * The input ring is always empty by now.
! 854: */
! 855: zst->zst_rx_blocked = 0;
! 856: }
! 857: zs_hwiflow(zst, stop);
! 858: out:
! 859: splx(s);
! 860: return 1;
! 861: }
! 862:
! 863: /*
! 864: * Internal version of zshwiflow
! 865: * called at splzs
! 866: */
! 867: static void
! 868: zs_hwiflow(zst, stop)
! 869: register struct zstty_softc *zst;
! 870: int stop;
! 871: {
! 872: register struct zs_chanstate *cs;
! 873: register struct tty *tp;
! 874: register int bis, and;
! 875:
! 876: cs = zst->zst_cs;
! 877: tp = zst->zst_tty;
! 878:
! 879: if (stop) {
! 880: /* Block input (Lower RTS) */
! 881: bis = 0;
! 882: and = ~ZSWR5_RTS;
! 883: } else {
! 884: /* Unblock input (Raise RTS) */
! 885: bis = ZSWR5_RTS;
! 886: and = ~0;
! 887: }
! 888:
! 889: cs->cs_preg[5] = (cs->cs_preg[5] | bis) & and;
! 890: if (cs->cs_heldchange == 0) {
! 891: if (zst->zst_tx_busy) {
! 892: zst->zst_heldtbc = zst->zst_tbc;
! 893: zst->zst_tbc = 0;
! 894: cs->cs_heldchange = (1<<5);
! 895: } else {
! 896: cs->cs_creg[5] = cs->cs_preg[5];
! 897: zs_write_reg(cs, 5, cs->cs_creg[5]);
! 898: }
! 899: }
! 900: }
! 901:
! 902:
! 903: /****************************************************************
! 904: * Interface to the lower layer (zscc)
! 905: ****************************************************************/
! 906:
! 907:
! 908: /*
! 909: * receiver ready interrupt.
! 910: * called at splzs
! 911: */
! 912: static void
! 913: zstty_rxint(cs)
! 914: register struct zs_chanstate *cs;
! 915: {
! 916: register struct zstty_softc *zst;
! 917: register int cc, put, put_next, ringmask;
! 918: register u_char c, rr0, rr1;
! 919: register u_short ch_rr1;
! 920:
! 921: zst = cs->cs_private;
! 922: put = zst->zst_rbput;
! 923: ringmask = zst->zst_ringmask;
! 924:
! 925: nextchar:
! 926:
! 927: /*
! 928: * First read the status, because reading the received char
! 929: * destroys the status of this char.
! 930: */
! 931: rr1 = zs_read_reg(cs, 1);
! 932: c = zs_read_data(cs);
! 933: ch_rr1 = (c << 8) | rr1;
! 934:
! 935: if (ch_rr1 & (ZSRR1_FE | ZSRR1_DO | ZSRR1_PE)) {
! 936: /* Clear the receive error. */
! 937: zs_write_csr(cs, ZSWR0_RESET_ERRORS);
! 938: }
! 939:
! 940: /* XXX: Check for the stop character? */
! 941:
! 942: zst->zst_rbuf[put] = ch_rr1;
! 943: put_next = (put + 1) & ringmask;
! 944:
! 945: /* Would overrun if increment makes (put==get). */
! 946: if (put_next == zst->zst_rbget) {
! 947: zst->zst_rx_overrun = 1;
! 948: } else {
! 949: /* OK, really increment. */
! 950: put = put_next;
! 951: }
! 952:
! 953: /* Keep reading until the FIFO is empty. */
! 954: rr0 = zs_read_csr(cs);
! 955: if (rr0 & ZSRR0_RX_READY)
! 956: goto nextchar;
! 957:
! 958: /* Done reading. */
! 959: zst->zst_rbput = put;
! 960:
! 961: /*
! 962: * If ring is getting too full, try to block input.
! 963: */
! 964: cc = put - zst->zst_rbget;
! 965: if (cc < 0)
! 966: cc += zstty_rbuf_size;
! 967: if ((cc > zst->zst_rbhiwat) && (zst->zst_rx_blocked == 0)) {
! 968: zst->zst_rx_blocked = 1;
! 969: zs_hwiflow(zst, 1);
! 970: }
! 971:
! 972: /* Ask for softint() call. */
! 973: cs->cs_softreq = 1;
! 974: }
! 975:
! 976: /*
! 977: * transmitter ready interrupt. (splzs)
! 978: */
! 979: static void
! 980: zstty_txint(cs)
! 981: register struct zs_chanstate *cs;
! 982: {
! 983: register struct zstty_softc *zst;
! 984: register int count;
! 985:
! 986: zst = cs->cs_private;
! 987:
! 988: /*
! 989: * If we suspended output for a "held" change,
! 990: * then handle that now and resume.
! 991: * Do flow-control changes ASAP.
! 992: * When the only change is for flow control,
! 993: * avoid hitting other registers, because that
! 994: * often makes the stupid zs drop input...
! 995: */
! 996: if (cs->cs_heldchange) {
! 997: if (cs->cs_heldchange == (1<<5)) {
! 998: /* Avoid whacking the chip... */
! 999: cs->cs_creg[5] = cs->cs_preg[5];
! 1000: zs_write_reg(cs, 5, cs->cs_creg[5]);
! 1001: } else
! 1002: zs_loadchannelregs(cs);
! 1003: cs->cs_heldchange = 0;
! 1004: count = zst->zst_heldtbc;
! 1005: } else
! 1006: count = zst->zst_tbc;
! 1007:
! 1008: /*
! 1009: * If our transmit buffer still has data,
! 1010: * just send the next character.
! 1011: */
! 1012: if (count > 0) {
! 1013: /* Send the next char. */
! 1014: zst->zst_tbc = --count;
! 1015: zs_write_data(cs, *zst->zst_tba);
! 1016: zst->zst_tba++;
! 1017: return;
! 1018: }
! 1019:
! 1020: zs_write_csr(cs, ZSWR0_RESET_TXINT);
! 1021:
! 1022: /* Ask the softint routine for more output. */
! 1023: zst->zst_tx_busy = 0;
! 1024: zst->zst_tx_done = 1;
! 1025: cs->cs_softreq = 1;
! 1026: }
! 1027:
! 1028: /*
! 1029: * status change interrupt. (splzs)
! 1030: */
! 1031: static void
! 1032: zstty_stint(cs)
! 1033: register struct zs_chanstate *cs;
! 1034: {
! 1035: register struct zstty_softc *zst;
! 1036: register struct tty *tp;
! 1037: register u_char rr0;
! 1038:
! 1039: zst = cs->cs_private;
! 1040: tp = zst->zst_tty;
! 1041:
! 1042: rr0 = zs_read_csr(cs);
! 1043: zs_write_csr(cs, ZSWR0_RESET_STATUS);
! 1044:
! 1045: /*
! 1046: * Check here for console break, so that we can abort
! 1047: * even when interrupts are locking up the machine.
! 1048: */
! 1049: if ((rr0 & ZSRR0_BREAK) &&
! 1050: (zst->zst_hwflags & ZS_HWFLAG_CONSOLE))
! 1051: {
! 1052: zs_abort();
! 1053: return;
! 1054: }
! 1055:
! 1056: /*
! 1057: * Need to handle CTS output flow control here.
! 1058: * Output remains stopped as long as either the
! 1059: * zst_tx_stopped or TS_TTSTOP flag is set.
! 1060: * Never restart here; the softint routine will
! 1061: * do that after things are ready to move.
! 1062: */
! 1063: if (((rr0 & ZSRR0_CTS) == 0) && (tp->t_cflag & CRTSCTS)) {
! 1064: zst->zst_tbc = 0;
! 1065: zst->zst_heldtbc = 0;
! 1066: zst->zst_tx_stopped = 1;
! 1067: }
! 1068:
! 1069: /*
! 1070: * We have to accumulate status line changes here.
! 1071: * Otherwise, if we get multiple status interrupts
! 1072: * before the softint runs, we could fail to notice
! 1073: * some status line changes in the softint routine.
! 1074: * Fix from Bill Studenmund, October 1996.
! 1075: */
! 1076: cs->cs_rr0_delta |= (cs->cs_rr0 ^ rr0);
! 1077:
! 1078: ttytstamp(tp, cs->cs_rr0 & ZSRR0_CTS, rr0 & ZSRR0_CTS,
! 1079: cs->cs_rr0 & ZSRR0_DCD, rr0 & ZSRR0_DCD);
! 1080:
! 1081: cs->cs_rr0 = rr0;
! 1082: zst->zst_st_check = 1;
! 1083:
! 1084: /* Ask for softint() call. */
! 1085: cs->cs_softreq = 1;
! 1086: }
! 1087:
! 1088: /*
! 1089: * Print out a ring or fifo overrun error message.
! 1090: */
! 1091: static void
! 1092: zsoverrun(zst, ptime, what)
! 1093: struct zstty_softc *zst;
! 1094: long *ptime;
! 1095: char *what;
! 1096: {
! 1097:
! 1098: if (*ptime != time_second) {
! 1099: *ptime = time_second;
! 1100: log(LOG_WARNING, "%s: %s overrun\n",
! 1101: zst->zst_dev.dv_xname, what);
! 1102: }
! 1103: }
! 1104:
! 1105: /*
! 1106: * Software interrupt. Called at zssoft
! 1107: *
! 1108: * The main job to be done here is to empty the input ring
! 1109: * by passing its contents up to the tty layer. The ring is
! 1110: * always emptied during this operation, therefore the ring
! 1111: * must not be larger than the space after "high water" in
! 1112: * the tty layer, or the tty layer might drop our input.
! 1113: *
! 1114: * Note: an "input blockage" condition is assumed to exist if
! 1115: * EITHER the TS_TBLOCK flag or zst_rx_blocked flag is set.
! 1116: */
! 1117: static void
! 1118: zstty_softint(cs)
! 1119: struct zs_chanstate *cs;
! 1120: {
! 1121: register struct zstty_softc *zst;
! 1122: register struct linesw *line;
! 1123: register struct tty *tp;
! 1124: register int get, c, s;
! 1125: int ringmask, overrun;
! 1126: register u_short ring_data;
! 1127: register u_char rr0, delta;
! 1128:
! 1129: zst = cs->cs_private;
! 1130: tp = zst->zst_tty;
! 1131: line = &linesw[tp->t_line];
! 1132: ringmask = zst->zst_ringmask;
! 1133: overrun = 0;
! 1134:
! 1135: /*
! 1136: * Raise to tty priority while servicing the ring.
! 1137: */
! 1138: s = spltty();
! 1139:
! 1140: if (zst->zst_rx_overrun) {
! 1141: zst->zst_rx_overrun = 0;
! 1142: zsoverrun(zst, &zst->zst_rotime, "ring");
! 1143: }
! 1144:
! 1145: /*
! 1146: * Copy data from the receive ring into the tty layer.
! 1147: */
! 1148: get = zst->zst_rbget;
! 1149: while (get != zst->zst_rbput) {
! 1150: ring_data = zst->zst_rbuf[get];
! 1151: get = (get + 1) & ringmask;
! 1152:
! 1153: if (ring_data & ZSRR1_DO)
! 1154: overrun++;
! 1155: /* low byte of ring_data is rr1 */
! 1156: c = (ring_data >> 8) & 0xff;
! 1157: if (ring_data & ZSRR1_FE)
! 1158: c |= TTY_FE;
! 1159: if (ring_data & ZSRR1_PE)
! 1160: c |= TTY_PE;
! 1161:
! 1162: line->l_rint(c, tp);
! 1163: }
! 1164: zst->zst_rbget = get;
! 1165:
! 1166: /*
! 1167: * If the overrun flag is set now, it was set while
! 1168: * copying char/status pairs from the ring, which
! 1169: * means this was a hardware (fifo) overrun.
! 1170: */
! 1171: if (overrun) {
! 1172: zsoverrun(zst, &zst->zst_fotime, "fifo");
! 1173: }
! 1174:
! 1175: /*
! 1176: * We have emptied the input ring. Maybe unblock input.
! 1177: * Note: an "input blockage" condition is assumed to exist
! 1178: * when EITHER zst_rx_blocked or the TS_TBLOCK flag is set,
! 1179: * so unblock here ONLY if TS_TBLOCK has not been set.
! 1180: */
! 1181: if (zst->zst_rx_blocked && ((tp->t_state & TS_TBLOCK) == 0)) {
! 1182: (void) splzs();
! 1183: zst->zst_rx_blocked = 0;
! 1184: zs_hwiflow(zst, 0); /* unblock input */
! 1185: (void) spltty();
! 1186: }
! 1187:
! 1188: /*
! 1189: * Do any deferred work for status interrupts.
! 1190: * The rr0 was saved in the h/w interrupt to
! 1191: * avoid another splzs in here.
! 1192: */
! 1193: if (zst->zst_st_check) {
! 1194: zst->zst_st_check = 0;
! 1195:
! 1196: rr0 = cs->cs_rr0;
! 1197: delta = cs->cs_rr0_delta;
! 1198: cs->cs_rr0_delta = 0;
! 1199: if (delta & ZSRR0_DCD) {
! 1200: c = ((rr0 & ZSRR0_DCD) != 0);
! 1201: if (line->l_modem(tp, c) == 0)
! 1202: zs_modem(zst, c);
! 1203: }
! 1204: if ((delta & ZSRR0_CTS) && (tp->t_cflag & CRTSCTS)) {
! 1205: /*
! 1206: * Only do restart here. Stop is handled
! 1207: * at the h/w interrupt level.
! 1208: */
! 1209: if (rr0 & ZSRR0_CTS) {
! 1210: zst->zst_tx_stopped = 0;
! 1211: tp->t_state &= ~TS_TTSTOP;
! 1212: (*line->l_start)(tp);
! 1213: }
! 1214: }
! 1215: }
! 1216:
! 1217: if (zst->zst_tx_done) {
! 1218: zst->zst_tx_done = 0;
! 1219: tp->t_state &= ~TS_BUSY;
! 1220: if (tp->t_state & TS_FLUSH)
! 1221: tp->t_state &= ~TS_FLUSH;
! 1222: else
! 1223: ndflush(&tp->t_outq, zst->zst_tba -
! 1224: (caddr_t) tp->t_outq.c_cf);
! 1225: line->l_start(tp);
! 1226: }
! 1227:
! 1228: splx(s);
! 1229: }
! 1230:
! 1231: struct zsops zsops_tty = {
! 1232: zstty_rxint, /* receive char available */
! 1233: zstty_stint, /* external/status */
! 1234: zstty_txint, /* xmit buffer empty */
! 1235: zstty_softint, /* process software interrupt */
! 1236: };
! 1237:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to z8530tty.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic