path: root/i386/i386at/if_ne.c

/*-
 * Copyright (c) 1990, 1991 William F. Jolitz.
 * Copyright (c) 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      @(#)if_ne.c     7.4 (Berkeley) 5/21/91
 */

/*
 * NE2000 Ethernet driver
 *
 * Parts inspired from Tim Tucker's if_wd driver for the wd8003,
 * insight on the ne2000 gained from Robert Clements PC/FTP driver.
 */

#include <ne.h>


#if NNE > 0
#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>
#include        <i386at/ds8390.h>
#include        <i386at/if_nereg.h>
#include	<i386/ipl.h>
#include	<chips/busses.h>
#ifdef FIPC
#include	<ipc/fipc.h>
#endif /* FIPC */

#else	MACH_KERNEL

#include        <sys/param.h>
#include        <mach/vm_param.h>
#include        <sys/systm.h>
#include        <sys/mbuf.h>
#include        <sys/table.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        <vm/vm_kern.h>

#include        <net/if.h>
#include        <net/if_types.h>
#include        <net/route.h>

#include        <netinet/in.h>
#include        <netinet/in_systm.h>
#include        <netinet/in_var.h>
#include        <netinet/ip.h>
#include        <netinet/if_ether.h>

#include        <netns/ns.h>
#include        <netns/ns_if.h>


#include        <i386/ipl.h>
#include        <i386at/atbus.h>
#include        <i386at/ds8390.h>
#include        <i386at/if_nereg.h>
#include        <i386/handler.h>
#include        <i386/dispatcher.h>
int    ether_output();
int    neioctl();

#endif


int    neprobe();
void    neattach();
int    neintr();
int    nestart();
int    neinit();

static vm_offset_t ne_std[NNE] = {0};
static struct bus_device *ne_info[NNE];
struct  bus_driver nedriver =
        { neprobe, 0, neattach, 0, ne_std, "ne", ne_info, 0, 0, 0 };

#define ETHER_MIN_LEN 64
#define ETHER_MAX_LEN 1536
#define SPLNET spl6
/*
 * Ethernet software status per interface.
 *
 * Each interface is referenced by a network interface structure,
 * ns_if, which the routing code uses to locate the interface.
 * This structure contains the output queue for the interface, its address, ...
 */
typedef struct {

#ifdef	MACH_KERNEL
	struct  ifnet ds_if;
	u_char  ds_addr[6];
#else	MACH_KERNEL
        struct  arpcom ns_ac;           /* Ethernet common part */
#define ds_if   ns_ac.ac_if             /* network-visible interface */
#define ds_addr ns_ac.ac_enaddr         /* hardware Ethernet address */
#endif  MACH_KERNEL

        int     ns_flags;
#define DSF_LOCK        1               /* block re-entering enstart */
#define DSF_RUNNING	2
        int     ns_oactive ;
        int     ns_mask ;
        int     ns_ba;                  /* byte addr in buffer ram of inc pkt */
        int     ns_cur;                 /* current page being filled */
        struct  prhdr   ns_ph;          /* hardware header of incoming packet*/
        struct  ether_header ns_eh;     /* header of incoming packet */
        u_char  ns_pb[2048 /*ETHERMTU+sizeof(long)*/];
        short   ns_txstart;             /* transmitter buffer start */
        short   ns_rxend;               /* recevier buffer end */
        short   ns_rxbndry;             /* recevier buffer boundary */
        caddr_t ns_port;                /* i/o port base */
        short   ns_mode;                /* word/byte mode */
	int	mode;
	short	card_present;
#ifndef MACH_KERNEL
        ihandler_t      handler;
        ihandler_id_t   *handler_id;
#endif	MACH_KERNEL

} ne_softc_t;
ne_softc_t ne_softc[NNE];

#define PAT(n)  (0xa55a + 37*(n))

u_short boarddata[16];
 
/*
 * Fetch from onboard ROM/RAM
 */
