xref: /csrg-svn/sys/vax/if/if_ec.c (revision 6525)
1*6525Sfeldman /*	if_ec.c	4.2	82/04/11	*/
26520Sfeldman 
36520Sfeldman #include "ec.h"
46520Sfeldman #include "imp.h"
56520Sfeldman 
66520Sfeldman /*
76520Sfeldman  * 3Com Ethernet Controller interface
86520Sfeldman  */
96520Sfeldman 
106520Sfeldman #include "../h/param.h"
116520Sfeldman #include "../h/systm.h"
126520Sfeldman #include "../h/mbuf.h"
136520Sfeldman #include "../h/pte.h"
146520Sfeldman #include "../h/buf.h"
156520Sfeldman #include "../h/protosw.h"
166520Sfeldman #include "../h/socket.h"
176520Sfeldman #include "../h/ubareg.h"
186520Sfeldman #include "../h/ubavar.h"
196520Sfeldman #include "../h/ecreg.h"
206520Sfeldman #include "../h/cpu.h"
216520Sfeldman #include "../h/mtpr.h"
226520Sfeldman #include "../h/vmmac.h"
236520Sfeldman #include "../net/in.h"
246520Sfeldman #include "../net/in_systm.h"
256520Sfeldman #include "../net/if.h"
266520Sfeldman #include "../net/if_ec.h"
276520Sfeldman #include "../net/if_uba.h"
286520Sfeldman #include "../net/ip.h"
296520Sfeldman #include "../net/ip_var.h"
306520Sfeldman #include "../net/pup.h"
316520Sfeldman #include "../net/route.h"
326520Sfeldman #include <errno.h>
336520Sfeldman 
346520Sfeldman #define	ECMTU	1500
356520Sfeldman 
366520Sfeldman int	ecprobe(), ecattach(), ecrint(), ecxint(), eccollide();
376520Sfeldman struct	uba_device *ecinfo[NEC];
386520Sfeldman u_short ecstd[] = { 0 };
396520Sfeldman struct	uba_driver ecdriver =
406520Sfeldman 	{ ecprobe, 0, ecattach, 0, ecstd, "ec", ecinfo };
416520Sfeldman #define	ECUNIT(x)	minor(x)
426520Sfeldman 
436520Sfeldman int	ecinit(),ecoutput(),ecreset();
446520Sfeldman struct mbuf *ecget();
456520Sfeldman 
466520Sfeldman /*
476520Sfeldman  * Ethernet software status per interface.
486520Sfeldman  *
496520Sfeldman  * Each interface is referenced by a network interface structure,
506520Sfeldman  * es_if, which the routing code uses to locate the interface.
516520Sfeldman  * This structure contains the output queue for the interface, its address, ...
526520Sfeldman  * We also have, for each interface, a UBA interface structure, which
536520Sfeldman  * contains information about the UNIBUS resources held by the interface:
546520Sfeldman  * map registers, buffered data paths, etc.  Information is cached in this
556520Sfeldman  * structure for use by the if_uba.c routines in running the interface
566520Sfeldman  * efficiently.
576520Sfeldman  */
586520Sfeldman struct	ec_softc {
596520Sfeldman 	struct	ifnet es_if;		/* network-visible interface */
606520Sfeldman 	struct	ifuba es_ifuba;		/* UNIBUS resources */
616520Sfeldman 	short	es_delay;		/* current output delay */
626520Sfeldman 	short	es_mask;		/* mask for current output delay */
636520Sfeldman #ifdef notdef
646520Sfeldman 	long	es_lastx;		/* host last transmitted to */
656520Sfeldman #endif
666520Sfeldman 	short	es_oactive;		/* is output active? */
676520Sfeldman 	caddr_t	es_buf[16];		/* virtual addresses of buffers */
686520Sfeldman 	u_char	es_enaddr[6];		/* board's ethernet address */
696520Sfeldman } ec_softc[NEC];
706520Sfeldman 
716520Sfeldman /*
726520Sfeldman  * Do output DMA to determine interface presence and
736520Sfeldman  * interrupt vector.  DMA is too short to disturb other hosts.
746520Sfeldman  */
756520Sfeldman ecprobe(reg)
766520Sfeldman 	caddr_t reg;
776520Sfeldman {
786520Sfeldman 	register int br, cvec;		/* r11, r10 value-result */
796520Sfeldman 	register struct ecdevice *addr = (struct ecdevice *)reg;
806520Sfeldman 	register caddr_t ecbuf = (caddr_t) &umem[0][0600000];
816520Sfeldman 
826520Sfeldman COUNT(ECPROBE);
836520Sfeldman #ifdef lint
846520Sfeldman 	br = 0; cvec = br; br = cvec;
856520Sfeldman 	ecrint(0); ecxint(0); eccollide(0);
866520Sfeldman #endif
876520Sfeldman 	/*
886520Sfeldman 	 * Check for existence of buffers on Unibus.
896520Sfeldman 	 * This won't work on a 780 until more work is done.
906520Sfeldman 	 */
916520Sfeldman 	if (badaddr((caddr_t) ecbuf, 2)) {
926520Sfeldman 		printf("ec: buffer mem not found");
936520Sfeldman 		return (0);
946520Sfeldman 	}
956520Sfeldman 
966520Sfeldman 	/*
976520Sfeldman 	 * Tell the system that the board has memory here, so it won't
986520Sfeldman 	 * attempt to allocate the addresses later.
996520Sfeldman 	 */
1006520Sfeldman 	ubamem(0, 0600000, 32*2);
1016520Sfeldman 
1026520Sfeldman 	/*
1036520Sfeldman 	 * Make a one byte packet in what should be buffer #0.
1046520Sfeldman 	 * Submit it for sending.  This whould cause an xmit interrupt.
1056520Sfeldman 	 * The xmit interrupt vector is 8 bytes after the receive vector,
1066520Sfeldman 	 * so adjust for this before returning.
1076520Sfeldman 	 */
1086520Sfeldman 	*(u_short *)ecbuf = (u_short) 03777;
1096520Sfeldman 	ecbuf[03777] = '\0';
1106520Sfeldman 	addr->ec_xcr = EC_XINTEN|EC_XWBN;
1116520Sfeldman 	DELAY(100000);
1126520Sfeldman 	addr->ec_xcr = EC_XCLR;
1136520Sfeldman 	if (cvec > 0 && cvec != 0x200)
1146520Sfeldman 		cvec -= 010;
1156520Sfeldman 		br += 2;
1166520Sfeldman 	return (1);
1176520Sfeldman }
1186520Sfeldman 
1196520Sfeldman /*
1206520Sfeldman  * Interface exists: make available by filling in network interface
1216520Sfeldman  * record.  System will initialize the interface when it is ready
1226520Sfeldman  * to accept packets.
1236520Sfeldman  */
1246520Sfeldman ecattach(ui)
1256520Sfeldman 	struct uba_device *ui;
1266520Sfeldman {
1276520Sfeldman 	register struct ec_softc *es = &ec_softc[ui->ui_unit];
1286520Sfeldman 	register struct sockaddr_in *sin;
1296520Sfeldman 	register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr;
1306520Sfeldman 	register int i, j;
1316520Sfeldman 	register u_char *cp;
1326520Sfeldman COUNT(ECATTACH);
1336520Sfeldman 
1346520Sfeldman 	es->es_if.if_unit = ui->ui_unit;
1356520Sfeldman 	es->es_if.if_name = "ec";
1366520Sfeldman 	es->es_if.if_mtu = ECMTU;
1376520Sfeldman 	es->es_if.if_net = ui->ui_flags & 0xff;
1386520Sfeldman 
1396520Sfeldman 	/*
1406520Sfeldman 	 * Read the ethernet address off the board,
1416520Sfeldman 	 * one nibble at a time!
1426520Sfeldman 	 */
1436520Sfeldman 	addr->ec_xcr = EC_UECLR;
1446520Sfeldman 	addr->ec_rcr = EC_AROM;
1456520Sfeldman 	cp = es->es_enaddr;
1466520Sfeldman 	for (i=0; i<6; i++) {
1476520Sfeldman 		*cp = 0;
1486520Sfeldman 		for (j=0; j<=4; j+=4) {
1496520Sfeldman 			*cp |= ((addr->ec_rcr >> 8) & 0xf) << j;
1506520Sfeldman 			addr->ec_rcr = EC_AROM|EC_ASTEP;
1516520Sfeldman 			addr->ec_rcr = EC_AROM;
1526520Sfeldman 			addr->ec_rcr = EC_AROM|EC_ASTEP;
1536520Sfeldman 			addr->ec_rcr = EC_AROM;
1546520Sfeldman 			addr->ec_rcr = EC_AROM|EC_ASTEP;
1556520Sfeldman 			addr->ec_rcr = EC_AROM;
1566520Sfeldman 			addr->ec_rcr = EC_AROM|EC_ASTEP;
1576520Sfeldman 			addr->ec_rcr = EC_AROM;
1586520Sfeldman 		}
1596520Sfeldman 		cp++;
1606520Sfeldman 	}
1616520Sfeldman 	printf("ec%d: addr=%x:%x:%x:%x:%x:%x\n", ui->ui_unit,
1626520Sfeldman 		es->es_enaddr[0]&0xff, es->es_enaddr[1]&0xff,
1636520Sfeldman 		es->es_enaddr[2]&0xff, es->es_enaddr[3]&0xff,
1646520Sfeldman 		es->es_enaddr[4]&0xff, es->es_enaddr[5]&0xff);
1656520Sfeldman 	es->es_if.if_host[0] = ((es->es_enaddr[3]&0xff)<<16) |
1666520Sfeldman 	    ((es->es_enaddr[4]&0xff)<<8) | (es->es_enaddr[5]&0xff);
1676520Sfeldman 	sin = (struct sockaddr_in *)&es->es_if.if_addr;
1686520Sfeldman 	sin->sin_family = AF_INET;
1696520Sfeldman 	sin->sin_addr = if_makeaddr(es->es_if.if_net, es->es_if.if_host[0]);
1706520Sfeldman 
1716520Sfeldman 	sin = (struct sockaddr_in *)&es->es_if.if_broadaddr;
1726520Sfeldman 	sin->sin_family = AF_INET;
1736520Sfeldman 	sin->sin_addr = if_makeaddr(es->es_if.if_net, 0);
1746520Sfeldman 	es->es_if.if_flags = IFF_BROADCAST;
1756520Sfeldman 
1766520Sfeldman 	es->es_if.if_init = ecinit;
1776520Sfeldman 	es->es_if.if_output = ecoutput;
1786520Sfeldman 	es->es_if.if_ubareset = ecreset;
1796520Sfeldman 	for (i=0; i<16; i++)
1806520Sfeldman 		es->es_buf[i] = &umem[ui->ui_ubanum][0600000+2048*i];
1816520Sfeldman 	if_attach(&es->es_if);
1826520Sfeldman #if NIMP == 0
1836520Sfeldman 	/* here's one for you john baby.... */
1846520Sfeldman 	if (ui->ui_flags &~ 0xff)
1856520Sfeldman 		eclhinit((ui->ui_flags &~ 0xff) | 0x0a);
1866520Sfeldman #endif
1876520Sfeldman }
1886520Sfeldman 
1896520Sfeldman /*
1906520Sfeldman  * Reset of interface after UNIBUS reset.
1916520Sfeldman  * If interface is on specified uba, reset its state.
1926520Sfeldman  */
1936520Sfeldman ecreset(unit, uban)
1946520Sfeldman 	int unit, uban;
1956520Sfeldman {
1966520Sfeldman 	register struct uba_device *ui;
1976520Sfeldman COUNT(ECRESET);
1986520Sfeldman 
1996520Sfeldman 	if (unit >= NEC || (ui = ecinfo[unit]) == 0 || ui->ui_alive == 0 ||
2006520Sfeldman 	    ui->ui_ubanum != uban)
2016520Sfeldman 		return;
2026520Sfeldman 	printf(" ec%d", unit);
2036520Sfeldman 	ecinit(unit);
2046520Sfeldman }
2056520Sfeldman 
2066520Sfeldman /*
2076520Sfeldman  * Initialization of interface; clear recorded pending
2086520Sfeldman  * operations, and reinitialize UNIBUS usage.
2096520Sfeldman  */
2106520Sfeldman ecinit(unit)
2116520Sfeldman 	int unit;
2126520Sfeldman {
2136520Sfeldman 	register struct ec_softc *es = &ec_softc[unit];
2146520Sfeldman 	register struct uba_device *ui = ecinfo[unit];
2156520Sfeldman 	register struct ecdevice *addr;
2166520Sfeldman 	register i;
2176520Sfeldman 	int s;
2186520Sfeldman 
2196520Sfeldman #ifdef notdef
2206520Sfeldman 	if (if_ubainit(&es->es_ifuba, ui->ui_ubanum,
2216520Sfeldman 	    sizeof (struct ec_header), (int)btoc(ECMTU)) == 0) {
2226520Sfeldman 		printf("ec%d: can't initialize\n", unit);
2236520Sfeldman 		es->es_if.if_flags &= ~IFF_UP;
2246520Sfeldman 		return;
2256520Sfeldman 	}
2266520Sfeldman #endif
2276520Sfeldman 	addr = (struct ecdevice *)ui->ui_addr;
2286520Sfeldman 
2296520Sfeldman 	/*
2306520Sfeldman 	 * Hang receive buffers and start any pending
2316520Sfeldman 	 * writes by faking a transmit complete.
2326520Sfeldman 	 */
2336520Sfeldman 	s = splimp();
2346520Sfeldman 	for (i=ECRHBF; i>=ECRLBF; i--)
2356520Sfeldman 		addr->ec_rcr = EC_READ|i;
2366520Sfeldman 	es->es_oactive = 1;
2376520Sfeldman 	es->es_if.if_flags |= IFF_UP;
2386520Sfeldman 	ecxint(unit);
2396520Sfeldman 	splx(s);
2406520Sfeldman 	if_rtinit(&es->es_if, RTF_DIRECT|RTF_UP);
2416520Sfeldman }
2426520Sfeldman 
2436520Sfeldman #ifdef notdef
2446520Sfeldman int	enalldelay = 0;
2456520Sfeldman int	eclastdel = 25;
2466520Sfeldman int	enlastmask = (~0) << 5;
2476520Sfeldman #endif
2486520Sfeldman 
2496520Sfeldman /*
2506520Sfeldman  * Start or restart output on interface.
2516520Sfeldman  * If interface is already active, then this is a retransmit
2526520Sfeldman  * after a collision, and just restuff registers and delay.
2536520Sfeldman  * If interface is not already active, get another datagram
2546520Sfeldman  * to send off of the interface queue, and map it to the interface
2556520Sfeldman  * before starting the output.
2566520Sfeldman  */
2576520Sfeldman ecstart(dev)
2586520Sfeldman 	dev_t dev;
2596520Sfeldman {
2606520Sfeldman         int unit = ECUNIT(dev);
2616520Sfeldman 	struct uba_device *ui = ecinfo[unit];
2626520Sfeldman 	register struct ec_softc *es = &ec_softc[unit];
2636520Sfeldman 	register struct ecdevice *addr;
2646520Sfeldman 	struct mbuf *m;
2656520Sfeldman 	caddr_t ecbuf;
2666520Sfeldman 	int dest;
2676520Sfeldman COUNT(ECSTART);
2686520Sfeldman 
2696520Sfeldman 	if (es->es_oactive)
2706520Sfeldman 		goto restart;
2716520Sfeldman 
2726520Sfeldman 	/*
2736520Sfeldman 	 * Not already active: dequeue another request
2746520Sfeldman 	 * and copy it into the buffer.  If no more requests,
2756520Sfeldman 	 * just return.
2766520Sfeldman 	 */
2776520Sfeldman 	IF_DEQUEUE(&es->es_if.if_snd, m);
2786520Sfeldman 	if (m == 0) {
2796520Sfeldman 		es->es_oactive = 0;
2806520Sfeldman 		return;
2816520Sfeldman 	}
2826520Sfeldman #ifdef notdef
2836520Sfeldman 	dest = mtod(m, struct ec_header *)->ec_dhost; /* wrong! */
2846520Sfeldman #endif
2856520Sfeldman 	ecput(es->es_buf[ECTBF], m);
2866520Sfeldman 
2876520Sfeldman #ifdef notdef
2886520Sfeldman 	/*
2896520Sfeldman 	 * Ethernet cannot take back-to-back packets (no
2906520Sfeldman 	 * buffering in interface).  To avoid overrunning
2916520Sfeldman 	 * receivers, enforce a small delay (about 1ms) in interface:
2926520Sfeldman 	 *	* between all packets when ecalldelay
2936520Sfeldman 	 *	* whenever last packet was broadcast
2946520Sfeldman 	 *	* whenever this packet is to same host as last packet
2956520Sfeldman 	 */
2966520Sfeldman 	if (enalldelay || es->es_lastx == 0 || es->es_lastx == dest) {
2976520Sfeldman 		es->es_delay = eclastdel;
2986520Sfeldman 		es->es_mask = eclastmask;
2996520Sfeldman 	}
3006520Sfeldman 	es->es_lastx = dest;
3016520Sfeldman #endif
3026520Sfeldman 
3036520Sfeldman restart:
3046520Sfeldman 	/*
3056520Sfeldman 	 * Start the output.
3066520Sfeldman 	 */
3076520Sfeldman 	addr = (struct ecdevice *)ui->ui_addr;
3086520Sfeldman 	addr->ec_xcr = EC_WRITE|ECTBF;
3096520Sfeldman 	es->es_oactive = 1;
3106520Sfeldman }
3116520Sfeldman 
3126520Sfeldman /*
3136520Sfeldman  * Ethernet interface transmitter interrupt.
3146520Sfeldman  * Start another output if more data to send.
3156520Sfeldman  */
3166520Sfeldman ecxint(unit)
3176520Sfeldman 	int unit;
3186520Sfeldman {
3196520Sfeldman 	register struct uba_device *ui = ecinfo[unit];
3206520Sfeldman 	register struct ec_softc *es = &ec_softc[unit];
3216520Sfeldman 	register struct ecdevice *addr = (struct ecdevice *)ui->ui_addr;
3226520Sfeldman COUNT(ECXINT);
3236520Sfeldman 
3246520Sfeldman 	if (es->es_oactive == 0)
3256520Sfeldman 		return;
3266520Sfeldman 	if (addr->ec_xcr&EC_XDONE == 0 || addr->ec_xcr&EC_XBN != ECTBF)
3276520Sfeldman 		printf("ec%d: strange xmit interrupt!\n", unit);
3286520Sfeldman 	es->es_if.if_opackets++;
3296520Sfeldman 	es->es_oactive = 0;
3306520Sfeldman 	es->es_delay = 0;
3316520Sfeldman 	es->es_mask = ~0;
3326520Sfeldman 	addr->ec_xcr = EC_XCLR;
3336520Sfeldman 	/*
3346520Sfeldman 	 * There shouldn't ever be any mbuf's to free, but just in case...
3356520Sfeldman 	 */
3366520Sfeldman 	if (es->es_ifuba.ifu_xtofree) {
3376520Sfeldman 		m_freem(es->es_ifuba.ifu_xtofree);
3386520Sfeldman 		es->es_ifuba.ifu_xtofree = 0;
3396520Sfeldman 	}
3406520Sfeldman 	if (es->es_if.if_snd.ifq_head == 0) {
3416520Sfeldman #ifdef notdef
3426520Sfeldman 		es->es_lastx = 0; /* ? */
3436520Sfeldman #endif
3446520Sfeldman 		return;
3456520Sfeldman 	}
3466520Sfeldman 	ecstart(unit);
3476520Sfeldman }
3486520Sfeldman 
3496520Sfeldman /*
3506520Sfeldman  * Collision on ethernet interface.  Do exponential
3516520Sfeldman  * backoff, and retransmit.  If have backed off all
3526520Sfeldman  * the way print warning diagnostic, and drop packet.
3536520Sfeldman  */
3546520Sfeldman eccollide(unit)
3556520Sfeldman 	int unit;
3566520Sfeldman {
3576520Sfeldman 	struct ec_softc *es = &ec_softc[unit];
3586520Sfeldman COUNT(ECCOLLIDE);
3596520Sfeldman 
3606520Sfeldman 	printf("ec%d: eccollide\n", unit);
3616520Sfeldman 	es->es_if.if_collisions++;
3626520Sfeldman 	if (es->es_oactive == 0)
3636520Sfeldman 		return;
3646520Sfeldman 	ecdocoll(unit);
3656520Sfeldman }
3666520Sfeldman 
3676520Sfeldman ecdocoll(unit)
3686520Sfeldman 	int unit;
3696520Sfeldman {
3706520Sfeldman 	register struct ec_softc *es = &ec_softc[unit];
3716520Sfeldman 
3726520Sfeldman 	/*
3736520Sfeldman 	 * Es_mask is a 16 bit number with n low zero bits, with
3746520Sfeldman 	 * n the number of backoffs.  When es_mask is 0 we have
3756520Sfeldman 	 * backed off 16 times, and give up.
3766520Sfeldman 	 */
3776520Sfeldman 	if (es->es_mask == 0) {
3786520Sfeldman 		printf("ec%d: send error\n", unit);
3796520Sfeldman 		/*
3806520Sfeldman 		 * this makes enxint wrong.  fix later.
3816520Sfeldman 		 */
3826520Sfeldman 		ecxint(unit);
3836520Sfeldman 		return;
3846520Sfeldman 	}
3856520Sfeldman 	/*
3866520Sfeldman 	 * Another backoff.  Restart with delay based on n low bits
3876520Sfeldman 	 * of the interval timer.
3886520Sfeldman 	 */
3896520Sfeldman 	es->es_mask <<= 1;
3906520Sfeldman 	es->es_delay = mfpr(ICR) &~ es->es_mask;
3916520Sfeldman 	/*
3926520Sfeldman 	 * This should do some sort of delay before calling ecstart.
3936520Sfeldman 	 * I'll figure this out later.
3946520Sfeldman 	 */
3956520Sfeldman 	ecstart(unit);
3966520Sfeldman }
3976520Sfeldman 
3986520Sfeldman #ifdef notdef
3996520Sfeldman struct	sockaddr_pup pupsrc = { AF_PUP };
4006520Sfeldman struct	sockaddr_pup pupdst = { AF_PUP };
4016520Sfeldman struct	sockproto pupproto = { PF_PUP };
4026520Sfeldman #endif
4036520Sfeldman /*
4046520Sfeldman  * Ethernet interface receiver interrupt.
4056520Sfeldman  * If input error just drop packet.
4066520Sfeldman  * Otherwise purge input buffered data path and examine
4076520Sfeldman  * packet to determine type.  If can't determine length
4086520Sfeldman  * from type, then have to drop packet.  Othewise decapsulate
4096520Sfeldman  * packet based on type and pass to type specific higher-level
4106520Sfeldman  * input routine.
4116520Sfeldman  */
4126520Sfeldman ecrint(unit)
4136520Sfeldman 	int unit;
4146520Sfeldman {
4156520Sfeldman 	struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
4166520Sfeldman COUNT(ECRINT);
4176520Sfeldman 
4186520Sfeldman #ifdef notdef
4196520Sfeldman 	printf("ec%d: ecrint:%d\n", unit, addr->ec_rcr & 0xf);
4206520Sfeldman #endif
4216520Sfeldman 	while (addr->ec_rcr & EC_RDONE)
4226520Sfeldman 		ecread(unit);
4236520Sfeldman }
4246520Sfeldman 
4256520Sfeldman ecread(unit)
4266520Sfeldman 	int unit;
4276520Sfeldman {
4286520Sfeldman 	register struct ec_softc *es = &ec_softc[unit];
4296520Sfeldman 	struct ecdevice *addr = (struct ecdevice *)ecinfo[unit]->ui_addr;
4306520Sfeldman 	register struct ec_header *ec;
4316520Sfeldman     	struct mbuf *m;
4326520Sfeldman 	int len, off, resid;
4336520Sfeldman 	register struct ifqueue *inq;
4346520Sfeldman 	caddr_t ecbuf;
4356520Sfeldman 	int ecoff;
4366520Sfeldman 	int buf;
4376520Sfeldman COUNT(ECREAD);
4386520Sfeldman 
4396520Sfeldman 	es->es_if.if_ipackets++;
4406520Sfeldman 	buf = addr->ec_rcr & EC_RBN;
4416520Sfeldman 	if (buf < ECRLBF || buf > ECRHBF)
4426520Sfeldman 		panic("ecrint");
4436520Sfeldman 	ecbuf = es->es_buf[buf];
4446520Sfeldman 	ecoff = *(short *)ecbuf;
4456520Sfeldman 	if (ecoff < ECRDOFF || ecoff >= ECMTU+ECRDOFF) {
4466520Sfeldman 		es->es_if.if_ierrors++;
4476520Sfeldman #ifdef notdef
4486520Sfeldman 		if (es->es_if.if_ierrors % 100 == 0)
4496520Sfeldman 			printf("ec%d: += 100 input errors\n", unit);
4506520Sfeldman #endif
4516520Sfeldman 		printf("ec%d: input error (offset=%d)\n", unit, ecoff);
4526520Sfeldman 		goto setup;
4536520Sfeldman 	}
4546520Sfeldman 
4556520Sfeldman 	/*
4566520Sfeldman 	 * Get input data length.
4576520Sfeldman 	 * Get pointer to ethernet header (in input buffer).
4586520Sfeldman 	 * Deal with trailer protocol: if type is PUP trailer
4596520Sfeldman 	 * get true type from first 16-bit word past data.
4606520Sfeldman 	 * Remember that type was trailer by setting off.
4616520Sfeldman 	 */
4626520Sfeldman 	len = ecoff - ECRDOFF - sizeof (struct ec_header);
4636520Sfeldman 	ec = (struct ec_header *)(ecbuf + ECRDOFF);
4646520Sfeldman #define	ecdataaddr(ec, off, type)	((type)(((caddr_t)((ec)+1)+(off))))
4656520Sfeldman 	if (ec->ec_type >= ECPUP_TRAIL &&
4666520Sfeldman 	    ec->ec_type < ECPUP_TRAIL+ECPUP_NTRAILER) {
4676520Sfeldman 		off = (ec->ec_type - ECPUP_TRAIL) * 512;
4686520Sfeldman 		if (off >= ECMTU)
4696520Sfeldman 			goto setup;		/* sanity */
4706520Sfeldman 		ec->ec_type = *ecdataaddr(ec, off, u_short *);
4716520Sfeldman 		resid = *(ecdataaddr(ec, off+2, u_short *));
4726520Sfeldman 		if (off + resid > len)
4736520Sfeldman 			goto setup;		/* sanity */
4746520Sfeldman 		len = off + resid;
4756520Sfeldman 	} else
4766520Sfeldman 		off = 0;
4776520Sfeldman 	if (len == 0)
4786520Sfeldman 		goto setup;
4796520Sfeldman 
4806520Sfeldman 	/*
4816520Sfeldman 	 * Pull packet off interface.  Off is nonzero if packet
4826520Sfeldman 	 * has trailing header; ecget will then force this header
4836520Sfeldman 	 * information to be at the front, but we still have to drop
4846520Sfeldman 	 * the type and length which are at the front of any trailer data.
4856520Sfeldman 	 */
4866520Sfeldman 	m = ecget(ecbuf, len, off);
4876520Sfeldman 	if (m == 0)
4886520Sfeldman 		goto setup;
4896520Sfeldman 	if (off) {
4906520Sfeldman 		m->m_off += 2 * sizeof (u_short);
4916520Sfeldman 		m->m_len -= 2 * sizeof (u_short);
4926520Sfeldman 	}
4936520Sfeldman 	switch (ec->ec_type) {
4946520Sfeldman 
4956520Sfeldman #ifdef INET
4966520Sfeldman 	case ECPUP_IPTYPE:
4976520Sfeldman 		schednetisr(NETISR_IP);
4986520Sfeldman 		inq = &ipintrq;
4996520Sfeldman 		break;
5006520Sfeldman #endif
5016520Sfeldman #ifdef notdef
5026520Sfeldman #ifdef PUP
5036520Sfeldman 	case ECPUP_PUPTYPE: {
5046520Sfeldman 		struct pup_header *pup = mtod(m, struct pup_header *);
5056520Sfeldman 
5066520Sfeldman 		pupproto.sp_protocol = pup->pup_type;
5076520Sfeldman 		pupdst.spup_addr = pup->pup_dport;
5086520Sfeldman 		pupsrc.spup_addr = pup->pup_sport;
5096520Sfeldman 		raw_input(m, &pupproto, (struct sockaddr *)&pupdst,
5106520Sfeldman 		  (struct sockaddr *)&pupsrc);
5116520Sfeldman 		goto setup;
5126520Sfeldman 	}
5136520Sfeldman #endif
5146520Sfeldman #endif
5156520Sfeldman 	default:
5166520Sfeldman 		m_freem(m);
5176520Sfeldman 		goto setup;
5186520Sfeldman 	}
5196520Sfeldman 
5206520Sfeldman 	if (IF_QFULL(inq)) {
5216520Sfeldman 		IF_DROP(inq);
5226520Sfeldman 		m_freem(m);
5236520Sfeldman 	} else
5246520Sfeldman 		IF_ENQUEUE(inq, m);
5256520Sfeldman 
5266520Sfeldman setup:
5276520Sfeldman 	/*
5286520Sfeldman 	 * Reset for next packet.
5296520Sfeldman 	 */
5306520Sfeldman 	addr->ec_rcr = EC_READ|EC_RCLR|buf;
5316520Sfeldman }
5326520Sfeldman 
5336520Sfeldman /*
5346520Sfeldman  * Ethernet output routine.
5356520Sfeldman  * Encapsulate a packet of type family for the local net.
5366520Sfeldman  * Use trailer local net encapsulation if enough data in first
5376520Sfeldman  * packet leaves a multiple of 512 bytes of data in remainder.
5386520Sfeldman  */
5396520Sfeldman ecoutput(ifp, m0, dst)
5406520Sfeldman 	struct ifnet *ifp;
5416520Sfeldman 	struct mbuf *m0;
5426520Sfeldman 	struct sockaddr *dst;
5436520Sfeldman {
5446520Sfeldman 	int type, dest, s, error;
5456520Sfeldman 	register struct ec_softc *es = &ec_softc[ifp->if_unit];
5466520Sfeldman 	register struct mbuf *m = m0;
5476520Sfeldman 	register struct ec_header *ec;
5486520Sfeldman 	register int off;
5496520Sfeldman 	register int i;
5506520Sfeldman 
5516520Sfeldman COUNT(ECOUTPUT);
5526520Sfeldman 	switch (dst->sa_family) {
5536520Sfeldman 
5546520Sfeldman #ifdef INET
5556520Sfeldman 	case AF_INET:
5566520Sfeldman 		dest = ((struct sockaddr_in *)dst)->sin_addr.s_addr;
5576520Sfeldman 		off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
5586520Sfeldman 		if (off > 0 && (off & 0x1ff) == 0 &&
5596520Sfeldman 		    m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
5606520Sfeldman 			type = ECPUP_TRAIL + (off>>9);
5616520Sfeldman 			m->m_off -= 2 * sizeof (u_short);
5626520Sfeldman 			m->m_len += 2 * sizeof (u_short);
5636520Sfeldman 			*mtod(m, u_short *) = ECPUP_IPTYPE;
5646520Sfeldman 			*(mtod(m, u_short *) + 1) = m->m_len;
5656520Sfeldman 			goto gottrailertype;
5666520Sfeldman 		}
5676520Sfeldman 		type = ECPUP_IPTYPE;
5686520Sfeldman 		off = 0;
5696520Sfeldman 		goto gottype;
5706520Sfeldman #endif
5716520Sfeldman #ifdef notdef
5726520Sfeldman #ifdef PUP
5736520Sfeldman 	case AF_PUP:
5746520Sfeldman 		dest = ((struct sockaddr_pup *)dst)->spup_addr.pp_host;
5756520Sfeldman 		type = ECPUP_PUPTYPE;
5766520Sfeldman 		off = 0;
5776520Sfeldman 		goto gottype;
5786520Sfeldman #endif
5796520Sfeldman #endif
5806520Sfeldman 
5816520Sfeldman 	default:
5826520Sfeldman 		printf("ec%d: can't handle af%d\n", ifp->if_unit,
5836520Sfeldman 			dst->sa_family);
5846520Sfeldman 		error = EAFNOSUPPORT;
5856520Sfeldman 		goto bad;
5866520Sfeldman 	}
5876520Sfeldman 
5886520Sfeldman gottrailertype:
5896520Sfeldman 	/*
5906520Sfeldman 	 * Packet to be sent as trailer: move first packet
5916520Sfeldman 	 * (control information) to end of chain.
5926520Sfeldman 	 */
5936520Sfeldman 	while (m->m_next)
5946520Sfeldman 		m = m->m_next;
5956520Sfeldman 	m->m_next = m0;
5966520Sfeldman 	m = m0->m_next;
5976520Sfeldman 	m0->m_next = 0;
5986520Sfeldman 	m0 = m;
5996520Sfeldman 
6006520Sfeldman gottype:
6016520Sfeldman 	/*
6026520Sfeldman 	 * Add local net header.  If no space in first mbuf,
6036520Sfeldman 	 * allocate another.
6046520Sfeldman 	 */
6056520Sfeldman 	if (m->m_off > MMAXOFF ||
6066520Sfeldman 	    MMINOFF + sizeof (struct ec_header) > m->m_off) {
6076520Sfeldman 		m = m_get(M_DONTWAIT);
6086520Sfeldman 		if (m == 0) {
6096520Sfeldman 			error = ENOBUFS;
6106520Sfeldman 			goto bad;
6116520Sfeldman 		}
6126520Sfeldman 		m->m_next = m0;
6136520Sfeldman 		m->m_off = MMINOFF;
6146520Sfeldman 		m->m_len = sizeof (struct ec_header);
6156520Sfeldman 	} else {
6166520Sfeldman 		m->m_off -= sizeof (struct ec_header);
6176520Sfeldman 		m->m_len += sizeof (struct ec_header);
6186520Sfeldman 	}
6196520Sfeldman 	ec = mtod(m, struct ec_header *);
6206520Sfeldman 	for (i=0; i<6; i++)
6216520Sfeldman 		ec->ec_shost[i] = es->es_enaddr[i];
622*6525Sfeldman 	if ((dest &~ 0xff) == 0)
6236520Sfeldman 		for (i=0; i<6; i++)
6246520Sfeldman 			ec->ec_dhost[i] = 0xff;
6256520Sfeldman 	else {
6266520Sfeldman 		ec->ec_dhost[0] = es->es_enaddr[0];
6276520Sfeldman 		ec->ec_dhost[1] = es->es_enaddr[1];
6286520Sfeldman 		ec->ec_dhost[2] = es->es_enaddr[2];
6296520Sfeldman 		ec->ec_dhost[3] = (dest>>8) & 0xff;
6306520Sfeldman 		ec->ec_dhost[4] = (dest>>16) & 0xff;
6316520Sfeldman 		ec->ec_dhost[5] = (dest>>24) & 0xff;
6326520Sfeldman 	}
6336520Sfeldman 	ec->ec_type = type;
6346520Sfeldman 
6356520Sfeldman 	/*
6366520Sfeldman 	 * Queue message on interface, and start output if interface
6376520Sfeldman 	 * not yet active.
6386520Sfeldman 	 */
6396520Sfeldman 	s = splimp();
6406520Sfeldman 	if (IF_QFULL(&ifp->if_snd)) {
6416520Sfeldman 		IF_DROP(&ifp->if_snd);
6426520Sfeldman 		error = ENOBUFS;
6436520Sfeldman 		goto qfull;
6446520Sfeldman 	}
6456520Sfeldman 	IF_ENQUEUE(&ifp->if_snd, m);
6466520Sfeldman 	if (es->es_oactive == 0)
6476520Sfeldman 		ecstart(ifp->if_unit);
6486520Sfeldman 	splx(s);
6496520Sfeldman 	return (0);
6506520Sfeldman qfull:
6516520Sfeldman 	m0 = m;
6526520Sfeldman 	splx(s);
6536520Sfeldman bad:
6546520Sfeldman 	m_freem(m0);
6556520Sfeldman 	return(error);
6566520Sfeldman }
6576520Sfeldman 
6586520Sfeldman /*
6596520Sfeldman  * Routine to copy from mbufs to UNIBUS memory.
6606520Sfeldman  * Similar in spirit to if_wubaput.
6616520Sfeldman  */
6626520Sfeldman ecput(ecbuf, m)
6636520Sfeldman 	char *ecbuf;
6646520Sfeldman 	struct mbuf *m;
6656520Sfeldman {
6666520Sfeldman 	register int len;
6676520Sfeldman 	register struct mbuf *mp;
6686520Sfeldman 	register char *bp, *mcp;
6696520Sfeldman 	register int i;
6706520Sfeldman 
6716520Sfeldman COUNT(ECPUT);
6726520Sfeldman 	len = 0;
6736520Sfeldman 	for (mp=m; mp; mp=mp->m_next)
6746520Sfeldman 		len += mp->m_len;
6756520Sfeldman 	*(u_short *)ecbuf = 2048 - len;
6766520Sfeldman 	bp = ecbuf + 2048 - len;
6776520Sfeldman 	mp = m;
6786520Sfeldman 	while (mp) {
6796520Sfeldman 		mcp = mtod(mp, char *);
6806520Sfeldman 		for (i=0; i<mp->m_len; i++)
6816520Sfeldman 			*bp++ = *mcp++;
6826520Sfeldman 		mp = m_free(mp);
6836520Sfeldman 	}
6846520Sfeldman 	if (bp != ecbuf+2048)
6856520Sfeldman 		printf("ec: bad ecput!\n");
6866520Sfeldman }
6876520Sfeldman 
6886520Sfeldman /*
6896520Sfeldman  * Routine to copy from UNIBUS memory into mbufs.
6906520Sfeldman  * Similar in spirit to if_rubaget.
6916520Sfeldman  */
6926520Sfeldman struct mbuf *
6936520Sfeldman ecget(ecbuf, totlen, off0)
6946520Sfeldman 	char *ecbuf;
6956520Sfeldman 	int totlen, off0;
6966520Sfeldman {
6976520Sfeldman 	struct mbuf *top, **mp, *m;
6986520Sfeldman 	int off = off0;
6996520Sfeldman 	int len;
7006520Sfeldman 	register char *cp = ecbuf + ECRDOFF + sizeof (struct ec_header);
7016520Sfeldman 	register char *mcp;
7026520Sfeldman 	register int i;
7036520Sfeldman 
7046520Sfeldman COUNT(ECGET);
7056520Sfeldman 	top = 0;
7066520Sfeldman 	mp = &top;
7076520Sfeldman 	while (totlen > 0) {
7086520Sfeldman 		MGET(m, 0);
7096520Sfeldman 		if (m == 0)
7106520Sfeldman 			goto bad;
7116520Sfeldman 		if (off) {
7126520Sfeldman 			len = totlen - off;
7136520Sfeldman 			cp = ecbuf + ECRDOFF + sizeof (struct ec_header) + off;
7146520Sfeldman 		} else
7156520Sfeldman 			len = totlen;
7166520Sfeldman 		if (len >= CLBYTES) {
7176520Sfeldman 			struct mbuf *p;
7186520Sfeldman 
7196520Sfeldman 			MCLGET(p, 1);
7206520Sfeldman 			if (p != 0) {
7216520Sfeldman 				m->m_len = len = CLBYTES;
7226520Sfeldman 				m->m_off = (int)p - (int)m;
7236520Sfeldman 			} else {
7246520Sfeldman 				m->m_len = len = MIN(MLEN, len);
7256520Sfeldman 				m->m_off = MMINOFF;
7266520Sfeldman 			}
7276520Sfeldman 		} else {
7286520Sfeldman 			m->m_len = len = MIN(MLEN, len);
7296520Sfeldman 			m->m_off = MMINOFF;
7306520Sfeldman 		}
7316520Sfeldman 		mcp = mtod(m, char *);
7326520Sfeldman 		for (i=0; i<len; i++)
7336520Sfeldman 			*mcp++ = *cp++;
7346520Sfeldman 		*mp = m;
7356520Sfeldman 		mp = &m->m_next;
7366520Sfeldman 		if (off) {
7376520Sfeldman 			off += len;
7386520Sfeldman 			if (off == totlen) {
7396520Sfeldman 				cp = ecbuf + ECRDOFF +
7406520Sfeldman 				    sizeof (struct ec_header);
7416520Sfeldman 				off = 0;
7426520Sfeldman 				totlen = off0;
7436520Sfeldman 			}
7446520Sfeldman 		} else
7456520Sfeldman 			totlen -= len;
7466520Sfeldman 	}
7476520Sfeldman 	return (top);
7486520Sfeldman bad:
7496520Sfeldman 	m_freem(top);
7506520Sfeldman 	return (0);
7516520Sfeldman }
7526520Sfeldman 
7536520Sfeldman #if NIMP == 0 && NEC > 0
7546520Sfeldman /*
7556520Sfeldman  * Logical host interface driver.
7566520Sfeldman  * Allows host to appear as an ARPAnet
7576520Sfeldman  * logical host.  Must also have routing
7586520Sfeldman  * table entry set up to forward packets
7596520Sfeldman  * to appropriate gateway on localnet.
7606520Sfeldman  */
7616520Sfeldman 
7626520Sfeldman struct	ifnet eclhif;
7636520Sfeldman int	eclhoutput();
7646520Sfeldman 
7656520Sfeldman /*
7666520Sfeldman  * Called by localnet interface to allow logical
7676520Sfeldman  * host interface to "attach".  Nothing should ever
7686520Sfeldman  * be sent locally to this interface, it's purpose
7696520Sfeldman  * is simply to establish the host's arpanet address.
7706520Sfeldman  */
7716520Sfeldman eclhinit(addr)
7726520Sfeldman 	int addr;
7736520Sfeldman {
7746520Sfeldman 	register struct ifnet *ifp = &eclhif;
7756520Sfeldman 	register struct sockaddr_in *sin;
7766520Sfeldman 
7776520Sfeldman COUNT(ECLHINIT);
7786520Sfeldman 	ifp->if_name = "lh";
7796520Sfeldman 	ifp->if_mtu = ECMTU;
7806520Sfeldman 	sin = (struct sockaddr_in *)&ifp->if_addr;
7816520Sfeldman 	sin->sin_family = AF_INET;
7826520Sfeldman 	sin->sin_addr.s_addr = addr;
7836520Sfeldman 	ifp->if_net = sin->sin_addr.s_net;
7846520Sfeldman 	ifp->if_flags = IFF_UP;
7856520Sfeldman 	ifp->if_output = eclhoutput;	/* should never be used */
7866520Sfeldman 	if_attach(ifp);
7876520Sfeldman }
7886520Sfeldman 
7896520Sfeldman eclhoutput(ifp, m0, dst)
7906520Sfeldman 	struct ifnet *ifp;
7916520Sfeldman 	struct mbuf *m0;
7926520Sfeldman 	struct sockaddr *dst;
7936520Sfeldman {
7946520Sfeldman COUNT(ECLHOUTPUT);
7956520Sfeldman 	ifp->if_oerrors++;
7966520Sfeldman 	m_freem(m0);
7976520Sfeldman 	return (0);
7986520Sfeldman }
7996520Sfeldman #endif
800