xref: /csrg-svn/sys/tahoe/if/if_enp.c (revision 29649)

/*	if_enp.c	1.1	86/07/20	*/

#include "enp.h"
#define ENPBPTE 128
#if NENP > 0

/*
 * Modified 3 Com Ethernet Controller interface
 * enp modifications added S. F. Holmgren
 */

#include "param.h"
#include "systm.h"
#include "mbuf.h"
#include "buf.h"
#include "protosw.h"
#include "socket.h"
#include "vmmac.h"
#include "errno.h"
#include "time.h"
#include "kernel.h"
#include "uio.h"

#include "../net/if.h"
#include "../net/netisr.h"
#include "../net/route.h"
#include "../netinet/in.h"
#include "../h/ioctl.h"

#include "../netinet/in_systm.h"
#include "../netinet/ip.h"
#include "../netinet/ip_var.h"
#include "../netinet/if_ether.h"

#include "../tahoevba/vbavar.h"
#include "../tahoeif/if_enp.h"
#include "../machine/mtpr.h"
#include "../tahoeif/if_debug.h"

#define ENP0_PHYSADDR	0xf40000	/* board # 0 physical base addr */
#define ENP1_PHYSADDR	0xf60000	/* board # 1 physical base addr */
#define ENPSTART	0xf02000	/* standard enp start addr 	*/

int	enpprobe(), enpattach(), enpintr();
extern	nulldev();
caddr_t	vtoph();
struct  mbuf *m_tofree();
struct  vba_device *enpinfo[ NENP ];

/*	Maximun 2 controllers per system supported			*/

long  enpstd[] = { ENP0_PHYSADDR+0x1000,ENP1_PHYSADDR+0x1000, 0 };
extern	char	enp0utl[], enp1utl[];	/* enp accessible ram map	*/
char	*enpmap[]= { enp0utl, enp1utl };
extern	long	ENP0map[], ENP1map[];
long	*ENPmap[] = {ENP0map, ENP1map};
long	ENPmapa[] = {0xfff41000, 0xfff61000};
long	enpismapped[NENP];

unsigned short intvec[4] =
	{ 0xc1, 0xc2, 0xc3, 0xc4 };	/* intrvec of upto 4 enps	*/

struct  vba_driver enpdriver =
{
/* use of prom based version
	enpprobe, 0, enpattach, 0, 0,	enpintr,
*/
	enpprobe, 0, nulldev, 0,
	enpstd,   "enp", enpinfo, "ENP 20", 0
};

int     enpinit(),
	enpioctl(),
	enpoutput(),
	enpreset(),
	enpbroadcast(),
	enptimeout();

int	enpcopy();

struct  mbuf *enpget();

extern  struct ifnet loif;

/*
 * 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	enp_softc[NENP];
long	stat_addr[NENP];	/* enp statistic addr (for nstat use) */
long	ring_addr[NENP];	/* enp dev ring addresses (for nstat use) */
int 	numenp = NENP;
int	enp_intr = 0, 		/* no. of enp_to_host interrupts */
	host_intr = 0;		/* no. of host_to_enp interrupts */
short	enpram[NENP];		/* open/close flags for enp devices */
/*	Debugging tools, used to trace input packets */
extern 	int	printerror;	/* error print flag, from if_ace.c */
int	save_enp_inpkt = 0;
#define	ENPTRACE(X)	if (save_enp_inpkt) X;

struct 	inp_err 	enperr[NENP];

/*
 * Probe for device.
 */

enpprobe(reg)
caddr_t reg;
{
	static	int 	unit=0;
	register ENPDEVICE	*addr = (ENPDEVICE *)reg;

	if( (badaddr( addr, 2 ) ) || (badaddr( &addr->enp_ram[0], 2 ) ) )
		return( 0 );
	addr->enp_state = S_ENPRESET; /* controller is reset by vbus reset */
	/* save address of statistic area for nstat uses	*/

	stat_addr[unit] = (long) &(addr->enp_stat);
	ring_addr[unit++] = (long) &(addr->enp_toenp);

	return( ENPSIZE );
}

