BSD 4_3_Reno release

[unix-history] / usr / src / sys / vaxuba / np.c

/*
 * Copyright (c) 1986 MICOM-Interlan, Inc., Boxborough Mass
 * All rights reserved.  The Berkeley software License Agreement
 * specifies the terms and conditions for redistribution.
 *
 *	@(#)np.c	7.7 (Berkeley) 6/21/90
 *
 * From:
 *	np.c version 1.5
 *
 *	This version retrieved: 8/18/86 @ 18:58:54
 *	    This delta created: 8/18/86 @ 18:19:24
 *
 *	static		char	*SCCSID = "@(#)np.c	1.5";
 *
 */

		/******************************************
 		*					  *
 		*		NPDRIVER		  *
 		*					  *
 		******************************************/

/*
 * The NP Driver is used to route requests, independent of protocol type,
 * to the NP series Intelligent Board. The facilities it provides are
 * used for board maintainance by the superuser and by protocol pseudo-drivers, 
 * such as WN, for sending requests to a board. The board maintainance and
 * control functions are accessed via npioctl() by the NP support utilities.
 */

/*
 * Modification History:
 * 4/9/86 DDW Removed pseudo-driver initialization flag resets from NpReset
 * 5/28/86 CJM Changed iodone() to wakeup() in NpProcQueue().
 *
 */

/*
 * Include Files
 */

#include "np.h"
#if NNP > 0
#include "param.h"
#include "buf.h"
#include "ubavar.h"
#include "signal.h"
#include "systm.h"
#include "user.h"
#include "proc.h"
#include "uio.h"
#include "errno.h"

#include "../vaxuba/npreg.h"

#define b_uio b_forw
#define b_rp  av_back
/*
 * Global variables for pseudo-drivers.
 */

int WnInitFlag = 0;
int IsInitFlag = 0;
int (*IxAttach)();
int (*IxReset)();

/*
 * Debugging level.
 */

int	NpDebug = 0;		

/* Driver Wide State used by the ICP */

int NpState = NPCLEAR;


/*
 * Master structure, one per board, contains request queue header,
 * shared memory address, and memory mapping information.
 */

struct npmaster npmasters[NNP];

/* Structure of the shared memory area */

static struct npspace npspaces[NNP];

/* Panic Message data structures */

static int panicmap;			/* Mapping information */
static char	NpPbuf[PANLEN] = 0;	/* Panic message buffer */
static caddr_t pstring;			/* Panic string address on board, absolute */
static unsign16 panaddr[2];		/* Panic string address on board (seg/offset) */

/* Driver Wide Connection Table */

static struct npconn npcnxtab[NNP][NNPCNN];

/* Head of the request queue, one per board */

static struct npreq reqhdr[NNP];

/* Require for diagnostic packages */

typedef struct npreq *reqptr;
reqptr np_mapreq[NNP];

/* The request structures, one pool per board */

static struct npreq npreqs[NNP][NUMCQE];


/*
 * Data structures needed for BSD 4.2 Device Drivers
 */

int	npprobe(), npattach(), npintr();
struct	uba_device *npdinfo[NNP];

/* UNIBUS address of Network Processors */

u_short	npstd[] = { 0166000, 0166020, 0 };

/* Interrupt vectors used by the Network Processors */

static unsign16 npvectors[NNP];

struct	uba_driver npdriver =
    { npprobe, 0, npattach, 0, npstd, "np", npdinfo };
struct	buf	np_tab[NNP];
static unsigned long np_icount[NNP];


/*
 * External function and data structure declarations.
 */

struct npreq * NpGetReq();
struct npmaster	*NpBoardChange();
int NpTimer();
struct CQE * NpRemCQE();

extern struct user u;
\f
/*
 * Np_init() is responsible for hardware initializiation and the software 
 * initialization of the connection table and driver software data structures.
 */

npinit(unit)
int unit;
{
	register int j;


		/* Software Initialization */

	npmasters[unit].flags = NPCLEAR;

	NpSWinit(unit);

		/* Hardware Initialization */

	NpHWinit(unit);		

		/* Connection Table Initialization */

	for(j=0;j<NNPCNN;j++) {
		npcnxtab[unit][j].protocol = NPCLCONN;
		npcnxtab[unit][j].unit = &npmasters[unit];
	}
}
\f
/*
 * Np_open establishes a connection to the NP Driver using the minor
 * device number as an identifier. A default protocol, NPMAINT, is assigned
 * with the specified unit. Protocol and unit may be changed using the 
 * NpProtChange and NpBoardChange functions.
 * Since the maintainance protocol does not need a working I-Board, entries
 * are always made in the Connection Table, npcnxtab, if the board exists.
 */

/*ARGSUSED*/
npopen(dev,flag)
dev_t dev;
int flag;
{
	int unit;
	unsign16 conn;
	struct npmaster *mp;
	int error;

	if(NpDebug & DEBENTRY)
		printf("npopen\n");

	/* Clear error */

	error = 0;

	/* Make sure it's the superuser */

	if(u.u_uid) 
		return(EPERM);
	
	/* Get the connection identifier */

	if(((conn = NPCONN(dev)) >= NNPCNN) ||
	    ((unit = NPUNIT(dev)) >= NNP)) 
		return(ENODEV);
	

	if(NpDebug  & DEBOPEN)
		printf("conn = %x unit = %d\n",conn,unit);

	/* Get the board for the specified unit */

	mp = NpBoardChange(NPMAINT,unit);

	if(mp != (struct npmaster *) 0) {
		npcnxtab[unit][conn].unit = mp;
		npcnxtab[unit][conn].protocol = NPMAINT;
	}
	else error = ENXIO;

	if(NpDebug & DEBENTRY)
		printf("npopen...\n");

	return(error);
}
\f
/*
 * Np_close is responsible updating the connection table for
 * that connection by marking it closed.
 */

npclose(dev)
dev_t dev;
{

	if(NpDebug & DEBENTRY)
		printf("npclose\n");

	/* Get the connection identifier */

	npcnxtab[NPUNIT(dev)][NPCONN(dev)].protocol = NPCLCONN;

	if(NpDebug & DEBENTRY)
		printf("npclose...\n");

	return(0);

}
\f
/*
 * Npioctl is the main conduit of commands between the I-Board and the
 * NP support utilities. Relevant information for the request is found in the
 * cmd and addr parameters. Cmd specifies the function to perform, addr is 
 * command specific. Npioctl returns 0 if successful, or an error number
 * (which winds up in errno).
 */

