1st working version

SCCS-vsn: sys/i386/isa/if_we.c 5.2

diff --git a/usr/src/sys/i386/isa/if_we.c b/usr/src/sys/i386/isa/if_we.c
index 2214b07..94a314f 100644 (file)
--- a/usr/src/sys/i386/isa/if_we.c
+++ b/usr/src/sys/i386/isa/if_we.c
@@ -7,17 +7,17 @@
  *
  * %sccs.include.noredist.c%
  *
  *
  * %sccs.include.noredist.c%
  *

- *     @(#)if_we.c     5.1 (Berkeley) %G%
+ *     @(#)if_we.c     5.2 (Berkeley) %G%

  */
 
 /*
  * Modification history
  *
  */
 
 /*
  * Modification history
  *

- * 8/28/89 - Initial version, Tim L Tucker
+ * 8/28/89 - Initial version(if_wd.c), Tim L Tucker

  */
  
  */
  

-#include "wd.h"
-#if    NWD > 0
+#include "we.h"
+#if    NWE > 0

 /*
  * Western Digital 8003 ethernet/starlan adapter
  *
 /*
  * Western Digital 8003 ethernet/starlan adapter
  *


@@ -50,11 +50,11 @@
 #include "../netns/ns_if.h"
 #endif
 
 #include "../netns/ns_if.h"
 #endif
 

-#include "if_wdreg.h"
-#include "../isa/isavar.h"
+#include "machine/isa/if_wereg.h"
+#include "machine/isa/device.h"

  
 /*
  
 /*

- * This constant should really be 60 because the wd adds 4 bytes of crc.
+ * This constant should really be 60 because the we adds 4 bytes of crc.

  * However when set to 60 our packets are ignored by deuna's , 3coms are
  * okay ??????????????????????????????????????????
  */
  * However when set to 60 our packets are ignored by deuna's , 3coms are
  * okay ??????????????????????????????????????????
  */


@@ -69,38 +69,41 @@
  * qe_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */
  * qe_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */

-struct wd_softc {
-       struct  arpcom wd_ac;           /* Ethernet common part         */
-#define        wd_if   wd_ac.ac_if             /* network-visible interface    */
-#define        wd_addr wd_ac.ac_enaddr         /* hardware Ethernet address    */
+struct we_softc {
+       struct  arpcom we_ac;           /* Ethernet common part         */
+#define        we_if   we_ac.ac_if             /* network-visible interface    */
+#define        we_addr we_ac.ac_enaddr         /* hardware Ethernet address    */

 
 

-       u_char  wd_flags;               /* software state               */
+       u_char  we_flags;               /* software state               */

 #define        WDF_RUNNING     0x01
 #define WDF_TXBUSY     0x02
 
 #define        WDF_RUNNING     0x01
 #define WDF_TXBUSY     0x02
 

-       u_char  wd_type;                /* interface type code          */
-       u_short wd_vector;              /* interrupt vector             */
-       caddr_t wd_io_ctl_addr;         /* i/o bus address, control     */
-       caddr_t wd_io_nic_addr;         /* i/o bus address, NS32490     */
+       u_char  we_type;                /* interface type code          */
+       u_short we_vector;              /* interrupt vector             */
+       caddr_t we_io_ctl_addr;         /* i/o bus address, control     */
+       caddr_t we_io_nic_addr;         /* i/o bus address, NS32490     */

 
 

-       caddr_t wd_vmem_addr;           /* card RAM virtual memory base */
-       u_long  wd_vmem_size;           /* card RAM bytes               */
-       caddr_t wd_vmem_ring;           /* receive ring RAM vaddress    */
-} wd_softc[NWD];
+       caddr_t we_vmem_addr;           /* card RAM virtual memory base */
+       u_long  we_vmem_size;           /* card RAM bytes               */
+       caddr_t we_vmem_ring;           /* receive ring RAM vaddress    */
+} we_softc[NWE];

 
 

-int    wdprobe(), wdattach(), wdintr();
-int    wdinit(), wdoutput(), wdioctl(), wdreset();
+int    weprobe(), weattach(), weintr();
+int    weinit(), weoutput(), weioctl(), wereset();
+
+struct isa_driver wedriver = {
+       weprobe, weattach, "we",
+};

  
 /*
  * Probe the WD8003 to see if it's there
  */
  
 /*
  * Probe the WD8003 to see if it's there
  */

-wdprobe(reg, is)
-       caddr_t reg;
+weprobe(is)

        struct isa_device *is;
 {
        register int i;
        struct isa_device *is;
 {
        register int i;

-       register struct wd_softc *sc = &wd_softc[is->is_unit];
-       union wd_mem_sel wdm;
+       register struct we_softc *sc = &we_softc[is->id_unit];
+       union we_mem_sel wem;

        u_char sum;
  
        /*
        u_char sum;
  
        /*


@@ -111,47 +114,49 @@ wdprobe(reg, is)
         * Autoconfiguration: No warning message is printed on error.
         */
        for (sum = 0, i = 0; i < 8; ++i)
         * Autoconfiguration: No warning message is printed on error.
         */
        for (sum = 0, i = 0; i < 8; ++i)

-           sum += INB(reg + WD_ROM_OFFSET + i);
+           sum += inb(is->id_iobase + WD_ROM_OFFSET + i);

        if (sum != WD_CHECKSUM)
             return (0);
        if (sum != WD_CHECKSUM)
             return (0);

-       sc->wd_type = INB(reg + WD_ROM_OFFSET + 6);
-       if ((sc->wd_type != WD_ETHER) && (sc->wd_type != WD_STARLAN))
+       sc->we_type = inb(is->id_iobase + WD_ROM_OFFSET + 6);
+       if ((sc->we_type != WD_ETHER) && (sc->we_type != WD_STARLAN)
+       && (sc->we_type != WD_ETHER2))

             return (0);
 
        /*
         * Setup card RAM area and i/o addresses
         * Kernel Virtual to segment C0000-DFFFF?????
         */
             return (0);
 
        /*
         * Setup card RAM area and i/o addresses
         * Kernel Virtual to segment C0000-DFFFF?????
         */

-       sc->wd_io_ctl_addr = reg;
-       sc->wd_io_nic_addr = sc->wd_io_ctl_addr + WD_NIC_OFFSET;
-       sc->wd_vector = is->is_vector;
-       sc->wd_vmem_addr = (caddr_t)is->is_mem;
-       sc->wd_vmem_size = is->is_memsize;
-       sc->wd_vmem_ring = sc->wd_vmem_addr + (WD_PAGE_SIZE * WD_TXBUF_SIZE);
+       sc->we_io_ctl_addr = is->id_iobase;
+       sc->we_io_nic_addr = sc->we_io_ctl_addr + WD_NIC_OFFSET;
+       sc->we_vector = is->id_irq;
+       sc->we_vmem_addr = (caddr_t)is->id_maddr;
+       sc->we_vmem_size = is->id_msize;
+       sc->we_vmem_ring = sc->we_vmem_addr + (WD_PAGE_SIZE * WD_TXBUF_SIZE);

 
        /*
         * Save board ROM station address
         */
        for (i = 0; i < ETHER_ADDR_LEN; ++i)
 
        /*
         * Save board ROM station address
         */
        for (i = 0; i < ETHER_ADDR_LEN; ++i)

-           sc->wd_addr[i] = INB(sc->wd_io_ctl_addr + WD_ROM_OFFSET + i);
+           sc->we_addr[i] = inb(sc->we_io_ctl_addr + WD_ROM_OFFSET + i);

 
        /*
         * Mapin interface memory, setup memory select register
         */
 
        /*
         * Mapin interface memory, setup memory select register
         */

-       wdm.ms_addr = (u_long)sc->wd_vmem_addr >> 13; 
-       wdm.ms_enable = 1;
-       wdm.ms_reset = 0;
-       OUTB(sc->wd_io_ctl_addr, wdm.ms_byte);
+       /* wem.ms_addr = (u_long)sc->we_vmem_addr >> 13;  */
+       wem.ms_addr = (u_long)(0xd0000)>> 13; 
+       wem.ms_enable = 1;
+       wem.ms_reset = 0;
+       outb(sc->we_io_ctl_addr, wem.ms_byte);

 
        /*
         * clear interface memory, then sum to make sure its valid
         */
 
        /*
         * clear interface memory, then sum to make sure its valid
         */

-       for (i = 0; i < sc->wd_vmem_size; ++i)
-           sc->wd_vmem_addr[i] = 0x0;
-       for (sum = 0, i = 0; i < sc->wd_vmem_size; ++i)
-           sum += sc->wd_vmem_addr[i];
+       for (i = 0; i < sc->we_vmem_size; ++i)
+           sc->we_vmem_addr[i] = 0x0;
+       for (sum = 0, i = 0; i < sc->we_vmem_size; ++i)
+           sum += sc->we_vmem_addr[i];

        if (sum != 0x0) {
        if (sum != 0x0) {

-            printf("wd%d: wd8003 dual port RAM address error\n", is->is_unit);
+            printf("we%d: wd8003 dual port RAM address error\n", is->id_unit);

            return (0);
        }
 
            return (0);
        }
 


@@ -163,78 +168,78 @@ wdprobe(reg, is)
  * 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.
  */

-wdattach(is)
+weattach(is)

        struct isa_device *is;
 {
        struct isa_device *is;
 {

-       register struct wd_softc *sc = &wd_softc[is->is_unit];
-       register struct ifnet *ifp = &sc->wd_if;
+       register struct we_softc *sc = &we_softc[is->id_unit];
+       register struct ifnet *ifp = &sc->we_if;

  
        /*
         * Initialize ifnet structure
         */
  
        /*
         * Initialize ifnet structure
         */

-       ifp->if_unit = is->is_unit;
-       ifp->if_name = "wd";
+       ifp->if_unit = is->id_unit;
+       ifp->if_name = "we";

        ifp->if_mtu = ETHERMTU;
        ifp->if_flags = IFF_BROADCAST|IFF_NOTRAILERS;
        ifp->if_mtu = ETHERMTU;
        ifp->if_flags = IFF_BROADCAST|IFF_NOTRAILERS;

-       ifp->if_init = wdinit;
-       ifp->if_output = wdoutput;
-       ifp->if_ioctl = wdioctl;
-       ifp->if_reset = wdreset;
+       ifp->if_init = weinit;
+       ifp->if_output = weoutput;
+       ifp->if_ioctl = weioctl;
+       ifp->if_reset = wereset;

        ifp->if_watchdog = 0;
        if_attach(ifp);
  
        /*
         * Banner...
         */
        ifp->if_watchdog = 0;
        if_attach(ifp);
  
        /*
         * Banner...
         */

-       printf("wd%d: %s, hardware address %s\n", is->is_unit,
-               ((sc->wd_type == WD_ETHER) ? "ethernet" : "starlan"),
-               ether_sprintf(sc->wd_addr));
+       printf(" %s address %s",
+               ((sc->we_type != WD_STARLAN) ? "ethernet" : "starlan"),
+               ether_sprintf(sc->we_addr));

 }
  
 /*
  * Reset of interface.
  */
 }
  
 /*
  * Reset of interface.
  */

-wdreset(unit, uban)
+wereset(unit, uban)

        int unit, uban;
 {
        int unit, uban;
 {

-       if (unit >= NWD)
+       if (unit >= NWE)

                return;
                return;

-       printf("wd%d: reset\n", unit);
-       wd_softc[unit].wd_flags &= ~WDF_RUNNING;
-       wdinit(unit);
+       printf("we%d: reset\n", unit);
+       we_softc[unit].we_flags &= ~WDF_RUNNING;
+       weinit(unit);

 }
  
 /*
  * Take interface offline.
  */
 }
  
 /*
  * Take interface offline.
  */

-wdstop(unit)
+westop(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
-       union wd_command wdcmd;
+       register struct we_softc *sc = &we_softc[unit];
+       union we_command wecmd;

        int s;
  
        /*
         * Shutdown NS32490
         */
        s = splimp();
        int s;
  
        /*
         * Shutdown NS32490
         */
        s = splimp();

-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_stp = 1;
-       wdcmd.cs_sta = 0;
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_stp = 1;
+       wecmd.cs_sta = 0;
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);

        (void) splx(s);
 }
 
 /*
  * Initialization of interface (really just NS32490). 
  */
        (void) splx(s);
 }
 
 /*
  * Initialization of interface (really just NS32490). 
  */

-wdinit(unit)
+weinit(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
-       register struct ifnet *ifp = &sc->wd_if;
-       union wd_command wdcmd;
+       register struct we_softc *sc = &we_softc[unit];
+       register struct ifnet *ifp = &sc->we_if;
+       union we_command wecmd;

        int i, s;
  
        /* address not known */
        int i, s;
  
        /* address not known */


@@ -242,89 +247,90 @@ wdinit(unit)
                return;
 
        /* already running */
                return;
 
        /* already running */

-       if (sc->wd_flags & WDF_RUNNING)
+       if (sc->we_flags & WDF_RUNNING)

                return;
 
        /*
         * Initialize NS32490 in order given in NSC NIC manual.
         * this is stock code...please see the National manual for details.
         */
                return;
 
        /*
         * Initialize NS32490 in order given in NSC NIC manual.
         * this is stock code...please see the National manual for details.
         */

-       s = splhi();
-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_stp = 1;
-       wdcmd.cs_sta = 0;
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       OUTB(sc->wd_io_nic_addr + WD_P0_DCR, WD_D_CONFIG);
-       OUTB(sc->wd_io_nic_addr + WD_P0_RBCR0, 0);
-       OUTB(sc->wd_io_nic_addr + WD_P0_RBCR1, 0);
-       OUTB(sc->wd_io_nic_addr + WD_P0_RCR, WD_R_MON);
-       OUTB(sc->wd_io_nic_addr + WD_P0_TCR, WD_T_CONFIG);
-       OUTB(sc->wd_io_nic_addr + WD_P0_TPSR, 0);
-       OUTB(sc->wd_io_nic_addr + WD_P0_PSTART, WD_TXBUF_SIZE);
-       OUTB(sc->wd_io_nic_addr + WD_P0_PSTOP,
-               sc->wd_vmem_size / WD_PAGE_SIZE);
-       OUTB(sc->wd_io_nic_addr + WD_P0_BNRY, WD_TXBUF_SIZE);
-       OUTB(sc->wd_io_nic_addr + WD_P0_ISR, 0xff);
-       OUTB(sc->wd_io_nic_addr + WD_P0_IMR, WD_I_CONFIG);
-       wdcmd.cs_ps = 1;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
+       s = splhigh();
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_stp = 1;
+       wecmd.cs_sta = 0;
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       outb(sc->we_io_nic_addr + WD_P0_DCR, WD_D_CONFIG);
+       outb(sc->we_io_nic_addr + WD_P0_RBCR0, 0);
+       outb(sc->we_io_nic_addr + WD_P0_RBCR1, 0);
+       outb(sc->we_io_nic_addr + WD_P0_RCR, WD_R_MON);
+       outb(sc->we_io_nic_addr + WD_P0_TCR, WD_T_CONFIG);
+       outb(sc->we_io_nic_addr + WD_P0_TPSR, 0);
+       outb(sc->we_io_nic_addr + WD_P0_PSTART, WD_TXBUF_SIZE);
+       outb(sc->we_io_nic_addr + WD_P0_PSTOP,
+               sc->we_vmem_size / WD_PAGE_SIZE);
+       outb(sc->we_io_nic_addr + WD_P0_BNRY, WD_TXBUF_SIZE);
+       outb(sc->we_io_nic_addr + WD_P0_ISR, 0xff);
+#define WD_I_CONFIG    0xff
+       outb(sc->we_io_nic_addr + WD_P0_IMR, WD_I_CONFIG);
+       wecmd.cs_ps = 1;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);

        for (i = 0; i < ETHER_ADDR_LEN; ++i)
        for (i = 0; i < ETHER_ADDR_LEN; ++i)

-           OUTB(sc->wd_io_nic_addr + WD_P1_PAR0 + i, sc->wd_addr[i]);
+           outb(sc->we_io_nic_addr + WD_P1_PAR0 + i, sc->we_addr[i]);

        for (i = 0; i < ETHER_ADDR_LEN; ++i)    /* == broadcast addr */
        for (i = 0; i < ETHER_ADDR_LEN; ++i)    /* == broadcast addr */

-           OUTB(sc->wd_io_nic_addr + WD_P1_MAR0 + i, 0xff);
-       OUTB(sc->wd_io_nic_addr + WD_P1_CURR, WD_TXBUF_SIZE);
-       wdcmd.cs_ps = 0;
-       wdcmd.cs_stp = 0;
-       wdcmd.cs_sta = 1;
-       wdcmd.cs_rd = 0x4;
-       OUTB(sc->wd_io_nic_addr + WD_P1_COMMAND, wdcmd.cs_byte);
-       OUTB(sc->wd_io_nic_addr + WD_P0_RCR, WD_R_CONFIG);
+           outb(sc->we_io_nic_addr + WD_P1_MAR0 + i, 0xff);
+       outb(sc->we_io_nic_addr + WD_P1_CURR, WD_TXBUF_SIZE);
+       wecmd.cs_ps = 0;
+       wecmd.cs_stp = 0;
+       wecmd.cs_sta = 1;
+       wecmd.cs_rd = 0x4;
+       outb(sc->we_io_nic_addr + WD_P1_COMMAND, wecmd.cs_byte);
+       outb(sc->we_io_nic_addr + WD_P0_RCR, WD_R_CONFIG);

 
        /*
         * Take the interface out of reset, program the vector, 
         * enable interrupts, and tell the world we are up.
         */
        ifp->if_flags |= IFF_UP | IFF_RUNNING;
 
        /*
         * Take the interface out of reset, program the vector, 
         * enable interrupts, and tell the world we are up.
         */
        ifp->if_flags |= IFF_UP | IFF_RUNNING;

-       sc->wd_flags |= WDF_RUNNING;
-       sc->wd_flags &= ~WDF_TXBUSY;
+       sc->we_flags |= WDF_RUNNING;
+       sc->we_flags &= ~WDF_TXBUSY;

        (void) splx(s);
        (void) splx(s);

-       wdstart(unit);
+       westart(unit);

 }
  
 /*
  * Start output on interface.
  */
 }
  
 /*
  * Start output on interface.
  */

