massive rewrites; must debug when hardware shows up

SCCS-vsn: sys/tahoe/if/if_enp.c 1.2
SCCS-vsn: sys/tahoe/if/if_enpreg.h 1.2

diff --git a/usr/src/sys/tahoe/if/if_enp.c b/usr/src/sys/tahoe/if/if_enp.c
index 356cd30..ac042aa 100644 (file)
--- a/usr/src/sys/tahoe/if/if_enp.c
+++ b/usr/src/sys/tahoe/if/if_enp.c
@@ -1,14 +1,13 @@
-/*     if_enp.c        1.1     86/07/20        */
+/*     if_enp.c        1.2     86/11/29        */

 
 #include "enp.h"
 
 #include "enp.h"

-#define ENPBPTE 128

 #if NENP > 0
 #if NENP > 0

-

 /*
 /*

- * Modified 3 Com Ethernet Controller interface
+ * Modified 3Com Ethernet Controller interface

  * enp modifications added S. F. Holmgren
  * enp modifications added S. F. Holmgren

+ *
+ * UNTESTED WITH 4.3

  */
  */

-

 #include "param.h"
 #include "systm.h"
 #include "mbuf.h"
 #include "param.h"
 #include "systm.h"
 #include "mbuf.h"


@@ -16,72 +15,48 @@
 #include "protosw.h"
 #include "socket.h"
 #include "vmmac.h"
 #include "protosw.h"
 #include "socket.h"
 #include "vmmac.h"

+#include "ioctl.h"

 #include "errno.h"
 #include "errno.h"

-#include "time.h"
-#include "kernel.h"
+#include "vmparam.h"
+#include "syslog.h"

 #include "uio.h"
 
 #include "../net/if.h"
 #include "../net/netisr.h"
 #include "../net/route.h"
 #include "uio.h"
 
 #include "../net/if.h"
 #include "../net/netisr.h"
 #include "../net/route.h"

+#ifdef INET

 #include "../netinet/in.h"
 #include "../netinet/in.h"

-#include "../h/ioctl.h"
-

 #include "../netinet/in_systm.h"
 #include "../netinet/in_systm.h"

+#include "../netinet/in_var.h"

 #include "../netinet/ip.h"
 #include "../netinet/ip_var.h"
 #include "../netinet/if_ether.h"
 #include "../netinet/ip.h"
 #include "../netinet/ip_var.h"
 #include "../netinet/if_ether.h"

+#endif
+#ifdef NS
+#include "../netns/ns.h"
+#include "../netns/ns_if.h"
+#endif
+
+#include "../tahoe/cpu.h"
+#include "../tahoe/pte.h"
+#include "../tahoe/mtpr.h"

 
 #include "../tahoevba/vbavar.h"
 
 #include "../tahoevba/vbavar.h"

-#include "../tahoeif/if_enp.h"
-#include "../machine/mtpr.h"
-#include "../tahoeif/if_debug.h"
+#include "../tahoeif/if_enpreg.h"

 
 

-#define ENP0_PHYSADDR  0xf40000        /* board # 0 physical base addr */
-#define ENP1_PHYSADDR  0xf60000        /* board # 1 physical base addr */
-#define ENPSTART       0xf02000        /* standard enp start addr      */
+#define        ENPVEC  0xc1
+#define ENPSTART       0xf02000        /* standard enp start addr */
+#define        ENPUNIT(dev)    (minor(dev))    /* for enp ram devices */

 
 int    enpprobe(), enpattach(), enpintr();
 
 int    enpprobe(), enpattach(), enpintr();

-extern nulldev();
-caddr_t        vtoph();
-struct  mbuf *m_tofree();
-struct  vba_device *enpinfo[ NENP ];
-
-/*     Maximun 2 controllers per system supported                      */
-
-long  enpstd[] = { ENP0_PHYSADDR+0x1000,ENP1_PHYSADDR+0x1000, 0 };
-extern char    enp0utl[], enp1utl[];   /* enp accessible ram map       */
-char   *enpmap[]= { enp0utl, enp1utl };
-extern long    ENP0map[], ENP1map[];
-long   *ENPmap[] = {ENP0map, ENP1map};
-long   ENPmapa[] = {0xfff41000, 0xfff61000};
-long   enpismapped[NENP];
-
-unsigned short intvec[4] = 
-       { 0xc1, 0xc2, 0xc3, 0xc4 };     /* intrvec of upto 4 enps       */
-
+long   enpstd[] = { 0xf41000, 0xf61000, 0 };
+struct  vba_device *enpinfo[NENP];

 struct  vba_driver enpdriver = 
 struct  vba_driver enpdriver = 

-{
-/* use of prom based version 
-       enpprobe, 0, enpattach, 0, 0,   enpintr,
-*/
-       enpprobe, 0, nulldev, 0, 
-       enpstd,   "enp", enpinfo, "ENP 20", 0
-};
-
-int     enpinit(),
-       enpioctl(),
-       enpoutput(),
-       enpreset(),
-       enpbroadcast(),
-       enptimeout();
-
-int    enpcopy();
+    { enpprobe, 0, enpattach, 0, enpstd, "enp", enpinfo, "enp-20", 0 };

 
 

+int    enpinit(), enpioctl(), enpreset(), enpoutput();

 struct  mbuf *enpget();
 
 struct  mbuf *enpget();
 

-extern  struct ifnet loif;
-

 /*
  * Ethernet software status per interface.
  *
 /*
  * Ethernet software status per interface.
  *


@@ -89,40 +64,34 @@ extern  struct ifnet loif;
  * es_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */
  * es_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */

-
-struct         enp_softc       enp_softc[NENP];
-long   stat_addr[NENP];        /* enp statistic addr (for nstat use) */
-long   ring_addr[NENP];        /* enp dev ring addresses (for nstat use) */
-int    numenp = NENP;
-int    enp_intr = 0,           /* no. of enp_to_host interrupts */
-       host_intr = 0;          /* no. of host_to_enp interrupts */
-short  enpram[NENP];           /* open/close flags for enp devices */
-/*     Debugging tools, used to trace input packets */
-extern         int     printerror;     /* error print flag, from if_ace.c */
-int    save_enp_inpkt = 0;
-#define        ENPTRACE(X)     if (save_enp_inpkt) X;
-
-struct         inp_err         enperr[NENP];
-
-/*
- * Probe for device.
- */
-
-enpprobe(reg)
-caddr_t reg;
+struct  enp_softc {
+       struct  arpcom es_ac;           /* common ethernet structures */
+#define es_if          es_ac.ac_if
+#define es_enaddr      es_ac.ac_enaddr
+       short   es_flags;               /* flags for devices */
+       short   es_ivec;                /* interrupt vector */
+       struct  pte *es_map;            /* map for dual ported memory */
+       caddr_t es_ram;                 /* virtual address of mapped memory */
+} enp_softc[NENP]; 
+extern struct ifnet loif;
+
+enpprobe(reg, vi)
+       caddr_t reg;
+       struct vba_device *vi;

 {
 {

-       static  int     unit=0;
-       register ENPDEVICE      *addr = (ENPDEVICE *)reg;
+       register br, cvec;              /* must be r12, r11 */
+       register struct enpdevice *addr = (struct enpdevice *)reg;
+       struct enp_softc *es = &enp_softc[vi->ui_unit];

 
 

-       if( (badaddr( addr, 2 ) ) || (badaddr( &addr->enp_ram[0], 2 ) ) )
-               return( 0 );
-       addr->enp_state = S_ENPRESET; /* controller is reset by vbus reset */
-       /* save address of statistic area for nstat uses        */
-
-       stat_addr[unit] = (long) &(addr->enp_stat); 
-       ring_addr[unit++] = (long) &(addr->enp_toenp); 
-
-       return( ENPSIZE );
+#ifdef lint
+       enpintr(0);
+#endif
+       if (badaddr(addr, 2) || badaddr(&addr->enp_ram[0], 2))
+               return (0);
+       es->es_ivec = --vi->ui_hd->vh_lastiv;
+       addr->enp_state = S_ENPRESET;           /* reset by VERSAbus reset */
+       br = 0x14, cvec = es->es_ivec;          /* XXX */
+       return (sizeof (struct enpdevice));

 }
 
 /*
 }
 
 /*


@@ -130,166 +99,110 @@ caddr_t reg;
  * record.  System will initialize the interface when it is ready
  * to accept packets. 
  */
  * record.  System will initialize the interface when it is ready
  * to accept packets. 
  */

-
-enpattach( md )
-register struct vba_device *md;
+enpattach(ui)
+       register struct vba_device *ui;

 {
 {

-       struct enp_softc        *es = &enp_softc[md->ui_unit];
-       register struct ifnet   *ifp = &es->es_if;
-       register ENPDEVICE      *addr = (ENPDEVICE *)md->ui_addr;
-       struct sockaddr_in      *sin;
+       struct enp_softc *es = &enp_softc[ui->ui_unit];
+       register struct ifnet *ifp = &es->es_if;
+       register struct enpdevice *addr = (struct enpdevice *)ui->ui_addr;

 
 

-       enpgetaddr( md->ui_unit );
-
-       ifp->if_unit = md->ui_unit;
+       ifp->if_unit = ui->ui_unit;

        ifp->if_name = "enp";
        ifp->if_mtu = ETHERMTU;
        ifp->if_name = "enp";
        ifp->if_mtu = ETHERMTU;

-
-/*     bcopy(&es->es_boardaddr, es->es_enaddr, sizeof(es->es_enaddr)); */
-
-       sin = (struct sockaddr_in *)&es->es_if.if_addr;
-       sin->sin_family = AF_INET;
+       /*
+        * Get station's addresses.
+        */
+       enpcopy(&addr->enp_addr.e_baseaddr, es->es_enaddr,
+           sizeof (es->es_enaddr));
+       printf("enp%d: hardware address %s\n", ui->ui_unit,
+           ether_sprintf(es->es_enaddr));
+       /*
+        * Allocate and map ram.
+        */
+       vbmemalloc(128, ((caddr_t)addr)+0x1000, &es->es_map, &es->es_ram);

 
        ifp->if_init = enpinit;
        ifp->if_ioctl = enpioctl;
        ifp->if_output = enpoutput;
        ifp->if_reset = enpreset;
 
        ifp->if_init = enpinit;
        ifp->if_ioctl = enpioctl;
        ifp->if_output = enpoutput;
        ifp->if_reset = enpreset;

+       ifp->if_flags = IFF_BROADCAST;

        if_attach(ifp);
 }
 
        if_attach(ifp);
 }
 

-

 /*
 /*

- * Reset of interface after UNIBUS reset.
+ * Reset of interface after "system" reset.

  */
  */

-enpreset(unit)
-int unit;
+enpreset(unit, vban)
+       int unit, vban;

 {
 {

-       register struct vba_device *md;
-
-       if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
-               return(ENODEV);
+       register struct vba_device *ui;

 
 

+       if (unit >= NENP || (ui = enpinfo[unit]) == 0 || ui->ui_alive == 0 ||
+           ui->ui_vbanum != vban)
+               return;
+       printf(" enp%d", unit);

        enpinit(unit);
 }
 
 /*
        enpinit(unit);
 }
 
 /*

- * Initialization of interface; clear recorded pending
- * operations.
+ * Initialization of interface; clear recorded pending operations.

  */
  */

-
-enpinit( unit )
-int unit;
+enpinit(unit)
+       int unit;

 {
 {

-       struct enp_softc        *es = &enp_softc[unit];
-       ENPDEVICE               *addr;
-       int i, s;
-       u_char *cp, *ap;
-       register struct ifnet   *ifp = &es->es_if;
-       register struct sockaddr_in *sin, *sinb;
-
-       sin = (struct sockaddr_in *)&ifp->if_addr;
-
-       if ( !enpismapped[unit] ) {
-               ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
-               ++enpismapped[unit];
-       }
-       if ((addr = (ENPDEVICE *)enpinfo[unit]->ui_addr) == (ENPDEVICE *)0)
-               return(ENODEV);
-       s = splimp();
-       RESET_ENP( addr );
-       DELAY( 200000 );
-
-#ifdef notdef
-/* only needed if not downloading ( ie, ROM-resident ENP code) */
-       addr->enp_intrvec = intvec[unit];
-       ENP_GO( addr,ENPSTART );
-       DELAY( 200000 );
-/* end of ROM-resident */
-#endif notdef
-
-       es->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
-       splx(s);
+       struct enp_softc *es = &enp_softc[unit];
+       register struct vba_device *ui = enpinfo[unit];
+       struct enpdevice *addr;
+       register struct ifnet *ifp = &es->es_if;
+       int s;

 
 

-       if_rtinit( &es->es_if,RTF_UP );
-       arpwhohas(&es->es_ac, &sin->sin_addr);
+       if (ifp->if_addrlist == (struct ifaddr *)0)
+               return;
+       if ((ifp->if_flags & IFF_RUNNING) == 0) {
+               addr = (struct enpdevice *)ui->ui_addr;
+               s = splimp();
+               RESET_ENP(addr);
+               DELAY(200000);
+               addr->enp_intrvec = es->es_ivec;
+               es->es_if.if_flags |= IFF_RUNNING;
+               splx(s);
+       }

 }
 
 }
 

-

 /*
  * Ethernet interface interrupt.
  */
 /*
  * Ethernet interface interrupt.
  */

-
-enpintr( unit )
+enpintr(unit)
+       int unit;

 {
 {

-       register ENPDEVICE              *addr;
-       register BCB                    *bcbp;
-       register struct vba_device       *md;
-
-       enp_intr++;
-
-       if (unit >= NENP || (md = enpinfo[unit]) == 0)
-               return;
-
-       addr = (ENPDEVICE *)md->ui_addr;
+       register struct enpdevice *addr;
+       register BCB *bcbp;

 
 

-       if( IS_ENP_INTR(addr) == 0 )
+       addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
+       if (!IS_ENP_INTR(addr))

                return;
                return;

-
-       ACK_ENP_INTR( addr );
-
-       while( (bcbp = (BCB *)ringget( &addr->enp_tohost )) != 0 )
-       {
-               enpread( &enp_softc[ unit ],bcbp, unit );
-               ringput( &addr->enp_enpfree,bcbp ); 
-       }
-       return(0);
-}
-
-#define        MAXBLEN 1500
-char   errpkt[MAXBLEN];
-int    bufptr = 0;
-int    maxl_tosave = 200;              /* save only the first 200 bytes */
-
-saverrpkt(errbuf, errtype, len)
-register u_char *errbuf;
-int errtype, len;
-{
-       int remain, newptr;
-
-       remain = MAXBLEN - bufptr;
-       if (remain < 50)                /* if too small                 */
-               return;                 /* no space avail               */
-       len = (len > maxl_tosave || len <= 0) ? maxl_tosave : len;
-       len = len > remain ? (remain - 2*sizeof(len)): len;
-       newptr = bufptr + len + 2*sizeof(len);
-       if (newptr <= MAXBLEN) {
-               enpcopy((char *)&len, &errpkt[bufptr], sizeof(len));
-               enpcopy((char *)&errtype, &errpkt[bufptr+sizeof(len)],
-                       sizeof(errtype));
-               enpcopy(errbuf, &errpkt[bufptr+(2*sizeof(len))], len);
+       ACK_ENP_INTR(addr);
+       while ((bcbp = (BCB *)ringget(&addr->enp_tohost )) != 0) {
+               (void) enpread(&enp_softc[unit], bcbp, unit);
+               ringput(&addr->enp_enpfree, bcbp); 

        }
        }

-       bufptr = newptr;

 }
 
 /*
  * Read input packet, examine its packet type, and enqueue it.
  */
 }
 
 /*
  * Read input packet, examine its packet type, and enqueue it.
  */

-
-enpread( es, bcbp, unit )
-struct enp_softc *es;
-register BCB *bcbp;
-int    unit;
+enpread(es, bcbp, unit)
+       struct enp_softc *es;
+       register BCB *bcbp;
+       int unit;

 {
        register struct ether_header *enp;
        struct mbuf *m;
 {
        register struct ether_header *enp;
        struct mbuf *m;

-       long int  s, v;
-       register short *vp = (short *)&v,
-                       *sp;
+       long int s;

        int len, off, resid, enptype;
        register struct ifqueue *inq;
 
        es->es_if.if_ipackets++; 
        int len, off, resid, enptype;
        register struct ifqueue *inq;
 
        es->es_if.if_ipackets++; 

-

        /*
         * Get input data length.
         * Get pointer to ethernet header (in input buffer).
        /*
         * Get input data length.
         * Get pointer to ethernet header (in input buffer).


@@ -297,106 +210,75 @@ int      unit;
         * get true type from first 16-bit word past data.
         * Remember that type was trailer by setting off.
         */
         * get true type from first 16-bit word past data.
         * Remember that type was trailer by setting off.
         */

-
-       len = bcbp->b_msglen - SIZEOF_ETHEADER;
-#ifdef TAHOE
-       sp = (short *)&bcbp->b_addr;
-       *vp = *sp; vp[1] = sp[1];
-       enp = (struct ether_header *) v;
-#else
+       len = bcbp->b_msglen - sizeof (struct ether_header);

        enp = (struct ether_header *)bcbp->b_addr;
        enp = (struct ether_header *)bcbp->b_addr;

-#endif TAHOE
-
-#define enpdataaddr(enp, off, type) ((type)(((caddr_t)(((char *)enp)+SIZEOF_ETHEADER)+(off))))
-
-       enptype = enp->ether_type;
-       if (enptype >= ETHERPUP_TRAIL && enptype < ETHERPUP_TRAIL+ETHERPUP_NTRAILER) 
-       {
-               off = (enptype - ETHERPUP_TRAIL) * 512;
-               if (off >= ETHERMTU) {
-                       enperr[unit].bad_offset++;
-                       ENPTRACE(saverrpkt((char *)enp, B_OFFSET, bcbp->b_msglen)); 
-
-                       goto badinput;
-               }
-               enptype = *enpdataaddr(enp, off, u_short *);
-               resid = *(enpdataaddr(enp, off+2, u_short *));
-
-               if (off + resid > len) {
-                       enperr[unit].bad_length++;
-                       ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen)); 
-                       goto badinput;
-               }
+#define enpdataaddr(enp, off, type) \
+    ((type)(((caddr_t)(((char *)enp)+sizeof (struct ether_header))+(off))))
+       enp->ether_type = ntohs((u_short)enp->ether_type);
+       if (enp->ether_type >= ETHERTYPE_TRAIL &&
+           enp->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
+               off = (enp->ether_type - ETHERTYPE_TRAIL) * 512;
+               if (off >= ETHERMTU)
+                       goto setup;
+               enp->ether_type = ntohs(*enpdataaddr(enp, off, u_short *));
+               resid = ntohs(*(enpdataaddr(enp, off+2, u_short *)));
+               if (off + resid > len)
+                       goto setup;

                len = off + resid;
                len = off + resid;

-       } 
-       else
+       } else

                off = 0;
                off = 0;

+       if (len == 0)
+               goto setup;

 
 

-       if( len == 0 ) {
-               enperr[unit].bad_length++;
-               ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen)); 
-               goto badinput;
-       }

        /*
         * Pull packet off interface.  Off is nonzero if packet
         * has trailing header; enpget 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.
         */
        /*
         * Pull packet off interface.  Off is nonzero if packet
         * has trailing header; enpget 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 = enpget(bcbp->b_addr, len, off, &es->es_if);
+       if (m == 0)
+               goto setup;
+       if (off) {
+               struct ifnet *ifp;

 
 

-       m = enpget(bcbp, len, off);
-       if( m == 0 )  {
-               enperr[unit].h_nobuffer++; /* host runs out of buf */
-               goto badinput;
-       }
-       if( off )
-       {
+               ifp = *(mtod(m, struct ifnet **));

                m->m_off += 2 * sizeof (u_short);
                m->m_len -= 2 * sizeof (u_short);
                m->m_off += 2 * sizeof (u_short);
                m->m_len -= 2 * sizeof (u_short);

+               *(mtod(m, struct ifnet **)) = ifp;

        }
        }

