projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
typo
[unix-history] / usr / src / sys / vax / uba / dh.c
diff --git a/usr/src/sys/vax/uba/dh.c b/usr/src/sys/vax/uba/dh.c
index a853d5d..05c1900 100644 (file)
--- a/usr/src/sys/vax/uba/dh.c
+++ b/usr/src/sys/vax/uba/dh.c
@@ -1,112 +1,119 @@
-/*     dh.c    4.16    81/02/17        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)dh.c        7.5 (Berkeley) %G%
+ */
 
 #include "dh.h"
 
 #include "dh.h"
-#if NDH11 > 0
-#define        DELAY(i)        { register int j = i; while (--j > 0); }
+#if NDH > 0
 /*
 /*
- * DH-11 driver
+ * DH-11/DM-11 driver
  */
  */
-#include "../h/param.h"
-#include "../h/conf.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/tty.h"
-#include "../h/map.h"
-#include "../h/pte.h"
-#include "../h/buf.h"
-#include "../h/uba.h"
-#include "../h/bk.h"
-#include "../h/clist.h"
-#include "../h/mx.h"
-#include "../h/file.h"
-
-#define        UBACVT(x, uban)         (cbase[uban] + ((x)-(char *)cfree))
+#include "../machine/pte.h"
+
+#include "bk.h"
+#include "uba.h"
+#include "param.h"
+#include "conf.h"
+#include "dir.h"
+#include "user.h"
+#include "proc.h"
+#include "ioctl.h"
+#include "tty.h"
+#include "map.h"
+#include "buf.h"
+#include "vm.h"
+#include "kernel.h"
+#include "syslog.h"
+
+#include "ubareg.h"
+#include "ubavar.h"
+#include "dhreg.h"
+#include "dmreg.h"
+
+#include "bkmac.h"
+#include "clist.h"
+#include "file.h"
+#include "uio.h"
 
 /*
 
 /*
- * Definition of the controller for the auto-configuration program.
+ * Definition of the driver for the auto-configuration program.
+ * There is one definition for the dh and one for the dm.
  */
  */
-int    dhcntrlr(), dhslave(), dhrint(), dhxint();
-struct uba_dinfo *dhinfo[NDH11];
+int    dhprobe(), dhattach(), dhrint(), dhxint(), dhtimer();
+struct uba_device *dhinfo[NDH];
 u_short        dhstd[] = { 0 };
 struct uba_driver dhdriver =
 u_short        dhstd[] = { 0 };
 struct uba_driver dhdriver =
-       { dhcntrlr, dhslave, 0, 0, dhstd, "dh", dhinfo };
-
-struct tty dh11[NDH11*16];
-int    dhact;
-int    ndh11   = NDH11*16;
-int    dhstart();
-int    ttrstrt();
-int    dh_ubinfo[MAXNUBA];
-int    cbase[MAXNUBA];
-
-/* Bits in dhlpr */
-#define        BITS6   01
-#define        BITS7   02
-#define        BITS8   03
-#define        TWOSB   04
-#define        PENABLE 020
-/* DEC manuals incorrectly say this bit causes generation of even parity. */
-#define        OPAR    040
-#define        HDUPLX  040000
-
-/* Bits in dhcsr */
-#define        DH_TI   0100000         /* transmit interrupt */
-#define        DH_SI   0040000         /* storage interrupt */
-#define        DH_TIE  0020000         /* transmit interrupt enable */
-#define        DH_SIE  0010000         /* storage interrupt enable */
-#define        DH_MC   0004000         /* master clear */
-#define        DH_NXM  0002000         /* non-existant memory */
-#define        DH_MM   0001000         /* maintenance mode */
-#define        DH_CNI  0000400         /* clear non-existant memory interrupt */
-#define        DH_RI   0000200         /* receiver interrupt */
-#define        DH_RIE  0000100         /* receiver interrupt enable */
-
-#define        DH_IE   (DH_TIE|DH_SIE|DH_RIE)
-
-/* Bits in dhrcr */
-#define        DH_PE   010000          /* parity error */
-#define        DH_FE   020000          /* framing error */
-#define        DH_DO   040000          /* data overrun */
+       { dhprobe, 0, dhattach, 0, dhstd, "dh", dhinfo };
+
+int    dmprobe(), dmattach(), dmintr();
+struct uba_device *dminfo[NDH];
+u_short        dmstd[] = { 0 };
+struct uba_driver dmdriver =
+       { dmprobe, 0, dmattach, 0, dmstd, "dm", dminfo };
+
+#ifndef        PORTSELECTOR
+#define        ISPEED  B9600
+#define        IFLAGS  (EVENP|ODDP|ECHO)
+#else
+#define        ISPEED  B4800
+#define        IFLAGS  (EVENP|ODDP)
+#endif
+
+#define        FASTTIMER       (hz/30)         /* scan rate with silos on */
 
 /*
 
 /*
- * DM control bits
+ * Local variables for the driver
  */
  */