-wdstart(unit)
+westart(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
+       register struct we_softc *sc = &we_softc[unit];

        struct mbuf *m0, *m;
        register caddr_t buffer;
        int len = 0, s;
        struct mbuf *m0, *m;
        register caddr_t buffer;
        int len = 0, s;

-       union wd_command wdcmd;
+       union we_command wecmd;

  
        /*
         * The NS32490 has only one transmit buffer, if it is busy we
         * must wait until the transmit interrupt completes.
         */
  
        /*
         * The NS32490 has only one transmit buffer, if it is busy we
         * must wait until the transmit interrupt completes.
         */

-       s = splhi();
-       if (sc->wd_flags & WDF_TXBUSY) {
+       s = splhigh();
+       if (sc->we_flags & WDF_TXBUSY) {

                (void) splx(s);
                return;
        }
                (void) splx(s);
                return;
        }

-       IF_DEQUEUE(&sc->wd_if.if_snd, m);
+       IF_DEQUEUE(&sc->we_if.if_snd, m);

        if (m == 0) {
                (void) splx(s);
                return;
        }
        if (m == 0) {
                (void) splx(s);
                return;
        }

-       sc->wd_flags |= WDF_TXBUSY; 
+       sc->we_flags |= WDF_TXBUSY; 

        (void) splx(s);
 
        /*
         * Copy the mbuf chain into the transmit buffer
         */
        (void) splx(s);
 
        /*
         * Copy the mbuf chain into the transmit buffer
         */

-       buffer = sc->wd_vmem_addr;
+       buffer = sc->we_vmem_addr;

        for (m0 = m; m != 0; m = m->m_next) {
                bcopy(mtod(m, caddr_t), buffer, m->m_len);
                buffer += m->m_len;
        for (m0 = m; m != 0; m = m->m_next) {
                bcopy(mtod(m, caddr_t), buffer, m->m_len);
                buffer += m->m_len;


@@ -336,137 +342,155 @@ wdstart(unit)
         * back because the hardware can't hear its own
         * transmits.
         */
         * back because the hardware can't hear its own
         * transmits.
         */

+#ifdef notyet

        if (bcmp((caddr_t)(mtod(m0, struct ether_header *)->ether_dhost),
           (caddr_t)etherbroadcastaddr,
           sizeof(etherbroadcastaddr)) == 0) {
        if (bcmp((caddr_t)(mtod(m0, struct ether_header *)->ether_dhost),
           (caddr_t)etherbroadcastaddr,
           sizeof(etherbroadcastaddr)) == 0) {

-               wdread(sc, m0);
+               weread(sc, m0);

        } else {
        } else {

+#endif

                m_freem(m0);
                m_freem(m0);

+#ifdef notyet

        }
        }

+#endif

 
        /*
         * Init transmit length registers, and set transmit start flag.
         */
 
        /*
         * Init transmit length registers, and set transmit start flag.
         */

-       s = splhi();
+       s = splhigh();

        len = MAX(len, ETHER_MIN_LEN);
        len = MAX(len, ETHER_MIN_LEN);

-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       OUTB(sc->wd_io_nic_addr + WD_P0_TBCR0, len & 0xff);
-       OUTB(sc->wd_io_nic_addr + WD_P0_TBCR1, len >> 8);
-       wdcmd.cs_txp = 1;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       outb(sc->we_io_nic_addr + WD_P0_TBCR0, len & 0xff);
+       outb(sc->we_io_nic_addr + WD_P0_TBCR1, len >> 8);
+       wecmd.cs_txp = 1;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);

        (void) splx(s);
 }
  
 /*
  * Ethernet interface interrupt processor
  */
        (void) splx(s);
 }
  
 /*
  * Ethernet interface interrupt processor
  */