nefetch (ns, up, ad, len) ne_softc_t *ns; caddr_t up; {
        u_char cmd;
        caddr_t nec = ns->ns_port;
        int counter = 10000;
		int t_len;
		unsigned char last_word[2];
		char odd;

        cmd = inb (nec + ds_cmd);
        outb (nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START);

        /* Setup remote dma */
        outb (nec + ds0_isr, DSIS_RDC);

		t_len = len;
        if ((ns->ns_mode & DSDC_WTS) && len&1) {
				odd=1;
                t_len++;          /* roundup to words */
		} else odd=0;

        outb (nec+ds0_rbcr0, t_len);
        outb (nec+ds0_rbcr1, t_len>>8);
        outb (nec+ds0_rsar0, ad);
        outb (nec+ds0_rsar1, ad>>8);

        /* Execute & extract from card */
        outb (nec+ds_cmd, DSCM_RREAD|DSCM_PG0|DSCM_START);

        if (ns->ns_mode & DSDC_WTS)
				if (odd) {
	                linw (nec+ne_data, up, len/2);
					*(last_word) = inw(nec+ne_data); /* get last word */
					*(up+len-1) = last_word[0]; /* last byte */
				} else {
                	linw (nec+ne_data, up, len/2);
				}
        else
                linb (nec+ne_data, up, len);


        /* Wait till done, then shutdown feature */
        while ((inb (nec+ds0_isr) & DSIS_RDC) == 0 && counter-- > 0)
                ;

        outb (nec+ds0_isr, DSIS_RDC);
        outb (nec+ds_cmd, cmd);
}

/*
 * Put to onboard RAM
 */
neput (ns, up, ad, len) ne_softc_t *ns; caddr_t up; {
        u_char cmd;
        caddr_t nec = ns->ns_port;
        int counter = 10000;
		int t_len;
		int odd;
		unsigned char last_word[2];

        cmd = inb(nec+ds_cmd);
        outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START);

        /* Setup for remote dma */
        outb (nec+ds0_isr, DSIS_RDC);

		t_len = len;
        if ((ns->ns_mode & DSDC_WTS) && len&1) {
				odd = 1;
                t_len++;          /* roundup to words */
		} else odd = 0;

        outb (nec+ds0_rbcr0, t_len);
        outb (nec+ds0_rbcr1, t_len>>8);
        outb (nec+ds0_rsar0, ad);
        outb (nec+ds0_rsar1, ad>>8);

        /* Execute & stuff to card */
        outb (nec+ds_cmd, DSCM_RWRITE|DSCM_PG0|DSCM_START);
        if (ns->ns_mode & DSDC_WTS) {
				if (odd) {
	                loutw (nec+ne_data, up, len/2);
					last_word[0] = *(up+len-1);
					outw (nec+ne_data, (unsigned short) *(last_word));
				}
				else {
	                loutw (nec+ne_data, up, len/2);
				}
		}
        else
                loutb (nec+ne_data, up, len);


        /* Wait till done, then shutdown feature */
        while ((inb (nec+ds0_isr) & DSIS_RDC) == 0 && counter-- > 0)
                ;

        outb (nec+ds0_isr, DSIS_RDC);
        outb (nec+ds_cmd, cmd);
}

int
neprobe(port, dev)
struct bus_device *dev;
{
        int val, i, sum, bytemode = 1, pat;
	int unit = dev->unit;
        ne_softc_t *ns = &ne_softc[unit];
        caddr_t nec;

        if ((unsigned) unit >= NNE)
                return(0);

        nec = (caddr_t) ns->ns_port = dev->address;

	if (ns->card_present) {
		printf("ne%s : card already present in port %x\n",
			unit, nec);
		return(0);
	}

        if (bytemode) {
                /* Byte Transfers, Burst Mode Select, Fifo at 8 bytes */
                ns->ns_mode = DSDC_BMS|DSDC_FT1;
                ns->ns_txstart = TBUF8;
                ns->ns_rxend = RBUFEND8;
        } else {
word:
                /* Word Transfers, Burst Mode Select, Fifo at 8 bytes */
                ns->ns_mode = DSDC_WTS|DSDC_BMS|DSDC_FT1;
                ns->ns_txstart = TBUF16;
                ns->ns_rxend = RBUFEND16;
                bytemode = 0;
        }

