remember dma count, as can't calculate correctly on Emulex;

[unix-history] / usr / src / sys / vax / uba / dz.c

diff --git a/usr/src/sys/vax/uba/dz.c b/usr/src/sys/vax/uba/dz.c
index 5c8f18d..1e35f9a 100644 (file)
--- a/usr/src/sys/vax/uba/dz.c
+++ b/usr/src/sys/vax/uba/dz.c
@@ -1,424 +1,661 @@
-/*     dz.c    3.8     %H%     */
+/*
+ * Copyright (c) 1982 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)dz.c        6.11 (Berkeley) %G%
+ */
+
+#include "dz.h"
+#if NDZ > 0
+/*
+ *  DZ-11/DZ-32 Driver
+ *
+ * This driver mimics dh.c; see it for explanation of common code.
+ */
+#include "bk.h"
+
+#include "../machine/pte.h"
+
+#include "param.h"
+#include "systm.h"
+#include "ioctl.h"
+#include "tty.h"
+#include "dir.h"
+#include "user.h"
+#include "proc.h"
+#include "map.h"
+#include "buf.h"
+#include "vm.h"
+#include "conf.h"
+#include "bkmac.h"
+#include "file.h"
+#include "uio.h"
+#include "kernel.h"
+#include "syslog.h"
+
+#include "pdma.h"
+#include "ubavar.h"
+#include "dzreg.h"
+
+/*
+ * Driver information for auto-configuration stuff.
+ */
+int    dzprobe(), dzattach(), dzrint();
+struct uba_device *dzinfo[NDZ];
+u_short        dzstd[] = { 0 };
+struct uba_driver dzdriver =
+       { dzprobe, 0, dzattach, 0, dzstd, "dz", dzinfo };
+
+#define        NDZLINE         (NDZ*8)
+#define        FASTTIMER       (hz/30)         /* rate to drain silos, when in use */
+
+int    dzstart(), dzxint(), dzdma();
+int    ttrstrt();
+struct tty dz_tty[NDZLINE];
+int    dz_cnt = { NDZLINE };
+int    dzact;
+int    dzsilos;                        /* mask of dz's with silo in use */
+int    dzchars[NDZ];                   /* recent input count */
+int    dzrate[NDZ];                    /* smoothed input count */
+int    dztimerintvl;                   /* time interval for dztimer */
+int    dzhighrate = 100;               /* silo on if dzchars > dzhighrate */
+int    dzlowrate = 75;                 /* silo off if dzrate < dzlowrate */
+
+#define dzwait(x)      while (((x)->dzlcs & DZ_ACK) == 0)

 
 /*
 
 /*

- *  DZ-11 Driver
+ * Software copy of dzbrk since it isn't readable

  */
  */

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/tty.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/map.h"
-#include "../h/pte.h"
-#include "../h/uba.h"
-#include "../h/conf.h"
-#include "../h/pdma.h"
-#include "../h/bk.h"
+char   dz_brk[NDZ];
+char   dzsoftCAR[NDZ];
+char   dz_lnen[NDZ];   /* saved line enable bits for DZ32 */

 
 /*
 
 /*

- * When running dz's using only SAE (silo alarm) on input
- * it is necessary to call dzrint() at clock interrupt time.
- * This is unsafe unless spl5()s in tty code are changed to
- * spl6()s to block clock interrupts.  Note that the dh driver
- * currently in use works the same way as the dz, even though
- * we could try to more intelligently manage its silo.
- * Thus don't take this out if you have no dz's unless you
- * change clock.c and dhtimer().
+ * The dz11 doesn't interrupt on carrier transitions, so
+ * we have to use a timer to watch it.

  */
  */

-#define        spl5    spl6
+char   dz_timer;               /* timer started? */
+
+/*
+ * Pdma structures for fast output code
+ */
+struct pdma dzpdma[NDZLINE];
+
+char   dz_speeds[] =
+       { 0,020,021,022,023,024,0,025,026,027,030,032,034,036,037,0 };

  
  

-#define DZADDR  (UBA0_DEV + 0160100)
-#ifdef ERNIE
-#define NDZ    (3*8)
+#ifndef        PORTSELECTOR
+#define        ISPEED  B9600
+#define        IFLAGS  (EVENP|ODDP|ECHO)

 #else
 #else

-#define        NDZ     (8)
+#define        ISPEED  B4800
+#define        IFLAGS  (EVENP|ODDP)

 #endif
 #endif