-wdintr(unit)
+weintr(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
-       union wd_command wdcmd;
-       union wd_interrupt wdisr;
+       register struct we_softc *sc = &we_softc[0];
+       union we_command wecmd;
+       union we_interrupt weisr;

        int s;
        int s;

+       unit =0;

  
        /* disable onboard interrupts, then get interrupt status */
  
        /* disable onboard interrupts, then get interrupt status */

-       s = splhi();
-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       OUTB(sc->wd_io_nic_addr + WD_P0_IMR, 0);
-       wdisr.is_byte = INB(sc->wd_io_nic_addr + WD_P0_ISR);
-       OUTB(sc->wd_io_nic_addr + WD_P0_ISR, 0xff);
+       s = splhigh();
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       /* outb(sc->we_io_nic_addr + WD_P0_IMR, 0); */
+       weisr.is_byte = inb(sc->we_io_nic_addr + WD_P0_ISR);
+#ifdef notdef
+printf("weintr %x ", inb(sc->we_io_nic_addr + WD_P0_ISR));
+outb(sc->we_io_nic_addr+WD_P0_IMR,0xff);
+#endif
+       outb(sc->we_io_nic_addr + WD_P0_ISR, 0xff);

        (void) splx(s);
 
        /* transmit error */
        (void) splx(s);
 
        /* transmit error */

-       if (wdisr.is_txe) {
+       if (weisr.is_txe) {
+printf("txe\n");

                /* need to read these registers to clear status */
                /* need to read these registers to clear status */

-               sc->wd_if.if_collisions +=
-                   INB(sc->wd_io_nic_addr + WD_P0_TBCR0);
-               ++sc->wd_if.if_oerrors;
+               sc->we_if.if_collisions +=
+                   inb(sc->we_io_nic_addr + WD_P0_TBCR0);
+               ++sc->we_if.if_oerrors;

        }
 
        /* receiver error */
        }
 
        /* receiver error */

-       if (wdisr.is_rxe) {
+       if (weisr.is_rxe) {
+printf("rxe\n");

                /* need to read these registers to clear status */
                /* need to read these registers to clear status */

-               (void) INB(sc->wd_io_nic_addr + 0xD);
-               (void) INB(sc->wd_io_nic_addr + 0xE);
-               (void) INB(sc->wd_io_nic_addr + 0xF);
-               ++sc->wd_if.if_ierrors;
+               (void) inb(sc->we_io_nic_addr + 0xD);
+               (void) inb(sc->we_io_nic_addr + 0xE);
+               (void) inb(sc->we_io_nic_addr + 0xF);
+               ++sc->we_if.if_ierrors;

        }
 
        /* normal transmit complete */
        }
 
        /* normal transmit complete */

-       if (wdisr.is_ptx)
-               wdtint (unit);
+       if (weisr.is_ptx)
+               wetint (unit);

 
        /* normal receive notification */
 
        /* normal receive notification */

-       if (wdisr.is_prx)
-               wdrint (unit);
+       if (weisr.is_prx)
+               werint (unit);

 
        /* try to start transmit */
 
        /* try to start transmit */

-       wdstart(unit);
+       westart(unit);

 
        /* re-enable onboard interrupts */
 
        /* re-enable onboard interrupts */

-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       OUTB(sc->wd_io_nic_addr + WD_P0_IMR, WD_I_CONFIG);
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       outb(sc->we_io_nic_addr + WD_P0_IMR, WD_I_CONFIG);

 }
  
 /*
  * Ethernet interface transmit interrupt.
  */
 }
  
 /*
  * Ethernet interface transmit interrupt.
  */