+       switch (enp->ether_type) {

 
 

-       switch (enptype) 
-       {

 #ifdef INET
 #ifdef INET

-       case ETHERPUP_IPTYPE:
-#ifdef notdef
-               arpipin(enp, m);
-#endif notdef
+       case ETHERTYPE_IP:

                schednetisr(NETISR_IP);
                inq = &ipintrq;
                break;
                schednetisr(NETISR_IP);
                inq = &ipintrq;
                break;

-
-       case ETHERPUP_ARPTYPE:
+#endif
+       case ETHERTYPE_ARP:

                arpinput(&es->es_ac, m);
                arpinput(&es->es_ac, m);

-               return(0);
+               goto setup;
+
+#ifdef NS
+       case ETHERTYPE_NS:
+               schednetisr(NETISR_NS);
+               inq = &nsintrq;
+               break;

 #endif
 #endif

-       default:        /* unrecognized ethernet header */
-               enperr[unit].bad_packetype++;
-               if (printerror) { 
-                       printf("\nenp%d: Undefined packet type 0x%x ", unit,
-                               enp->ether_type);
-                       printf("from host: %x.%x.%x.%x.%x.%x\n", 
-                               enp->ether_shost[0], enp->ether_shost[1], 
-                               enp->ether_shost[2], enp->ether_shost[3],
-                               enp->ether_shost[4], enp->ether_shost[5]);
-               }       /* end debugging aid    */
-               ENPTRACE(saverrpkt((char *)enp, B_PACKETYPE, bcbp->b_msglen)); 
+       default:

                m_freem(m);
                m_freem(m);

-               goto badinput;
+               goto setup;

        }
        }

-
-       if (IF_QFULL(inq)) 
-       {
-               enperr[unit].inq_full++;
+       if (IF_QFULL(inq)) {

                IF_DROP(inq);
                m_freem(m);
                IF_DROP(inq);
                m_freem(m);

-               return(0);
+               goto setup;

        }
        s = splimp();
        IF_ENQUEUE(inq, m);
        splx(s);
        }
        s = splimp();
        IF_ENQUEUE(inq, m);
        splx(s);

-badinput:
-       return(0);         /* sanity */
+setup:
+       return (0);

 }
 
 /*
 }
 
 /*


@@ -408,83 +290,69 @@ badinput:
  * loop device to kludge around the fact that 3com interfaces can't
  * talk to themselves.
  */
  * loop device to kludge around the fact that 3com interfaces can't
  * talk to themselves.
  */

-

 enpoutput(ifp, m0, dst)
 enpoutput(ifp, m0, dst)

-struct ifnet *ifp;
-struct mbuf *m0;
-struct sockaddr *dst;
+       struct ifnet *ifp;
+       struct mbuf *m0;
+       struct sockaddr *dst;

 {
 {

-       int type, s, error;
-       struct ether_addr edst;
-       struct in_addr idst;
-

        register struct enp_softc *es = &enp_softc[ifp->if_unit];
        register struct mbuf *m = m0;
        register struct ether_header *enp;
        register int off, i;
        register struct enp_softc *es = &enp_softc[ifp->if_unit];
        register struct mbuf *m = m0;
        register struct ether_header *enp;
        register int off, i;

+       struct mbuf *mcopy = (struct mbuf *)0;
+       int type, s, error, usetrailers;
+       u_char edst[6];
+       struct in_addr idst;

 
 

-       struct mbuf *mcopy = (struct mbuf *) 0;         /* Null */
-       int unit = ifp->if_unit;
-
-       switch( dst->sa_family )
-       {
+       if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
+               error = ENETDOWN;
+               goto bad;
+       }
+       switch (dst->sa_family) {

 #ifdef INET
        case AF_INET:
                idst = ((struct sockaddr_in *)dst)->sin_addr;
 #ifdef INET
        case AF_INET:
                idst = ((struct sockaddr_in *)dst)->sin_addr;

-
-               /* translate internet to ethernet address */
-
-               switch(arpresolve(&es->es_ac, m, &idst, &edst)) {
-
-                       case ARPRESOLVE_WILLSEND:
-                               return (0);     /* if not yet resolved */
-                       case ARPRESOLVE_BROADCAST:
-                               mcopy = m_copy(m, 0, (int)M_COPYALL);
-                               if (mcopy)
-                                       looutput(&loif, mcopy, dst);
-
-                               /* falls through ... */
-                       case ARPRESOLVE_OK:
-                               break;
+               if (!arpresolve(&es->es_ac, m, &idst, edst, &usetrailers))
+                       return (0);     /* if not yet resolved */
+               if (!bcmp((caddr_t)edst, (caddr_t)etherbroadcastaddr,
+                   sizeof (edst)))
+                       mcopy = m_copy(m, 0, (int)M_COPYALL);
+               off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
+               if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
+                   m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
+                       type = ETHERTYPE_TRAIL + (off>>9);
+                       m->m_off -= 2 * sizeof (u_short);
+                       m->m_len += 2 * sizeof (u_short);
+                       *mtod(m, u_short *) = ETHERTYPE_IP;
+                       *(mtod(m, u_short *) + 1) = m->m_len;
+                       goto gottrailertype;

                }
                }

-               off = ((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
-               if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
-                       if (off > 0 && (off & 0x1ff) == 0 &&
-                           m->m_off >= MMINOFF + 2 * sizeof (u_short)) 
-                       {
-                               type = ETHERPUP_TRAIL + (off>>9);
-                               m->m_off -= 2 * sizeof (u_short);
-                               m->m_len += 2 * sizeof (u_short);
-                               *mtod(m, u_short *) = ETHERPUP_IPTYPE;
-                               *(mtod(m, u_short *) + 1) = m->m_len;
-                               goto gottrailertype;
-                       }
-
-               type = ETHERPUP_IPTYPE;
+               type = ETHERTYPE_IP;

                off = 0;
                goto gottype;
 #endif
                off = 0;
                goto gottype;
 #endif

-
-#ifdef notdef
-       case AF_RAW:
-               enp = mtod(m, struct ether_header *);
-               if (m->m_len < sizeof *enp) 
-               {
-                       error = EMSGSIZE;
-                       goto bad;
-               }
-               goto gotheader;
+#ifdef NS
+       case AF_NS:
+               bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
+                   (caddr_t)edst, sizeof (edst));
+               if (!bcmp((caddr_t)edst, (caddr_t)&ns_broadhost, sizeof (edst)))
+                       mcopy = m_copy(m, 0, (int)M_COPYALL);
+               else if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost,
+                   sizeof (edst)))
+                       return (looutput(&loif, m, dst));
+               type = ETHERTYPE_NS;
+               off = 0;
+               goto gottype;

 #endif
 #endif

-

        case AF_UNSPEC:
                enp = (struct ether_header *)dst->sa_data;
        case AF_UNSPEC:
                enp = (struct ether_header *)dst->sa_data;

-               bcopy( enp->ether_dhost, &edst, sizeof(edst));
+               bcopy((caddr_t)enp->ether_dhost, (caddr_t)edst, sizeof (edst));

                type = enp->ether_type;
                goto gottype;
 
        default:
                type = enp->ether_type;
                goto gottype;
 
        default:

-               if (printerror)
-                   printf("enp%d: can't handle af%d\n", unit,dst->sa_family);
+               log(LOG_ERR, "enp%d: can't handle af%d\n",
+                   ifp->if_unit, dst->sa_family);

                error = EAFNOSUPPORT;
                goto bad;
        }
                error = EAFNOSUPPORT;
                goto bad;
        }


@@ -507,197 +375,143 @@ gottype:
          * allocate another.
          */
        if (m->m_off > MMAXOFF ||
          * allocate another.
          */
        if (m->m_off > MMAXOFF ||

-           MMINOFF + SIZEOF_ETHEADER > m->m_off) 
-       {
+           MMINOFF + sizeof (struct ether_header) > m->m_off) {

                m = m_get(M_DONTWAIT, MT_HEADER);
                m = m_get(M_DONTWAIT, MT_HEADER);

-               if (m == 0) 
-               {
-                       enperr[unit].h_nobuffer++; /* host runs out of buf */
+               if (m == 0) {

                        error = ENOBUFS;
                        goto bad;
                }
                m->m_next = m0;
                m->m_off = MMINOFF;
                        error = ENOBUFS;
                        goto bad;
                }
                m->m_next = m0;
                m->m_off = MMINOFF;

-               m->m_len = SIZEOF_ETHEADER;
-       } 
-       else
-       {
-               m->m_off -= SIZEOF_ETHEADER;
-               m->m_len += SIZEOF_ETHEADER;
+               m->m_len = sizeof (struct ether_header);
+       } else {
+               m->m_off -= sizeof (struct ether_header);
+               m->m_len += sizeof (struct ether_header);

        }
        enp = mtod(m, struct ether_header *);
        }
        enp = mtod(m, struct ether_header *);

