BSD 4_3_Net_2 release
[unix-history] / usr / src / sys / vax / if / if_dmc.c
index cb165a5..0e252ce 100644 (file)
-/*     if_dmc.c        6.3     84/09/27        */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)if_dmc.c    7.10 (Berkeley) 12/16/90
+ */
 
 #include "dmc.h"
 #if NDMC > 0
 
 #include "dmc.h"
 #if NDMC > 0
-#define printd if(dmcdebug)printf
-int dmcdebug = 0;
+
 /*
  * DMC11 device driver, internet version
  *
 /*
  * DMC11 device driver, internet version
  *
- *     Bill Nesheim    (bill@cornell.arpa or {vax135,uw-beaver,ihnp4}!bill)
+ *     Bill Nesheim
  *     Cornell University
  *     Cornell University
- *     Department of Computer Science
- *
- *     Based loosly on 4.2BSD release
- *     The UNIBUS support routines were taken from Lou Salkind's DEUNA driver
  *
  *
- * TO DO:
- *     generalize unibus routines
- *     add timeout to mark interface down when other end of link dies
- *     figure out better way to check for completed buffers
- *     (not critical with DMC, only 7 bufs, but may cause problems
- *             on a DMR)
+ *     Lou Salkind
+ *     New York University
  */
  */
-#include "../machine/pte.h"
-
-#include "param.h"
-#include "systm.h"
-#include "mbuf.h"
-#include "buf.h"
-#include "ioctl.h"             /* must precede tty.h */
-#include "tty.h"
-#include "protosw.h"
-#include "socket.h"
-#include "vmmac.h"
-#include "errno.h"
-
-#include "../net/if.h"
-#include "../net/netisr.h"
-#include "../net/route.h"
-#include "../netinet/in.h"
-#include "../netinet/in_systm.h"
-
-#include "../vax/cpu.h"
-#include "../vax/mtpr.h"
+
+/* #define DEBUG       /* for base table dump on fatal error */
+
+#include "../include/pte.h"
+
+#include "sys/param.h"
+#include "sys/systm.h"
+#include "sys/mbuf.h"
+#include "sys/buf.h"
+#include "sys/ioctl.h"         /* must precede tty.h */
+#include "sys/tty.h"
+#include "sys/protosw.h"
+#include "sys/socket.h"
+#include "sys/syslog.h"
+#include "sys/vmmac.h"
+#include "sys/errno.h"
+#include "sys/time.h"
+#include "sys/kernel.h"
+
+#include "net/if.h"
+#include "net/netisr.h"
+#include "net/route.h"
+
+#ifdef INET
+#include "netinet/in.h"
+#include "netinet/in_systm.h"
+#include "netinet/in_var.h"
+#include "netinet/ip.h"
+#endif
+
+#include "../include/cpu.h"
+#include "../include/mtpr.h"
 #include "if_uba.h"
 #include "if_dmc.h"
 #include "if_uba.h"
 #include "if_dmc.h"
-#include "../vaxuba/ubareg.h"
-#include "../vaxuba/ubavar.h"
+#include "../uba/ubareg.h"
+#include "../uba/ubavar.h"
+
+
+/*
+ * output timeout value, sec.; should depend on line speed.
+ */
+int    dmc_timeout = 20;
 
 /*
  * Driver information for auto-configuration stuff.
  */
 int    dmcprobe(), dmcattach(), dmcinit(), dmcioctl();
 
 /*
  * Driver information for auto-configuration stuff.
  */
 int    dmcprobe(), dmcattach(), dmcinit(), dmcioctl();
-int    dmcoutput(), dmcreset();
+int    dmcoutput(), dmcreset(), dmctimeout();
 struct uba_device *dmcinfo[NDMC];
 u_short        dmcstd[] = { 0 };
 struct uba_driver dmcdriver =
        { dmcprobe, 0, dmcattach, 0, dmcstd, "dmc", dmcinfo };
 
 struct uba_device *dmcinfo[NDMC];
 u_short        dmcstd[] = { 0 };
 struct uba_driver dmcdriver =
        { dmcprobe, 0, dmcattach, 0, dmcstd, "dmc", dmcinfo };
 
-/* as long as we use clists for command queues, we only have 28 bytes to use! */
-/* DMC-11 only has 7 buffers; DMR-11 has 64 */
 #define NRCV 7
 #define NRCV 7
-#define NXMT (NRCV - 2)        /* avoid running out of buffers on recv end */ 
-#define NTOT (NRCV + NXMT)
+#define NXMT 3 
+#define NCMDS  (NRCV+NXMT+4)   /* size of command queue */
+
+#define printd if(dmcdebug)printf
+int dmcdebug = 0;
 
 /* error reporting intervals */
 #define DMC_RPNBFS     50
 #define DMC_RPDSC      1
 
 /* error reporting intervals */
 #define DMC_RPNBFS     50
 #define DMC_RPDSC      1
