xref: /csrg-svn/sys/vax/if/if_ex.c (revision 40681)
123292Smckusick /*
229363Smckusick  * Copyright (c) 1982, 1986 Regents of the University of California.
335320Sbostic  * All rights reserved.
423292Smckusick  *
535320Sbostic  * This code is derived from software contributed to Berkeley by
635320Sbostic  * Excelan Inc.
735320Sbostic  *
835320Sbostic  * Redistribution and use in source and binary forms are permitted
935320Sbostic  * provided that the above copyright notice and this paragraph are
1035320Sbostic  * duplicated in all such forms and that any documentation,
1135320Sbostic  * advertising materials, and other materials related to such
1235320Sbostic  * distribution and use acknowledge that the software was developed
1335320Sbostic  * by the University of California, Berkeley.  The name of the
1435320Sbostic  * University may not be used to endorse or promote products derived
1535320Sbostic  * from this software without specific prior written permission.
1635320Sbostic  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
1735320Sbostic  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
1835320Sbostic  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
1935320Sbostic  *
20*40681Skarels  *	@(#)if_ex.c	7.6 (Berkeley) 04/03/90
2123292Smckusick  */
2219880Skarels 
2319880Skarels #include "ex.h"
2425273Sbloom #if NEX > 0
2519880Skarels 
2619880Skarels /*
2719880Skarels  * Excelan EXOS 204 Interface
2819880Skarels  *
2919880Skarels  *	George Powers
3019880Skarels  *	Excelan Inc.
3119880Skarels  */
3219880Skarels 
3321777Skarels #include "param.h"
3421777Skarels #include "systm.h"
3521777Skarels #include "mbuf.h"
3621777Skarels #include "buf.h"
3721777Skarels #include "protosw.h"
3821777Skarels #include "socket.h"
3921777Skarels #include "vmmac.h"
4021777Skarels #include "ioctl.h"
4129849Skarels #include "syslog.h"
4221777Skarels #include "errno.h"
4319880Skarels 
4419880Skarels #include "../net/if.h"
4519880Skarels #include "../net/netisr.h"
4619880Skarels #include "../net/route.h"
4724539Skarels 
4824539Skarels #ifdef	INET
4919880Skarels #include "../netinet/in.h"
5019880Skarels #include "../netinet/in_systm.h"
5121777Skarels #include "../netinet/in_var.h"
5219880Skarels #include "../netinet/ip.h"
5319880Skarels #include "../netinet/if_ether.h"
5424539Skarels #endif
5524539Skarels 
5624556Ssklower #ifdef NS
5724556Ssklower #include "../netns/ns.h"
5824556Ssklower #include "../netns/ns_if.h"
5924556Ssklower #endif
6024556Ssklower 
6137476Ssklower #ifdef ISO
6237476Ssklower #include "../netiso/iso.h"
6337476Ssklower #include "../netiso/iso_var.h"
6437476Ssklower #include "../netiso/iso_snpac.h"
6537476Ssklower extern struct snpa_cache all_es, all_is;
6637476Ssklower #endif
6737476Ssklower 
6834531Skarels #include "../vax/pte.h"
6919880Skarels #include "../vax/cpu.h"
7019880Skarels #include "../vax/mtpr.h"
7121777Skarels #include "if_exreg.h"
7221777Skarels #include "if_uba.h"
7319880Skarels #include "../vaxuba/ubareg.h"
7419880Skarels #include "../vaxuba/ubavar.h"
7519880Skarels 
7634531Skarels /* #define DEBUG			/* check for "impossible" events */
7719880Skarels 
7819880Skarels #define	NH2X 4			/* a sufficient number is critical */
7919880Skarels #define	NX2H 4			/* this is pretty arbitrary */
8019880Skarels #define	EXWATCHINTVL 10		/* call exwatch() every 10 seconds */
8119880Skarels 
8219880Skarels int	exprobe(), exattach(), excdint();
8319880Skarels struct	uba_device *exinfo[NEX];
8419880Skarels u_short exstd[] = { 0 };
8519880Skarels struct	uba_driver exdriver =
8619880Skarels 	{ exprobe, 0, exattach, 0, exstd, "ex", exinfo };
87*40681Skarels int	exinit(),exstart(),ether_output(),exioctl(),exreset(),exwatch();
8819880Skarels struct ex_msg *exgetcbuf();
8919880Skarels 
9019880Skarels /*
9119880Skarels  * Ethernet software status per interface.
9219880Skarels  *
9319880Skarels  * Each interface is referenced by a network interface structure,
9419880Skarels  * xs_if, which the routing code uses to locate the interface.
9519880Skarels  * This structure contains the output queue for the interface, its address, ...
9619880Skarels  * We also have, for each interface, a UBA interface structure, which
9719880Skarels  * contains information about the UNIBUS resources held by the interface:
9819880Skarels  * map registers, buffered data paths, etc.  Information is cached in this
9919880Skarels  * structure for use by the if_uba.c routines in running the interface
10019880Skarels  * efficiently.
10119880Skarels  */
10219880Skarels struct	ex_softc {
10321777Skarels 	struct	arpcom xs_ac;		/* Ethernet common part */
10421777Skarels #define	xs_if	xs_ac.ac_if		/* network-visible interface */
10521777Skarels #define	xs_addr	xs_ac.ac_enaddr		/* hardware Ethernet address */
10619880Skarels #ifdef DEBUG
10719880Skarels 	int	xs_wait;
10819880Skarels #endif
10919880Skarels 	struct	ifuba xs_ifuba;		/* UNIBUS resources */
11019880Skarels 	int	xs_flags;		/* private flags */
11119880Skarels #define	EX_XPENDING	1		/* xmit rqst pending on EXOS */
11219880Skarels #define	EX_STATPENDING	(1<<1)		/* stats rqst pending on EXOS */
11325447Skarels #define	EX_RUNNING	(1<<2)		/* board is running */
11425621Ssklower #define EX_SETADDR	(1<<3)		/* physaddr has been changed */
11519880Skarels 	struct	ex_msg *xs_h2xnext;	/* host pointer to request queue */
11619880Skarels 	struct	ex_msg *xs_x2hnext;	/* host pointer to reply queue */
11726391Skarels 	int	xs_ubaddr;		/* map info for structs below */
11819880Skarels #define	UNIADDR(x)	((u_long)(x)&0x3FFFF)
11919880Skarels #define	P_UNIADDR(x)	((u_long)(x)&0x3FFF0)
12019880Skarels 	/* the following structures are always mapped in */
12119880Skarels 	u_short	xs_h2xhdr;		/* EXOS's request queue header */
12219880Skarels 	u_short	xs_x2hhdr;		/* EXOS's reply queue header */
12319880Skarels 	struct	ex_msg xs_h2xent[NH2X];	/* request msg buffers */
12419880Skarels 	struct	ex_msg xs_x2hent[NX2H];	/* reply msg buffers */
12519880Skarels 	struct	confmsg xs_cm;		/* configuration message */
12619880Skarels 	struct	stat_array xs_xsa;	/* EXOS writes stats here */
12719880Skarels 	/* end mapped area */
12826391Skarels #define	INCORE_BASE(p)	((caddr_t)((u_long)(&(p)->xs_h2xhdr) & 0xFFFFFFF0))
12925728Smckusick #define	RVAL_OFF(unit, n) \
13026391Skarels 	((caddr_t)(&(ex_softc[unit].n)) - INCORE_BASE(&ex_softc[unit]))
13125728Smckusick #define	LVAL_OFF(unit, n) \
13226391Skarels 	((caddr_t)(ex_softc[unit].n) - INCORE_BASE(&ex_softc[unit]))
13325728Smckusick #define	H2XHDR_OFFSET(unit)	RVAL_OFF(unit, xs_h2xhdr)
13425728Smckusick #define	X2HHDR_OFFSET(unit)	RVAL_OFF(unit, xs_x2hhdr)
13525728Smckusick #define	H2XENT_OFFSET(unit)	LVAL_OFF(unit, xs_h2xent)
13625728Smckusick #define	X2HENT_OFFSET(unit)	LVAL_OFF(unit, xs_x2hent)
13725728Smckusick #define	CM_OFFSET(unit)		RVAL_OFF(unit, xs_cm)
13825728Smckusick #define	SA_OFFSET(unit)		RVAL_OFF(unit, xs_xsa)
13925728Smckusick #define	INCORE_SIZE(unit)	RVAL_OFF(unit, xs_end)
14019880Skarels 	int	xs_end;			/* place holder */
14119880Skarels } ex_softc[NEX];
14219880Skarels 
14319880Skarels /*
14419880Skarels  * The following structure is a kludge to store a cvec value
14519880Skarels  * between the time exprobe is called, and exconfig.
14619880Skarels  */
14719880Skarels struct	ex_cvecs {
14819880Skarels 	struct	exdevice *xc_csraddr;
14919880Skarels 	int	xc_cvec;
15019880Skarels }ex_cvecs[NEX];
15119880Skarels 
15219880Skarels int	ex_ncall = 0;			/* counts calls to exprobe */
15319880Skarels 
15419880Skarels exprobe(reg)
15519880Skarels 	caddr_t reg;
15619880Skarels {
15719880Skarels 	register int br, cvec;		/* r11, r10 value-result */
15819880Skarels 	register struct exdevice *addr = (struct exdevice *)reg;
15919880Skarels 	register i;
16019880Skarels 
16119880Skarels 	/*
16219880Skarels 	 * We program the EXOS interrupt vector, like dmf device.
16319880Skarels 	 */
16419880Skarels 	br = 0x15;
16519880Skarels 	cvec = (uba_hd[numuba].uh_lastiv -= 4);
16619880Skarels 	ex_cvecs[ex_ncall].xc_csraddr = addr;
16726013Skarels 	ex_cvecs[ex_ncall].xc_cvec = cvec;
16819880Skarels 	/*
16919880Skarels 	 * Reset EXOS and run self-test (guaranteed to
17019880Skarels 	 * complete within 2 seconds).
17119880Skarels 	 */
17219880Skarels 	addr->xd_porta = EX_RESET;
17326013Skarels 	i = 2000;
17419880Skarels 	while (((addr->xd_portb & EX_TESTOK) == 0) && --i)
17526013Skarels 		DELAY(1000);
17619880Skarels 	if ((addr->xd_portb & EX_TESTOK) == 0) {
17719880Skarels 		printf("ex: self-test failed\n");
17819880Skarels 		return 0;
17919880Skarels 	}
18024539Skarels #ifdef lint
18124539Skarels 	br = br;
18226391Skarels 	excdint(0);
18324539Skarels #endif
18426013Skarels 	ex_ncall++;
18519880Skarels 	return (sizeof(struct exdevice));
18619880Skarels }
18719880Skarels 
18819880Skarels /*
18919880Skarels  * Interface exists: make available by filling in network interface
19019880Skarels  * record.  System will initialize the interface when it is ready
19119880Skarels  * to accept packets.  Board is temporarily configured and issues
19219880Skarels  * a NET_ADDRS command, only to get the Ethernet address.
19319880Skarels  */
19419880Skarels exattach(ui)
19537476Ssklower 	register struct uba_device *ui;
19619880Skarels {
19719880Skarels 	register struct ex_softc *xs = &ex_softc[ui->ui_unit];
19819880Skarels 	register struct ifnet *ifp = &xs->xs_if;
19919880Skarels 	register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
20019880Skarels 	register struct ex_msg *bp;
20125728Smckusick 	int unit = ui->ui_unit;
20219880Skarels 	ifp->if_unit = ui->ui_unit;
20319880Skarels 	ifp->if_name = "ex";
20419880Skarels 	ifp->if_mtu = ETHERMTU;
20519880Skarels 
20619880Skarels 	/*
20719880Skarels 	 * Temporarily map queues in order to configure EXOS
20819880Skarels 	 */
20925728Smckusick 	xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs),
21025728Smckusick 		INCORE_SIZE(unit), 0);
21119880Skarels 	exconfig(ui, 0);			/* without interrupts */
21219880Skarels 	if (xs->xs_cm.cm_cc) goto badconf;
21319880Skarels 
21419880Skarels 	bp = exgetcbuf(xs);
21519880Skarels 	bp->mb_rqst = LLNET_ADDRS;
21619880Skarels 	bp->mb_na.na_mask = READ_OBJ;
21719880Skarels 	bp->mb_na.na_slot = PHYSSLOT;
21819880Skarels 	bp->mb_status |= MH_EXOS;
21919880Skarels 	addr->xd_portb = EX_NTRUPT;
22019880Skarels 	bp = xs->xs_x2hnext;
22119880Skarels 	while ((bp->mb_status & MH_OWNER) == MH_EXOS)	/* poll for reply */
22219880Skarels 		;
22325975Skarels 	printf("ex%d: HW %c.%c, NX %c.%c, hardware address %s\n",
22426013Skarels 		ui->ui_unit, xs->xs_cm.cm_vc[2], xs->xs_cm.cm_vc[3],
22526013Skarels 		xs->xs_cm.cm_vc[0], xs->xs_cm.cm_vc[1],
22626013Skarels 		ether_sprintf(bp->mb_na.na_addrs));
22719880Skarels 	bcopy((caddr_t)bp->mb_na.na_addrs, (caddr_t)xs->xs_addr,
22819880Skarels 	    sizeof (xs->xs_addr));
22919880Skarels 
23019880Skarels 	ifp->if_init = exinit;
23137476Ssklower 	ifp->if_output = ether_output;
232*40681Skarels 	ifp->if_start = exstart;
23319880Skarels 	ifp->if_ioctl = exioctl;
23419880Skarels 	ifp->if_reset = exreset;
23521777Skarels 	ifp->if_flags = IFF_BROADCAST;
23619880Skarels 	xs->xs_ifuba.ifu_flags = UBA_CANTWAIT;
23719880Skarels 	if_attach(ifp);
23819880Skarels badconf:
23919880Skarels 	ubarelse(ui->ui_ubanum, &xs->xs_ubaddr);
24019880Skarels }
24119880Skarels 
24219880Skarels /*
24319880Skarels  * Reset of interface after UNIBUS reset.
24419880Skarels  * If interface is on specified uba, reset its state.
24519880Skarels  */
24619880Skarels exreset(unit, uban)
24719880Skarels 	int unit, uban;
24819880Skarels {
24919880Skarels 	register struct uba_device *ui;
25019880Skarels 
25119880Skarels 	if (unit >= NEX || (ui = exinfo[unit]) == 0 || ui->ui_alive == 0 ||
25219880Skarels 	    ui->ui_ubanum != uban)
25319880Skarels 		return;
25419880Skarels 	printf(" ex%d", unit);
25521777Skarels 	ex_softc[unit].xs_if.if_flags &= ~IFF_RUNNING;
25625447Skarels 	ex_softc[unit].xs_flags &= ~EX_RUNNING;
25719880Skarels 	exinit(unit);
25819880Skarels }
25919880Skarels 
26019880Skarels /*
26119880Skarels  * Initialization of interface; clear recorded pending
26219880Skarels  * operations, and reinitialize UNIBUS usage.
26319880Skarels  * Called at boot time (with interrupts disabled?),
26419880Skarels  * and at ifconfig time via exioctl, with interrupts disabled.
26519880Skarels  */
26619880Skarels exinit(unit)
26719880Skarels 	int unit;
26819880Skarels {
26919880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
27019880Skarels 	register struct uba_device *ui = exinfo[unit];
27119880Skarels 	register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
27219880Skarels 	register struct ifnet *ifp = &xs->xs_if;
27319880Skarels 	register struct ex_msg *bp;
27419880Skarels 	int s;
27519880Skarels 
27621777Skarels 	/* not yet, if address still unknown */
27721777Skarels 	if (ifp->if_addrlist == (struct ifaddr *)0)
27819880Skarels 		return;
27925447Skarels 	if (xs->xs_flags & EX_RUNNING)
28025447Skarels 		return;
28119880Skarels 
28225447Skarels 	if ((ifp->if_flags & IFF_RUNNING) == 0) {
28325447Skarels 		if (if_ubainit(&xs->xs_ifuba, ui->ui_ubanum,
28425447Skarels 		    sizeof (struct ether_header),
28525447Skarels 		    (int)btoc(EXMAXRBUF-sizeof(struct ether_header))) == 0) {
28625447Skarels 			printf("ex%d: can't initialize\n", unit);
28725447Skarels 			xs->xs_if.if_flags &= ~IFF_UP;
28825447Skarels 			return;
28925447Skarels 		}
29025447Skarels 		xs->xs_ubaddr = uballoc(ui->ui_ubanum, INCORE_BASE(xs),
29125728Smckusick 			INCORE_SIZE(unit), 0);
29219880Skarels 	}
29319880Skarels 	exconfig(ui, 4);		/* with vectored interrupts*/
29419880Skarels 	/*
29519880Skarels 	 * Put EXOS on the Ethernet, using NET_MODE command
29619880Skarels 	 */
29719880Skarels 	bp = exgetcbuf(xs);
29819880Skarels 	bp->mb_rqst = LLNET_MODE;
29919880Skarels 	bp->mb_nm.nm_mask = WRITE_OBJ;
30019880Skarels 	bp->mb_nm.nm_optn = 0;
30119880Skarels 	bp->mb_nm.nm_mode = MODE_PERF;
30219880Skarels 	bp->mb_status |= MH_EXOS;
30319880Skarels 	addr->xd_portb = EX_NTRUPT;
30419880Skarels 	bp = xs->xs_x2hnext;
30519880Skarels 	while ((bp->mb_status & MH_OWNER) == MH_EXOS)	/* poll for reply */
30619880Skarels 		;
30719880Skarels 	bp->mb_length = MBDATALEN;
30819880Skarels 	bp->mb_status |= MH_EXOS;		/* free up buffer */
30919880Skarels 	addr->xd_portb = EX_NTRUPT;		/* tell EXOS about it */
31019880Skarels 	xs->xs_x2hnext = xs->xs_x2hnext->mb_next;
31119880Skarels 
31219880Skarels 	ifp->if_watchdog = exwatch;
31319880Skarels 	ifp->if_timer = EXWATCHINTVL;
31419880Skarels 	s = splimp();	/* are interrupts always disabled here, anyway? */
31519880Skarels 	exhangrcv(unit);			/* hang receive request */
31621777Skarels 	xs->xs_if.if_flags |= IFF_RUNNING;
31725447Skarels 	xs->xs_flags |= EX_RUNNING;
31825621Ssklower 	if (xs->xs_flags & EX_SETADDR)
31926391Skarels 		ex_setaddr((u_char *)0, unit);
32037476Ssklower #ifdef ISO
32137476Ssklower 	ex_setmulti(all_es.sc_snpa, unit, 1);
32237476Ssklower 	ex_setmulti(all_is.sc_snpa, unit, 2);
32337476Ssklower #endif
32437476Ssklower 	(void) exstart(&xs->xs_if);			/* start transmits */
32519880Skarels 	splx(s);
32619880Skarels }
32719880Skarels 
32819880Skarels /*
32919880Skarels  * Reset, test, and configure EXOS.  This routine assumes
33019880Skarels  * that message queues, etc. have already been mapped into
33119880Skarels  * the UBA.  It is called by exinit, and should also be
33219880Skarels  * callable by exattach.
33319880Skarels  */
33419880Skarels exconfig(ui, itype)
33519880Skarels 	struct	uba_device *ui;
33619880Skarels 	int itype;
33719880Skarels {
33819880Skarels 	register int unit = ui->ui_unit;
33919880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
34019880Skarels 	register struct exdevice *addr = (struct exdevice *) ui->ui_addr;
34119880Skarels 	register struct confmsg *cm = &xs->xs_cm;
34219880Skarels 	register struct ex_msg *bp;
34319880Skarels 	int i;
34419880Skarels 	u_long shiftreg;
34519880Skarels 
34619880Skarels 	xs->xs_flags = 0;
34719880Skarels 	/*
34819880Skarels 	 * Reset EXOS, wait for self-test to complete
34919880Skarels 	 */
35019880Skarels 	addr->xd_porta = EX_RESET;
35119880Skarels 	while ((addr->xd_portb & EX_TESTOK) == 0)
35219880Skarels 		;
35319880Skarels 	/*
35419880Skarels 	 * Set up configuration message.
35519880Skarels 	 */
35619880Skarels 	cm->cm_1rsrv = 1;
35719880Skarels 	cm->cm_cc = 0xFF;
35819880Skarels 	cm->cm_opmode = 0;		/* link-level controller mode */
35919880Skarels 	cm->cm_dfo = 0x0101;		/* enable host data order conversion */
36019880Skarels 	cm->cm_dcn1 = 1;
36137476Ssklower 	cm->cm_2rsrv[0] = cm->cm_2rsrv[1] = 0;
36219880Skarels 	cm->cm_ham = 3;			/* absolute address mode */
36319880Skarels 	cm->cm_3rsrv = 0;
36419880Skarels 	cm->cm_mapsiz = 0;
36519880Skarels 	cm->cm_byteptrn[0] = 0x01;	/* EXOS deduces data order of host */
36619880Skarels 	cm->cm_byteptrn[1] = 0x03;	/*  by looking at this pattern */
36719880Skarels 	cm->cm_byteptrn[2] = 0x07;
36819880Skarels 	cm->cm_byteptrn[3] = 0x0F;
36919880Skarels 	cm->cm_wordptrn[0] = 0x0103;
37019880Skarels 	cm->cm_wordptrn[1] = 0x070F;
37119880Skarels 	cm->cm_lwordptrn = 0x0103070F;
37219880Skarels 	for (i=0; i<20; i++) cm->cm_rsrvd[i] = 0;
37319880Skarels 	cm->cm_mba = 0xFFFFFFFF;
37419880Skarels 	cm->cm_nproc = 0xFF;
37519880Skarels 	cm->cm_nmbox = 0xFF;
37619880Skarels 	cm->cm_nmcast = 0xFF;
37719880Skarels 	cm->cm_nhost = 1;
37819880Skarels 	cm->cm_h2xba = P_UNIADDR(xs->xs_ubaddr);
37925728Smckusick 	cm->cm_h2xhdr = H2XHDR_OFFSET(unit);
38019880Skarels 	cm->cm_h2xtyp = 0;		/* should never wait for rqst buffer */
38119880Skarels 	cm->cm_x2hba = cm->cm_h2xba;
38225728Smckusick 	cm->cm_x2hhdr = X2HHDR_OFFSET(unit);
38319880Skarels 	cm->cm_x2htyp = itype;		/* 0 for none, 4 for vectored */
38419880Skarels 	for (i=0; (addr != ex_cvecs[i].xc_csraddr); i++)
38519880Skarels #ifdef DEBUG
38619880Skarels 	if (i >= NEX)
38719880Skarels 		panic("ex: matching csr address not found");
38819880Skarels #endif
38919880Skarels 		;
39019880Skarels 	cm->cm_x2haddr = ex_cvecs[i].xc_cvec;	/* stashed here by exprobe */
39119880Skarels 	/*
39219880Skarels 	 * Set up message queues and headers.
39319880Skarels 	 * First the request queue.
39419880Skarels 	 */
39519880Skarels 	for (bp = &xs->xs_h2xent[0]; bp < &xs->xs_h2xent[NH2X]; bp++) {
39619880Skarels 		bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs));
39719880Skarels 		bp->mb_rsrv = 0;
39819880Skarels 		bp->mb_length = MBDATALEN;
39919880Skarels 		bp->mb_status = MH_HOST;
40019880Skarels 		bp->mb_next = bp+1;
40119880Skarels 	}
40219880Skarels 	xs->xs_h2xhdr =
40337476Ssklower 		xs->xs_h2xent[NH2X-1].mb_link = (u_short)H2XENT_OFFSET(unit);
40437476Ssklower 	xs->xs_h2xnext = xs->xs_h2xent[NH2X-1].mb_next = xs->xs_h2xent;
40519880Skarels 
40619880Skarels 	/* Now the reply queue. */
40719880Skarels 	for (bp = &xs->xs_x2hent[0]; bp < &xs->xs_x2hent[NX2H]; bp++) {
40819880Skarels 		bp->mb_link = (u_short)((char *)(bp+1)-INCORE_BASE(xs));
40919880Skarels 		bp->mb_rsrv = 0;
41019880Skarels 		bp->mb_length = MBDATALEN;
41119880Skarels 		bp->mb_status = MH_EXOS;
41219880Skarels 		bp->mb_next = bp+1;
41319880Skarels 	}
41419880Skarels 	xs->xs_x2hhdr =
41537476Ssklower 		xs->xs_x2hent[NX2H-1].mb_link = (u_short)X2HENT_OFFSET(unit);
41637476Ssklower 	xs->xs_x2hnext = xs->xs_x2hent[NX2H-1].mb_next = xs->xs_x2hent;
41719880Skarels 
41819880Skarels 	/*
41919880Skarels 	 * Write config msg address to EXOS and wait for
42019880Skarels 	 * configuration to complete (guaranteed response
42119880Skarels 	 * within 2 seconds).
42219880Skarels 	 */
42319880Skarels 	shiftreg = (u_long)0x0000FFFF;
42419880Skarels 	for (i = 0; i < 8; i++) {
42519880Skarels 		if (i == 4)
42625728Smckusick 			shiftreg = P_UNIADDR(xs->xs_ubaddr) + CM_OFFSET(unit);
42719880Skarels 		while (addr->xd_portb & EX_UNREADY)
42819880Skarels 			;
42919880Skarels 		addr->xd_portb = (u_char)(shiftreg & 0xFF);
43019880Skarels 		shiftreg >>= 8;
43119880Skarels 	}
43219880Skarels 	for (i = 1000000; (cm->cm_cc == 0xFF) && i; --i);
43319880Skarels 	if (cm->cm_cc)
43419880Skarels 		printf("ex%d: configuration failed; cc = %x\n",
43519880Skarels 			unit, cm->cm_cc);
43619880Skarels }
43719880Skarels 
43819880Skarels /*
43919880Skarels  * Start or re-start output on interface.
44019880Skarels  * Get another datagram to send off of the interface queue,
44119880Skarels  * and map it to the interface before starting the output.
44237476Ssklower  * This routine is called by exinit(), ether_output(), and excdint().
44319880Skarels  * In all cases, interrupts by EXOS are disabled.
44419880Skarels  */
44537476Ssklower exstart(ifp)
44637476Ssklower struct ifnet *ifp;
44719880Skarels {
44837476Ssklower 	int unit = ifp->if_unit;
44919880Skarels 	struct uba_device *ui = exinfo[unit];
45019880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
45119880Skarels 	register struct exdevice *addr = (struct exdevice *)ui->ui_addr;
45219880Skarels 	register struct ex_msg *bp;
45319880Skarels 	struct mbuf *m;
45419880Skarels         int len;
45519880Skarels 
45619880Skarels #ifdef DEBUG
45737476Ssklower 	if (xs->xs_if.if_flags & IFF_OACTIVE)
45819880Skarels 		panic("exstart(): xmit still pending");
45919880Skarels #endif
46019880Skarels 	IF_DEQUEUE(&xs->xs_if.if_snd, m);
46119880Skarels 	if (m == 0)
46237476Ssklower 		return (0);
46319880Skarels 	len = if_wubaput(&xs->xs_ifuba, m);
46419880Skarels 	if (len - sizeof(struct ether_header) < ETHERMIN)
46519880Skarels 		len = ETHERMIN + sizeof(struct ether_header);
46619880Skarels 	/*
46719880Skarels 	 * Place a transmit request.
46819880Skarels 	 */
46919880Skarels 	bp = exgetcbuf(xs);
47019880Skarels 	bp->mb_rqst = LLRTRANSMIT;
47119880Skarels 	bp->mb_et.et_nblock = 1;
47219880Skarels 	bp->mb_et.et_blks[0].bb_len = (u_short)len;
47319880Skarels 	*(u_long *)bp->mb_et.et_blks[0].bb_addr =
47419880Skarels 		UNIADDR(xs->xs_ifuba.ifu_w.ifrw_info);
47537476Ssklower 	xs->xs_if.if_flags |= IFF_OACTIVE;
47619880Skarels 	bp->mb_status |= MH_EXOS;
47719880Skarels 	addr->xd_portb = EX_NTRUPT;
47837476Ssklower 	return (0);
47919880Skarels }
48019880Skarels 
48119880Skarels /*
48219880Skarels  * Command done interrupt.
48319880Skarels  */
48419880Skarels excdint(unit)
48519880Skarels 	int unit;
48619880Skarels {
48719880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
48819880Skarels 	register struct ex_msg *bp = xs->xs_x2hnext;
48919880Skarels 	struct uba_device *ui = exinfo[unit];
49019880Skarels 	struct exdevice *addr = (struct exdevice *)ui->ui_addr;
49119880Skarels 
49219880Skarels 	while ((bp->mb_status & MH_OWNER) == MH_HOST) {
49319880Skarels 		switch (bp->mb_rqst) {
49419880Skarels 		case LLRECEIVE:
49519880Skarels 			exrecv(unit, bp);
49619880Skarels 			exhangrcv(unit);
49719880Skarels 			break;
49819880Skarels 		case LLRTRANSMIT:
49919880Skarels #ifdef DEBUG
50037476Ssklower 			if ((xs->xs_if.if_flags & IFF_OACTIVE) == 0)
50119880Skarels 				panic("exxmit: no xmit pending");
50219880Skarels #endif
50337476Ssklower 			xs->xs_if.if_flags &= ~IFF_OACTIVE;
50419880Skarels 			xs->xs_if.if_opackets++;
50519880Skarels 			if (bp->mb_rply == LL_OK) {
50619880Skarels 				;
50719880Skarels 			} else if (bp->mb_rply & LLXM_1RTRY) {
50819880Skarels 				xs->xs_if.if_collisions++;
50919880Skarels 			} else if (bp->mb_rply & LLXM_RTRYS) {
51019880Skarels 				xs->xs_if.if_collisions += 2;	/* guess */
51119880Skarels 			} else if (bp->mb_rply & LLXM_ERROR) {
51219880Skarels 				xs->xs_if.if_oerrors++;
51329849Skarels 				log(LOG_ERR, "ex%d: transmit error=%b\n",
51419880Skarels 					unit, bp->mb_rply, XMIT_BITS);
51519880Skarels 			}
51619880Skarels 			if (xs->xs_ifuba.ifu_xtofree) {
51719880Skarels 				m_freem(xs->xs_ifuba.ifu_xtofree);
51819880Skarels 				xs->xs_ifuba.ifu_xtofree = 0;
51919880Skarels 			}
52037476Ssklower 			(void) exstart(&xs->xs_if);
52119880Skarels 			break;
52219880Skarels 		case LLNET_STSTCS:
52319880Skarels 			xs->xs_if.if_ierrors = xs->xs_xsa.sa_crc;
52419880Skarels 			xs->xs_flags &= ~EX_STATPENDING;
52519880Skarels 			break;
52625621Ssklower 		case LLNET_ADDRS:
52725621Ssklower 		case LLNET_RECV:
52825621Ssklower 			break;
52919880Skarels #ifdef	DEBUG
53019880Skarels 		default:
53119880Skarels 			panic("ex%d: unknown reply");
53219880Skarels #endif
53319880Skarels 		} /* end of switch */
53419880Skarels 		bp->mb_length = MBDATALEN;
53519880Skarels 		bp->mb_status |= MH_EXOS;		/* free up buffer */
53619880Skarels 		addr->xd_portb = EX_NTRUPT;		/* tell EXOS about it */
53719880Skarels 		bp = xs->xs_x2hnext = xs->xs_x2hnext->mb_next;
53819880Skarels 	}
53919880Skarels }
54019880Skarels 
54119880Skarels /*
54219880Skarels  * Get a request buffer, fill in standard values, advance pointer.
54319880Skarels  */
54419880Skarels struct ex_msg *
54519880Skarels exgetcbuf(xs)
54619880Skarels 	struct ex_softc *xs;
54719880Skarels {
54819880Skarels 	register struct ex_msg *bp = xs->xs_h2xnext;
54919880Skarels 
55019880Skarels #ifdef DEBUG
55119880Skarels 	if ((bp->mb_status & MH_OWNER) == MH_EXOS)
55219880Skarels 		panic("exgetcbuf(): EXOS owns message buffer");
55319880Skarels #endif
55419880Skarels 	bp->mb_1rsrv = 0;
55519880Skarels 	bp->mb_length = MBDATALEN;
55619880Skarels 	xs->xs_h2xnext = xs->xs_h2xnext->mb_next;
55719880Skarels 	return bp;
55819880Skarels }
55919880Skarels 
56019880Skarels /*
56119880Skarels  * Process Ethernet receive completion:
56219880Skarels  *	If input error just drop packet.
56319880Skarels  *	Otherwise purge input buffered data path and examine
56419880Skarels  *	packet to determine type.  If can't determine length
56519880Skarels  *	from type, then have to drop packet.  Otherwise decapsulate
56619880Skarels  *	packet based on type and pass to type-specific higher-level
56719880Skarels  *	input routine.
56819880Skarels  */
56919880Skarels exrecv(unit, bp)
57019880Skarels 	int unit;
57119880Skarels 	register struct ex_msg *bp;
57219880Skarels {
57319880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
57419880Skarels 	register struct ether_header *eh;
57519880Skarels     	struct mbuf *m;
57619880Skarels 	register int len, off, resid;
57719880Skarels 	register struct ifqueue *inq;
57829849Skarels 	int s;
57919880Skarels 
58019880Skarels 	xs->xs_if.if_ipackets++;
58119880Skarels 	len = bp->mb_er.er_blks[0].bb_len - sizeof(struct ether_header) - 4;
58219880Skarels 	if (bp->mb_rply != LL_OK) {
58319880Skarels 		xs->xs_if.if_ierrors++;
58429849Skarels 		log(LOG_ERR, "ex%d: receive error=%b\n",
58519880Skarels 			unit, bp->mb_rply, RECV_BITS);
58619880Skarels 		return;
58719880Skarels 	}
58819880Skarels 	eh = (struct ether_header *)(xs->xs_ifuba.ifu_r.ifrw_addr);
58919880Skarels 
59019880Skarels 	/*
59121777Skarels 	 * Deal with trailer protocol: if type is trailer
59219880Skarels 	 * get true type from first 16-bit word past data.
59319880Skarels 	 * Remember that type was trailer by setting off.
59419880Skarels 	 */
59519880Skarels 	eh->ether_type = ntohs((u_short)eh->ether_type);
59619880Skarels #define	exdataaddr(eh, off, type)	((type)(((caddr_t)((eh)+1)+(off))))
59721777Skarels 	if (eh->ether_type >= ETHERTYPE_TRAIL &&
59821777Skarels 	    eh->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
59921777Skarels 		off = (eh->ether_type - ETHERTYPE_TRAIL) * 512;
60019880Skarels 		if (off >= ETHERMTU)
60119880Skarels 			return;		/* sanity */
60219880Skarels 		eh->ether_type = ntohs(*exdataaddr(eh, off, u_short *));
60319880Skarels 		resid = ntohs(*(exdataaddr(eh, off+2, u_short *)));
60419880Skarels 		if (off + resid > len)
60519880Skarels 			return;		/* sanity */
60619880Skarels 		len = off + resid;
60719880Skarels 	} else
60819880Skarels 		off = 0;
60919880Skarels 	if (len == 0)
61019880Skarels 		return;
61119880Skarels 
61219880Skarels 	/*
61319880Skarels 	 * Pull packet off interface.  Off is nonzero if packet
61419880Skarels 	 * has trailing header; if_rubaget will then force this header
61519880Skarels 	 * information to be at the front, but we still have to drop
61619880Skarels 	 * the type and length which are at the front of any trailer data.
61719880Skarels 	 */
61824539Skarels 	m = if_rubaget(&xs->xs_ifuba, len, off, &xs->xs_if);
61919880Skarels 	if (m == 0)
62019880Skarels 		return;
62137476Ssklower 	ether_input(&xs->xs_if, eh, m);
62219880Skarels }
62319880Skarels 
62419880Skarels /*
62519880Skarels  * Send receive request to EXOS.
62619880Skarels  * This routine is called by exinit and excdint,
62719880Skarels  * with interrupts disabled in both cases.
62819880Skarels  */
62919880Skarels exhangrcv(unit)
63019880Skarels 	int unit;
63119880Skarels {
63219880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
63319880Skarels 	register struct ex_msg *bp = exgetcbuf(xs);
63419880Skarels 	struct exdevice *addr = (struct exdevice *)exinfo[unit]->ui_addr;
63519880Skarels 
63619880Skarels 	bp->mb_rqst = LLRECEIVE;
63719880Skarels 	bp->mb_er.er_nblock = 1;
63819880Skarels 	bp->mb_er.er_blks[0].bb_len = EXMAXRBUF;
63919880Skarels 	*(u_long *)bp->mb_er.er_blks[0].bb_addr =
64019880Skarels 		UNIADDR(xs->xs_ifuba.ifu_r.ifrw_info);
64119880Skarels 	bp->mb_status |= MH_EXOS;
64219880Skarels 	addr->xd_portb = EX_NTRUPT;
64319880Skarels }
64419880Skarels 
64519880Skarels /*
64619880Skarels  * Watchdog routine - place stats request to EXOS
64719880Skarels  * (This could be dispensed with, if you don't care
64819880Skarels  *  about the if_ierrors count, or are willing to receive
64919880Skarels  *  bad packets in order to derive it.)
65019880Skarels  */
65119880Skarels exwatch(unit)
65219880Skarels 	int unit;
65319880Skarels {
65419880Skarels 	struct uba_device *ui = exinfo[unit];
65519880Skarels 	struct exdevice *addr = (struct exdevice *)ui->ui_addr;
65619880Skarels 	register struct ex_softc *xs = &ex_softc[unit];
65719880Skarels 	register struct ex_msg *bp;
65819880Skarels 	int s = splimp();
65919880Skarels 
66019880Skarels 	if (xs->xs_flags & EX_STATPENDING) goto exspnd;
66119880Skarels 	bp = exgetcbuf(xs);
66219880Skarels 	xs->xs_flags |= EX_STATPENDING;
66319880Skarels 	bp->mb_rqst = LLNET_STSTCS;
66419880Skarels 	bp->mb_ns.ns_mask = READ_OBJ;
66519880Skarels 	bp->mb_ns.ns_rsrv = 0;
66619880Skarels 	bp->mb_ns.ns_nobj = 8;		/* read all 8 stats objects */
66719880Skarels 	bp->mb_ns.ns_xobj = 0;		/* starting with the 1st one */
66825728Smckusick 	bp->mb_ns.ns_bufp = P_UNIADDR(xs->xs_ubaddr) + SA_OFFSET(unit);
66919880Skarels 	bp->mb_status |= MH_EXOS;
67019880Skarels 	addr->xd_portb = EX_NTRUPT;
67119880Skarels exspnd:
67219880Skarels 	splx(s);
67319880Skarels 	xs->xs_if.if_timer = EXWATCHINTVL;
67419880Skarels }
67519880Skarels 
67619880Skarels /*
67719880Skarels  * Process an ioctl request.
67819880Skarels  */
67919880Skarels exioctl(ifp, cmd, data)
68019880Skarels 	register struct ifnet *ifp;
68119880Skarels 	int cmd;
68219880Skarels 	caddr_t data;
68319880Skarels {
68421777Skarels 	register struct ifaddr *ifa = (struct ifaddr *)data;
68525447Skarels 	register struct ex_softc *xs = &ex_softc[ifp->if_unit];
68619880Skarels 	int s = splimp(), error = 0;
68719880Skarels 
68819880Skarels 	switch (cmd) {
68919880Skarels 
69019880Skarels 	case SIOCSIFADDR:
69121777Skarels                 ifp->if_flags |= IFF_UP;
69224539Skarels                 exinit(ifp->if_unit);
69321777Skarels 
69437476Ssklower                 switch (ifa->ifa_addr->sa_family) {
69524556Ssklower #ifdef INET
69621777Skarels 		case AF_INET:
69721777Skarels 			((struct arpcom *)ifp)->ac_ipaddr =
69821777Skarels 				IA_SIN(ifa)->sin_addr;
69921777Skarels 			arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
70021777Skarels 			break;
70124556Ssklower #endif
70224556Ssklower #ifdef NS
70324556Ssklower 		case AF_NS:
70425621Ssklower 		    {
70525621Ssklower 			register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
70625621Ssklower 
70725621Ssklower 			if (ns_nullhost(*ina))
70825621Ssklower 				ina->x_host = *(union ns_host *)(xs->xs_addr);
70925621Ssklower 			else
71025621Ssklower 				ex_setaddr(ina->x_host.c_host,ifp->if_unit);
71124556Ssklower 			break;
71225621Ssklower 		    }
71324556Ssklower #endif
71421777Skarels 		}
71519880Skarels 		break;
71619880Skarels 
71725447Skarels 	case SIOCSIFFLAGS:
71825447Skarels 		if ((ifp->if_flags & IFF_UP) == 0 &&
71925447Skarels 		    xs->xs_flags & EX_RUNNING) {
72025447Skarels 			((struct exdevice *)
72125447Skarels 			  (exinfo[ifp->if_unit]->ui_addr))->xd_porta = EX_RESET;
72225447Skarels 			xs->xs_flags &= ~EX_RUNNING;
72325447Skarels 		} else if (ifp->if_flags & IFF_UP &&
72425447Skarels 		    (xs->xs_flags & EX_RUNNING) == 0)
72525447Skarels 			exinit(ifp->if_unit);
72625447Skarels 		break;
72725447Skarels 
72819880Skarels 	default:
72919880Skarels 		error = EINVAL;
73019880Skarels 	}
73119880Skarels 	splx(s);
73219880Skarels 	return (error);
73319880Skarels }
73425621Ssklower 
73525621Ssklower /*
73625621Ssklower  * set ethernet address for unit
73725621Ssklower  */
73825621Ssklower ex_setaddr(physaddr, unit)
73925621Ssklower 	u_char *physaddr;
74025621Ssklower 	int unit;
74125621Ssklower {
74225621Ssklower 	register struct ex_softc *xs = &ex_softc[unit];
74325621Ssklower 
74425621Ssklower 	if (physaddr) {
74525621Ssklower 		xs->xs_flags |= EX_SETADDR;
74625621Ssklower 		bcopy((caddr_t)physaddr, (caddr_t)xs->xs_addr, 6);
74725621Ssklower 	}
74837476Ssklower 	ex_setmulti((u_char *)xs->xs_addr, unit, PHYSSLOT);
74937476Ssklower }
75037476Ssklower /*
75137476Ssklower  * enable multicast reception on a particular address.
75237476Ssklower  */
75337476Ssklower ex_setmulti(linkaddr, unit, slot)
75437476Ssklower 	u_char *linkaddr;
75537476Ssklower 	int unit;
75637476Ssklower {
75737476Ssklower 	register struct ex_softc *xs = &ex_softc[unit];
75837476Ssklower 	struct uba_device *ui = exinfo[unit];
75937476Ssklower 	register struct exdevice *addr= (struct exdevice *)ui->ui_addr;
76037476Ssklower 	register struct ex_msg *bp;
76137476Ssklower 
76225621Ssklower 	if (! (xs->xs_flags & EX_RUNNING))
76325621Ssklower 		return;
76425621Ssklower 	bp = exgetcbuf(xs);
76525621Ssklower 	bp->mb_rqst = LLNET_ADDRS;
76625621Ssklower 	bp->mb_na.na_mask = READ_OBJ|WRITE_OBJ;
76737476Ssklower 	bp->mb_na.na_slot = slot;
76837476Ssklower 	bcopy((caddr_t)linkaddr, (caddr_t)bp->mb_na.na_addrs, 6);
76925621Ssklower 	bp->mb_status |= MH_EXOS;
77025621Ssklower 	addr->xd_portb = EX_NTRUPT;
77125621Ssklower 	bp = xs->xs_x2hnext;
77225621Ssklower 	while ((bp->mb_status & MH_OWNER) == MH_EXOS)	/* poll for reply */
77325621Ssklower 		;
77425975Skarels #ifdef	DEBUG
77537476Ssklower 	log(LOG_DEBUG, "ex%d: %s %s (slot %d)\n", unit,
77637476Ssklower 		(slot == PHYSSLOT ? "reset addr" : "add multicast"
77737476Ssklower 		ether_sprintf(bp->mb_na.na_addrs), slot);
77825975Skarels #endif
77925621Ssklower 	/*
78037476Ssklower 	 * Now, re-enable reception on slot.
78125621Ssklower 	 */
78225621Ssklower 	bp = exgetcbuf(xs);
78325621Ssklower 	bp->mb_rqst = LLNET_RECV;
78425621Ssklower 	bp->mb_nr.nr_mask = ENABLE_RCV|READ_OBJ|WRITE_OBJ;
78537476Ssklower 	bp->mb_nr.nr_slot = slot;
78625621Ssklower 	bp->mb_status |= MH_EXOS;
78725621Ssklower 	addr->xd_portb = EX_NTRUPT;
78825621Ssklower 	bp = xs->xs_x2hnext;
78925621Ssklower 	while ((bp->mb_status & MH_OWNER) == MH_EXOS)	/* poll for reply */
79025621Ssklower 		;
79125621Ssklower }
79225273Sbloom #endif
793