        /* Reset the bastard */
        val = inb(nec + ne_reset);
        delay(200);
        outb(nec + ne_reset, val);
        delay(200);

        outb(nec + ds_cmd, DSCM_STOP|DSCM_NODMA);
        
        i = 10000;
        while ((inb(nec + ds0_isr) & DSIS_RESET) == 0 && i-- > 0);
        if (i < 0) return (0);

        outb(nec + ds0_isr, 0xff);
        outb(nec + ds0_dcr, ns->ns_mode);
        outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP);
        delay(1000);

        /* Check cmd reg and fail if not right */
        if ((i = inb(nec + ds_cmd)) != (DSCM_NODMA|DSCM_PG0|DSCM_STOP))
                return(0);

        outb(nec + ds0_tcr, DSTC_LB0);
        outb(nec + ds0_rcr, DSRC_MON);
        outb(nec + ds0_pstart, ns->ns_txstart+PKTSZ);
        outb(nec + ds0_pstop, ns->ns_rxend);
        outb(nec + ds0_bnry, ns->ns_rxend);
        outb(nec + ds0_imr, 0);
        outb(nec + ds0_isr, 0);
        outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP);
        outb(nec + ds1_curr, ns->ns_txstart+PKTSZ);
        outb(nec + ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP);

#ifdef NEDEBUG
#define RCON    37
        {       int i, rom;

                rom=1;
                printf("ne ram ");
                
                for (i = 0; i < 0xfff0; i+=4) {
                        pat = PAT(i);
                        neput(ns, &pat,i,4);
                        nefetch(ns, &pat,i,4);
                        if (pat == PAT(i)) {
                                if (rom) {
                                        rom=0;
                                        printf(" %x", i);
                                }
                        } else {
                                if (!rom) {
                                        rom=1;
                                        printf("..%x ", i);
                                }
                        }
                        pat=0;
                        neput(ns, &pat,i,4);
                }
                printf("\n");
        }
#endif

        /*
         * <groan> detect difference between units
         * solely by where the RAM is decoded.
         */
        pat = PAT(0);
        neput  (ns, &pat, ns->ns_txstart*DS_PGSIZE, 4);
        nefetch(ns, &pat, ns->ns_txstart*DS_PGSIZE, 4);
        if (pat != PAT(0)) {
                if (bytemode)
                        goto word;
                else return (0);
        }


        /* Extract board address */
        nefetch (ns, (caddr_t)boarddata, 0, sizeof(boarddata));

        for(i=0; i < 6; i++)
                ns->ds_addr[i] = boarddata[i];
	ns->card_present = 1;
        return (1);
}

/*
 * Interface exists: make available by filling in network interface
 * record.  System will initialize the interface when it is ready
 * to accept packets.  We get the ethernet address here.
 */
void 
neattach(dev)
struct bus_device *dev;
{
        short unit = dev->unit;
        ne_softc_t *ns = &ne_softc[unit];
        register struct ifnet *ifp = &(ns->ds_if);

        if ((unsigned) unit >= NNE)
                return;

#ifdef	MACH_KERNEL
	take_dev_irq(dev);
#else	MACH_KERNEL
        /* setup intr handler */
        ns->handler.ih_level            = dev->dev_pic;
        ns->handler.ih_handler          = dev->dev_intr[0];
        ns->handler.ih_resolver         = i386_resolver;
        ns->handler.ih_rdev             = dev;
        ns->handler.ih_stats.intr_type  = INTR_DEVICE;
        ns->handler.ih_stats.intr_cnt   = 0;
        ns->handler.ih_hparam[0].intparam = unit;
        if ((ns->handler_id = handler_add(&ns->handler)) != NULL)
                handler_enable(ns->handler_id);
        else
                panic("Unable to add NEx000 interrupt handler");
#endif	MACH_KERNEL
	printf (", port = %x, spl = %d, pic = %d, [%s].",
		dev->address, dev->sysdep, dev->sysdep1,
		ether_sprintf(ns->ds_addr));
#ifndef	MACH_KERNEL
	ns->ns_ac.ac_bcastaddr	= (u_char *)etherbroadcastaddr;
	ns->ns_ac.ac_arphrd	= ARPHRD_ETHER;
#endif	MACH_KERNEL
	ns->ns_flags	= 0;
	ns->mode	= 0;
        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 *)&ns->ds_addr[0];
	if_init_queues(ifp);