-#define        DM_ON   03      /* CD lead + line enable */
-#define        DM_OFF  01      /* line enable */
-#define        DM_DTR  02      /* data terminal ready */
-#define        DM_RQS  04      /* request to send */
+short  dhsar[NDH];                     /* software copy of last bar */
+short  dhsoftCAR[NDH];
+
+struct tty dh11[NDH*16];
+int    ndh11   = NDH*16;
+int    dhact;                          /* mask of active dh's */
+int    dhsilos;                        /* mask of dh's with silo in use */
+int    dhchars[NDH];                   /* recent input count */
+int    dhrate[NDH];                    /* smoothed input count */
+int    dhhighrate = 100;               /* silo on if dhchars > dhhighrate */
+int    dhlowrate = 75;                 /* silo off if dhrate < dhlowrate */
+static short timerstarted;
+int    dhstart(), ttrstrt();
 
 
-/* Software copy of last dhbar */
-short  dhsar[NDH11];
-
-struct device
-{
-       union {
-               short   dhcsr;          /* control-status register */
-               char    dhcsrl;         /* low byte for line select */
-       } un;
-       short   dhrcr;                  /* receive character register */
-       short   dhlpr;                  /* line parameter register */
-       u_short dhcar;                  /* current address register */
-       short   dhbcr;                  /* byte count register */
-       u_short dhbar;                  /* buffer active register */
-       short   dhbreak;                /* break control register */
-       short   dhsilo;                 /* silo status register */
-};
+/*
+ * The clist space is mapped by one terminal driver onto each UNIBUS.
+ * The identity of the board which allocated resources is recorded,
+ * so the process may be repeated after UNIBUS resets.
+ * The UBACVT macro converts a clist space address for unibus uban
+ * into an i/o space address for the DMA routine.
+ */
+int    dh_uballoc[NUBA];       /* which dh (if any) allocated unibus map */
+int    cbase[NUBA];            /* base address of clists in unibus map */
+#define        UBACVT(x, uban)         (cbase[uban] + ((x)-(char *)cfree))
 
 /*
  * Routine for configuration to force a dh to interrupt.
  * Set to transmit at 9600 baud, and cause a transmitter interrupt.
  */
 /*ARGSUSED*/
 
 /*
  * Routine for configuration to force a dh to interrupt.
  * Set to transmit at 9600 baud, and cause a transmitter interrupt.
  */
 /*ARGSUSED*/
