xref: /csrg-svn/sys/vax/if/if_de.c (revision 45801)
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