*
* %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
*
#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 ??????????????????????????????????????????
*/
* 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;
/*
* 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);
}
* 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 */
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;
* 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;
/* 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;
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;
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;
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;
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
}
IF_ENQUEUE(&ifp->if_snd, m);
(void) splx(s);
- wdstart(ifp->if_unit);
+ westart(ifp->if_unit);
return (0);
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;
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:
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
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:
/*
* 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;
*/
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