-wdtint(unit)
+wetint(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
+       register struct we_softc *sc = &we_softc[unit];

 
        /*
         * Do some statistics (assume page zero of NIC mapped in)
         */
 
        /*
         * Do some statistics (assume page zero of NIC mapped in)
         */

-       sc->wd_flags &= ~WDF_TXBUSY; 
-       sc->wd_if.if_timer = 0;
-       ++sc->wd_if.if_opackets;
-       sc->wd_if.if_collisions += INB(sc->wd_io_nic_addr + WD_P0_TBCR0);
+       sc->we_flags &= ~WDF_TXBUSY; 
+       sc->we_if.if_timer = 0;
+       ++sc->we_if.if_opackets;
+       sc->we_if.if_collisions += inb(sc->we_io_nic_addr + WD_P0_TBCR0);

 }
  
 /*
  * Ethernet interface receiver interrupt.
  */
 }
  
 /*
  * Ethernet interface receiver interrupt.
  */

-wdrint(unit)
+werint(unit)

        int unit;
 {
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
+       register struct we_softc *sc = &we_softc[unit];

        register struct mbuf **m;
        int mlen, len, count;
        u_char bnry, curr;
        register struct mbuf **m;
        int mlen, len, count;
        u_char bnry, curr;

-       union wd_command wdcmd;
-       struct wd_ring *wdr;
+       union we_command wecmd;
+       struct we_ring *wer;

        struct mbuf *m0;
        caddr_t pkt, endp;
        struct mbuf *m0;
        caddr_t pkt, endp;

+static Bdry;

  
        /*
         * Traverse the receive ring looking for packets to pass back.
         * The search is complete when we find a descriptor not in use.
         */
  
        /*
         * Traverse the receive ring looking for packets to pass back.
         * The search is complete when we find a descriptor not in use.
         */

-       wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-       wdcmd.cs_ps = 0;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       bnry = INB(sc->wd_io_nic_addr + WD_P0_BNRY);
-       wdcmd.cs_ps = 1;
-       OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-       curr = INB(sc->wd_io_nic_addr + WD_P1_CURR);
+       wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+       wecmd.cs_ps = 0;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       bnry = inb(sc->we_io_nic_addr + WD_P0_BNRY);
+       wecmd.cs_ps = 1;
+       outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+       curr = inb(sc->we_io_nic_addr + WD_P1_CURR);
+printf("Bd %x cur %x ", bnry, curr);
+if(Bdry && Bdry > bnry){
+       bnry =Bdry;
+printf("bd %x! ", bnry);
+}

        while (bnry != curr)
        {
                /* get pointer to this buffer header structure */
        while (bnry != curr)
        {
                /* get pointer to this buffer header structure */

-               wdr = (struct wd_ring *)(sc->wd_vmem_addr + (bnry << 8));
-               len = wdr->wd_count - 4;        /* count includes CRC */
-               pkt = (caddr_t)(wdr + 1) - 2;   /* 2 - word align pkt data */
-               count = len + 2;                /* copy two extra bytes */
-               endp = (caddr_t)(sc->wd_vmem_addr + sc->wd_vmem_size);
-               ++sc->wd_if.if_ipackets;
+               wer = (struct we_ring *)(sc->we_vmem_addr + (bnry << 8));
+               len = wer->we_count - 4;        /* count includes CRC */
+printf("l %d", len);
+               pkt = (caddr_t)(wer + 1) /*- 2*/;       /* 2 - word align pkt data */
+               count = len /*+ 2*/;            /* copy two extra bytes */
+               endp = (caddr_t)(sc->we_vmem_addr + sc->we_vmem_size);
+               ++sc->we_if.if_ipackets;

 
                /* pull packet out of dual ported RAM */
                m = &m0; m0 = 0;
 
                /* pull packet out of dual ported RAM */
                m = &m0; m0 = 0;


@@ -491,47 +515,51 @@ wdrint(unit)
 
                    /* wrap memory pointer around circ buffer */
                    if (pkt == endp)
 
                    /* wrap memory pointer around circ buffer */
                    if (pkt == endp)

-                       pkt = (caddr_t)sc->wd_vmem_ring;
+                       pkt = (caddr_t)sc->we_vmem_ring;

                }
 
                /* skip aligment bytes, send packet up to higher levels */
                if (m0 != 0)
                {
                }
 
                /* skip aligment bytes, send packet up to higher levels */
                if (m0 != 0)
                {

-                   m0->m_off += 2;
-                   wdread(sc, m0);
+/*                 m0->m_off += 2*/;
+                   weread(sc, m0);

                }
 
 outofbufs:
                /* advance on chip Boundry register */
                }
 
 outofbufs:
                /* advance on chip Boundry register */

-               bnry = wdr->wd_next_packet;
-               wdcmd.cs_byte = INB(sc->wd_io_nic_addr + WD_P0_COMMAND);
-               wdcmd.cs_ps = 0;
-               OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
+printf("nx %x ", wer->we_next_packet);
+               bnry = wer->we_next_packet;
+               wecmd.cs_byte = inb(sc->we_io_nic_addr + WD_P0_COMMAND);
+               wecmd.cs_ps = 0;
+               outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);

 
                /* watch out for NIC overflow, reset Boundry if invalid */
                if ((bnry - 1) < WD_TXBUF_SIZE) {
 #ifdef notdef
 
                /* watch out for NIC overflow, reset Boundry if invalid */
                if ((bnry - 1) < WD_TXBUF_SIZE) {
 #ifdef notdef

-                   wdreset(unit, 0);
+                   wereset(unit, 0);

                    break;
 #else
                    break;
 #else

-                   OUTB(sc->wd_io_nic_addr + WD_P0_BNRY,
-                       (sc->wd_vmem_size / WD_PAGE_SIZE) - 1);
+                   outb(sc->we_io_nic_addr + WD_P0_BNRY,
+                       (sc->we_vmem_size / WD_PAGE_SIZE) - 1);

 #endif
                }
 #endif
                }