/*ARGSUSED*/
npioctl(dev,cmd,addr,flag)
dev_t dev;
int cmd;
caddr_t *addr;
int flag;
{
	unsign16 protocol;
	unsign16 conn;
	unsign16 unit;
	int error;

	register struct npmaster *mp;
	register struct npreq *rp;
	unsigned usrarg;

	if(NpDebug & DEBENTRY)
		printf("npioctl\n");

	/* Clear error */

	error = 0;

	/* Strip off IOC_VOID bit */

	cmd &= CMDMASK;

	/* Get connection identifier */

	conn = NPCONN(dev);
	unit = NPUNIT(dev);

	/* Master pointer for this unit */

	mp = npcnxtab[unit][conn].unit;

	protocol = npcnxtab[unit][conn].protocol;

	/* Get a request structure from the pool and initialize it */

	while((rp = NpGetReq(mp->reqtab)) == NULL) {
		mp->reqtab->flags |= WANTREQ;
		sleep((caddr_t)(mp->reqtab),PZERO -1);
	}

	if(NpDebug & DEBREQ)
		printf("NP Reqp is %x\n",rp);

	/* Initializations of request structure */

	rp->intr = (int (*)())0;	/* Do not call interrupt routine */
	rp->bufoffset = 0;		/* Offset into data buffer */
	rp->procp = u.u_procp; 	/* Process structure for this user */

	/* Copy in user's argument to ioctl() call */

	if(error = copyin(*addr,&usrarg,sizeof(usrarg)))
		return(error);
	

	if(NpDebug & DEBIOCTL)
		printf("arg = %x\n",usrarg);

	/* Execute the specified command */

	switch(cmd) {

	    case NPSETPROT:
	    	if((error = NpProtChange(usrarg,mp->unit)) == 0)
			npcnxtab[unit][conn].protocol = usrarg;
		break;
	    case NPSETBOARD:
		if(mp = NpBoardChange(protocol,usrarg))
			npcnxtab[unit][conn].unit = mp;
		else {
			mp = npcnxtab[unit][conn].unit;
			error = ENXIO;
		}
		break;
	    case NPRESET:
		error = NpReset(mp,rp);
		break;
	    case NPSETNPDEB:
		NpDebug = usrarg;
		break;
	    case NPINIT:
		error = NpSWinit(mp->unit);
		break;
	    case NPSTART:

#ifdef OLDROM
		/*
		 * Kludge to work around I-Board boot from Host. Read two bytes
		 * from the board into the Device Configuration Word
		 * in Shared Memory.
		 */

		NPIO(mp,(paddr_t)0x500,(paddr_t)(&mp->shmemp->statblock.sb_dcw),2,B_READ);

		mp->shmemp->statblock.sb_drw = 0;
#endif

		/* Set the Address at which to begin On-Board execution */

		error = NpSetXeqAddr(mp,(caddr_t)usrarg);
		break;
	    case NPSTATS:
		error = NpStats();
		break;
	    case NPGPANIC:
		error = copyout((caddr_t)NpPbuf,*addr,PANLEN);

		/* Clear panic request flag and leave */

		mp->flags &= ~PANICREQ;
		break;
	    case NPPOLL:
		error = NpPoll(mp,*addr);
		break;
	    case NPKILL:
		error = NpKill(mp,rp);
		break;
	    case NPSETADDR:
		error = NpSetMemAddr(mp,*addr);
		break;
	    case NPRCSR0:
		usrarg = RCSR0(mp->iobase);
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPRCSR1:
		usrarg = RCSR1(mp->iobase);
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPRCSR2:
		usrarg = RCSR2(mp->iobase);
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPRCSR3:
		usrarg = RCSR3(mp->iobase);
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPWCSR0:
		WCSR0(mp->iobase,usrarg);
		break;
	    case NPWCSR1:
		WCSR1(mp->iobase,usrarg);
		break;
	    case NPWCSR2:
		WCSR2(mp->iobase,usrarg);
		break;
	    case NPWCSR3:
		WCSR3(mp->iobase,usrarg);
		break;
	    case NPNETBOOT:
		error = NpSetIntLevel(mp,mp->vector);
		if(error) break;
		error = NpSetXeqAddr(mp,(caddr_t)INETBOOT);
		break;
	    case NPSETLAST:
		if (usrarg)
			mp->flags &= ~LSTCMD;
		else
			mp->flags |= LSTCMD;
		break;
	    case NPCLRICNT:
		np_icount[unit] = NPCLEAR;
		break;
	    case NPGETICNT:
		usrarg = np_icount[unit];
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPGETIVEC:
		usrarg = mp->vector;
		error = copyout((caddr_t)&usrarg,*addr,sizeof(usrarg));
		break;
	    case NPMAPMEM:
		error = NpMem(mp, rp, *addr);
		break;
	    default:
		printf("Bad Maintenance command: %d!\n",cmd);
		error = EIO;
		break;
	}
	if((cmd != NPRESET) && (cmd != NPINIT) && (cmd != NPMAPMEM))
		NpFreeReq(mp->reqtab,rp);

	if(NpDebug & DEBENTRY)
		printf("npioctl...\n");

	return(error);
}

/*
 * np_start - start io activity
 */
npstart(mp)
register struct npmaster *mp;
{

	register struct uio 	*uio;
	register struct buf	*bp;
	register struct npreq	*rp;

	int error;			/* Return from NPIO call */

	if(NpDebug & DEBENTRY)
		printf("npstart\n");

	if((bp = np_tab[mp->unit].b_actf) == (struct buf *)0) {
		np_tab[mp->unit].b_active = 0;
		return;
	}
	if((rp = (struct npreq *)(bp->b_rp)) == (struct npreq *)0) {
		bp->b_flags = B_ERROR;
		iodone(bp);
		return;
	}
	if ((uio = (struct uio *)bp->b_uio) == (struct uio *)0) {
		bp->b_flags = B_ERROR;
		iodone(bp);
		return;
	}
	np_tab[mp->unit].b_active = 1;

	if(NpDebug & DEBIO)
		printf("NP IO src %x dst = %x cnt = %x\n", bp->b_un.b_addr,
			uio->uio_offset, bp->b_bcount);

	/* Send the request to the board via the CSR0 command interface */

	if(bp->b_flags & B_READ) 
		error = NPIO(mp, (paddr_t)uio->uio_offset, (paddr_t)rp->bufaddr,
	    		bp->b_bcount, (bp->b_flags & B_READ)); 
	else
		error = NPIO(mp, (paddr_t)rp->bufaddr, (paddr_t)uio->uio_offset,
			bp->b_bcount, (bp->b_flags & B_READ)); 
	

	/* Check return from I/O */

	if(error) {
		bp->b_flags |= B_ERROR;
		np_tab[mp->unit].b_actf = bp->av_forw;
		if(NpDebug & DEBIO)
			printf("NPIO return error: b_flags is %x \n",bp->b_flags);
		iodone(bp);
	}

	if(NpDebug & DEBENTRY)
		printf("npstart...\n");

}
/*
 * npstrategy - the strategy routine
 */

npstrategy(bp)
register struct buf *bp;
{

	register struct buf *ip;	/* quick pointer */
	register struct npmaster *mp;	/* master structure for this device */
	register struct npreq *rp;	/* reqest struct pointer */
	int s;				/* priority to return to */

	if(NpDebug & DEBENTRY)
		printf("npstrategy\n");
	if(NpDebug & DEBIO)
		printf("flag = %x count = %x paddr = %x %x blkno = %x %x\n",
		    bp->b_flags, bp->b_bcount, bp->b_un.b_addr, bp->b_un.b_addr,
		    bp->b_blkno,bp->b_blkno);

	/* get master structure */

	mp = npcnxtab[NPUNIT(bp->b_dev)][NPCONN(bp->b_dev)].unit;

	/* make sure the boards ok */

	if (mp->flags & BADBOARD) {
		bp->b_flags |= B_ERROR;

		if(NpDebug & DEBMEM)
			printf("Bad Board %x bp %x\n",mp->flags,bp->b_flags);

		np_tab[mp->unit].b_actf = bp->av_forw;
		iodone(bp);
		return;
	}

	/* Initializations of request structure */

	while((rp = NpGetReq(mp->reqtab)) == NULL) {
		mp->reqtab->flags |= WANTREQ;
		sleep((caddr_t)(mp->reqtab),PZERO -1);
	}

	rp->bufoffset = 0;		/* This is the start of the buffer */
	ip = &np_tab[mp->unit];
	bp->b_rp = (struct buf *)rp;

	rp->flags |= KERNREQ;		/* Mark it as kernel so not to map */

	rp->mapbase = ubasetup(mp->devp->ui_ubanum,bp,0);
	rp->bufaddr = (caddr_t)((int)(rp->mapbase) & UBADDRMASK);

	s = spl5();
	if(ip->b_actf ==(struct buf *)0)
		ip->b_actf = bp;
	else {
		if(ip->b_actf->av_forw)
			printf("Panic NP100 bad buffer chain\n");
		ip->b_actf->av_forw = bp;
	}
	ip->b_actl = bp;

	NpAddReq(mp->reqtab,rp);		/* Queue onto active list */

	if(ip->b_active == 0) {

		if(NpDebug & DEBIO)
			printf("calling npstart %x\n",mp);

		npstart(mp);
	}
	splx(s);

	if(NpDebug & DEBIO)
		printf("back from npstart\n");

	/* Await completion of I/O */

	iowait(bp);

	if(NpDebug & DEBIO)
		printf("after iowait in npstrategy\n");

	/* Remove request from queue */

	NpRemReq(rp);

	/* Release mapping registers */

	ubarelse(mp->devp->ui_ubanum,&rp->mapbase);

	/* Free up request structure */

	NpFreeReq(mp->reqtab,rp);

	if(NpDebug & DEBENTRY)
		printf("Leaving npstrategy flags is %x\n",bp->b_flags);
}

