usr/src/sys/tahoe/if/if_enp.c

/*
 * Copyright (c) 1988 Regents of the University of California.
 * All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * Computer Consoles Inc.
 *
 * %sccs.include.redist.c%
 *
 *	@(#)if_enp.c	7.7 (Berkeley) %G%
 */

#include "enp.h"
#if NENP > 0
/*
 * CMC ENP-20 Ethernet Controller.
 */
#include "param.h"
#include "systm.h"
#include "mbuf.h"
#include "buf.h"
#include "protosw.h"
#include "socket.h"
#include "vmmac.h"
#include "ioctl.h"
#include "errno.h"
#include "vmparam.h"
#include "syslog.h"
#include "uio.h"

#include "../net/if.h"
#include "../net/netisr.h"
#include "../net/route.h"
#ifdef INET
#include "../netinet/in.h"
#include "../netinet/in_systm.h"
#include "../netinet/in_var.h"
#include "../netinet/ip.h"
#include "../netinet/ip_var.h"
#include "../netinet/if_ether.h"
#endif
#ifdef NS
#include "../netns/ns.h"
#include "../netns/ns_if.h"
#endif

#include "../tahoe/cpu.h"
#include "../tahoe/pte.h"
#include "../tahoe/mtpr.h"

#include "../tahoevba/vbavar.h"
#include "../tahoeif/if_enpreg.h"

#define ENPSTART	0xf02000	/* standard enp start addr */
#define	ENPUNIT(dev)	(minor(dev))	/* for enp ram devices */
/* macros for dealing with longs in i/o space */
#define	ENPGETLONG(a)	((((u_short *)(a))[0] << 16)|(((u_short *)(a))[1]))
#define	ENPSETLONG(a,v) \
   { register u_short *wp = (u_short *)(a); \
     wp[0] = ((u_short *)&(v))[0]; wp[1] = ((u_short *)&(v))[1];}

int	enpprobe(), enpattach(), enpintr();
long	enpstd[] = { 0xfff41000, 0xfff61000, 0 };
struct  vba_device *enpinfo[NENP];
struct  vba_driver enpdriver =
    { enpprobe, 0, enpattach, 0, enpstd, "enp", enpinfo, "enp-20", 0 };

int	enpinit(), enpioctl(), enpreset(), enpoutput(), enpstart();
struct  mbuf *enpget();

/*
 * Ethernet software status per interface.
 *
 * Each interface is referenced by a network interface structure,
 * es_if, which the routing code uses to locate the interface.
 * This structure contains the output queue for the interface, its address, ...
 */
struct  enp_softc {
	struct  arpcom es_ac;           /* common ethernet structures */
#define es_if		es_ac.ac_if
#define es_addr	es_ac.ac_enaddr
	short	es_ivec;		/* interrupt vector */
} enp_softc[NENP];
extern	struct ifnet loif;

enpprobe(reg, vi)
	caddr_t reg;
	struct vba_device *vi;
{
	register br, cvec;		/* must be r12, r11 */
	register struct enpdevice *addr = (struct enpdevice *)reg;
	struct enp_softc *es = &enp_softc[vi->ui_unit];

#ifdef lint
	br = 0; cvec = br; br = cvec;
	enpintr(0);
#endif
	if (badaddr((caddr_t)addr, 2) || badaddr((caddr_t)&addr->enp_ram[0], 2))
		return (0);
	es->es_ivec = --vi->ui_hd->vh_lastiv;
	addr->enp_state = S_ENPRESET;		/* reset by VERSAbus reset */
	br = 0x14, cvec = es->es_ivec;		/* XXX */
	return (sizeof (struct enpdevice));
}

/*
 * Interface exists: make available by filling in network interface
 * record.  System will initialize the interface when it is ready
 * to accept packets.
 */
enpattach(ui)
	register struct vba_device *ui;
{
	struct enp_softc *es = &enp_softc[ui->ui_unit];
	register struct ifnet *ifp = &es->es_if;

	ifp->if_unit = ui->ui_unit;
	ifp->if_name = "enp";
	ifp->if_mtu = ETHERMTU;
	ifp->if_init = enpinit;
	ifp->if_ioctl = enpioctl;
	ifp->if_output = ether_output;
	ifp->if_start = enpstart;
	ifp->if_reset = enpreset;
	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX;
	if_attach(ifp);
}

/*
 * Reset of interface after "system" reset.
 */
enpreset(unit, vban)
	int unit, vban;
{
	register struct vba_device *ui;

	if (unit >= NENP || (ui = enpinfo[unit]) == 0 || ui->ui_alive == 0 ||
	    ui->ui_vbanum != vban)
		return;
	printf(" enp%d", unit);
	enpinit(unit);
}

/*
 * Initialization of interface; clear recorded pending operations.
 */
enpinit(unit)
	int unit;
{
	struct enp_softc *es = &enp_softc[unit];
	register struct vba_device *ui = enpinfo[unit];
	struct enpdevice *addr;
	register struct ifnet *ifp = &es->es_if;
	int s;

	if (ifp->if_addrlist == (struct ifaddr *)0)
		return;
	if ((ifp->if_flags & IFF_RUNNING) == 0) {
		addr = (struct enpdevice *)ui->ui_addr;
		s = splimp();
		RESET_ENP(addr);
		DELAY(200000);
		es->es_if.if_flags |= IFF_RUNNING;
		splx(s);
	}
}