#else	MACH_KERNEL
        ifp->if_name	= nedriver.driver_dname;
        ifp->if_init	= neinit;
        ifp->if_output	= ether_output;
        ifp->if_start	= nestart;
        ifp->if_ioctl	= neioctl;
        ifp->if_reset	= nereset;
        ifp->if_watchdog= 0;
        if_attach(ifp);
#endif	MACH_KERNEL
}

/*
 * Initialization of interface; set up initialization block
 * and transmit/receive descriptor rings.
 */
neinit(unit)
        int unit;
{
        ne_softc_t *ns = &ne_softc[unit];
        struct ifnet *ifp = &ns->ds_if;
        int i; char *cp;
	int oldpri;
        caddr_t nec = ns->ns_port;

#ifndef MACH_KERNEL
        if (ifp->if_addrlist == (struct ifaddr *)0) return;
#endif	MACH_KERNEL

	oldpri = SPLNET();

	outb(nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP);

        /* Word Transfer select, Burst Mode Select, Fifo at 8 bytes */
        outb(nec+ds0_dcr, ns->ns_mode);

	/* clear remote byte count resigters */
        outb (nec+ds0_rbcr0, 0);
        outb (nec+ds0_rbcr1, 0);

	/* don't store incoming packets into memory for now */
        outb (nec+ds0_rcr, DSRC_MON);

	/* place NIC in internal loopback mode */
	outb(nec+ds0_tcr, DSTC_LB0);

	/* initialize transmit/recieve (ring-buffer) Page Start */
	outb (nec+ds0_tpsr, 0);
        outb (nec+ds0_pstart, ns->ns_txstart+PKTSZ);

	/* initialize reciever (ring-buffer) Page Stop and Boundary */
        outb (nec+ds0_pstop, ns->ns_rxend);
        outb (nec+ds0_bnry, ns->ns_txstart+PKTSZ);

	/* clear all interrupts */
        outb (nec+ds0_isr, 0xff);

	/* enable the interrupts that we care about */
        outb (nec+ds0_imr, IMR_ENABLE);

        /* set physical address on ethernet */
        outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG1|DSCM_STOP);
        for (i=0 ; i < 6 ; i++) outb(nec+ds1_par0+i,ns->ds_addr[i]);

	ns->ns_cur = ns->ns_txstart+PKTSZ + 1;
        outb (nec+ds1_curr, ns->ns_cur);

	/* XXX deal with Reciever Configuration Register */
        /* clr logical address hash filter for now */
        for (i=0 ; i < 8 ; i++) outb(nec+ds1_mar0+i,0xff);
	
	/* set page 0 registers */
	outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_STOP);
        outb (nec+ds0_rcr, DSRC_AB);

	/* take unit out of loopback mode */
        outb (nec+ds0_tcr, 0);

        ns->ds_if.if_flags |= IFF_RUNNING;
        ns->ns_flags &= ~(DSF_LOCK|DSF_RUNNING);
        ns->ns_oactive = 0; ns->ns_mask = ~0;
        splx(oldpri);
        nestart(unit);
	return(1);
}

/*
 * Setup output on interface.
 * Get another datagram to send off of the interface queue,
 * and map it to the interface before starting the output.
 * called only at splimp or interrupt level.
 */