unsigned
nptrim(bp)
register struct buf *bp;
{

	if(bp->b_bcount > NPMAXXFR)
		bp->b_bcount = NPMAXXFR;
}

/*
 * Npread dumps data from the board to the user's buffer
 */
npread(dev,uio)
dev_t dev;
struct uio *uio;
{
	struct buf *bp;
	bp = &npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_rbuf;

	if(NpDebug & DEBENTRY)
		printf("in npread\n");

	bp->b_uio = (struct buf *)uio;
	return(physio(npstrategy,bp,dev,B_READ ,nptrim,uio));
}

/*
 * Npwrite loads the np100 board from the user's buffer
 */

npwrite(dev,uio)
dev_t dev;
struct uio *uio;
{
	struct buf *bp;
	bp = &npcnxtab[NPUNIT(dev)][NPCONN(dev)].np_wbuf;

	if(NpDebug & DEBENTRY)
		printf("in npwrite \n");

	bp->b_uio = (struct buf *)uio;
	return(physio(npstrategy,bp,dev,B_WRITE ,nptrim,uio));
}

/*
 * npreset - called as result of a UNIBUS reset.
 */

npreset(uban)
int uban;
{

	register struct npmaster *mp;
	register struct npreq *rp;
	register struct uba_device *ui;
	int i;

	if(NpDebug & DEBENTRY)
		printf("npreset(ubareset)\n");
	for(i = 0; i < NNP; i++) {

		if(((ui = npdinfo[i]) == (struct uba_device *)NULL) ||
			(ui->ui_ubanum != uban))
			continue;

		mp = &npmasters[i];

		/* Get a Request structure */

		while((rp = NpGetReq(mp->reqtab)) == NULL) {
			mp->reqtab->flags |= WANTREQ;
			sleep((caddr_t)(mp->reqtab),PZERO -1);
		}

		NpReset(mp,rp);
	}
	if(NpDebug & DEBENTRY)
		printf("npreset(ubareset)...\n");
}


/*
 * Nppoll looks for work by polling each board. He goes to sleep if there are
 * no outstanding requests for him but reminds the board that he's there when
 * needed.
 */

NpPoll(mp,addr)
struct npmaster *mp;
caddr_t	addr;
{
	int error;

	struct {
		unsign16 request;
		unsign16 unit;
	}icpreq;

	if(NpDebug & DEBMAINT)
		printf("NpPoll: flags is %x.\n",mp->flags);

	while(TRUE) {

		for(mp = npmasters; mp; mp = mp->next) {

			if(mp->flags & BOARDREQ) {

				/* Get request type from master structure */

				if(mp->flags & BRDRESET) {
					icpreq.request = ICPPOLL;
					mp->reqtab->reqcnt--;

					if(NpDebug & DEBMAINT)
						printf("Waking NpResetter!\n");

					wakeup((caddr_t)(&mp->reqtab));
				}
				else if(mp->flags & PANICREQ)
					icpreq.request = ICPPANIC;
				else if(mp->flags & DUMPREQ)
					icpreq.request = ICPDUMP;
				else if(mp->flags & LOADREQ)
					icpreq.request = ICPLOAD;
				else {
					mp->flags &= ~BOARDREQ;
					continue;
				}

				if(NpDebug & DEBMAINT)
					printf("ProcICP servicing %d \n",icpreq.request );

				/* Request and unit number to be sent */

				icpreq.unit = mp->unit;

				/* Copy service request to calling process */

				error = copyout(&icpreq,addr,sizeof(icpreq));

				/* Mark Poller as being unavailable */

				NpState &= ~ICPAVAIL;

				return(error);
			}
		}

		/* Mark Poller as being available */

		NpState |= ICPAVAIL;

		if (error = tsleep((caddr_t)&NpState, (PZERO + 1) | PCATCH,
		    devio, 0))
			return (error);

		if(NpDebug & DEBMAINT)
			printf("wakeup in NpPoll\n");

	}
}
\f
/*
 * Software initialization of Driver data structures for the specified unit.
 */