-dhcntrlr(ui, reg)
-       struct uba_dinfo *ui;
+dhprobe(reg)
        caddr_t reg;
 {
        register int br, cvec;          /* these are ``value-result'' */
        caddr_t reg;
 {
        register int br, cvec;          /* these are ``value-result'' */
-       register struct device *dhaddr = (struct device *)reg;
-       int i;
-
+       register struct dhdevice *dhaddr = (struct dhdevice *)reg;
+
+#ifdef lint
+       br = 0; cvec = br; br = cvec;
+       if (ndh11 == 0) ndh11 = 1;
+       dhrint(0); dhxint(0);
+#endif
+#ifndef notdef
+       dhaddr->un.dhcsr = DH_RIE|DH_MM|DH_RI;
+       DELAY(1000);
+       dhaddr->un.dhcsr &= ~DH_RI;
+       dhaddr->un.dhcsr = 0;
+#else
        dhaddr->un.dhcsr = DH_TIE;
        DELAY(5);
        dhaddr->dhlpr = (B9600 << 10) | (B9600 << 6) | BITS7|PENABLE;
        dhaddr->un.dhcsr = DH_TIE;
        DELAY(5);
        dhaddr->dhlpr = (B9600 << 10) | (B9600 << 6) | BITS7|PENABLE;
@@ -117,18 +124,47 @@ dhcntrlr(ui, reg)
        dhaddr->un.dhcsr = 0;
        if (cvec && cvec != 0x200)
                cvec -= 4;              /* transmit -> receive */
        dhaddr->un.dhcsr = 0;
        if (cvec && cvec != 0x200)
                cvec -= 4;              /* transmit -> receive */
-       return (1);
+#endif
+       return (sizeof (struct dhdevice));
+}
+
+/*
+ * Routine called to attach a dh.
+ */
+dhattach(ui)
+       struct uba_device *ui;
+{
+
+       dhsoftCAR[ui->ui_unit] = ui->ui_flags;
+       cbase[ui->ui_ubanum] = -1;
+       dh_uballoc[ui->ui_unit] = -1;
 }
 
 /*
 }
 
 /*
- * Routine called to init slave tables.
+ * Configuration routine to cause a dm to interrupt.
  */
  */
-dhslave(ui, reg, slaveno)
-       struct uba_dinfo *ui;
+dmprobe(reg)
        caddr_t reg;
 {
        caddr_t reg;
 {
+       register int br, vec;                   /* value-result */
+       register struct dmdevice *dmaddr = (struct dmdevice *)reg;
+
+#ifdef lint
+       br = 0; vec = br; br = vec;
+       dmintr(0);
+#endif
+       dmaddr->dmcsr = DM_DONE|DM_IE;
+       DELAY(20);
+       dmaddr->dmcsr = 0;
+       return (1);
+}
+
+/*ARGSUSED*/
+dmattach(ui)
+       struct uba_device *ui;
+{
 
 
-       /* no tables to set up */
+       /* no local state to set up */
 }
 
 /*
 }
 
 /*
@@ -142,62 +178,64 @@ dhopen(dev, flag)
 {
        register struct tty *tp;
        register int unit, dh;
 {
        register struct tty *tp;
        register int unit, dh;
-       register struct device *addr;
-       register struct uba_dinfo *ui;
+       register struct dhdevice *addr;
+       register struct uba_device *ui;
        int s;
 
        unit = minor(dev);
        dh = unit >> 4;
        int s;
 
        unit = minor(dev);
        dh = unit >> 4;
-       if (unit >= NDH11*16 || (ui = dhinfo[dh])== 0 || ui->ui_alive == 0) {
-               u.u_error = ENXIO;
-               return;
-       }
+       if (unit >= NDH*16 || (ui = dhinfo[dh])== 0 || ui->ui_alive == 0)
+               return (ENXIO);
        tp = &dh11[unit];
        tp = &dh11[unit];
-       if (tp->t_state&XCLUDE && u.u_uid!=0) {
-               u.u_error = EBUSY;
-               return;
-       }
-       addr = (struct device *)ui->ui_addr;
+       if (tp->t_state&TS_XCLUDE && u.u_uid!=0)
+               return (EBUSY);
+       addr = (struct dhdevice *)ui->ui_addr;
        tp->t_addr = (caddr_t)addr;
        tp->t_oproc = dhstart;
        tp->t_addr = (caddr_t)addr;
        tp->t_oproc = dhstart;
-       tp->t_iproc = NULL;
-       tp->t_state |= WOPEN;
+       tp->t_state |= TS_WOPEN;
        /*
         * While setting up state for this uba and this dh,
         * block uba resets which can clear the state.
         */
        s = spl5();
        /*
         * While setting up state for this uba and this dh,
         * block uba resets which can clear the state.
         */
        s = spl5();
-       if (dh_ubinfo[ui->ui_ubanum] == 0) {
-               /* 512+ is a kludge to try to get around a hardware problem */
-               dh_ubinfo[ui->ui_ubanum] =
-                   uballoc(ui->ui_ubanum, (caddr_t)cfree,
-                       512+NCLIST*sizeof(struct cblock), 0);
-               cbase[ui->ui_ubanum] = dh_ubinfo[ui->ui_ubanum]&0x3ffff;
+       if (cbase[ui->ui_ubanum] == -1) {
+               dh_uballoc[ui->ui_ubanum] = dh;
+               cbase[ui->ui_ubanum] = UBAI_ADDR(uballoc(ui->ui_ubanum,
+                   (caddr_t)cfree, nclist*sizeof(struct cblock), 0));
+       }
+       if (timerstarted == 0) {
+               timerstarted++;
+               timeout(dhtimer, (caddr_t) 0, hz);
        }
        if ((dhact&(1<<dh)) == 0) {
                addr->un.dhcsr |= DH_IE;
        }
        if ((dhact&(1<<dh)) == 0) {
                addr->un.dhcsr |= DH_IE;
-               DELAY(5);
                dhact |= (1<<dh);
                dhact |= (1<<dh);
-               addr->dhsilo = 16;
+               addr->dhsilo = 0;
        }
        splx(s);
        /*
        }
        splx(s);
        /*
-        * If this is first open, initialze tty state to default.
+        * If this is first open, initialize tty state to default.
         */
         */
-       if ((tp->t_state&ISOPEN) == 0) {
+       if ((tp->t_state&TS_ISOPEN) == 0) {
                ttychars(tp);
                ttychars(tp);
+#ifndef PORTSELECTOR
                if (tp->t_ispeed == 0) {
                if (tp->t_ispeed == 0) {
-                       tp->t_ispeed = B300;
-                       tp->t_ospeed = B300;
-                       tp->t_flags = ODDP|EVENP|ECHO;
+#else
+                       tp->t_state |= TS_HUPCLS;
+#endif PORTSELECTOR
+                       tp->t_ispeed = ISPEED;
+                       tp->t_ospeed = ISPEED;
+                       tp->t_flags = IFLAGS;
+#ifndef PORTSELECTOR
                }
                }
+#endif PORTSELECTOR
                dhparam(unit);
        }
        /*
         * Wait for carrier, then process line discipline specific open.
         */
        dmopen(dev);
                dhparam(unit);
        }
        /*
         * Wait for carrier, then process line discipline specific open.
         */
        dmopen(dev);
-       (*linesw[tp->t_line].l_open)(dev, tp);
+       return ((*linesw[tp->t_line].l_open)(dev, tp));
 }
 
 /*
 }
 
 /*
@@ -214,28 +252,28 @@ dhclose(dev, flag)
        unit = minor(dev);
        tp = &dh11[unit];
        (*linesw[tp->t_line].l_close)(tp);
        unit = minor(dev);
        tp = &dh11[unit];
        (*linesw[tp->t_line].l_close)(tp);
-       ((struct device *)(tp->t_addr))->dhbreak &= ~(1<<(unit&017));
-       if (tp->t_state&HUPCLS || (tp->t_state&ISOPEN)==0)
-               dmctl(unit, DM_OFF, DMSET);
+       ((struct dhdevice *)(tp->t_addr))->dhbreak &= ~(1<<(unit&017));
+       if (tp->t_state&TS_HUPCLS || (tp->t_state&TS_ISOPEN)==0)
+               dmctl(unit, DML_OFF, DMSET);
        ttyclose(tp);
 }
 
        ttyclose(tp);
 }
 
-dhread(dev)
+dhread(dev, uio)
        dev_t dev;
        dev_t dev;
+       struct uio *uio;
 {
 {
-       register struct tty *tp;
+       register struct tty *tp = &dh11[minor(dev)];
 
 
-       tp = &dh11[minor(dev)];
-       (*linesw[tp->t_line].l_read)(tp);
+       return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
 
 }
 
-dhwrite(dev)
+dhwrite(dev, uio)
        dev_t dev;
        dev_t dev;
+       struct uio *uio;
 {
 {
-       register struct tty *tp;
+       register struct tty *tp = &dh11[minor(dev)];
 
 
-       tp = &dh11[minor(dev)];
-       (*linesw[tp->t_line].l_write)(tp);
+       return ((*linesw[tp->t_line].l_write)(tp, uio));
 }
 
 /*
 }
 
 /*
@@ -246,13 +284,15 @@ dhrint(dh)
 {
        register struct tty *tp;
        register c;
 {
        register struct tty *tp;
        register c;
-       register struct device *addr;
+       register struct dhdevice *addr;
        register struct tty *tp0;
        register struct tty *tp0;
-       register struct uba_dinfo *ui;
-       int s;
+       register struct uba_device *ui;
+       int overrun = 0;
 
        ui = dhinfo[dh];
 
        ui = dhinfo[dh];
-       addr = (struct device *)ui->ui_addr;
+       if (ui == 0 || ui->ui_alive == 0)
+               return;
+       addr = (struct dhdevice *)ui->ui_addr;
        tp0 = &dh11[dh<<4];
        /*
         * Loop fetching characters from the silo for this
        tp0 = &dh11[dh<<4];
        /*
         * Loop fetching characters from the silo for this
@@ -260,16 +300,22 @@ dhrint(dh)
         */
        while ((c = addr->dhrcr) < 0) {
                tp = tp0 + ((c>>8)&0xf);
         */
        while ((c = addr->dhrcr) < 0) {
                tp = tp0 + ((c>>8)&0xf);
-               if ((tp->t_state&ISOPEN)==0) {
-                       wakeup((caddr_t)tp);
-                       continue;
+               dhchars[dh]++;
+               if ((tp->t_state&TS_ISOPEN)==0) {
+                       wakeup((caddr_t)&tp->t_rawq);
+#ifdef PORTSELECTOR
+                       if ((tp->t_state&TS_WOPEN) == 0)
+#endif
+                               continue;
                }
                if (c & DH_PE)
                        if ((tp->t_flags&(EVENP|ODDP))==EVENP
                         || (tp->t_flags&(EVENP|ODDP))==ODDP )
                                continue;
                }
                if (c & DH_PE)
                        if ((tp->t_flags&(EVENP|ODDP))==EVENP
                         || (tp->t_flags&(EVENP|ODDP))==ODDP )
                                continue;
-               if (c & DH_DO)
-                       printf("O");
+               if ((c & DH_DO) && overrun == 0) {
+                       log(LOG_WARNING, "dh%d: silo overflow\n", dh);
+                       overrun = 1;
+               }
                if (c & DH_FE)
                        /*
                         * At framing error (break) generate
                if (c & DH_FE)
                        /*
                         * At framing error (break) generate
@@ -279,11 +325,13 @@ dhrint(dh)
                        if (tp->t_flags&RAW)
                                c = 0;
                        else
                        if (tp->t_flags&RAW)
                                c = 0;
                        else
-                               c = tun.t_intrc;
+                               c = tp->t_intrc;
+#if NBK > 0
                if (tp->t_line == NETLDISC) {
                        c &= 0177;
                        BKINPUT(c, tp);
                } else
                if (tp->t_line == NETLDISC) {
                        c &= 0177;
                        BKINPUT(c, tp);
                } else
+#endif
                        (*linesw[tp->t_line].l_rint)(c, tp);
        }
 }
                        (*linesw[tp->t_line].l_rint)(c, tp);
        }
 }
@@ -292,35 +340,46 @@ dhrint(dh)
  * Ioctl for DH11.
  */
 /*ARGSUSED*/
  * Ioctl for DH11.
  */
 /*ARGSUSED*/
-dhioctl(dev, cmd, addr, flag)
-       caddr_t addr;
+dhioctl(dev, cmd, data, flag)
+       caddr_t data;
 {
        register struct tty *tp;
 {
        register struct tty *tp;
-       register unit = minor(dev);
+       register int unit = minor(dev);
+       int error;
 
        tp = &dh11[unit];
 
        tp = &dh11[unit];
-       cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr);
-       if (cmd == 0)
-               return;
-       if (ttioctl(tp, cmd, addr, flag)) {
-               if (cmd==TIOCSETP || cmd==TIOCSETN)
+       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)
                        dhparam(unit);
                        dhparam(unit);
-       } else switch(cmd) {
+               return (error);
+       }
+       switch (cmd) {
+
        case TIOCSBRK:
        case TIOCSBRK:
-               ((struct device *)(tp->t_addr))->dhbreak |= 1<<(unit&017);
+               ((struct dhdevice *)(tp->t_addr))->dhbreak |= 1<<(unit&017);
                break;
                break;
+
        case TIOCCBRK:
        case TIOCCBRK:
-               ((struct device *)(tp->t_addr))->dhbreak &= ~(1<<(unit&017));
+               ((struct dhdevice *)(tp->t_addr))->dhbreak &= ~(1<<(unit&017));
                break;
                break;
+
        case TIOCSDTR:
        case TIOCSDTR:
-               dmctl(unit, DM_DTR|DM_RQS, DMBIS);
+               dmctl(unit, DML_DTR|DML_RTS, DMBIS);
                break;
                break;
+
        case TIOCCDTR:
        case TIOCCDTR:
-               dmctl(unit, DM_DTR|DM_RQS, DMBIC);
+               dmctl(unit, DML_DTR|DML_RTS, DMBIC);
                break;
                break;
+
        default:
        default:
-               u.u_error = ENOTTY;
+               return (ENOTTY);
        }
        }
+       return (0);
 }
 
 /*
 }
 
 /*
@@ -331,12 +390,12 @@ dhparam(unit)
        register int unit;
 {
        register struct tty *tp;
        register int unit;
 {
        register struct tty *tp;
-       register struct device *addr;
+       register struct dhdevice *addr;
        register int lpar;
        int s;
 
        tp = &dh11[unit];
        register int lpar;
        int s;
 
        tp = &dh11[unit];
-       addr = (struct device *)tp->t_addr;
+       addr = (struct dhdevice *)tp->t_addr;
        /*
         * Block interrupts so parameters will be set
         * before the line interrupts.
        /*
         * Block interrupts so parameters will be set
         * before the line interrupts.
@@ -344,14 +403,15 @@ dhparam(unit)
        s = spl5();
        addr->un.dhcsrl = (unit&0xf) | DH_IE;
        if ((tp->t_ispeed)==0) {
        s = spl5();
        addr->un.dhcsrl = (unit&0xf) | DH_IE;
        if ((tp->t_ispeed)==0) {
-               tp->t_state |= HUPCLS;
-               dmctl(unit, DM_OFF, DMSET);
+               tp->t_state |= TS_HUPCLS;
+               dmctl(unit, DML_OFF, DMSET);
+               splx(s);
                return;
        }
        lpar = ((tp->t_ospeed)<<10) | ((tp->t_ispeed)<<6);
        if ((tp->t_ispeed) == B134)
                lpar |= BITS6|PENABLE|HDUPLX;
                return;
        }
        lpar = ((tp->t_ospeed)<<10) | ((tp->t_ispeed)<<6);
        if ((tp->t_ispeed) == B134)
                lpar |= BITS6|PENABLE|HDUPLX;
-       else if ((tp->t_flags&RAW) || (tp->t_local&LLITOUT))
+       else if (tp->t_flags & (RAW|LITOUT|PASS8))
                lpar |= BITS8;
        else
                lpar |= BITS7|PENABLE;
                lpar |= BITS8;
        else
                lpar |= BITS7|PENABLE;
@@ -372,19 +432,17 @@ dhxint(dh)
        int dh;
 {
        register struct tty *tp;
        int dh;
 {
        register struct tty *tp;
-       register struct device *addr;
+       register struct dhdevice *addr;
        short ttybit, bar, *sbar;
        short ttybit, bar, *sbar;
-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;
        register int unit;
        register int unit;
-       int s;
-       u_short cnt;
+       u_short cntr;
 
        ui = dhinfo[dh];
 
        ui = dhinfo[dh];
-       addr = (struct device *)ui->ui_addr;
+       addr = (struct dhdevice *)ui->ui_addr;
        if (addr->un.dhcsr & DH_NXM) {
        if (addr->un.dhcsr & DH_NXM) {
-               DELAY(5);
                addr->un.dhcsr |= DH_CNI;
                addr->un.dhcsr |= DH_CNI;
-               printf("dh%d NXM\n", dh);
+               printf("dh%d: NXM\n", dh);
        }
        sbar = &dhsar[dh];
        bar = *sbar & ~addr->dhbar;
        }
        sbar = &dhsar[dh];
        bar = *sbar & ~addr->dhbar;
@@ -395,19 +453,18 @@ dhxint(dh)
                        *sbar &= ~ttybit;
                        bar &= ~ttybit;
                        tp = &dh11[unit];
                        *sbar &= ~ttybit;
                        bar &= ~ttybit;
                        tp = &dh11[unit];
-                       tp->t_state &= ~BUSY;
-                       if (tp->t_state&FLUSH)
-                               tp->t_state &= ~FLUSH;
+                       tp->t_state &= ~TS_BUSY;
+                       if (tp->t_state&TS_FLUSH)
+                               tp->t_state &= ~TS_FLUSH;
                        else {
                                addr->un.dhcsrl = (unit&017)|DH_IE;
                        else {
                                addr->un.dhcsrl = (unit&017)|DH_IE;
-                               DELAY(5);
                                /*
                                 * Do arithmetic in a short to make up
                                 * for lost 16&17 bits.
                                 */
                                /*
                                 * Do arithmetic in a short to make up
                                 * for lost 16&17 bits.
                                 */
-                               cnt = addr->dhcar -
+                               cntr = addr->dhcar -
                                    UBACVT(tp->t_outq.c_cf, ui->ui_ubanum);
                                    UBACVT(tp->t_outq.c_cf, ui->ui_ubanum);
-                               ndflush(&tp->t_outq, cnt);
+                               ndflush(&tp->t_outq, (int)cntr);
                        }
                        if (tp->t_line)
                                (*linesw[tp->t_line].l_start)(tp);
                        }
                        if (tp->t_line)
                                (*linesw[tp->t_line].l_start)(tp);
