Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/arch/vax/vsa/if_ln.c

1036 lines
24 KiB
C
Raw Blame History

/* $NetBSD: if_ln.c,v 1.13 1999/05/18 23:52:54 thorpej Exp $ */
/*-
* Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
* Simulation Facility, NASA Ames Research Center.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/*-
* Copyright (c) 1992, 1993
* The Regents of the University of California. All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Ralph Campbell and Rick Macklem.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)if_le.c 8.2 (Berkeley) 11/16/93
*/
#include "opt_inet.h"
#include "opt_ccitt.h"
#include "opt_llc.h"
#include "opt_ns.h"
#include "bpfilter.h"
#include "rnd.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mbuf.h>
#include <sys/syslog.h>
#include <sys/socket.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/ioctl.h>
#include <sys/errno.h>
#include <sys/reboot.h>
#if NRND > 0
#include <sys/rnd.h>
#endif
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_ether.h>
#ifdef INET
#include <netinet/in.h>
#include <netinet/if_inarp.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#endif
#ifdef NS
#include <netns/ns.h>
#include <netns/ns_if.h>
#endif
#if defined(CCITT) && defined(LLC)
#include <sys/socketvar.h>
#include <netccitt/x25.h>
#include <netccitt/pk.h>
#include <netccitt/pk_var.h>
#include <netccitt/pk_extern.h>
#endif
#if NBPFILTER > 0
#include <net/bpf.h>
#include <net/bpfdesc.h>
#endif
#include <dev/ic/lancereg.h>
#include <dev/ic/am7990reg.h>
#include <machine/bus.h>
#include <machine/cpu.h>
#include <machine/rpb.h>
#include <machine/vsbus.h>
#include "ioconf.h"
#define RLEN 5
#define NRBUF (1 << RLEN)
#define TLEN 3
#define NTBUF (1 << TLEN)
#define BUFSIZE 1536
/*
* Init block & buffer descriptors according to DEC system
* specification documentation.
*/
struct initblock {
short ib_mode;
char ib_padr[6]; /* Ethernet address */
short ib_ladrf[4];
int ib_rdr; /* Receive address */
int ib_tdr; /* Transmit address */
};
struct buffdesc {
int bd_adrflg;
short bd_bcnt;
short bd_mcnt;
};
/* Flags in the address field */
#define BR_OWN 0x80000000
#define BR_ERR 0x40000000
#define BR_FRAM 0x20000000
#define BR_OFLO 0x10000000
#define BR_CRC 0x08000000
#define BR_BUFF 0x04000000
#define BR_STP 0x02000000
#define BR_ENP 0x01000000
#define BT_OWN 0x80000000
#define BT_ERR 0x40000000
#define BT_MORE 0x10000000
#define BT_ONE 0x08000000
#define BT_DEF 0x04000000
#define BT_STP 0x02000000
#define BT_ENP 0x01000000
#define TD_BUFF 0x8000
#define TD_UFLO 0x4000
#define TD_LCOL 0x1000
#define TD_LCAR 0x0800
#define TD_RTRY 0x0400
/*
* The physical memory used by the lance-host communication is
* only referenced by its virtual address. Whenever a physical address
* is needed the high-order bit is just cleared.
*/
struct ln_softc {
struct device sc_dev; /* base device glue */
struct ethercom sc_ethercom; /* Ethernet common part */
struct initblock *sc_ib; /* LANCE initblock */
caddr_t sc_memblk; /* Memory descr/buffer block */
bus_dma_tag_t sc_dmat;
bus_dmamap_t sc_dmamap;
struct buffdesc *sc_rdesc;
struct buffdesc *sc_tdesc;
int sc_first_td, sc_last_td, sc_no_td;
int sc_last_rd;
char sc_enaddr[6];
};
static inline struct mbuf *ln_get __P((struct ln_softc *, caddr_t, int));
void ln_start __P((struct ifnet *));
void ln_watchdog __P((struct ifnet *));
int ln_ioctl __P((struct ifnet *, u_long, caddr_t));
void ln_setladrf __P((struct ethercom *, u_int16_t *));
static void ln_intr __P((int));
int lnmatch __P((struct device *, struct cfdata *, void *));
void lnattach __P((struct device *, struct device *, void *));
static void ln_init __P((struct ln_softc *));
static inline int ln_put __P((struct ln_softc *, caddr_t, struct mbuf *));
static inline void ln_rint __P((struct ln_softc *));
static inline void ln_tint __P((struct ln_softc *));
static inline void ln_read __P((struct ln_softc *, caddr_t, int));
void ln_reset __P((struct ln_softc *));
static short *lance_csr; /* LANCE CSR virtual address */
static int *lance_addr; /* Ethernet address */
struct cfattach ln_ca = {
sizeof(struct ln_softc), lnmatch, lnattach
};
#define LEWRCSR(port, val) { lance_csr[2] = port; lance_csr[0] = (val); }
#define LERDCSR(port) (lance_csr[2] = port, lance_csr[0])
#define ifp (&sc->sc_ethercom.ec_if)
int
lnmatch(parent, cf, aux)
struct device *parent;
struct cfdata *cf;
void *aux;
{
struct vsbus_attach_args *va = aux;
volatile short *lance_csr = (short *)va->va_addr;
/* Make sure the chip is stopped. */
LEWRCSR(LE_CSR0, LE_C0_STOP);
DELAY(100);
LEWRCSR(LE_CSR0, LE_C0_INIT|LE_C0_INEA);
/* Wait for initialization to finish. */
DELAY(100000);
va->va_ivec = ln_intr;
/* Should have interrupted by now */
if (LERDCSR(LE_CSR0) & LE_C0_IDON)
return 1;
return 0;
}
void
lnattach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
struct vsbus_attach_args *va = aux;
struct ln_softc *sc = (void *)self;
u_int highmark;
bus_dma_segment_t seg;
int i, err, rseg;
/* Allocate the needed virtual space */
if (lance_csr == 0)
lance_csr = (short *)vax_map_physmem(NI_BASE, 1);
if (lance_addr == 0)
lance_addr = (int *)vax_map_physmem(NI_ADDR, 1);
/*
* Allocate a (DMA-safe) block for all descriptors and buffers.
*/
sc->sc_dmat = va->va_dmat;
#define ALLOCSIZ ((sizeof(struct buffdesc) + BUFSIZE) * (NRBUF + NTBUF))
err = bus_dmamem_alloc(sc->sc_dmat, ALLOCSIZ, NBPG, 0,
&seg, 1, &rseg, BUS_DMA_NOWAIT);
if (err) {
printf(": unable to alloc buffer block: err %d\n", err);
return;
}
err = bus_dmamem_map(sc->sc_dmat, &seg, rseg, ALLOCSIZ,
&sc->sc_memblk, BUS_DMA_NOWAIT|BUS_DMA_COHERENT);
if (err) {
printf(": unable to map buffer block: err %d\n", err);
bus_dmamem_free(sc->sc_dmat, &seg, rseg);
return;
}
/*
* Get the ethernet address out of rom
*/
for (i = 0; i < 6; i++)
sc->sc_enaddr[i] = (u_char)lance_addr[i];
/* Make sure the chip is stopped. */
LEWRCSR(LE_CSR0, LE_C0_STOP);
/* Initialize ifnet structure. */
bcopy(sc->sc_dev.dv_xname, ifp->if_xname, IFNAMSIZ);
ifp->if_softc = sc;
ifp->if_start = ln_start;
ifp->if_ioctl = ln_ioctl;
ifp->if_watchdog = ln_watchdog;
ifp->if_flags =
IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
/* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp, sc->sc_enaddr);
#define ALLOC(size) highmark; highmark += (int)(size)
printf("\n%s: address %s\n", self->dv_xname,
ether_sprintf(sc->sc_enaddr));
highmark = (u_int)sc->sc_memblk;
sc->sc_ib = (void *)ALLOC(sizeof(struct initblock));
bcopy(sc->sc_enaddr, sc->sc_ib->ib_padr, 6);
sc->sc_rdesc = (void *)ALLOC(sizeof(struct buffdesc) * NRBUF);
sc->sc_tdesc = (void *)ALLOC(sizeof(struct buffdesc) * NTBUF);
sc->sc_ib->ib_rdr = ((int)sc->sc_rdesc & 0xffffff) | (RLEN << 29);
sc->sc_ib->ib_tdr = ((int)sc->sc_tdesc & 0xffffff) | (TLEN << 29);
for (i = 0; i < NRBUF; i++) {
sc->sc_rdesc[i].bd_adrflg = ALLOC(BUFSIZE);
sc->sc_rdesc[i].bd_adrflg &= 0xffffff;
sc->sc_rdesc[i].bd_bcnt = -BUFSIZE;
sc->sc_rdesc[i].bd_mcnt = 0;
}
for (i = 0; i < NTBUF; i++) {
sc->sc_tdesc[i].bd_adrflg = ALLOC(BUFSIZE);
sc->sc_tdesc[i].bd_bcnt = 0xf000;
sc->sc_tdesc[i].bd_mcnt = 0;
}
#if NRND > 0
rnd_attach_source(&sc->rnd_source, sc->sc_dev.dv_xname,
RND_TYPE_NET, 0);
#endif
#if NBPFILTER > 0
bpfattach(&ifp->if_bpf, ifp, DLT_EN10MB, sizeof(struct ether_header));
#endif
/*
* Register this device as boot device if we booted from it.
* This will fail if there are more than one le in a machine,
* fortunately there may be only one.
*/
if (B_TYPE(bootdev) == BDEV_LE)
booted_from = self;
}
void
ln_reset(sc)
struct ln_softc *sc;
{
int s;
s = splimp();
ln_init(sc);
splx(s);
}
/*
* Initialization of interface; set up initialization block
* and transmit/receive descriptor rings.
*/
void
ln_init(sc)
struct ln_softc *sc;
{
int timo, i;
LEWRCSR(LE_CSR0, LE_C0_STOP);
DELAY(100);
/* Set the correct byte swapping mode, etc. */
LEWRCSR(LE_CSR3, 0);
#if NBPFILTER > 0
if (ifp->if_flags & IFF_PROMISC)
sc->sc_ib->ib_mode = LE_MODE_NORMAL | LE_MODE_PROM;
else
#endif
sc->sc_ib->ib_mode = LE_MODE_NORMAL;
ln_setladrf(&sc->sc_ethercom, sc->sc_ib->ib_ladrf);
for (i = 0; i < NRBUF; i++) {
sc->sc_rdesc[i].bd_adrflg &= 0xffffff;
sc->sc_rdesc[i].bd_adrflg |= BR_OWN;
sc->sc_rdesc[i].bd_bcnt = -BUFSIZE;
sc->sc_rdesc[i].bd_mcnt = 0;
}
for (i = 0; i < NTBUF; i++) {
sc->sc_tdesc[i].bd_adrflg &= 0xffffff;
sc->sc_tdesc[i].bd_bcnt = 0xf000;
sc->sc_tdesc[i].bd_mcnt = 0;
}
sc->sc_first_td = sc->sc_last_td = sc->sc_no_td = sc->sc_last_rd = 0;
/* Give LANCE the physical address of its init block. */
LEWRCSR(LE_CSR1, (int)sc->sc_ib & 0xffff);
LEWRCSR(LE_CSR2, ((int)sc->sc_ib >> 16) & 255);
/* Try to initialize the LANCE. */
DELAY(100);
LEWRCSR(LE_CSR0, LE_C0_INIT);
/* Wait for initialization to finish. */
for (timo = 100000; timo; timo--)
if (LERDCSR(LE_CSR0) & LE_C0_IDON)
break;
if (LERDCSR(LE_CSR0) & LE_C0_IDON) {
/* Start the LANCE. */
LEWRCSR(LE_CSR0, LE_C0_INEA | LE_C0_STRT | LE_C0_IDON);
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
ifp->if_timer = 0;
ln_start(ifp);
} else
printf("%s: card failed to initialize\n", sc->sc_dev.dv_xname);
}
/*
* Routine to copy from mbuf chain to transmit buffer in
* network buffer memory.
*/
static inline int
ln_put(sc, boff, m)
struct ln_softc *sc;
caddr_t boff;
struct mbuf *m;
{
struct mbuf *n;
int len, tlen = 0;
boff += KERNBASE;
for (; m; m = n) {
len = m->m_len;
if (len == 0) {
MFREE(m, n);
continue;
}
bcopy(mtod(m, caddr_t), boff, len);
boff += len;
tlen += len;
MFREE(m, n);
}
if (tlen < LEMINSIZE) {
bzero(boff, LEMINSIZE - tlen);
tlen = LEMINSIZE;
}
return (tlen);
}
/*
* Pull data off an interface.
* Len is length of data, with local net header stripped.
* We copy the data into mbufs. When full cluster sized units are present
* we copy into clusters.
*/
static inline struct mbuf *
ln_get(sc, boff, totlen)
struct ln_softc *sc;
caddr_t boff;
int totlen;
{
register struct mbuf *m;
struct mbuf *top, **mp;
int len;
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == 0)
return (0);
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.len = totlen;
len = MHLEN;
top = 0;
mp = &top;
boff += KERNBASE;
while (totlen > 0) {
if (top) {
MGET(m, M_DONTWAIT, MT_DATA);
if (m == 0) {
m_freem(top);
return 0;
}
len = MLEN;
}
if (totlen >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
if ((m->m_flags & M_EXT) == 0) {
m_free(m);
m_freem(top);
return 0;
}
len = MCLBYTES;
}
if (!top) {
register int pad =
ALIGN(sizeof(struct ether_header)) -
sizeof(struct ether_header);
m->m_data += pad;
len -= pad;
}
m->m_len = len = min(totlen, len);
bcopy(boff, mtod(m, caddr_t), len);
boff += len;
totlen -= len;
*mp = m;
mp = &m->m_next;
}
return (top);
}
/*
* Pass a packet to the higher levels.
*/
static inline void
ln_read(sc, boff, len)
struct ln_softc *sc;
caddr_t boff;
int len;
{
struct mbuf *m;
struct ether_header *eh;
if (len <= sizeof(struct ether_header) ||
len > ETHERMTU + sizeof(struct ether_header)) {
ifp->if_ierrors++;
return;
}
/* Pull packet off interface. */
m = ln_get(sc, boff, len);
if (m == 0) {
ifp->if_ierrors++;
return;
}
ifp->if_ipackets++;
/* We assume that the header fit entirely in one mbuf. */
eh = mtod(m, struct ether_header *);
#if NBPFILTER > 0
/*
* Check if there's a BPF listener on this interface.
* If so, hand off the raw packet to BPF.
*/
if (ifp->if_bpf) {
bpf_mtap(ifp->if_bpf, m);
/*
* Note that the interface cannot be in promiscuous mode if
* there are no BPF listeners. And if we are in promiscuous
* mode, we have to check if this packet is really ours.
*/
if ((ifp->if_flags & IFF_PROMISC) != 0 &&
(eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */
bcmp(eh->ether_dhost, sc->sc_enaddr, 6)) {
m_freem(m);
return;
}
}
#endif
/* Pass the packet up. */
(*ifp->if_input)(ifp, m);
}
static inline void
ln_rint(sc)
struct ln_softc *sc;
{
struct buffdesc *bd;
register int bix;
bix = sc->sc_last_rd;
/* Process all buffers with valid data. */
for (;;) {
bd = sc->sc_rdesc + bix;
if (bd->bd_adrflg < 0)
break;
if (bd->bd_adrflg & BR_ERR) {
if ((bd->bd_adrflg & BR_ENP) == 0) {
if (bd->bd_adrflg & BR_OFLO)
printf("%s: overflow\n",
sc->sc_dev.dv_xname);
}
if (bd->bd_adrflg & BR_BUFF)
printf("%s: receive buffer error\n",
sc->sc_dev.dv_xname);
ifp->if_ierrors++;
} else if ((bd->bd_adrflg & (BR_STP | BR_ENP)) !=
(BR_STP | BR_ENP)) {
printf("%s: dropping chained buffer\n",
sc->sc_dev.dv_xname);
ifp->if_ierrors++;
} else {
ln_read(sc, (caddr_t)(bd->bd_adrflg & 0xffffff),
bd->bd_mcnt - 4);
}
bd->bd_adrflg &= 0xffffff;
bd->bd_bcnt = -BUFSIZE;
bd->bd_mcnt = 0;
bd->bd_adrflg |= BR_OWN;
if (++bix == NRBUF)
bix = 0;
}
sc->sc_last_rd = bix;
}
static inline void
ln_tint(sc)
register struct ln_softc *sc;
{
struct buffdesc *bd;
register int bix;
bix = sc->sc_first_td;
for (;;) {
if (sc->sc_no_td <= 0)
break;
bd = sc->sc_tdesc + bix;
if (bd->bd_adrflg < 0)
break;
ifp->if_flags &= ~IFF_OACTIVE;
if (bd->bd_adrflg & BT_ERR) {
if (bd->bd_mcnt & TD_BUFF)
printf("%s: transmit buffer error\n",
sc->sc_dev.dv_xname);
else if (bd->bd_mcnt & TD_UFLO)
printf("%s: underflow\n", sc->sc_dev.dv_xname);
if (bd->bd_mcnt & (TD_BUFF | TD_UFLO)) {
ln_reset(sc);
return;
}
if (bd->bd_mcnt & TD_LCAR) {
printf("%s: lost carrier\n",
sc->sc_dev.dv_xname);
}
if (bd->bd_mcnt & TD_LCOL)
ifp->if_collisions++;
if (bd->bd_mcnt & TD_RTRY) {
printf("%s: excessive collisions, tdr %d\n",
sc->sc_dev.dv_xname,
bd->bd_mcnt & LE_T3_TDR_MASK);
ifp->if_collisions += 16;
}
ifp->if_oerrors++;
} else {
if (bd->bd_adrflg & BT_ONE)
ifp->if_collisions++;
else if (bd->bd_adrflg & BT_MORE)
/* Real number is unknown. */
ifp->if_collisions += 2;
ifp->if_opackets++;
}
if (++bix == NTBUF)
bix = 0;
--sc->sc_no_td;
}
sc->sc_first_td = bix;
ln_start(ifp);
if (sc->sc_no_td == 0)
ifp->if_timer = 0;
}
/*
* Controller interrupt.
*/
static void
ln_intr(arg)
int arg;
{
register struct ln_softc *sc = ln_cd.cd_devs[arg];
unsigned short r0;
/*
* This is the way recommended by DEC to not loose interrupts
* while handling them.
*/
r0 = LERDCSR(LE_CSR0);
r0 &= ~LE_C0_INEA;
LEWRCSR(LE_CSR0, r0);
LEWRCSR(LE_CSR0, LE_C0_INEA);
if (r0 & LE_C0_ERR) {
if (r0 & LE_C0_BABL) {
ifp->if_oerrors++;
}
if (r0 & LE_C0_MISS) {
ln_init(sc);
ifp->if_ierrors++;
}
if (r0 & LE_C0_MERR) {
printf("%s: memory error\n", sc->sc_dev.dv_xname);
ln_init(sc);
return;
}
}
if ((r0 & LE_C0_RXON) == 0) {
printf("%s: receiver disabled\n", sc->sc_dev.dv_xname);
ifp->if_ierrors++;
ln_init(sc);
return;
}
if ((r0 & LE_C0_TXON) == 0) {
printf("%s: transmitter disabled\n", sc->sc_dev.dv_xname);
ifp->if_oerrors++;
ln_init(sc);
return;
}
if (r0 & LE_C0_RINT)
ln_rint(sc);
if (r0 & LE_C0_TINT)
ln_tint(sc);
#if NRND > 0
rnd_add_uint32(&sc->rnd_source, r0);
#endif
return;
}
#undef ifp
void
ln_watchdog(ifp)
struct ifnet *ifp;
{
struct ln_softc *sc = ifp->if_softc;
log(LOG_ERR, "%s: device timeout %x\n", sc->sc_dev.dv_xname,
LERDCSR(LE_CSR0));
++ifp->if_oerrors;
ln_reset(sc);
}
/*
* Setup output on interface.
* Get another datagram to send off of the interface queue, and map it to the
* interface before starting the output.
* Called only at splimp or interrupt level.
*/
void
ln_start(ifp)
register struct ifnet *ifp;
{
register struct ln_softc *sc = ifp->if_softc;
struct buffdesc *bd;
register int bix;
register struct mbuf *m, *m0;
caddr_t addr, faddr;
int len;
if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
return;
bix = sc->sc_last_td;
for (;;) {
bd = sc->sc_tdesc + bix;
if (bd->bd_adrflg < 0) {
ifp->if_flags |= IFF_OACTIVE;
printf("missing buffer, no_td = %d, last_td = %d\n",
sc->sc_no_td, sc->sc_last_td);
}
IF_DEQUEUE(&ifp->if_snd, m);
if (m == 0)
break;
#if NBPFILTER > 0
/*
* If BPF is listening on this interface, let it see the packet
* before we commit it to the wire.
*/
if (ifp->if_bpf)
bpf_mtap(ifp->if_bpf, m);
#endif
addr = (caddr_t)(bd->bd_adrflg & 0xffffff) + KERNBASE;
m0 = m;
len = 0;
while (m0) {
faddr = mtod(m0, caddr_t);
bcopy(faddr, addr, m0->m_len);
len += m0->m_len;
addr += m0->m_len;
m0 = m0->m_next;
}
m_freem(m);
ifp->if_timer = 5;
if (len < LEMINSIZE)
bzero(addr, LEMINSIZE - len);
/*
* Init transmit registers, and set transmit start flag.
*/
bd->bd_bcnt = -max(len, LEMINSIZE);
bd->bd_mcnt = 0;
bd->bd_adrflg |= BT_OWN | BT_STP | BT_ENP;
LEWRCSR(LE_CSR0, LE_C0_INEA | LE_C0_TDMD);
if (++bix == NTBUF)
bix = 0;
if (++sc->sc_no_td == NTBUF) {
ifp->if_flags |= IFF_OACTIVE;
break;
}
}
sc->sc_last_td = bix;
}
/*
* Process an ioctl request.
*/
int
ln_ioctl(ifp, cmd, data)
register struct ifnet *ifp;
u_long cmd;
caddr_t data;
{
register struct ln_softc *sc = ifp->if_softc;
struct ifaddr *ifa = (struct ifaddr *)data;
struct ifreq *ifr = (struct ifreq *)data;
int s, error = 0;
s = splimp();
switch (cmd) {
case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
ln_init(sc);
arp_ifinit(ifp, ifa);
break;
#endif
#ifdef NS
case AF_NS:
{
register struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
if (ns_nullhost(*ina))
ina->x_host =
*(union ns_host *)LLADDR(ifp->if_sadl);
else {
bcopy(ina->x_host.c_host,
LLADDR(ifp->if_sadl),
sizeof(sc->sc_enaddr));
}
/* Set new address. */
ln_init(sc);
break;
}
#endif
default:
ln_init(sc);
break;
}
break;
#if defined(CCITT) && defined(LLC)
case SIOCSIFCONF_X25:
ifp->if_flags |= IFF_UP;
ifa->ifa_rtrequest = cons_rtrequest; /* XXX */
error = x25_llcglue(PRC_IFUP, ifa->ifa_addr);
if (error == 0)
ln_init(sc);
break;
#endif /* CCITT && LLC */
case SIOCSIFFLAGS:
if ((ifp->if_flags & IFF_UP) == 0 &&
(ifp->if_flags & IFF_RUNNING) != 0) {
/*
* If interface is marked down and it is running, then
* stop it.
*/
LEWRCSR(LE_CSR0, LE_C0_STOP);
ifp->if_flags &= ~IFF_RUNNING;
} else if ((ifp->if_flags & IFF_UP) != 0 &&
(ifp->if_flags & IFF_RUNNING) == 0) {
/*
* If interface is marked up and it is stopped, then
* start it.
*/
ln_init(sc);
} else {
/*
* Reset the interface to pick up changes in any other
* flags that affect hardware registers.
*/
/*ln_stop(sc);*/
ln_init(sc);
}
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
error = (cmd == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->sc_ethercom) :
ether_delmulti(ifr, &sc->sc_ethercom);
if (error == ENETRESET) {
/*
* Multicast list has changed; set the hardware filter
* accordingly.
*/
ln_reset(sc);
error = 0;
}
break;
default:
error = EINVAL;
break;
}
splx(s);
return (error);
}
/*
* Set up the logical address filter.
*/
void
ln_setladrf(ac, af)
struct ethercom *ac;
u_int16_t *af;
{
struct ifnet *ifp = &ac->ec_if;
struct ether_multi *enm;
register u_char *cp, c;
register u_int32_t crc;
register int i, len;
struct ether_multistep step;
/*
* Set up multicast address filter by passing all multicast addresses
* through a crc generator, and then using the high order 6 bits as an
* index into the 64 bit logical address filter. The high order bit
* selects the word, while the rest of the bits select the bit within
* the word.
*/
if (ifp->if_flags & IFF_PROMISC)
goto allmulti;
af[0] = af[1] = af[2] = af[3] = 0x0000;
ETHER_FIRST_MULTI(step, ac, enm);
while (enm != NULL) {
if (bcmp(enm->enm_addrlo, enm->enm_addrhi, 6)) {
/*
* We must listen to a range of multicast addresses.
* For now, just accept all multicasts, rather than
* trying to set only those filter bits needed to match
* the range. (At this time, the only use of address
* ranges is for IP multicast routing, for which the
* range is big enough to require all bits set.)
*/
goto allmulti;
}
cp = enm->enm_addrlo;
crc = 0xffffffff;
for (len = sizeof(enm->enm_addrlo); --len >= 0;) {
c = *cp++;
for (i = 8; --i >= 0;) {
if ((crc & 0x01) ^ (c & 0x01)) {
crc >>= 1;
crc ^= 0xedb88320;
} else
crc >>= 1;
c >>= 1;
}
}
/* Just want the 6 most significant bits. */
crc >>= 26;
/* Set the corresponding bit in the filter. */
af[crc >> 4] |= 1 << (crc & 0xf);
ETHER_NEXT_MULTI(step, enm);
}
ifp->if_flags &= ~IFF_ALLMULTI;
return;
allmulti:
ifp->if_flags |= IFF_ALLMULTI;
af[0] = af[1] = af[2] = af[3] = 0xffff;
}
Reference in New Issue View Git Blame Copy Permalink