- 
-#define BITS7  020
-#define BITS8  030
-#define TWOSB  040
-#define PENABLE        0100
-#define OPAR   0200
-#define MSE    040             /* Master Scan Enable */
-#define RIE    0100            /* Receiver Interrupt Enable */
-#define        SAE     010000          /* Silo Alarm Enable */
-#define TIE    040000          /* Transmit Interrupt Enable */
-#define DZ_IEN (MSE+RIE+TIE+SAE)
-#define PERROR 010000
-#define FRERROR        020000
-#define        OVERRUN 040000
-#define SSPEED 7               /* std speed = 300 baud */

 
 

- 
-#define        dzlpr   dzrbuf
-#define dzmsr  dzbrk
-#define ON     1
-#define OFF    0
- 
-int    dzstart();
-int    dzxint();
-int    ttrstrt();
-struct tty dz_tty[NDZ];
-int    dz_cnt = { NDZ };
-int    dzact;
+dzprobe(reg)
+       caddr_t reg;
+{
+       register int br, cvec;
+       register struct dzdevice *dzaddr = (struct dzdevice *)reg;

 
 

-struct device {
-       short   dzcsr;
-       short   dzrbuf;
-       char    dztcr;
-       char    dzdtr;
-       char    dztbuf;
-       char    dzbrk;
-};
-
-struct pdma dzpdma[] = {
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[0], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[1], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[2], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[3], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[4], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[5], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[6], dzxint,
-       (struct device *)(DZADDR), NULL, NULL, (int)&dz_tty[7], dzxint,
-#ifdef ERNIE
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[8], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[9], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[10], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[11], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[12], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[13], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[14], dzxint,
-       (struct device *)(DZADDR+010), NULL, NULL, (int)&dz_tty[15], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[16], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[17], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[18], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[19], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[20], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[21], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[22], dzxint,
-       (struct device *)(DZADDR+020), NULL, NULL, (int)&dz_tty[23], dzxint,
+#ifdef lint
+       br = 0; cvec = br; br = cvec;
+       dzrint(0); dzxint((struct tty *)0);

 #endif
 #endif

-};
-char   dz_timer;
-char   dz_speeds[] = {
-       0, 020 , 021 , 022 , 023 , 024 , 0, 025,
-       026 , 027 , 030 , 032 , 034 , 036 , 0 , 0,
-};
- 
-/*ARGSUSED*/
-dzopen(d, flag)
+       dzaddr->dzcsr = DZ_TIE|DZ_MSE|DZ_32;
+       if (dzaddr->dzcsr & DZ_32)
+               dzaddr->dzlnen = 1;
+       else
+               dzaddr->dztcr = 1;              /* enable any line */
+       DELAY(100000);
+       dzaddr->dzcsr = DZ_CLR|DZ_32;           /* reset everything */
+       if (cvec && cvec != 0x200)
+               cvec -= 4;
+       return (sizeof (struct dzdevice));
+}
+
+dzattach(ui)
+       register struct uba_device *ui;

 {
 {

-       register struct tty *tp;
-       register dev;
+       register struct pdma *pdp = &dzpdma[ui->ui_unit*8];
+       register struct tty *tp = &dz_tty[ui->ui_unit*8];
+       register int cntr;

        extern dzscan();
        extern dzscan();

- 
-       dev = minor(d);
-       if (dev >= dz_cnt) {
-               u.u_error = ENXIO;
-               return;
+
+       for (cntr = 0; cntr < 8; cntr++) {
+               pdp->p_addr = (struct dzdevice *)ui->ui_addr;
+               pdp->p_arg = (int)tp;
+               pdp->p_fcn = dzxint;
+               pdp++, tp++;

        }
        }

+       dzsoftCAR[ui->ui_unit] = ui->ui_flags;

        if (dz_timer == 0) {
                dz_timer++;
        if (dz_timer == 0) {
                dz_timer++;

-               timeout(dzscan, (caddr_t)0, 60);
+               timeout(dzscan, (caddr_t)0, hz);
+               dztimerintvl = FASTTIMER;

        }
        }

-       tp = &dz_tty[dev];
-       tp->t_addr = (caddr_t)&dzpdma[dev];
+}
+
+/*ARGSUSED*/
+dzopen(dev, flag)
+       dev_t dev;
+{
+       register struct tty *tp;
+       register int unit;
+ 
+       unit = minor(dev);
+       if (unit >= dz_cnt || dzpdma[unit].p_addr == 0)
+               return (ENXIO);
+       tp = &dz_tty[unit];
+       tp->t_addr = (caddr_t)&dzpdma[unit];

        tp->t_oproc = dzstart;
        tp->t_oproc = dzstart;

-       tp->t_iproc = NULL;
-       tp->t_state |= WOPEN;
-       if ((tp->t_state & ISOPEN) == 0) {
+       if ((tp->t_state & TS_ISOPEN) == 0) {

                ttychars(tp);
                ttychars(tp);

-               tp->t_ospeed = tp->t_ispeed = SSPEED;
-               tp->t_flags = ODDP|EVENP|ECHO;
-               /*tp->t_state |= HUPCLS;*/
-               dzparam(dev);
-       } else if (tp->t_state&XCLUDE && u.u_uid != 0) {
-               u.u_error = EBUSY;
-               return;
-       }
-       dzmodem(dev, ON);
+#ifndef PORTSELECTOR
+               if (tp->t_ispeed == 0) {
+#else
+                       tp->t_state |= TS_HUPCLS;
+#endif PORTSELECTOR
+                       tp->t_ispeed = ISPEED;
+                       tp->t_ospeed = ISPEED;
+                       tp->t_flags = IFLAGS;
+#ifndef PORTSELECTOR
+               }
+#endif PORTSELECTOR
+               dzparam(unit);
+       } else if (tp->t_state&TS_XCLUDE && u.u_uid != 0)
+               return (EBUSY);
+       (void) dzmctl(dev, DZ_ON, DMSET);

        (void) spl5();
        (void) spl5();

-       while ((tp->t_state & CARR_ON) == 0) {
-               tp->t_state |= WOPEN;
+       while ((tp->t_state & TS_CARR_ON) == 0) {
+               tp->t_state |= TS_WOPEN;

                sleep((caddr_t)&tp->t_rawq, TTIPRI);
        }
        (void) spl0();
                sleep((caddr_t)&tp->t_rawq, TTIPRI);
        }
        (void) spl0();

-       (*linesw[tp->t_line].l_open)(d, tp);
+       return ((*linesw[tp->t_line].l_open)(dev, tp));

 }
  
 }
  