-       bcopy( &edst, enp->ether_dhost, sizeof(enp->ether_dhost) );
-       enp->ether_type = type;
-gotheader:
-       bcopy( es->es_enaddr, enp->ether_shost, sizeof(enp->ether_shost));
+       bcopy((caddr_t)edst, (caddr_t)enp->ether_dhost, sizeof (edst));
+       bcopy((caddr_t)es->es_enaddr, (caddr_t)enp->ether_shost,
+           sizeof (es->es_enaddr));
+       enp->ether_type = htons((u_short)type);

 
        /*
         * Queue message on interface if possible 
         */
 
        /*
         * Queue message on interface if possible 
         */

-

        s = splimp();   
        s = splimp();   

-       if( enpput( unit,m ) )
-       {
+       if (enpput(ifp->if_unit, m)) {

                error = ENOBUFS;
                error = ENOBUFS;

-               enperr[unit].c_nobuffer++; /* controller runs out of buf */

                goto qfull;
        }
                goto qfull;
        }

-       splx( s );      
+       splx(s);        

        es->es_if.if_opackets++; 
        es->es_if.if_opackets++; 

-       return(0);
+       return (mcopy ? looutput(&loif, mcopy, dst) : 0);

 qfull:
 qfull:

-       splx( s );      
+       splx(s);        

        m0 = m;
 bad:
        m_freem(m0);
        m0 = m;
 bad:
        m_freem(m0);

-       return(error);
+       if (mcopy)
+               m_freem(mcopy);
+       return (error);

 }
 
 /*
 }
 
 /*

- * Routine to copy from mbuf chain to transmitter
- * buffer in Multibus memory.
+ * Routine to copy from mbuf chain to transmitter buffer on the VERSAbus.

  */
  */