/*
 * Ethernet interface interrupt.
 */
enpintr(unit)
	int unit;
{
	register struct enpdevice *addr;
	register BCB *bcbp;

	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
#if ENP == 30
	if (!IS_ENP_INTR(addr))
		return;
	ACK_ENP_INTR(addr);
#endif
	while ((bcbp = (BCB *)ringget((RING *)&addr->enp_tohost )) != 0) {
		enpread(&enp_softc[unit], bcbp);
		(void) ringput((RING *)&addr->enp_enpfree, bcbp);
	}
}

/*
 * Read input packet, examine its packet type, and enqueue it.
 */
enpread(es, bcbp)
	struct enp_softc *es;
	register BCB *bcbp;
{
	register struct ether_header *enp;
	struct mbuf *m;
	int s, len, off, resid;

	es->es_if.if_ipackets++;
	/*
	 * Get input data length.
	 * Get pointer to ethernet header (in input buffer).
	 * Deal with trailer protocol: if type is PUP trailer
	 * get true type from first 16-bit word past data.
	 * Remember that type was trailer by setting off.
	 */
	len = bcbp->b_msglen - sizeof (struct ether_header);
	enp = (struct ether_header *)ENPGETLONG(&bcbp->b_addr);
#define enpdataaddr(enp, off, type) \
    ((type)(((caddr_t)(((char *)enp)+sizeof (struct ether_header))+(off))))
	enp->ether_type = ntohs((u_short)enp->ether_type);
	if (enp->ether_type >= ETHERTYPE_TRAIL &&
	    enp->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
		off = (enp->ether_type - ETHERTYPE_TRAIL) * 512;
		if (off >= ETHERMTU)
			return;
		enp->ether_type = ntohs(*enpdataaddr(enp, off, u_short *));
		resid = ntohs(*(enpdataaddr(enp, off+2, u_short *)));
		if (off + resid > len)
			return;
		len = off + resid;
	} else
		off = 0;
	if (len == 0)
		return;

	/*
	 * Pull packet off interface.  Off is nonzero if packet
	 * has trailing header; enpget will then force this header
	 * information to be at the front.
	 */
	m = enpget((u_char *)enp, len, off, &es->es_if);
	if (m == 0)
		return;
	ether_input(&es->es_if, enp, m);
}

enpstart(ifp)
	struct ifnet *ifp;
{

	if (enpput(ifp))
		return (ENOBUFS);
	else
		return (0);
}

/*
 * Routine to copy from mbuf chain to transmitter buffer on the VERSAbus.
 */
enpput(ifp)
struct ifnet *ifp;
{
	register BCB *bcbp;
	register struct enpdevice *addr;
	register struct mbuf *mp;
	register u_char *bp;
	register u_int len;
	int unit = ifp->if_unit, ret = 1;
	struct mbuf *m;

	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
again:
	if (ringempty((RING *)&addr->enp_hostfree))  {
	/*	ifp->if_flags |= IFF_OACTIVE; */
		return (ret);
	}
	IF_DEQUEUE(&ifp->if_snd, m);
	if (m == 0) {
		ifp->if_flags &= ~IFF_OACTIVE;
		return (0);
	}
	bcbp = (BCB *)ringget((RING *)&addr->enp_hostfree);
	bcbp->b_len = 0;
	bp = (u_char *)ENPGETLONG(&bcbp->b_addr);
	for (mp = m; mp; mp = mp->m_next) {
		len = mp->m_len;
		if (len == 0)
			continue;
		enpcopy(mtod(mp, u_char *), bp, len);
		bp += len;
		bcbp->b_len += len;
	}
	bcbp->b_len = max(ETHERMIN+sizeof (struct ether_header), bcbp->b_len);
	bcbp->b_reserved = 0;
	if (ringput((RING *)&addr->enp_toenp, bcbp) == 1)
		INTR_ENP(addr);
	m_freem(m);
	ret = 0;
	goto again;
}

/*
 * Routine to copy from VERSAbus memory into mbufs.
 *
 * Warning: This makes the fairly safe assumption that
 * mbufs have even lengths.
 */
struct mbuf *
enpget(rxbuf, totlen, off, ifp)
	u_char *rxbuf;
	int totlen, off;
	struct ifnet *ifp;
{
	register u_char *cp;
	register struct mbuf *m;
	struct mbuf *top = 0, **mp = &top;
	int len;
	u_char *packet_end;

	rxbuf += sizeof (struct ether_header);
	cp = rxbuf;
	packet_end = cp + totlen;
	if (off) {
		off += 2 * sizeof(u_short);
		totlen -= 2 *sizeof(u_short);
		cp = rxbuf + off;
	}

	MGETHDR(m, M_DONTWAIT, MT_DATA);
	if (m == 0)
		return (0);
	m->m_pkthdr.rcvif = ifp;
	m->m_pkthdr.len = totlen;
	m->m_len = MHLEN;