-dzclose(d)
+/*ARGSUSED*/
+dzclose(dev, flag)
+       dev_t dev;

 {
        register struct tty *tp;
 {
        register struct tty *tp;

-       register dev;
+       register int unit;
+       register struct dzdevice *dzaddr;
+       int dz;

  
  

-       dev = minor(d);
-       tp = &dz_tty[dev];
+       unit = minor(dev);
+       dz = unit >> 3;
+       tp = &dz_tty[unit];

        (*linesw[tp->t_line].l_close)(tp);
        (*linesw[tp->t_line].l_close)(tp);

-       if (tp->t_state & HUPCLS)
-               dzmodem(dev, OFF);
+       dzaddr = dzpdma[unit].p_addr;
+       if (dzaddr->dzcsr&DZ_32)
+               (void) dzmctl(dev, DZ_BRK, DMBIC);
+       else
+               dzaddr->dzbrk = (dz_brk[dz] &= ~(1 << (unit&07)));
+       if ((tp->t_state&(TS_HUPCLS|TS_WOPEN)) || (tp->t_state&TS_ISOPEN) == 0)
+               (void) dzmctl(dev, DZ_OFF, DMSET);

        ttyclose(tp);
 }
  
        ttyclose(tp);
 }
  

-dzread(d)
+dzread(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
        register struct tty *tp;
  
 {
        register struct tty *tp;
  

-       tp = &dz_tty[minor(d)];
-       (*linesw[tp->t_line].l_read)(tp);
+       tp = &dz_tty[minor(dev)];
+       return ((*linesw[tp->t_line].l_read)(tp, uio));

 }
  
 }
  

-dzwrite(d)
+dzwrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
        register struct tty *tp;
  
 {
        register struct tty *tp;
  

-       tp = &dz_tty[minor(d)];
-       (*linesw[tp->t_line].l_write)(tp);
+       tp = &dz_tty[minor(dev)];
+       return ((*linesw[tp->t_line].l_write)(tp, uio));

 }
  
 /*ARGSUSED*/
 }
  
 /*ARGSUSED*/