@@ -423,14 +480,14 @@ dhxint(dh)
 dhstart(tp)
        register struct tty *tp;
 {
 dhstart(tp)
        register struct tty *tp;
 {
-       register struct device *addr;
+       register struct dhdevice *addr;
        register int car, dh, unit, nch;
        int s;
 
        unit = minor(tp->t_dev);
        dh = unit >> 4;
        unit &= 0xf;
        register int car, dh, unit, nch;
        int s;
 
        unit = minor(tp->t_dev);
        dh = unit >> 4;
        unit &= 0xf;
-       addr = (struct device *)tp->t_addr;
+       addr = (struct dhdevice *)tp->t_addr;
 
        /*
         * Must hold interrupts in following code to prevent
 
        /*
         * Must hold interrupts in following code to prevent
@@ -440,18 +497,22 @@ dhstart(tp)
        /*
         * If it's currently active, or delaying, no need to do anything.
         */
        /*
         * If it's currently active, or delaying, no need to do anything.
         */
-       if (tp->t_state&(TIMEOUT|BUSY|TTSTOP))
+       if (tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP))
                goto out;
        /*
         * If there are sleepers, and output has drained below low
         * water mark, wake up the sleepers.
         */
                goto out;
        /*
         * If there are sleepers, and output has drained below low
         * water mark, wake up the sleepers.
         */
-       if ((tp->t_state&ASLEEP) && tp->t_outq.c_cc<=TTLOWAT(tp)) {
-               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;
+               }
        }
        /*
         * Now restart transmission unless the output queue is
        }
        /*
         * Now restart transmission unless the output queue is
@@ -459,7 +520,7 @@ dhstart(tp)
         */
        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))
                nch = ndqb(&tp->t_outq, 0);
        else {
                nch = ndqb(&tp->t_outq, 0200);
                nch = ndqb(&tp->t_outq, 0);
        else {
                nch = ndqb(&tp->t_outq, 0200);
@@ -469,7 +530,7 @@ dhstart(tp)
                if (nch == 0) {
                        nch = getc(&tp->t_outq);
                        timeout(ttrstrt, (caddr_t)tp, (nch&0x7f)+6);
                if (nch == 0) {
                        nch = getc(&tp->t_outq);
                        timeout(ttrstrt, (caddr_t)tp, (nch&0x7f)+6);
-                       tp->t_state |= TIMEOUT;
+                       tp->t_state |= TS_TIMEOUT;
                        goto out;
                }
        }
                        goto out;
                }
        }