/*
 * Interface exists: make available by filling in network interface
 * record.  System will initialize the interface when it is ready
 * to accept packets.
 */

enpattach( md )
register struct vba_device *md;
{
	struct enp_softc 	*es = &enp_softc[md->ui_unit];
	register struct ifnet 	*ifp = &es->es_if;
	register ENPDEVICE 	*addr = (ENPDEVICE *)md->ui_addr;
	struct sockaddr_in 	*sin;

	enpgetaddr( md->ui_unit );

	ifp->if_unit = md->ui_unit;
	ifp->if_name = "enp";
	ifp->if_mtu = ETHERMTU;

/*	bcopy(&es->es_boardaddr, es->es_enaddr, sizeof(es->es_enaddr)); */

	sin = (struct sockaddr_in *)&es->es_if.if_addr;
	sin->sin_family = AF_INET;

	ifp->if_init = enpinit;
	ifp->if_ioctl = enpioctl;
	ifp->if_output = enpoutput;
	ifp->if_reset = enpreset;
	if_attach(ifp);
}


/*
 * Reset of interface after UNIBUS reset.
 */
enpreset(unit)
int unit;
{
	register struct vba_device *md;

	if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
		return(ENODEV);

	enpinit(unit);
}

/*
 * Initialization of interface; clear recorded pending
 * operations.
 */

enpinit( unit )
int unit;
{
	struct enp_softc 	*es = &enp_softc[unit];
	ENPDEVICE 		*addr;
	int i, s;
	u_char *cp, *ap;
	register struct ifnet 	*ifp = &es->es_if;
	register struct sockaddr_in *sin, *sinb;

	sin = (struct sockaddr_in *)&ifp->if_addr;

	if ( !enpismapped[unit] ) {
		ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
		++enpismapped[unit];
	}
	if ((addr = (ENPDEVICE *)enpinfo[unit]->ui_addr) == (ENPDEVICE *)0)
		return(ENODEV);
	s = splimp();
	RESET_ENP( addr );
	DELAY( 200000 );

#ifdef notdef
/* only needed if not downloading ( ie, ROM-resident ENP code) */
	addr->enp_intrvec = intvec[unit];
	ENP_GO( addr,ENPSTART );
	DELAY( 200000 );
/* end of ROM-resident */
#endif notdef

	es->es_if.if_flags |= IFF_UP|IFF_RUNNING; /* open for business*/
	splx(s);

	if_rtinit( &es->es_if,RTF_UP );
	arpwhohas(&es->es_ac, &sin->sin_addr);
}


/*
 * Ethernet interface interrupt.
 */

enpintr( unit )
{
	register ENPDEVICE 		*addr;
	register BCB			*bcbp;
	register struct vba_device	 *md;

	enp_intr++;

	if (unit >= NENP || (md = enpinfo[unit]) == 0)
		return;

	addr = (ENPDEVICE *)md->ui_addr;

	if( IS_ENP_INTR(addr) == 0 )
		return;

	ACK_ENP_INTR( addr );

	while( (bcbp = (BCB *)ringget( &addr->enp_tohost )) != 0 )
	{
		enpread( &enp_softc[ unit ],bcbp, unit );
		ringput( &addr->enp_enpfree,bcbp );
	}
	return(0);
}

#define	MAXBLEN	1500
char	errpkt[MAXBLEN];
int	bufptr = 0;
int	maxl_tosave = 200;		/* save only the first 200 bytes */