nestart(unit)
int unit;
{
        ne_softc_t *ns = &ne_softc[unit];
        struct ifnet *ifp = &ns->ds_if;
        int buffer;
        int len, i, total,t;
        caddr_t nec = ns->ns_port;
#ifdef	MACH_KERNEL
	io_req_t m;

#else	MACH_KERNEL
        struct mbuf *m0, *m;
#endif	MACH_KERNEL

        /*
         * The DS8390 has only one transmit buffer, if it is busy we
         * must wait until the transmit interrupt completes.
         */
        outb(nec+ds_cmd,DSCM_NODMA|DSCM_START);

        if (ns->ns_flags & DSF_LOCK) 
                goto done;

        if (inb(nec+ds_cmd) & DSCM_TRANS) 
                goto done;

        if ((ns->ds_if.if_flags & IFF_RUNNING) == 0)
                goto done;

        IF_DEQUEUE(&ns->ds_if.if_snd, m);
        if (m == 0)
                goto done;

        /*
         * Copy the mbuf chain into the transmit buffer
         */

        ns->ns_flags |= DSF_LOCK;       /* prevent entering nestart */
        buffer = ns->ns_txstart*DS_PGSIZE;
#ifdef	MACH_KERNEL
	total = m->io_count;
	neput(ns, m->io_data, buffer, total);
#else	MACH_KERNEL
        t = 0; len = i = 0;
        for (m0 = m; m != 0; m = m->m_next)
                t += m->m_len;
                
        m = m0;
        total = t;
        for (m0 = m; m != 0; ) {
                
                if (m->m_len&1 && t > m->m_len) {
                        neput(ns, mtod(m, caddr_t), buffer, m->m_len - 1);
                        t -= m->m_len - 1;
                        buffer += m->m_len - 1;
                        m->m_data += m->m_len - 1;
                        m->m_len = 1;
                        m = m_pullup(m, 2);
                } else {
                        neput(ns, mtod(m, caddr_t), buffer, m->m_len);
                        buffer += m->m_len;
                        t -= m->m_len;
                        MFREE(m, m0);
                        m = m0;
                }
        }
#endif	MACH_KERNEL
        /*
         * Init transmit length registers, and set transmit start flag.
         */

        len = total;
        if (len < ETHER_MIN_LEN) len = ETHER_MIN_LEN;
        outb(nec+ds0_tbcr0,len&0xff);
        outb(nec+ds0_tbcr1,(len>>8)&0xff);
        outb(nec+ds0_tpsr, ns->ns_txstart);
        outb(nec+ds_cmd, DSCM_TRANS|DSCM_NODMA|DSCM_START);

#ifdef	MACH_KERNEL
	iodone(m);
	m = 0;
done:
#endif	MACH_KERNEL
}

/* buffer successor/predecessor in ring? */
#define succ(n) (((n)+1 >= ns->ns_rxend) ? (ns->ns_txstart+PKTSZ) : (n)+1)
#define pred(n) (((n)-1 < (ns->ns_txstart+PKTSZ)) ? ns->ns_rxend-1 : (n)-1)

/*
 * Controller interrupt.
 */
neintr(unit)
{
        ne_softc_t *ns = &ne_softc[unit];
        u_char cmd,isr;
        caddr_t nec = ns->ns_port;

        /* Save cmd, clear interrupt */
        cmd = inb (nec+ds_cmd);
        isr = inb (nec+ds0_isr);
loop:
        outb(nec+ds_cmd,DSCM_NODMA|DSCM_START);
        outb(nec+ds0_isr, isr);

        /* Receiver error */
        if (isr & DSIS_RXE) {
		(void) inb(nec+ds0_rsr);
                /* need to read these registers to clear status */
                ns->ds_if.if_ierrors++;
        }

	/* Counters overflowed, reading the registers resets them */
	if (isr & DSIS_CTRS) {
		(void) inb(nec+ds0_cntr0);
		(void) inb(nec+ds0_cntr1);
		(void) inb(nec+ds0_cntr2);
	}


        /* We received something; rummage thru tiny ring buffer */
        if (isr & (DSIS_RX|DSIS_RXE|DSIS_ROVRN)) {
                u_char pend,lastfree;

                outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1);
                pend = inb(nec+ds1_curr);
                outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0);

                /* Something in the buffer? */
                while (pend != ns->ns_cur) {
                        /* Extract header from microcephalic board */
                        nefetch(ns, &ns->ns_ph,ns->ns_cur*DS_PGSIZE,
                                sizeof(ns->ns_ph));
                        ns->ns_ba = ns->ns_cur*DS_PGSIZE+sizeof(ns->ns_ph);

                        /* Incipient paranoia */
                        if (ns->ns_ph.pr_status == DSRS_RPC ||
                                /* for dequna's */
                                ns->ns_ph.pr_status == 0x21) {
                                if (nerecv(ns))
					ns->ns_cur = ns->ns_ph.pr_nxtpg ;
				else {
                        		outb(nec+ds0_bnry, pred(ns->ns_cur));
					goto short_load;
				}
			}
#ifdef NEDEBUG
                        else  {
                                printf("cur %x pnd %x lfr %x ",
                                        ns->ns_cur, pend, lastfree);
                                printf("nxt %x len %x ", ns->ns_ph.pr_nxtpg,
                                        (ns->ns_ph.pr_sz1<<8)+ ns->ns_ph.pr_sz0);
                                printf("Bogus Sts %x\n", ns->ns_ph.pr_status);  
				ns->ns_cur = pend;
                        }
#endif
                        outb(nec+ds0_bnry, pred(ns->ns_cur));
                        outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG1);
                        pend = inb(nec+ds1_curr);
                        outb(nec+ds_cmd, DSCM_START|DSCM_NODMA|DSCM_PG0);
                }