NpSWinit(unit)
int unit;
{

	register int j;
	register struct npmaster *mp;
	register struct npspace *npsp;
	register struct CmdQue *cqp;
	int offset;

	if(NpDebug & DEBINIT)
		printf("SW reset on unit %d.\n",unit);

	np_icount[unit] = NPCLEAR;
	np_mapreq[unit] = (struct npreq *) NPCLEAR;

	/* Initialize master structure pointer for this unit */

	mp = &npmasters[unit];

	/* Initialize unit buffer headers */

	np_tab[unit].b_active = 0;
	np_tab[unit].b_actf = 0;

	/* UBA device structure for this unit */

	mp->devp = npdinfo[unit];

	/* Interrupt vector for this unit */

	mp->vector = npvectors[unit];

	if(unit == (NNP -1))
		mp->next = (struct npmaster *)NULL;
	else mp->next = &npmasters[unit + 1];

	/*
	 * Guarantee alignment of shared memory area on a
         * 16 byte boundary as required by I-Board
	 */

	mp->shmemp = &npspaces[unit];
	mp->shmemp = (struct npspace *)ROUND16((int)(mp->shmemp));

	/* Base address of this controller */

	mp->iobase = (struct NPREG *)(mp->devp->ui_addr);

	if(NpDebug & DEBMEM) { 
		printf("Npspaces starts at %x.\n",npspaces);
		printf("Shared memory starts at %x.\n",mp->shmemp);
		printf("End of shared memory is %x.\n",&npspaces[unit + 1]);
		printf("Iobase is %x.\n",mp->iobase);
		printf("Npmasters start at %x\n",npmasters);
		printf("Reqhdr start at %x\n",reqhdr);
		printf("Npreqs start at %x\n",npreqs);
 	}

	/* Initialize the request header */

	mp->reqtab = &reqhdr[unit];

	/* Unit initialization */

	mp->unit = unit;

	/* Initialize Status Block */

	npsp = mp->shmemp;
	offset = (int) (mp->shmemp);

	npsp->statblock.sb_drw = 0;
	npsp->statblock.sb_hcw = HOSTCONF;
	npsp->statblock.sb_dcw = 0;
	npsp->statblock.sb_dpm = 0;

	npsp->statblock.sb_dcq = (unsign16)((int)(&npsp->devcq))-offset;

	npsp->statblock.sb_hcq = (unsign16)((int)(&npsp->hostcq))-offset;

	/* Initialize Device Command Queue */

	cqp = (struct CmdQue *) &npsp->devcq;

	if(NpDebug & DEBCQ) 
		printf("Device CQ at %x\n",cqp);

	cqp->scanflag = NPCLEAR;
	cqp->chngflag = NPCLEAR;

	cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
	cqp->cq_rem = cqp->cq_add;

	cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;

	for(j = 0; j < NUMCQE; j++)
		cqp->cq_cqe[j] = (unsign16)NULL;

	/* Initialize Host Command Queue */

	cqp = (struct CmdQue *) &npsp->hostcq;

	if(NpDebug & DEBCQ) 
		printf("HOST CQ at %x\n",cqp);

	cqp->scanflag = NPCLEAR;
	cqp->chngflag = NPCLEAR;

	cqp->cq_add = (unsign16)(int)(&cqp->cq_cqe[0]) - offset;
	cqp->cq_rem = cqp->cq_add;

	cqp->cq_wrap = (unsign16)(int)(&cqp->cq_cqe[NUMCQE]) - offset;

	for(j = 0; j < NUMCQE; j++)
		cqp->cq_cqe[j] = (unsign16)NULL;

	/*
	 * Initialize the reqid of the elements to the address
	 * of the corresponding Npreq structure. These don't change.
 	 */

	for(j = 0; j < NUMCQE; j++)
		npsp->elements[j].cqe_reqid = &npreqs[unit][j];

	/*
	 * Initialize the Request Header (reqhdr), free list of
 	 * npreqs, and pointers to CQEs.
 	 */

	reqhdr[unit].forw = reqhdr[unit].back = &reqhdr[unit];
	reqhdr[unit].free = &npreqs[unit][0];

	for(j = 0; j < NUMCQE; j++) {
		npreqs[unit][j].free = &npreqs[unit][j + 1];
		npreqs[unit][j].element = &npsp->elements[j];
		npreqs[unit][j].forw = npreqs[unit][j].back = (struct npreq *)NULL;
		npreqs[unit][j].flags = NPCLEAR;
	}
	npreqs[unit][--j].free = &reqhdr[unit];

	/*
	 * Set up the UNIBUS I/O Map Registers for the
	 * Shared memory area.
 	 */

	mp->iomapbase = uballoc(mp->devp->ui_ubanum,(caddr_t)(mp->shmemp),sizeof(struct npspace),0);


	if(NpDebug & DEBENTRY)
		printf("SW_Init...\n");
	return(0);
}
\f
/*
 * NpHWinit() issues a hardware reset to the specified board and waits
 * for on-board diagnostics to complete. It returns 0 if the board is
 * present and passed diagnostics, an error value otherwise.
 */

NpHWinit(unit)
int unit;
{
	register struct npmaster *mp;
	struct NPREG *REG;
	unsign16 status;
	int dflag;

	if(unit >= NNP)
		return(ENXIO);

	mp = &npmasters[unit];

	if(NpDebug & DEBENTRY)
		printf("NpHWinit\n");

	/* See if the board is out there */

	REG = (struct NPREG *)mp->iobase;

	if(NpDebug & DEBINIT)
		printf("REG in HWinit is %x.\n",mp->iobase);

	if(!(mp->flags & BRDRESET))

		if(badaddr(REG,2)) {
			mp->flags |= BADBOARD;
			printf("\nNP100 unit %d not found!\n",unit);
			return(ENXIO);
		}


	if(NpDebug & DEBENTRY)
		printf("Resetting the NP100 Board at %x\n",mp->iobase);

	/* Reset the Board */

	RESET(mp);

	dflag = NPCLEAR;

	timeout(NpTimer,&dflag,DIAGTIME);

	/* Wait for Enable and Read Data Ready to go high */

	while(! ((RCSR1(mp->iobase) & NPENB) && (RCSR1(mp->iobase) & NPRDR))) {
		if(dflag)
			break;

	}

	untimeout(NpTimer,&dflag);

	if(NpDebug & DEBINIT)
		printf("np reset %d \n",dflag);

	if(dflag) {
		mp->flags |= BADBOARD;
		printf("NP100 Unit %d timed out!\n",unit);
		return(EIO);
	}

	status = RCSR0(mp->iobase);

	/* Check for Hardware OK */

	if(!(RCSR1(mp->iobase) & NPHOK)) {
		mp->flags |= BADBOARD;
		printf("NP100 Unit %d Failed diagnostics!\n",unit);
		printf("Status from CSR0: %x.\n",status);
		return(EIO);
	}

	if(NpDebug & DEBENTRY)
		printf("HWinit...\n");

	return(0);
}
\f
/*
 * NP Driver Interrupt Handler
 */

npintr(unit)
int unit;
{
	register struct npmaster *mp;
	register struct buf	*bp;

	if(NpDebug & DEBENTRY)
		printf("npintr on unit %d!\n",unit);

	mp = &npmasters[unit];
	np_icount[unit]++;

	if(NpDebug & DEBINTR)
		printf("npintr mp->flags = %x  interupt count = %x\n",
			mp->flags, np_icount[unit]);

	/* Wake up anyone sleeping on a CSR0 Command */

	if(mp->flags & CSRPEND) {

		mp->flags &= ~CSRPEND;
		if(np_tab[mp->unit].b_active) {
			np_tab[mp->unit].b_active = 0;
			bp = np_tab[mp->unit].b_actf;
			np_tab[mp->unit].b_actf = bp->av_forw;

			if(NpDebug & DEBINTR)
				printf("bp = %x resid = %d forw = %x\n",bp,
				    bp->b_resid,bp->av_forw);

			bp->b_resid = 0;
			iodone(bp);
		}
		if(mp->flags & PANIC3) {
			mp->flags &= ~PANIC3;
			mp->flags = AVAILABLE;
			ubarelse(mp->devp->ui_ubanum,&panicmap);
		}
		if(mp->flags & PANIC2) {
			mp->flags &= ~PANIC2;
			printf("Panic Message: %s",NpPbuf);
			mp->flags |= PANIC3;
			NpPbuf[0] = 0;
			NPIO(mp,(paddr_t)((int) panicmap & UBADDRMASK),(paddr_t)pstring,sizeof(NpPbuf),B_WRITE);
		}
		if(mp->flags & PANIC1) {
			mp->flags &= ~PANIC1;
			mp->flags |= PANIC2;
			ubarelse(mp->devp->ui_ubanum,&panicmap);
			panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)NpPbuf,sizeof(NpPbuf),0);
			pstring = (caddr_t)((panaddr[1] << 4) + panaddr[0]);
			NPIO(mp,(paddr_t)pstring,(paddr_t)((int) panicmap & UBADDRMASK),sizeof(NpPbuf),B_READ);
		}

		wakeup((caddr_t)mp);
		goto out;
	}

	/* Mark unit as being available if Device Protocol Mask set */

	if(!(mp->flags & AVAILABLE)) {

		if((mp->shmemp->statblock.sb_dpm) && (!(mp->flags & BRDRESET)))

			mp->flags = AVAILABLE;
	}

	/* Honor service requests from the device */

	switch(mp->shmemp->statblock.sb_drw) {

	    case NOREQ:
		break;

	    case NPPANIC:

		printf("\nPanic from NP100 unit %d!\n",mp->unit);
		mp->flags &= ~AVAILABLE;
		mp->flags |= PANIC1;

		/* Clear device request word */

		mp->shmemp->statblock.sb_drw = 0;

		panicmap = uballoc(mp->devp->ui_ubanum,(caddr_t)panaddr,sizeof(panaddr),0);
		NPIO(mp,(paddr_t)NPPSADDR,(paddr_t)((int)panicmap & UBADDRMASK),sizeof(panaddr),B_READ);
		goto out;
		break;

	    case NPDUMP:
		mp->flags |= (DUMPREQ | BOARDREQ);

		/* Clear device request word */

		mp->shmemp->statblock.sb_drw = 0;

		if(NpState & ICPAVAIL)
			wakeup((caddr_t)&NpState);
		break;

	    case NPLOAD:
		mp->flags |= (LOADREQ | BOARDREQ);

		/* Clear device request word */

		mp->shmemp->statblock.sb_drw = 0;

		if(NpState & ICPAVAIL)
			wakeup((caddr_t)&NpState);
		break;

	    default:
		printf("Bad Req: %x.\n",mp->shmemp->statblock.sb_drw);
		goto out;

	}

 	/* Process the Host Command Queue for this device */

	NpProcQueue(mp);