saverrpkt(errbuf, errtype, len)
register u_char *errbuf;
int errtype, len;
{
	int remain, newptr;

	remain = MAXBLEN - bufptr;
	if (remain < 50)		/* if too small			*/
		return;			/* no space avail		*/
	len = (len > maxl_tosave || len <= 0) ? maxl_tosave : len;
	len = len > remain ? (remain - 2*sizeof(len)): len;
	newptr = bufptr + len + 2*sizeof(len);
	if (newptr <= MAXBLEN) {
		enpcopy((char *)&len, &errpkt[bufptr], sizeof(len));
		enpcopy((char *)&errtype, &errpkt[bufptr+sizeof(len)],
			sizeof(errtype));
		enpcopy(errbuf, &errpkt[bufptr+(2*sizeof(len))], len);
	}
	bufptr = newptr;
}

/*
 * Read input packet, examine its packet type, and enqueue it.
 */

enpread( es, bcbp, unit )
struct	enp_softc *es;
register BCB *bcbp;
int	unit;
{
	register struct ether_header *enp;
	struct mbuf *m;
	long int  s, v;
	register short *vp = (short *)&v,
			*sp;
	int len, off, resid, enptype;
	register struct ifqueue *inq;

	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_ETHEADER;
#ifdef TAHOE
	sp = (short *)&bcbp->b_addr;
	*vp = *sp; vp[1] = sp[1];
	enp = (struct ether_header *) v;
#else
	enp = (struct ether_header *)bcbp->b_addr;
#endif TAHOE

#define enpdataaddr(enp, off, type) ((type)(((caddr_t)(((char *)enp)+SIZEOF_ETHEADER)+(off))))

	enptype = enp->ether_type;
	if (enptype >= ETHERPUP_TRAIL && enptype < ETHERPUP_TRAIL+ETHERPUP_NTRAILER)
	{
		off = (enptype - ETHERPUP_TRAIL) * 512;
		if (off >= ETHERMTU) {
			enperr[unit].bad_offset++;
			ENPTRACE(saverrpkt((char *)enp, B_OFFSET, bcbp->b_msglen));

			goto badinput;
		}
		enptype = *enpdataaddr(enp, off, u_short *);
		resid = *(enpdataaddr(enp, off+2, u_short *));

		if (off + resid > len) {
			enperr[unit].bad_length++;
			ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen));
			goto badinput;
		}
		len = off + resid;
	}
	else
		off = 0;

	if( len == 0 ) {
		enperr[unit].bad_length++;
		ENPTRACE(saverrpkt((char *)enp, B_LENGTH, bcbp->b_msglen));
		goto badinput;
	}
	/*
	 * Pull packet off interface.  Off is nonzero if packet
	 * has trailing header; enpget will then force this header
	 * information to be at the front, but we still have to drop
	 * the type and length which are at the front of any trailer data.
	 */

	m = enpget(bcbp, len, off);
	if( m == 0 )  {
		enperr[unit].h_nobuffer++; /* host runs out of buf */
		goto badinput;
	}
	if( off )
	{
		m->m_off += 2 * sizeof (u_short);
		m->m_len -= 2 * sizeof (u_short);
	}

	switch (enptype)
	{
#ifdef INET
	case ETHERPUP_IPTYPE:
#ifdef notdef
		arpipin(enp, m);
#endif notdef
		schednetisr(NETISR_IP);
		inq = &ipintrq;
		break;

	case ETHERPUP_ARPTYPE:
		arpinput(&es->es_ac, m);
		return(0);
#endif
	default:	/* unrecognized ethernet header */
		enperr[unit].bad_packetype++;
		if (printerror) {
			printf("\nenp%d: Undefined packet type 0x%x ", unit,
				enp->ether_type);
			printf("from host: %x.%x.%x.%x.%x.%x\n",
				enp->ether_shost[0], enp->ether_shost[1],
				enp->ether_shost[2], enp->ether_shost[3],
				enp->ether_shost[4], enp->ether_shost[5]);
		}	/* end debugging aid	*/
		ENPTRACE(saverrpkt((char *)enp, B_PACKETYPE, bcbp->b_msglen));
		m_freem(m);
		goto badinput;
	}

	if (IF_QFULL(inq))
	{
		enperr[unit].inq_full++;
		IF_DROP(inq);
		m_freem(m);
		return(0);
	}
	s = splimp();
	IF_ENQUEUE(inq, m);
	splx(s);