-#define DMC_RPTMO      20
-#define DMC_RPDCK      5
+#define DMC_RPTMO      10
+#define DMC_RPDCK      10
 
 struct  dmc_command {
        char    qp_cmd;         /* command */
 
 struct  dmc_command {
        char    qp_cmd;         /* command */
@@ -76,26 +118,6 @@ struct  dmc_command {
        struct  dmc_command *qp_next;   /* next command on queue */
 };
 
        struct  dmc_command *qp_next;   /* next command on queue */
 };
 
-/*
- * The dmcuba structures generalize the ifuba structure
- * to an arbitrary number of recieve and transmit buffers.
- */
-struct ifxmt {
-       struct  ifrw x_ifrw;            /* mapping imfo */
-       struct  pte x_map[IF_MAXNUBAMR];        /* output base pages */
-       short   x_xswapd;               /* mask of clusters swapped */
-       struct  mbuf *x_xtofree;        /* pages being dma'd out */
-};
-struct dmcuba {
-       short   ifu_uban;               /* uba number */
-       short   ifu_hlen;               /* local net header length */
-       struct  uba_regs *ifu_uba;      /* uba regs, in vm */
-       struct  ifrw ifu_r[NRCV];       /* receive information */
-       struct  ifxmt ifu_w[NXMT];      /* transmit information */
-                               /* these should only be pointers */
-       short   ifu_flags;              /* used during uballoc's */
-};
-
 struct dmcbufs {
        int     ubinfo;         /* from uballoc */
        short   cc;             /* buffer size */
 struct dmcbufs {
        int     ubinfo;         /* from uballoc */
        short   cc;             /* buffer size */
@@ -104,9 +126,8 @@ struct dmcbufs {
 #define        DBUF_OURS       0       /* buffer is available */
 #define        DBUF_DMCS       1       /* buffer claimed by somebody */
 #define        DBUF_XMIT       4       /* transmit buffer */
 #define        DBUF_OURS       0       /* buffer is available */
 #define        DBUF_DMCS       1       /* buffer claimed by somebody */
 #define        DBUF_XMIT       4       /* transmit buffer */
-#define        DBUF_RCV        8       /* recieve buffer */
+#define        DBUF_RCV        8       /* receive buffer */
 
 
-struct mbuf *dmc_get();
 
 /*
  * DMC software status per interface.
 
 /*
  * DMC software status per interface.
@@ -122,21 +143,23 @@ struct mbuf *dmc_get();
  * efficiently.
  */
 struct dmc_softc {
  * efficiently.
  */
 struct dmc_softc {
+       struct  ifnet sc_if;            /* network-visible interface */
        short   sc_oused;               /* output buffers currently in use */
        short   sc_iused;               /* input buffers given to DMC */
        short   sc_flag;                /* flags */
        short   sc_oused;               /* output buffers currently in use */
        short   sc_iused;               /* input buffers given to DMC */
        short   sc_flag;                /* flags */
-       struct  ifnet sc_if;            /* network-visible interface */
-       struct  dmcbufs sc_rbufs[NRCV]; /* recieve buffer info */
-       struct  dmcbufs sc_xbufs[NXMT]; /* transmit buffer info */
-       struct  dmcuba sc_ifuba;        /* UNIBUS resources */
        int     sc_ubinfo;              /* UBA mapping info for base table */
        int     sc_errors[4];           /* non-fatal error counters */
 #define sc_datck sc_errors[0]
 #define sc_timeo sc_errors[1]
 #define sc_nobuf sc_errors[2]
 #define sc_disc  sc_errors[3]
        int     sc_ubinfo;              /* UBA mapping info for base table */
        int     sc_errors[4];           /* non-fatal error counters */
 #define sc_datck sc_errors[0]
 #define sc_timeo sc_errors[1]
 #define sc_nobuf sc_errors[2]
 #define sc_disc  sc_errors[3]
+       struct  dmcbufs sc_rbufs[NRCV]; /* receive buffer info */
+       struct  dmcbufs sc_xbufs[NXMT]; /* transmit buffer info */
+       struct  ifubinfo sc_ifuba;      /* UNIBUS resources */
+       struct  ifrw sc_ifr[NRCV];      /* UNIBUS receive buffer maps */
+       struct  ifxmt sc_ifw[NXMT];     /* UNIBUS receive buffer maps */
        /* command queue stuff */
        /* command queue stuff */
-       struct  dmc_command sc_cmdbuf[NTOT+3];
+       struct  dmc_command sc_cmdbuf[NCMDS];
        struct  dmc_command *sc_qhead;  /* head of command queue */
        struct  dmc_command *sc_qtail;  /* tail of command queue */
        struct  dmc_command *sc_qactive;        /* command in progress */
        struct  dmc_command *sc_qhead;  /* head of command queue */
        struct  dmc_command *sc_qtail;  /* tail of command queue */
        struct  dmc_command *sc_qactive;        /* command in progress */
@@ -146,11 +169,13 @@ struct dmc_softc {
 } dmc_softc[NDMC];
 
 /* flags */
 } dmc_softc[NDMC];
 
 /* flags */
-#define        DMC_ALLOC       01      /* unibus resources allocated */
-#define        DMC_BMAPPED     02      /* base table mapped */
+#define DMC_RUNNING    0x01            /* device initialized */
+#define DMC_BMAPPED    0x02            /* base table mapped */
+#define DMC_RESTART    0x04            /* software restart in progress */
+#define DMC_ONLINE     0x08            /* device running (had a RDYO) */
 
 
-struct dmc_base {
-       short   d_base[128];    /* DMC base table */
+struct dmc_base {
+       short   d_base[128];            /* DMC base table */
 } dmc_base[NDMC];
 
 /* queue manipulation macros */
 } dmc_base[NDMC];
 
 /* queue manipulation macros */
@@ -187,11 +212,14 @@ dmcprobe(reg)
        addr->bsel1 = DMC_MCLR;
        for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
                ;
        addr->bsel1 = DMC_MCLR;
        for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
                ;
-       if ((addr->bsel1 & DMC_RUN) == 0)
+       if ((addr->bsel1 & DMC_RUN) == 0) {
+               printf("dmcprobe: can't start device\n" );
                return (0);
                return (0);
-       /* MCLR is self clearing */
+       }
        addr->bsel0 = DMC_RQI|DMC_IEI;
        addr->bsel0 = DMC_RQI|DMC_IEI;
-       DELAY(100000);
+       /* let's be paranoid */
+       addr->bsel0 |= DMC_RQI|DMC_IEI;
+       DELAY(1000000);
        addr->bsel1 = DMC_MCLR;
        for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
                ;
        addr->bsel1 = DMC_MCLR;
        for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
                ;
@@ -207,7 +235,6 @@ dmcattach(ui)
        register struct uba_device *ui;
 {
        register struct dmc_softc *sc = &dmc_softc[ui->ui_unit];
        register struct uba_device *ui;
 {
        register struct dmc_softc *sc = &dmc_softc[ui->ui_unit];
-       register struct dmc_command *qp;
 
        sc->sc_if.if_unit = ui->ui_unit;
        sc->sc_if.if_name = "dmc";
 
        sc->sc_if.if_unit = ui->ui_unit;
        sc->sc_if.if_name = "dmc";
@@ -216,23 +243,16 @@ dmcattach(ui)
        sc->sc_if.if_output = dmcoutput;
        sc->sc_if.if_ioctl = dmcioctl;
        sc->sc_if.if_reset = dmcreset;
        sc->sc_if.if_output = dmcoutput;
        sc->sc_if.if_ioctl = dmcioctl;
        sc->sc_if.if_reset = dmcreset;
+       sc->sc_if.if_watchdog = dmctimeout;
        sc->sc_if.if_flags = IFF_POINTOPOINT;
        sc->sc_if.if_flags = IFF_POINTOPOINT;
-       sc->sc_ifuba.ifu_flags = UBA_CANTWAIT;
+       sc->sc_ifuba.iff_flags = UBA_CANTWAIT;
 
 
-       /* set up command queues */
-       sc->sc_qfreeh = sc->sc_qfreet =
-               sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
-               (struct dmc_command *) 0;
-       /* set up free command buffer list */
-       for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NTOT+2]; qp++ ) {
-               QUEUE_AT_HEAD( qp, sc->sc_qfreeh, sc->sc_qfreet);
-       }
        if_attach(&sc->sc_if);
 }
 
 /*
  * Reset of interface after UNIBUS reset.
        if_attach(&sc->sc_if);
 }
 
 /*
  * Reset of interface after UNIBUS reset.
- * If interface is on specified UBA, reset it's state.
+ * If interface is on specified UBA, reset its state.
  */
 dmcreset(unit, uban)
        int unit, uban;
  */
 dmcreset(unit, uban)
        int unit, uban;
@@ -244,7 +264,8 @@ dmcreset(unit, uban)
            ui->ui_ubanum != uban)
                return;
        printf(" dmc%d", unit);
            ui->ui_ubanum != uban)
                return;
        printf(" dmc%d", unit);
-       sc->sc_flag = 0;        /* previous unibus resources no longer valid */
+       sc->sc_flag = 0;
+       sc->sc_if.if_flags &= ~IFF_RUNNING;
        dmcinit(unit);
 }
 
        dmcinit(unit);
 }
 
@@ -261,92 +282,110 @@ dmcinit(unit)
        register struct ifrw *ifrw;
        register struct ifxmt *ifxp;
        register struct dmcbufs *rp;
        register struct ifrw *ifrw;
        register struct ifxmt *ifxp;
        register struct dmcbufs *rp;
+       register struct dmc_command *qp;
+       struct ifaddr *ifa;
        int base;
        int base;
-       struct sockaddr_in *sin;
+       int s;
 
 
-       printd("dmcinit\n");
        addr = (struct dmcdevice *)ui->ui_addr;
 
        addr = (struct dmcdevice *)ui->ui_addr;
 
-       sin = (struct sockaddr_in *) &ifp->if_addr;
-       if (sin->sin_addr.s_addr == 0)  /* if address still unknown */
-               return;
-       sin = (struct sockaddr_in *) &ifp->if_dstaddr;
-       if (sin->sin_addr.s_addr == 0)  /* if address still unknown */
+       /*
+        * Check to see that an address has been set
+        * (both local and destination for an address family).
+        */
+       for (ifa = ifp->if_addrlist; ifa; ifa = ifa->ifa_next)
+               if (ifa->ifa_addr->sa_family && ifa->ifa_dstaddr->sa_family)
+                       break;
+       if (ifa == (struct ifaddr *) 0)
                return;
 
        if ((addr->bsel1&DMC_RUN) == 0) {
                printf("dmcinit: DMC not running\n");
                return;
 
        if ((addr->bsel1&DMC_RUN) == 0) {
                printf("dmcinit: DMC not running\n");
-               ifp->if_flags &= ~(IFF_RUNNING|IFF_UP);
+               ifp->if_flags &= ~IFF_UP;
                return;
        }
        /* map base table */
                return;
        }
        /* map base table */