@@ -479,13 +540,18 @@ dhstart(tp)
        if (nch) {
                car = UBACVT(tp->t_outq.c_cf, dhinfo[dh]->ui_ubanum);
                addr->un.dhcsrl = unit|((car>>12)&0x30)|DH_IE;
        if (nch) {
                car = UBACVT(tp->t_outq.c_cf, dhinfo[dh]->ui_ubanum);
                addr->un.dhcsrl = unit|((car>>12)&0x30)|DH_IE;
-               DELAY(5);
-               unit = 1 << unit;
-               dhsar[dh] |= unit;
+               /*
+                * The following nonsense with short word
+                * is to make sure the dhbar |= word below
+                * is done with an interlocking bisw2 instruction.
+                */
+               { short word = 1 << unit;
+               dhsar[dh] |= word;
                addr->dhcar = car;
                addr->dhbcr = -nch;
                addr->dhcar = car;
                addr->dhbcr = -nch;
-               addr->dhbar |= unit;
-               tp->t_state |= BUSY;
+               addr->dhbar |= word;
+               }
+               tp->t_state |= TS_BUSY;
        }
 out:
        splx(s);
        }
 out:
        splx(s);
@@ -498,15 +564,15 @@ out:
 dhstop(tp, flag)
        register struct tty *tp;
 {
 dhstop(tp, flag)
        register struct tty *tp;
 {
-       register struct device *addr;
+       register struct dhdevice *addr;
        register int unit, s;
 
        register int unit, s;
 
-       addr = (struct device *)tp->t_addr;
+       addr = (struct dhdevice *)tp->t_addr;
        /*
         * Block input/output interrupts while messing with state.
         */
        s = spl5();
        /*
         * Block input/output interrupts while messing with state.
         */
        s = spl5();
-       if (tp->t_state & BUSY) {
+       if (tp->t_state & TS_BUSY) {
                /*
                 * Device is transmitting; stop output
                 * by selecting the line and setting the byte
                /*
                 * Device is transmitting; stop output
                 * by selecting the line and setting the byte
@@ -515,9 +581,8 @@ dhstop(tp, flag)
                 */
                unit = minor(tp->t_dev);
                addr->un.dhcsrl = (unit&017) | DH_IE;
                 */
                unit = minor(tp->t_dev);
                addr->un.dhcsrl = (unit&017) | DH_IE;
-               DELAY(5);
-               if ((tp->t_state&TTSTOP)==0)
-                       tp->t_state |= FLUSH;
+               if ((tp->t_state&TS_TTSTOP)==0)
+                       tp->t_state |= TS_FLUSH;
                addr->dhbcr = -1;
        }
        splx(s);
                addr->dhbcr = -1;
        }
        splx(s);
@@ -533,123 +598,123 @@ dhreset(uban)
 {
        register int dh, unit;
        register struct tty *tp;
 {
        register int dh, unit;
        register struct tty *tp;
-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;
        int i;
 
        int i;
 
-       if (dh_ubinfo[uban] == 0)
-               return;
-       printf(" dh");
-       ubarelse(uban, &dh_ubinfo[uban]);
-       dh_ubinfo[uban] = uballoc(uban, (caddr_t)cfree,
-           512+NCLIST*sizeof (struct cblock), 0);
-       cbase[uban] = dh_ubinfo[uban]&0x3ffff;
        dh = 0;
        dh = 0;
-       for (dh = 0; dh < NDH11; dh++) {
+       for (dh = 0; dh < NDH; dh++) {
                ui = dhinfo[dh];
                if (ui == 0 || ui->ui_alive == 0 || ui->ui_ubanum != uban)
                        continue;
                ui = dhinfo[dh];
                if (ui == 0 || ui->ui_alive == 0 || ui->ui_ubanum != uban)
                        continue;
-               ((struct device *)ui->ui_addr)->un.dhcsr |= DH_IE;
-               DELAY(5);
-               ((struct device *)ui->ui_addr)->dhsilo = 16;
+               printf(" dh%d", dh);
+               if (dh_uballoc[uban] == dh) {
+                       int info;
+
+                       info = uballoc(uban, (caddr_t)cfree,
+                           nclist * sizeof(struct cblock), UBA_CANTWAIT);
+                       if (info)
+                               cbase[uban] = UBAI_ADDR(info);
+                       else {
+                               printf(" [can't get uba map]");
+                               cbase[uban] = -1;
+                       }
+               }
+               ((struct dhdevice *)ui->ui_addr)->un.dhcsr |= DH_IE;
+               ((struct dhdevice *)ui->ui_addr)->dhsilo = 0;
                unit = dh * 16;
                for (i = 0; i < 16; i++) {
                        tp = &dh11[unit];
                unit = dh * 16;
                for (i = 0; i < 16; i++) {
                        tp = &dh11[unit];
-                       if (tp->t_state & (ISOPEN|WOPEN)) {
+                       if (tp->t_state & (TS_ISOPEN|TS_WOPEN)) {
                                dhparam(unit);
                                dhparam(unit);
-                               dmctl(unit, DM_ON, DMSET);
-                               tp->t_state &= ~BUSY;
+                               dmctl(unit, DML_ON, DMSET);
+                               tp->t_state &= ~TS_BUSY;
                                dhstart(tp);
                        }
                        unit++;
                }
        }
                                dhstart(tp);
                        }
                        unit++;
                }
        }
-       dhtimer();
+       dhsilos = 0;
 }
 
 }
 
+int dhtransitions, dhslowtimers, dhfasttimers;         /*DEBUG*/
 /*
 /*
- * At software clock interrupt time or after a UNIBUS reset
- * empty all the dh silos.
+ * At software clock interrupt time, check status.
+ * Empty all the dh silos that are in use, and decide whether
+ * to turn any silos off or on.
  */
 dhtimer()
 {
  */
 dhtimer()
 {
-       register int dh;
-
-       for (dh = 0; dh < NDH11; dh++)
-               dhrint(dh);
-}
-
-/*
- * DM-11 driver.
- */
-
-/*
- * Definition of the controller for the auto-configuration program.
- */
-int    dmcntrlr(), dmslave(), dmintr();
-struct uba_dinfo *dminfo[NDH11];
-u_short        dmstd[] = { 0 };
-struct uba_driver dmdriver =
-       { dmcntrlr, dmslave, 0, 0, dmstd, "dm", dminfo };
-
-/* hardware bits */
-#define        DM_CARRTRANS    040000          /* carrier transition */
-#define        DM_CLSCAN       004000          /* clear scan */
-#define        DM_DONE         000200
-#define        DM_CARRON       000100          /* carrier on */
-#define        DM_SCENABLE     000040          /* scan enable */
-#define        DM_SCBUSY       000020          /* scan busy */
-
-struct dmdevice
-{
-       short   dmcsr;
-       short   dmlstat;
-       short   dmpad1[2];
-};
-
-dmcntrlr(um, addr)
-       struct uba_minfo *um;
-       caddr_t addr;
-{
-
-}
-
-dmslave()
-{
-
+       register int dh, s;
+       static int timercalls;
+
+       if (dhsilos) {
+               dhfasttimers++;         /*DEBUG*/
+               timercalls++;
+               s = spl5();
+               for (dh = 0; dh < NDH; dh++)
+                       if (dhsilos & (1 << dh))
+                               dhrint(dh);
+               splx(s);
+       }
+       if ((dhsilos == 0) || ((timercalls += FASTTIMER) >= hz)) {
+               dhslowtimers++;         /*DEBUG*/
+               timercalls = 0;
+               for (dh = 0; dh < NDH; dh++) {
+                   ave(dhrate[dh], dhchars[dh], 8);
+                   if ((dhchars[dh] > dhhighrate) &&
+                     ((dhsilos & (1 << dh)) == 0)) {
+                       ((struct dhdevice *)(dhinfo[dh]->ui_addr))->dhsilo =
+                           (dhchars[dh] > 500? 32 : 16);
+                       dhsilos |= (1 << dh);
+                       dhtransitions++;                /*DEBUG*/
+                   } else if ((dhsilos & (1 << dh)) &&
+                     (dhrate[dh] < dhlowrate)) {
+                       ((struct dhdevice *)(dhinfo[dh]->ui_addr))->dhsilo = 0;
+                       dhsilos &= ~(1 << dh);
+                   }
+                   dhchars[dh] = 0;
+               }
+       }
+       timeout(dhtimer, (caddr_t) 0, dhsilos? FASTTIMER: hz);
 }
 
 /*
 }
 
 /*
- * Turn on the line associated with the dh device dev.
+ * Turn on the line associated with dh dev.
  */
 dmopen(dev)
        dev_t dev;
 {
        register struct tty *tp;
        register struct dmdevice *addr;
  */
 dmopen(dev)
        dev_t dev;
 {
        register struct tty *tp;
        register struct dmdevice *addr;
-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;
        register int unit;
        register int dm;
        register int unit;
        register int dm;
+       int s;
 
        unit = minor(dev);
 
        unit = minor(dev);
-       dm = unit >> 8;
+       dm = unit >> 4;
        tp = &dh11[unit];
        tp = &dh11[unit];
-       if (dm >= NDH11 || (ui = dminfo[dm]) == 0 || ui->ui_alive == 0) {
-               tp->t_state |= CARR_ON;
+       unit &= 0xf;
+       if (dm >= NDH || (ui = dminfo[dm]) == 0 || ui->ui_alive == 0) {
+               tp->t_state |= TS_CARR_ON;
                return;
        }
        addr = (struct dmdevice *)ui->ui_addr;
                return;
        }
        addr = (struct dmdevice *)ui->ui_addr;
-       spl5();
-       addr->dmcsr &= ~DM_SCENABLE;
-       while (addr->dmcsr & DM_SCBUSY)
-               ;
-       addr->dmcsr = unit & 0xf;
-       addr->dmlstat = DM_ON;
-       if (addr->dmlstat&DM_CARRON)
-               tp->t_state |= CARR_ON;
-       addr->dmcsr = DH_IE|DM_SCENABLE;
-       while ((tp->t_state&CARR_ON)==0)
+       s = spl5();
+       for (;;) {
+               addr->dmcsr &= ~DM_SE;
+               while (addr->dmcsr & DM_BUSY)
+                       ;
+               addr->dmcsr = unit;
+               addr->dmlstat = DML_ON;
+               if ((addr->dmlstat & DML_CAR) || (dhsoftCAR[dm] & (1 << unit)))
+                       tp->t_state |= TS_CARR_ON;
+               addr->dmcsr = DM_IE|DM_SE;
+               if (tp->t_state & TS_CARR_ON)
+                       break;
                sleep((caddr_t)&tp->t_rawq, TTIPRI);
                sleep((caddr_t)&tp->t_rawq, TTIPRI);
-       spl0();
+       }
+       splx(s);
 }
 
 /*
 }
 
 /*
@@ -659,7 +724,7 @@ dmctl(dev, bits, how)
        dev_t dev;
        int bits, how;
 {
        dev_t dev;
        int bits, how;
 {
-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;
        register struct dmdevice *addr;
        register int unit, s;
        int dm;
        register struct dmdevice *addr;
        register int unit, s;
        int dm;
@@ -670,8 +735,8 @@ dmctl(dev, bits, how)
                return;
        addr = (struct dmdevice *)ui->ui_addr;
        s = spl5();
                return;
        addr = (struct dmdevice *)ui->ui_addr;
        s = spl5();
-       addr->dmcsr &= ~DM_SCENABLE;
-       while (addr->dmcsr & DM_SCBUSY)
+       addr->dmcsr &= ~DM_SE;
+       while (addr->dmcsr & DM_BUSY)
                ;
        addr->dmcsr = unit & 0xf;
        switch(how) {
                ;
        addr->dmcsr = unit & 0xf;
        switch(how) {
@@ -685,7 +750,7 @@ dmctl(dev, bits, how)
                addr->dmlstat &= ~bits;
                break;
        }
                addr->dmlstat &= ~bits;
                break;
        }
-       addr->dmcsr = DH_IE|DM_SCENABLE;
+       addr->dmcsr = DM_IE|DM_SE;
        splx(s);
 }
 
        splx(s);
 }
 
@@ -695,35 +760,26 @@ dmctl(dev, bits, how)
 dmintr(dm)
        register int dm;
 {
 dmintr(dm)
        register int dm;
 {
-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;
        register struct tty *tp;
        register struct dmdevice *addr;
        register struct tty *tp;
        register struct dmdevice *addr;
+       int unit;
 
        ui = dminfo[dm];
 
        ui = dminfo[dm];
+       if (ui == 0)
+               return;
        addr = (struct dmdevice *)ui->ui_addr;
        addr = (struct dmdevice *)ui->ui_addr;
-       if (addr->dmcsr&DM_DONE && addr->dmcsr&DM_CARRTRANS) {
-               tp = &dh11[(dm<<4)+(addr->dmcsr&0xf)];
-               wakeup((caddr_t)&tp->t_rawq);
-               if ((tp->t_state&WOPEN)==0 &&
-                   (tp->t_local&LMDMBUF)) {
-                       if (addr->dmlstat & DM_CARRON) {
-                               tp->t_state &= ~TTSTOP;
-                               ttstart(tp);
-                       } else if ((tp->t_state&TTSTOP) == 0) {
-                               tp->t_state |= TTSTOP;
-                               dhstop(tp, 0);
-                       }
-               } else if ((addr->dmlstat&DM_CARRON)==0) {
-                       if ((tp->t_state&WOPEN)==0 &&
-                           (tp->t_local&LNOHANG)==0) {
-                               gsignal(tp->t_pgrp, SIGHUP);
-                               gsignal(tp->t_pgrp, SIGCONT);
+       if (addr->dmcsr&DM_DONE) {
+               if (addr->dmcsr&DM_CF) {
+                       unit = addr->dmcsr & 0xf;
+                       tp = &dh11[(dm << 4) + unit];
+                       if (addr->dmlstat & DML_CAR)
+                               (void)(*linesw[tp->t_line].l_modem)(tp, 1);
+                       else if ((dhsoftCAR[dm] & (1<<unit)) == 0 &&
+                           (*linesw[tp->t_line].l_modem)(tp, 0) == 0)
                                addr->dmlstat = 0;
                                addr->dmlstat = 0;
-                               flushtty(tp, FREAD|FWRITE);
-                       }
-                       tp->t_state &= ~CARR_ON;
-               } else
-                       tp->t_state |= CARR_ON;
-               addr->dmcsr = DH_IE|DM_SCENABLE;
+               }
+               addr->dmcsr = DM_IE|DM_SE;
        }
 }
        }
 }
+#endif
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.