minor fixes relating to u.u_error handling

[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..f4ae51a 100644 (file)
--- a/usr/src/sys/vax/uba/dh.c
+++ b/usr/src/sys/vax/uba/dh.c
@@ -1,53 +1,68 @@
-/*     dh.c    4.16    81/02/17        */
+/*     dh.c    4.52    82/10/10        */

 
 #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 "bk.h"

 #include "../h/param.h"
 #include "../h/conf.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/param.h"
 #include "../h/conf.h"
 #include "../h/dir.h"
 #include "../h/user.h"

+#include "../h/proc.h"

 #include "../h/tty.h"
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"
 #include "../h/tty.h"
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"

-#include "../h/uba.h"
+#include "../h/vm.h"
+
+#include "../vaxuba/ubareg.h"
+#include "../vaxuba/ubavar.h"
+

 #include "../h/bk.h"
 #include "../h/clist.h"
 #include "../h/bk.h"
 #include "../h/clist.h"

-#include "../h/mx.h"

 #include "../h/file.h"
 #include "../h/file.h"

-
-#define        UBACVT(x, uban)         (cbase[uban] + ((x)-(char *)cfree))
+#include "../h/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();
+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 };
+       { dhprobe, 0, dhattach, 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];
+int    dmprobe(), dmattach(), dmintr();
+struct uba_device *dminfo[NDH];
+u_short        dmstd[] = { 0 };
+struct uba_driver dmdriver =
+       { dmprobe, 0, dmattach, 0, dmstd, "dm", dminfo };

 
 

-/* 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
+struct dhdevice
+{
+       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 */
+};
+
+#ifndef        PORTSELECTOR
+#define        ISPEED  B300
+#define        IFLAGS  (EVENP|ODDP|ECHO)
+#else
+#define        ISPEED  B4800
+#define        IFLAGS  (EVENP|ODDP)
+#endif

 
 /* Bits in dhcsr */
 #define        DH_TI   0100000         /* transmit interrupt */
 
 /* Bits in dhcsr */
 #define        DH_TI   0100000         /* transmit interrupt */


@@ -61,52 +76,99 @@ int cbase[MAXNUBA];
 #define        DH_RI   0000200         /* receiver interrupt */
 #define        DH_RIE  0000100         /* receiver interrupt enable */
 
 #define        DH_RI   0000200         /* receiver interrupt */
 #define        DH_RIE  0000100         /* receiver interrupt enable */
 

+/* 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
+

 #define        DH_IE   (DH_TIE|DH_SIE|DH_RIE)
 
 /* Bits in dhrcr */
 #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 */
+#define        DH_PE           0010000         /* parity error */
+#define        DH_FE           0020000         /* framing error */
+#define        DH_DO           0040000         /* data overrun */
+
+struct dmdevice
+{
+       short   dmcsr;          /* control status register */
+       short   dmlstat;        /* line status register */
+       short   dmpad1[2];
+};
+
+/* bits in dm csr */
+#define        DM_RF           0100000         /* ring flag */
+#define        DM_CF           0040000         /* carrier flag */
+#define        DM_CTS          0020000         /* clear to send */
+#define        DM_SRF          0010000         /* secondary receive flag */
+#define        DM_CS           0004000         /* clear scan */
+#define        DM_CM           0002000         /* clear multiplexor */
+#define        DM_MM           0001000         /* maintenance mode */
+#define        DM_STP          0000400         /* step */
+#define        DM_DONE         0000200         /* scanner is done */
+#define        DM_IE           0000100         /* interrupt enable */
+#define        DM_SE           0000040         /* scan enable */
+#define        DM_BUSY         0000020         /* scan busy */
+
+/* bits in dm lsr */
+#define        DML_RNG         0000200         /* ring */
+#define        DML_CAR         0000100         /* carrier detect */
+#define        DML_CTS         0000040         /* clear to send */
+#define        DML_SR          0000020         /* secondary receive */
+#define        DML_ST          0000010         /* secondary transmit */
+#define        DML_RTS         0000004         /* request to send */
+#define        DML_DTR         0000002         /* data terminal ready */
+#define        DML_LE          0000001         /* line enable */
+
+#define        DML_ON          (DML_DTR|DML_RTS|DML_LE)
+#define        DML_OFF         (DML_LE)

 
 /*
 
 /*

- * 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];

 
 

-/* Software copy of last dhbar */
-short  dhsar[NDH11];
+struct tty dh11[NDH*16];
+int    ndh11   = NDH*16;
+int    dhact;                          /* mask of active dh's */
+int    dhstart(), ttrstrt();

 
 