out:
	CLEARINT(mp);	/* Clear the interrupt */

	if(NpDebug & DEBENTRY)
		printf("npintr...\n");

	return(1);	/* Interrupt serviced */

}
\f
/*
 * This routine, called from the interrupt handler, is used to process the
 * Host Command Queue for the specified device.
 */

NpProcQueue(mp)
struct npmaster *mp;
{
	register struct CmdQue *cqp;
	register struct CQE *ep;
	register struct npreq *rp;
	register int base;
	int s;

	if(NpDebug & DEBENTRY)
		printf("NpProcQueue\n");

	cqp = &mp->shmemp->hostcq;	/* Command Queue pointer */

	s = spl5();
	if(mp->flags & SCANNING) {
		splx(s);
            	return;
	}
	mp->flags |= SCANNING;
	splx(s);

	cqp->scanflag | = ON;

	base = (int)mp->shmemp;		/* Shared memory base address */

	while(1) {

	       	cqp->scanflag |= ON;
		cqp->chngflag &= ~ON;
		while(ep = NpRemCQE(cqp,base)) {

			rp = ep->cqe_reqid;

			if(NpDebug & DEBCQE)
				printf("cqe_sts is %x ep = %x\n",ep->cqe_sts,ep);

			switch (ep->cqe_sts)  {

			    case NPDONE:
				rp->flags |= REQDONE;	/* Normal completion */
				break;
			    case NPIFC:			/* IFC Request */
				rp->flags |= IOIFC;
				break;
			    case NPPERR:		/* Protocol Error */
				rp->flags |= (NPPERR | REQDONE);
				break;
			    case NPMERR:		/* Memory allocation */
				rp->flags |= (NPMERR | REQDONE);
				break;
			    default:			/* Error on Board */
				rp->flags |= (IOERR | REQDONE);
				break;

			}

			if(NpDebug & DEBCQE) {
				printf("flag is %x reqid = %x\n",rp->flags,ep->cqe_reqid);
				printf("wakeup in procqueue\n");
			}

			if(rp->intr) {

				if(NpDebug & DEBINTR)
					printf("calling usr intr at %x\n",
						rp->intr);

				/* Call interrupt routine */

				(*rp->intr)(mp,rp);
			}
			else {

			if(NpDebug & DEBINTR)
				printf("waking up %x\n",rp);

				/* if(rp->flags & NPUIO)
					iodone(&rp->buf);
				else	wakeup((caddr_t) (rp)); /* Awaken */

				wakeup((caddr_t)(rp)); 	/* Awaken */
			if(NpDebug & DEBINTR)
				printf("AWAKE\n");
			}
		}

		cqp->scanflag &= ~ON;
		if(!(cqp->chngflag & ON))
			break;

	}

	mp->flags &= ~SCANNING;
	if(NpDebug & DEBENTRY)
		printf("NpProcQueue...\n");
}

/*
 * NpIFC - processes an IFC (Internal Fuction Call) request 
 *		NOTE: this function must be called from the user context
 *			on all virtual pageing systems
 *
 */
NpIFC(mp,rp)
register struct npmaster *mp;
register struct npreq *rp;
{
	register struct CQE	*ep;

	if(NpDebug & DEBENTRY)
		printf("NpIFC\n");

	ep = rp->element;
	rp->flags &= ~IOIFC;
	switch(ep->cqe_func) {

	    case NPUNLOCK:	/* Unlock process, free up mapping registers  */

		if(NpDebug & DEBIFC)
			printf("NPUNLOCK\n");

		if(rp->mapbase)
			NpUnMapMem(mp,rp);
		break;

	    case NPLOCK:	/* Lock process, get mapping registers */

		if(NpDebug & DEBIFC)
			printf("NPLOCK\n");
		NpMapMem(mp,rp,rp->virtmem,rp->bytecnt);
		ep->cqe_dma[0] = LOWORD(rp->bufaddr);
		ep->cqe_dma[1] = HIWORD(rp->bufaddr);
		break;

	    case NPREMAP:

		if(NpDebug & DEBIFC)
			printf("NPREMAP\n");

		/* Remap user buffer and update buffer offset */
#ifdef USG
		np_remapmem(rp,rp->virtmem); 
		ep->cqe_dma[0] = LOWORD(rp->bufaddr);
		ep->cqe_dma[1] = HIWORD(rp->bufaddr);
		break;
#endif

	    default:
		if(NpDebug & DEBIFC)
			printf("Bad case %x in IFC\n", ep->cqe_func);

		rp->flags |= (REQDONE | IOERR);
		break;
	}
}
\f
/*
 * The following contains various routines for allocating and deallocating
 * structures used by the NP Driver. Routines are also here for addding
 * and removing Command Queue Elements from a Command Queue.
 */

/*
 * Get a free NP Request structure from the list pointed to by head. Returns
 * a pointer to a npreq or NULL if none left.
 */

struct npreq *
NpGetReq(head)
struct npreq *head;
{

	register struct npreq *p;

	p = head->free;
	head->free = p->free;
	if (p->flags & REQALOC)
		printf("GetReq: Req %x already allocated\n", p);
	p->flags &= WANTREQ;
	if (p != head)
		p->flags |= REQALOC;
	return(p==head ? (struct npreq *)NULL : p);
}

/*
 * Return a NP Request structure to the free list pointed to by head.
 */

NpFreeReq(head,nprp)
register struct npreq *head, *nprp;
{
	int s;

	if(NpDebug & DEBREQ)
		printf("NpFreeReq, head is %x rp is %x\n",head,nprp);

	if (nprp == NULL) {
		printf("FREEREQ: attempt to free null pointer\n");
		return;
	}
	if (!(nprp->flags & REQALOC)) {
		printf("FREEREQ: attempt to free unallocated request %x\n",
			nprp);
		return;
	}
	if (nprp->flags & REQUSE)
		printf("FREEREQ: freeing unremoved request %x\n", nprp);

	s = spl5();
	nprp->forw = nprp->back = (struct npreq *)NULL;
	nprp->free = head->free;
	head->free = nprp;
	nprp->flags &= ~REQALOC;
	splx(s);

	/* Wake up any processes waiting for a request structure */

	if(head->flags & WANTREQ) {
		head->flags &= ~WANTREQ;
		wakeup((caddr_t)head);
	}

	if(NpDebug & DEBENTRY)
		printf("NpFreeReq...\n");
}

/*
 * Add a Command Queue Element onto the specified Command Queue and
 * update its Add offset.
 */

NpAddCQE(ep,cqp,mp)
struct CQE *ep;
struct CmdQue *cqp;
struct npmaster *mp;
{

