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