	while (totlen > 0) {
		if (top) {
			MGET(m, M_DONTWAIT, MT_DATA);
			if (m == 0) {
				m_freem(top);
				return (0);
			}
			m->m_len = MLEN;
		}
		len = min(totlen, (packet_end - cp));
		if (len >= MINCLSIZE) {
			MCLGET(m, M_DONTWAIT);
			if (m->m_flags & M_EXT)
				m->m_len = len = min(len, MCLBYTES);
			else
				len = m->m_len;
		} else {
			/*
			 * Place initial small packet/header at end of mbuf.
			 */
			if (len < m->m_len) {
				if (top == 0 && len + max_linkhdr <= m->m_len)
					m->m_data += max_linkhdr;
				m->m_len = len;
			} else
				len = m->m_len;
		}
		enpcopy(cp, mtod(m, u_char *), (u_int)len);
		*mp = m;
		mp = &m->m_next;
		totlen -= len;
		cp += len;
		if (cp == packet_end)
			cp = rxbuf;
	}
	return (top);
}

enpcopy(from, to, cnt)
	register u_char *from, *to;
	register u_int cnt;
{
	register c;
	register short *f, *t;

	if (((int)from&01) && ((int)to&01)) {
		/* source & dest at odd addresses */
		*to++ = *from++;
		--cnt;
	}
	if (cnt > 1 && (((int)to&01) == 0) && (((int)from&01) == 0)) {
		t = (short *)to;
		f = (short *)from;
		for (c = cnt>>1; c; --c)	/* even address copy */
			*t++ = *f++;
		cnt &= 1;
		if (cnt) {			/* odd len */
			from = (u_char *)f;
			to = (u_char *)t;
			*to = *from;
		}
	}
	while ((int)cnt-- > 0)	/* one of the address(es) must be odd */
		*to++ = *from++;
}

/*
 * Process an ioctl request.
 */
enpioctl(ifp, cmd, data)
	register struct ifnet *ifp;
	int cmd;
	caddr_t data;
{
	register struct ifaddr *ifa = (struct ifaddr *)data;
	struct enpdevice *addr;
	int s = splimp(), error = 0;

	switch (cmd) {

	case SIOCSIFADDR:
		ifp->if_flags |= IFF_UP;
		switch (ifa->ifa_addr->sa_family) {
#ifdef INET
		case AF_INET:
			enpinit(ifp->if_unit);
			((struct arpcom *)ifp)->ac_ipaddr =
			    IA_SIN(ifa)->sin_addr;
			arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
			break;
#endif
#ifdef NS
		case AF_NS: {
			struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
			struct enp_softc *es = &enp_softc[ifp->if_unit];

			if (!ns_nullhost(*ina)) {
				ifp->if_flags &= ~IFF_RUNNING;
				addr = (struct enpdevice *)
				    enpinfo[ifp->if_unit]->ui_addr;
				enpsetaddr(ifp->if_unit, addr,
				    ina->x_host.c_host);
			} else
				ina->x_host = *(union ns_host *)es->es_addr;
			enpinit(ifp->if_unit);
			break;
		}
#endif
		default:
			enpinit(ifp->if_unit);
			break;
		}
		break;

	case SIOCSIFFLAGS:
		if ((ifp->if_flags&IFF_UP) == 0 && ifp->if_flags&IFF_RUNNING) {
			enpinit(ifp->if_unit);		/* reset board */
			ifp->if_flags &= ~IFF_RUNNING;
		} else if (ifp->if_flags&IFF_UP &&
		     (ifp->if_flags&IFF_RUNNING) == 0)
			enpinit(ifp->if_unit);
		break;

	default:
		error = EINVAL;
	}
	splx(s);
	return (error);
}

enpsetaddr(unit, addr, enaddr)
	int unit;
	struct enpdevice *addr;
	u_char *enaddr;
{

	enpcopy(enaddr, addr->enp_addr.e_baseaddr.ea_addr,
	    sizeof (struct ether_addr));
	enpinit(unit);
	enpgetaddr(unit, addr);
}

enpgetaddr(unit, addr)
	int unit;
	struct enpdevice *addr;
{
	struct enp_softc *es = &enp_softc[unit];

	enpcopy(addr->enp_addr.e_baseaddr.ea_addr, es->es_addr,
	    sizeof (struct ether_addr));
	printf("enp%d: hardware address %s\n",
	    unit, ether_sprintf(es->es_addr));
}

/*
 * Routines to synchronize enp and host.
 */
#ifdef notdef
static
ringinit(rp, size)
	register RING *rp;
{

	rp->r_rdidx = rp->r_wrtidx = 0;
	rp->r_size = size;
}

static
ringfull(rp)
	register RING *rp;
{
	register short idx;

	idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
	return (idx == rp->r_rdidx);
}

static
fir(rp)
	register RING *rp;
{

	return (rp->r_rdidx != rp->r_wrtidx ? rp->r_slot[rp->r_rdidx] : 0);
}
#endif

static
ringempty(rp)
	register RING *rp;
{

	return (rp->r_rdidx == rp->r_wrtidx);
}

static
ringput(rp, v)
	register RING *rp;
	BCB *v;
{
	register int idx;

	idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
	if (idx != rp->r_rdidx) {
		ENPSETLONG(&rp->r_slot[rp->r_wrtidx], v);
		rp->r_wrtidx = idx;
		if ((idx -= rp->r_rdidx) < 0)
			idx += rp->r_size;
		return (idx);			/* num ring entries */
	}
	return (0);
}

static
ringget(rp)
	register RING *rp;
{
	register int i = 0;

	if (rp->r_rdidx != rp->r_wrtidx) {
		i = ENPGETLONG(&rp->r_slot[rp->r_rdidx]);
		rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
	}
	return (i);
}