	register unsign16 *temp;
	register unsign16 cqe_offset;
	register int base;

	base = (int)mp->shmemp;		/* Shared memory base address */

	temp = (unsign16 *)(base + cqp->cq_add); /* Offset to add element */

	cqe_offset = (unsign16)((int)ep - base);

	if(*temp) {			/* Should never happen */

		printf("No more room on Command Queue!\n");
		return;
	}
	else *temp = cqe_offset;	/* Enter this request's offset */

	/* Update cqe_add where next request is to be added */

	cqp->cq_add += sizeof(unsign16);

	if(cqp->cq_add == cqp->cq_wrap)	/* Wrap if necessary */
		cqp->cq_add = (unsign16)((int)cqp->cq_cqe - base);

	cqp->chngflag |= ON;		/* Set change flag unconditionally */

	/* Interrupt the Board if his scan flag isn't on */

	if(!(cqp->scanflag & ON))

		INTNI(mp);		/* Interrupt the Board */

}

/*
 * The NpRemCQE routine is used to remove the next CQE from the Command Queue
 * specified by cqp. The common offset of shared memory used by the device
 * is specified by base. NpRemCQE returns a pointer to the next CQE or
 * NULL if there are none left. This routine will also update the cqe_rem
 * offset which specifies where the next element to be removed from the
 * queue is located.
 */

struct CQE *
NpRemCQE(cqp,base)
struct CmdQue *cqp;
int base;
{

	register unsign16 *temp;
	register unsign16 cqe_offset;

	cqp->chngflag &= ~ON;			/* Turn off unconditionally */

	/* Get address of element to remove */

	temp = (unsign16 *)(base +cqp->cq_rem);

	if(*temp == NULL)			/* If none left, go home */
		return((struct CQE *) NULL);

	else cqe_offset = *temp;		/* Offset of CQE to remove */

	/* Update the Command Queue's cqe_rem offset */

	*temp = NULL;				/* Clear out this entry */

	cqp->cq_rem += sizeof(unsign16);	/* Bump offset */

	if(cqp->cq_rem == cqp->cq_wrap)		/* Wrap if necessary */
		cqp->cq_rem = (unsign16)((int)cqp->cq_cqe - base);

	temp = (unsign16 *)(base + cqe_offset);	/* CQE address */
	return((struct CQE *)temp);		/* is returned */
}

/*
 * NpAddReq will add the specified npreq structure to the queue controlled
 * by head.
 */

NpAddReq(head,rp)
register struct npreq *head, *rp;
{
	int s;

	if (NpDebug & (DEBENTRY|DEBREQ))
		printf("NpAddReq: %x\n",rp);

	if (rp->flags & REQUSE)
		printf("ADDREQ: Request %x allready in use\n", rp);

	s = spl7();
	rp->forw = head->forw;
	rp->forw->back = rp;
	rp->back = head;
	head->forw = rp;
	rp->flags |= REQUSE;
	splx(s);

	if(NpDebug & DEBENTRY)
		printf("NpAddReq...\n");
}

/*
 * NpRemReq is used to remove a npreq structure from the queue specified by
 * head.
 */

NpRemReq(rp)
register struct npreq *rp;
{
	int s;

	if (NpDebug & (DEBENTRY|DEBREQ))
		printf("NpRemReq: %x\n",rp);

	if (rp == NULL) {
		printf("REMREQ: null pointer removal requested\n");
		return;
	}
	if (!(rp->flags & REQUSE)) {
		printf("REMREQ: trying to rem unused req %x\n", rp);
		return;
	}
	if (!(rp->flags & REQALOC)) {
		printf("REMREQ: trying to rem unallocated req %x\n", rp);
		return;
	}
		
	s = spl7();
	rp->back->forw = rp->forw;
	rp->forw->back = rp->back;
	rp->flags &= ~REQUSE;
	splx(s);

	if(NpDebug & DEBENTRY)
		printf("NpRemReq...\n");
}

\f
/*
 * The following routines are used to communicate with the
 * NI Hardware via the CSR0 commands. These commands are issued during
 * the hardware initializtion process and may also be used subsequently
 * by privileged processes who wish to communicate in this way. The
 * convention for passing data as a Command Block is discussed in detail
 * in the NI1510 UNIBUS Compatible Ethernet Communications Processor
 * Hardware Specification.
 */

NpSendCSR0(iobase,src,bcount)
struct NPREG *iobase;
register unsign16 *src;
int bcount;
{
	register int wcount;
	int i;
	int csrflag;
	unsign16 tmp;

	if(NpDebug & DEBENTRY)
		printf("NpSendCSR0\n");

	/* Jolt the board into CSR0 command mode if necessary */

	if(!(RCSR1(iobase) & NPENB)){   
		tmp = NPCLEAR;		/* MC68000 clr reads before writing */
		WCSR0(iobase,tmp); 	
	}

	wcount = (bcount +1) >> 1;	/* Convert byte count to word count */

	/* Clear timer flag before beginning the timer */

	csrflag = NPCLEAR;
	timeout(NpTimer,&csrflag,DIAGTIME);

	for(i = 0; (i < wcount) & (csrflag == NPCLEAR); i++) {
		while(! ((RCSR1(iobase) & NPENB) && (RCSR1(iobase) & NPRDY)))
			if(csrflag) break;
		WCSR0(iobase,*src);
		src++;			/* Better do this WCSR is a macro */
	}

	/* Clear the timer entry */

	untimeout(NpTimer,&csrflag);

	/* Error if timer went off */

	if(csrflag)
		return(EIO);	

	if(NpDebug & DEBENTRY)
		printf("NpSendCSR0...\n");
	return(0);
}

/*
 * NpSetIntLev sets the UNIBUS interrupt vector to be used by the NP board when
 * interupting the host. The board is specified by mp.
 */

NpSetIntLevel(mp,level)
struct npmaster *mp;
int level;
{

	struct {
		unsign16 cmd_word;
		unsign16 int_level;
	}cmd_block;

	cmd_block.cmd_word = NPCBI | CBICNT;
	cmd_block.int_level = level;

	return(NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block)));
}

/*
 * NpSetMemAddr is used to declare the shared memory area address to be used
 * for communication between the driver and the device. This address is used
 * to access data structures by acting as a base from which defined offsets
 * locate data. The board is specified by mp.
 */

NpSetMemAddr(mp,addr)
struct npmaster *mp;
caddr_t addr;
{

	caddr_t shmaddr;
	int error;

	struct {
		unsign16 cmd_word;
		unsign16 hi_addr;
		unsign16 lo_addr;
	} cmd_block;

	if(NpDebug & DEBENTRY)
		printf("NpSetMemAddr\n");

	shmaddr = addr;

	if(NpDebug & DEBMEM)
		printf("NpSetMemAddr, addr is %x shmaddr is %x.\n",addr,shmaddr);

	cmd_block.cmd_word = NPCMD | CMDCNT;
	cmd_block.hi_addr = HIWORD(shmaddr);
	cmd_block.lo_addr = LOWORD(shmaddr);

	error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));

	if(NpDebug & DEBENTRY)
		printf("NpSetMemAddr...\n");

	return(error);
}


/*
 * NpSetXeqAddr specifies the address at which the board should begin
 * execution of its on-board software. It also indicates the shared memory
 * address to be used. The board is specified by mp.
 */