-               OUTB(sc->wd_io_nic_addr + WD_P0_BNRY, bnry - 1);
+               outb(sc->we_io_nic_addr + WD_P0_BNRY, bnry-1);

 
                /* refresh our copy of CURR */
 
                /* refresh our copy of CURR */

-               wdcmd.cs_ps = 1;
-               OUTB(sc->wd_io_nic_addr + WD_P0_COMMAND, wdcmd.cs_byte);
-               curr = INB(sc->wd_io_nic_addr + WD_P1_CURR);
+               wecmd.cs_ps = 1;
+               outb(sc->we_io_nic_addr + WD_P0_COMMAND, wecmd.cs_byte);
+               curr = inb(sc->we_io_nic_addr + WD_P1_CURR);
+printf("bd %x cur %x ", bnry-1, curr);

        }
        }

+printf("bD %x\n", bnry);
+Bdry = bnry;

 }
 
 /*
  * Ethernet output routine.
  * Encapsulate a packet of type family for the local net.
  */
 }
 
 /*
  * Ethernet output routine.
  * Encapsulate a packet of type family for the local net.
  */

-wdoutput(ifp, m0, dst)
+weoutput(ifp, m0, dst)

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


@@ -539,7 +567,7 @@ wdoutput(ifp, m0, dst)
        int type, s, error;
        u_char edst[6];
        struct in_addr idst;
        int type, s, error;
        u_char edst[6];
        struct in_addr idst;

