123503Ssklower /*
240842Ssklower * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
335316Sbostic * All rights reserved.
423503Ssklower *
544557Sbostic * %sccs.include.redist.c%
635316Sbostic *
7*45801Sbostic * @(#)if_de.c 7.12 (Berkeley) 12/16/90
823503Ssklower */
935316Sbostic
1015357Skarels #include "de.h"
1115357Skarels #if NDE > 0
1215357Skarels
1315357Skarels /*
1415357Skarels * DEC DEUNA interface
1515357Skarels *
1615357Skarels * Lou Salkind
1715357Skarels * New York University
1815357Skarels *
1915357Skarels * TODO:
2015357Skarels * timeout routine (get statistics)
2115357Skarels */
22*45801Sbostic #include "../include/pte.h"
2315357Skarels
24*45801Sbostic #include "sys/param.h"
25*45801Sbostic #include "sys/systm.h"
26*45801Sbostic #include "sys/mbuf.h"
27*45801Sbostic #include "sys/buf.h"
28*45801Sbostic #include "sys/protosw.h"
29*45801Sbostic #include "sys/socket.h"
30*45801Sbostic #include "sys/vmmac.h"
31*45801Sbostic #include "sys/ioctl.h"
32*45801Sbostic #include "sys/errno.h"
33*45801Sbostic #include "sys/syslog.h"
3415357Skarels
35*45801Sbostic #include "net/if.h"
36*45801Sbostic #include "net/netisr.h"
37*45801Sbostic #include "net/route.h"
3823503Ssklower
3923503Ssklower #ifdef INET
40*45801Sbostic #include "netinet/in.h"
41*45801Sbostic #include "netinet/in_systm.h"
42*45801Sbostic #include "netinet/in_var.h"
43*45801Sbostic #include "netinet/ip.h"
44*45801Sbostic #include "netinet/if_ether.h"
4523503Ssklower #endif
4623503Ssklower
4723503Ssklower #ifdef NS
48*45801Sbostic #include "netns/ns.h"
49*45801Sbostic #include "netns/ns_if.h"
5023503Ssklower #endif
5123503Ssklower
5237476Ssklower #ifdef ISO
53*45801Sbostic #include "netiso/iso.h"
54*45801Sbostic #include "netiso/iso_var.h"
5543337Ssklower extern char all_es_snpa[], all_is_snpa[];
5637476Ssklower #endif
5737476Ssklower
58*45801Sbostic #include "../include/cpu.h"
59*45801Sbostic #include "../include/mtpr.h"
6017110Sbloom #include "if_dereg.h"
6117110Sbloom #include "if_uba.h"
62*45801Sbostic #include "../uba/ubareg.h"
63*45801Sbostic #include "../uba/ubavar.h"
6415357Skarels
6523559Ssklower #define NXMT 3 /* number of transmit buffers */
6623559Ssklower #define NRCV 7 /* number of receive buffers (must be > 1) */
6715357Skarels
6816279Skarels int dedebug = 0;
6915916Skarels
7015357Skarels int deprobe(), deattach(), deintr();
7115357Skarels struct uba_device *deinfo[NDE];
7215357Skarels u_short destd[] = { 0 };
7315357Skarels struct uba_driver dedriver =
7415357Skarels { deprobe, 0, deattach, 0, destd, "de", deinfo };
7537187Ssklower int deinit(),ether_output(),deioctl(),dereset(),destart();
7615357Skarels
7715357Skarels
7815357Skarels /*
7915357Skarels * Ethernet software status per interface.
8015357Skarels *
8115357Skarels * Each interface is referenced by a network interface structure,
8215357Skarels * ds_if, which the routing code uses to locate the interface.
8315357Skarels * This structure contains the output queue for the interface, its address, ...
8415357Skarels * We also have, for each interface, a UBA interface structure, which
8515357Skarels * contains information about the UNIBUS resources held by the interface:
8615357Skarels * map registers, buffered data paths, etc. Information is cached in this
8715357Skarels * structure for use by the if_uba.c routines in running the interface
8815357Skarels * efficiently.
8915357Skarels */
9015357Skarels struct de_softc {
9115357Skarels struct arpcom ds_ac; /* Ethernet common part */
9215357Skarels #define ds_if ds_ac.ac_if /* network-visible interface */
9315357Skarels #define ds_addr ds_ac.ac_enaddr /* hardware Ethernet address */
9415357Skarels int ds_flags;
9525448Skarels #define DSF_RUNNING 2 /* board is enabled */
9625448Skarels #define DSF_SETADDR 4 /* physical address is changed */
9715357Skarels int ds_ubaddr; /* map info for incore structs */
9824795Skarels struct ifubinfo ds_deuba; /* unibus resource structure */
9924795Skarels struct ifrw ds_ifr[NRCV]; /* unibus receive maps */
10024795Skarels struct ifxmt ds_ifw[NXMT]; /* unibus xmt maps */
10115357Skarels /* the following structures are always mapped in */
10215357Skarels struct de_pcbb ds_pcbb; /* port control block */
10315357Skarels struct de_ring ds_xrent[NXMT]; /* transmit ring entrys */
10415357Skarels struct de_ring ds_rrent[NRCV]; /* receive ring entrys */
10515357Skarels struct de_udbbuf ds_udbbuf; /* UNIBUS data buffer */
10615357Skarels /* end mapped area */
10715357Skarels #define INCORE_BASE(p) ((char *)&(p)->ds_pcbb)
10815357Skarels #define RVAL_OFF(n) ((char *)&de_softc[0].n - INCORE_BASE(&de_softc[0]))
10915357Skarels #define LVAL_OFF(n) ((char *)de_softc[0].n - INCORE_BASE(&de_softc[0]))
11015357Skarels #define PCBB_OFFSET RVAL_OFF(ds_pcbb)
11115357Skarels #define XRENT_OFFSET LVAL_OFF(ds_xrent)
11215357Skarels #define RRENT_OFFSET LVAL_OFF(ds_rrent)
11315357Skarels #define UDBBUF_OFFSET RVAL_OFF(ds_udbbuf)
11415357Skarels #define INCORE_SIZE RVAL_OFF(ds_xindex)
11515357Skarels int ds_xindex; /* UNA index into transmit chain */
11615357Skarels int ds_rindex; /* UNA index into receive chain */
11715357Skarels int ds_xfree; /* index for next transmit buffer */
11815357Skarels int ds_nxmit; /* # of transmits in progress */
11915357Skarels } de_softc[NDE];
12015357Skarels
deprobe(reg)12115357Skarels deprobe(reg)
12215357Skarels caddr_t reg;
12315357Skarels {
12415357Skarels register int br, cvec; /* r11, r10 value-result */
12515357Skarels register struct dedevice *addr = (struct dedevice *)reg;
12615357Skarels register i;
12715357Skarels
12815357Skarels #ifdef lint
12915357Skarels br = 0; cvec = br; br = cvec;
13015357Skarels i = 0; derint(i); deintr(i);
13115357Skarels #endif
13215357Skarels
13329572Skarels /*
13429572Skarels * Make sure self-test is finished before we screw with the board.
13529572Skarels * Self-test on a DELUA can take 15 seconds (argh).
13629572Skarels */
13729572Skarels for (i = 0;
13829572Skarels i < 160 &&
13929572Skarels (addr->pcsr0 & PCSR0_FATI) == 0 &&
14029572Skarels (addr->pcsr1 & PCSR1_STMASK) == STAT_RESET;
14129572Skarels ++i)
14229572Skarels DELAY(100000);
14329572Skarels if ((addr->pcsr0 & PCSR0_FATI) != 0 ||
14429572Skarels (addr->pcsr1 & PCSR1_STMASK) != STAT_READY)
14529572Skarels return(0);
14629572Skarels
14729572Skarels addr->pcsr0 = 0;
14829572Skarels DELAY(100);
14915357Skarels addr->pcsr0 = PCSR0_RSET;
15015357Skarels while ((addr->pcsr0 & PCSR0_INTR) == 0)
15115357Skarels ;
15215357Skarels /* make board interrupt by executing a GETPCBB command */
15315357Skarels addr->pcsr0 = PCSR0_INTE;
15415357Skarels addr->pcsr2 = 0;
15515357Skarels addr->pcsr3 = 0;
15615357Skarels addr->pcsr0 = PCSR0_INTE|CMD_GETPCBB;
15715357Skarels DELAY(100000);
15815357Skarels return(1);
15915357Skarels }
16015357Skarels
16115357Skarels /*
16215357Skarels * Interface exists: make available by filling in network interface
16315357Skarels * record. System will initialize the interface when it is ready
16415357Skarels * to accept packets. We get the ethernet address here.
16515357Skarels */
16615357Skarels deattach(ui)
16715357Skarels struct uba_device *ui;
16815357Skarels {
16915357Skarels register struct de_softc *ds = &de_softc[ui->ui_unit];
17015357Skarels register struct ifnet *ifp = &ds->ds_if;
17115357Skarels register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
17229572Skarels int csr1;
17315357Skarels
17415357Skarels ifp->if_unit = ui->ui_unit;
17515357Skarels ifp->if_name = "de";
17615357Skarels ifp->if_mtu = ETHERMTU;
17719861Skarels ifp->if_flags = IFF_BROADCAST;
17815357Skarels
17915357Skarels /*
18029572Skarels * What kind of a board is this?
18129572Skarels * The error bits 4-6 in pcsr1 are a device id as long as
18229572Skarels * the high byte is zero.
18329572Skarels */
18429572Skarels csr1 = addr->pcsr1;
18529572Skarels if (csr1 & 0xff60)
18629572Skarels printf("de%d: broken\n", ui->ui_unit);
18729572Skarels else if (csr1 & 0x10)
18829572Skarels printf("de%d: delua\n", ui->ui_unit);
18929572Skarels else
19029572Skarels printf("de%d: deuna\n", ui->ui_unit);
19129572Skarels
19229572Skarels /*
19315357Skarels * Reset the board and temporarily map
19415357Skarels * the pcbb buffer onto the Unibus.
19515357Skarels */
19629572Skarels addr->pcsr0 = 0; /* reset INTE */
19729572Skarels DELAY(100);
19815357Skarels addr->pcsr0 = PCSR0_RSET;
19925633Skarels (void)dewait(ui, "reset");
20025633Skarels
20115357Skarels ds->ds_ubaddr = uballoc(ui->ui_ubanum, (char *)&ds->ds_pcbb,
20215357Skarels sizeof (struct de_pcbb), 0);
20315357Skarels addr->pcsr2 = ds->ds_ubaddr & 0xffff;
20415357Skarels addr->pcsr3 = (ds->ds_ubaddr >> 16) & 0x3;
20515357Skarels addr->pclow = CMD_GETPCBB;
20625633Skarels (void)dewait(ui, "pcbb");
20725633Skarels
20815357Skarels ds->ds_pcbb.pcbb0 = FC_RDPHYAD;
20915357Skarels addr->pclow = CMD_GETCMD;
21025633Skarels (void)dewait(ui, "read addr ");
21125633Skarels
21215357Skarels ubarelse(ui->ui_ubanum, &ds->ds_ubaddr);
21319861Skarels bcopy((caddr_t)&ds->ds_pcbb.pcbb2, (caddr_t)ds->ds_addr,
21415357Skarels sizeof (ds->ds_addr));
21525974Skarels printf("de%d: hardware address %s\n", ui->ui_unit,
21625974Skarels ether_sprintf(ds->ds_addr));
21715357Skarels ifp->if_init = deinit;
21837187Ssklower ifp->if_output = ether_output;
21915357Skarels ifp->if_ioctl = deioctl;
22015357Skarels ifp->if_reset = dereset;
22137187Ssklower ifp->if_start = destart;
22224795Skarels ds->ds_deuba.iff_flags = UBA_CANTWAIT;
22315357Skarels #ifdef notdef
22415357Skarels /* CAN WE USE BDP's ??? */
22524795Skarels ds->ds_deuba.iff_flags |= UBA_NEEDBDP;
22615357Skarels #endif
22715357Skarels if_attach(ifp);
22815357Skarels }
22915357Skarels
23015357Skarels /*
23115357Skarels * Reset of interface after UNIBUS reset.
23215357Skarels * If interface is on specified uba, reset its state.
23315357Skarels */
dereset(unit,uban)23415357Skarels dereset(unit, uban)
23515357Skarels int unit, uban;
23615357Skarels {
23715357Skarels register struct uba_device *ui;
23815357Skarels
23915357Skarels if (unit >= NDE || (ui = deinfo[unit]) == 0 || ui->ui_alive == 0 ||
24015357Skarels ui->ui_ubanum != uban)
24115357Skarels return;
24215357Skarels printf(" de%d", unit);
24337187Ssklower de_softc[unit].ds_if.if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
24437187Ssklower de_softc[unit].ds_flags &= ~DSF_RUNNING;
24532660Skarels ((struct dedevice *)ui->ui_addr)->pcsr0 = PCSR0_RSET;
24632660Skarels (void)dewait(ui, "reset");
24715357Skarels deinit(unit);
24815357Skarels }
24915357Skarels
25015357Skarels /*
25115357Skarels * Initialization of interface; clear recorded pending
25215357Skarels * operations, and reinitialize UNIBUS usage.
25315357Skarels */
deinit(unit)25415357Skarels deinit(unit)
25515357Skarels int unit;
25615357Skarels {
25715357Skarels register struct de_softc *ds = &de_softc[unit];
25815357Skarels register struct uba_device *ui = deinfo[unit];
25915357Skarels register struct dedevice *addr;
26015357Skarels register struct ifrw *ifrw;
26116208Skarels register struct ifxmt *ifxp;
26216208Skarels struct ifnet *ifp = &ds->ds_if;
26315357Skarels int s;
26415357Skarels struct de_ring *rp;
26515357Skarels int incaddr;
26615357Skarels
26719861Skarels /* not yet, if address still unknown */
26819861Skarels if (ifp->if_addrlist == (struct ifaddr *)0)
26915357Skarels return;
27015357Skarels
27125448Skarels if (ds->ds_flags & DSF_RUNNING)
27219861Skarels return;
27325448Skarels if ((ifp->if_flags & IFF_RUNNING) == 0) {
27425448Skarels if (if_ubaminit(&ds->ds_deuba, ui->ui_ubanum,
27525448Skarels sizeof (struct ether_header), (int)btoc(ETHERMTU),
27625448Skarels ds->ds_ifr, NRCV, ds->ds_ifw, NXMT) == 0) {
27725448Skarels printf("de%d: can't initialize\n", unit);
27825448Skarels ds->ds_if.if_flags &= ~IFF_UP;
27925448Skarels return;
28025448Skarels }
28125448Skarels ds->ds_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(ds),
28225448Skarels INCORE_SIZE, 0);
28315357Skarels }
28415357Skarels addr = (struct dedevice *)ui->ui_addr;
28515357Skarels
28615357Skarels /* set the pcbb block address */
28715357Skarels incaddr = ds->ds_ubaddr + PCBB_OFFSET;
28815357Skarels addr->pcsr2 = incaddr & 0xffff;
28915357Skarels addr->pcsr3 = (incaddr >> 16) & 0x3;
29029572Skarels addr->pclow = 0; /* reset INTE */
29129572Skarels DELAY(100);
29215357Skarels addr->pclow = CMD_GETPCBB;
29325633Skarels (void)dewait(ui, "pcbb");
29415357Skarels
29515357Skarels /* set the transmit and receive ring header addresses */
29615357Skarels incaddr = ds->ds_ubaddr + UDBBUF_OFFSET;
29715357Skarels ds->ds_pcbb.pcbb0 = FC_WTRING;
29815357Skarels ds->ds_pcbb.pcbb2 = incaddr & 0xffff;
29915357Skarels ds->ds_pcbb.pcbb4 = (incaddr >> 16) & 0x3;
30015357Skarels
30115357Skarels incaddr = ds->ds_ubaddr + XRENT_OFFSET;
30215357Skarels ds->ds_udbbuf.b_tdrbl = incaddr & 0xffff;
30315357Skarels ds->ds_udbbuf.b_tdrbh = (incaddr >> 16) & 0x3;
30415357Skarels ds->ds_udbbuf.b_telen = sizeof (struct de_ring) / sizeof (short);
30515357Skarels ds->ds_udbbuf.b_trlen = NXMT;
30615357Skarels incaddr = ds->ds_ubaddr + RRENT_OFFSET;
30715357Skarels ds->ds_udbbuf.b_rdrbl = incaddr & 0xffff;
30815357Skarels ds->ds_udbbuf.b_rdrbh = (incaddr >> 16) & 0x3;
30915357Skarels ds->ds_udbbuf.b_relen = sizeof (struct de_ring) / sizeof (short);
31015357Skarels ds->ds_udbbuf.b_rrlen = NRCV;
31115357Skarels
31215357Skarels addr->pclow = CMD_GETCMD;
31325633Skarels (void)dewait(ui, "wtring");
31415357Skarels
31515357Skarels /* initialize the mode - enable hardware padding */
31615357Skarels ds->ds_pcbb.pcbb0 = FC_WTMODE;
31715357Skarels /* let hardware do padding - set MTCH bit on broadcast */
31815357Skarels ds->ds_pcbb.pcbb2 = MOD_TPAD|MOD_HDX;
31915357Skarels addr->pclow = CMD_GETCMD;
32025633Skarels (void)dewait(ui, "wtmode");
32115357Skarels
32215357Skarels /* set up the receive and transmit ring entries */
32324795Skarels ifxp = &ds->ds_ifw[0];
32415357Skarels for (rp = &ds->ds_xrent[0]; rp < &ds->ds_xrent[NXMT]; rp++) {
32524795Skarels rp->r_segbl = ifxp->ifw_info & 0xffff;
32624795Skarels rp->r_segbh = (ifxp->ifw_info >> 16) & 0x3;
32715357Skarels rp->r_flags = 0;
32816208Skarels ifxp++;
32915357Skarels }
33024795Skarels ifrw = &ds->ds_ifr[0];
33115357Skarels for (rp = &ds->ds_rrent[0]; rp < &ds->ds_rrent[NRCV]; rp++) {
33215357Skarels rp->r_slen = sizeof (struct de_buf);
33315357Skarels rp->r_segbl = ifrw->ifrw_info & 0xffff;
33415357Skarels rp->r_segbh = (ifrw->ifrw_info >> 16) & 0x3;
33515357Skarels rp->r_flags = RFLG_OWN; /* hang receive */
33615357Skarels ifrw++;
33715357Skarels }
33815357Skarels
33915357Skarels /* start up the board (rah rah) */
34015357Skarels s = splimp();
34125448Skarels ds->ds_rindex = ds->ds_xindex = ds->ds_xfree = ds->ds_nxmit = 0;
34219861Skarels ds->ds_if.if_flags |= IFF_RUNNING;
34329572Skarels addr->pclow = PCSR0_INTE; /* avoid interlock */
34440842Ssklower destart(&ds->ds_if); /* queue output packets */
34525633Skarels ds->ds_flags |= DSF_RUNNING; /* need before de_setaddr */
34625448Skarels if (ds->ds_flags & DSF_SETADDR)
34725448Skarels de_setaddr(ds->ds_addr, unit);
34825633Skarels addr->pclow = CMD_START | PCSR0_INTE;
34915357Skarels splx(s);
35015357Skarels }
35115357Skarels
35215357Skarels /*
35315357Skarels * Setup output on interface.
35415357Skarels * Get another datagram to send off of the interface queue,
35515357Skarels * and map it to the interface before starting the output.
35640842Ssklower * Must be called from ipl >= our interrupt level.
35715357Skarels */
35837187Ssklower destart(ifp)
35937187Ssklower struct ifnet *ifp;
36015357Skarels {
36115357Skarels int len;
36237187Ssklower int unit = ifp->if_unit;
36315357Skarels struct uba_device *ui = deinfo[unit];
36415357Skarels struct dedevice *addr = (struct dedevice *)ui->ui_addr;
36515357Skarels register struct de_softc *ds = &de_softc[unit];
36615357Skarels register struct de_ring *rp;
36715357Skarels struct mbuf *m;
36815357Skarels register int nxmit;
36915357Skarels
37015357Skarels /*
37115357Skarels * the following test is necessary, since
37215357Skarels * the code is not reentrant and we have
37315357Skarels * multiple transmission buffers.
37415357Skarels */
37537187Ssklower if (ds->ds_if.if_flags & IFF_OACTIVE)
37640842Ssklower return;
37715357Skarels for (nxmit = ds->ds_nxmit; nxmit < NXMT; nxmit++) {
37815357Skarels IF_DEQUEUE(&ds->ds_if.if_snd, m);
37915357Skarels if (m == 0)
38015357Skarels break;
38115357Skarels rp = &ds->ds_xrent[ds->ds_xfree];
38215357Skarels if (rp->r_flags & XFLG_OWN)
38315357Skarels panic("deuna xmit in progress");
38424795Skarels len = if_ubaput(&ds->ds_deuba, &ds->ds_ifw[ds->ds_xfree], m);
38524795Skarels if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
38624795Skarels UBAPURGE(ds->ds_deuba.iff_uba,
38724795Skarels ds->ds_ifw[ds->ds_xfree].ifw_bdp);
38815357Skarels rp->r_slen = len;
38915357Skarels rp->r_tdrerr = 0;
39015357Skarels rp->r_flags = XFLG_STP|XFLG_ENP|XFLG_OWN;
39115357Skarels
39215357Skarels ds->ds_xfree++;
39315357Skarels if (ds->ds_xfree == NXMT)
39415357Skarels ds->ds_xfree = 0;
39515357Skarels }
39615357Skarels if (ds->ds_nxmit != nxmit) {
39715357Skarels ds->ds_nxmit = nxmit;
39815916Skarels if (ds->ds_flags & DSF_RUNNING)
39915357Skarels addr->pclow = PCSR0_INTE|CMD_PDMD;
40015357Skarels }
40115357Skarels }
40215357Skarels
40315357Skarels /*
40415357Skarels * Command done interrupt.
40515357Skarels */
deintr(unit)40615357Skarels deintr(unit)
40715357Skarels int unit;
40815357Skarels {
40915357Skarels struct uba_device *ui = deinfo[unit];
41015357Skarels register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
41115357Skarels register struct de_softc *ds = &de_softc[unit];
41215357Skarels register struct de_ring *rp;
41316208Skarels register struct ifxmt *ifxp;
41415357Skarels short csr0;
41515357Skarels
41615357Skarels /* save flags right away - clear out interrupt bits */
41715357Skarels csr0 = addr->pcsr0;
41815357Skarels addr->pchigh = csr0 >> 8;
41915357Skarels
42015357Skarels
42137187Ssklower ds->ds_if.if_flags |= IFF_OACTIVE; /* prevent entering destart */
42215357Skarels /*
42315357Skarels * if receive, put receive buffer on mbuf
42415357Skarels * and hang the request again
42515357Skarels */
42615357Skarels derecv(unit);
42715357Skarels
42815357Skarels /*
42915357Skarels * Poll transmit ring and check status.
43015357Skarels * Be careful about loopback requests.
43115357Skarels * Then free buffer space and check for
43215357Skarels * more transmit requests.
43315357Skarels */
43415357Skarels for ( ; ds->ds_nxmit > 0; ds->ds_nxmit--) {
43515357Skarels rp = &ds->ds_xrent[ds->ds_xindex];
43615357Skarels if (rp->r_flags & XFLG_OWN)
43715357Skarels break;
43815357Skarels ds->ds_if.if_opackets++;
43924795Skarels ifxp = &ds->ds_ifw[ds->ds_xindex];
44015357Skarels /* check for unusual conditions */
44115357Skarels if (rp->r_flags & (XFLG_ERRS|XFLG_MTCH|XFLG_ONE|XFLG_MORE)) {
44215357Skarels if (rp->r_flags & XFLG_ERRS) {
44315357Skarels /* output error */
44415357Skarels ds->ds_if.if_oerrors++;
44515916Skarels if (dedebug)
44615357Skarels printf("de%d: oerror, flags=%b tdrerr=%b (len=%d)\n",
44715357Skarels unit, rp->r_flags, XFLG_BITS,
44815357Skarels rp->r_tdrerr, XERR_BITS, rp->r_slen);
44915357Skarels } else if (rp->r_flags & XFLG_ONE) {
45015357Skarels /* one collision */
45115357Skarels ds->ds_if.if_collisions++;
45215357Skarels } else if (rp->r_flags & XFLG_MORE) {
45315357Skarels /* more than one collision */
45415357Skarels ds->ds_if.if_collisions += 2; /* guess */
45515357Skarels } else if (rp->r_flags & XFLG_MTCH) {
45615357Skarels /* received our own packet */
45715357Skarels ds->ds_if.if_ipackets++;
45824795Skarels deread(ds, &ifxp->ifrw,
45915357Skarels rp->r_slen - sizeof (struct ether_header));
46015357Skarels }
46115357Skarels }
46224795Skarels if (ifxp->ifw_xtofree) {
46324795Skarels m_freem(ifxp->ifw_xtofree);
46424795Skarels ifxp->ifw_xtofree = 0;
46516208Skarels }
46615357Skarels /* check if next transmit buffer also finished */
46715357Skarels ds->ds_xindex++;
46815357Skarels if (ds->ds_xindex == NXMT)
46915357Skarels ds->ds_xindex = 0;
47015357Skarels }
47137187Ssklower ds->ds_if.if_flags &= ~IFF_OACTIVE;
47240842Ssklower destart(&ds->ds_if);
47315357Skarels
47415357Skarels if (csr0 & PCSR0_RCBI) {
47525633Skarels if (dedebug)
47625633Skarels log(LOG_WARNING, "de%d: buffer unavailable\n", unit);
47715357Skarels addr->pclow = PCSR0_INTE|CMD_PDMD;
47815357Skarels }
47915357Skarels }
48015357Skarels
48115357Skarels /*
48215357Skarels * Ethernet interface receiver interface.
48315357Skarels * If input error just drop packet.
48415357Skarels * Otherwise purge input buffered data path and examine
48515357Skarels * packet to determine type. If can't determine length
48615357Skarels * from type, then have to drop packet. Othewise decapsulate
48715357Skarels * packet based on type and pass to type specific higher-level
48815357Skarels * input routine.
48915357Skarels */
derecv(unit)49015357Skarels derecv(unit)
49115357Skarels int unit;
49215357Skarels {
49315357Skarels register struct de_softc *ds = &de_softc[unit];
49415357Skarels register struct de_ring *rp;
49515357Skarels int len;
49615357Skarels
49715357Skarels rp = &ds->ds_rrent[ds->ds_rindex];
49815357Skarels while ((rp->r_flags & RFLG_OWN) == 0) {
49915357Skarels ds->ds_if.if_ipackets++;
50024795Skarels if (ds->ds_deuba.iff_flags & UBA_NEEDBDP)
50124795Skarels UBAPURGE(ds->ds_deuba.iff_uba,
50224795Skarels ds->ds_ifr[ds->ds_rindex].ifrw_bdp);
50315357Skarels len = (rp->r_lenerr&RERR_MLEN) - sizeof (struct ether_header)
50415357Skarels - 4; /* don't forget checksum! */
50515357Skarels /* check for errors */
50615357Skarels if ((rp->r_flags & (RFLG_ERRS|RFLG_FRAM|RFLG_OFLO|RFLG_CRC)) ||
50715357Skarels (rp->r_flags&(RFLG_STP|RFLG_ENP)) != (RFLG_STP|RFLG_ENP) ||
50815357Skarels (rp->r_lenerr & (RERR_BUFL|RERR_UBTO|RERR_NCHN)) ||
50915357Skarels len < ETHERMIN || len > ETHERMTU) {
51015357Skarels ds->ds_if.if_ierrors++;
51115916Skarels if (dedebug)
51215357Skarels printf("de%d: ierror, flags=%b lenerr=%b (len=%d)\n",
51315357Skarels unit, rp->r_flags, RFLG_BITS, rp->r_lenerr,
51415357Skarels RERR_BITS, len);
51515357Skarels } else
51624795Skarels deread(ds, &ds->ds_ifr[ds->ds_rindex], len);
51715357Skarels
51815357Skarels /* hang the receive buffer again */
51915357Skarels rp->r_lenerr = 0;
52015357Skarels rp->r_flags = RFLG_OWN;
52115357Skarels
52215357Skarels /* check next receive buffer */
52315357Skarels ds->ds_rindex++;
52415357Skarels if (ds->ds_rindex == NRCV)
52515357Skarels ds->ds_rindex = 0;
52615357Skarels rp = &ds->ds_rrent[ds->ds_rindex];
52715357Skarels }
52815357Skarels }
52915357Skarels
53015357Skarels /*
53115357Skarels * Pass a packet to the higher levels.
53215357Skarels * We deal with the trailer protocol here.
53315357Skarels */
deread(ds,ifrw,len)53415357Skarels deread(ds, ifrw, len)
53515357Skarels register struct de_softc *ds;
53615357Skarels struct ifrw *ifrw;
53715357Skarels int len;
53815357Skarels {
53915357Skarels struct ether_header *eh;
54015357Skarels struct mbuf *m;
54115357Skarels int off, resid;
54216722Sbloom int s;
54315357Skarels register struct ifqueue *inq;
54415357Skarels
54515357Skarels /*
54619861Skarels * Deal with trailer protocol: if type is trailer type
54715357Skarels * get true type from first 16-bit word past data.
54815357Skarels * Remember that type was trailer by setting off.
54915357Skarels */
55015357Skarels eh = (struct ether_header *)ifrw->ifrw_addr;
55115357Skarels eh->ether_type = ntohs((u_short)eh->ether_type);
55215357Skarels #define dedataaddr(eh, off, type) ((type)(((caddr_t)((eh)+1)+(off))))
55319861Skarels if (eh->ether_type >= ETHERTYPE_TRAIL &&
55419861Skarels eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
55519861Skarels off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
55615357Skarels if (off >= ETHERMTU)
55715357Skarels return; /* sanity */
55815357Skarels eh->ether_type = ntohs(*dedataaddr(eh, off, u_short *));
55915357Skarels resid = ntohs(*(dedataaddr(eh, off+2, u_short *)));
56015357Skarels if (off + resid > len)
56115357Skarels return; /* sanity */
56215357Skarels len = off + resid;
56315357Skarels } else
56415357Skarels off = 0;
56515357Skarels if (len == 0)
56615357Skarels return;
56715357Skarels
56815357Skarels /*
56915357Skarels * Pull packet off interface. Off is nonzero if packet
57024795Skarels * has trailing header; if_ubaget will then force this header
57140842Ssklower * information to be at the front.
57215357Skarels */
57324795Skarels m = if_ubaget(&ds->ds_deuba, ifrw, len, off, &ds->ds_if);
57440842Ssklower if (m)
57540842Ssklower ether_input(&ds->ds_if, eh, m);
57615357Skarels }
57715357Skarels /*
57815357Skarels * Process an ioctl request.
57915357Skarels */
deioctl(ifp,cmd,data)58015357Skarels deioctl(ifp, cmd, data)
58115357Skarels register struct ifnet *ifp;
58215357Skarels int cmd;
58315357Skarels caddr_t data;
58415357Skarels {
58519861Skarels register struct ifaddr *ifa = (struct ifaddr *)data;
58625448Skarels register struct de_softc *ds = &de_softc[ifp->if_unit];
58715357Skarels int s = splimp(), error = 0;
58815357Skarels
58915357Skarels switch (cmd) {
59015357Skarels
59115357Skarels case SIOCSIFADDR:
59219861Skarels ifp->if_flags |= IFF_UP;
59315357Skarels deinit(ifp->if_unit);
59419861Skarels
59537187Ssklower switch (ifa->ifa_addr->sa_family) {
59623503Ssklower #ifdef INET
59719861Skarels case AF_INET:
59819861Skarels ((struct arpcom *)ifp)->ac_ipaddr =
59919861Skarels IA_SIN(ifa)->sin_addr;
60019861Skarels arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
60119861Skarels break;
60223503Ssklower #endif
60323503Ssklower #ifdef NS
60423503Ssklower case AF_NS:
60523559Ssklower {
60623559Ssklower register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
60723559Ssklower
60825448Skarels if (ns_nullhost(*ina))
60925448Skarels ina->x_host = *(union ns_host *)(ds->ds_addr);
61025448Skarels else
61123559Ssklower de_setaddr(ina->x_host.c_host,ifp->if_unit);
61223503Ssklower break;
61323559Ssklower }
61423503Ssklower #endif
61519861Skarels }
61615357Skarels break;
61715357Skarels
61825448Skarels case SIOCSIFFLAGS:
61925448Skarels if ((ifp->if_flags & IFF_UP) == 0 &&
62025448Skarels ds->ds_flags & DSF_RUNNING) {
62125448Skarels ((struct dedevice *)
62229572Skarels (deinfo[ifp->if_unit]->ui_addr))->pclow = 0;
62329572Skarels DELAY(100);
62429572Skarels ((struct dedevice *)
62525448Skarels (deinfo[ifp->if_unit]->ui_addr))->pclow = PCSR0_RSET;
62637187Ssklower ds->ds_flags &= ~DSF_RUNNING;
62737187Ssklower ds->ds_if.if_flags &= ~IFF_OACTIVE;
62825448Skarels } else if (ifp->if_flags & IFF_UP &&
62925448Skarels (ds->ds_flags & DSF_RUNNING) == 0)
63025448Skarels deinit(ifp->if_unit);
63125448Skarels break;
63225448Skarels
63315357Skarels default:
63415357Skarels error = EINVAL;
63515357Skarels }
63615357Skarels splx(s);
63715357Skarels return (error);
63815357Skarels }
63923559Ssklower
64023559Ssklower /*
64123559Ssklower * set ethernet address for unit
64223559Ssklower */
de_setaddr(physaddr,unit)64323559Ssklower de_setaddr(physaddr, unit)
64425448Skarels u_char *physaddr;
64525448Skarels int unit;
64623559Ssklower {
64723559Ssklower register struct de_softc *ds = &de_softc[unit];
64825633Skarels struct uba_device *ui = deinfo[unit];
64923559Ssklower register struct dedevice *addr= (struct dedevice *)ui->ui_addr;
65023559Ssklower
65123672Ssklower if (! (ds->ds_flags & DSF_RUNNING))
65223672Ssklower return;
65323672Ssklower
65434502Skarels bcopy((caddr_t) physaddr, (caddr_t) &ds->ds_pcbb.pcbb2, 6);
65523559Ssklower ds->ds_pcbb.pcbb0 = FC_WTPHYAD;
65625448Skarels addr->pclow = PCSR0_INTE|CMD_GETCMD;
65725633Skarels if (dewait(ui, "address change") == 0) {
65825633Skarels ds->ds_flags |= DSF_SETADDR;
65934502Skarels bcopy((caddr_t) physaddr, (caddr_t) ds->ds_addr, 6);
66025633Skarels }
66125633Skarels }
66225633Skarels
66325633Skarels /*
66425633Skarels * Await completion of the named function
66525633Skarels * and check for errors.
66625633Skarels */
dewait(ui,fn)66725633Skarels dewait(ui, fn)
66825633Skarels register struct uba_device *ui;
66925633Skarels char *fn;
67025633Skarels {
67125633Skarels register struct dedevice *addr = (struct dedevice *)ui->ui_addr;
67225633Skarels register csr0;
67325633Skarels
67425448Skarels while ((addr->pcsr0 & PCSR0_INTR) == 0)
67525448Skarels ;
67623559Ssklower csr0 = addr->pcsr0;
67723559Ssklower addr->pchigh = csr0 >> 8;
67823559Ssklower if (csr0 & PCSR0_PCEI)
67925633Skarels printf("de%d: %s failed, csr0=%b csr1=%b\n",
68025633Skarels ui->ui_unit, fn, csr0, PCSR0_BITS,
68123559Ssklower addr->pcsr1, PCSR1_BITS);
68225633Skarels return (csr0 & PCSR0_PCEI);
68323559Ssklower }
68416208Skarels #endif
685