NpSetXeqAddr(mp,addr)
struct npmaster *mp;
caddr_t addr;
{
	caddr_t shmaddr;
	int error;

	struct {
		unsign16 cmd_word;
		unsign16 hi_addr;
		unsign16 lo_addr;
		unsign16 mhi_addr;
		unsign16 mlo_addr;
	} cmd_block;

	if(NpDebug & DEBENTRY)
		printf("NpSetXeqAddr\n");

	shmaddr = (caddr_t)((int)mp->iomapbase & UBADDRMASK);

	cmd_block.cmd_word = NPBGN | NPCMD | NPLST | (BGNCNT + CMDCNT);
	cmd_block.hi_addr = HIWORD(addr);
	cmd_block.lo_addr = LOWORD(addr);
	cmd_block.mhi_addr = HIWORD(shmaddr);
	cmd_block.mlo_addr = LOWORD(shmaddr);

	if(NpDebug & DEBINIT) {
		printf("NpSetXeqAdddr: hi: %x lo: %x\n",HIWORD(addr), LOWORD(addr));
		printf("NpSetXeqAdddr: mhi: %x mlo: %x\n",HIWORD(shmaddr),LOWORD(shmaddr));
	}

	error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));

	if(NpDebug & DEBENTRY)
		printf("NpSetXeqAddr...\n");

	return(error);
}

/*
 * NPIO issues a CSR0 load or dump request to the I-Board after packaging a
 * CSR0 Command Block.
 */

NPIO(mp,src,dest,count,dir)
struct npmaster *mp;
paddr_t dest;
paddr_t src;
unsign16 count;
int dir;		/* Direction  READ/WRITE */
{

	int error;

	struct {
		unsign16 cmd_word;	/* Command Word */
		unsign16 shi_addr;	/* High word of Source Address */
		unsign16 slo_addr;	/* Low word of Source Address */
		unsign16 dhi_addr;	/* High word of Destination Address */
		unsign16 dlo_addr;	/* Low word of Destination Address */
		unsign16 count;		/* Byte count */
		unsign16 intlevel;	/* Interrupt level to host */
	} cmd_block;

	if(NpDebug & DEBENTRY)
		printf("NPIO\n");
	if(NpDebug & DEBMAINT) {
		printf("I/O src addr = %x, dest addr = %x \n",src,dest);
		printf("I/O count = %d \n",count);
	}

	cmd_block.cmd_word = NPCBI | (CBICNT + IOCNT);
	cmd_block.intlevel = mp->vector;
	cmd_block.shi_addr = HIWORD(src);
	cmd_block.slo_addr = LOWORD(src);
	cmd_block.dhi_addr = HIWORD(dest);
	cmd_block.dlo_addr = LOWORD(dest);
	cmd_block.count = count;
	if ((mp->flags & LSTCMD) == 0)
		cmd_block.cmd_word |= NPLST;
	if(dir == B_READ)
		cmd_block.cmd_word |= NPDMP;
	else
		cmd_block.cmd_word |= NPLD;


	if(NpDebug & DEBIO) {
		printf("cmd: %x int: %o shi: %x slo: %x dhi: %x dlo: %x cnt: %x\n",
	cmd_block.cmd_word,cmd_block.intlevel,cmd_block.shi_addr,cmd_block.slo_addr,
	cmd_block.dhi_addr,cmd_block.dlo_addr,cmd_block.count);
	}
	
	mp->flags |= CSRPEND;		/* CSR0 command pending */

	error = NpSendCSR0(mp->iobase,(unsign16 *)&cmd_block,(int)sizeof(cmd_block));
	if(NpDebug & DEBENTRY)
		printf("NPIO...\n");

	return(error);
}


/*
 * NpKill will terminate all outstanding requests for the specified board.
 */

NpKill(mp,curr_rp)
struct npmaster *mp;
struct npreq *curr_rp;
{
	struct npreq *rp;
	int s;

	if(NpDebug & DEBENTRY)
		printf("NpKill\n");

	mp->reqtab->reqcnt = 0;		/* Init request count */

	s = spl5();			/* Disable interrupts */

	/* Mark each active request as having an error and wake him up */

	for(rp = mp->reqtab->forw;rp != mp->reqtab;rp = rp->forw) {

		if(rp == curr_rp) continue;

		rp->flags |= (IOABORT | REQDONE);
		mp->reqtab->reqcnt++;
		/* if(rp->flags & NPUIO)
			iodone(&rp->buf);
		else */
		wakeup((caddr_t)rp);
	}

	if(NpDebug & DEBMAINT)
		printf("NpKill, req count is %d\n",mp->reqtab->reqcnt);

	splx(s);

	if(NpDebug & DEBENTRY)
		printf("NpKill...\n");

	return(0);

}

/* Hardware and Software Initializations for the specified unit */

NpReset(mp,rp)
register struct npmaster *mp;
struct npreq *rp;
{
	int error;

	if(NpDebug & DEBENTRY)
		printf("NpReset!\n");

	/* Mark board as being reset and make unavailable */

	mp->flags = BRDRESET;

	/* Abort outstanding requests for this board */

	mp->reqtab->reqcnt = 0;		/* Init request count */

	/* Wakeup Poller if available and wait until he's gone */

	if(NpState & ICPAVAIL) {

		mp->flags |= BOARDREQ;
		mp->reqtab->reqcnt++;

		if(NpDebug & DEBMAINT)
			printf("Waking ICP in reset!\n");

		wakeup((caddr_t)&NpState);

		while(mp->reqtab->reqcnt)
			if (error = tsleep((caddr_t)(&mp->reqtab),
			    (PZERO + 1) | PCATCH, devio, 0))
				return (error);

		if(NpDebug & DEBMAINT)
			printf("Reset:awoken by ICP senior!\n");

	}

	/* Abort outstanding requests and wait till they're gone */

	NpKill(mp,rp);

	while(mp->reqtab->reqcnt) {

		if(NpDebug & DEBMAINT) {
			printf("Sleeping in NpReset on reqtab!\n");
			printf("Reqcnt is %d.\n",mp->reqtab->reqcnt);
		}

		if (error = tsleep((caddr_t)(&mp->reqtab),
		    (PZERO + 1) | PCATCH, devio, 0))
			return (error);
	}

	/* Free up I/O Map registers if any allocated */

	if(mp->iomapbase) {

		if(NpDebug & DEBMEM)
			printf("freeing shared memory map.\n");

		ubarelse(mp->devp->ui_ubanum,&mp->iomapbase);
		mp->iomapbase = 0;
	}

	/* Initialize S/W data structures in NP Driver */

	NpSWinit(mp->unit);		/* Software initialization */

	/* Hardware initialization of the board */

	error = NpHWinit(mp->unit);	/* Hardware initialization */

	mp->flags &= ~BRDRESET;		/* Initialization complete */

	/* Initialize Pseudo-Drivers */

	if (IxReset)
		(*IxReset)(mp->unit, mp->devp->ui_ubanum, rp);

	/* Clear Poller's State Flag */

	NpState = NPCLEAR;

	if(NpDebug & DEBENTRY)
		printf("NpReset...\n");
	
	return(error);
}

/*
 * General purpose timeout function which sets the flag passed to it
 * as argument.
 */

NpTimer(flagp)
int *flagp;
{
	*flagp = NPSET;
}

NpStats()
{
	if(NpDebug & DEBENTRY)
		printf("npstats\n");
	return(0);
}

/*
 * NpCloseConn is called to issue a close connection command to the I-Board.
 */