short_load:
                outb(nec+ds_cmd, DSCM_START|DSCM_NODMA);
        }

        /* Transmit error */
        if (isr & DSIS_TXE) {
                ns->ns_flags &= ~DSF_LOCK;
                /* Need to read these registers to clear status */
                ns->ds_if.if_collisions += inb(nec+ds0_tbcr0);
                ns->ds_if.if_oerrors++;
        }

        /* Packet Transmitted */
        if (isr & DSIS_TX) {
                ns->ns_flags &= ~DSF_LOCK;
                ++ns->ds_if.if_opackets;
                ns->ds_if.if_collisions += inb(nec+ds0_tbcr0);
        }

        /* Receiver ovverun? */
        if (isr & DSIS_ROVRN) {
                outb(nec+ds0_rbcr0, 0);
                outb(nec+ds0_rbcr1, 0);
                outb(nec+ds0_tcr, DSTC_LB0);
                outb(nec+ds0_rcr, DSRC_MON);
                outb(nec+ds_cmd, DSCM_START|DSCM_NODMA);
                outb(nec+ds0_rcr, DSRC_AB);
                outb(nec+ds0_tcr, 0);
        }

        /* Any more to send? */
        outb (nec+ds_cmd, DSCM_NODMA|DSCM_PG0|DSCM_START);
        nestart(unit);
        outb (nec+ds_cmd, cmd);
        outb (nec+ds0_imr, IMR_ENABLE);

        /* Still more to do? */
        isr = inb (nec+ds0_isr);
        if(isr) goto loop;

	return 0;
}

/*
 * Ethernet interface receiver interface.
 * If input error just drop packet.
 * Otherwise examine packet to determine type.  If can't determine length
 * from type, then have to drop packet.  Othewise decapsulate
 * packet based on type and pass to type specific higher-level
 * input routine.
 */
