Initial source

1 files changed, 1240 insertions, 0 deletions

diff --git a/i386/i386at/if_3c501.c b/i386/i386at/if_3c501.c
new file mode 100644
index 0000000..b822d27
--- /dev/null
+++ b/i386/i386at/if_3c501.c
@@ -0,0 +1,1240 @@
+/* 
+ * Mach Operating System
+ * Copyright (c) 1991,1990,1989 Carnegie Mellon University
+ * All Rights Reserved.
+ * 
+ * Permission to use, copy, modify and distribute this software and its
+ * documentation is hereby granted, provided that both the copyright
+ * notice and this permission notice appear in all copies of the
+ * software, derivative works or modified versions, and any portions
+ * thereof, and that both notices appear in supporting documentation.
+ * 
+ * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
+ * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
+ * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
+ * 
+ * Carnegie Mellon requests users of this software to return to
+ * 
+ *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
+ *  School of Computer Science
+ *  Carnegie Mellon University
+ *  Pittsburgh PA 15213-3890
+ * 
+ * any improvements or extensions that they make and grant Carnegie Mellon
+ * the rights to redistribute these changes.
+ */
+/*
+ *	File:	if_3c501.c
+ *	Author: Philippe Bernadat
+ *	Date:	1989
+ * 	Copyright (c) 1989 OSF Research Institute 
+ *
+ * 	3COM Etherlink 3C501 Mach Ethernet drvier
+ */
+/*
+  Copyright 1990 by Open Software Foundation,
+Cambridge, MA.
+
+		All Rights Reserved
+
+  Permission to use, copy, modify, and distribute this software and
+its documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appears in all copies and
+that both the copyright notice and this permission notice appear in
+supporting documentation, and that the name of OSF or Open Software
+Foundation not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+  OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
+INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS,
+IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
+NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
+WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <at3c501.h>
+
+#ifdef	MACH_KERNEL
+#include	<kern/time_out.h>
+#include	<device/device_types.h>
+#include	<device/errno.h>
+#include	<device/io_req.h>
+#include	<device/if_hdr.h>
+#include	<device/if_ether.h>
+#include	<device/net_status.h>
+#include	<device/net_io.h>
+#else	MACH_KERNEL
+#include	<sys/param.h>
+#include	<mach/machine/vm_param.h>
+#include	<sys/systm.h>
+#include	<sys/mbuf.h>
+#include	<sys/buf.h>
+#include	<sys/protosw.h>
+#include	<sys/socket.h>
+#include	<sys/vmmac.h>
+#include	<sys/ioctl.h>
+#include	<sys/errno.h>
+#include	<sys/syslog.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/if_ether.h>
+#endif
+
+#ifdef	NS
+#include	<netns/ns.h>
+#include	<netns/ns_if.h>
+#endif
+#endif	MACH_KERNEL
+
+#include	<i386/ipl.h>
+#include	<chips/busses.h>
+#include	<i386at/if_3c501.h>
+
+#define	SPLNET	spl6
+
+int	at3c501probe();
+void	at3c501attach();
+int	at3c501intr();
+int	at3c501init();
+int	at3c501output();
+int	at3c501ioctl();
+int	at3c501reset();
+int	at3c501watch();
+
+static vm_offset_t at3c501_std[NAT3C501] = { 0 };
+static struct bus_device *at3c501_info[NAT3C501];
+struct	bus_driver	at3c501driver = 
+	{at3c501probe, 0, at3c501attach, 0, at3c501_std, "et", at3c501_info, };
+
+int	watchdog_id;
+
+typedef struct { 
+#ifdef	MACH_KERNEL
+	struct	ifnet	ds_if;		/* generic interface header */
+	u_char	ds_addr[6];		/* Ethernet hardware address */
+#else	MACH_KERNEL
+	struct	arpcom	at3c501_ac;
+#define	ds_if	at3c501_ac.ac_if
+#define	ds_addr	at3c501_ac.ac_enaddr
+#endif	MACH_KERNEL
+	int	flags;
+        int     timer;
+	char 	*base;
+        u_char   address[ETHER_ADD_SIZE];
+	short	mode;
+	int	badxmt;
+	int	badrcv;
+	int	spurious;
+	int	rcv;
+	int	xmt;
+} at3c501_softc_t;
+
+at3c501_softc_t	at3c501_softc[NAT3C501];
+
+/*
+ * at3c501probe:
+ *
+ *	This function "probes" or checks for the 3c501 board on the bus to see
+ *	if it is there.  As far as I can tell, the best break between this
+ *	routine and the attach code is to simply determine whether the board
+ *	is configured in properly.  Currently my approach to this is to write
+ *	and read a string from the Packet Buffer on the board being probed.
+ *	If the string comes back properly then we assume the board is there.
+ *	The config code expects to see a successful return from the probe
+ *	routine before 	attach will be called.
+ *
+ * input	: address device is mapped to, and unit # being checked
+ * output	: a '1' is returned if the board exists, and a 0 otherwise
+ *
+ */
+at3c501probe(port, dev)
+struct bus_device	*dev;
+{
+	caddr_t		base = (caddr_t)dev->address;
+	int		unit = dev->unit;
+	char		inbuf[50];
+	char		*str = "3c501 ethernet board %d out of range\n";
+	int 		strsize = strlen(str);
+
+	if ((unit < 0) || (unit >= NAT3C501)) {
+		printf(str, unit);
+		return(0);
+	}
+
+	/* reset */
+	outb(IE_CSR(base), IE_RESET);
+
+	/* write a string to the packet buffer */
+
+	outb(IE_CSR(base), IE_RIDE | IE_SYSBFR);
+	outw(IE_GP(base), 0);
+	loutb(IE_BFR(base), str, strsize);
+
+	/* read it back */
+
+	outb(IE_CSR(base), IE_RIDE | IE_SYSBFR);
+	outw(IE_GP(base), 0);
+	linb(IE_BFR(base), inbuf, strsize);
+	/* compare them */
+
+#ifdef	MACH_KERNEL
+	if (strncmp(str, inbuf, strsize))
+#else	MACH_KERNEL
+	if (bcmp(str, inbuf, strsize))
+#endif	MACH_KERNEL
+	{
+		return(0);
+	}
+	at3c501_softc[unit].base = base;
+
+	return(1);
+}
+
+/*
+ * at3c501attach:
+ *
+ *	This function attaches a 3C501 board to the "system".  The rest of
+ *	runtime structures are initialized here (this routine is called after
+ *	a successful probe of the board).  Once the ethernet address is read
+ *	and stored, the board's ifnet structure is attached and readied.
+ *
+ * input	: bus_device structure setup in autoconfig
+ * output	: board structs and ifnet is setup
+ *
+ */
+void at3c501attach(dev)
+struct bus_device	*dev;
+{
+	at3c501_softc_t	*sp;
+	struct	ifnet	*ifp;
+	u_char	unit;
+	caddr_t		base;
+#ifdef	MACH_KERNEL
+#else	MACH_KERNEL
+	extern int	tcp_recvspace;
+	tcp_recvspace = 0x300;		/* empircal messure */
+#endif	MACH_KERNEL
+
+	take_dev_irq(dev);
+	unit = (u_char)dev->unit;	
+	printf(", port = %x, spl = %d, pic = %d. ",
+		dev->address, dev->sysdep, dev->sysdep1);
+
+	sp = &at3c501_softc[unit];
+	base = sp->base;
+	if (base != (caddr_t)dev->address) {
+		printf("3C501 board %d attach address error\n", unit);
+		return;
+	}
+	sp->timer = -1;
+	sp->flags = 0;
+	sp->mode = 0;
+	outb(IE_CSR(sp->base), IE_RESET);
+	at3c501geteh(base, sp->ds_addr);
+	at3c501geteh(base, sp->address);
+	at3c501seteh(base, sp->address);
+	printf("ethernet id [%x:%x:%x:%x:%x:%x]",
+		sp->address[0],sp->address[1],sp->address[2], 
+		sp->address[3],sp->address[4],sp->address[5]);
+	ifp = &(sp->ds_if);
+	ifp->if_unit = unit;
+	ifp->if_mtu = ETHERMTU;
+	ifp->if_flags = IFF_BROADCAST;
+#ifdef	MACH_KERNEL
+	ifp->if_header_size = sizeof(struct ether_header);
+	ifp->if_header_format = HDR_ETHERNET;
+	ifp->if_address_size = 6;
+	ifp->if_address = (char *)&sp->address[0];
+	if_init_queues(ifp);
+#else	MACH_KERNEL
+	ifp->if_name = "et";
+	ifp->if_init = at3c501init;
+	ifp->if_output = at3c501output;
+	ifp->if_ioctl = at3c501ioctl;
+	ifp->if_reset = at3c501reset;
+	ifp->if_next = NULL;
+	if_attach(ifp);
+#ifdef notdef
+	watchdog_id = timeout(at3c501watch, &(ifp->if_unit), 20*HZ);
+#endif
+#endif	MACH_KERNEL
+}
+
+/*
+ * at3c501watch():
+ *
+ */
+at3c501watch(b_ptr)
+
+caddr_t	b_ptr;
+
+{
+	int	x,
+		y,
+		opri,
+		unit;
+	at3c501_softc_t *is;
+
+	unit = *b_ptr;
+#ifdef	MACH_KERNEL
+	timeout(at3c501watch,b_ptr,20*hz);
+#else	MACH_KERNEL
+	watchdog_id = timeout(at3c501watch,b_ptr,20*HZ);
+#endif	MACH_KERNEL
+	is = &at3c501_softc[unit];
+	printf("\nxmt/bad	rcv/bad	spurious\n");
+	printf("%d/%d		%d/%d	%d\n", is->xmt, is->badxmt, \
+		is->rcv, is->badrcv, is->spurious);
+	is->rcv=is->badrcv=is->xmt=is->badxmt=is->spurious=0;
+}
+
+/*
+ * at3c501geteh:
+ *
+ *	This function gets the ethernet address (array of 6 unsigned
+ *	bytes) from the 3c501 board prom. 
+ *
+ */
+
+at3c501geteh(base, ep)
+caddr_t	base;
+char *ep;
+{
+	int	i;
+
+	for (i = 0; i < ETHER_ADD_SIZE; i++) {
+		outw(IE_GP(base), i);
+		*ep++ = inb(IE_SAPROM(base));
+	}
+}
+
+/*
+ * at3c501seteh:
+ *
+ *	This function sets the ethernet address (array of 6 unsigned
+ *	bytes) on the 3c501 board. 
+ *
+ */
+
+at3c501seteh(base, ep)
+caddr_t	base;
+char *ep;
+{
+	int	i;
+
+	for (i = 0; i < ETHER_ADD_SIZE; i++) {
+		outb(EDLC_ADDR(base) + i, *ep++);
+	}
+}
+
+#ifdef	MACH_KERNEL
+int at3c501start();	/* forward */
+
+at3c501output(dev, ior)
+	dev_t		dev;
+	io_req_t	ior;
+{
+	register int	unit = minor(dev);
+
+	if (unit < 0 || unit >= NAT3C501 ||
+		at3c501_softc[unit].base == 0)
+	    return (ENXIO);
+
+	return (net_write(&at3c501_softc[unit].ds_if, at3c501start, ior));
+}
+
+at3c501setinput(dev, receive_port, priority, filter, filter_count)
+	dev_t		dev;
+	mach_port_t	receive_port;
+	int		priority;
+	filter_t	filter[];
+	u_int		filter_count;
+{
+	register int unit = minor(dev);
+
+	if (unit < 0 || unit >= NAT3C501 ||
+		at3c501_softc[unit].base == 0)
+	    return (ENXIO);
+
+	return (net_set_filter(&at3c501_softc[unit].ds_if,
+			receive_port, priority,
+			filter, filter_count));
+}
+
+#else	MACH_KERNEL
+/*
+ * at3c501output:
+ *
+ *	This routine is called by the "if" layer to output a packet to
+ *	the network.  This code resolves the local ethernet address, and
+ *	puts it into the mbuf if there is room.  If not, then a new mbuf
+ *	is allocated with the header information and precedes the data
+ *	to be transmitted.
+ *
+ * input:	ifnet structure pointer, an mbuf with data, and address
+ *		to be resolved
+ * output:	mbuf is updated to hold enet address, or a new mbuf
+ *	  	with the address is added
+ *
+ */
+at3c501output(ifp, m0, dst)
+struct ifnet	*ifp;
+struct mbuf	*m0;
+struct sockaddr *dst;
+{
+	int 				type, error;
+	spl_t				opri;
+ 	u_char				edst[6];
+	struct in_addr 			idst;
+	register at3c501_softc_t 	*is;
+	register struct mbuf 		*m = m0;
+	register struct ether_header	*eh;
+	register int			 off;
+	int				usetrailers;
+
+	is = &at3c501_softc[ifp->if_unit];
+	if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
+		printf("3C501 Turning off board %d\n", ifp->if_unit);
+		at3c501intoff(ifp->if_unit);
+		error = ENETDOWN;
+		goto bad;
+	}
+	switch (dst->sa_family) {
+
+#ifdef INET
+	case AF_INET:
+		idst = ((struct sockaddr_in *)dst)->sin_addr;
+ 		if (!arpresolve(&is->at3c501_ac, m, &idst, edst, &usetrailers)){
+			return (0);	/* if not yet resolved */
+		}
+		off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
+
+		if (usetrailers && off > 0 && (off & 0x1ff) == 0 &&
+		    m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
+			type = ETHERTYPE_TRAIL + (off>>9);
+			m->m_off -= 2 * sizeof (u_short);
+			m->m_len += 2 * sizeof (u_short);
+			*mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP);
+			*(mtod(m, u_short *) + 1) = htons((u_short)m->m_len);
+			goto gottrailertype;
+		}
+		type = ETHERTYPE_IP;
+		off = 0;
+		goto gottype;
+#endif
+#ifdef NS
+	case AF_NS:
+		type = ETHERTYPE_NS;
+ 		bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
+		(caddr_t)edst, sizeof (edst));
+		off = 0;
+		goto gottype;
+#endif
+
+	case AF_UNSPEC:
+		eh = (struct ether_header *)dst->sa_data;
+ 		bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst));
+		type = eh->ether_type;
+		goto gottype;
+
+	default:
+		printf("at3c501%d: can't handle af%d\n", ifp->if_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 (struct ether_header) > m->m_off) {
+		m = m_get(M_DONTWAIT, MT_HEADER);
+		if (m == 0) {
+			error = ENOBUFS;
+			goto bad;
+		}
+		m->m_next = m0;
+		m->m_off = MMINOFF;
+		m->m_len = sizeof (struct ether_header);
+	} else {
+		m->m_off -= sizeof (struct ether_header);
+		m->m_len += sizeof (struct ether_header);
+	}
+	eh = mtod(m, struct ether_header *);
+	eh->ether_type = htons((u_short)type);
+ 	bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst));
+ 	bcopy((caddr_t)is->address,(caddr_t)eh->ether_shost,
+								sizeof(edst));
+	/*
+	 * Queue message on interface, and start output if interface
+	 * not yet active.
+	 */
+	opri = SPLNET();
+	if (IF_QFULL(&ifp->if_snd)) {
+		IF_DROP(&ifp->if_snd);
+		splx(opri);
+		m_freem(m);
+		return (ENOBUFS);
+	}
+	IF_ENQUEUE(&ifp->if_snd, m);
+	/*
+ 	 * Some action needs to be added here for checking whether the
+	 * board is already transmitting.  If it is, we don't want to
+ 	 * start it up (ie call at3c501start()).  We will attempt to send
+ 	 * packets that are queued up after an interrupt occurs.  Some
+ 	 * flag checking action has to happen here and/or in the start
+ 	 * routine.  This note is here to remind me that some thought
+ 	 * is needed and there is a potential problem here.
+	 *
+	 */
+	at3c501start(ifp->if_unit);
+	splx(opri);
+	return (0);
+
+bad:
+	m_freem(m0);
+	return (error);
+}
+#endif	MACH_KERNEL
+
+/*
+ * at3c501reset:
+ *
+ *	This routine is in part an entry point for the "if" code.  Since most 
+ *	of the actual initialization has already (we hope already) been done
+ *	by calling at3c501attach().
+ *
+ * input	: unit number or board number to reset
+ * output	: board is reset
+ *
+ */
+at3c501reset(unit)
+int	unit;
+{
+	at3c501_softc[unit].ds_if.if_flags &= ~IFF_RUNNING;
+	return(at3c501init(unit));
+}
+
+
+
+/*
+ * at3c501init:
+ *
+ *	Another routine that interfaces the "if" layer to this driver.  
+ *	Simply resets the structures that are used by "upper layers".  
+ *	As well as calling at3c501hwrst that does reset the at3c501 board.
+ *
+ * input	: board number
+ * output	: structures (if structs) and board are reset
+ *
+ */	
+at3c501init(unit)
+int	unit;
+{
+	struct	ifnet	*ifp;
+	int		stat;
+	spl_t		oldpri;
+
+	ifp = &(at3c501_softc[unit].ds_if);
+#ifdef	MACH_KERNEL
+#else	MACH_KERNEL
+	if (ifp->if_addrlist == (struct ifaddr *)0) {
+		return;
+	}
+#endif	MACH_KERNEL
+	oldpri = SPLNET();
+	if ((stat = at3c501hwrst(unit)) == TRUE) {
+		at3c501_softc[unit].ds_if.if_flags |= IFF_RUNNING;
+		at3c501_softc[unit].flags |= DSF_RUNNING;
+		at3c501start(unit);
+	}
+	else
+		printf("3C501 trouble resetting board %d\n", unit);
+	at3c501_softc[unit].timer = 5;
+	splx(oldpri);
+	return(stat);
+
+}
+
+#ifdef	MACH_KERNEL
+/*ARGSUSED*/
+at3c501open(dev, flag)
+	dev_t	dev;
+	int	flag;
+{
+	register int	unit = minor(dev);
+
+	if (unit < 0 || unit >= NAT3C501 ||
+		at3c501_softc[unit].base == 0)
+	    return (ENXIO);
+
+	at3c501_softc[unit].ds_if.if_flags |= IFF_UP;
+	at3c501init(unit);
+	return(0);
+}
+#endif	MACH_KERNEL
+
+/*
+ * at3c501start:
+ *
+ *	This is yet another interface routine that simply tries to output a
+ *	in an mbuf after a reset.
+ *
+ * input	: board number
+ * output	: stuff sent to board if any there
+ *
+ */
+at3c501start(unit)
+int	unit;
+
+{
+#ifdef	MACH_KERNEL
+	io_req_t	m;
+#else	MACH_KERNEL
+	struct	mbuf	*m;
+#endif	MACH_KERNEL
+	struct	ifnet	*ifp;
+
+	ifp = &(at3c501_softc[unit].ds_if);
+	for(;;) {
+		IF_DEQUEUE(&ifp->if_snd, m);
+#ifdef	MACH_KERNEL
+		if (m != 0)
+#else	MACH_KERNEL
+		if (m != (struct mbuf *)0)
+#endif	MACH_KERNEL
+			at3c501xmt(unit, m);
+		else
+			return;
+	}
+}
+
+#ifdef	MACH_KERNEL
+/*ARGSUSED*/
+at3c501getstat(dev, flavor, status, count)
+	dev_t		dev;
+	int		flavor;
+	dev_status_t	status;		/* pointer to OUT array */
+	u_int		*count;		/* out */
+{
+	register int	unit = minor(dev);
+
+	if (unit < 0 || unit >= NAT3C501 ||
+		at3c501_softc[unit].base == 0)
+	    return (ENXIO);
+
+	return (net_getstat(&at3c501_softc[unit].ds_if,
+			    flavor,
+			    status,
+			    count));
+}
+
+at3c501setstat(dev, flavor, status, count)
+	dev_t		dev;
+	int		flavor;
+	dev_status_t	status;
+	u_int		count;
+{
+	register int	unit = minor(dev);
+	register at3c501_softc_t *sp;
+
+	if (unit < 0 || unit >= NAT3C501 ||
+		at3c501_softc[unit].base == 0)
+	    return (ENXIO);
+
+	sp = &at3c501_softc[unit];
+
+	switch (flavor) {
+	    case NET_STATUS:
+	    {
+		/*
+		 * All we can change are flags, and not many of those.
+		 */
+		register struct net_status *ns = (struct net_status *)status;
+		int	mode = 0;
+
+		if (count < NET_STATUS_COUNT)
+		    return (D_INVALID_SIZE);
+
+		if (ns->flags & IFF_ALLMULTI)
+		    mode |= MOD_ENAL;
+		if (ns->flags & IFF_PROMISC)
+		    mode |= MOD_PROM;
+
+		/*
+		 * Force a compilete reset if the receive mode changes
+		 * so that these take effect immediately.
+		 */
+		if (sp->mode != mode) {
+		    sp->mode = mode;
+		    if (sp->flags & DSF_RUNNING) {
+			sp->flags &= ~(DSF_LOCK | DSF_RUNNING);
+			at3c501init(unit);
+		    }
+		}
+		break;
+	    }
+	    case NET_ADDRESS:
+	    {
+		register union ether_cvt {
+		    char	addr[6];
+		    int		lwd[2];
+		} *ec = (union ether_cvt *)status;
+
+		if (count < sizeof(*ec)/sizeof(int))
+		    return (D_INVALID_SIZE);
+
+		ec->lwd[0] = ntohl(ec->lwd[0]);
+		ec->lwd[1] = ntohl(ec->lwd[1]);
+   		at3c501seteh(sp->base, ec->addr);
+		break;
+	    }
+
+	    default:
+		return (D_INVALID_OPERATION);
+	}
+	return (D_SUCCESS);
+}
+#else	MACH_KERNEL
+
+/*
+ * at3c501ioctl:
+ *
+ *	This routine processes an ioctl request from the "if" layer
+ *	above.
+ *
+ * input	: pointer the appropriate "if" struct, command, and data
+ * output	: based on command appropriate action is taken on the
+ *	 	  at3c501 board(s) or related structures
+ * return	: error is returned containing exit conditions
+ *
+ */
+int		curr_ipl;
+u_short	curr_pic_mask;
+u_short 	pic_mask[];
+
+at3c501ioctl(ifp, cmd, data)
+struct ifnet	*ifp;
+int	cmd;
+caddr_t	data;
+{
+	register struct ifaddr		*ifa = (struct ifaddr *)data;
+	register at3c501_softc_t 	*is;
+	int 				error;
+	spl_t				opri;
+	short 				mode = 0;
+
+	is = &at3c501_softc[ifp->if_unit];
+ 	opri = SPLNET();
+	error = 0;
+	switch (cmd) {
+		case SIOCSIFADDR:
+			ifp->if_flags |= IFF_UP;
+			at3c501init(ifp->if_unit);
+			switch (ifa->ifa_addr.sa_family) {
+#ifdef INET
+				case AF_INET:
+					((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:
+		    			{
+					register struct ns_addr *ina = 
+					&(IA_SNS(ifa)->sns_addr);
+					if (ns_nullhost(*ina))
+						ina->x_host = 
+						*(union ns_host *)(ds->ds_addr);
+					else
+						at3c501seteh(ina->x_host.c_host,
+						at3c501_softc[ifp->if_unit].base);
+					break;
+		    			}
+#endif
+			}
+			break;
+		case SIOCSIFFLAGS:
+			if (ifp->if_flags & IFF_ALLMULTI)
+				mode |= MOD_ENAL;
+			if (ifp->if_flags & IFF_PROMISC)
+				mode |= MOD_PROM;
+			/*
+			 * force a complete reset if the receive multicast/
+			 * promiscuous mode changes so that these take 
+			 * effect immediately.
+			 *
+			 */
+			if (is->mode != mode) {
+				is->mode = mode;
+				if (is->flags & DSF_RUNNING) {
+			    		is->flags &=
+						~(DSF_LOCK|DSF_RUNNING);
+					at3c501init(ifp->if_unit);
+				}
+			}
+			if ((ifp->if_flags & IFF_UP) == 0 &&
+		    	    is->flags & DSF_RUNNING) {
+				printf("AT3C501 ioctl: turning off board %d\n", 
+				       ifp->if_unit);
+				is->flags &= ~(DSF_LOCK | DSF_RUNNING);
+				is->timer = -1;
+				at3c501intoff(ifp->if_unit);
+			} else 
+			if (ifp->if_flags & IFF_UP &&
+		    	    (is->flags & DSF_RUNNING) == 0)
+				at3c501init(ifp->if_unit);
+			break;
+	default:
+		error = EINVAL;
+	}
+	splx(opri);
+	return (error);
+}
+#endif	MACH_KERNEL
+
+
+/*
+ * at3c501hwrst:
+ *
+ *	This routine resets the at3c501 board that corresponds to the 
+ *	board number passed in.
+ *
+ * input	: board number to do a hardware reset
+ * output	: board is reset
+ *
+ */
+#define XMT_STAT (EDLC_16|EDLC_JAM|EDLC_UNDER|EDLC_IDLE)
+#define RCV_STAT (EDLC_STALE|EDLC_ANY|EDLC_SHORT|EDLC_DRIBBLE|EDLC_OVER|EDLC_FCS)
+int 
+at3c501hwrst(unit)
+int unit;
+{
+	u_char	stat;
+	caddr_t	base = at3c501_softc[unit].base;
+
+	outb(IE_CSR(base), IE_RESET);
+	outb(IE_CSR(base), 0);
+	at3c501seteh(base, at3c501_softc[unit].address);
+	if ((stat = inb(IE_CSR(base))) != IE_RESET) {
+		printf("at3c501reset: can't reset CSR: %x\n", stat);
+		return(FALSE);
+	}
+	if ((stat = inb(EDLC_XMT(base))) & XMT_STAT) {
+		printf("at3c501reset: can't reset XMT: %x\n", stat);
+		return(FALSE);
+	}
+	if (((stat = inb(EDLC_RCV(base))) & RCV_STAT) != EDLC_STALE) {
+		printf("at3c501reset: can't reset RCV: %x\n", stat);
+		return(FALSE);
+	}
+	if (at3c501config(unit) == FALSE) {
+		printf("at3c501hwrst(): failed to config\n");
+		return(FALSE);
+	}
+	outb(IE_RP(base), 0);
+	outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+	return(TRUE);
+}
+
+/*
+ * at3c501intr:
+ *
+ *	This function is the interrupt handler for the at3c501 ethernet
+ *	board.  This routine will be called whenever either a packet
+ *	is received, or a packet has successfully been transfered and
+ *	the unit is ready to transmit another packet.
+ *
+ * input	: board number that interrupted
+ * output	: either a packet is received, or a packet is transfered
+ *
+ */
+at3c501intr(unit)
+int unit;
+{
+	at3c501rcv(unit);
+	at3c501start(unit);
+
+	return(0);
+}
+
+
+/*
+ * at3c501rcv:
+ *
+ *	This routine is called by the interrupt handler to initiate a
+ *	packet transfer from the board to the "if" layer above this
+ *	driver.  This routine checks if a buffer has been successfully
+ *	received by the at3c501.  If so, the routine at3c501read is called
+ *	to do the actual transfer of the board data (including the
+ *	ethernet header) into a packet (consisting of an mbuf chain).
+ *
+ * input	: number of the board to check
+ * output	: if a packet is available, it is "sent up"
+ *
+ */
+at3c501rcv(unit)
+int	unit;
+{
+	int stat;
+	caddr_t base;
+#ifdef	MACH_KERNEL
+	ipc_kmsg_t	new_kmsg;
+	struct ether_header *ehp;
+	struct packet_header *pkt;
+#else	MACH_KERNEL
+    	struct	mbuf	*m,	*tm;
+#endif	MACH_KERNEL
+	u_short	len;
+	register struct ifnet *ifp;
+	struct ether_header header;
+	int	tlen;
+	register at3c501_softc_t	*is;
+	register struct	ifqueue		*inq;
+	spl_t	opri;
+	struct	ether_header eh;
+
+	is = &at3c501_softc[unit];
+	ifp = &is->ds_if;
+	base = at3c501_softc[unit].base;
+	is->rcv++;
+	if (inb(IE_CSR(base)) & IE_RCVBSY)
+		is->spurious++;
+	while (!((stat=inb(EDLC_RCV(base))) & EDLC_STALE)) {
+		outb(IE_CSR(base), IE_SYSBFR);
+		if (!(stat & EDLC_ANY)) {
+			outw(IE_GP(base), 0);
+			len = inw(IE_RP(base))-sizeof(struct ether_header);
+			outb(IE_RP(base), 0);
+			outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+			is->badrcv++;
+#ifdef DEBUG
+			printf("at3c501rcv: received %d bad bytes", len);
+			if (stat & EDLC_SHORT)
+				printf(" Short frame");
+			if (stat & EDLC_OVER) 
+				printf(" Data overflow");
+			if (stat & EDLC_DRIBBLE)
+				printf(" Dribble error");
+			if (stat & EDLC_FCS)
+				printf(" CRC error");
+			printf("\n");
+#endif DEBUG
+		} else {
+			outw(IE_GP(base), 0);
+			len = inw(IE_RP(base));
+			if (len < 60) {
+				outb(IE_RP(base), 0);
+				outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+				return;
+			}
+			linb(IE_BFR(base), &eh, sizeof(struct ether_header));
+#ifdef	MACH_KERNEL
+			new_kmsg = net_kmsg_get();
+			if (new_kmsg == IKM_NULL) {
+			    /*
+			     * Drop the packet.
+			     */
+			    is->ds_if.if_rcvdrops++;
+
+			    outb(IE_RP(base), 0);
+			    outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+			    return;
+			}
+
+			ehp = (struct ether_header *)
+				(&net_kmsg(new_kmsg)->header[0]);
+			pkt = (struct packet_header *)
+				(&net_kmsg(new_kmsg)->packet[0]);
+
+			/*
+			 * Get header.
+			 */
+			*ehp = eh;
+
+			/*
+			 * Get body
+			 */
+			linb(IE_BFR(base),
+			     (char *)(pkt + 1),
+			     len - sizeof(struct ether_header));
+
+			outb(IE_RP(base), 0);
+			outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+
+			pkt->type = ehp->ether_type;
+			pkt->length = len - sizeof(struct ether_header)
+					  + sizeof(struct packet_header);
+
+			/*
+			 * Hand the packet to the network module.
+			 */
+			net_packet(ifp, new_kmsg, pkt->length,
+				   ethernet_priority(new_kmsg));
+
+#else	MACH_KERNEL
+			eh.ether_type = htons(eh.ether_type);
+			m =(struct mbuf *)0;
+#ifdef DEBUG
+			printf("received %d bytes\n", len);
+#endif DEBUG
+			len -= sizeof(struct ether_header);
+			while ( len ) {
+				if (m == (struct mbuf *)0) {
+					m = m_get(M_DONTWAIT, MT_DATA);
+					if (m == (struct mbuf *)0) {
+						printf("at3c501rcv: Lost frame\n");
+						outb(IE_RP(base), 0);
+						outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+
+						return;
+					}
+					tm = m;
+					tm->m_off = MMINOFF;
+			/*
+			 * first mbuf in the packet must contain a pointer to the
+			 * ifnet structure.  other mbufs that follow and make up
+			 * the packet do not need this pointer in the mbuf.
+		 	 *
+		 	 */
+					*(mtod(tm, struct ifnet **)) = ifp;
+					tm->m_len = sizeof(struct ifnet **);
+				}
+				else {
+					tm->m_next = m_get(M_DONTWAIT, MT_DATA);
+					tm = tm->m_next;
+					tm->m_off = MMINOFF;
+					tm->m_len = 0;
+					if (tm == (struct mbuf *)0) {
+						m_freem(m);
+						printf("at3c501rcv: No mbufs, lost frame\n");
+						outb(IE_RP(base), 0);
+						outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+						return;
+					}
+				}
+				tlen = MIN( MLEN - tm->m_len, len );
+				tm->m_next = (struct mbuf *)0;
+				linb(IE_BFR(base), mtod(tm, char *)+tm->m_len, tlen );
+				tm->m_len += tlen;
+				len -= tlen;
+			}
+			outb(IE_RP(base), 0);
+			outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+			/*
+			 * received packet is now in a chain of mbuf's.  next step is
+			 * to pass the packet upwards.
+			 *
+			 */
+			switch (eh.ether_type) {
+#ifdef INET
+				case ETHERTYPE_IP:
+					schednetisr(NETISR_IP);
+					inq = &ipintrq;
+					break;
+				case ETHERTYPE_ARP:
+					arpinput(&is->at3c501_ac, m);
+					return;
+#endif
+#ifdef NS
+				case ETHERTYPE_NS:
+					schednetisr(NETISR_NS);
+					inq = &nsintrq;
+					break;
+#endif
+				default:
+					m_freem(m);
+					return;
+			}
+			opri = SPLNET();
+			if (IF_QFULL(inq)) {
+				IF_DROP(inq);
+				splx(opri);
+				m_freem(m);
+				return;
+			}
+			IF_ENQUEUE(inq, m);
+			splx(opri);
+#endif	MACH_KERNEL
+		}
+	}
+}
+
+
+/*
+ * at3c501xmt:
+ *
+ *	This routine fills in the appropriate registers and memory
+ *	locations on the 3C501 board and starts the board off on
+ *	the transmit.
+ *
+ * input	: board number of interest, and a pointer to the mbuf
+ * output	: board memory and registers are set for xfer and attention
+ *
+ */
+at3c501xmt(unit, m)
+int	unit;
+#ifdef	MACH_KERNEL
+io_req_t	m;
+#else	MACH_KERNEL
+struct	mbuf	*m;
+#endif	MACH_KERNEL
+{
+#ifdef	MACH_KERNEL
+#else	MACH_KERNEL
+	register struct	mbuf	*tm_p;
+#endif	MACH_KERNEL
+	int			i;
+	at3c501_softc_t		*is = &at3c501_softc[unit];
+	caddr_t			base = is->base;
+	u_short			count = 0;
+	u_short			bytes_in_msg;
+
+	is->xmt++;
+	outb(IE_CSR(base), IE_SYSBFR);
+#ifdef	MACH_KERNEL
+	count = m->io_count;
+#define	max(a,b)	(((a) > (b)) ? (a) : (b))
+	bytes_in_msg = max(count,
+			   ETHERMIN + sizeof(struct ether_header));
+#else	MACH_KERNEL
+	bytes_in_msg = max(m_length(m), ETHERMIN + sizeof(struct ether_header));
+#endif	MACH_KERNEL
+	outw(IE_GP(base), BFRSIZ-bytes_in_msg);
+#ifdef	MACH_KERNEL
+	loutb(IE_BFR(base), m->io_data, count);
+#else	MACH_KERNEL
+	for (tm_p = m; tm_p != (struct mbuf *)0; tm_p = tm_p->m_next) {
+		if (count + tm_p->m_len > ETHERMTU + sizeof(struct ether_header))
+			break;
+		if (tm_p->m_len == 0)
+			continue;
+		loutb(IE_BFR(base), mtod(tm_p, caddr_t), tm_p->m_len);
+		count += tm_p->m_len;
+	}
+#endif	MACH_KERNEL
+	while (count < bytes_in_msg) {
+		outb(IE_BFR(base), 0);
+		count++;
+	}
+	do {
+		if (!(int)m) {
+			outb(IE_CSR(base), IE_SYSBFR);
+		}
+		outw(IE_GP(base), BFRSIZ-bytes_in_msg);
+		outb(IE_CSR(base), IE_RIDE|IE_XMTEDLC);
+		if (m) {
+#ifdef	MACH_KERNEL
+			iodone(m);
+			m = 0;
+#else	MACH_KERNEL
+			m_freem(m);
+			m = (struct mbuf *) 0;
+#endif	MACH_KERNEL
+		}
+		for (i=0; inb(IE_CSR(base)) & IE_XMTBSY; i++);
+		if ((i=inb(EDLC_XMT(base))) & EDLC_JAM) {
+			is->badxmt++;
+#ifdef DEBUG
+			printf("at3c501xmt jam\n");
+#endif DEBUG
+		}
+	} while ((i & EDLC_JAM) && !(i & EDLC_16));
+
+	if (i & EDLC_16) {
+		printf("%");
+	}
+	return;
+
+}
+
+/*
+ * at3c501config:
+ *
+ *	This routine does a standard config of the at3c501 board.
+ *
+ */
+at3c501config(unit)
+int	unit;
+{
+	caddr_t	base = at3c501_softc[unit].base;
+	u_char	stat;
+
+	/* Enable DMA & Interrupts */
+
+	outb(IE_CSR(base), IE_RIDE|IE_SYSBFR);
+
+	/* No Transmit Interrupts */
+
+	outb(EDLC_XMT(base), 0);
+	inb(EDLC_XMT(base));
+
+	/* Setup Receive Interrupts */
+
+	outb(EDLC_RCV(base), EDLC_BROAD|EDLC_SHORT|EDLC_GOOD|EDLC_DRIBBLE|EDLC_OVER);
+	inb(EDLC_RCV(base));
+
+	outb(IE_CSR(base), IE_RIDE|IE_SYSBFR);
+	outb(IE_RP(base), 0);
+	outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC);
+	return(TRUE);
+}
+
+/*
+ * at3c501intoff:
+ *
+ *	This function turns interrupts off for the at3c501 board indicated.
+ *
+ */
+at3c501intoff(unit)
+int unit;
+{
+	caddr_t base = at3c501_softc[unit].base;
+	outb(IE_CSR(base), 0);
+}
+
+#ifdef	MACH_KERNEL
+#else	MACH_KERNEL
+/*
+ * The length of an mbuf chain
+ */
+m_length(m)
+	register struct mbuf *m;
+{
+	register int len = 0;
+	
+	while (m) {
+		len += m->m_len;
+		m = m->m_next;
+	}
+	return len;
+}
+#endif	MACH_KERNEL