-       register struct wd_softc *sc = &wd_softc[ifp->if_unit];
+       register struct we_softc *sc = &we_softc[ifp->if_unit];

        register struct mbuf *m = m0;
        register struct ether_header *eh;
        int usetrailers;
        register struct mbuf *m = m0;
        register struct ether_header *eh;
        int usetrailers;


@@ -555,7 +583,7 @@ wdoutput(ifp, m0, dst)
        case AF_INET:
                /* Note: we ignore usetrailers */
                idst = ((struct sockaddr_in *)dst)->sin_addr;
        case AF_INET:
                /* Note: we ignore usetrailers */
                idst = ((struct sockaddr_in *)dst)->sin_addr;

-               if (!arpresolve(&sc->wd_ac, m, &idst, edst, &usetrailers))
+               if (!arpresolve(&sc->we_ac, m, &idst, edst, &usetrailers))

                        return (0);     /* if not yet resolved */
                type = ETHERTYPE_IP;
                break;
                        return (0);     /* if not yet resolved */
                type = ETHERTYPE_IP;
                break;


@@ -576,7 +604,7 @@ wdoutput(ifp, m0, dst)
                break;
  
        default:
                break;
  
        default:

-               printf("wd%d: can't handle af%d\n", ifp->if_unit,
+               printf("we%d: can't handle af%d\n", ifp->if_unit,

                        dst->sa_family);
                error = EAFNOSUPPORT;
                goto bad;
                        dst->sa_family);
                error = EAFNOSUPPORT;
                goto bad;