-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 the driver onto each UNIBUS.
+ * The UBACVT macro converts a clist space address for unibus uban
+ * into an i/o space address for the DMA routine.
+ */
+int    dh_ubinfo[MAXNUBA];             /* info about allocated unibus map */
+int    cbase[MAXNUBA];                 /* base address 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 +179,45 @@ 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;

 }
 
 /*
 }
 
 /*

- * 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,26 +231,25 @@ 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) {
+       if (unit >= NDH*16 || (ui = dhinfo[dh])== 0 || ui->ui_alive == 0) {

                u.u_error = ENXIO;
                return;
        }
        tp = &dh11[unit];
                u.u_error = ENXIO;
                return;
        }
        tp = &dh11[unit];

-       if (tp->t_state&XCLUDE && u.u_uid!=0) {
+       if (tp->t_state&TS_XCLUDE && u.u_uid!=0) {

                u.u_error = EBUSY;
                return;
        }
                u.u_error = EBUSY;
                return;
        }

-       addr = (struct device *)ui->ui_addr;
+       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.
        /*
         * While setting up state for this uba and this dh,
         * block uba resets which can clear the state.


@@ -171,12 +259,11 @@ dhopen(dev, flag)
                /* 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+ 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);
+                       512+nclist*sizeof(struct cblock), 0);

                cbase[ui->ui_ubanum] = dh_ubinfo[ui->ui_ubanum]&0x3ffff;
        }
        if ((dhact&(1<<dh)) == 0) {
                addr->un.dhcsr |= DH_IE;
                cbase[ui->ui_ubanum] = dh_ubinfo[ui->ui_ubanum]&0x3ffff;
        }
        if ((dhact&(1<<dh)) == 0) {
                addr->un.dhcsr |= DH_IE;

-               DELAY(5);

                dhact |= (1<<dh);
                addr->dhsilo = 16;
        }
                dhact |= (1<<dh);
                addr->dhsilo = 16;
        }


@@ -184,13 +271,17 @@ dhopen(dev, flag)
        /*
         * If this is first open, initialze tty state to default.
         */
        /*
         * If this is first open, initialze 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;
+#endif
+                       tp->t_ispeed = ISPEED;
+                       tp->t_ospeed = ISPEED;
+                       tp->t_flags = IFLAGS;
+#ifndef PORTSELECTOR

                }
                }

+#endif

                dhparam(unit);
        }
        /*
                dhparam(unit);
        }
        /*


@@ -214,28 +305,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 +337,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,7 +353,11 @@ 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) {
+#ifndef PORTSELECTOR
+               if ((tp->t_state&TS_ISOPEN)==0) {
+#else
+               if ((tp->t_state&(TS_ISOPEN|TS_WOPEN))==0) {
+#endif

                        wakeup((caddr_t)tp);
                        continue;
                }
                        wakeup((caddr_t)tp);
                        continue;
                }


@@ -268,8 +365,10 @@ dhrint(dh)
                        if ((tp->t_flags&(EVENP|ODDP))==EVENP
                         || (tp->t_flags&(EVENP|ODDP))==ODDP )
                                continue;
                        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) {
+                       printf("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


@@ -280,10 +379,12 @@ dhrint(dh)
                                c = 0;
                        else
                                c = tun.t_intrc;
                                c = 0;
                        else
                                c = tun.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,32 +393,37 @@ 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 unit = minor(dev);
 
        tp = &dh11[unit];
 {
        register struct tty *tp;
        register unit = minor(dev);
 
        tp = &dh11[unit];

-       cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, addr);
+       cmd = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag);

        if (cmd == 0)
                return;
        if (cmd == 0)
                return;

-       if (ttioctl(tp, cmd, addr, flag)) {
-               if (cmd==TIOCSETP || cmd==TIOCSETN)
+       if (ttioctl(tp, cmd, data, flag)) {
+               if (cmd == TIOCSETP || cmd == TIOCSETN)

                        dhparam(unit);
        } else switch(cmd) {
                        dhparam(unit);
        } else 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:
                u.u_error = ENOTTY;
        }
        default:
                u.u_error = ENOTTY;
        }


@@ -331,12 +437,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,8 +450,8 @@ 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);

                return;
        }
        lpar = ((tp->t_ospeed)<<10) | ((tp->t_ispeed)<<6);
                return;
        }
        lpar = ((tp->t_ospeed)<<10) | ((tp->t_ispeed)<<6);


@@ -372,19 +478,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 +499,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 +526,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 +543,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 +566,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 || tp->t_local&LLITOUT)

                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 +576,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 +586,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 +610,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 +627,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,31 +644,30 @@ 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;
 
        if (dh_ubinfo[uban] == 0)
                return;
        int i;
 
        if (dh_ubinfo[uban] == 0)
                return;

-       printf(" dh");

        ubarelse(uban, &dh_ubinfo[uban]);
        dh_ubinfo[uban] = uballoc(uban, (caddr_t)cfree,
        ubarelse(uban, &dh_ubinfo[uban]);
        dh_ubinfo[uban] = uballoc(uban, (caddr_t)cfree,

-           512+NCLIST*sizeof (struct cblock), 0);
+           512+nclist*sizeof (struct cblock), 0);

        cbase[uban] = dh_ubinfo[uban]&0x3ffff;
        dh = 0;
        cbase[uban] = dh_ubinfo[uban]&0x3ffff;
        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);
+               ((struct dhdevice *)ui->ui_addr)->un.dhcsr |= DH_IE;
+               ((struct dhdevice *)ui->ui_addr)->dhsilo = 16;

                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++;


@@ -573,83 +683,48 @@ dhreset(uban)
 dhtimer()
 {
        register int dh;
 dhtimer()
 {
        register int dh;

+       register int s = spl5();

 
 

-       for (dh = 0; dh < NDH11; dh++)
+       for (dh = 0; dh < NDH; dh++)

                dhrint(dh);
                dhrint(dh);

+       splx(s);

 }
 
 /*
 }
 
 /*

- * 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()
-{
-
-}
-
-/*
- * 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 ||
+           (dhsoftCAR[dm]&(1<<unit))) {
+               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)
+       s = spl5();
+       addr->dmcsr &= ~DM_SE;
+       while (addr->dmcsr & DM_BUSY)

                ;
                ;

-       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)
+       addr->dmcsr = unit;
+       addr->dmlstat = DML_ON;
+       if (addr->dmlstat&DML_CAR)
+               tp->t_state |= TS_CARR_ON;
+       addr->dmcsr = DM_IE|DM_SE;
+       while ((tp->t_state&TS_CARR_ON)==0)

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

-       spl0();
+       splx(s);

 }
 
 /*
 }
 
 /*


@@ -659,7 +734,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 +745,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 +760,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 +770,40 @@ 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;
 
        ui = dminfo[dm];
        register struct tty *tp;
        register struct dmdevice *addr;
 
        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);
-                               addr->dmlstat = 0;
-                               flushtty(tp, FREAD|FWRITE);
-                       }
-                       tp->t_state &= ~CARR_ON;
-               } else
-                       tp->t_state |= CARR_ON;
-               addr->dmcsr = DH_IE|DM_SCENABLE;
+       if (addr->dmcsr&DM_DONE) {
+               if (addr->dmcsr&DM_CF) {
+                       tp = &dh11[(dm<<4)+(addr->dmcsr&0xf)];
+                       wakeup((caddr_t)&tp->t_rawq);
+                       if ((tp->t_state&TS_WOPEN)==0 &&
+                           (tp->t_local&LMDMBUF)) {
+                               if (addr->dmlstat & DML_CAR) {
+                                       tp->t_state &= ~TS_TTSTOP;
+                                       ttstart(tp);
+                               } else if ((tp->t_state&TS_TTSTOP) == 0) {
+                                       tp->t_state |= TS_TTSTOP;
+                                       dhstop(tp, 0);
+                               }
+                       } else if ((addr->dmlstat&DML_CAR)==0) {
+                               if ((tp->t_state&TS_WOPEN)==0 &&
+                                   (tp->t_local&LNOHANG)==0) {
+                                       gsignal(tp->t_pgrp, SIGHUP);
+                                       gsignal(tp->t_pgrp, SIGCONT);
+                                       addr->dmlstat = 0;
+                                       flushtty(tp, FREAD|FWRITE);
+                               }
+                               tp->t_state &= ~TS_CARR_ON;
+                       } else
+                               tp->t_state |= TS_CARR_ON;
+               }
+               addr->dmcsr = DM_IE|DM_SE;

        }
 }
        }
 }

+#endif