-dzrint(dev)
+dzrint(dz)
+       int dz;

 {
        register struct tty *tp;
        register int c;
 {
        register struct tty *tp;
        register int c;

-       register struct device *dzaddr;
+       register struct dzdevice *dzaddr;

        register struct tty *tp0;
        register struct tty *tp0;

-       int s;
+       register int unit;
+       int overrun = 0;

  
  

-       s = spl6();     /* see comment in clock.c */
-       /* as long as we are here, service them all */
-       for (dev = 0; dev < NDZ; dev += 8) {
-               if ((dzact & (1<<(dev>>3))) == 0)
+       if ((dzact & (1<<dz)) == 0)
+               return;
+       unit = dz * 8;
+       dzaddr = dzpdma[unit].p_addr;
+       tp0 = &dz_tty[unit];
+       dzaddr->dzcsr &= ~(DZ_RIE|DZ_MIE);      /* the manual says this song */
+       dzaddr->dzcsr |= DZ_RIE|DZ_MIE;         /*   and dance is necessary */
+       while (dzaddr->dzcsr & DZ_MSC) {        /* DZ32 modem change interrupt */
+               c = dzaddr->dzmtsr;
+               tp = tp0 + (c&7);
+               if (tp >= &dz_tty[dz_cnt])
+                       break;
+               dzaddr->dzlcs = c&7;    /* get status of modem lines */
+               dzwait(dzaddr);         /* wait for them */
+               if (c & DZ_CD)          /* carrier status change? */
+               if (dzaddr->dzlcs & DZ_CD) {    /* carrier up? */
+                       /* carrier present */
+                       (void)(*linesw[tp->t_line].l_modem)(tp, 1);
+               } else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0)
+                       dzaddr->dzlcs = DZ_ACK|(c&7);
+       }
+       while ((c = dzaddr->dzrbuf) < 0) {      /* char present */
+               dzchars[dz]++;
+               tp = tp0 + ((c>>8)&07);
+               if (tp >= &dz_tty[dz_cnt])

                        continue;
                        continue;

-               dzaddr = dzpdma[dev].p_addr;
-               tp0 = &dz_tty[dev];
-               while ((c = dzaddr->dzrbuf) < 0) {      /* char present */
-                       tp = tp0 + ((c>>8)&07);
-                       if (tp >= &dz_tty[dz_cnt])
+               if ((tp->t_state & TS_ISOPEN) == 0) {
+                       wakeup((caddr_t)&tp->t_rawq);
+#ifdef PORTSELECTOR
+                       if ((tp->t_state&TS_WOPEN) == 0)
+#endif

                                continue;
                                continue;

-                       if ((tp->t_state & ISOPEN) == 0) {
-                               wakeup((caddr_t)&tp->t_rawq);
+               }
+               if (c&DZ_FE)
+                       if (tp->t_flags & RAW)
+                               c = 0;
+                       else
+                               c = tp->t_intrc;
+               if (c&DZ_DO && overrun == 0) {
+                       log(LOG_WARNING, "dz%d,%d: silo overflow\n", dz, (c>>8)&7);
+                       overrun = 1;
+               }
+               if (c&DZ_PE)    
+                       if (((tp->t_flags & (EVENP|ODDP)) == EVENP)
+                         || ((tp->t_flags & (EVENP|ODDP)) == ODDP))

                                continue;
                                continue;

-                       }
-                       if (c&FRERROR)
-                               /* framing error = break */
-                               if (tp->t_flags & RAW)
-                                       c = 0;          /* null for getty */
-                               else
-#ifdef IIASA
-                                       continue;
-#else
-                                       c = tun.t_intrc;
+#if NBK > 0
+               if (tp->t_line == NETLDISC) {
+                       c &= 0177;
+                       BKINPUT(c, tp);
+               } else

 #endif
 #endif

-                       if (c&OVERRUN)
-                               printf("o");
-                       if (c&PERROR)   
-                               /* parity error */
-                               if (((tp->t_flags & (EVENP|ODDP)) == EVENP)
-                                 || ((tp->t_flags & (EVENP|ODDP)) == ODDP))
-                                       continue;
-                       if (tp->t_line == NETLDISC) {
-                               c &= 0177;
-                               BKINPUT(c, tp);
-                       } else
-                               (*linesw[tp->t_line].l_rint)(c, tp);
-               }
+                       (*linesw[tp->t_line].l_rint)(c, tp);

        }
        }

-       splx(s);

 }
  
 /*ARGSUSED*/
 }
  
 /*ARGSUSED*/