/*
 * ENP Ram device.
 */
enpr_open(dev)
	dev_t dev;
{
	register int unit = ENPUNIT(dev);
	struct vba_device *ui;
	struct enpdevice *addr;

	if (unit >= NENP || (ui = enpinfo[unit]) == 0 || ui->ui_alive == 0 ||
	    (addr = (struct enpdevice *)ui->ui_addr) == 0)
		return (ENODEV);
	if (addr->enp_state != S_ENPRESET)
		return (EACCES);  /* enp is not in reset state, don't open  */
	return (0);
}

/*ARGSUSED*/
enpr_close(dev)
	dev_t dev;
{

	return (0);
}

enpr_read(dev, uio)
	dev_t dev;
	register struct uio *uio;
{
	register struct iovec *iov;
	struct enpdevice *addr;

	if (uio->uio_offset > RAM_SIZE)
		return (ENODEV);
	iov = uio->uio_iov;
	if (uio->uio_offset + iov->iov_len > RAM_SIZE)
		iov->iov_len = RAM_SIZE - uio->uio_offset;
	addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
	if (useracc(iov->iov_base, (unsigned)iov->iov_len, 0) == 0)
		return (EFAULT);
	enpcopy((u_char *)&addr->enp_ram[uio->uio_offset],
	    (u_char *)iov->iov_base, (u_int)iov->iov_len);
	uio->uio_resid -= iov->iov_len;
	iov->iov_len = 0;
	return (0);
}

enpr_write(dev, uio)
	dev_t dev;
	register struct uio *uio;
{
	register struct enpdevice *addr;
	register struct iovec *iov;

	addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
	iov = uio->uio_iov;
	if (uio->uio_offset > RAM_SIZE)
		return (ENODEV);
	if (uio->uio_offset + iov->iov_len > RAM_SIZE)
		iov->iov_len = RAM_SIZE - uio->uio_offset;
	if (useracc(iov->iov_base, (unsigned)iov->iov_len, 1) == 0)
		return (EFAULT);
	enpcopy((u_char *)iov->iov_base,
	    (u_char *)&addr->enp_ram[uio->uio_offset], (u_int)iov->iov_len);
	uio->uio_resid -= iov->iov_len;
	uio->uio_offset += iov->iov_len;
	iov->iov_len = 0;
	return (0);
}

