From: Bill Joy Date: Fri, 9 Nov 1990 11:38:45 +0000 (-0800) Subject: 1st working version X-Git-Tag: BSD-4_3_Reno-Snapshot-Development~246 X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/commitdiff_plain/4ad9a99e12cc24c158f606d347722edc6b3f7395?hp=d7344592443c2a5be2cdf4f309b422d86a596cc1 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 2214b07733..94a314f132 100644 --- 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% * - * @(#)if_we.c 5.1 (Berkeley) %G% + * @(#)if_we.c 5.2 (Berkeley) %G% */ /* * 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 * @@ -50,11 +50,11 @@ #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 ?????????????????????????????????????????? */ @@ -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, ... */ -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 - 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 */ -wdprobe(reg, is) - caddr_t reg; +weprobe(is) 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; /* @@ -111,47 +114,49 @@ wdprobe(reg, is) * 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); - 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????? */ - 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) - 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 */ - 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 */ - 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) { - 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); } @@ -163,78 +168,78 @@ wdprobe(reg, is) * record. System will initialize the interface when it is ready * to accept packets. */ -wdattach(is) +weattach(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 */ - 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_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... */ - 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. */ -wdreset(unit, uban) +wereset(unit, uban) int unit, uban; { - if (unit >= NWD) + if (unit >= NWE) 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. */ -wdstop(unit) +westop(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(); - 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). */ -wdinit(unit) +weinit(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 */ @@ -242,89 +247,90 @@ wdinit(unit) 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. */ - 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) - 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 */ - 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; - sc->wd_flags |= WDF_RUNNING; - sc->wd_flags &= ~WDF_TXBUSY; + sc->we_flags |= WDF_RUNNING; + sc->we_flags &= ~WDF_TXBUSY; (void) splx(s); - wdstart(unit); + westart(unit); } /* * Start output on interface. */ -wdstart(unit) +westart(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; - 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. */ - s = splhi(); - if (sc->wd_flags & WDF_TXBUSY) { + s = splhigh(); + if (sc->we_flags & WDF_TXBUSY) { (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; } - sc->wd_flags |= WDF_TXBUSY; + sc->we_flags |= WDF_TXBUSY; (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; @@ -336,137 +342,155 @@ wdstart(unit) * 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) { - wdread(sc, m0); + weread(sc, m0); } else { +#endif m_freem(m0); +#ifdef notyet } +#endif /* * Init transmit length registers, and set transmit start flag. */ - s = splhi(); + s = splhigh(); 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 */ -wdintr(unit) +weintr(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; + unit =0; /* 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 */ - if (wdisr.is_txe) { + if (weisr.is_txe) { +printf("txe\n"); /* 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 */ - if (wdisr.is_rxe) { + if (weisr.is_rxe) { +printf("rxe\n"); /* 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 */ - if (wdisr.is_ptx) - wdtint (unit); + if (weisr.is_ptx) + wetint (unit); /* normal receive notification */ - if (wdisr.is_prx) - wdrint (unit); + if (weisr.is_prx) + werint (unit); /* try to start transmit */ - wdstart(unit); + westart(unit); /* 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. */ -wdtint(unit) +wetint(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) */ - 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. */ -wdrint(unit) +werint(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; - union wd_command wdcmd; - struct wd_ring *wdr; + union we_command wecmd; + struct we_ring *wer; 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. */ - 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 */ - 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; @@ -491,47 +515,51 @@ wdrint(unit) /* 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) { - m0->m_off += 2; - wdread(sc, m0); +/* m0->m_off += 2*/; + weread(sc, m0); } 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 - wdreset(unit, 0); + wereset(unit, 0); 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 } - 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 */ - 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. */ -wdoutput(ifp, m0, dst) +weoutput(ifp, m0, 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; - 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; @@ -555,7 +583,7 @@ wdoutput(ifp, m0, dst) 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; @@ -576,7 +604,7 @@ wdoutput(ifp, m0, dst) 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; @@ -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)); - 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 @@ -618,7 +646,7 @@ wdoutput(ifp, m0, dst) } IF_ENQUEUE(&ifp->if_snd, m); (void) splx(s); - wdstart(ifp->if_unit); + westart(ifp->if_unit); return (0); bad: @@ -629,12 +657,12 @@ bad: /* * Process an ioctl request. */ -wdioctl(ifp, cmd, data) +weioctl(ifp, cmd, 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; @@ -642,7 +670,7 @@ wdioctl(ifp, cmd, data) 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: @@ -657,9 +685,9 @@ wdioctl(ifp, cmd, data) 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 - wdsetaddr(ina->x_host.c_host, ifp->if_unit); + wesetaddr(ina->x_host.c_host, ifp->if_unit); break; } #endif @@ -668,11 +696,11 @@ wdioctl(ifp, cmd, data) 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) && - ((sc->wd_flags & WDF_RUNNING) == 0)) - wdinit(ifp->if_unit); + ((sc->we_flags & WDF_RUNNING) == 0)) + weinit(ifp->if_unit); break; default: @@ -686,28 +714,28 @@ wdioctl(ifp, cmd, data) /* * set ethernet address for unit */ -wdsetaddr(physaddr, unit) +wesetaddr(physaddr, 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++) - 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! */ -wdread(sc, m) - register struct wd_softc *sc; +weread(sc, m) + register struct we_softc *sc; 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 *); - *(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: +printf("ip "); 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