-dzioctl(dev, cmd, addr, flag)
-caddr_t addr;
-dev_t dev;
+dzioctl(dev, cmd, data, flag)
+       dev_t dev;
+       caddr_t data;

 {
        register struct tty *tp;
 {
        register struct tty *tp;

+       register int unit = minor(dev);
+       register int dz = unit >> 3;
+       register struct dzdevice *dzaddr;
+       int error;

  
  

-       tp = &dz_tty[minor(dev)];
-       cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr);
-       if (cmd == 0)
-               return;
-       if (ttioccomm(cmd, tp, addr, dev)) {
-               if (cmd==TIOCSETP || cmd==TIOCSETN)
-                       dzparam(minor(dev));
-       } else switch(cmd) {
+       tp = &dz_tty[unit];
+       error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);
+       if (error >= 0)
+               return (error);
+       error = ttioctl(tp, cmd, data, flag);
+       if (error >= 0) {
+               if (cmd == TIOCSETP || cmd == TIOCSETN || cmd == TIOCLBIS ||
+                   cmd == TIOCLBIC || cmd == TIOCLSET)
+                       dzparam(unit);
+               return (error);
+       }
+       switch (cmd) {
+

        case TIOCSBRK:
        case TIOCSBRK:

-               ((struct device *)(tp->t_addr))->dzbrk |= 1 << (dev&07);
+               dzaddr = ((struct pdma *)(tp->t_addr))->p_addr;
+               if (dzaddr->dzcsr&DZ_32)
+                       (void) dzmctl(dev, DZ_BRK, DMBIS);
+               else
+                       dzaddr->dzbrk = (dz_brk[dz] |= 1 << (unit&07));

                break;
                break;

+

        case TIOCCBRK:
        case TIOCCBRK:

-               ((struct device *)(tp->t_addr))->dzbrk &= ~(1 << (dev&07));
+               dzaddr = ((struct pdma *)(tp->t_addr))->p_addr;
+               if (dzaddr->dzcsr&DZ_32)
+                       (void) dzmctl(dev, DZ_BRK, DMBIC);
+               else
+                       dzaddr->dzbrk = (dz_brk[dz] &= ~(1 << (unit&07)));

                break;
                break;

+

        case TIOCSDTR:
        case TIOCSDTR:

-               dzmodem(dev, ON);
+               (void) dzmctl(dev, DZ_DTR|DZ_RTS, DMBIS);

                break;
                break;

+

        case TIOCCDTR:
        case TIOCCDTR:

-               dzmodem(dev, OFF);
+               (void) dzmctl(dev, DZ_DTR|DZ_RTS, DMBIC);
+               break;
+
+       case TIOCMSET:
+               (void) dzmctl(dev, dmtodz(*(int *)data), DMSET);
+               break;
+
+       case TIOCMBIS:
+               (void) dzmctl(dev, dmtodz(*(int *)data), DMBIS);
+               break;
+
+       case TIOCMBIC:
+               (void) dzmctl(dev, dmtodz(*(int *)data), DMBIC);
+               break;
+
+       case TIOCMGET:
+               *(int *)data = dztodm(dzmctl(dev, 0, DMGET));

                break;
                break;

+

        default:
        default:

-               u.u_error = ENOTTY;
+               return (ENOTTY);

        }
        }

+       return (0);
+}
+
+dmtodz(bits)
+       register int bits;
+{
+       register int b;
+
+       b = (bits >>1) & 0370;
+       if (bits & DML_ST) b |= DZ_ST;
+       if (bits & DML_RTS) b |= DZ_RTS;
+       if (bits & DML_DTR) b |= DZ_DTR;
+       if (bits & DML_LE) b |= DZ_LE;
+       return(b);
+}
+
+dztodm(bits)
+       register int bits;
+{
+       register int b;
+
+       b = (bits << 1) & 0360;
+       if (bits & DZ_DSR) b |= DML_DSR;
+       if (bits & DZ_DTR) b |= DML_DTR;
+       if (bits & DZ_ST) b |= DML_ST;
+       if (bits & DZ_RTS) b |= DML_RTS;
+       return(b);

 }
  
 }
  

-dzparam(dev)
+dzparam(unit)
+       register int unit;

 {
        register struct tty *tp;
 {
        register struct tty *tp;

-       register struct device *dzaddr;
-       register short lpr;
+       register struct dzdevice *dzaddr;
+       register int lpr;

  
  

-       tp = &dz_tty[dev];
-       dzaddr = dzpdma[dev].p_addr;
-       dzaddr->dzcsr = DZ_IEN;
-       dzact |= (1<<(dev>>3));
+       tp = &dz_tty[unit];
+       dzaddr = dzpdma[unit].p_addr;
+       if (dzsilos & (1 << (unit >> 3)))
+               dzaddr->dzcsr = DZ_IEN | DZ_SAE;
+       else
+               dzaddr->dzcsr = DZ_IEN;
+       dzact |= (1<<(unit>>3));

        if (tp->t_ispeed == 0) {
        if (tp->t_ispeed == 0) {

-               dzmodem(dev, OFF);              /* hang up line */
+               (void) dzmctl(unit, DZ_OFF, DMSET);     /* hang up line */

                return;
        }
                return;
        }

-       lpr = (dz_speeds[tp->t_ispeed]<<8) | (dev & 07);
-       if (tp->t_flags & RAW)
+       lpr = (dz_speeds[tp->t_ispeed]<<8) | (unit & 07);
+       if (tp->t_flags & (RAW|LITOUT|PASS8))

                lpr |= BITS8;
        else
                lpr |= (BITS7|PENABLE);
        if ((tp->t_flags & EVENP) == 0)
                lpr |= OPAR;
                lpr |= BITS8;
        else
                lpr |= (BITS7|PENABLE);
        if ((tp->t_flags & EVENP) == 0)
                lpr |= OPAR;

-       if (tp->t_ispeed == 3)
-               lpr |= TWOSB;                   /* 110 baud: 2 stop bits */
+       if (tp->t_ispeed == B110)
+               lpr |= TWOSB;

        dzaddr->dzlpr = lpr;
 }
  
 dzxint(tp)
        dzaddr->dzlpr = lpr;
 }
  
 dzxint(tp)