NpCloseConn(mp,protocol)
struct npmaster *mp;
unsign16 protocol;
{

	register struct npreq *rp;
	register struct CQE *ep;
	int pri;

	if(NpDebug & DEBENTRY)
		printf("NpCloseConn\n");

	/*
	 * Don't issue the Close Connection command if the Board
         * isn't up.
         */

	if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol))) {
		return;
	}

	/* Get a Request structure */

	while((rp = NpGetReq(mp->reqtab)) == NULL) {
		mp->reqtab->flags |= WANTREQ;
		sleep((caddr_t)(mp->reqtab),PZERO -1);
	}

	rp->intr = (int (*)())0;	/* Do not call interrupt routine */
	rp->mapbase = 0;		/* Clear mapping information */

	ep = rp->element;		/* Handy pointer */

	/* Fill in CQE */

	ep->cqe_wind = 0;		/* Entire buffer mapped */
	ep->cqe_nbuf = 1;		/* Must be 1, no buffer chaining */
	ep->cqe_char = 0;		/* Set to 0 for now */

	ep->cqe_func = NPSTOP;		/* OS_STP to I-Board */

	ep->cqe_prot = protocol;	/* Protocol of this connection */
	ep->cqe_lenrpb = 0;		/* Parameter block length */

	ep->cqe_ust0 = ep->cqe_ust1 = NPCLEAR;	/* Clear status flags */

	ep->cqe_famid = (unsign32)u.u_procp->p_pid;  /* Process ID */

	NpAddReq(mp->reqtab,rp);	/* Queue onto active list */

	pri = spl5();			/* Mask our interrupts */

	NpAddCQE(ep,&mp->shmemp->devcq,mp); /* Add CQE to device's queue */

	/* Wait for command to complete */

	while(!(rp->flags & REQDONE)) 
		sleep((caddr_t)rp,PZERO - 1);

	splx(pri);

	NpRemReq(rp);			/* Remove request from active list */

	NpFreeReq(mp->reqtab,rp);	/* Deallocate request structure */

	if(NpDebug & DEBENTRY)
		printf("NpCloseConn...\n");

}

/*
 * This function allows the protocol to be changed for a given connection.
 * It returns 0 for success, error code otherwise.
 */

NpProtChange(protocol,unit)
register unsign16 protocol;
register int unit;
{

	register struct npmaster *mp;

	/* Privileged users only for Maintenance Protocol */

	if((protocol == NPMAINT) && (u.u_uid != 0)) 
		return(EPERM);

	if(NpDebug & DEBMAINT)
		printf("NpProtChange = %x\n",protocol);

	if(protocol != NPMAINT) {

		/* Make sure the I-Board supports the protocol */

		mp = &npmasters[unit];

		if(!((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
			return(ENXIO);
	}

	return(0);
}

/*
 * This function allows for the changing of the unit for a given connection.
 */

struct npmaster *
NpBoardChange(protocol,unit)
register unsign16 protocol;
register int unit;			/* Unit number */
{
	register struct npmaster *mp;


	if(unit > NNP)
		return((struct npmaster *)0);

	if(protocol != NPMAINT) {

		/*
		 * Loop through the master structures finding a board which 
		 * supports the requested protocol.
		 */

		for(mp = npmasters; mp ; mp = mp->next) {

			if(mp->flags & BADBOARD)
				continue;

			if(((mp->shmemp->statblock.sb_dpm) & PROTOMASK(protocol)))
				return(mp);
		}
		return((struct npmaster *)0);
	}
	return(&npmasters[unit]);
}

/*
 * NpMapMem - maps the user's memory updating the fields in the npreq
 * structure and returning the mapped address in rp->buffaddr.
 */
NpMapMem(mp,rp,addr,count)
register struct npmaster *mp;
register struct npreq *rp;
caddr_t	addr;
int	count;
{

	if(NpDebug & DEBENTRY)
		printf("NpMapMem\n");
	if(NpDebug & DEBIO)
		printf("mp %x rp %x addr %x count %x\n",mp,rp,addr,count);

	rp->virtmem = addr;
	rp->bytecnt = count;

	rp->buf.b_un.b_addr = addr;
	rp->buf.b_flags = B_PHYS | B_BUSY;
	rp->buf.b_bcount = count;
	rp->buf.b_proc = rp->procp;
		
	rp->procp->p_flag |= SPHYSIO;
	if(NpDebug & DEBENTRY)
		printf("vslock\n");
	vslock(addr,count);
	if(NpDebug & DEBENTRY)
		printf("vslock...\n");

	rp->mapbase = ubasetup(mp->devp->ui_ubanum,&rp->buf,0);

	rp->bufaddr = (caddr_t)(rp->mapbase & UBADDRMASK);

	if(NpDebug & DEBENTRY)
		printf("NpMapMem...\n");
}

/*
 * Unmap the user's memory and free up mapping registers 
 */

NpUnMapMem(mp,rp)
struct npmaster *mp;
struct npreq *rp;
{
	if(NpDebug & DEBENTRY)
		printf("NpUnMapMem\n");

	ubarelse(mp->devp->ui_ubanum,&rp->mapbase);
	rp->mapbase = 0;
	vsunlock(rp->virtmem,rp->bytecnt,B_READ);
	rp->procp->p_flag &= ~SPHYSIO;

	if(NpDebug & DEBENTRY)
		printf("NpUnMapMem...\n");
}

npprobe(reg, ui)
caddr_t reg;
struct uba_device *ui;
{
register int br,cvec;
u_short csraddr;
int i;

#ifdef lint
	br = 0; cvec = br; br = cvec;
#endif

	if(NpDebug & DEBINIT)
		printf("In npprobe, regaddr is %x!\n",reg);

	cvec = (uba_hd[numuba].uh_lastiv -= 4); 

#ifdef OLDBSD
	/* Find unit number from npstd[] by matching the csr address */

	csraddr = (u_short)((int)reg & 0x0FFFF);

	for(i = 0; i < NNP; i++) {

		if(csraddr == npstd[i]) {
			npvectors[i] = cvec;
			break;
		}
	}
	if(i == NNP)
		printf("Couldn't find device in npstd[]!\n");

#else
	npvectors[ui->ui_unit] = cvec;
#endif
	br = 0x15;

	if(NpDebug & DEBINIT)
		printf("npprobe...\n");

	return(sizeof(struct NPREG));		/* CSR Registers */

}

npattach(ui)
register struct uba_device *ui;
{

	if(NpDebug & DEBINIT)
		printf("In npattach, ui is %x.\n",ui);

	npinit(ui->ui_unit);
	if (IxAttach)
		(*IxAttach)(ui);

	if(NpDebug & DEBINIT)
		printf("npattach...\n");
}


NpMem(mp, rp, uaddr)
struct npmaster *mp;
struct npreq *rp;
unsigned long uaddr;
{
	struct np_mem mem;
	register int error = 0;

	if(NpDebug & DEBENTRY)
		printf("npmem\n");

	if (error = copyin(uaddr, &mem, sizeof(mem)))
		return (error);

	if (mem.mem_type == NP_SET) {
		if (np_mapreq[mp->unit] != (struct npreq *)NPCLEAR)
			error = EBUSY;
		else {
			error = NpMapMem(mp, rp, mem.mem_addr, mem.mem_count);
			if (error != 0) {
				np_mapreq[mp->unit] = rp;
				mem.mem_addr = rp->bufaddr;
			}
		}
	} else if (mem.mem_type == NP_USET) {
		error = NpUnMapMem(mp, np_mapreq[mp->unit]);
		NpFreeReq(mp->reqtab, rp);
		NpFreeReq(mp->reqtab, np_mapreq[mp->unit]);
		np_mapreq[mp->unit] = (struct npreq *)NPCLEAR;
	} else 
		error = EIO;

	if (error != 0)
		error = copyout(&mem, uaddr, sizeof(mem));

	if(NpDebug & DEBENTRY)
		printf("npmem...\n");
	return (error);
}
#endif