-
-enpput( unit,m )
-int unit;
-struct mbuf *m;
+enpput(unit, m)
+       int unit;
+       struct mbuf *m;

 {
        register BCB *bcbp;
 {
        register BCB *bcbp;

-       register ENPDEVICE *addr;
+       register struct enpdevice *addr;

        register struct mbuf *mp;
        register u_char *bp;
        register struct mbuf *mp;
        register u_char *bp;

-       int      ctr = 0;
-       long int        v;
-       register short *vp = (short *)&v,
-                       *sp;
+       register u_int len;
+       u_char *mcp;

 
 

-       addr = (ENPDEVICE *)enpinfo[ unit ]->ui_addr;
-
-       if ( ringempty( &addr->enp_hostfree ) ) 
-                       return( 1 );    
-
-       bcbp = (BCB *)ringget( &addr->enp_hostfree );
+       addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
+       if (ringempty(&addr->enp_hostfree)) 
+               return (1);     
+       bcbp = (BCB *)ringget(&addr->enp_hostfree);

        bcbp->b_len = 0;
        bcbp->b_len = 0;

-#ifdef TAHOE
-       sp = (short *)&bcbp->b_addr;
-       *vp = *sp; vp[1] = sp[1];
-       bp = (u_char *)v;
-#else

        bp = (u_char *)bcbp->b_addr;
        bp = (u_char *)bcbp->b_addr;

-#endif TAHOE
-       for (mp = m; mp; mp = mp->m_next) 
-       {
-               register unsigned len;
-               u_char *mcp;
-
+       for (mp = m; mp; mp = mp->m_next) {

                len = mp->m_len;
                len = mp->m_len;

-               if( len == 0 )
+               if (len == 0)

                        continue;
                        continue;

-               mcp = mtod( mp,u_char * );
-               enpcopy( mcp,bp,len );
+               mcp = mtod(mp, u_char *);
+               enpcopy(mcp, bp, len);

                bp += len;
                bcbp->b_len += len;
        }
                bp += len;
                bcbp->b_len += len;
        }

-       bcbp->b_len = max( MINPKTSIZE,bcbp->b_len );
+       bcbp->b_len = max(ETHERMIN, bcbp->b_len);

        bcbp->b_reserved = 0;
        bcbp->b_reserved = 0;

-       if ( ringput( &addr->enp_toenp,bcbp ) == 1 ) {
-               host_intr++;
-               INTR_ENP( addr );
-       }
+       if (ringput(&addr->enp_toenp, bcbp) == 1)
+               INTR_ENP(addr);

        m_freem(m);
        m_freem(m);

-       return( 0 );
+       return (0);

 }
 
 /*
 }
 
 /*

- * Routine to copy from Multibus memory into mbufs.
+ * Routine to copy from VERSAbus memory into mbufs.

  *
  * Warning: This makes the fairly safe assumption that
  * mbufs have even lengths.
  */
 struct mbuf *
  *
  * Warning: This makes the fairly safe assumption that
  * mbufs have even lengths.
  */
 struct mbuf *

-enpget( bcbp, totlen, off0 )
-register BCB *bcbp;
-int totlen, off0;
+enpget(rxbuf, totlen, off0, ifp)
+       u_char *rxbuf;
+       int totlen, off0;
+       struct ifnet *ifp;

 {
 {

+       register u_char *cp, *mcp;

        register struct mbuf *m;
        register struct mbuf *m;

-       register int off = off0;
-       register unsigned char *cp;
-       long int        v;
-       register short *vp = (short *)&v,
-                       *sp;
-
-       int len;
-       struct mbuf *top = 0;
-       struct mbuf **mp = &top;
-
-#ifdef TAHOE
-       sp = (short *)&bcbp->b_addr;
-       *vp = *sp; vp[1] = sp[1];
-       cp = (unsigned char *)v + SIZEOF_ETHEADER;
-#else
-       cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
-#endif TAHOE
-
-       while( totlen > 0 )
-       {
-               u_char *mcp;
+       struct mbuf *top = 0, **mp = &top;
+       int len, off = off0;

 
 

+       cp = rxbuf + sizeof (struct ether_header);
+       while (totlen > 0) {

                MGET(m, M_DONTWAIT, MT_DATA);
                if (m == 0) 
                        goto bad;
                MGET(m, M_DONTWAIT, MT_DATA);
                if (m == 0) 
                        goto bad;

-               if( off )
-               {
+               if (off) {

                        len = totlen - off;
                        len = totlen - off;

-#ifdef TAHOE
-                       sp = (short *)&bcbp->b_addr;
-                       *vp = *sp; vp[1] = sp[1];
-                       cp = (unsigned char *)v + SIZEOF_ETHEADER
-                               + off;
-#else
-                       cp = (unsigned char *)bcbp->b_addr + 
-                               SIZEOF_ETHEADER + off;
-#endif TAHOE
-               } 
-               else
+                       cp = rxbuf + sizeof (struct ether_header) + off;
+               } else

                        len = totlen;
                        len = totlen;

-
-
-               if (len >= CLBYTES) {
+               if (len >= NBPG) {

                        struct mbuf *p;
 
                        struct mbuf *p;
 

-                       MCLGET(p, 1);
-                       if (p != 0) {
-                               m->m_len = len = CLBYTES;
-                               m->m_off = (int)p - (int)m;
-                       } else  {
+                       MCLGET(m);
+                       if (m->m_len == CLBYTES)
+                               m->m_len = len = MIN(len, CLBYTES);
+                       else

                                m->m_len = len = MIN(MLEN, len);
                                m->m_len = len = MIN(MLEN, len);

-                               m->m_off = MMINOFF;
-                               }
-               } else  { 
+               } else {

                        m->m_len = len = MIN(MLEN, len);
                        m->m_off = MMINOFF;
                }
                        m->m_len = len = MIN(MLEN, len);
                        m->m_off = MMINOFF;
                }

-

                mcp = mtod(m, u_char *);
                mcp = mtod(m, u_char *);

+               if (ifp) {
+                       /*
+                        * Prepend interface pointer to first mbuf.
+                        */
+                       *(mtod(m, struct ifnet **)) = ifp;
+                       mcp += sizeof (ifp);
+                       len -= sizeof (ifp);
+                       ifp = (struct ifnet *)0;
+               }

                enpcopy(cp, mcp, len);
                cp += len;
                *mp = m;
                mp = &m->m_next;
                enpcopy(cp, mcp, len);
                cp += len;
                *mp = m;
                mp = &m->m_next;

-               if (off == 0) 
-               {
+               if (off == 0) {

                        totlen -= len;
                        continue;
                }
                off += len;
                        totlen -= len;
                        continue;
                }
                off += len;

-               if (off == totlen) 
-               {
-#ifdef TAHOE
-                       sp = (short *)&bcbp->b_addr;
-                       *vp = *sp; vp[1] = sp[1];
-                       cp = (unsigned char *)v + SIZEOF_ETHEADER;
-#else
-                       cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
-#endif TAHOE
+               if (off == totlen) {
+                       cp = rxbuf + sizeof (struct ether_header);

                        off = 0;
                        totlen = off0;
                }
                        off = 0;
                        totlen = off0;
                }


@@ -708,269 +522,123 @@ bad:
        return (0);
 }
 
        return (0);
 }
 

+enpcopy(from, to, cnt)
+       register char *from, *to;
+       register cnt;
+{
+       register c;
+       register short *f, *t;
+
+       if (((int)from&01) && ((int)to&01)) {
+               /* source & dest at odd addresses */
+               *to++ = *from++;
+               --cnt;
+       }
+       if (cnt > 1 && (((int)to&01) == 0) && (((int)from&01) == 0)) {
+               t = (short *)to;
+               f = (short *)from;
+               for (c = cnt>>1; c; --c)        /* even address copy */
+                       *t++ = *f++;
+               cnt &= 1;
+               if (cnt) {                      /* odd len */
+                       from = (char *)f;
+                       to = (char *)t;
+                       *to = *from;
+               }
+       }
+       while (cnt-- > 0)       /* one of the address(es) must be odd */
+               *to++ = *from++;
+}
+

 /*
  * Process an ioctl request.
 /*
  * Process an ioctl request.

- *    this can be called via the "socket" route for SIOCSIFADDR or
- *     by the cdev/inode route for SIOCSIFCCFWR/RD
- *

  */
  */

-

 enpioctl(ifp, cmd, data)
 enpioctl(ifp, cmd, data)

-register struct ifnet *ifp;
-int cmd;
-caddr_t data;
+       register struct ifnet *ifp;
+       int cmd;
+       caddr_t data;

 {
 {

-       register int    unit = ifp->if_unit;
-       register struct vba_device *md;
-       int s, error = 0;
-       struct sockaddr_in      *sin;
-       struct sockaddr         *sa;
-       struct enp_softc        *es = &enp_softc[ifp->if_unit];
-       ENPDEVICE               *addr;
-       struct config_entry     *cf;
-       struct ifreq *ifr       = (struct ifreq *)data;
-       struct sockaddr_in      *et_addr;
-       int code, i;
-
-
-       if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
-               return(ENODEV);
+       register struct ifaddr *ifa = (struct ifaddr *)data;
+       struct enpdevice *addr;
+       int s = splimp(), error = 0;

 
        switch (cmd) {
 
        case SIOCSIFADDR:
 
        switch (cmd) {
 
        case SIOCSIFADDR:

-               s = splimp();
-               sa = (struct sockaddr *)&ifr->ifr_addr;
-               if (sa->sa_family == AF_UNSPEC ) {
-                       if (sa->sa_data[0] & 1){ /*broad or multi-cast*/
-                               splx( s );
-                               return( EINVAL );
-                       }
-                       bcopy(sa->sa_data,es->es_enaddr,sizeof(es->es_enaddr));
-                       enpinit( ifp->if_unit);
+               ifp->if_flags |= IFF_UP;
+               switch (ifa->ifa_addr.sa_family) {
+#ifdef INET
+               case AF_INET:
+                       enpinit(ifp->if_unit);
+                       ((struct arpcom *)ifp)->ac_ipaddr =
+                           IA_SIN(ifa)->sin_addr;
+                       arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
+                       break;
+#endif
+#ifdef NS
+               case AF_NS: {
+                       struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
+                       struct enp_softc *es = &enp_softc[ifp->if_unit];
+
+                       if (!ns_nullhost(*ina)) {
+                               ifp->if_flags &= ~IFF_RUNNING;
+                               addr = (struct enpdevice *)
+                                   enpinfo[ifp->if_unit]->ui_addr;
+                               enpsetaddr(ifp->if_unit, addr,
+                                   ina->x_host.c_host);
+                       } else
+                               ina->x_host = *(union ns_host *)es->es_enaddr;
+                       enpinit(ifp->if_unit);

                        break;
                }
                        break;
                }

-               sin = (struct sockaddr_in *)&ifr->ifr_addr;
-               if (sin->sin_family != AF_INET){
-                       splx( s );
-                       return( EINVAL );
-               }
-               if (ifp->if_flags & IFF_RUNNING)
-                       if_rtinit(ifp, -1);     /* delete previous route */
-               enpsetaddr(ifp, sin);
-               enpinit(ifp->if_unit);
-               enpgetaddr( ifp->if_unit );
-               splx(s);
-               break;
-
-
-       case SIOCSETETADDR:     /* Set Ethernet station address */
-               s = splimp();
-               ifp->if_flags &= (~IFF_RUNNING | IFF_UP);
-               et_addr = (struct sockaddr_in *)&ifr->ifr_addr;
-               addr = (ENPDEVICE *)enpinfo[ifp->if_unit]->ui_addr;
-
-               /* Set station address and reset controller board */
-               {
-               u_char  *to = &addr->enp_addr.e_baseaddr.ea_addr[0];
-               char    *from = &et_addr->sin_zero[2];
-               int     i;
-
-               for (i = 0 ; i < ETHADDR_SIZE; i++) 
-                       *to++ = (u_char) (~(*from++ & 0xff));
+#endif
+               default:
+                       enpinit(ifp->if_unit);
+                       break;

                }
                }

-               enpcopy(&addr->enp_addr.e_listsize, &code, sizeof(code)); 
-               code |= E_ADDR_SUPP;
-               enpcopy(&code, &addr->enp_addr.e_listsize, sizeof(code)); 
-               enpreset(ifp->if_unit);         /* Re-initialize */
-               enpgetaddr(ifp->if_unit);
-               splx(s);

                break;
 
                break;
 

-       case SIOCGETETADDR:     /* Get Foreign Hosts' Ethernet addresses */
-               arpwhohas(&es->es_ac, (struct in_addr *)ifr->ifr_data);
+       case SIOCSIFFLAGS:
+               if ((ifp->if_flags&IFF_UP) == 0 && ifp->if_flags&IFF_RUNNING) {
+                       enpinit(ifp->if_unit);          /* reset board */
+                       ifp->if_flags &= ~IFF_RUNNING;
+               } else if (ifp->if_flags&IFF_UP &&
+                    (ifp->if_flags&IFF_RUNNING) == 0)
+                       enpinit(ifp->if_unit);

                break;
 
        default:
                error = EINVAL;
        }
                break;
 
        default:
                error = EINVAL;
        }

-       return(error);
-}
-
-enpsetaddr(ifp, sin)
-register struct ifnet *ifp;
-register struct sockaddr_in *sin;
-{
-
-       ifp->if_addr = *(struct sockaddr *)sin;
-       ifp->if_net = in_netof(sin->sin_addr);
-       ifp->if_host[0] = in_lnaof(sin->sin_addr);
-       sin = (struct sockaddr_in *)&ifp->if_broadaddr;
-       sin->sin_family = AF_INET;
-       sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY);
-       ifp->if_flags |= IFF_BROADCAST;
-}
-
-
-/*
- * Get the ethernet addr, store it and print it
- * Read the ethernet address off the board, one byte at a time.
- *     put it in enp_softc
- */
-
-
-enpgetaddr( unit )
-int unit;
-{
-       register struct enp_softc       *es = &enp_softc[unit];
-       register ENPDEVICE *addr =(ENPDEVICE *)enpinfo[unit]->ui_addr;
-       int i;
-       
-#ifdef TAHOE
-       enpcopy(&addr->enp_addr.e_baseaddr, &es->es_boardaddr, sizeof(es->es_boardaddr));
-#else
-       es->es_boardaddr = addr->enp_addr.e_baseaddr;
-#endif TAHOE
-       bcopy(&es->es_boardaddr, es->es_enaddr, ETHADDR_SIZE);
-       return( 1 );
-}
-
-/*
- * enpram device
- *
- */
-
-enpr_open( dev )
-{
-       register int    unit = minor(dev);
-       register struct vba_device *md;
-       register ENPDEVICE      *addr;
-
-       if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
-           (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
-               return(ENODEV);
-       if (addr->enp_state != S_ENPRESET)
-               return(EACCES);  /* enp is not in reset state, don't open  */
-       if ( !enpismapped[unit] ) {
-               ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
-               ++enpismapped[unit];
-       }
-       enpram[unit] = ENP_OPEN;
-       return( 0 );
-}
-
-enpr_close(dev)
-{
-       enpram[minor(dev)] = ENP_CLOSE;
-       return( 0 );
-}
-
-enpr_read( dev,uio )
-int dev;
-register struct uio *uio;
-{
-       register ENPDEVICE *addr;
-       register struct iovec *iov;
-       register r=0;
-
-       if (enpram[minor(dev)] != ENP_OPEN)
-               return(EACCES);
-       if ( uio->uio_offset > RAM_SIZE )
-               return( ENODEV );
-       if ( uio->uio_offset + iov->iov_len > RAM_SIZE )
-               iov->iov_len = RAM_SIZE - uio->uio_offset;
-       addr = (ENPDEVICE *)enpinfo[ minor( dev ) ]->ui_addr;
-       iov  = uio->uio_iov;
-
-       if( r = enpcopyout( &addr->enp_ram[ uio->uio_offset ], iov->iov_base,
-                        iov->iov_len ) )
-                return( r );
-
-       uio->uio_resid -= iov->iov_len;
-       iov->iov_len = 0;
-
-       return( 0 );
-}
-
-enpr_write( dev,uio )
-int dev;
-register struct uio *uio;
-{
-       register ENPDEVICE *addr;
-       register struct iovec *iov;
-       register r=0;
-
-       if (enpram[minor(dev)] != ENP_OPEN)
-               return(EACCES);
-       addr = (ENPDEVICE *)enpinfo[ minor( dev ) ]->ui_addr;
-       iov  = uio->uio_iov;
-
-       if ( uio->uio_offset > RAM_SIZE )
-               return( ENODEV );
-       if ( uio->uio_offset + iov->iov_len > RAM_SIZE )
-               iov->iov_len = RAM_SIZE - uio->uio_offset;
-       if( r = enpcopyin( iov->iov_base, &addr->enp_ram[ uio->uio_offset ],
-                       iov->iov_len ) )
-               return( r );
-
-       uio->uio_resid -= iov->iov_len;
-       iov->iov_len = 0;
-
-       return( 0 );
+       splx(s);
+       return (error);

 }
 
 }
 

-enpr_ioctl( dev,cmd,arg,fflag )
-dev_t dev;
-caddr_t *arg;
+enpsetaddr(unit, addr, enaddr)
+       int unit;
+       struct enpdevice *addr;
+       u_char *enaddr;

 {
 {

-       register ENPDEVICE *addr;
-       long int        v;
-       register short  *vp = (short *)&v, *sp;
-       register unit = minor(dev);
-       register struct vba_device *md;
-
-       if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
-           (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
-               return(ENODEV);
-       switch( cmd )
-       {
-               case ENPIOGO:
-/* not needed if prom based version */
-#ifdef TAHOE
-                       sp = (short *)&addr->enp_base;
-                       v = (int)addr;
-                       *sp = *vp; sp[1] = vp[1];
-#else
-                       addr->enp_base = (int)addr;
-#endif TAHOE
-                       addr->enp_intrvec = intvec[ unit ];
-                       ENP_GO( addr, ENPSTART );
-                       DELAY( 200000 );
-                       enpattach( enpinfo[ unit ] );
-                       enpinit( unit );
-                       addr->enp_state = S_ENPRUN;  /* it is running now */
-/* end of not needed */
-
-                       break;
-
-               case ENPIORESET:
-                       RESET_ENP( addr );
-                       addr->enp_state = S_ENPRESET;  /* it is reset now */
-                       DELAY( 100000 );
-                       break;
-       }
-       return( 0 );
+       u_char *cp;
+       int i, code;
+
+       cp = &addr->enp_addr.e_baseaddr.ea_addr[0];
+       for (i = 0; i < 6; i++)
+               *cp++ = ~*enaddr++;
+       enpcopy(&addr->enp_addr.e_listsize, &code, sizeof (code)); 
+       code |= E_ADDR_SUPP;
+       enpcopy(&code, &addr->enp_addr.e_listsize, sizeof (code)); 
+       enpinit(unit);

 }
 
 /* 
 }
 
 /* 

- * routines to synchronize enp and host 
+ * Routines to synchronize enp and host.

  */
  */

-

 static
 static

-ringinit( rp,size )
-register RING *rp;
+ringinit(rp, size)
+       register RING *rp;

 {
 {

-       register int    i;
+       register int i;

        register short *sp; 
 
        rp->r_rdidx = rp->r_wrtidx = 0;
        register short *sp; 
 
        rp->r_rdidx = rp->r_wrtidx = 0;


@@ -978,180 +646,160 @@ register RING *rp;
 }
 
 static
 }
 
 static

-ringempty( rp )
-register RING *rp;
+ringempty(rp)
+       register RING *rp;

 {
 {

-       return( rp->r_rdidx == rp->r_wrtidx );
+
+       return (rp->r_rdidx == rp->r_wrtidx);

 }
 
 static
 }
 
 static

-ringfull( rp )
-register RING *rp;
+ringfull(rp)
+       register RING *rp;

 {
        register short idx;
 
        idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
 {
        register short idx;
 
        idx = (rp->r_wrtidx + 1) & (rp->r_size-1);

-       return( idx == rp->r_rdidx );
+       return (idx == rp->r_rdidx);

 }
 
 static
 }
 
 static

-ringput( rp,v )
-register RING *rp;
+ringput(rp, v)
+       register RING *rp;

 {
        register int idx;
 {
        register int idx;

-       register short *vp = (short *)&v,
-                      *sp;

 
        idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
 
        idx = (rp->r_wrtidx + 1) & (rp->r_size-1);

-       if( idx != rp->r_rdidx )
-       {
-#ifdef TAHOE
-               sp = (short *)&rp->r_slot[ rp->r_wrtidx ];
-               *sp = *vp; sp[1] = vp[1];
-#else
-               rp->r_slot[ rp->r_wrtidx ] = v;
-#endif TAHOE
+       if (idx != rp->r_rdidx) {
+               rp->r_slot[rp->r_wrtidx] = v;

                rp->r_wrtidx = idx;
                rp->r_wrtidx = idx;

-               if( (idx -= rp->r_rdidx) < 0 )
+               if ((idx -= rp->r_rdidx) < 0)

                        idx += rp->r_size;
                        idx += rp->r_size;

-               return( idx );                  /* num ring entries */
+               return (idx);                   /* num ring entries */

        }
        }

-       return( 0 );
+       return (0);

 }
 
 static
 }
 
 static

-ringget( rp )
-register RING *rp;
+ringget(rp)
+       register RING *rp;

 {
        register int i = 0;
 {
        register int i = 0;

-       long int v;
-       register short *vp = (short *)&v,
-                      *sp;
-
-       if( rp->r_rdidx != rp->r_wrtidx )
-       {
-#ifdef TAHOE
-               sp = (short *)&rp->r_slot[ rp->r_rdidx ];
-               *vp = *sp; vp[1] = sp[1];
-               i = v;
-#else
-               i = rp->r_slot[ rp->r_rdidx ];
-#endif TAHOE
+
+       if (rp->r_rdidx != rp->r_wrtidx) {
+               i = rp->r_slot[rp->r_rdidx];

                rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
        }
                rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
        }

-       return( i );
+       return (i);

 }
 
 }
 

-#ifdef notdef
-struct mbuf *
-m_tofree( rp )
-register RING *rp;
-{
-       long int v = 0;
-       register short *vp = (short *)&v,
-                      *sp;
-
-       if( rp->r_rdidx != rp->r_wrtidx )
-       {
-#ifdef TAHOE
-               sp = (short *)&rp->r_slot[ rp->r_rdidx ];
-               *vp = *sp; vp[1] = sp[1];
-               /* *sp = 0xffff; sp[1] = 0xffff; */
-#else
-               v = rp->r_slot[ rp->r_rdidx ];
-#endif TAHOE
-               rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
-       }
-       return( (struct mbuf *)v );
-}
-#endif

 static
 static

-fir( rp )
-register RING *rp;
+fir(rp)
+       register RING *rp;

 {
 {

-       long int v;
-       register short *vp = (short *)&v,
-                      *sp;
-
-       if( rp->r_rdidx != rp->r_wrtidx )
-#ifdef TAHOE
-       {
-               sp = (short *)&rp->r_slot[ rp->r_rdidx ];
-               *vp = *sp; vp[1] = sp[1];
-               return( v );
-       }
-#else
-               return( rp->r_slot[ rp->r_rdidx ] );
-#endif TAHOE
-       else   
-               return( 0 );
-}

 
 

+       return (rp->r_rdidx != rp->r_wrtidx ? rp->r_slot[rp->r_rdidx] : 0);
+}

 
 

-static
-prtbytes( addr )
-register char *addr;
+/*
+ * ENP Ram device.
+ */
+enpr_open(dev)
+       dev_t dev;

 {
 {

-       register int i;
+       register int unit = ENPUNIT(dev);
+       struct vba_device *ui;
+       struct enpdevice *addr;

 
 

-       for( i = 0; i < 12; i++ )
-       {
-               printf("%X ",*addr&0377);
-               addr++;
-       }
-       printf("\n");
+       if (unit >= NENP || (ui = enpinfo[unit]) == 0 || ui->ui_alive == 0 ||
+           (addr = (struct enpdevice *)ui->ui_addr) == 0)
+               return (ENODEV);
+       if (addr->enp_state != S_ENPRESET)
+               return (EACCES);  /* enp is not in reset state, don't open  */
+       return (0);

 }
 
 }
 

-static
-enpcopy(from, to, cnt)
-register char *from, *to;
-register cnt;
+enpr_close(dev)
+       dev_t dev;

 {
 {

-       register c;
-       register short *f, *t;
-
-       if (((int)from & 01) && ((int)to & 01)) {
-                                       /* source & dest at odd addresses */
-               *to++ = *from++;
-               --cnt;
-       }
-       if (cnt > 1 && (((int)to & 01)==0) && (((int)from & 01)==0)) {
-               t = (short *) to;
-               f = (short *) from;
-               for( c = cnt>>1; c; --c)        /* even address copy */
-                       *t++ = *f++;
-               cnt &= 1;
-               if ( cnt ) {                    /* odd len */
-                       from = (char *) f;
-                       to   = (char *) t;
-                       *to = *from;
-               }
-       }
-       while (cnt-- > 0)       /* one of the address(es) must be odd */
-               *to++ = *from++;

 
 

+       return (0);

 }
 
 }
 

-static
-enpcopyin(userv, kernv, cnt)
+enpr_read(dev, uio)
+       dev_t dev;
+       register struct uio *uio;

 {
 {

+       register struct iovec *iov;
+       struct enpdevice *addr;
+       int error;

 
 

-       if (useracc(userv, cnt, 1)) {
-               enpcopy( userv, kernv, cnt );
-               return( 0 );
-       }
-       else    return( EFAULT );
+       if (uio->uio_offset > RAM_SIZE)
+               return (ENODEV);
+       if (uio->uio_offset + iov->iov_len > RAM_SIZE)
+               iov->iov_len = RAM_SIZE - uio->uio_offset;
+       addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
+       iov = uio->uio_iov;
+       error = useracc(iov->iov_base, iov->iov_len, 0);
+       if (error)
+               return (error);
+       enpcopy(&addr->enp_ram[uio->uio_offset], iov->iov_base, iov->iov_len);
+       uio->uio_resid -= iov->iov_len;
+       iov->iov_len = 0;
+       return (0);

 }
 
 }
 

+enpr_write(dev, uio)
+       dev_t dev;
+       register struct uio *uio;
+{
+       register struct enpdevice *addr;
+       register struct iovec *iov;
+       register error;

 
 

-static
-enpcopyout(kernv, userv, cnt)
+       addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
+       iov = uio->uio_iov;
+       if (uio->uio_offset > RAM_SIZE)
+               return (ENODEV);
+       if (uio->uio_offset + iov->iov_len > RAM_SIZE)
+               iov->iov_len = RAM_SIZE - uio->uio_offset;
+       error =  useracc(iov->iov_base, iov->iov_len, 1);
+       if (error)
+               return (error);
+       enpcopy(iov->iov_base, &addr->enp_ram[uio->uio_offset], iov->iov_len);
+       uio->uio_resid -= iov->iov_len;
+       iov->iov_len = 0;
+       return (0);
+}
+
+enpr_ioctl(dev, cmd, data)
+       dev_t dev;
+       caddr_t data;

 {
 {

+       register struct enpdevice *addr;
+       register unit = ENPUNIT(dev);
+       register struct vba_device *ui;

 
 

-       if (useracc(userv, cnt, 0)) {
-               enpcopy( kernv, userv, cnt );
-               return( 0 );
+       addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
+       switch(cmd) {
+
+       case ENPIOGO:
+/* not needed if prom based version */
+               addr->enp_base = (int)addr;
+               addr->enp_intrvec = enp_softc[unit].es_ivec;
+               ENP_GO(addr, ENPSTART);
+               DELAY(200000);
+               enpinit(unit);
+               addr->enp_state = S_ENPRUN;  /* it is running now */
+/* end of not needed */
+               break;
+
+       case ENPIORESET:
+               RESET_ENP(addr);
+               addr->enp_state = S_ENPRESET;  /* it is reset now */
+               DELAY(100000);
+               break;

        }
        }

-       else    return( EFAULT );
+       return (0);

 }
 #endif
 }
 #endif

diff --git a/usr/src/sys/tahoe/if/if_enpreg.h b/usr/src/sys/tahoe/if/if_enpreg.h
index 596dd4b..f8234e2 100644 (file)
--- a/usr/src/sys/tahoe/if/if_enpreg.h
+++ b/usr/src/sys/tahoe/if/if_enpreg.h
@@ -1,4 +1,4 @@
-/*     if_enpreg.h     1.1     86/07/20        */
+/*     if_enpreg.h     1.2     86/11/29        */

 
 /*     Copyright (c) 1984 by Communication Machinery Corporation
  *
 
 /*     Copyright (c) 1984 by Communication Machinery Corporation
  *


@@ -14,135 +14,45 @@
  *     ENP-10 update 7/21/85 J. Mullen
  *     ENP-20 update 8/11/85 J. Mullen
  *     Mods for CCI TAHOE system 8/14/85 J. Mullen
  *     ENP-10 update 7/21/85 J. Mullen
  *     ENP-20 update 8/11/85 J. Mullen
  *     Mods for CCI TAHOE system 8/14/85 J. Mullen

- * 

  */
 
 #define K              *1024
 
  */
 
 #define K              *1024
 

-#define ENPSIZE                (124 K)         /* VME bus space allocated to enp */
-#define MINPKTSIZE     60              /* minimum ethernet packet size */
-
-/* Note: paged window (4 K) is identity mapped by ENP kernel to provide
- * 124 K contiguous RAM (as reflected in RAM_SIZE)
- */
-
-#define RAM_WINDOW     (128 K)
-#define IOACCESS_WINDOW (512)
-#define FIXED_WINDOW   (RAM_WINDOW - IOACCESS_WINDOW)
-#define RAMROM_SWAP    (4 K)
-#define RAM_SIZE       (FIXED_WINDOW - RAMROM_SWAP)
-
-#define HOST_RAMSIZE   (48 K)
-#define ENP_RAMSIZE    (20 K)
-
-/* ...top of 4K local i/o space for ENP */
-
-#ifdef notdef
-typedef struct iow10 {
-       char    pad1[0x81];
-/* written to: causes an interrupt on the host at the vector written
-   read from : returns the most significant 8 bits of the slave address */
-       char    vector;
-       char    pad2[0x1F];
-       char    csrarr[0x1E];
-       char    pad3[2];
-       char    ier;            /* intr. enable reg., 0x80 == enable,0 == off*/
-       char    pad4[1];
-       char    tir;            /* transmit intr. (Level 4 INP autovector) */
-       char    pad5[1];
-       char    rir;            /* receive intr. (Level 5 INP autovector) */
-       char    pad6[1];
-       char    uir;            /* utility intr. (Level 1 INP autovector) */
-       char    pad7[7];
-       char    mapfirst4k;     /* bit 7 set means ram, clear means rom */
-       char    pad8[0x11];
-       char    exr;            /* exception register, see bit defines above */
-       char    pad9[0xD1F];
-       char    hst2enp_interrupt;      /* R or W interrupts ENP */
-       char    pad10[0xFF];
-       char    hst2enp_reset;  /* R or W resets ENP */
-} iow10;
-#endif notdef
-
-typedef struct iow20
-{
-       char    pad0;   
-       char    hst2enp_interrupt;
-       char    pad1[510];
-} iow20;
-
-
-#ifdef notdef
-typedef struct iow30 
-{
-       char    pad0;
-       char    impucsr;
-       char    pad1[0x1d];
-       short   bus2mpu_interrupt;
-       short   bs2enp_wsctl;
-       short   bs2enp_rsctl;
-       short   enp2hst_clear_intr;  /* 0x27 */
-       short   enp_rcv_intr;
-       short   enp_xmit_intr;
-       short   hst2enp_interrupt;   /* 0x2d */
-       short   pad2;
-       char    pad3[0xf];
-       short   bus_page;       /* Bus page register */ 
-       char    pad4[0x1d];
-       short   lock_ctrl;
-       char    pad5[0x1d];
-       short   duart[0x10];    /* 16 duart regs */
-       char    pad6[0x1f];
-       short   bus_window;
-} iow30; 
-#endif notdef
-
-struct ether_addr
-{
+struct ether_addr {

        u_char ea_addr[6];
 };
 
        u_char ea_addr[6];
 };
 

-#define ETHADDR                struct ether_addr
-#define ETHADDR_SIZE   6               /* size of ethernet address     */
-
-typedef
-struct ethlist
-{
+typedef struct ethlist {

        int     e_listsize;             /* active addr entries */
        int     e_listsize;             /* active addr entries */

-       ETHADDR e_baseaddr;             /* addr lance is working with */
-       ETHADDR e_addrs[ 16 ];          /* possible addresses */
+       struct  ether_addr e_baseaddr;  /* addr lance is working with */
+       struct  ether_addr e_addrs[16]; /* possible addresses */

 } ETHLIST;
 
 } ETHLIST;
 

-typedef
-struct enpstat
-{
-       unsigned long e_xmit_successful;        /* Successful transmissions */
-       unsigned long e_mult_retry;             /* multiple retries on xmit */
-       unsigned long e_one_retry;              /* single retries */
-       unsigned long e_fail_retry;             /* too many retries */
-       unsigned long e_deferrals;              /* transmission delayed due
-                                                  to active medium */
-       unsigned long e_xmit_buff_err;          /* xmit data chaining failed --
+typedef struct {
+       u_long  e_xmit_successful;      /* Successful transmissions */
+       u_long  e_mult_retry;           /* multiple retries on xmit */
+       u_long  e_one_retry;            /* single retries */
+       u_long  e_fail_retry;           /* too many retries */
+       u_long  e_deferrals;            /* xmit delayed 'cuz cable busy */
+       u_long  e_xmit_buff_err;        /* xmit data chaining failed --

                                                   "can't happen" */
                                                   "can't happen" */

-       unsigned long e_silo_underrun;          /* transmit data fetch failed */
-       unsigned long e_late_coll;              /* collision after xmit */
-       unsigned long e_lost_carrier;
-       unsigned long e_babble;                 /* xmit length > 1518 */
-       unsigned long e_collision;
-       unsigned long e_xmit_mem_err;
-       unsigned long e_rcv_successful;         /* good receptions */
-       unsigned long e_rcv_missed;             /* no recv buff available */
-       unsigned long e_crc_err;                /* checksum failed */
-       unsigned long e_frame_err;              /* crc error AND
-                                                  data length != 0 mod 8 */
-       unsigned long e_rcv_buff_err;           /* rcv data chain failure --
+       u_long  e_silo_underrun;        /* transmit data fetch failed */
+       u_long  e_late_coll;            /* collision after xmit */
+       u_long  e_lost_carrier;
+       u_long  e_babble;               /* xmit length > 1518 */
+       u_long  e_collision;
+       u_long  e_xmit_mem_err;
+       u_long  e_rcv_successful;       /* good receptions */
+       u_long  e_rcv_missed;           /* no recv buff available */
+       u_long  e_crc_err;              /* checksum failed */
+       u_long  e_frame_err;            /* crc error & data length != 0 mod 8 */
+       u_long  e_rcv_buff_err;         /* rcv data chain failure --

                                                   "can't happen" */
                                                   "can't happen" */

-       unsigned long e_silo_overrun;           /* receive data store failed */
-       unsigned long e_rcv_mem_err;
+       u_long  e_silo_overrun;         /* receive data store failed */
+       u_long  e_rcv_mem_err;

 } ENPSTAT;
 
 } ENPSTAT;
 

-typedef struct RING
-{
+typedef struct RING {

        short   r_rdidx;
        short   r_wrtidx;
        short   r_size;
        short   r_rdidx;
        short   r_wrtidx;
        short   r_size;


@@ -150,58 +60,70 @@ typedef struct RING
        int     r_slot[1];
 } RING;
 
        int     r_slot[1];
 } RING;
 

-typedef struct RING32
-{
+typedef struct RING32 {

        short   r_rdidx;
        short   r_wrtidx;
        short   r_size;
        short   r_pad;                  /* to make VAXen happy */
        short   r_rdidx;
        short   r_wrtidx;
        short   r_size;
        short   r_pad;                  /* to make VAXen happy */

-       int     r_slot[ 32 ];
+       int     r_slot[32];

 } RING32;
 
 /*
 } RING32;
 
 /*

- *     ENP Ram data layout
- *
- *     If you don't put it here - it isn't there
- *
+ * ENP Ram data layout

  */
 
  */
 

-typedef struct enpdevice {
+/*
+ * Note: paged window (4 K) is identity mapped by ENP kernel to provide
+ * 124 K contiguous RAM (as reflected in RAM_SIZE)
+ */
+#define RAM_WINDOW     (128 K)
+#define IOACCESS_WINDOW (512)
+#define FIXED_WINDOW   (RAM_WINDOW - IOACCESS_WINDOW)
+#define RAMROM_SWAP    (4 K)
+#define RAM_SIZE       (FIXED_WINDOW - RAMROM_SWAP)
+
+#define HOST_RAMSIZE   (48 K)
+#define ENP_RAMSIZE    (20 K)
+
+typedef        struct iow20 {
+       char    pad0;   
+       char    hst2enp_interrupt;
+       char    pad1[510];
+} iow20;
+
+struct enpdevice {

 #ifdef notdef
        char    enp_ram_rom[4 K];
 #endif notdef
        union {
                char    all_ram[RAM_SIZE];
                struct {
 #ifdef notdef
        char    enp_ram_rom[4 K];
 #endif notdef
        union {
                char    all_ram[RAM_SIZE];
                struct {

-                       unsigned int    t_go;
-                       unsigned int    t_pstart;
+                       u_int   t_go;
+                       u_int   t_pstart;

                } t;
                struct {
                        char    nram[RAM_SIZE - (HOST_RAMSIZE + ENP_RAMSIZE)];
                        char    hram[HOST_RAMSIZE];
                        char    kram[ENP_RAMSIZE];
                } u_ram;
                } t;
                struct {
                        char    nram[RAM_SIZE - (HOST_RAMSIZE + ENP_RAMSIZE)];
                        char    hram[HOST_RAMSIZE];
                        char    kram[ENP_RAMSIZE];
                } u_ram;

-               struct
-               {
-                       char    pad7[ 0x100 ];  /* starts 0x1100 - 0x2000 */
+               struct {
+                       char    pad7[0x100];    /* starts 0x1100 - 0x2000 */

                        short   e_enpstate;     /* 1102 */
                        short   e_enpmode;      /* 1104 */
                        int     e_enpbase;      /* 1104 */
                        int     e_enprun;       /* 1108 */
                        short   e_enpstate;     /* 1102 */
                        short   e_enpmode;      /* 1104 */
                        int     e_enpbase;      /* 1104 */
                        int     e_enprun;       /* 1108 */

-                       unsigned short  e_intrvec;
-                       unsigned short  e_dummy[3];
-
+                       u_short e_intrvec;
+                       u_short e_dummy[3];

                        RING32  h_toenp;        /* 110C */
                        RING32  h_hostfree;             
                        RING32  e_tohost;               
                        RING32  e_enpfree;              
                        RING32  h_toenp;        /* 110C */
                        RING32  h_hostfree;             
                        RING32  e_tohost;               
                        RING32  e_enpfree;              

-

                        ENPSTAT e_stat;
                        ETHLIST e_netaddr;              
                } iface;
        } enp_u;
        iow20   enp_iow;
                        ENPSTAT e_stat;
                        ETHLIST e_netaddr;              
                } iface;
        } enp_u;
        iow20   enp_iow;

-} ENPDEVICE;
+};

 
 #define        enp_ram         enp_u.all_ram
 #define        enp_nram        enp_u.u_ram.nram
 
 #define        enp_ram         enp_u.all_ram
 #define        enp_nram        enp_u.u_ram.nram


@@ -222,91 +144,72 @@ typedef struct enpdevice {
 #define enp_stat       enp_u.iface.e_stat
 #define enp_addr       enp_u.iface.e_netaddr
 
 #define enp_stat       enp_u.iface.e_stat
 #define enp_addr       enp_u.iface.e_netaddr
 

-#define ENPVAL         0xff    /* value to poke in enp_iow.hst2enp_interrupt */
-#define RESETVAL       0x00    /* value to poke in enp_iow.enp2hst_clear_intr */
+#define ENPVAL         0xff    /* enp_iow.hst2enp_interrupt poke value */
+#define RESETVAL       0x00    /* enp_iow.enp2hst_clear_intr poke value */

 
 

-#define INTR_ENP(addr)         addr->enp_iow.hst2enp_interrupt = ENPVAL
+#define INTR_ENP(addr)         (addr->enp_iow.hst2enp_interrupt = ENPVAL)

 
 #if ENP == 30
 
 #if ENP == 30

-#define ACK_ENP_INTR(addr)     addr->enp_iow.enp2hst_clear_intr = RESETVAL
+#define ACK_ENP_INTR(addr)     (addr->enp_iow.enp2hst_clear_intr = RESETVAL)

 #define IS_ENP_INTR(addr)      (addr->enp_iow.enp2hst_clear_intr&0x80)
 #define IS_ENP_INTR(addr)      (addr->enp_iow.enp2hst_clear_intr&0x80)

-# else
+#else

 #define ACK_ENP_INTR(addr)
 #define ACK_ENP_INTR(addr)

-#define IS_ENP_INTR(addr)      ( 1 )
+#define IS_ENP_INTR(addr)      (1)

 #endif ENP == 30
 
 #ifdef notdef
 #endif ENP == 30
 
 #ifdef notdef

-#define RESET_ENP(addr)                addr->enp_iow.hst2enp_reset = 01
-# else
+#define RESET_ENP(addr)                (addr->enp_iow.hst2enp_reset = 01)
+#else

 #define RESET_ENP(addr)
 #endif notdef
 
 #ifdef TAHOE
 #define RESET_ENP(addr)
 #endif notdef
 
 #ifdef TAHOE

-#define ENP_GO( addr,start )   {int v; v = start; \
-                       enpcopy(&v, &addr->enp_prog_start, sizeof(v) ); \
-                       v = 0x80800000; \
-                       enpcopy( &v, &addr->enp_go, sizeof(v) ); }
+#define ENP_GO(addr,start) { \
+       int v = start; \
+       enpcopy(&v, &addr->enp_prog_start, sizeof(v) ); \
+       v = 0x80800000; \
+       enpcopy( &v, &addr->enp_go, sizeof(v) ); \
+}

 #else
 #else

-#define ENP_GO( addr,start,intvec ) { addr->enp_prog_start = (unsigned int)(start); \
-                               addr->enp_intrvec = (unsigned short) intvec; \
-                               addr->enp_go = 0x80800000; }
+#define ENP_GO(addr,start,intvec ) { \
+       addr->enp_prog_start = (u_int)(start); \
+       addr->enp_intrvec = (u_short) intvec; \
+       addr->enp_go = 0x80800000; \
+}

 #endif TAHOE
 
 #endif TAHOE
 

-#define SPL_ENP                        spl4
-
-

 /*
 /*

- * state bits
+ * State bits

  */
  */

-

 #define S_ENPRESET     01              /* enp is in reset state */
 #define S_ENPRUN       02              /* enp is in run state */
 
 /*
 #define S_ENPRESET     01              /* enp is in reset state */
 #define S_ENPRUN       02              /* enp is in run state */
 
 /*

- * mode bits
+ * Mode bits

  */
  */

+#define E_SWAP16       0x1             /* swap two octets within 16 */
+#define E_SWAP32       0x2             /* swap 16s within 32 */
+#define E_SWAPRD       0x4             /* swap on read */
+#define E_SWAPWRT      0x8             /* swap on write */
+#define E_DMA          0x10            /* enp does data moving */

 
 

-#define E_SWAP16               0x1             /* swap two octets within 16 */
-#define E_SWAP32               0x2             /* swap 16s within 32 */
-#define E_SWAPRD               0x4             /* swap on read */
-#define E_SWAPWRT              0x8             /* swap on write */
-#define E_DMA                  0x10            /* enp does data moving */
-
-#define E_EXAM_LIST            0x80000000      /*enp should examine addrlist */
-#define E_ADDR_SUPP            0x40000000      /*enp should use supplied addr*/
-
+#define E_EXAM_LIST    0x80000000      /* enp should examine addrlist */
+#define E_ADDR_SUPP    0x40000000      /* enp should use supplied addr */

 
 /*
 
 /*

- *     Download ioctl definitions
+ * Download ioctl definitions

  */
  */

-
-#define mkioctl(type,value) (0x20000000|('type'<<8)|value)
-
-#define ENPIOGO                mkioctl( S,1 )          /* start the enp */
-#define ENPIORESET     mkioctl( S,2 )          /* reset the enp */
+#define ENPIOGO                _IO(S,1)                /* start the enp */
+#define ENPIORESET     _IO(S,2)                /* reset the enp */

 
 /*
 
 /*

- *     The ENP Data Buffer Structure
+ * The ENP Data Buffer Structure

  */
  */

-
-typedef struct BCB
-{
-       struct BCB *b_link;
+typedef struct BCB {
+       struct  BCB *b_link;

        short    b_stat;
        short    b_len;
        char    *b_addr;
        short    b_msglen;
        short    b_reserved;
        short    b_stat;
        short    b_len;
        char    *b_addr;
        short    b_msglen;
        short    b_reserved;

-}BCB;
-
-struct  enp_softc 
-{
-       struct  arpcom es_ac;           /* common ethernet structures */
-       struct  ether_addr es_boardaddr;/* board ethernet address */
-}; 
-
-#define es_if           es_ac.ac_if     /* network-visible interface */
-#define es_enaddr       es_ac.ac_enaddr /* hardware ethernet address */
-
-#define        ENP_OPEN        1               /* device enpram opened */
-#define ENP_CLOSE      2               /* device enpram closed */
+} BCB;