-register struct tty *tp;
+       register struct tty *tp;

 {
        register struct pdma *dp;
 {
        register struct pdma *dp;

-       register s;
-       s = spl6();     /* block the clock */
+       register dz, unit;

  
  

-       dp = &dzpdma[tp-dz_tty];
-       tp->t_state &= ~BUSY;
-       if (tp->t_state & FLUSH)
-               tp->t_state &= ~FLUSH;
-       else
-               ndflush(&tp->t_outq, dp->p_end-tp->t_outq.c_cf);
+       dp = (struct pdma *)tp->t_addr;
+       tp->t_state &= ~TS_BUSY;
+       if (tp->t_state & TS_FLUSH)
+               tp->t_state &= ~TS_FLUSH;
+       else {
+               ndflush(&tp->t_outq, dp->p_mem-tp->t_outq.c_cf);
+               dp->p_end = dp->p_mem = tp->t_outq.c_cf;
+       }

        if (tp->t_line)
                (*linesw[tp->t_line].l_start)(tp);
        else
                dzstart(tp);
        if (tp->t_line)
                (*linesw[tp->t_line].l_start)(tp);
        else
                dzstart(tp);

-       if (tp->t_outq.c_cc == 0 || (tp->t_state&BUSY)==0)
-               dp->p_addr->dztcr &= ~(1 << ((tp-dz_tty) % 8));
-       splx(s);
+       dz = minor(tp->t_dev) >> 3;
+       unit = minor(tp->t_dev) & 7;
+       if (tp->t_outq.c_cc == 0 || (tp->t_state&TS_BUSY)==0)
+               if (dp->p_addr->dzcsr & DZ_32)
+                       dp->p_addr->dzlnen = (dz_lnen[dz] &= ~(1<<unit));
+               else
+                       dp->p_addr->dztcr &= ~(1<<unit);

 }
 
 dzstart(tp)
 }
 
 dzstart(tp)

-register struct tty *tp;
+       register struct tty *tp;

 {
        register struct pdma *dp;
 {
        register struct pdma *dp;

-       register struct device *dzaddr;
-       register cc;
-       int sps;
+       register struct dzdevice *dzaddr;
+       register int cc;
+       int s, dz, unit;

  
  

-       dp = &dzpdma[tp-dz_tty];
+       dp = (struct pdma *)tp->t_addr;

        dzaddr = dp->p_addr;
        dzaddr = dp->p_addr;

-       sps = spl5();
-       if (tp->t_state & (TIMEOUT|BUSY|TTSTOP))
+       s = spl5();
+       if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP))

                goto out;
                goto out;

-       if (tp->t_outq.c_cc <= TTLOWAT && tp->t_state&ASLEEP) {
-               tp->t_state &= ~ASLEEP;
-               if (tp->t_chan)
-                       mcstart(tp->t_chan, (caddr_t)&tp->t_outq);
-               else
+       if (tp->t_outq.c_cc <= TTLOWAT(tp)) {
+               if (tp->t_state&TS_ASLEEP) {
+                       tp->t_state &= ~TS_ASLEEP;

                        wakeup((caddr_t)&tp->t_outq);
                        wakeup((caddr_t)&tp->t_outq);

+               }
+               if (tp->t_wsel) {
+                       selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL);
+                       tp->t_wsel = 0;
+                       tp->t_state &= ~TS_WCOLL;
+               }

        }
        if (tp->t_outq.c_cc == 0)
                goto out;
        }
        if (tp->t_outq.c_cc == 0)
                goto out;