-       if ((sc->sc_flag&DMC_BMAPPED) == 0) {
+       if ((sc->sc_flag & DMC_BMAPPED) == 0) {
                sc->sc_ubinfo = uballoc(ui->ui_ubanum,
                        (caddr_t)&dmc_base[unit], sizeof (struct dmc_base), 0);
                sc->sc_flag |= DMC_BMAPPED;
        }
        /* initialize UNIBUS resources */
        sc->sc_iused = sc->sc_oused = 0;
                sc->sc_ubinfo = uballoc(ui->ui_ubanum,
                        (caddr_t)&dmc_base[unit], sizeof (struct dmc_base), 0);
                sc->sc_flag |= DMC_BMAPPED;
        }
        /* initialize UNIBUS resources */
        sc->sc_iused = sc->sc_oused = 0;
-       if ((sc->sc_flag&DMC_ALLOC) == 0) {
-               if (dmc_ubainit(&sc->sc_ifuba, ui->ui_ubanum, 0,
-                               (int)btoc(DMCMTU)) == 0) {
-                       printf("dmc%d: can't initialize\n", unit);
+       if ((ifp->if_flags & IFF_RUNNING) == 0) {
+               if (if_ubaminit(&sc->sc_ifuba, ui->ui_ubanum,
+                   sizeof(struct dmc_header), (int)btoc(DMCMTU),
+                   sc->sc_ifr, NRCV, sc->sc_ifw, NXMT) == 0) {
+                       printf("dmc%d: can't allocate uba resources\n", unit);
                        ifp->if_flags &= ~IFF_UP;
                        return;
                }
                        ifp->if_flags &= ~IFF_UP;
                        return;
                }
-               sc->sc_flag |= DMC_ALLOC;
+               ifp->if_flags |= IFF_RUNNING;
        }
        }
+       sc->sc_flag &= ~DMC_ONLINE;
+       sc->sc_flag |= DMC_RUNNING;
+       /*
+        * Limit packets enqueued until we see if we're on the air.
+        */
+       ifp->if_snd.ifq_maxlen = 3;
 
        /* initialize buffer pool */
 
        /* initialize buffer pool */
-       /* recieves */
-       ifrw = &sc->sc_ifuba.ifu_r[0];
+       /* receives */
+       ifrw = &sc->sc_ifr[0];
        for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
        for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
-               rp->ubinfo = ifrw->ifrw_info & 0x3ffff;
-               rp->cc = DMCMTU;
+               rp->ubinfo = UBAI_ADDR(ifrw->ifrw_info);
+               rp->cc = DMCMTU + sizeof (struct dmc_header);
                rp->flags = DBUF_OURS|DBUF_RCV;
                rp->flags = DBUF_OURS|DBUF_RCV;
-               printd("rcv: 0x%x\n",rp->ubinfo);
                ifrw++; 
        }
        /* transmits */
                ifrw++; 
        }
        /* transmits */
-       ifxp = &sc->sc_ifuba.ifu_w[0];
+       ifxp = &sc->sc_ifw[0];
        for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
        for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
-               rp->ubinfo = ifxp->x_ifrw.ifrw_info & 0x3ffff;
+               rp->ubinfo = UBAI_ADDR(ifxp->ifw_info);
                rp->cc = 0;
                rp->flags = DBUF_OURS|DBUF_XMIT;
                rp->cc = 0;
                rp->flags = DBUF_OURS|DBUF_XMIT;
-               printd("xmit: 0x%x\n",rp->ubinfo);
                ifxp++; 
        }
                ifxp++; 
        }
+
+       /* set up command queues */
+       sc->sc_qfreeh = sc->sc_qfreet
+                = sc->sc_qhead = sc->sc_qtail = sc->sc_qactive =
+               (struct dmc_command *)0;
+       /* set up free command buffer list */
+       for (qp = &sc->sc_cmdbuf[0]; qp < &sc->sc_cmdbuf[NCMDS]; qp++) {
+               QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
+       }
+
        /* base in */
        /* base in */
-       base = sc->sc_ubinfo & 0x3ffff;
-       printd("  base 0x%x\n", base);
-       dmcload(sc, DMC_BASEI, base, (base>>2)&DMC_XMEM);
+       base = UBAI_ADDR(sc->sc_ubinfo);
+       dmcload(sc, DMC_BASEI, (u_short)base, (base>>2) & DMC_XMEM);
        /* specify half duplex operation, flags tell if primary */
        /* or secondary station */
        if (ui->ui_flags == 0)
        /* specify half duplex operation, flags tell if primary */
        /* or secondary station */
        if (ui->ui_flags == 0)
-                      /* use DDMCP mode in full duplex */
-                       dmcload(sc, DMC_CNTLI, 0, 0);
+               /* use DDCMP mode in full duplex */
+               dmcload(sc, DMC_CNTLI, 0, 0);
        else if (ui->ui_flags == 1)
        else if (ui->ui_flags == 1)
-                      /* use MAINTENENCE mode */
-                      dmcload(sc, DMC_CNTLI, 0, DMC_MAINT );
+               /* use MAINTENENCE mode */
+               dmcload(sc, DMC_CNTLI, 0, DMC_MAINT );
        else if (ui->ui_flags == 2)
                /* use DDCMP half duplex as primary station */
                dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX);
        else if (ui->ui_flags == 3)
                /* use DDCMP half duplex as secondary station */
                dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC);
        else if (ui->ui_flags == 2)
                /* use DDCMP half duplex as primary station */
                dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX);
        else if (ui->ui_flags == 3)
                /* use DDCMP half duplex as secondary station */
                dmcload(sc, DMC_CNTLI, 0, DMC_HDPLX | DMC_SEC);
-       
+
+       /* enable operation done interrupts */
+       while ((addr->bsel2 & DMC_IEO) == 0)
+               addr->bsel2 |= DMC_IEO;
+       s = spl5();
        /* queue first NRCV buffers for DMC to fill */
        for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
                rp->flags |= DBUF_DMCS;
                dmcload(sc, DMC_READ, rp->ubinfo,
        /* queue first NRCV buffers for DMC to fill */
        for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
                rp->flags |= DBUF_DMCS;
                dmcload(sc, DMC_READ, rp->ubinfo,
-                       (((rp->ubinfo>>2)&DMC_XMEM)|rp->cc));
+                       (((rp->ubinfo>>2)&DMC_XMEM) | rp->cc));
                sc->sc_iused++;
        }
                sc->sc_iused++;
        }
-
-       /* enable output interrupts */
-       while ((addr->bsel2&DMC_IEO) == 0)
-               addr->bsel2 |= DMC_IEO;
-       ifp->if_flags |= IFF_UP|IFF_RUNNING;
+       splx(s);
 }
 
 /*
 }
 
 /*
@@ -356,19 +395,14 @@ dmcinit(unit)
  *
  * Must be called at spl 5
  */
  *
  * Must be called at spl 5
  */