nerecv(ns)
        ne_softc_t *ns;
{
#ifdef	MACH_KERNEL
	ipc_kmsg_t	new_kmsg;
	struct ether_header *ehp;
	struct packet_header *pkt;
	register struct ifnet *ifp = &ns->ds_if;
#ifdef FIPC
	char *fipc_buf;
#endif
#else	MACH_KERNEL
        struct mbuf *top, **mp, *m, *p;
#endif	MACH_KERNEL
        int len, l;
        int epkt;

        ns->ds_if.if_ipackets++;
        len = ns->ns_ph.pr_sz0 + (ns->ns_ph.pr_sz1<<8);
        if(len < ETHER_MIN_LEN || len > ETHER_MAX_LEN)
                return 0;

        nefetch(ns, &ns->ns_eh, ns->ns_ba, sizeof(struct ether_header));

#ifndef MACH_KERNEL
        ns->ns_eh.ether_type = ntohs((u_short)ns->ns_eh.ether_type);
#endif	MACH_KERNEL
	ns->ns_ba += sizeof(struct ether_header);

        /* don't forget checksum! */
        len -= (sizeof(struct ether_header) + sizeof(long));
#ifdef	MACH_KERNEL
#ifdef  FIPC
	if (ns->ns_eh.ether_type == FIPC_MSG_TYPE)  /* fipc packet */
	{
		/* We need to hand the whole packet to the handler. */

		fipc_recvs++;

		fipc_buf = get_fipc_buffer (len, TRUE, TRUE);

		if (fipc_buf == NULL)
		{
			ns->ds_if.if_rcvdrops++;
			return(0);
		}
		nefetch (ns, fipc_buf, ns->ns_ba, len);

		fipc_packet (fipc_buf, ns->ns_eh);
	}
	else  /* net_kmsg */
	{
#endif /* FIPC */
		new_kmsg = net_kmsg_get();

		if (new_kmsg == IKM_NULL) {
			ns->ds_if.if_rcvdrops++;
			return(0);
		}

		ehp = (struct ether_header *) (&net_kmsg(new_kmsg)->header[0]);
		pkt = (struct packet_header *)(&net_kmsg(new_kmsg)->packet[0]);
		*ehp = ns->ns_eh;

       		nefetch(ns, (char *) (pkt + 1), ns->ns_ba, len);

		pkt->type = ehp->ether_type;
	
		pkt->length = len + sizeof(struct packet_header);
		net_packet(ifp, new_kmsg, pkt->length, ethernet_priority(new_kmsg));
#ifdef FIPC
	}
#endif

#else	MACH_KERNEL
/**/
        epkt = ns->ns_ba + len;

        MGETHDR(m, M_DONTWAIT, MT_DATA);
        if (m == 0)
                return (0);

        m->m_pkthdr.rcvif = &ns->ds_if;
        m->m_pkthdr.len = len;
        m->m_len = MHLEN;

        top = 0;
        mp = &top;
        while (len > 0) {
                if (top) {
                        MGET(m, M_DONTWAIT, MT_DATA);
                        if (m == 0) {
                                m_freem(top);
                                return (0);
                        }
                        m->m_len = MLEN;
                }
                l = min(len, epkt - ns->ns_ba);
                if (l >= MINCLSIZE) {
                        MCLGET(m, M_DONTWAIT);
                        if (m->m_flags & M_EXT)
                                m->m_len = l = min(len, MCLBYTES);
                        else
                                l = m->m_len;
                } else {
                        /*
                         * Place initial small packet/header at end of mbuf.
                         */
                        if (l < m->m_len) {
                                if (top == 0 && len + max_linkhdr <= m->m_len)
                                        m->m_data += max_linkhdr;
                                m->m_len = l;
                        } else
                                l = m->m_len;
                }
        	nefetch(ns, mtod(m, caddr_t), ns->ns_ba, l);
                ns->ns_ba += l;
                *mp = m;
                mp = &m->m_next;
                len -= l;
        }
/**/
        if (top == 0) return 0; /* NEED MODIFY HERE !!! */

        ether_input(&ns->ds_if, &ns->ns_eh, top);
#endif	MACH_KERNEL
	return 1;
}

#ifdef	MACH_KERNEL
neopen(dev, flag)
dev_t dev;
int   flag;
{
	register int unit = minor(dev);

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	ne_softc[unit].ds_if.if_flags |= IFF_UP;
	neinit(unit);
	return(0);
}

#ifdef FIPC
nefoutput(dev, ior)
dev_t dev;
io_req_t ior;
{
	register int unit = minor(dev);

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	return (net_fwrite(&ne_softc[unit].ds_if, nestart, ior));
}
#endif

neoutput(dev, ior)
dev_t dev;
io_req_t ior;
{
	register int unit = minor(dev);

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	return (net_write(&ne_softc[unit].ds_if, nestart, ior));
}

nesetinput(dev, receive_port, priority, filter, filter_count)
dev_t		dev;
mach_port_t	receive_port;
int		priority;
filter_t	filter[];
unsigned int	filter_count;
{
	register int unit = minor(dev);

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	return (net_set_filter(&ne_softc[unit].ds_if,
				receive_port, priority,
				filter, filter_count));
}