-       if (tp->t_flags&RAW)
+       if (tp->t_flags & (RAW|LITOUT))

                cc = ndqb(&tp->t_outq, 0);
        else {
                cc = ndqb(&tp->t_outq, 0200);
                if (cc == 0) {
                        cc = getc(&tp->t_outq);
                cc = ndqb(&tp->t_outq, 0);
        else {
                cc = ndqb(&tp->t_outq, 0200);
                if (cc == 0) {
                        cc = getc(&tp->t_outq);

-                       timeout(ttrstrt, (caddr_t)tp, (cc&0177) + 6);
-                       tp->t_state |= TIMEOUT;
+                       timeout(ttrstrt, (caddr_t)tp, (cc&0x7f) + 6);
+                       tp->t_state |= TS_TIMEOUT;

                        goto out;
                }
        }
                        goto out;
                }
        }

-       tp->t_state |= BUSY;
+       tp->t_state |= TS_BUSY;

        dp->p_end = dp->p_mem = tp->t_outq.c_cf;
        dp->p_end += cc;
        dp->p_end = dp->p_mem = tp->t_outq.c_cf;
        dp->p_end += cc;

-       dzaddr->dztcr |= 1 << ((tp-dz_tty) % 8);
-   out:
-       splx(sps);
+       dz = minor(tp->t_dev) >> 3;
+       unit = minor(tp->t_dev) & 7;
+       if (dzaddr->dzcsr & DZ_32)
+               dzaddr->dzlnen = (dz_lnen[dz] |= (1<<unit));
+       else
+               dzaddr->dztcr |= (1<<unit);
+out:
+       splx(s);

 }
  
 /*
  * Stop output on a line.
 }
  
 /*
  * Stop output on a line.

- * Assume call is made at spl6.

  */
 /*ARGSUSED*/
 dzstop(tp, flag)
  */
 /*ARGSUSED*/
 dzstop(tp, flag)

-register struct tty *tp;
+       register struct tty *tp;

 {
        register struct pdma *dp;
        register int s;
 
 {
        register struct pdma *dp;
        register int s;
 

-       dp = &dzpdma[tp-dz_tty];
-       s = spl6();
-       if (tp->t_state & BUSY) {
+       dp = (struct pdma *)tp->t_addr;
+       s = spl5();
+       if (tp->t_state & TS_BUSY) {

                dp->p_end = dp->p_mem;
                dp->p_end = dp->p_mem;

-               if ((tp->t_state&TTSTOP)==0) {
-                       tp->t_state |= FLUSH;
-               }
+               if ((tp->t_state&TS_TTSTOP)==0)
+                       tp->t_state |= TS_FLUSH;

        }
        splx(s);
 }
  
        }
        splx(s);
 }
  

-dzmodem(dev, flag)
-register int dev;
+dzmctl(dev, bits, how)
+       dev_t dev;
+       int bits, how;

 {
 {

-       register struct device *dzaddr;
-       register char bit;
- 
-       dzaddr = dzpdma[dev].p_addr;
-       bit = 1<<(dev&07);
-       if (flag == OFF)
-               dzaddr->dzdtr &= ~bit;
-       else
-               dzaddr->dzdtr |= bit;
+       register struct dzdevice *dzaddr;
+       register int unit, mbits;
+       int b, s;
+
+       unit = minor(dev);
+       b = 1<<(unit&7);
+       dzaddr = dzpdma[unit].p_addr;
+       s = spl5();
+       if (dzaddr->dzcsr & DZ_32) {
+               dzwait(dzaddr)
+               DELAY(100);             /* IS 100 TOO MUCH? */
+               dzaddr->dzlcs = unit&7;
+               DELAY(100);
+               dzwait(dzaddr)
+               DELAY(100);
+               mbits = dzaddr->dzlcs;
+               mbits &= 0177770;
+       } else {
+               mbits = (dzaddr->dzdtr & b) ? DZ_DTR : 0;
+               mbits |= (dzaddr->dzmsr & b) ? DZ_CD : 0;
+               mbits |= (dzaddr->dztbuf & b) ? DZ_RI : 0;
+       }
+       switch (how) {
+       case DMSET:
+               mbits = bits;
+               break;
+
+       case DMBIS:
+               mbits |= bits;
+               break;
+
+       case DMBIC:
+               mbits &= ~bits;
+               break;
+
+       case DMGET:
+               (void) splx(s);
+               return(mbits);
+       }
+       if (dzaddr->dzcsr & DZ_32) {
+               mbits |= DZ_ACK|(unit&7);
+               dzaddr->dzlcs = mbits;
+       } else {
+               if (mbits & DZ_DTR)
+                       dzaddr->dzdtr |= b;
+               else
+                       dzaddr->dzdtr &= ~b;
+       }
+       (void) splx(s);
+       return(mbits);

 }
  
 }
  