@@ -602,8 +630,8 @@ wdoutput(ifp, m0, dst)
        eh = mtod(m, struct ether_header *);
        eh->ether_type = htons((u_short)type);
        bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
        eh = mtod(m, struct ether_header *);
        eh->ether_type = htons((u_short)type);
        bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));

-       bcopy((caddr_t)sc->wd_addr, (caddr_t)eh->ether_shost,
-               sizeof (sc->wd_addr));
+       bcopy((caddr_t)sc->we_addr, (caddr_t)eh->ether_shost,
+               sizeof (sc->we_addr));

  
        /*
         * Queue message on interface, and start output if interface
  
        /*
         * Queue message on interface, and start output if interface


@@ -618,7 +646,7 @@ wdoutput(ifp, m0, dst)
        }
        IF_ENQUEUE(&ifp->if_snd, m);
        (void) splx(s);
        }
        IF_ENQUEUE(&ifp->if_snd, m);
        (void) splx(s);

-       wdstart(ifp->if_unit);
+       westart(ifp->if_unit);

        return (0);
  
 bad:
        return (0);
  
 bad:


@@ -629,12 +657,12 @@ bad:
 /*
  * Process an ioctl request.
  */
 /*
  * Process an ioctl request.
  */

-wdioctl(ifp, cmd, data)
+weioctl(ifp, cmd, data)

        register struct ifnet *ifp;
        int cmd;
        caddr_t data;
 {
        register struct ifnet *ifp;
        int cmd;
        caddr_t data;
 {

-       struct wd_softc *sc = &wd_softc[ifp->if_unit];
+       struct we_softc *sc = &we_softc[ifp->if_unit];

        struct ifaddr *ifa = (struct ifaddr *)data;
        int s = splimp(), error = 0;
  
        struct ifaddr *ifa = (struct ifaddr *)data;
        int s = splimp(), error = 0;
  


@@ -642,7 +670,7 @@ wdioctl(ifp, cmd, data)
  
        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP;
  
        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP;

-               wdinit(ifp->if_unit);
+               weinit(ifp->if_unit);

                switch(ifa->ifa_addr.sa_family) {
 #ifdef INET
                case AF_INET:
                switch(ifa->ifa_addr.sa_family) {
 #ifdef INET
                case AF_INET:


@@ -657,9 +685,9 @@ wdioctl(ifp, cmd, data)
                        register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
                        
                        if (ns_nullhost(*ina))
                        register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
                        
                        if (ns_nullhost(*ina))

-                               ina->x_host = *(union ns_host *)(sc->wd_addr);
+                               ina->x_host = *(union ns_host *)(sc->we_addr);

                        else
                        else

-                               wdsetaddr(ina->x_host.c_host, ifp->if_unit);
+                               wesetaddr(ina->x_host.c_host, ifp->if_unit);

                        break;
                    }
 #endif
                        break;
                    }
 #endif


@@ -668,11 +696,11 @@ wdioctl(ifp, cmd, data)
 
        case SIOCSIFFLAGS:
                if (((ifp->if_flags & IFF_UP) == 0) &&
 
        case SIOCSIFFLAGS:
                if (((ifp->if_flags & IFF_UP) == 0) &&

-                  (sc->wd_flags & WDF_RUNNING)) {
-                       wdstop(ifp->if_unit);
+                  (sc->we_flags & WDF_RUNNING)) {
+                       westop(ifp->if_unit);

                } else if (((ifp->if_flags & IFF_UP) == IFF_UP) &&
                } else if (((ifp->if_flags & IFF_UP) == IFF_UP) &&

-                  ((sc->wd_flags & WDF_RUNNING) == 0))
-                       wdinit(ifp->if_unit);
+                  ((sc->we_flags & WDF_RUNNING) == 0))
+                       weinit(ifp->if_unit);

                break;
 
        default:
                break;
 
        default:


@@ -686,28 +714,28 @@ wdioctl(ifp, cmd, data)
 /*
  * set ethernet address for unit
  */
 /*
  * set ethernet address for unit
  */

-wdsetaddr(physaddr, unit)
+wesetaddr(physaddr, unit)

        u_char *physaddr;
        int unit;
 {
        u_char *physaddr;
        int unit;
 {

-       register struct wd_softc *sc = &wd_softc[unit];
+       register struct we_softc *sc = &we_softc[unit];

        register int i;
 
        /*
         * Rewrite ethernet address, and then force restart of NIC
         */
        for (i = 0; i < ETHER_ADDR_LEN; i++)
        register int i;
 
        /*
         * Rewrite ethernet address, and then force restart of NIC
         */
        for (i = 0; i < ETHER_ADDR_LEN; i++)

-               sc->wd_addr[i] = physaddr[i];
-       sc->wd_flags &= ~WDF_RUNNING;
-       wdinit(unit);
+               sc->we_addr[i] = physaddr[i];
+       sc->we_flags &= ~WDF_RUNNING;
+       weinit(unit);

 }
  
 /*
  * Pass a packet to the higher levels.
  * NO TRAILER PROTOCOL!
  */
 }
  
 /*
  * Pass a packet to the higher levels.
  * NO TRAILER PROTOCOL!
  */

-wdread(sc, m)
-       register struct wd_softc *sc;
+weread(sc, m)
+       register struct we_softc *sc;

        struct mbuf *m;
 {
        struct ether_header *eh;
        struct mbuf *m;
 {
        struct ether_header *eh;


@@ -731,18 +759,21 @@ wdread(sc, m)
         */
        m->m_off -= sizeof (struct ifnet *);
        m->m_len += sizeof (struct ifnet *);
         */
        m->m_off -= sizeof (struct ifnet *);
        m->m_len += sizeof (struct ifnet *);

-       *(mtod(m, struct ifnet **)) = &sc->wd_if;
+       *(mtod(m, struct ifnet **)) = &sc->we_if;

 
 

+printf("ty %x ", type);

        switch (type) {
 
 #ifdef INET
        case ETHERTYPE_IP:
        switch (type) {
 
 #ifdef INET
        case ETHERTYPE_IP:

+printf("ip ");

                scn = NETISR_IP;
                inq = &ipintrq;
                break;
 
        case ETHERTYPE_ARP:
                scn = NETISR_IP;
                inq = &ipintrq;
                break;
 
        case ETHERTYPE_ARP:

-               arpinput(&sc->wd_ac, m);
+printf("arp ");
+               arpinput(&sc->we_ac, m);

                return;
 #endif
 #ifdef NS
                return;
 #endif
 #ifdef NS