-dmcstart(dev)
-       dev_t dev;
+dmcstart(unit)
+       int unit;
 {
 {
-       int unit = minor(dev);
        register struct dmc_softc *sc = &dmc_softc[unit];
        struct mbuf *m;
        register struct dmcbufs *rp;
        register int n;
 
        register struct dmc_softc *sc = &dmc_softc[unit];
        struct mbuf *m;
        register struct dmcbufs *rp;
        register int n;
 
-       if ((sc->sc_flag & DMC_ALLOC) == 0) {
-               printf("dmcstart: no unibus resources!!\n");
-               return;
-       }
        /*
         * Dequeue up to NXMT requests and map them to the UNIBUS.
         * If no more requests, or no dmc buffers available, just return.
        /*
         * Dequeue up to NXMT requests and map them to the UNIBUS.
         * If no more requests, or no dmc buffers available, just return.
@@ -376,20 +410,20 @@ dmcstart(dev)
        n = 0;
        for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
                /* find an available buffer */
        n = 0;
        for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++ ) {
                /* find an available buffer */
-               if ((rp->flags&DBUF_DMCS) == 0){
+               if ((rp->flags & DBUF_DMCS) == 0) {
                        IF_DEQUEUE(&sc->sc_if.if_snd, m);
                        if (m == 0)
                                return;
                        IF_DEQUEUE(&sc->sc_if.if_snd, m);
                        if (m == 0)
                                return;
-                       if ((rp->flags&DBUF_XMIT) == 0)
-                               printf("dmcstart: not xmit buf\n");
                        /* mark it dmcs */
                        rp->flags |= (DBUF_DMCS);
                        /*
                         * Have request mapped to UNIBUS for transmission
                         * and start the output.
                         */
                        /* mark it dmcs */
                        rp->flags |= (DBUF_DMCS);
                        /*
                         * Have request mapped to UNIBUS for transmission
                         * and start the output.
                         */
-                       rp->cc = (dmcput(&sc->sc_ifuba, n, m))&DMC_CCOUNT;
-                       sc->sc_oused++;
+                       rp->cc = if_ubaput(&sc->sc_ifuba, &sc->sc_ifw[n], m);
+                       rp->cc &= DMC_CCOUNT;
+                       if (++sc->sc_oused == 1)
+                               sc->sc_if.if_timer = dmc_timeout;
                        dmcload(sc, DMC_WRITE, rp->ubinfo, 
                                rp->cc | ((rp->ubinfo>>2)&DMC_XMEM));
                }
                        dmcload(sc, DMC_WRITE, rp->ubinfo, 
                                rp->cc | ((rp->ubinfo>>2)&DMC_XMEM));
                }
@@ -402,13 +436,14 @@ dmcstart(dev)
  */
 dmcload(sc, type, w0, w1)
        register struct dmc_softc *sc;
  */
 dmcload(sc, type, w0, w1)
        register struct dmc_softc *sc;
-       int type, w0, w1;
+       int type;
+       u_short w0, w1;
 {
        register struct dmcdevice *addr;
        register int unit, sps;
        register struct dmc_command *qp;
 
 {
        register struct dmcdevice *addr;
        register int unit, sps;
        register struct dmc_command *qp;
 
-       unit = (sc - dmc_softc)/ sizeof (struct dmc_softc);
+       unit = sc - dmc_softc;
        addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
        sps = spl5();
 
        addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
        sps = spl5();
 
@@ -452,15 +487,13 @@ dmcrint(unit)
        addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
        sc = &dmc_softc[unit];
        if ((qp = sc->sc_qactive) == (struct dmc_command *) 0) {
        addr = (struct dmcdevice *)dmcinfo[unit]->ui_addr;
        sc = &dmc_softc[unit];
        if ((qp = sc->sc_qactive) == (struct dmc_command *) 0) {
-               printf("dmcrint: no command\n");
+               printf("dmc%d: dmcrint no command\n", unit);
                return;
        }
        while (addr->bsel0&DMC_RDYI) {
                addr->sel4 = qp->qp_ubaddr;
                addr->sel6 = qp->qp_cc;
                addr->bsel0 &= ~(DMC_IEI|DMC_RQI);
                return;
        }
        while (addr->bsel0&DMC_RDYI) {
                addr->sel4 = qp->qp_ubaddr;
                addr->sel6 = qp->qp_cc;
                addr->bsel0 &= ~(DMC_IEI|DMC_RQI);
-               printd("load done, cmd 0x%x, ubaddr 0x%x, cc 0x%x\n",
-                       qp->qp_cmd, qp->qp_ubaddr, qp->qp_cc);
                /* free command buffer */
                QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
                while (addr->bsel0 & DMC_RDYI) {
                /* free command buffer */
                QUEUE_AT_HEAD(qp, sc->sc_qfreeh, sc->sc_qfreet);
                while (addr->bsel0 & DMC_RDYI) {
@@ -471,22 +504,23 @@ dmcrint(unit)
                        DELAY(5);
                }
                /* move on to next command */
                        DELAY(5);
                }
                /* move on to next command */
-               if ((sc->sc_qactive = sc->sc_qhead)==(struct dmc_command *) 0) 
-                       /* all done */
-                       break;
+               if ((sc->sc_qactive = sc->sc_qhead) == (struct dmc_command *)0)
+                       break;          /* all done */
                /* more commands to do, start the next one */
                qp = sc->sc_qactive;
                DEQUEUE(sc->sc_qhead, sc->sc_qtail);
                addr->bsel0 = qp->qp_cmd;
                n = RDYSCAN;
                /* more commands to do, start the next one */
                qp = sc->sc_qactive;
                DEQUEUE(sc->sc_qhead, sc->sc_qtail);
                addr->bsel0 = qp->qp_cmd;
                n = RDYSCAN;
-               while (n-- && (addr->bsel0&DMC_RDYI) == 0)
-                       DELAY(5);
+               while (n-- > 0)
+                       if ((addr->bsel0&DMC_RDYI) || (addr->bsel2&DMC_RDYO))
+                               break;
        }
        if (sc->sc_qactive) {
                addr->bsel0 |= DMC_IEI|DMC_RQI;
                /* VMS does it twice !*$%@# */
                addr->bsel0 |= DMC_IEI|DMC_RQI;
        }
        }
        if (sc->sc_qactive) {
                addr->bsel0 |= DMC_IEI|DMC_RQI;
                /* VMS does it twice !*$%@# */
                addr->bsel0 |= DMC_IEI|DMC_RQI;
        }
+
 }
 
 /*
 }
 
 /*
@@ -503,174 +537,300 @@ dmcxint(unit)
        struct uba_device *ui = dmcinfo[unit];
        struct dmcdevice *addr;
        struct mbuf *m;
        struct uba_device *ui = dmcinfo[unit];
        struct dmcdevice *addr;
        struct mbuf *m;
-       register struct ifqueue *inq;
-       int arg, pkaddr, cmd, len;
+       struct ifqueue *inq;
+       int arg, pkaddr, cmd, len, s;
        register struct ifrw *ifrw;
        register struct dmcbufs *rp;
        register struct ifrw *ifrw;
        register struct dmcbufs *rp;
+       register struct ifxmt *ifxp;
+       struct dmc_header *dh;
+       int off, resid;
 
        addr = (struct dmcdevice *)ui->ui_addr;
        sc = &dmc_softc[unit];
        ifp = &sc->sc_if;
 
 
        addr = (struct dmcdevice *)ui->ui_addr;
        sc = &dmc_softc[unit];
        ifp = &sc->sc_if;
 
-       cmd = addr->bsel2 & 0xff;
-       arg = addr->sel6 & 0xffff;
-       if ((cmd&DMC_RDYO) == 0)  {
-               printf("dmc%d: bogus xmit intr\n", unit);
-               return; 
-       }
-       /* reconstruct UNIBUS address of buffer returned to us */
-       pkaddr = ((arg&DMC_XMEM)<<2)|(addr->sel4 & 0xffff);
-       /* release port */
-       addr->bsel2 &= ~DMC_RDYO;
-       switch (cmd & 07) {
-
-       case DMC_OUR:
-               /*
-                * A read has completed.  
-                * Pass packet to type specific
-                * higher-level input routine.
-                */
-               ifp->if_ipackets++;
-               len = arg & DMC_CCOUNT;
-               /* find location in dmcuba struct */
-               ifrw = &sc->sc_ifuba.ifu_r[0];
-               rp = &sc->sc_rbufs[0];
-               for (; rp < &sc->sc_rbufs[NRCV]; rp++) {
-                       if (rp->ubinfo == pkaddr)
-                               goto foundrcv;
-                       ifrw++;
-               }
-               printf("bad rcv pkt addr 0x%x len 0x%x\n", pkaddr, len);
-               goto setup;
-               
-       foundrcv:
-               if ((rp->flags&DBUF_DMCS) == 0) {
-                       printf("dmcxint: done unalloc rbuf\n");
-               }
-               switch (ifp->if_addr.sa_family) {
+       while (addr->bsel2 & DMC_RDYO) {
+
+               cmd = addr->bsel2 & 0xff;
+               arg = addr->sel6 & 0xffff;
+               /* reconstruct UNIBUS address of buffer returned to us */
+               pkaddr = ((arg&DMC_XMEM)<<2) | (addr->sel4 & 0xffff);
+               /* release port */
+               addr->bsel2 &= ~DMC_RDYO;
+               switch (cmd & 07) {
+
+               case DMC_OUR:
+                       /*
+                        * A read has completed.  
+                        * Pass packet to type specific
+                        * higher-level input routine.
+                        */
+                       ifp->if_ipackets++;
+                       /* find location in dmcuba struct */
+                       ifrw= &sc->sc_ifr[0];
+                       for (rp = &sc->sc_rbufs[0]; rp < &sc->sc_rbufs[NRCV]; rp++) {
+                               if(rp->ubinfo == pkaddr)
+                                       break;
+                               ifrw++;
+                       }
+                       if (rp >= &sc->sc_rbufs[NRCV])
+                               panic("dmc rcv");
+                       if ((rp->flags & DBUF_DMCS) == 0)
+                               printf("dmc%d: done unalloc rbuf\n", unit);
+
+                       len = (arg & DMC_CCOUNT) - sizeof (struct dmc_header);
+                       if (len < 0 || len > DMCMTU) {
+                               ifp->if_ierrors++;
+                               printd("dmc%d: bad rcv pkt addr 0x%x len 0x%x\n",
+                                   unit, pkaddr, len);
+                               goto setup;
+                       }
+                       /*
+                        * Deal with trailer protocol: if type is trailer
+                        * get true type from first 16-bit word past data.
+                        * Remember that type was trailer by setting off.
+                        */
+                       dh = (struct dmc_header *)ifrw->ifrw_addr;
+                       dh->dmc_type = ntohs((u_short)dh->dmc_type);
+#define dmcdataaddr(dh, off, type)     ((type)(((caddr_t)((dh)+1)+(off))))
+                       if (dh->dmc_type >= DMC_TRAILER &&
+                           dh->dmc_type < DMC_TRAILER+DMC_NTRAILER) {
+                               off = (dh->dmc_type - DMC_TRAILER) * 512;
+                               if (off >= DMCMTU)
+                                       goto setup;             /* sanity */
+                               dh->dmc_type = ntohs(*dmcdataaddr(dh, off, u_short *));
+                               resid = ntohs(*(dmcdataaddr(dh, off+2, u_short *)));
+                               if (off + resid > len)
+                                       goto setup;             /* sanity */
+                               len = off + resid;
+                       } else
+                               off = 0;
+                       if (len == 0)
+                               goto setup;
+
+                       /*
+                        * Pull packet off interface.  Off is nonzero if
+                        * packet has trailing header; dmc_get will then
+                        * force this header information to be at the front,
+                        * but we still have to drop the type and length
+                        * which are at the front of any trailer data.
+                        */
+                       m = if_ubaget(&sc->sc_ifuba, ifrw, len, off, ifp);
+                       if (m == 0)
+                               goto setup;
+                       switch (dh->dmc_type) {
+
 #ifdef INET
 #ifdef INET
-               case AF_INET:
-                       schednetisr(NETISR_IP);
-                       inq = &ipintrq;
-                       break;
+                       case DMC_IPTYPE:
+                               schednetisr(NETISR_IP);
+                               inq = &ipintrq;
+                               break;
 #endif
 #endif
+                       default:
+                               m_freem(m);
+                               goto setup;
+                       }
 
 
-               default:
-                       printf("dmc%d: unknown address type %d\n", unit,
-                           ifp->if_addr.sa_family);
-                       goto setup;
-               }
+                       s = splimp();
+                       if (IF_QFULL(inq)) {
+                               IF_DROP(inq);
+                               m_freem(m);
+                       } else
+                               IF_ENQUEUE(inq, m);
+                       splx(s);
 
 
-               m = dmc_get(&sc->sc_ifuba, ifrw, len, 0);
-               if (m == (struct mbuf *)0)
-                       goto setup;
-               if (IF_QFULL(inq)) {
-                       IF_DROP(inq);
-                       m_freem(m);
-               } else
-                       IF_ENQUEUE(inq, m);
-setup:
-               arg = ifrw->ifrw_info & 0x3ffff;
-               dmcload(sc, DMC_READ, arg, ((arg >> 2) & DMC_XMEM) | DMCMTU);
-               break;
+       setup:
+                       /* is this needed? */
+                       rp->ubinfo = UBAI_ADDR(ifrw->ifrw_info);
 
 
-       case DMC_OUX:
-               /*
-                * A write has completed, start another
-                * transfer if there is more data to send.
-                */
-               ifp->if_opackets++;
-               printd("OUX pkaddr 0x%x\n",pkaddr);
-               /* find associated dmcbuf structure */
-               rp = &sc->sc_xbufs[0];
-               for (; rp < &sc->sc_xbufs[NXMT]; rp++) {
-                       if (rp->ubinfo == pkaddr)
-                               goto found;
-               }
-               printf("dmc%d: bad packet address 0x%x\n",
-                       unit, pkaddr);
-               break;
-       found:
-               if ((rp->flags&DBUF_DMCS) == 0)
-                       printf("dmc returned unallocated packet 0x%x\n",
-                               pkaddr);
-               /* mark buffer free */
-               rp->flags &= ~(DBUF_DMCS);
-               sc->sc_oused--;
-               dmcstart(unit);
-               break;
+                       dmcload(sc, DMC_READ, rp->ubinfo, 
+                           ((rp->ubinfo >> 2) & DMC_XMEM) | rp->cc);
+                       break;
 
 
-       case DMC_CNTLO:
-               arg &= DMC_CNTMASK;
-               if (arg&DMC_FATAL) {
-                       register int i;
-
-                       printf("dmc%d: fatal error, flags=%b\n",
-                           unit, arg, CNTLO_BITS);
-                       ifp->if_flags &= ~(IFF_RUNNING|IFF_UP);
-                       /* master clear device */
-                       addr->bsel1 = DMC_MCLR;
-                       for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
-                               ;
-                       dmcinit(unit);
-                       ifp->if_ierrors++;
+               case DMC_OUX:
+                       /*
+                        * A write has completed, start another
+                        * transfer if there is more data to send.
+                        */
+                       ifp->if_opackets++;
+                       /* find associated dmcbuf structure */
+                       ifxp = &sc->sc_ifw[0];
+                       for (rp = &sc->sc_xbufs[0]; rp < &sc->sc_xbufs[NXMT]; rp++) {
+                               if(rp->ubinfo == pkaddr)
+                                       break;
+                               ifxp++;
+                       }
+                       if (rp >= &sc->sc_xbufs[NXMT]) {
+                               printf("dmc%d: bad packet address 0x%x\n",
+                                   unit, pkaddr);
+                               break;
+                       }
+                       if ((rp->flags & DBUF_DMCS) == 0)
+                               printf("dmc%d: unallocated packet 0x%x\n",
+                                   unit, pkaddr);
+                       /* mark buffer free */
+                       if (ifxp->ifw_xtofree) {
+                               (void)m_freem(ifxp->ifw_xtofree);
+                               ifxp->ifw_xtofree = 0;
+                       }
+                       rp->flags &= ~DBUF_DMCS;
+                       if (--sc->sc_oused == 0)
+                               sc->sc_if.if_timer = 0;
+                       else
+                               sc->sc_if.if_timer = dmc_timeout;
+                       if ((sc->sc_flag & DMC_ONLINE) == 0) {
+                               extern int ifqmaxlen;
+
+                               /*
+                                * We're on the air.
+                                * Open the queue to the usual value.
+                                */
+                               sc->sc_flag |= DMC_ONLINE;
+                               ifp->if_snd.ifq_maxlen = ifqmaxlen;
+                       }
                        break;
                        break;
-               } else {
-                        /* ACCUMULATE STATISTICS */
+
+               case DMC_CNTLO:
+                       arg &= DMC_CNTMASK;
+                       if (arg & DMC_FATAL) {
+                               if (arg != DMC_START)
+                                       log(LOG_ERR,
+                                           "dmc%d: fatal error, flags=%b\n",
+                                           unit, arg, CNTLO_BITS);
+                               dmcrestart(unit);
+                               break;
+                       }
+                       /* ACCUMULATE STATISTICS */
                        switch(arg) {
                        case DMC_NOBUFS:
                        switch(arg) {
                        case DMC_NOBUFS:
-                               ifp->if_ierrors++;
-                               if((sc->sc_nobuf++ % DMC_RPNBFS) != 0)
-                                       break;
-                               goto report;
+                               ifp->if_ierrors++;
+                               if ((sc->sc_nobuf++ % DMC_RPNBFS) == 0)
+                                       goto report;
+                               break;
                        case DMC_DISCONN:
                        case DMC_DISCONN:
-                               if((sc->sc_disc++ % DMC_RPDSC) != 0)
-                                       break;
-                               goto report;
+                               if ((sc->sc_disc++ % DMC_RPDSC) == 0)
+                                       goto report;
+                               break;
                        case DMC_TIMEOUT:
                        case DMC_TIMEOUT:
-                               if((sc->sc_timeo++ % DMC_RPTMO) != 0)
-                                       break;
-                               goto report;
+                               if ((sc->sc_timeo++ % DMC_RPTMO) == 0)
+                                       goto report;
+                               break;
                        case DMC_DATACK:
                        case DMC_DATACK:
-                               ifp->if_oerrors++;
-                               if((sc->sc_datck++ % DMC_RPDCK) != 0)
-                                       break;
-                               goto report;
+                               ifp->if_oerrors++;
+                               if ((sc->sc_datck++ % DMC_RPDCK) == 0)
+                                       goto report;
+                               break;
                        default:
                                goto report;
                        }
                        break;
                report:
                        default:
                                goto report;
                        }
                        break;
                report:
-                        printf("dmc%d: soft error, flags=%b\n",
-                            unit, arg, CNTLO_BITS);
-               }
-               break;
+                       printd("dmc%d: soft error, flags=%b\n", unit,
+                           arg, CNTLO_BITS);
+                       if ((sc->sc_flag & DMC_RESTART) == 0) {
+                               /*
+                                * kill off the dmc to get things
+                                * going again by generating a
+                                * procedure error
+                                */
+                               sc->sc_flag |= DMC_RESTART;
+                               arg = UBAI_ADDR(sc->sc_ubinfo);
+                               dmcload(sc, DMC_BASEI, arg, (arg>>2)&DMC_XMEM);
+                       }
+                       break;
 
 
-       default:
-               printf("dmc%d: bad control %o\n", unit, cmd);
+               default:
+                       printf("dmc%d: bad control %o\n", unit, cmd);
+                       break;
+               }
        }
        }
+       dmcstart(unit);
        return;
 }
 
 /*
  * DMC output routine.
        return;
 }
 
 /*
  * DMC output routine.
- * Just send the data, header was supplied by
- * upper level protocol routines.
+ * Encapsulate a packet of type family for the dmc.
+ * Use trailer local net encapsulation if enough data in first
+ * packet leaves a multiple of 512 bytes of data in remainder.
  */
  */
-dmcoutput(ifp, m, dst)
+dmcoutput(ifp, m0, dst)
        register struct ifnet *ifp;
        register struct ifnet *ifp;
-       register struct mbuf *m;
+       register struct mbuf *m0;
        struct sockaddr *dst;
 {
        struct sockaddr *dst;
 {
-       int s;
+       int type, error, s;
+       register struct mbuf *m = m0;
+       register struct dmc_header *dh;
+       register int off;
+
+       if ((ifp->if_flags & IFF_UP) == 0) {
+               error = ENETDOWN;
+               goto bad;
+       }
 
 
-       if (dst->sa_family != ifp->if_addr.sa_family) {
-               printf("dmc%d: af%d not supported\n", ifp->if_unit,
-                   dst->sa_family);
-               m_freem(m);
-               return (EAFNOSUPPORT);
+       switch (dst->sa_family) {
+#ifdef INET
+       case AF_INET:
+               off = m->m_pkthdr.len - m->m_len;
+               if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
+               if (off > 0 && (off & 0x1ff) == 0 &&
+                   (m->m_flags & M_EXT) == 0 &&
+                   m->m_data >= m->m_pktdat + 2 * sizeof (u_short)) {
+                       type = DMC_TRAILER + (off>>9);
+                       m->m_data -= 2 * sizeof (u_short);
+                       m->m_len += 2 * sizeof (u_short);
+                       *mtod(m, u_short *) = htons((u_short)DMC_IPTYPE);
+                       *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
+                       goto gottrailertype;
+               }
+               type = DMC_IPTYPE;
+               off = 0;
+               goto gottype;
+#endif
+
+       case AF_UNSPEC:
+               dh = (struct dmc_header *)dst->sa_data;
+               type = dh->dmc_type;
+               goto gottype;
+
+       default:
+               printf("dmc%d: can't handle af%d\n", ifp->if_unit,
+                       dst->sa_family);
+               error = EAFNOSUPPORT;
+               goto bad;
        }
        }
-       s = spl5();
+
+gottrailertype:
+       /*
+        * Packet to be sent as a trailer; move first packet
+        * (control information) to end of chain.
+        */
+       while (m->m_next)
+               m = m->m_next;
+       m->m_next = m0;
+       m = m0->m_next;
+       m0->m_next = 0;
+       m0 = m;
+
+gottype:
+       /*
+        * Add local network header
+        * (there is space for a uba on a vax to step on)
+        */
+       M_PREPEND(m, sizeof(struct dmc_header), M_DONTWAIT);
+       if (m == 0) {
+               error = ENOBUFS;
+               goto bad;
+       }
+       dh = mtod(m, struct dmc_header *);
+       dh->dmc_type = htons((u_short)type);
+
+       /*
+        * Queue message on interface, and start output if interface
+        * not yet active.
+        */
+       s = splimp();
        if (IF_QFULL(&ifp->if_snd)) {
                IF_DROP(&ifp->if_snd);
                m_freem(m);
        if (IF_QFULL(&ifp->if_snd)) {
                IF_DROP(&ifp->if_snd);
                m_freem(m);
@@ -681,309 +841,137 @@ dmcoutput(ifp, m, dst)
        dmcstart(ifp->if_unit);
        splx(s);
        return (0);
        dmcstart(ifp->if_unit);
        splx(s);
        return (0);
+
+bad:
+       m_freem(m0);
+       return (error);
 }
 
 }
 
+
 /*
  * Process an ioctl request.
  */
 /*
  * Process an ioctl request.
  */
+/* ARGSUSED */
 dmcioctl(ifp, cmd, data)
        register struct ifnet *ifp;
        int cmd;
        caddr_t data;
 {
 dmcioctl(ifp, cmd, data)
        register struct ifnet *ifp;
        int cmd;
        caddr_t data;
 {
-       struct ifreq *ifr = (struct ifreq *)data;
-       struct sockaddr_in *sin;
        int s = splimp(), error = 0;
        int s = splimp(), error = 0;
+       register struct dmc_softc *sc = &dmc_softc[ifp->if_unit];
 
        switch (cmd) {
 
        case SIOCSIFADDR:
 
        switch (cmd) {
 
        case SIOCSIFADDR:
-               if (ifp->if_flags & IFF_RUNNING)
-                       if_rtinit(ifp, -1);     /* delete previous route */
-               sin = (struct sockaddr_in *)&ifr->ifr_addr;
-               ifp->if_addr = *(struct sockaddr *)sin;
-               ifp->if_net = in_netof(sin->sin_addr);
                ifp->if_flags |= IFF_UP;
                ifp->if_flags |= IFF_UP;
-               /* set up routing table entry */
-               if ((ifp->if_flags & IFF_ROUTE) == 0) {
-                       rtinit(&ifp->if_dstaddr, &ifp->if_addr, RTF_HOST|RTF_UP);
-                       ifp->if_flags |= IFF_ROUTE;
-               }
+               if ((ifp->if_flags & IFF_RUNNING) == 0)
+                       dmcinit(ifp->if_unit); 
                break;
 
        case SIOCSIFDSTADDR:
                break;
 
        case SIOCSIFDSTADDR:
-               ifp->if_dstaddr = ifr->ifr_dstaddr;
+               if ((ifp->if_flags & IFF_RUNNING) == 0)
+                       dmcinit(ifp->if_unit); 
                break;
                
                break;
                
+       case SIOCSIFFLAGS:
+               if ((ifp->if_flags & IFF_UP) == 0 &&
+                   sc->sc_flag & DMC_RUNNING)
+                       dmcdown(ifp->if_unit);
+               else if (ifp->if_flags & IFF_UP &&
+                   (sc->sc_flag & DMC_RUNNING) == 0)
+                       dmcrestart(ifp->if_unit);
+               break;
+
        default:
                error = EINVAL;
        }
        default:
                error = EINVAL;
        }
-       if ((ifp->if_flags & IFF_RUNNING) == 0)
-               dmcinit(ifp->if_unit); 
        splx(s);
        return (error);
 }
 
 /*
        splx(s);
        return (error);
 }
 
 /*
- * Routines supporting UNIBUS network interfaces.
- */
-
-/*
- * Init UNIBUS for interface on uban whose headers of size hlen are to
- * end on a page boundary.  We allocate a UNIBUS map register for the page
- * with the header, and nmr more UNIBUS map registers for i/o on the adapter,
- * doing this for each receive and transmit buffer.  We also
- * allocate page frames in the mbuffer pool for these pages.
+ * Restart after a fatal error.
+ * Clear device and reinitialize.
  */
  */
-dmc_ubainit(ifu, uban, hlen, nmr)
-       register struct dmcuba *ifu;
-       int uban, hlen, nmr;
+dmcrestart(unit)
+       int unit;
 {
 {
-       register caddr_t cp, dp;
-       register struct ifrw *ifrw;
-       register struct ifxmt *ifxp;
-       int i, ncl;
-
-       ncl = clrnd(nmr + CLSIZE) / CLSIZE;
-       if (ifu->ifu_r[0].ifrw_addr) {
-               /*
-                * If the first read buffer has a non-zero
-                * address, it means we have already allocated core
-                */
-               cp = ifu->ifu_r[0].ifrw_addr - (CLBYTES - hlen);
-       } else {
-               cp = m_clalloc(NTOT * ncl, MPG_SPACE);
-               if (cp == 0)
-                       return (0);
-               ifu->ifu_hlen = hlen;
-               ifu->ifu_uban = uban;
-               ifu->ifu_uba = uba_hd[uban].uh_uba;
-               dp = cp + CLBYTES - hlen;
-               for (ifrw = ifu->ifu_r; ifrw < &ifu->ifu_r[NRCV]; ifrw++) {
-                       ifrw->ifrw_addr = dp;
-                       dp += ncl * CLBYTES;
-               }
-               for (ifxp = ifu->ifu_w; ifxp < &ifu->ifu_w[NXMT]; ifxp++) {
-                       ifxp->x_ifrw.ifrw_addr = dp;
-                       dp += ncl * CLBYTES;
-               }
-       }
-       /* allocate for receive ring */
-       for (ifrw = ifu->ifu_r; ifrw < &ifu->ifu_r[NRCV]; ifrw++) {
-               if (dmc_ubaalloc(ifu, ifrw, nmr) == 0) {
-                       struct ifrw *rw;
-
-                       for (rw = ifu->ifu_r; rw < ifrw; rw++)
-                               ubarelse(ifu->ifu_uban, &rw->ifrw_info);
-                       goto bad;
-               }
-       }
-       /* and now transmit ring */
-       for (ifxp = ifu->ifu_w; ifxp < &ifu->ifu_w[NXMT]; ifxp++) {
-               ifrw = &ifxp->x_ifrw;
-               if (dmc_ubaalloc(ifu, ifrw, nmr) == 0) {
-                       struct ifxmt *xp;
-
-                       for (xp = ifu->ifu_w; xp < ifxp; xp++)
-                               ubarelse(ifu->ifu_uban, &xp->x_ifrw.ifrw_info);
-                       for (ifrw = ifu->ifu_r; ifrw < &ifu->ifu_r[NRCV]; ifrw++)
-                               ubarelse(ifu->ifu_uban, &ifrw->ifrw_info);
-                       goto bad;
-               }
-               for (i = 0; i < nmr; i++)
-                       ifxp->x_map[i] = ifrw->ifrw_mr[i];
-               ifxp->x_xswapd = 0;
-       }
-       return (1);
-bad:
-       m_pgfree(cp, NTOT * ncl);
-       ifu->ifu_r[0].ifrw_addr = 0;
-       return (0);
-}
+       register struct dmc_softc *sc = &dmc_softc[unit];
+       register struct dmcdevice *addr;
+       register int i;
+       int s;
+       
+#ifdef DEBUG
+       /* dump base table */
+       printf("dmc%d base table:\n", unit);
+       for (i = 0; i < sizeof (struct dmc_base); i++)
+               printf("%o\n" ,dmc_base[unit].d_base[i]);
+#endif
 
 
-/*
- * Setup either a ifrw structure by allocating UNIBUS map registers,
- * possibly a buffered data path, and initializing the fields of
- * the ifrw structure to minimize run-time overhead.
- */
-static
-dmc_ubaalloc(ifu, ifrw, nmr)
-       struct dmcuba *ifu;
-       register struct ifrw *ifrw;
-       int nmr;
-{
-       register int info;
+       dmcdown(unit);
 
 
-       info =
-           uballoc(ifu->ifu_uban, ifrw->ifrw_addr, nmr*NBPG + ifu->ifu_hlen,
-               ifu->ifu_flags);
-       if (info == 0)
-               return (0);
-       ifrw->ifrw_info = info;
-       ifrw->ifrw_bdp = UBAI_BDP(info);
-       ifrw->ifrw_proto = UBAMR_MRV | (UBAI_BDP(info) << UBAMR_DPSHIFT);
-       ifrw->ifrw_mr = &ifu->ifu_uba->uba_map[UBAI_MR(info) + 1];
-       return (1);
+       /*
+        * Let the DMR finish the MCLR.  At 1 Mbit, it should do so
+        * in about a max of 6.4 milliseconds with diagnostics enabled.
+        */
+       addr = (struct dmcdevice *)(dmcinfo[unit]->ui_addr);
+       for (i = 100000; i && (addr->bsel1 & DMC_RUN) == 0; i--)
+               ;
+       /* Did the timer expire or did the DMR finish? */
+       if ((addr->bsel1 & DMC_RUN) == 0) {
+               log(LOG_ERR, "dmc%d: M820 Test Failed\n", unit);
+               return;
+       }
+
+       /* restart DMC */
+       dmcinit(unit);
+       sc->sc_flag &= ~DMC_RESTART;
+       s = spl5();
+       dmcstart(unit);
+       splx(s);
+       sc->sc_if.if_collisions++;      /* why not? */
 }
 
 /*
 }
 
 /*
- * Pull read data off a interface.
- * Len is length of data, with local net header stripped.
- * Off is non-zero if a trailer protocol was used, and
- * gives the offset of the trailer information.
- * We copy the trailer information and then all the normal
- * data into mbufs.  When full cluster sized units are present
- * on the interface on cluster boundaries we can get them more
- * easily by remapping, and take advantage of this here.
+ * Reset a device and mark down.
+ * Flush output queue and drop queue limit.
  */
  */
-struct mbuf *
-dmc_get(ifu, ifrw, totlen, off0)
-       register struct dmcuba *ifu;
-       register struct ifrw *ifrw;
-       int totlen, off0;
+dmcdown(unit)
+       int unit;
 {
 {
-       struct mbuf *top, **mp, *m;
-       int off = off0, len;
-       register caddr_t cp = ifrw->ifrw_addr + ifu->ifu_hlen;
-
-       top = 0;
-       mp = &top;
-       while (totlen > 0) {
-               MGET(m, M_DONTWAIT, MT_DATA);
-               if (m == 0)
-                       goto bad;
-               if (off) {
-                       len = totlen - off;
-                       cp = ifrw->ifrw_addr + ifu->ifu_hlen + off;
-               } else
-                       len = totlen;
-               if (len >= CLBYTES) {
-                       struct mbuf *p;
-                       struct pte *cpte, *ppte;
-                       int x, *ip, i;
-
-                       MCLGET(p, 1);
-                       if (p == 0)
-                               goto nopage;
-                       len = m->m_len = CLBYTES;
-                       m->m_off = (int)p - (int)m;
-                       if (!claligned(cp))
-                               goto copy;
+       register struct dmc_softc *sc = &dmc_softc[unit];
+       register struct ifxmt *ifxp;
 
 
-                       /*
-                        * Switch pages mapped to UNIBUS with new page p,
-                        * as quick form of copy.  Remap UNIBUS and invalidate.
-                        */
-                       cpte = &Mbmap[mtocl(cp)*CLSIZE];
-                       ppte = &Mbmap[mtocl(p)*CLSIZE];
-                       x = btop(cp - ifrw->ifrw_addr);
-                       ip = (int *)&ifrw->ifrw_mr[x];
-                       for (i = 0; i < CLSIZE; i++) {
-                               struct pte t;
-                               t = *ppte; *ppte++ = *cpte; *cpte = t;
-                               *ip++ =
-                                   cpte++->pg_pfnum|ifrw->ifrw_proto;
-                               mtpr(TBIS, cp);
-                               cp += NBPG;
-                               mtpr(TBIS, (caddr_t)p);
-                               p += NBPG / sizeof (*p);
-                       }
-                       goto nocopy;
+       ((struct dmcdevice *)(dmcinfo[unit]->ui_addr))->bsel1 = DMC_MCLR;
+       sc->sc_flag &= ~(DMC_RUNNING | DMC_ONLINE);
+
+       for (ifxp = sc->sc_ifw; ifxp < &sc->sc_ifw[NXMT]; ifxp++) {
+               if (ifxp->ifw_xtofree) {
+                       (void) m_freem(ifxp->ifw_xtofree);
+                       ifxp->ifw_xtofree = 0;
                }
                }
-nopage:
-               m->m_len = MIN(MLEN, len);
-               m->m_off = MMINOFF;
-copy:
-               bcopy(cp, mtod(m, caddr_t), (unsigned)m->m_len);
-               cp += m->m_len;
-nocopy:
-               *mp = m;
-               mp = &m->m_next;
-               if (off) {
-                       /* sort of an ALGOL-W style for statement... */
-                       off += m->m_len;
-                       if (off == totlen) {
-                               cp = ifrw->ifrw_addr + ifu->ifu_hlen;
-                               off = 0;
-                               totlen = off0;
-                       }
-               } else
-                       totlen -= m->m_len;
        }
        }
-       return (top);
-bad:
-       m_freem(top);
-       return (0);
+       if_qflush(&sc->sc_if.if_snd);
 }
 
 /*
 }
 
 /*
- * Map a chain of mbufs onto a network interface
- * in preparation for an i/o operation.
- * The argument chain of mbufs includes the local network
- * header which is copied to be in the mapped, aligned
- * i/o space.
+ * Watchdog timeout to see that transmitted packets don't
+ * lose interrupts.  The device has to be online (the first
+ * transmission may block until the other side comes up).
  */
  */
-dmcput(ifu, n, m)
-       struct dmcuba *ifu;
-       int n;
-       register struct mbuf *m;
+dmctimeout(unit)
+       int unit;
 {
 {
-       register struct mbuf *mp;
-       register caddr_t cp;
-       register struct ifxmt *ifxp;
-       register struct ifrw *ifrw;
-       register int i;
-       int xswapd = 0;
-       int x, cc, t;
-       caddr_t dp;
-
-       ifxp = &ifu->ifu_w[n];
-       ifrw = &ifxp->x_ifrw;
-       cp = ifrw->ifrw_addr;
-       while (m) {
-               dp = mtod(m, char *);
-               if (claligned(cp) && claligned(dp) && m->m_len == CLBYTES) {
-                       struct pte *pte; int *ip;
-                       pte = &Mbmap[mtocl(dp)*CLSIZE];
-                       x = btop(cp - ifrw->ifrw_addr);
-                       ip = (int *)&ifrw->ifrw_mr[x];
-                       for (i = 0; i < CLSIZE; i++)
-                               *ip++ = ifrw->ifrw_proto | pte++->pg_pfnum;
-                       xswapd |= 1 << (x>>(CLSHIFT-PGSHIFT));
-                       mp = m->m_next;
-                       m->m_next = ifxp->x_xtofree;
-                       ifxp->x_xtofree = m;
-                       cp += m->m_len;
-               } else {
-                       bcopy(mtod(m, caddr_t), cp, (unsigned)m->m_len);
-                       cp += m->m_len;
-                       MFREE(m, mp);
-               }
-               m = mp;
-       }
+       register struct dmc_softc *sc;
+       struct dmcdevice *addr;
 
 
-       /*
-        * Xswapd is the set of clusters we just mapped out.  Ifxp->x_xswapd
-        * is the set of clusters mapped out from before.  We compute
-        * the number of clusters involved in this operation in x.
-        * Clusters mapped out before and involved in this operation
-        * should be unmapped so original pages will be accessed by the device.
-        */
-       cc = cp - ifrw->ifrw_addr;
-       x = ((cc - ifu->ifu_hlen) + CLBYTES - 1) >> CLSHIFT;
-       ifxp->x_xswapd &= ~xswapd;
-       while (i = ffs(ifxp->x_xswapd)) {
-               i--;
-               if (i >= x)
-                       break;
-               ifxp->x_xswapd &= ~(1<<i);
-               i *= CLSIZE;
-               for (t = 0; t < CLSIZE; t++) {
-                       ifrw->ifrw_mr[i] = ifxp->x_map[i];
-                       i++;
-               }
+       sc = &dmc_softc[unit];
+       if (sc->sc_flag & DMC_ONLINE) {
+               addr = (struct dmcdevice *)(dmcinfo[unit]->ui_addr);
+               log(LOG_ERR, "dmc%d: output timeout, bsel0=%b bsel2=%b\n",
+                   unit, addr->bsel0 & 0xff, DMC0BITS,
+                   addr->bsel2 & 0xff, DMC2BITS);
+               dmcrestart(unit);
        }
        }
-       ifxp->x_xswapd |= xswapd;
-       return (cc);
 }
 #endif
 }
 #endif