NetBSD/sys/arch/i386/isa/if_is.c

1200 lines
26 KiB
C

/*
* Isolan AT 4141-0 Ethernet driver
* Isolink 4110
*
* Copyright (c) 1994 Charles Hannum.
*
* Copyright (C) 1993, Paul Richards. This software may be used, modified,
* copied, distributed, and sold, in both source and binary form provided
* that the above copyright and these terms are retained. Under no
* circumstances is the author responsible for the proper functioning
* of this software, nor does the author assume any responsibility
* for damages incurred with its use.
*
* $Id: if_is.c,v 1.23 1994/02/16 20:22:16 mycroft Exp $
*/
/* TODO
* 1) Advertise for more packets until all transmit buffers are full
* 2) Add more of the timers/counters e.g. arpcom.opackets etc.
*/
#include "is.h"
#include "bpfilter.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/syslog.h>
#include <sys/device.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/netisr.h>
#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#endif
#ifdef NS
#include <netns/ns.h>
#include <netns/ns_if.h>
#endif
#if NBPFILTER > 0
#include <net/bpf.h>
#include <net/bpfdesc.h>
#endif
#include <vm/vm.h>
#include <machine/cpu.h>
#include <machine/pio.h>
#include <i386/isa/isa_device.h>
#include <i386/isa/icu.h>
#include <i386/isa/if_isreg.h>
#define ETHER_MIN_LEN 64
#define ETHER_MAX_LEN 1518
#define ETHER_ADDR_LEN 6
char *card_type[] = {"unknown", "BICC Isolan", "NE2100"};
char *chip_type[] = {"unknown", "Am7990 LANCE", "Am79960 PCnet-ISA"};
/*
* Ethernet software status per interface.
*
* Each interface is referenced by a network interface structure,
* arpcom.ac_if, which the routing code uses to locate the interface.
* This structure contains the output queue for the interface, its address, ...
*/
struct is_softc {
struct device sc_dev;
struct arpcom sc_arpcom; /* Ethernet common part */
u_short sc_iobase; /* IO base address of card */
u_short sc_rap, sc_rdp;
int sc_chip, sc_card;
struct init_block *sc_init; /* Lance initialisation block */
struct mds *sc_rd, *sc_td;
u_char *sc_rbuf, *sc_tbuf;
int sc_last_rd, sc_last_td;
int sc_no_td;
#ifdef ISDEBUG
int sc_debug;
#endif
caddr_t sc_bpf; /* BPF "magic cookie" */
} is_softc[NIS];
int is_probe __P((struct isa_device *));
int ne2100_probe __P((struct isa_device *, struct is_softc *));
int bicc_probe __P((struct isa_device *, struct is_softc *));
int lance_probe __P((struct is_softc *));
int is_attach __P((struct isa_device *));
int isintr __P((int)); /* XXX can't be renamed till new interrupt code */
int is_ioctl __P((struct ifnet *, int, caddr_t));
int is_start __P((struct ifnet *));
int is_watchdog __P((/* short */));
void iswrcsr __P((/* struct is_softc *, u_short, u_short */));
u_short isrdcsr __P((/* struct is_softc *, u_short */));
void is_init __P((struct is_softc *));
void init_mem __P((struct is_softc *));
void is_reset __P((struct is_softc *));
void is_stop __P((struct is_softc *));
void is_tint __P((struct is_softc *));
void is_rint __P((struct is_softc *));
void is_read __P((/* struct is_softc *, u_char *, u_short */));
struct mbuf *is_get __P((u_char *, int, int, struct ifnet *));
#ifdef ISDEBUG
void recv_print __P((struct is_softc *, int));
void xmit_print __P((struct is_softc *, int));
#endif
void is_setladrf __P((struct arpcom *, u_long *));
struct isa_driver isdriver = {
is_probe,
is_attach,
"is"
};
struct trailer_header {
u_short ether_type;
u_short ether_residual;
};
void
iswrcsr(sc, port, val)
struct is_softc *sc;
u_short port;
u_short val;
{
outw(sc->sc_rap, port);
outw(sc->sc_rdp, val);
}
u_short
isrdcsr(sc, port)
struct is_softc *sc;
u_short port;
{
outw(sc->sc_rap, port);
return inw(sc->sc_rdp);
}
int
is_probe(isa_dev)
struct isa_device *isa_dev;
{
int unit = isa_dev->id_unit;
register struct is_softc *sc = &is_softc[unit];
int nports;
/* XXX HACK */
sprintf(sc->sc_dev.dv_xname, "%s%d", isdriver.name, isa_dev->id_unit);
sc->sc_dev.dv_unit = isa_dev->id_unit;
if (nports = bicc_probe(isa_dev, sc))
goto found;
if (nports = ne2100_probe(isa_dev, sc))
goto found;
return 0;
found:
/*
* XXX - hopefully have better way to get dma'able memory later,
* this code assumes that the physical memory address returned
* from malloc will be below 16Mb. The Lance's address registers
* are only 16 bits wide!
*/
#define MAXMEM ((NRBUF+NTBUF)*(BUFSIZE) + (NRBUF+NTBUF)*sizeof(struct mds) \
+ sizeof(struct init_block) + 8)
sc->sc_init = (struct init_block *)malloc(MAXMEM, M_TEMP, M_NOWAIT);
if (!sc->sc_init) {
printf("%s: couldn't allocate memory for card\n",
sc->sc_dev.dv_xname);
return 0;
}
/*
* Make sure it's quadword aligned? This is kind of bogus, but
* what the Hell...
*/
sc->sc_init += 8 - ((u_long)sc->sc_init & 7);
return nports;
}
int
ne2100_probe(isa_dev, sc)
struct isa_device *isa_dev;
struct is_softc *sc;
{
u_short iobase = isa_dev->id_iobase;
int i;
sc->sc_iobase = iobase;
sc->sc_rap = iobase + NE2100_RAP;
sc->sc_rdp = iobase + NE2100_RDP;
sc->sc_card = NE2100;
if (!(sc->sc_chip = lance_probe(sc)))
return 0;
/*
* Extract the physical MAC address from the ROM.
*/
for (i = 0; i < ETHER_ADDR_LEN; i++)
sc->sc_arpcom.ac_enaddr[i] = inb(iobase + i);
return 24;
}
int
bicc_probe(isa_dev, sc)
struct isa_device *isa_dev;
struct is_softc *sc;
{
u_short iobase = isa_dev->id_iobase;
int i;
sc->sc_iobase = iobase;
sc->sc_rap = iobase + BICC_RAP;
sc->sc_rdp = iobase + BICC_RDP;
sc->sc_card = BICC;
if (!(sc->sc_chip = lance_probe(sc)))
return 0;
/*
* Extract the physical MAC address from the ROM.
*/
for (i = 0; i < ETHER_ADDR_LEN; i++)
sc->sc_arpcom.ac_enaddr[i] = inb(iobase + (i * 2));
return 16;
}
/*
* Determine which chip is present on the card.
*/
int
lance_probe(sc)
struct is_softc *sc;
{
int type;
/* Stop the LANCE chip and put it in a known state. */
iswrcsr(sc, 0, STOP);
DELAY(100);
if (isrdcsr(sc, 0) != STOP)
return 0;
/*
* Which bits are settable will depend on the type of chip.
*/
iswrcsr(sc, 3, PROBE_MASK);
switch (isrdcsr(sc, 3)) {
case LANCE_MASK:
type = LANCE;
break;
case PCnet_ISA_MASK:
type = PCnet_ISA;
break;
default:
type = 0;
break;
}
iswrcsr(sc, 3, 0);
return type;
}
/*
* Interface exists: make available by filling in network interface
* record. System will initialize the interface when it is ready
* to accept packets. We get the ethernet address here.
*/
int
is_attach(isa_dev)
struct isa_device *isa_dev;
{
struct is_softc *sc = &is_softc[isa_dev->id_unit];
struct ifnet *ifp = &sc->sc_arpcom.ac_if;
struct ifaddr *ifa;
struct sockaddr_dl *sdl;
ifp->if_unit = sc->sc_dev.dv_unit;
ifp->if_name = isdriver.name;
ifp->if_mtu = ETHERMTU;
ifp->if_output = ether_output;
ifp->if_start = is_start;
ifp->if_ioctl = is_ioctl;
ifp->if_watchdog = is_watchdog;
ifp->if_flags =
IFF_BROADCAST | IFF_SIMPLEX | IFF_NOTRAILERS | IFF_MULTICAST;
isa_dmacascade(isa_dev->id_drq);
/* Attach the interface. */
if_attach(ifp);
/*
* Search down the ifa address list looking for the AF_LINK type entry.
*/
ifa = ifp->if_addrlist;
while (ifa && ifa->ifa_addr) {
if (ifa->ifa_addr->sa_family == AF_LINK) {
/*
* Fill in the link level address for this interface.
*/
sdl = (struct sockaddr_dl *)ifa->ifa_addr;
sdl->sdl_type = IFT_ETHER;
sdl->sdl_alen = ETHER_ADDR_LEN;
sdl->sdl_slen = 0;
bcopy(sc->sc_arpcom.ac_enaddr, LLADDR(sdl),
ETHER_ADDR_LEN);
break;
} else
ifa = ifa->ifa_next;
}
printf("%s: address %s, type %s %s\n", sc->sc_dev.dv_xname,
ether_sprintf(sc->sc_arpcom.ac_enaddr),
card_type[sc->sc_card], chip_type[sc->sc_chip]);
#if NBPFILTER > 0
bpfattach(&sc->sc_bpf, ifp, DLT_EN10MB, sizeof(struct ether_header));
#endif
}
void
is_reset(sc)
struct is_softc *sc;
{
log(LOG_NOTICE, "%s: reset\n", sc->sc_dev.dv_xname);
is_init(sc);
}
int
is_watchdog(unit)
short unit;
{
struct is_softc *sc = &is_softc[unit];
log(LOG_ERR, "%s: device timeout\n", sc->sc_dev.dv_xname);
++sc->sc_arpcom.ac_if.if_oerrors;
is_reset(sc);
}
/* Lance initialisation block set up. */
void
init_mem(sc)
struct is_softc *sc;
{
struct ifnet *ifp = &sc->sc_arpcom.ac_if;
int i;
void *temp;
/*
* At this point we assume that the memory allocated to the Lance is
* quadword aligned. If it isn't then the initialisation is going
* fail later on.
*/
/*
* Set up lance initialisation block.
*/
temp = (void *)sc->sc_init;
temp += sizeof(struct init_block);
sc->sc_rd = temp;
temp += NRBUF * sizeof(struct mds);
sc->sc_td = temp;
temp += NTBUF * sizeof(struct mds);
#if NBPFILTER > 0
if (ifp->if_flags & IFF_PROMISC)
sc->sc_init->mode = PROM;
else
#endif
sc->sc_init->mode = 0;
for (i = 0; i < ETHER_ADDR_LEN; i++)
sc->sc_init->padr[i] = sc->sc_arpcom.ac_enaddr[i];
is_setladrf(&sc->sc_arpcom, sc->sc_init->ladrf);
sc->sc_init->rdra = kvtop(sc->sc_rd);
sc->sc_init->rlen = ((kvtop(sc->sc_rd) >> 16) & 0xff) | (RLEN << 13);
sc->sc_init->tdra = kvtop(sc->sc_td);
sc->sc_init->tlen = ((kvtop(sc->sc_td) >> 16) & 0xff) | (TLEN << 13);
/*
* Set up receive ring descriptors.
*/
sc->sc_rbuf = temp;
for (i = 0; i < NRBUF; i++) {
sc->sc_rd[i].addr = kvtop(temp);
sc->sc_rd[i].flags = ((kvtop(temp) >> 16) & 0xff) | OWN;
sc->sc_rd[i].bcnt = -BUFSIZE;
sc->sc_rd[i].mcnt = 0;
temp += BUFSIZE;
}
/*
* Set up transmit ring descriptors.
*/
sc->sc_tbuf = temp;
for (i = 0; i < NTBUF; i++) {
sc->sc_td[i].addr = kvtop(temp);
sc->sc_td[i].flags= ((kvtop(temp) >> 16) & 0xff);
sc->sc_td[i].bcnt = 0;
sc->sc_td[i].mcnt = 0;
temp += BUFSIZE;
}
}
void
is_stop(sc)
struct is_softc *sc;
{
iswrcsr(sc, 0, STOP);
}
/*
* Initialization of interface; set up initialization block
* and transmit/receive descriptor rings.
*/
void
is_init(sc)
struct is_softc *sc;
{
struct ifnet *ifp = &sc->sc_arpcom.ac_if;
int s;
register i;
/* Address not known. */
if (!ifp->if_addrlist)
return;
s = splnet();
/*
* Lance must be stopped to access registers.
*/
is_stop(sc);
sc->sc_last_rd = sc->sc_last_td = sc->sc_no_td = 0;
/* Set up lance's memory area. */
init_mem(sc);
/* No byte swapping etc. */
iswrcsr(sc, 3, 0);
/* Give lance the physical address of its memory area. */
iswrcsr(sc, 1, kvtop(sc->sc_init));
iswrcsr(sc, 2, (kvtop(sc->sc_init) >> 16) & 0xff);
/* OK, let's try and initialise the Lance. */
iswrcsr(sc, 0, INIT);
/* Wait for initialisation to finish. */
for (i = 0; i < 1000; i++)
if (isrdcsr(sc, 0) & IDON)
break;
if (isrdcsr(sc, 0) & IDON) {
/* Start the lance. */
iswrcsr(sc, 0, STRT | IDON | INEA);
ifp->if_flags |= IFF_RUNNING;
ifp->if_flags &= ~IFF_OACTIVE;
is_start(ifp);
} else
printf("%s: card failed to initialise\n", sc->sc_dev.dv_xname);
(void) splx(s);
}
/*
* 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.
*/
int
is_start(ifp)
struct ifnet *ifp;
{
register struct is_softc *sc = &is_softc[ifp->if_unit];
struct mbuf *m0, *m;
u_char *buffer;
int len;
int i;
struct mds *cdm;
if ((sc->sc_arpcom.ac_if.if_flags ^ IFF_RUNNING) &
(IFF_RUNNING | IFF_OACTIVE))
return;
outloop:
if (++sc->sc_no_td > NTBUF) {
sc->sc_no_td = NTBUF;
sc->sc_arpcom.ac_if.if_flags |= IFF_OACTIVE;
#ifdef ISDEBUG
if (sc->sc_debug)
printf("no_td = %x, last_td = %x\n", sc->sc_no_td,
sc->sc_last_td);
#endif
return;
}
cdm = &sc->sc_td[sc->sc_last_td];
#if 0 /* XXX redundant */
if (cdm->flags & OWN)
return;
#endif
IF_DEQUEUE(&sc->sc_arpcom.ac_if.if_snd, m);
if (!m)
return;
/*
* Copy the mbuf chain into the transmit buffer.
*/
buffer = sc->sc_tbuf + (BUFSIZE * sc->sc_last_td);
len = 0;
for (m0 = m; m; m = m->m_next) {
bcopy(mtod(m, caddr_t), buffer, m->m_len);
buffer += m->m_len;
len += m->m_len;
}
#if NBPFILTER > 0
if (sc->sc_bpf) {
u_short etype;
int off, datasize, resid;
struct ether_header *eh;
struct trailer_header trailer_header;
char ether_packet[ETHER_MAX_LEN];
char *ep;
ep = ether_packet;
/*
* We handle trailers below:
* Copy ether header first, then residual data, then data. Put
* all this in a temporary buffer 'ether_packet' and send off
* to bpf. Since the system has generated this packet, we
* assume that all of the offsets in the packet are correct; if
* they're not, the system will almost certainly crash in
* m_copydata. We make no assumptions about how the data is
* arranged in the mbuf chain (i.e. how much data is in each
* mbuf, if mbuf clusters are used, etc.), which is why we use
* m_copydata to get the ether header rather than assume that
* this is located in the first mbuf.
*/
/* Copy ether header. */
m_copydata(m0, 0, sizeof(struct ether_header), ep);
eh = (struct ether_header *) ep;
ep += sizeof(struct ether_header);
etype = ntohs(eh->ether_type);
if (etype >= ETHERTYPE_TRAIL &&
etype < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
datasize = (etype - ETHERTYPE_TRAIL) << 9;
off = datasize + sizeof(struct ether_header);
/* Copy trailer_header into a data structure. */
m_copydata(m0, off, sizeof(struct trailer_header),
&trailer_header.ether_type);
/* Copy residual data. */
m_copydata(m0, off + sizeof(struct trailer_header),
resid = ntohs(trailer_header.ether_residual) -
sizeof(struct trailer_header), ep);
ep += resid;
/* Copy data. */
m_copydata(m0, sizeof(struct ether_header), datasize,
ep);
ep += datasize;
/* Restore original ether packet type. */
eh->ether_type = trailer_header.ether_type;
bpf_tap(sc->sc_bpf, ether_packet, ep - ether_packet);
} else
bpf_mtap(sc->sc_bpf, m0);
}
#endif
m_freem(m0);
len = max(len, ETHER_MIN_LEN);
/*
* Init transmit registers, and set transmit start flag.
*/
cdm->flags |= OWN | STP | ENP;
cdm->bcnt = -len;
cdm->mcnt = 0;
#ifdef ISDEBUG
if (sc->sc_debug)
xmit_print(sc, sc->sc_last_td);
#endif
iswrcsr(sc, 0, TDMD | INEA);
if (++sc->sc_last_td >= NTBUF)
sc->sc_last_td = 0;
/* possible more packets */
goto outloop;
}
/*
* Controller interrupt.
*/
int
isintr(unit)
{
register struct is_softc *sc = &is_softc[unit];
u_short isr;
isr = isrdcsr(sc, 0);
if ((isr & INTR) == 0)
return 0;
do {
if (isr & ERR) {
if (isr & BABL){
printf("%s: BABL\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_oerrors++;
}
if (isr & CERR) {
printf("%s: CERR\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_collisions++;
}
if (isr & MISS) {
printf("%s: MISS\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_ierrors++;
}
if (isr & MERR)
printf("%s: MERR\n", sc->sc_dev.dv_xname);
iswrcsr(sc, 0, BABL | CERR | MISS | MERR | INEA);
}
if ((isr & RXON) == 0) {
printf("%s: !RXON\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_ierrors++;
is_reset(sc);
return 1;
}
if ((isr & TXON) == 0) {
printf("%s: !TXON\n", sc->sc_dev.dv_xname);
sc->sc_arpcom.ac_if.if_oerrors++;
is_reset(sc);
return 1;
}
if (isr & RINT) {
/* Reset watchdog timer. */
sc->sc_arpcom.ac_if.if_timer = 0;
is_rint(sc);
}
if (isr & TINT) {
/* Reset watchdog timer. */
sc->sc_arpcom.ac_if.if_timer = 0;
iswrcsr(sc, 0, TINT | INEA);
is_tint(sc);
}
isr = isrdcsr(sc, 0);
} while (isr & INTR);
return 1;
}
void
is_tint(sc)
struct is_softc *sc;
{
register struct ifnet *ifp = &sc->sc_arpcom.ac_if;
int i, loopcount=0;
struct mds *cdm;
do {
if ((i = sc->sc_last_td - sc->sc_no_td) < 0)
i += NTBUF;
cdm = &sc->sc_td[i];
#ifdef ISDEBUG
if (sc->sc_debug)
printf("trans cdm = %x\n", cdm);
#endif
if (cdm->flags & OWN) {
if (loopcount)
break;
return;
}
loopcount++;
sc->sc_arpcom.ac_if.if_opackets++;
sc->sc_arpcom.ac_if.if_flags &= ~IFF_OACTIVE;
} while (--sc->sc_no_td > 0);
is_start(ifp);
}
#define NEXTRDS \
if (++rmd == NRBUF) rmd=0, cdm=sc->sc_rd; else ++cdm
/* only called from one place, so may as well integrate */
void
is_rint(sc)
struct is_softc *sc;
{
register int rmd = sc->sc_last_rd;
struct mds *cdm = &sc->sc_rd[rmd];
/* Out of sync with hardware, should never happen */
if (cdm->flags & OWN) {
printf("%s: error: out of sync\n", sc->sc_dev.dv_xname);
iswrcsr(sc, 0, RINT|INEA);
return;
}
/* Process all buffers with valid data. */
while ((cdm->flags & OWN) == 0) {
/* Clear interrupt to avoid race condition. */
iswrcsr(sc, 0, RINT | INEA);
if (cdm->flags & ERR) {
if (cdm->flags & FRAM)
printf("%s: FRAM\n", sc->sc_dev.dv_xname);
if (cdm->flags & OFLO)
printf("%s: OFLO\n", sc->sc_dev.dv_xname);
if (cdm->flags & CRC)
printf("%s: CRC\n", sc->sc_dev.dv_xname);
if (cdm->flags & RBUFF)
printf("%s: RBUFF\n", sc->sc_dev.dv_xname);
} else if (cdm->flags & (STP | ENP) != (STP | ENP)) {
do {
iswrcsr(sc, 0, RINT | INEA);
cdm->mcnt = 0;
cdm->flags |= OWN;
NEXTRDS;
} while ((cdm->flags & (OWN | ERR | STP | ENP)) == 0);
sc->sc_last_rd = rmd;
printf("%s: chained buffer\n", sc->sc_dev.dv_xname);
if ((cdm->flags & (OWN | ERR | STP | ENP)) != ENP) {
is_reset(sc);
return;
}
} else {
#ifdef ISDEBUG
if (sc->sc_debug)
recv_print(sc, sc->sc_last_rd);
#endif
is_read(sc, sc->sc_rbuf + (BUFSIZE*rmd),
(int)cdm->mcnt);
sc->sc_arpcom.ac_if.if_ipackets++;
}
cdm->flags |= OWN;
cdm->mcnt = 0;
NEXTRDS;
#ifdef ISDEBUG
if (sc->sc_debug)
printf("sc->sc_last_rd = %x, cdm = %x\n",
sc->sc_last_rd, cdm);
#endif
} /* while */
sc->sc_last_rd = rmd;
} /* is_rint */
/*
* Pass a packet to the higher levels.
* We deal with the trailer protocol here.
*/
void
is_read(sc, buf, len)
struct is_softc *sc;
u_char *buf;
u_short len;
{
struct ether_header *eh;
struct mbuf *m;
u_short off;
int resid;
u_short etype;
/*
* Deal with trailer protocol: if type is trailer type
* get true type from first 16-bit word past data.
* Remember that type was trailer by setting off.
*/
eh = (struct ether_header *)buf;
etype = ntohs(eh->ether_type);
len -= sizeof(struct ether_header) + 4;
#define nedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
if (etype >= ETHERTYPE_TRAIL &&
etype < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
off = (etype - ETHERTYPE_TRAIL) << 9;
if ((off + sizeof(struct trailer_header)) > len)
return;
eh->ether_type = *nedataaddr(eh, off, u_short *);
resid = ntohs(*(nedataaddr(eh, off+2, u_short *)));
if (off + resid > len)
return;
len = off + resid;
} else
off = 0;
if (len == 0)
return;
/*
* Pull packet off interface. Off is nonzero if packet has trailing
* header; is_get will then force this header information to be at the
* front, but we still have to drop the type and length which are at
* the front of any trailer data.
*/
m = is_get(buf, len, off, &sc->sc_arpcom.ac_if);
if (m == 0)
return;
#if NBPFILTER > 0
/*
* Check if there's a BPF listener on this interface.
* If so, hand off the raw packet to bpf.
*/
if (sc->sc_bpf) {
bpf_mtap(sc->sc_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.
*
* XXX This test does not support multicasts.
*/
if ((sc->sc_arpcom.ac_if.if_flags & IFF_PROMISC) &&
(eh->ether_dhost[0] & 1) == 0 && /* !mcast and !bcast */
bcmp(eh->ether_dhost, sc->sc_arpcom.ac_enaddr,
sizeof(eh->ether_dhost)) != 0) {
m_freem(m);
return;
}
}
#endif
ether_input(&sc->sc_arpcom.ac_if, eh, m);
}
/*
* Supporting routines
*/
/*
* Pull read data off a interface.
* Len is length of data, with local net header stripped.
* Off is non-zero if a trailer protocol was used, and
* gives the offset of the trailer information.
* We copy the trailer information and then all the normal
* data into mbufs. When full cluster sized units are present
* we copy into clusters.
*/
struct mbuf *
is_get(buf, totlen, off0, ifp)
u_char *buf;
int totlen, off0;
struct ifnet *ifp;
{
struct mbuf *top, **mp, *m, *p;
int off = off0, len;
register caddr_t cp = buf;
char *epkt;
buf += sizeof(struct ether_header);
cp = buf;
epkt = cp + totlen;
if (off) {
cp += off + 2 * sizeof(u_short);
totlen -= 2 * sizeof(u_short);
}
MGETHDR(m, M_DONTWAIT, MT_DATA);
if (m == 0)
return 0;
m->m_pkthdr.rcvif = ifp;
m->m_pkthdr.len = totlen;
m->m_len = MHLEN;
top = 0;
mp = &top;
while (totlen > 0) {
if (top) {
MGET(m, M_DONTWAIT, MT_DATA);
if (m == 0) {
m_freem(top);
return 0;
}
m->m_len = MLEN;
}
len = min(totlen, epkt - cp);
if (len >= MINCLSIZE) {
MCLGET(m, M_DONTWAIT);
if (m->m_flags & M_EXT)
m->m_len = len = min(len, MCLBYTES);
else
len = m->m_len;
} else {
/*
* Place initial small packet/header at end of mbuf.
*/
if (len < m->m_len) {
if (top == 0 && len + max_linkhdr <= m->m_len)
m->m_data += max_linkhdr;
m->m_len = len;
} else
len = m->m_len;
}
bcopy(cp, mtod(m, caddr_t), (unsigned)len);
cp += len;
*mp = m;
mp = &m->m_next;
totlen -= len;
if (cp == epkt)
cp = buf;
}
return top;
}
/*
* Process an ioctl request.
*/
int
is_ioctl(ifp, cmd, data)
struct ifnet *ifp;
int cmd;
caddr_t data;
{
struct is_softc *sc = &is_softc[ifp->if_unit];
struct ifaddr *ifa = (struct ifaddr *)data;
struct ifreq *ifr = (struct ifreq *)data;
int s, error = 0;
s = splnet();
switch (cmd) {
case SIOCSIFADDR:
ifp->if_flags |= IFF_UP;
switch (ifa->ifa_addr->sa_family) {
#ifdef INET
case AF_INET:
is_init(sc); /* before arpwhohas */
/*
* See if another station has *our* IP address.
* i.e.: There is an address conflict! If a
* conflict exists, a message is sent to the
* console.
*/
sc->sc_arpcom.ac_ipaddr = IA_SIN(ifa)->sin_addr;
arpwhohas(&sc->sc_arpcom, &IA_SIN(ifa)->sin_addr);
break;
#endif
#ifdef NS
/* XXX - This code is probably wrong. */
case AF_NS:
{
register struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
if (ns_nullhost(*ina))
ina->x_host =
*(union ns_host *)(sc->sc_arpcom.ac_enaddr);
else {
/*
*
*/
bcopy(ina->x_host.c_host,
sc->sc_arpcom.ac_enaddr,
sizeof(sc->sc_arpcom.ac_enaddr));
}
/* Set new address. */
is_init(sc);
break;
}
#endif
default:
is_init(sc);
break;
}
break;
case SIOCSIFFLAGS:
/*
* If interface is marked down and it is running, then stop it
*/
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.
*/
is_stop(sc);
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.
*/
is_init(sc);
} else {
/*
* Reset the interface to pick up changes in any other
* flags that affect hardware registers.
*/
/*is_stop(sc);*/
is_init(sc);
}
#ifdef ISDEBUG
if (ifp->if_flags & IFF_DEBUG)
sc->sc_debug = 1;
else
sc->sc_debug = 0;
#endif
break;
case SIOCADDMULTI:
case SIOCDELMULTI:
error = (cmd == SIOCADDMULTI) ?
ether_addmulti(ifr, &sc->sc_arpcom):
ether_delmulti(ifr, &sc->sc_arpcom);
if (error == ENETRESET) {
/*
* Multicast list has changed; set the hardware filter
* accordingly.
*/
is_init(sc);
error = 0;
}
break;
#ifdef notdef
case SIOCGHWADDR:
bcopy(sc->sc_arpcom.ac_enaddr, &ifr->ifr_data,
sizeof(sc->sc_arpcom.ac_enaddr));
break;
#endif
default:
error = EINVAL;
}
(void) splx(s);
return error;
}
#ifdef ISDEBUG
void
recv_print(sc, no)
struct is_softc *sc;
int no;
{
struct mds *rmd;
int i, printed = 0;
u_short len;
rmd = &sc->sc_rd[no];
len = rmd->mcnt;
printf("%s: receive buffer %d, len = %d\n", sc->sc_dev.dv_xname, no,
len);
printf("%s: status %x\n", sc->sc_dev.dv_xname, isrdcsr(sc, 0));
for (i = 0; i < len; i++) {
if (!printed) {
printed = 1;
printf("%s: data: ", sc->sc_dev.dv_xname);
}
printf("%x ", *(sc->sc_rbuf + (BUFSIZE*no) + i));
}
if (printed)
printf("\n");
}
void
xmit_print(sc, no)
struct is_softc *sc;
int no;
{
struct mds *rmd;
int i, printed=0;
u_short len;
rmd = &sc->sc_td[no];
len = -rmd->bcnt;
printf("%s: transmit buffer %d, len = %d\n", sc->sc_dev.dv_xname, no,
len);
printf("%s: status %x\n", sc->sc_dev.dv_xname, isrdcsr(sc, 0));
printf("%s: addr %x, flags %x, bcnt %x, mcnt %x\n",
sc->sc_dev.dv_xname, rmd->addr, rmd->flags, rmd->bcnt, rmd->mcnt);
for (i = 0; i < len; i++) {
if (!printed) {
printed = 1;
printf("%s: data: ", sc->sc_dev.dv_xname);
}
printf("%x ", *(sc->sc_tbuf + (BUFSIZE*no) + i));
}
if (printed)
printf("\n");
}
#endif /* ISDEBUG */
/*
* Set up the logical address filter.
*/
void
is_setladrf(ac, af)
struct arpcom *ac;
u_long *af;
{
struct ifnet *ifp = &ac->ac_if;
struct ether_multi *enm;
register u_char *cp, c;
register u_long 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) {
ifp->if_flags |= IFF_ALLMULTI;
af[0] = af[1] = 0xffffffff;
return;
}
af[0] = af[1] = 0;
ETHER_FIRST_MULTI(step, ac, enm);
while (enm != NULL) {
if (bcmp(enm->enm_addrlo, enm->enm_addrhi,
sizeof(enm->enm_addrlo)) != 0) {
/*
* 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.)
*/
ifp->if_flags |= IFF_ALLMULTI;
af[0] = af[1] = 0xffffffff;
return;
}
cp = enm->enm_addrlo;
crc = 0xffffffff;
for (len = sizeof(enm->enm_addrlo); --len >= 0;) {
c = *cp++;
for (i = 8; --i >= 0;) {
if (((crc & 0x80000000) ? 1 : 0) ^ (c & 0x01)) {
crc <<= 1;
crc ^= 0x04c11db6 | 1;
} else
crc <<= 1;
c >>= 1;
}
}
/* Just want the 6 most significant bits. */
crc >>= 26;
/* Turn on the corresponding bit in the filter. */
af[crc >> 5] |= 1 << ((crc & 0x1f) ^ 24);
ETHER_NEXT_MULTI(step, enm);
}
ifp->if_flags &= ~IFF_ALLMULTI;
}