xref: /csrg-svn/sys/vax/uba/uba.c (revision 2067)

/*	uba.c	4.6	01/06/81	*/

#include "../h/param.h"
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/uba.h"
#include "../h/buf.h"
#include "../h/dir.h"
#include "../h/user.h"
#include "../h/proc.h"
#include "../h/vm.h"
#include "../h/conf.h"
#include "../h/mtpr.h"

/*
 * Allocate as many contiguous UBA mapping registers
 * as are necessary to do transfer of bcnt bytes
 * to/from location baddr.  Wait for enough map registers.
 *
 * Bdpflg is non-zero if a "buffered data path" (BDP) is
 * to be used, else 0 -> use direct data path (DDP).  Return
 *
 *	Bits 0-8	Byte offset
 *	Bits 9-17	Start map reg. no.
 *	Bits 18-27	No. mapping reg's
 *	Bits 28-31	BDP no.
 */
ubasetup(bp, bdpflg)
struct buf *bp;
{
	register int temp, i;
	int npf, reg, bdp;
	unsigned v;
	register struct pte *pte, *io;
	struct proc *rp;
	int a, o, ubinfo;

	v = btop(bp->b_un.b_addr);
	o = (int)bp->b_un.b_addr & PGOFSET;
	npf = btoc(bp->b_bcount + o) + 1;
	a = spl6();
	while ((reg = malloc(ubamap, npf)) == 0) {
		panic("ran out of uba map");
		umrwant++;
		sleep((caddr_t)ubamap, PSWP);
	}
	reg--;
	bdp = 0;
	if (bdpflg)
		while ((bdp = malloc(bdpmap, 1)) == 0) {
			panic("ran out of bdp's");
			bdpwant++;
			sleep((caddr_t)bdpmap, PSWP);
		}
	splx(a);
	ubinfo = (bdp << 28) | (npf << 18) | (reg << 9) | o;
	io = &(((struct uba_regs *)UBA0)->uba_map[reg]);
	temp = (bdp << 21) | MRV;
	rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;
	if (bdp && (o & 01))
		temp |= BO;
	if (bp->b_flags & B_UAREA) {
		for (i = UPAGES - bp->b_bcount / NBPG; i < UPAGES; i++) {
			if (rp->p_addr[i].pg_pfnum == 0)
				panic("uba: zero upage");
			*(int *)io++ = rp->p_addr[i].pg_pfnum | temp;
		}
	} else if ((bp->b_flags & B_PHYS) == 0) {
		pte = &Sysmap[btop(((int)bp->b_un.b_addr)&0x7fffffff)];
		while (--npf != 0)
			*(int *)io++ = pte++->pg_pfnum | temp;
	} else {
		if (bp->b_flags & B_PAGET)
			pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)];
		else
			pte = vtopte(rp, v);
		while (--npf != 0) {
			if (pte->pg_pfnum == 0)
				panic("uba zero uentry");
			*(int *)io++ = pte++->pg_pfnum | temp;
		}
	}
	*(int *)io++ = 0;
	return (ubinfo);
}

/*
 * Non buffer unibus interface... set up a buffer and call ubasetup.
 */
uballoc(addr, bcnt, bdpflg)
	caddr_t addr;
	unsigned short bcnt;
{
	struct buf ubabuf;

	ubabuf.b_un.b_addr = addr;
	ubabuf.b_flags = B_BUSY;
	ubabuf.b_bcount = bcnt;
	/* that's all the fields ubasetup() needs */
	return (ubasetup(&ubabuf, bdpflg));
}

/*
 * Old ubafree(info) is now ubarelse(&info) to avoid races.
 */
ubarelse(amr)
	int *amr;
{
	register int bdp, reg, npf, a;
	int mr;

	a = spl6();
	mr = *amr;
	if (mr == 0) {
		splx(a);
		return;
	}
	*amr = 0;
	bdp = (mr >> 28) & 0x0f;
	if (bdp) {
		((struct uba_regs *)UBA0)->uba_dpr[bdp] |= BNE;	/* purge */
		mfree(bdpmap, 1, bdp);
		if (bdpwant) {
			bdpwant = 0;
			wakeup((caddr_t)bdpmap);
		}
	}
	npf = (mr >> 18) & 0x3ff;
	reg = ((mr >> 9) & 0x1ff) + 1;
	mfree(ubamap, npf, reg);
	if (umrwant) {
		umrwant = 0;
		wakeup((caddr_t)ubamap);
	}
	splx(a);
}

ubainit()
{

	mfree(ubamap, 496, 1);
	mfree(bdpmap, NUBABDP, 1);
}

#define	DELAY(N)	{ register int d; d = N; while (--d > 0); }

ubareset()
{
	struct uba_regs *up = (struct uba_regs *)UBA0;
	register struct cdevsw *cdp;
	int s;

	s = spl6();
#if VAX==780
	printf("UBA RESET:");
	up->uba_cr = ADINIT;
	up->uba_cr = IFS|BRIE|USEFIE|SUEFIE;
	while ((up->uba_cnfgr & UBIC) == 0)
		;
#endif
#if VAX==750
	printf("UNIBUS INIT:");
	mtpr(IUR, 1);
	DELAY(100000);
#endif
	for (cdp = cdevsw; cdp->d_open; cdp++)
		(*cdp->d_reset)();
	printf("\n");
	splx(s);
}