badinput:
	return(0);         /* sanity */
}

/*
 * Ethernet output routine. (called by user)
 * Encapsulate a packet of type family for the local net.
 * Use trailer local net encapsulation if enough data in first
 * packet leaves a multiple of 512 bytes of data in remainder.
 * If destination is this address or broadcast, send packet to
 * loop device to kludge around the fact that 3com interfaces can't
 * talk to themselves.
 */

enpoutput(ifp, m0, dst)
struct ifnet *ifp;
struct mbuf *m0;
struct sockaddr *dst;
{
	int type, s, error;
	struct ether_addr edst;
	struct in_addr idst;

	register struct enp_softc *es = &enp_softc[ifp->if_unit];
	register struct mbuf *m = m0;
	register struct ether_header *enp;
	register int off, i;

	struct mbuf *mcopy = (struct mbuf *) 0;         /* Null */
	int unit = ifp->if_unit;

	switch( dst->sa_family )
	{
#ifdef INET
	case AF_INET:
		idst = ((struct sockaddr_in *)dst)->sin_addr;

		/* translate internet to ethernet address */

		switch(arpresolve(&es->es_ac, m, &idst, &edst)) {

		   	case ARPRESOLVE_WILLSEND:
				return (0);	/* if not yet resolved */
		   	case ARPRESOLVE_BROADCAST:
				mcopy = m_copy(m, 0, (int)M_COPYALL);
				if (mcopy)
					looutput(&loif, mcopy, dst);

				/* falls through ... */
		   	case ARPRESOLVE_OK:
				break;
		}
		off = ((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
		if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
			if (off > 0 && (off & 0x1ff) == 0 &&
			    m->m_off >= MMINOFF + 2 * sizeof (u_short))
			{
				type = ETHERPUP_TRAIL + (off>>9);
				m->m_off -= 2 * sizeof (u_short);
				m->m_len += 2 * sizeof (u_short);
				*mtod(m, u_short *) = ETHERPUP_IPTYPE;
				*(mtod(m, u_short *) + 1) = m->m_len;
				goto gottrailertype;
			}

		type = ETHERPUP_IPTYPE;
		off = 0;
		goto gottype;
#endif

#ifdef notdef
	case AF_RAW:
		enp = mtod(m, struct ether_header *);
		if (m->m_len < sizeof *enp)
		{
			error = EMSGSIZE;
			goto bad;
		}
		goto gotheader;
#endif

	case AF_UNSPEC:
		enp = (struct ether_header *)dst->sa_data;
		bcopy( enp->ether_dhost, &edst, sizeof(edst));
		type = enp->ether_type;
		goto gottype;

	default:
		if (printerror)
		    printf("enp%d: can't handle af%d\n", unit,dst->sa_family);
		error = EAFNOSUPPORT;
		goto bad;
	}

gottrailertype:
	/*
	 * Packet to be sent as trailer: move first packet
	 * (control information) to end of chain.
	 */
	while (m->m_next)
		m = m->m_next;
	m->m_next = m0;
	m = m0->m_next;
	m0->m_next = 0;
	m0 = m;

gottype:
	/*
         * Add local net header.  If no space in first mbuf,
         * allocate another.
         */
	if (m->m_off > MMAXOFF ||
	    MMINOFF + SIZEOF_ETHEADER > m->m_off)
	{
		m = m_get(M_DONTWAIT, MT_HEADER);
		if (m == 0)
		{
			enperr[unit].h_nobuffer++; /* host runs out of buf */
			error = ENOBUFS;
			goto bad;
		}
		m->m_next = m0;
		m->m_off = MMINOFF;
		m->m_len = SIZEOF_ETHEADER;
	}
	else
	{
		m->m_off -= SIZEOF_ETHEADER;
		m->m_len += SIZEOF_ETHEADER;
	}
	enp = mtod(m, struct ether_header *);
	bcopy( &edst, enp->ether_dhost, sizeof(enp->ether_dhost) );
	enp->ether_type = type;
gotheader:
	bcopy( es->es_enaddr, enp->ether_shost, sizeof(enp->ether_shost));

	/*
	 * Queue message on interface if possible
	 */

	s = splimp();
	if( enpput( unit,m ) )
	{
		error = ENOBUFS;
		enperr[unit].c_nobuffer++; /* controller runs out of buf */
		goto qfull;
	}
	splx( s );
	es->es_if.if_opackets++;
	return(0);
qfull:
	splx( s );
	m0 = m;
bad:
	m_freem(m0);
	return(error);
}

/*
 * Routine to copy from mbuf chain to transmitter
 * buffer in Multibus memory.
 */

enpput( unit,m )
int unit;
struct mbuf *m;
{
	register BCB *bcbp;
	register ENPDEVICE *addr;
	register struct mbuf *mp;
	register u_char *bp;
	int	 ctr = 0;
	long int	v;
	register short *vp = (short *)&v,
			*sp;

	addr = (ENPDEVICE *)enpinfo[ unit ]->ui_addr;

	if ( ringempty( &addr->enp_hostfree ) )
			return( 1 );

	bcbp = (BCB *)ringget( &addr->enp_hostfree );
	bcbp->b_len = 0;
#ifdef TAHOE
	sp = (short *)&bcbp->b_addr;
	*vp = *sp; vp[1] = sp[1];
	bp = (u_char *)v;
#else
	bp = (u_char *)bcbp->b_addr;
#endif TAHOE
	for (mp = m; mp; mp = mp->m_next)
	{
		register unsigned len;
		u_char *mcp;

		len = mp->m_len;
		if( len == 0 )
			continue;
		mcp = mtod( mp,u_char * );
		enpcopy( mcp,bp,len );
		bp += len;
		bcbp->b_len += len;
	}
	bcbp->b_len = max( MINPKTSIZE,bcbp->b_len );
	bcbp->b_reserved = 0;
	if ( ringput( &addr->enp_toenp,bcbp ) == 1 ) {
		host_intr++;
		INTR_ENP( addr );
	}
	m_freem(m);
	return( 0 );
}

/*
 * Routine to copy from Multibus memory into mbufs.
 *
 * Warning: This makes the fairly safe assumption that
 * mbufs have even lengths.
 */
struct mbuf *
enpget( bcbp, totlen, off0 )
register BCB *bcbp;
int totlen, off0;
{
	register struct mbuf *m;
	register int off = off0;
	register unsigned char *cp;
	long int	v;
	register short *vp = (short *)&v,
			*sp;

	int len;
	struct mbuf *top = 0;
	struct mbuf **mp = &top;

#ifdef TAHOE
	sp = (short *)&bcbp->b_addr;
	*vp = *sp; vp[1] = sp[1];
	cp = (unsigned char *)v + SIZEOF_ETHEADER;
#else
	cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
#endif TAHOE

	while( totlen > 0 )
	{
		u_char *mcp;

		MGET(m, M_DONTWAIT, MT_DATA);
		if (m == 0)
			goto bad;
		if( off )
		{
			len = totlen - off;
#ifdef TAHOE
			sp = (short *)&bcbp->b_addr;
			*vp = *sp; vp[1] = sp[1];
			cp = (unsigned char *)v + SIZEOF_ETHEADER
				+ off;
#else
			cp = (unsigned char *)bcbp->b_addr +
				SIZEOF_ETHEADER + off;
#endif TAHOE
		}
		else
			len = totlen;


		if (len >= CLBYTES) {
			struct mbuf *p;

			MCLGET(p, 1);
			if (p != 0) {
				m->m_len = len = CLBYTES;
				m->m_off = (int)p - (int)m;
			} else  {
				m->m_len = len = MIN(MLEN, len);
				m->m_off = MMINOFF;
				}
		} else  {
			m->m_len = len = MIN(MLEN, len);
			m->m_off = MMINOFF;
		}

		mcp = mtod(m, u_char *);
		enpcopy(cp, mcp, len);
		cp += len;
		*mp = m;
		mp = &m->m_next;
		if (off == 0)
		{
			totlen -= len;
			continue;
		}
		off += len;
		if (off == totlen)
		{
#ifdef TAHOE
			sp = (short *)&bcbp->b_addr;
			*vp = *sp; vp[1] = sp[1];
			cp = (unsigned char *)v + SIZEOF_ETHEADER;
#else
			cp = (unsigned char *)bcbp->b_addr + SIZEOF_ETHEADER;
#endif TAHOE
			off = 0;
			totlen = off0;
		}
	}
	return (top);
bad:
	m_freem(top);
	return (0);
}

/*
 * Process an ioctl request.
 *    this can be called via the "socket" route for SIOCSIFADDR or
 *	by the cdev/inode route for SIOCSIFCCFWR/RD
 *
 */

enpioctl(ifp, cmd, data)
register struct ifnet *ifp;
int cmd;
caddr_t data;
{
	register int	unit = ifp->if_unit;
	register struct vba_device *md;
	int s, error = 0;
	struct sockaddr_in	*sin;
	struct sockaddr		*sa;
	struct enp_softc	*es = &enp_softc[ifp->if_unit];
	ENPDEVICE		*addr;
	struct config_entry	*cf;
	struct ifreq *ifr	= (struct ifreq *)data;
	struct sockaddr_in	*et_addr;
	int code, i;


	if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0)
		return(ENODEV);

	switch (cmd) {

	case SIOCSIFADDR:
		s = splimp();
		sa = (struct sockaddr *)&ifr->ifr_addr;
		if (sa->sa_family == AF_UNSPEC ) {
			if (sa->sa_data[0] & 1){ /*broad or multi-cast*/
				splx( s );
				return( EINVAL );
			}
			bcopy(sa->sa_data,es->es_enaddr,sizeof(es->es_enaddr));
			enpinit( ifp->if_unit);
			break;
		}
		sin = (struct sockaddr_in *)&ifr->ifr_addr;
		if (sin->sin_family != AF_INET){
			splx( s );
			return( EINVAL );
		}
		if (ifp->if_flags & IFF_RUNNING)
			if_rtinit(ifp, -1);     /* delete previous route */
		enpsetaddr(ifp, sin);
		enpinit(ifp->if_unit);
		enpgetaddr( ifp->if_unit );
		splx(s);
		break;


	case SIOCSETETADDR:	/* Set Ethernet station address */
		s = splimp();
		ifp->if_flags &= (~IFF_RUNNING | IFF_UP);
		et_addr = (struct sockaddr_in *)&ifr->ifr_addr;
		addr = (ENPDEVICE *)enpinfo[ifp->if_unit]->ui_addr;

		/* Set station address and reset controller board */
		{
		u_char	*to = &addr->enp_addr.e_baseaddr.ea_addr[0];
		char	*from = &et_addr->sin_zero[2];
		int	i;

		for (i = 0 ; i < ETHADDR_SIZE; i++)
			*to++ = (u_char) (~(*from++ & 0xff));
		}
		enpcopy(&addr->enp_addr.e_listsize, &code, sizeof(code));
		code |= E_ADDR_SUPP;
		enpcopy(&code, &addr->enp_addr.e_listsize, sizeof(code));
		enpreset(ifp->if_unit);		/* Re-initialize */
		enpgetaddr(ifp->if_unit);
		splx(s);
		break;

	case SIOCGETETADDR:	/* Get Foreign Hosts' Ethernet addresses */
		arpwhohas(&es->es_ac, (struct in_addr *)ifr->ifr_data);
		break;

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

enpsetaddr(ifp, sin)
register struct ifnet *ifp;
register struct sockaddr_in *sin;
{

	ifp->if_addr = *(struct sockaddr *)sin;
	ifp->if_net = in_netof(sin->sin_addr);
	ifp->if_host[0] = in_lnaof(sin->sin_addr);
	sin = (struct sockaddr_in *)&ifp->if_broadaddr;
	sin->sin_family = AF_INET;
	sin->sin_addr = if_makeaddr(ifp->if_net, INADDR_ANY);
	ifp->if_flags |= IFF_BROADCAST;
}


/*
 * Get the ethernet addr, store it and print it
 * Read the ethernet address off the board, one byte at a time.
 *	put it in enp_softc
 */


enpgetaddr( unit )
int unit;
{
	register struct enp_softc	*es = &enp_softc[unit];
	register ENPDEVICE *addr =(ENPDEVICE *)enpinfo[unit]->ui_addr;
	int i;

#ifdef TAHOE
	enpcopy(&addr->enp_addr.e_baseaddr, &es->es_boardaddr, sizeof(es->es_boardaddr));
#else
	es->es_boardaddr = addr->enp_addr.e_baseaddr;
#endif TAHOE
	bcopy(&es->es_boardaddr, es->es_enaddr, ETHADDR_SIZE);
	return( 1 );
}

/*
 * enpram device
 *
 */

enpr_open( dev )
{
	register int	unit = minor(dev);
	register struct vba_device *md;
	register ENPDEVICE	*addr;

	if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
	    (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
		return(ENODEV);
	if (addr->enp_state != S_ENPRESET)
		return(EACCES);  /* enp is not in reset state, don't open  */
	if ( !enpismapped[unit] ) {
		ioaccess(ENPmap[unit],ENPmapa[unit],ENPBPTE);
		++enpismapped[unit];
	}
	enpram[unit] = ENP_OPEN;
	return( 0 );
}

enpr_close(dev)
{
	enpram[minor(dev)] = ENP_CLOSE;
	return( 0 );
}

enpr_read( dev,uio )
int dev;
register struct uio *uio;
{
	register ENPDEVICE *addr;
	register struct iovec *iov;
	register r=0;

	if (enpram[minor(dev)] != ENP_OPEN)
		return(EACCES);
	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;
	addr = (ENPDEVICE *)enpinfo[ minor( dev ) ]->ui_addr;
	iov  = uio->uio_iov;

	if( r = enpcopyout( &addr->enp_ram[ uio->uio_offset ], iov->iov_base,
			 iov->iov_len ) )
		 return( r );

	uio->uio_resid -= iov->iov_len;
	iov->iov_len = 0;

	return( 0 );
}

enpr_write( dev,uio )
int dev;
register struct uio *uio;
{
	register ENPDEVICE *addr;
	register struct iovec *iov;
	register r=0;

	if (enpram[minor(dev)] != ENP_OPEN)
		return(EACCES);
	addr = (ENPDEVICE *)enpinfo[ minor( 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( r = enpcopyin( iov->iov_base, &addr->enp_ram[ uio->uio_offset ],
			iov->iov_len ) )
		return( r );

	uio->uio_resid -= iov->iov_len;
	iov->iov_len = 0;

	return( 0 );
}

enpr_ioctl( dev,cmd,arg,fflag )
dev_t dev;
caddr_t *arg;
{
	register ENPDEVICE *addr;
	long int	v;
	register short	*vp = (short *)&v, *sp;
	register unit = minor(dev);
	register struct vba_device *md;

	if (unit >= NENP || (md = enpinfo[unit]) == 0 || md->ui_alive == 0 ||
	    (addr = (ENPDEVICE *)md->ui_addr) == (ENPDEVICE *)0)
		return(ENODEV);
	switch( cmd )
	{
		case ENPIOGO:
/* not needed if prom based version */
#ifdef TAHOE
			sp = (short *)&addr->enp_base;
			v = (int)addr;
			*sp = *vp; sp[1] = vp[1];
#else
			addr->enp_base = (int)addr;
#endif TAHOE
			addr->enp_intrvec = intvec[ unit ];
			ENP_GO( addr, ENPSTART );
			DELAY( 200000 );
			enpattach( enpinfo[ unit ] );
			enpinit( unit );
			addr->enp_state = S_ENPRUN;  /* it is running now */
/* end of not needed */

			break;

		case ENPIORESET:
			RESET_ENP( addr );
			addr->enp_state = S_ENPRESET;  /* it is reset now */
			DELAY( 100000 );
			break;
	}
	return( 0 );
}

/*
 * routines to synchronize enp and host
 */

static
ringinit( rp,size )
register RING *rp;
{
	register int	i;
	register short *sp;

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

static
ringempty( rp )
register RING *rp;
{
	return( rp->r_rdidx == rp->r_wrtidx );
}

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

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

static
ringput( rp,v )
register RING *rp;
{
	register int idx;
	register short *vp = (short *)&v,
		       *sp;

	idx = (rp->r_wrtidx + 1) & (rp->r_size-1);
	if( idx != rp->r_rdidx )
	{
#ifdef TAHOE
		sp = (short *)&rp->r_slot[ rp->r_wrtidx ];
		*sp = *vp; sp[1] = vp[1];
#else
		rp->r_slot[ rp->r_wrtidx ] = v;
#endif TAHOE
		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;
	long int v;
	register short *vp = (short *)&v,
		       *sp;

	if( rp->r_rdidx != rp->r_wrtidx )
	{
#ifdef TAHOE
		sp = (short *)&rp->r_slot[ rp->r_rdidx ];
		*vp = *sp; vp[1] = sp[1];
		i = v;
#else
		i = rp->r_slot[ rp->r_rdidx ];
#endif TAHOE
		rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
	}
	return( i );
}

#ifdef notdef
struct mbuf *
m_tofree( rp )
register RING *rp;
{
	long int v = 0;
	register short *vp = (short *)&v,
		       *sp;

	if( rp->r_rdidx != rp->r_wrtidx )
	{
#ifdef TAHOE
		sp = (short *)&rp->r_slot[ rp->r_rdidx ];
		*vp = *sp; vp[1] = sp[1];
		/* *sp = 0xffff; sp[1] = 0xffff; */
#else
		v = rp->r_slot[ rp->r_rdidx ];
#endif TAHOE
	  	rp->r_rdidx = (++rp->r_rdidx) & (rp->r_size-1);
	}
	return( (struct mbuf *)v );
}
#endif
static
fir( rp )
register RING *rp;
{
	long int v;
	register short *vp = (short *)&v,
		       *sp;

	if( rp->r_rdidx != rp->r_wrtidx )
#ifdef TAHOE
	{
		sp = (short *)&rp->r_slot[ rp->r_rdidx ];
		*vp = *sp; vp[1] = sp[1];
		return( v );
	}
#else
		return( rp->r_slot[ rp->r_rdidx ] );
#endif TAHOE
	else
		return( 0 );
}


static
prtbytes( addr )
register char *addr;
{
	register int i;

	for( i = 0; i < 12; i++ )
	{
		printf("%X ",*addr&0377);
		addr++;
	}
	printf("\n");
}

static
enpcopy(from, to, cnt)
register char *from, *to;
register 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 = (char *) f;
			to   = (char *) t;
			*to = *from;
		}
	}
	while (cnt-- > 0)	/* one of the address(es) must be odd */
		*to++ = *from++;

}

static
enpcopyin(userv, kernv, cnt)
{

	if (useracc(userv, cnt, 1)) {
		enpcopy( userv, kernv, cnt );
		return( 0 );
	}
	else	return( EFAULT );
}


static
enpcopyout(kernv, userv, cnt)
{

	if (useracc(userv, cnt, 0)) {
		enpcopy( kernv, userv, cnt );
		return( 0 );
	}
	else	return( EFAULT );
}
#endif