negetstat(dev, flavor, status, count)
dev_t		dev;
int		flavor;
dev_status_t	status;
unsigned int	*count;
{
	register int unit = minor(dev);

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	return (net_getstat(&ne_softc[unit].ds_if,
			    flavor,
			    status,
			    count));
}

nesetstat(dev, flavor, status, count)
dev_t		dev;
int		flavor;
dev_status_t	status;
unsigned int	count;
{
	register int unit = minor(dev);
	register ne_softc_t *ns;

	if (!ne_softc[unit].card_present || unit < 0 || unit >= NNE)
		return (ENXIO);

	ns = &ne_softc[unit];

	switch(flavor) {
	case NET_STATUS: {
		register struct net_status *s = (struct net_status *)status;
		int mode = 0;
		if (count < NET_STATUS_COUNT)
			return(D_INVALID_SIZE);
#define MOD_ENAL 1
#define MOD_PROM 2
		if (s->flags & IFF_ALLMULTI)
			mode |= MOD_ENAL;
		if (s->flags & IFF_PROMISC)
			mode |= MOD_PROM;

		if (ns->mode != mode) {
			ns->mode = mode;
			if (ns->ns_flags & DSF_RUNNING) {
				ns->ns_flags &= ~(DSF_LOCK | DSF_RUNNING);
				neinit(unit);
			}
		}
		break;
		}
	default :
		return (D_INVALID_OPERATION);
	}
	return (D_SUCCESS);
}

#else	MACH_KERNEL

/*
 * Process an ioctl request.
 */
neioctl(ifp, cmd, data)
        register struct ifnet *ifp;
        int cmd;
        caddr_t data;
{
        register struct ifaddr *ifa = (struct ifaddr *)data;
        ne_softc_t *ns = &ne_softc[ifp->if_unit];
        struct ifreq *ifr = (struct ifreq *)data;
        int s = splimp(), error = 0;


        switch (cmd) {

        case SIOCSIFADDR:
                ifp->if_flags |= IFF_UP;

                switch (ifa->ifa_addr->sa_family) {
                case AF_INET:
                        neinit(ifp->if_unit);   /* before arpwhohas */
                        ((struct arpcom *)ifp)->ac_ipaddr =
                                IA_SIN(ifa)->sin_addr;
                        arpwhohas((struct arpcom *)ifp, &IA_SIN(ifa)->sin_addr);
                        break;
                case AF_NS:
                    {
                        register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);

                        if (ns_nullhost(*ina))
                                ina->x_host = *(union ns_host *)(ns->ds_addr);
                        else {
                                /* 
                                 * The manual says we can't change the address 
                                 * while the receiver is armed,
                                 * so reset everything
                                 */
                                ifp->if_flags &= ~IFF_RUNNING; 
                                bcopy((caddr_t)ina->x_host.c_host,
                                    (caddr_t)ns->ds_addr, sizeof(ns->ds_addr));
                        }
                        neinit(ifp->if_unit); /* does ne_setaddr() */
                        break;
                    }
                default:
                        neinit(ifp->if_unit);
                        break;
                }
                break;

        case SIOCSIFFLAGS:
                if ((ifp->if_flags & IFF_UP) == 0 &&
                    ifp->if_flags & IFF_RUNNING) {
                        ifp->if_flags &= ~IFF_RUNNING;
                        outb(ns->ns_port + ds_cmd, DSCM_STOP|DSCM_NODMA);
                } else if (ifp->if_flags & IFF_UP &&
                    (ifp->if_flags & IFF_RUNNING) == 0)
                        neinit(ifp->if_unit);
                break;

#ifdef notdef
        case SIOCGHWADDR:
                bcopy((caddr_t)ns->ds_addr, (caddr_t) &ifr->ifr_data,
                        sizeof(ns->ds_addr));
                break;
#endif

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

/*
 * Reset of interface.
 */
nereset(unit, uban)
        int unit, uban;
{
        if (unit >= NNE)
                return;
        printf("ne%d: reset\n", unit);
        ne_softc[unit].ns_flags &= ~DSF_LOCK;
        neinit(unit);
}
#endif	MACH_KERNEL
#endif