+int dztransitions, dzfasttimers;               /*DEBUG*/

 dzscan()
 {
        register i;
 dzscan()
 {
        register i;

-       register struct device *dzaddr;
+       register struct dzdevice *dzaddr;

        register bit;
        register struct tty *tp;
        register bit;
        register struct tty *tp;

+       register car;
+       int olddzsilos = dzsilos;
+       int dztimer();

  
        for (i = 0; i < dz_cnt ; i++) {
                dzaddr = dzpdma[i].p_addr;
  
        for (i = 0; i < dz_cnt ; i++) {
                dzaddr = dzpdma[i].p_addr;

+               if (dzaddr == 0)
+                       continue;

                tp = &dz_tty[i];
                bit = 1<<(i&07);
                tp = &dz_tty[i];
                bit = 1<<(i&07);

-               if (dzaddr->dzmsr & bit) {
+               car = 0;
+               if (dzsoftCAR[i>>3]&bit)
+                       car = 1;
+               else if (dzaddr->dzcsr & DZ_32) {
+                       dzaddr->dzlcs = i&07;
+                       dzwait(dzaddr);
+                       car = dzaddr->dzlcs & DZ_CD;
+               } else
+                       car = dzaddr->dzmsr&bit;
+               if (car) {

                        /* carrier present */
                        /* carrier present */

-                       if ((tp->t_state & CARR_ON) == 0) {
-                               wakeup((caddr_t)&tp->t_rawq);
-                               tp->t_state |= CARR_ON;
-                       }
-               } else {
-                       if ((tp->t_state & CARR_ON)) {
-                               /* carrier lost */
-                               if (tp->t_state&ISOPEN &&
-                                   (tp->t_local&LNOHANG) == 0) {
-                                       gsignal(tp->t_pgrp, SIGHUP);
-                                       gsignal(tp->t_pgrp, SIGCONT);
-                                       dzaddr->dzdtr &= ~bit;
-                                       flushtty(tp);
-                               }
-                               tp->t_state &= ~CARR_ON;
-                       }
+                       if ((tp->t_state & TS_CARR_ON) == 0)
+                               (void)(*linesw[tp->t_line].l_modem)(tp, 1);
+               } else if ((tp->t_state&TS_CARR_ON) &&
+                   (*linesw[tp->t_line].l_modem)(tp, 0) == 0)
+                       dzaddr->dzdtr &= ~bit;
+       }
+       for (i = 0; i < NDZ; i++) {
+               ave(dzrate[i], dzchars[i], 8);
+               if (dzchars[i] > dzhighrate && ((dzsilos & (1 << i)) == 0)) {
+                       dzpdma[i << 3].p_addr->dzcsr = DZ_IEN | DZ_SAE;
+                       dzsilos |= (1 << i);
+                       dztransitions++;                /*DEBUG*/
+               } else if ((dzsilos & (1 << i)) && (dzrate[i] < dzlowrate)) {
+                       dzpdma[i << 3].p_addr->dzcsr = DZ_IEN;
+                       dzsilos &= ~(1 << i);

                }
                }

+               dzchars[i] = 0;

        }
        }

-       timeout(dzscan, (caddr_t)0, 2*HZ);
+       if (dzsilos && !olddzsilos)
+               timeout(dztimer, (caddr_t)0, dztimerintvl);
+       timeout(dzscan, (caddr_t)0, hz);

 }
 
 dztimer()
 {
 }
 
 dztimer()
 {

+       register int dz;
+       register int s;
+
+       if (dzsilos == 0)
+               return;
+       s = spl5();
+       dzfasttimers++;         /*DEBUG*/
+       for (dz = 0; dz < NDZ; dz++)
+               if (dzsilos & (1 << dz))
+                   dzrint(dz);
+       splx(s);
+       timeout(dztimer, (caddr_t) 0, dztimerintvl);
+}
+
+/*
+ * Reset state of driver if UBA reset was necessary.
+ * Reset parameters and restart transmission on open lines.
+ */
+dzreset(uban)
+       int uban;
+{
+       register int unit;
+       register struct tty *tp;
+       register struct uba_device *ui;

 
 

-       dzrint(0);
+       for (unit = 0; unit < NDZLINE; unit++) {
+               ui = dzinfo[unit >> 3];
+               if (ui == 0 || ui->ui_ubanum != uban || ui->ui_alive == 0)
+                       continue;
+               if (unit%8 == 0)
+                       printf(" dz%d", unit>>3);
+               tp = &dz_tty[unit];
+               if (tp->t_state & (TS_ISOPEN|TS_WOPEN)) {
+                       dzparam(unit);
+                       (void) dzmctl(unit, DZ_ON, DMSET);
+                       tp->t_state &= ~TS_BUSY;
+                       dzstart(tp);
+               }
+       }

 }
 }

+#endif