/*ARGSUSED*/
enpr_ioctl(dev, cmd, data)
	dev_t dev;
	caddr_t data;
{
	register unit = ENPUNIT(dev);
	struct enpdevice *addr;

	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
	switch(cmd) {

	case ENPIOGO:
		ENPSETLONG(&addr->enp_base, addr);
		addr->enp_intrvec = enp_softc[unit].es_ivec;
		ENP_GO(addr, ENPSTART);
		DELAY(200000);
		enpinit(unit);
		/*
		 * Fetch Ethernet address after link level
		 * is booted (firmware copies manufacturer's
		 * address from on-board ROM).
		 */
		enpgetaddr(unit, addr);
		addr->enp_state = S_ENPRUN;
		break;

	case ENPIORESET:
		RESET_ENP(addr);
		addr->enp_state = S_ENPRESET;
		DELAY(100000);
		break;
	default:
		return (EINVAL);
	}
	return (0);
}
#endif
Commit	Line	Data
	1	/*
	2	* Copyright (c) 1988 Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* This code is derived from software contributed to Berkeley by
	6	* Computer Consoles Inc.
	7	*
	8	* %sccs.include.redist.c%
	9	*
	10	* @(#)if_enp.c 7.7 (Berkeley) %G%
	11	*/
	12
	13	#include "enp.h"
	14	#if NENP > 0
	15	/*
	16	* CMC ENP-20 Ethernet Controller.
	17	*/
	18	#include "param.h"
	19	#include "systm.h"
	20	#include "mbuf.h"
	21	#include "buf.h"
	22	#include "protosw.h"
	23	#include "socket.h"
	24	#include "vmmac.h"
	25	#include "ioctl.h"
	26	#include "errno.h"
	27	#include "vmparam.h"
	28	#include "syslog.h"
	29	#include "uio.h"
	30
	31	#include "../net/if.h"
	32	#include "../net/netisr.h"
	33	#include "../net/route.h"
	34	#ifdef INET
	35	#include "../netinet/in.h"
	36	#include "../netinet/in_systm.h"
	37	#include "../netinet/in_var.h"
	38	#include "../netinet/ip.h"
	39	#include "../netinet/ip_var.h"
	40	#include "../netinet/if_ether.h"
	41	#endif
	42	#ifdef NS
	43	#include "../netns/ns.h"
	44	#include "../netns/ns_if.h"
	45	#endif
	46
	47	#include "../tahoe/cpu.h"
	48	#include "../tahoe/pte.h"
	49	#include "../tahoe/mtpr.h"
	50
	51	#include "../tahoevba/vbavar.h"
	52	#include "../tahoeif/if_enpreg.h"
	53
	54	#define ENPSTART 0xf02000 /* standard enp start addr */
	55	#define ENPUNIT(dev) (minor(dev)) /* for enp ram devices */
	56	/* macros for dealing with longs in i/o space */
	57	#define ENPGETLONG(a) ((((u_short )(a))[0] << 16)\|(((u_short )(a))[1]))
	58	#define ENPSETLONG(a,v) \
	59	{ register u_short wp = (u_short )(a); \
	60	wp[0] = ((u_short )&(v))[0]; wp[1] = ((u_short )&(v))[1];}
	61
	62	int enpprobe(), enpattach(), enpintr();
	63	long enpstd[] = { 0xfff41000, 0xfff61000, 0 };
	64	struct vba_device *enpinfo[NENP];
	65	struct vba_driver enpdriver =
	66	{ enpprobe, 0, enpattach, 0, enpstd, "enp", enpinfo, "enp-20", 0 };
	67
	68	int enpinit(), enpioctl(), enpreset(), enpoutput(), enpstart();
	69	struct mbuf *enpget();
	70
	71	/*
	72	* Ethernet software status per interface.
	73	*
	74	* Each interface is referenced by a network interface structure,
	75	* es_if, which the routing code uses to locate the interface.
	76	* This structure contains the output queue for the interface, its address, ...
	77	*/
	78	struct enp_softc {
	79	struct arpcom es_ac; /* common ethernet structures */
	80	#define es_if es_ac.ac_if
	81	#define es_addr es_ac.ac_enaddr
	82	short es_ivec; /* interrupt vector */
	83	} enp_softc[NENP];
	84	extern struct ifnet loif;
	85
	86	enpprobe(reg, vi)
	87	caddr_t reg;
	88	struct vba_device *vi;
	89	{
	90	register br, cvec; /* must be r12, r11 */
	91	register struct enpdevice addr = (struct enpdevice )reg;
	92	struct enp_softc *es = &enp_softc[vi->ui_unit];
	93
	94	#ifdef lint
	95	br = 0; cvec = br; br = cvec;
	96	enpintr(0);
	97	#endif
	98	if (badaddr((caddr_t)addr, 2) \|\| badaddr((caddr_t)&addr->enp_ram[0], 2))
	99	return (0);
	100	es->es_ivec = --vi->ui_hd->vh_lastiv;
	101	addr->enp_state = S_ENPRESET; /* reset by VERSAbus reset */
	102	br = 0x14, cvec = es->es_ivec; /* XXX */
	103	return (sizeof (struct enpdevice));
	104	}
	105
	106	/*
	107	* Interface exists: make available by filling in network interface
	108	* record. System will initialize the interface when it is ready
	109	* to accept packets.
	110	*/
	111	enpattach(ui)
	112	register struct vba_device *ui;
	113	{
	114	struct enp_softc *es = &enp_softc[ui->ui_unit];
	115	register struct ifnet *ifp = &es->es_if;
	116
	117	ifp->if_unit = ui->ui_unit;
	118	ifp->if_name = "enp";
	119	ifp->if_mtu = ETHERMTU;
	120	ifp->if_init = enpinit;
	121	ifp->if_ioctl = enpioctl;
	122	ifp->if_output = ether_output;
	123	ifp->if_start = enpstart;
	124	ifp->if_reset = enpreset;
	125	ifp->if_flags = IFF_BROADCAST \| IFF_SIMPLEX;
	126	if_attach(ifp);
	127	}
	128
	129	/*
	130	* Reset of interface after "system" reset.
	131	*/
	132	enpreset(unit, vban)
	133	int unit, vban;
	134	{
	135	register struct vba_device *ui;
	136
	137	if (unit >= NENP \|\| (ui = enpinfo[unit]) == 0 \|\| ui->ui_alive == 0 \|\|
	138	ui->ui_vbanum != vban)
	139	return;
	140	printf(" enp%d", unit);
	141	enpinit(unit);
	142	}
	143
	144	/*
	145	* Initialization of interface; clear recorded pending operations.
	146	*/
	147	enpinit(unit)
	148	int unit;
	149	{
	150	struct enp_softc *es = &enp_softc[unit];
	151	register struct vba_device *ui = enpinfo[unit];
	152	struct enpdevice *addr;
	153	register struct ifnet *ifp = &es->es_if;
	154	int s;
	155
	156	if (ifp->if_addrlist == (struct ifaddr *)0)
	157	return;
	158	if ((ifp->if_flags & IFF_RUNNING) == 0) {
	159	addr = (struct enpdevice *)ui->ui_addr;
	160	s = splimp();
	161	RESET_ENP(addr);
	162	DELAY(200000);
	163	es->es_if.if_flags \|= IFF_RUNNING;
	164	splx(s);
	165	}
	166	}
	167
	168	/*
	169	* Ethernet interface interrupt.
	170	*/
	171	enpintr(unit)
	172	int unit;
	173	{
	174	register struct enpdevice *addr;
	175	register BCB *bcbp;
	176
	177	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
	178	#if ENP == 30
	179	if (!IS_ENP_INTR(addr))
	180	return;
	181	ACK_ENP_INTR(addr);
	182	#endif
	183	while ((bcbp = (BCB )ringget((RING )&addr->enp_tohost )) != 0) {
	184	enpread(&enp_softc[unit], bcbp);
	185	(void) ringput((RING *)&addr->enp_enpfree, bcbp);
	186	}
	187	}
	188
	189	/*
	190	* Read input packet, examine its packet type, and enqueue it.
	191	*/
	192	enpread(es, bcbp)
	193	struct enp_softc *es;
	194	register BCB *bcbp;
	195	{
	196	register struct ether_header *enp;
	197	struct mbuf *m;
	198	int s, len, off, resid;
	199
	200	es->es_if.if_ipackets++;
	201	/*
	202	* Get input data length.
	203	* Get pointer to ethernet header (in input buffer).
	204	* Deal with trailer protocol: if type is PUP trailer
	205	* get true type from first 16-bit word past data.
	206	* Remember that type was trailer by setting off.
	207	*/
	208	len = bcbp->b_msglen - sizeof (struct ether_header);
	209	enp = (struct ether_header *)ENPGETLONG(&bcbp->b_addr);
	210	#define enpdataaddr(enp, off, type) \
	211	((type)(((caddr_t)(((char *)enp)+sizeof (struct ether_header))+(off))))
	212	enp->ether_type = ntohs((u_short)enp->ether_type);
	213	if (enp->ether_type >= ETHERTYPE_TRAIL &&
	214	enp->ether_type < ETHERTYPE_TRAIL+ETHERTYPE_NTRAILER) {
	215	off = (enp->ether_type - ETHERTYPE_TRAIL) * 512;
	216	if (off >= ETHERMTU)
	217	return;
	218	enp->ether_type = ntohs(enpdataaddr(enp, off, u_short ));
	219	resid = ntohs((enpdataaddr(enp, off+2, u_short )));
	220	if (off + resid > len)
	221	return;
	222	len = off + resid;
	223	} else
	224	off = 0;
	225	if (len == 0)
	226	return;
	227
	228	/*
	229	* Pull packet off interface. Off is nonzero if packet
	230	* has trailing header; enpget will then force this header
	231	* information to be at the front.
	232	*/
	233	m = enpget((u_char *)enp, len, off, &es->es_if);
	234	if (m == 0)
	235	return;
	236	ether_input(&es->es_if, enp, m);
	237	}
	238
	239	enpstart(ifp)
	240	struct ifnet *ifp;
	241	{
	242
	243	if (enpput(ifp))
	244	return (ENOBUFS);
	245	else
	246	return (0);
	247	}
	248
	249	/*
	250	* Routine to copy from mbuf chain to transmitter buffer on the VERSAbus.
	251	*/
	252	enpput(ifp)
	253	struct ifnet *ifp;
	254	{
	255	register BCB *bcbp;
	256	register struct enpdevice *addr;
	257	register struct mbuf *mp;
	258	register u_char *bp;
	259	register u_int len;
	260	int unit = ifp->if_unit, ret = 1;
	261	struct mbuf *m;
	262
	263	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
	264	again:
	265	if (ringempty((RING *)&addr->enp_hostfree)) {
	266	/* ifp->if_flags \|= IFF_OACTIVE; */
	267	return (ret);
	268	}
	269	IF_DEQUEUE(&ifp->if_snd, m);
	270	if (m == 0) {
	271	ifp->if_flags &= ~IFF_OACTIVE;
	272	return (0);
	273	}
	274	bcbp = (BCB )ringget((RING )&addr->enp_hostfree);
	275	bcbp->b_len = 0;
	276	bp = (u_char *)ENPGETLONG(&bcbp->b_addr);
	277	for (mp = m; mp; mp = mp->m_next) {
	278	len = mp->m_len;
	279	if (len == 0)
	280	continue;
	281	enpcopy(mtod(mp, u_char *), bp, len);
	282	bp += len;
	283	bcbp->b_len += len;
	284	}
	285	bcbp->b_len = max(ETHERMIN+sizeof (struct ether_header), bcbp->b_len);
	286	bcbp->b_reserved = 0;
	287	if (ringput((RING *)&addr->enp_toenp, bcbp) == 1)
	288	INTR_ENP(addr);
	289	m_freem(m);
	290	ret = 0;
	291	goto again;
	292	}
	293
	294	/*
	295	* Routine to copy from VERSAbus memory into mbufs.
	296	*
	297	* Warning: This makes the fairly safe assumption that
	298	* mbufs have even lengths.
	299	*/
	300	struct mbuf *
	301	enpget(rxbuf, totlen, off, ifp)
	302	u_char *rxbuf;
	303	int totlen, off;
	304	struct ifnet *ifp;
	305	{
	306	register u_char *cp;
	307	register struct mbuf *m;
	308	struct mbuf top = 0, *mp = &top;
	309	int len;
	310	u_char *packet_end;
	311
	312	rxbuf += sizeof (struct ether_header);
	313	cp = rxbuf;
	314	packet_end = cp + totlen;
	315	if (off) {
	316	off += 2 * sizeof(u_short);
	317	totlen -= 2 *sizeof(u_short);
	318	cp = rxbuf + off;
	319	}
	320
	321	MGETHDR(m, M_DONTWAIT, MT_DATA);
	322	if (m == 0)
	323	return (0);
	324	m->m_pkthdr.rcvif = ifp;
	325	m->m_pkthdr.len = totlen;
	326	m->m_len = MHLEN;
	327
	328	while (totlen > 0) {
	329	if (top) {
	330	MGET(m, M_DONTWAIT, MT_DATA);
	331	if (m == 0) {
	332	m_freem(top);
	333	return (0);
	334	}
	335	m->m_len = MLEN;
	336	}
	337	len = min(totlen, (packet_end - cp));
	338	if (len >= MINCLSIZE) {
	339	MCLGET(m, M_DONTWAIT);
	340	if (m->m_flags & M_EXT)
	341	m->m_len = len = min(len, MCLBYTES);
	342	else
	343	len = m->m_len;
	344	} else {
	345	/*
	346	* Place initial small packet/header at end of mbuf.
	347	*/
	348	if (len < m->m_len) {
	349	if (top == 0 && len + max_linkhdr <= m->m_len)
	350	m->m_data += max_linkhdr;
	351	m->m_len = len;
	352	} else
	353	len = m->m_len;
	354	}
	355	enpcopy(cp, mtod(m, u_char *), (u_int)len);
	356	*mp = m;
	357	mp = &m->m_next;
	358	totlen -= len;
	359	cp += len;
	360	if (cp == packet_end)
	361	cp = rxbuf;
	362	}
	363	return (top);
	364	}
	365
	366	enpcopy(from, to, cnt)
	367	register u_char from, to;
	368	register u_int cnt;
	369	{
	370	register c;
	371	register short f, t;
	372
	373	if (((int)from&01) && ((int)to&01)) {
	374	/* source & dest at odd addresses */
	375	to++ = from++;
	376	--cnt;
	377	}
	378	if (cnt > 1 && (((int)to&01) == 0) && (((int)from&01) == 0)) {
	379	t = (short *)to;
	380	f = (short *)from;
	381	for (c = cnt>>1; c; --c) /* even address copy */
	382	t++ = f++;
	383	cnt &= 1;
	384	if (cnt) { /* odd len */
	385	from = (u_char *)f;
	386	to = (u_char *)t;
	387	to = from;
	388	}
	389	}
	390	while ((int)cnt-- > 0) /* one of the address(es) must be odd */
	391	to++ = from++;
	392	}
	393
	394	/*
	395	* Process an ioctl request.
	396	*/
	397	enpioctl(ifp, cmd, data)
	398	register struct ifnet *ifp;
	399	int cmd;
	400	caddr_t data;
	401	{
	402	register struct ifaddr ifa = (struct ifaddr )data;
	403	struct enpdevice *addr;
	404	int s = splimp(), error = 0;
	405
	406	switch (cmd) {
	407
	408	case SIOCSIFADDR:
	409	ifp->if_flags \|= IFF_UP;
	410	switch (ifa->ifa_addr->sa_family) {
	411	#ifdef INET
	412	case AF_INET:
	413	enpinit(ifp->if_unit);
	414	((struct arpcom *)ifp)->ac_ipaddr =
	415	IA_SIN(ifa)->sin_addr;
	416	arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
	417	break;
	418	#endif
	419	#ifdef NS
	420	case AF_NS: {
	421	struct ns_addr *ina = &IA_SNS(ifa)->sns_addr;
	422	struct enp_softc *es = &enp_softc[ifp->if_unit];
	423
	424	if (!ns_nullhost(*ina)) {
	425	ifp->if_flags &= ~IFF_RUNNING;
	426	addr = (struct enpdevice *)
	427	enpinfo[ifp->if_unit]->ui_addr;
	428	enpsetaddr(ifp->if_unit, addr,
	429	ina->x_host.c_host);
	430	} else
	431	ina->x_host = (union ns_host )es->es_addr;
	432	enpinit(ifp->if_unit);
	433	break;
	434	}
	435	#endif
	436	default:
	437	enpinit(ifp->if_unit);
	438	break;
	439	}
	440	break;
	441
	442	case SIOCSIFFLAGS:
	443	if ((ifp->if_flags&IFF_UP) == 0 && ifp->if_flags&IFF_RUNNING) {
	444	enpinit(ifp->if_unit); /* reset board */
	445	ifp->if_flags &= ~IFF_RUNNING;
	446	} else if (ifp->if_flags&IFF_UP &&
	447	(ifp->if_flags&IFF_RUNNING) == 0)
	448	enpinit(ifp->if_unit);
	449	break;
	450
	451	default:
	452	error = EINVAL;
	453	}
	454	splx(s);
	455	return (error);
	456	}
	457
	458	enpsetaddr(unit, addr, enaddr)
	459	int unit;
	460	struct enpdevice *addr;
	461	u_char *enaddr;
	462	{
	463
	464	enpcopy(enaddr, addr->enp_addr.e_baseaddr.ea_addr,
	465	sizeof (struct ether_addr));
	466	enpinit(unit);
	467	enpgetaddr(unit, addr);
	468	}
	469
	470	enpgetaddr(unit, addr)
	471	int unit;
	472	struct enpdevice *addr;
	473	{
	474	struct enp_softc *es = &enp_softc[unit];
	475
	476	enpcopy(addr->enp_addr.e_baseaddr.ea_addr, es->es_addr,
	477	sizeof (struct ether_addr));
	478	printf("enp%d: hardware address %s\n",
	479	unit, ether_sprintf(es->es_addr));
	480	}
	481
	482	/*
	483	* Routines to synchronize enp and host.
	484	*/
	485	#ifdef notdef
	486	static
	487	ringinit(rp, size)
	488	register RING *rp;
	489	{
	490
	491	rp->r_rdidx = rp->r_wrtidx = 0;
	492	rp->r_size = size;
	493	}
	494
	495	static
	496	ringfull(rp)
	497	register RING *rp;
	498	{
	499	register short idx;
	500
	501	idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
	502	return (idx == rp->r_rdidx);
	503	}
	504
	505	static
	506	fir(rp)
	507	register RING *rp;
	508	{
	509
	510	return (rp->r_rdidx != rp->r_wrtidx ? rp->r_slot[rp->r_rdidx] : 0);
	511	}
	512	#endif
	513
	514	static
	515	ringempty(rp)
	516	register RING *rp;
	517	{
	518
	519	return (rp->r_rdidx == rp->r_wrtidx);
	520	}
	521
	522	static
	523	ringput(rp, v)
	524	register RING *rp;
	525	BCB *v;
	526	{
	527	register int idx;
	528
	529	idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
	530	if (idx != rp->r_rdidx) {
	531	ENPSETLONG(&rp->r_slot[rp->r_wrtidx], v);
	532	rp->r_wrtidx = idx;
	533	if ((idx -= rp->r_rdidx) < 0)
	534	idx += rp->r_size;
	535	return (idx); /* num ring entries */
	536	}
	537	return (0);
	538	}
	539
	540	static
	541	ringget(rp)
	542	register RING *rp;
	543	{
	544	register int i = 0;
	545
	546	if (rp->r_rdidx != rp->r_wrtidx) {
	547	i = ENPGETLONG(&rp->r_slot[rp->r_rdidx]);
	548	rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
	549	}
	550	return (i);
	551	}
	552
	553	/*
	554	* ENP Ram device.
	555	*/
	556	enpr_open(dev)
	557	dev_t dev;
	558	{
	559	register int unit = ENPUNIT(dev);
	560	struct vba_device *ui;
	561	struct enpdevice *addr;
	562
	563	if (unit >= NENP \|\| (ui = enpinfo[unit]) == 0 \|\| ui->ui_alive == 0 \|\|
	564	(addr = (struct enpdevice *)ui->ui_addr) == 0)
	565	return (ENODEV);
	566	if (addr->enp_state != S_ENPRESET)
	567	return (EACCES); /* enp is not in reset state, don't open */
	568	return (0);
	569	}
	570
	571	/ARGSUSED/
	572	enpr_close(dev)
	573	dev_t dev;
	574	{
	575
	576	return (0);
	577	}
	578
	579	enpr_read(dev, uio)
	580	dev_t dev;
	581	register struct uio *uio;
	582	{
	583	register struct iovec *iov;
	584	struct enpdevice *addr;
	585
	586	if (uio->uio_offset > RAM_SIZE)
	587	return (ENODEV);
	588	iov = uio->uio_iov;
	589	if (uio->uio_offset + iov->iov_len > RAM_SIZE)
	590	iov->iov_len = RAM_SIZE - uio->uio_offset;
	591	addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
	592	if (useracc(iov->iov_base, (unsigned)iov->iov_len, 0) == 0)
	593	return (EFAULT);
	594	enpcopy((u_char *)&addr->enp_ram[uio->uio_offset],
	595	(u_char *)iov->iov_base, (u_int)iov->iov_len);
	596	uio->uio_resid -= iov->iov_len;
	597	iov->iov_len = 0;
	598	return (0);
	599	}
	600
	601	enpr_write(dev, uio)
	602	dev_t dev;
	603	register struct uio *uio;
	604	{
	605	register struct enpdevice *addr;
	606	register struct iovec *iov;
	607
	608	addr = (struct enpdevice *)enpinfo[ENPUNIT(dev)]->ui_addr;
	609	iov = uio->uio_iov;
	610	if (uio->uio_offset > RAM_SIZE)
	611	return (ENODEV);
	612	if (uio->uio_offset + iov->iov_len > RAM_SIZE)
	613	iov->iov_len = RAM_SIZE - uio->uio_offset;
	614	if (useracc(iov->iov_base, (unsigned)iov->iov_len, 1) == 0)
	615	return (EFAULT);
	616	enpcopy((u_char *)iov->iov_base,
	617	(u_char *)&addr->enp_ram[uio->uio_offset], (u_int)iov->iov_len);
	618	uio->uio_resid -= iov->iov_len;
	619	uio->uio_offset += iov->iov_len;
	620	iov->iov_len = 0;
	621	return (0);
	622	}
	623
	624	/ARGSUSED/
	625	enpr_ioctl(dev, cmd, data)
	626	dev_t dev;
	627	caddr_t data;
	628	{
	629	register unit = ENPUNIT(dev);
	630	struct enpdevice *addr;
	631
	632	addr = (struct enpdevice *)enpinfo[unit]->ui_addr;
	633	switch(cmd) {
	634
	635	case ENPIOGO:
	636	ENPSETLONG(&addr->enp_base, addr);
	637	addr->enp_intrvec = enp_softc[unit].es_ivec;
	638	ENP_GO(addr, ENPSTART);
	639	DELAY(200000);
	640	enpinit(unit);
	641	/*
	642	* Fetch Ethernet address after link level
	643	* is booted (firmware copies manufacturer's
	644	* address from on-board ROM).
	645	*/
	646	enpgetaddr(unit, addr);
	647	addr->enp_state = S_ENPRUN;
	648	break;
	649
	650	case ENPIORESET:
	651	RESET_ENP(addr);
	652	addr->enp_state = S_ENPRESET;
	653	DELAY(100000);
	654	break;
	655	default:
	656	return (EINVAL);
	657	}
	658	return (0);
	659	}
	660	#endif