new mapdev/()/mapiodev() calling convention uses "struct rom_reg *" to supply

base plus an offset
new dvma routines

25 files changed, 466 insertions, 412 deletions

diff --git a/sys/arch/sparc/dev/amd7930.c b/sys/arch/sparc/dev/amd7930.c
index 0702e095162..c7a133e3eaf 100644
--- a/sys/arch/sparc/dev/amd7930.c
+++ b/sys/arch/sparc/dev/amd7930.c
@@ -301,9 +301,8 @@ amd9730attach(parent, self, args)
 	}
 	pri = ra->ra_intr[0].int_pri;
 	printf(" pri %d, softpri %d\n", pri, PIL_AUSOFT);
-	amd = (volatile struct amd7930 *)(ra->ra_vaddr ?
-		ra->ra_vaddr : mapiodev(ra->ra_paddr, sizeof (*amd),
-					ca->ca_bustype));
+	amd = (volatile struct amd7930 *)(ra->ra_vaddr ? ra->ra_vaddr :
+	    mapiodev(ra->ra_reg, 0, sizeof (*amd), ca->ca_bustype));
 
 	sc->sc_map.mr_mmr1 = AMD_MMR1_GX | AMD_MMR1_GER |
 			     AMD_MMR1_GR | AMD_MMR1_STG;
diff --git a/sys/arch/sparc/dev/bwtwo.c b/sys/arch/sparc/dev/bwtwo.c
index 7dda6e1b8bf..5da9f43258c 100644
--- a/sys/arch/sparc/dev/bwtwo.c
+++ b/sys/arch/sparc/dev/bwtwo.c
@@ -109,7 +109,7 @@ struct bwtwo_softc {
 	struct	sbusdev sc_sd;		/* sbus device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
 	volatile struct bwtworeg *sc_reg;/* control registers */
-	caddr_t	sc_phys;		/* display RAM (phys addr) */
+	struct rom_reg sc_phys;		/* display RAM (phys addr) */
 	int	sc_bustype;
 };
 
@@ -173,7 +173,6 @@ bwtwoattach(parent, self, args)
 	register struct bwtwo_softc *sc = (struct bwtwo_softc *)self;
 	register struct confargs *ca = args;
 	register int node = ca->ca_ra.ra_node, ramsize;
-	register struct bwtwo_all *p;
 	int isconsole;
 	char *nam;
 
@@ -195,18 +194,27 @@ bwtwoattach(parent, self, args)
 		nam = "bwtwo";
 		break;  
 #endif
+#endif
 	case BUS_OBIO:
+#if defined(SUN4M)
+		if (cputyp == CPU_SUN4M) {   /* 4m has framebuffer on obio */
+			nam = getpropstring(node, "model");
+			break;
+		}
+#endif
+#if defined(SUN4)
 		node = 0;
 		nam = "bwtwo";
 		break;
 #endif
-
 	case BUS_SBUS:
 #if defined(SUN4C) || defined(SUN4M)
 		nam = getpropstring(node, "model");
-#endif
 		break;
+#endif
 	}
+	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
 
 	sc->sc_fb.fb_type.fb_depth = 1;
 	fb_setsize(&sc->sc_fb, sc->sc_fb.fb_type.fb_depth,
@@ -241,15 +249,13 @@ bwtwoattach(parent, self, args)
 	 * registers ourselves.  We only need the video RAM if we are
 	 * going to print characters via rconsole.
 	 */
-	p = (struct bwtwo_all *)ca->ca_ra.ra_paddr;
 	if ((sc->sc_fb.fb_pixels = ca->ca_ra.ra_vaddr) == NULL && isconsole) {
 		/* this probably cannot happen (on sun4c), but what the heck */
-		sc->sc_fb.fb_pixels = mapiodev(p->ba_ram, ramsize,
-		    ca->ca_bustype);
+		sc->sc_fb.fb_pixels = mapiodev(ca->ca_ra.ra_reg, BWREG_MEM,
+		    ramsize, ca->ca_bustype);
 	}
-	sc->sc_reg = (volatile struct bwtworeg *)mapiodev((caddr_t)&p->ba_reg,
-	    sizeof(p->ba_reg), ca->ca_bustype);
-	sc->sc_phys = p->ba_ram;
+	sc->sc_reg = (volatile struct bwtworeg *)mapiodev(ca->ca_ra.ra_reg,
+	    BWREG_REG, sizeof(struct bwtworeg), ca->ca_bustype);
 
 	/* Insure video is enabled */
 	bwtwoenable(sc, 1);
@@ -352,7 +358,7 @@ bwtwommap(dev, off, prot)
 	 * I turned on PMAP_NC here to disable the cache as I was
 	 * getting horribly broken behaviour with it on.
 	 */
-	return ((int)sc->sc_phys + off + PMAP_OBIO + PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, BWREG_MEM+off, sc->sc_bustype) | PMAP_NC);
 }
 
 
diff --git a/sys/arch/sparc/dev/cgeight.c b/sys/arch/sparc/dev/cgeight.c
index e558e907d81..546a6992797 100644
--- a/sys/arch/sparc/dev/cgeight.c
+++ b/sys/arch/sparc/dev/cgeight.c
@@ -78,7 +78,8 @@ struct cgeight_softc {
 	struct	device sc_dev;		/* base device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
 	volatile struct bt_regs *sc_bt;	/* Brooktree registers */
-	caddr_t	sc_phys;		/* display RAM (phys addr) */
+	struct rom_reg	sc_phys;	/* display RAM (phys addr) */
+	int	sc_bustype;		/* type of bus we live on */
 	int	sc_blanked;		/* true if blanked */
 	union	bt_cmap sc_cmap;	/* Brooktree color map */
 };
@@ -172,19 +173,19 @@ cgeightattach(parent, self, args)
 	 * Ridiculous!
 	 */
 	isconsole = node == fbnode && fbconstty != NULL;
-	p = (struct cgeight_all *)ca->ca_ra.ra_paddr;
 	if (ca->ca_ra.ra_vaddr == NULL) {
 		/* this probably cannot happen, but what the heck */
-		ca->ca_ra.ra_vaddr = mapiodev(p->ba_overlay, ramsize,
-		    ca->ca_bustype);
+		ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0,
+		    ramsize, ca->ca_bustype);
 	}
 	sc->sc_fb.fb_pixels = (char *)((int)ca->ca_ra.ra_vaddr +
 	    CG8REG_COLOUR - CG8REG_OVERLAY);
 
-	sc->sc_bt = bt = (volatile struct bt_regs *)
-	    mapiodev((caddr_t)&p->ba_btreg, sizeof(p->ba_btreg),
-	    ca->ca_bustype);
-	sc->sc_phys = p->ba_overlay;
+#define	O(memb) ((u_int)(&((struct cgeight_all *)0)->memb))
+	sc->sc_bt = bt = (volatile struct bt_regs *)mapiodev(ca->ca_ra.ra_reg,
+	    O(ba_btreg), sizeof(struct bt_regs), ca->ca_bustype);
+	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
 
 	/* tell the enable plane to look at the mono image */
 	memset(ca->ca_ra.ra_vaddr, 0xff,
@@ -435,5 +436,5 @@ cgeightmmap(dev, off, prot)
 	 * I turned on PMAP_NC here to disable the cache as I was
 	 * getting horribly broken behaviour with it on.
 	 */
-	return ((u_int)sc->sc_phys + poff + PMAP_OBIO + PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, off, sc->sc_bustype) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/cgfour.c b/sys/arch/sparc/dev/cgfour.c
index 74f5b470733..96b604662b3 100644
--- a/sys/arch/sparc/dev/cgfour.c
+++ b/sys/arch/sparc/dev/cgfour.c
@@ -82,7 +82,8 @@ struct cgfour_softc {
 	struct	device sc_dev;		/* base device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
 	volatile struct bt_regs *sc_bt;	/* Brooktree registers */
-	caddr_t	sc_phys;		/* display RAM (phys addr) */
+	struct rom_reg	sc_phys;	/* display RAM (phys addr) */
+	int	sc_bustype;		/* type of bus we live on */
 	int	sc_blanked;		/* true if blanked */
 	union	bt_cmap sc_cmap;	/* Brooktree color map */
 };
@@ -142,7 +143,6 @@ cgfourattach(parent, self, args)
 	register struct confargs *ca = args;
 	register int node = 0, ramsize, i;
 	register volatile struct bt_regs *bt;
-	register struct cgfour_all *p;
 	int isconsole;
 
 	sc->sc_fb.fb_driver = &cgfourfbdriver;
@@ -172,19 +172,19 @@ cgfourattach(parent, self, args)
 	 * the mmap code down below doesn't use it all. Ridiculous!
 	 */
 	isconsole = node == fbnode && fbconstty != NULL;
-	p = (struct cgfour_all *)ca->ca_ra.ra_paddr;
 	if (ca->ca_ra.ra_vaddr == NULL) {
 		/* this probably cannot happen, but what the heck */
-		ca->ca_ra.ra_vaddr = mapiodev(p->ba_overlay, ramsize,
-		    ca->ca_bustype);
+		ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0,
+		    ramsize, ca->ca_bustype);
 	}
 	sc->sc_fb.fb_pixels = (char *)((int)ca->ca_ra.ra_vaddr +
 	    CG4REG_COLOUR - CG4REG_OVERLAY);
 
-	sc->sc_bt = bt = (volatile struct bt_regs *)
-	    mapiodev((caddr_t)&p->ba_btreg, sizeof(p->ba_btreg),
-	    ca->ca_bustype);
-	sc->sc_phys = p->ba_overlay;
+#define	O(memb) ((u_int)(&((struct cgfour_all *)0)->memb))
+	sc->sc_bt = bt = (volatile struct bt_regs *)mapiodev(ca->ca_ra.ra_reg,
+	    O(ba_btreg), sizeof(struct bt_regs), ca->ca_bustype);
+	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
 
 	/* grab initial (current) color map */
 	bt->bt_addr = 0;
@@ -406,5 +406,5 @@ cgfourmmap(dev, off, prot)
 		poff = off + (CG4REG_COLOUR - CG4REG_OVERLAY) - START_COLOUR;
 	else
 		return (-1);
-	return ((u_int)sc->sc_phys + poff + PMAP_OBIO + PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, off, sc->sc_bustype) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/cgsix.c b/sys/arch/sparc/dev/cgsix.c
index 46870946ad5..9dab9af06b0 100644
--- a/sys/arch/sparc/dev/cgsix.c
+++ b/sys/arch/sparc/dev/cgsix.c
@@ -97,7 +97,8 @@ struct cgsix_softc {
 	struct	device sc_dev;		/* base device */
 	struct	sbusdev sc_sd;		/* sbus device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
-	volatile struct cg6_layout *sc_physadr;	/* phys addr of h/w */
+	struct	rom_reg sc_physadr;	/* phys addr of h/w */
+	int	sc_bustype;		/* type of bus we live on */
 	volatile struct bt_regs *sc_bt;		/* Brooktree registers */
 	volatile int *sc_fhc;			/* FHC register */
 	volatile struct cg6_thc *sc_thc;	/* THC registers */
@@ -180,7 +181,7 @@ cgsixattach(parent, self, args)
 {
 	register struct cgsix_softc *sc = (struct cgsix_softc *)self;
 	register struct confargs *ca = args;
-	register int node, ramsize, i, isconsole;
+	register int node = ca->ca_ra.ra_node, ramsize, i, isconsole;
 	register volatile struct bt_regs *bt;
 	register volatile struct cg6_layout *p;
 	char *nam;
@@ -213,8 +214,15 @@ cgsixattach(parent, self, args)
 		nam = "cgsix";
 		break;
 #endif /* SUN4 */
+	case BUS_OBIO:
+#if defined(SUN4M)
+		if (cputyp == CPU_SUN4M) {   /* 4m has framebuffer on obio */
+			nam = getpropstring(node, "model");
+			break;
+		}
+#endif
+		break;
 	case BUS_SBUS:
-		node = ca->ca_ra.ra_node;
 		nam = getpropstring(node, "model");
 		break;
 	}
@@ -228,26 +236,24 @@ cgsixattach(parent, self, args)
 	sc->sc_fb.fb_type.fb_size = ramsize;
 	printf(": %s, %d x %d", nam,
 	    sc->sc_fb.fb_type.fb_width, sc->sc_fb.fb_type.fb_height);
+	isconsole = node == fbnode && fbconstty != NULL;
 
 	/*
 	 * Dunno what the PROM has mapped, though obviously it must have
 	 * the video RAM mapped.  Just map what we care about for ourselves
 	 * (the FHC, THC, and Brooktree registers).
 	 */
-	isconsole = node == fbnode && fbconstty != NULL;
-	sc->sc_physadr = p = (struct cg6_layout *)ca->ca_ra.ra_paddr;
-	sc->sc_bt = bt = (volatile struct bt_regs *)
-	    mapiodev((caddr_t)&p->cg6_bt_un.un_btregs, sizeof *sc->sc_bt,
-	    ca->ca_bustype);
-	sc->sc_fhc = (volatile int *)
-	    mapiodev((caddr_t)&p->cg6_fhc_un.un_fhc, sizeof *sc->sc_fhc,
-	    ca->ca_bustype);
-	sc->sc_thc = (volatile struct cg6_thc *)
-	    mapiodev((caddr_t)&p->cg6_thc_un.un_thc, sizeof *sc->sc_thc,
-	    ca->ca_bustype);
-	sc->sc_tec = (volatile struct cg6_tec_xxx *)
-	    mapiodev((caddr_t)&p->cg6_tec_un.un_tec, sizeof *sc->sc_tec,
-	    ca->ca_bustype);
+#define	O(memb) ((u_int)(&((struct cg6_layout *)0)->memb))
+	sc->sc_physadr = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
+	sc->sc_bt = bt = (volatile struct bt_regs *)mapiodev(ca->ca_ra.ra_reg,
+	    O(cg6_bt_un.un_btregs), sizeof *sc->sc_bt, ca->ca_bustype);
+	sc->sc_fhc = (volatile int *)mapiodev(ca->ca_ra.ra_reg,
+	    O(cg6_fhc_un.un_fhc), sizeof *sc->sc_fhc, ca->ca_bustype);
+	sc->sc_thc = (volatile struct cg6_thc *)mapiodev(ca->ca_ra.ra_reg,
+	    O(cg6_thc_un.un_thc), sizeof *sc->sc_thc, ca->ca_bustype);
+	sc->sc_tec = (volatile struct cg6_tec_xxx *)mapiodev(ca->ca_ra.ra_reg,
+	    O(cg6_tec_un.un_tec), sizeof *sc->sc_tec, ca->ca_bustype);
 
 	sc->sc_fhcrev = (*sc->sc_fhc >> FHC_REV_SHIFT) &
 	    (FHC_REV_MASK >> FHC_REV_SHIFT);
@@ -266,6 +272,11 @@ cgsixattach(parent, self, args)
 
 	if (isconsole) {
 		printf(" (console)\n");
+#ifdef RASTERCONSOLE
+		sc->sc_fb.fb_pixels = (caddr_t)mapiodev(ca->ca_ra.ra_reg,
+		    O(cg6_ram[0]), ramsize, ca->ca_bustype);
+		fbrcons_init(&sc->sc_fb);
+#endif
 	} else
 		printf("\n");
 #if defined(SUN4C) || defined(SUN4M)
@@ -686,8 +697,8 @@ cgsixmmap(dev, off, prot)
 		u = off - mo->mo_uaddr;
 		sz = mo->mo_size ? mo->mo_size : sc->sc_fb.fb_type.fb_size;
 		if (u < sz)
-			return ((int)sc->sc_physadr + u + mo->mo_physoff +
-			    PMAP_OBIO + PMAP_NC);
+			return (REG2PHYS(&sc->sc_physadr, u + mo->mo_physoff,
+			    sc->sc_bustype) | PMAP_NC);
 	}
 #ifdef DEBUG
 	{
diff --git a/sys/arch/sparc/dev/cgthree.c b/sys/arch/sparc/dev/cgthree.c
index ae5949225b9..06c62b15e91 100644
--- a/sys/arch/sparc/dev/cgthree.c
+++ b/sys/arch/sparc/dev/cgthree.c
@@ -78,7 +78,8 @@ struct cgthree_softc {
 	struct	sbusdev sc_sd;		/* sbus device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
 	volatile struct bt_regs *sc_bt;	/* Brooktree registers */
-	caddr_t	sc_phys;		/* display RAM (phys addr) */
+	struct rom_reg sc_phys;		/* display RAM (phys addr) */
+	int	sc_bustype;		/* type of bus we live on */
 	int	sc_blanked;		/* true if blanked */
 	union	bt_cmap sc_cmap;	/* Brooktree color map */
 };
@@ -137,7 +138,7 @@ cgthreeattach(parent, self, args)
 {
 	register struct cgthree_softc *sc = (struct cgthree_softc *)self;
 	register struct confargs *ca = args;
-	register int node, ramsize, i;
+	register int node = ca->ca_ra.ra_node, ramsize, i;
 	register volatile struct bt_regs *bt;
 	register struct cgthree_all *p;
 	int isconsole;
@@ -151,12 +152,18 @@ cgthreeattach(parent, self, args)
 	 */
 	sc->sc_fb.fb_type.fb_type = FBTYPE_SUN3COLOR;
 	switch (ca->ca_bustype) {
+#if defined(SUN4M)
+	case BUS_OBIO:
+		if (cputyp == CPU_SUN4M)	/* 4m has framebuffer on obio */
+			nam = getpropstring(node, "model");
+		break;
+#endif
+
 	case BUS_VME32:
 		node = 0;
 		nam = "cgthree";
 		break;
 	case BUS_SBUS:
-		node = ca->ca_ra.ra_node;
 		nam = getpropstring(node, "model");
 		break;
 	}
@@ -182,11 +189,14 @@ cgthreeattach(parent, self, args)
 	p = (struct cgthree_all *)ca->ca_ra.ra_paddr;
 	if ((sc->sc_fb.fb_pixels = ca->ca_ra.ra_vaddr) == NULL && isconsole) {
 		/* this probably cannot happen, but what the heck */
-		sc->sc_fb.fb_pixels = mapiodev(p->ba_ram, ramsize, ca->ca_bustype);
+		sc->sc_fb.fb_pixels = mapiodev(ca->ca_ra.ra_reg, CG3REG_MEM,
+		    ramsize, ca->ca_bustype);
 	}
-	sc->sc_bt = bt = (volatile struct bt_regs *)
-	    mapiodev((caddr_t)&p->ba_btreg, sizeof(p->ba_btreg), ca->ca_bustype);
-	sc->sc_phys = p->ba_ram;
+	sc->sc_bt = bt = (volatile struct bt_regs *)mapiodev(ca->ca_ra.ra_reg,
+	    CG3REG_REG, sizeof(struct bt_regs), ca->ca_bustype);
+
+	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
 
 	/* grab initial (current) color map */
 	bt->bt_addr = 0;
@@ -395,5 +405,5 @@ cgthreemmap(dev, off, prot)
 	 * I turned on PMAP_NC here to disable the cache as I was
 	 * getting horribly broken behaviour with it on.
 	 */
-	return ((int)sc->sc_phys + off + PMAP_OBIO + PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, CG3REG_MEM+off, sc->sc_bustype) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/cgtwo.c b/sys/arch/sparc/dev/cgtwo.c
index e11f2608341..e8c2f3e30bc 100644
--- a/sys/arch/sparc/dev/cgtwo.c
+++ b/sys/arch/sparc/dev/cgtwo.c
@@ -76,7 +76,8 @@
 struct cgtwo_softc {
 	struct	device sc_dev;		/* base device */
 	struct	fbdevice sc_fb;		/* frame buffer device */
-	caddr_t	sc_phys;		/* display RAM (phys addr) */
+	struct rom_reg	sc_phys;	/* display RAM (phys addr) */
+	int	sc_bustype;		/* type of bus we live on */
 	volatile struct cg2statusreg *sc_reg;	/* CG2 control registers */
 	volatile u_short *sc_cmap;
 #define sc_redmap(sc)	((sc)->sc_cmap)
@@ -185,25 +186,25 @@ cgtwoattach(parent, self, args)
 			isconsole = 0;
 	}
 #endif
-	sc->sc_phys = (caddr_t)ca->ca_ra.ra_paddr;
+	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	sc->sc_bustype = ca->ca_bustype;
+
 	if ((sc->sc_fb.fb_pixels = ca->ca_ra.ra_vaddr) == NULL && isconsole) {
 		/* this probably cannot happen, but what the heck */
-		sc->sc_fb.fb_pixels = mapiodev(sc->sc_phys + CG2_PIXMAP_OFF,
+		sc->sc_fb.fb_pixels = mapiodev(ca->ca_ra.ra_reg, CG2_PIXMAP_OFF,
 		    CG2_PIXMAP_SIZE, ca->ca_bustype);
 	}
 #ifndef offsetof
 #define	offsetof(type, member)  ((size_t)(&((type *)0)->member))
 #endif
 
-	sc->sc_reg = (volatile struct cg2statusreg *)
-	    mapiodev((caddr_t)sc->sc_phys +
-		CG2_ROPMEM_OFF + offsetof(struct cg2fb, status.reg),
-		sizeof(struct cg2statusreg), ca->ca_bustype);
+	sc->sc_reg = (volatile struct cg2statusreg *)mapiodev(ca->ca_ra.ra_reg,
+	    CG2_ROPMEM_OFF + offsetof(struct cg2fb, status.reg),
+	    sizeof(struct cg2statusreg), ca->ca_bustype);
 
-	sc->sc_cmap = (volatile u_short *)
-	    mapiodev((caddr_t)sc->sc_phys +
-		CG2_ROPMEM_OFF + offsetof(struct cg2fb, redmap[0]),
-		3 * CG2_CMSIZE, ca->ca_bustype);
+	sc->sc_cmap = (volatile u_short *)mapiodev(ca->ca_ra.ra_reg,
+	    CG2_ROPMEM_OFF + offsetof(struct cg2fb, redmap[0]),
+	    3 * CG2_CMSIZE, ca->ca_bustype);
 
 	if (isconsole) {
 		printf(" (console)\n");
@@ -404,5 +405,5 @@ cgtwommap(dev, off, prot)
 	if ((unsigned)off >= sc->sc_fb.fb_type.fb_size)
 		return (-1);
 
-	return ((int)sc->sc_phys + off + PMAP_VME32 + PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, off, PMAP_VME32) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/dma.c b/sys/arch/sparc/dev/dma.c
index 8b80019450a..5a96cd4bf84 100644
--- a/sys/arch/sparc/dev/dma.c
+++ b/sys/arch/sparc/dev/dma.c
@@ -140,7 +140,7 @@ dmaattach(parent, self, aux)
 
 	/* XXX modifying ra_vaddr is bad! */
 	if (ca->ca_ra.ra_vaddr == NULL)
-		ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_paddr,
+		ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0,
 		    ca->ca_ra.ra_len, ca->ca_bustype);
 	if ((u_long)ca->ca_ra.ra_paddr & PGOFSET)
 		(u_long)ca->ca_ra.ra_vaddr |= ((u_long)ca->ca_ra.ra_paddr & PGOFSET);
diff --git a/sys/arch/sparc/dev/esp.c b/sys/arch/sparc/dev/esp.c
index d0ca940b08a..7941b614917 100644
--- a/sys/arch/sparc/dev/esp.c
+++ b/sys/arch/sparc/dev/esp.c
@@ -167,7 +167,7 @@ espattach(parent, self, aux)
 		sc->sc_regs = (struct espregs *) ca->ca_ra.ra_vaddr;
 	else {
 		sc->sc_regs = (struct espregs *)
-		    mapiodev(ca->ca_ra.ra_paddr, ca->ca_ra.ra_len,
+		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len,
 		    ca->ca_bustype);
 	}
 	espr = sc->sc_regs;
diff --git a/sys/arch/sparc/dev/fb.c b/sys/arch/sparc/dev/fb.c
index 67281d399c9..a990eae83a9 100644
--- a/sys/arch/sparc/dev/fb.c
+++ b/sys/arch/sparc/dev/fb.c
@@ -144,6 +144,17 @@ fb_setsize(fb, depth, def_width, def_height, node, bustype)
 	case BUS_VME16:
 	case BUS_VME32:
 	case BUS_OBIO:
+#if defined(SUN4M)
+		if (cputyp == CPU_SUN4M) {   /* 4m has framebuffer on obio */
+		        fb->fb_type.fb_width = getpropint(node, "width",
+			    def_width);
+			fb->fb_type.fb_height = getpropint(node, "height",
+			    def_height);
+			fb->fb_linebytes = getpropint(node, "linebytes",
+			    (fb->fb_type.fb_width * depth) / 8);
+			break;
+		}
+#endif
 		/* Set up some defaults. */
 		fb->fb_type.fb_width = def_width;
 		fb->fb_type.fb_height = def_height;
diff --git a/sys/arch/sparc/dev/fd.c b/sys/arch/sparc/dev/fd.c
index ed66fa9c3a5..75575b457ef 100644
--- a/sys/arch/sparc/dev/fd.c
+++ b/sys/arch/sparc/dev/fd.c
@@ -93,7 +93,7 @@ enum fdc_state {
 
 /* software state, per controller */
 struct fdc_softc {
-	struct dkdevice sc_dk;		/* boilerplate */
+	struct device	sc_dev;		/* boilerplate */
 	struct intrhand sc_sih;
 	struct intrhand sc_hih;
 	caddr_t		sc_reg;
@@ -320,7 +320,7 @@ fdcattach(parent, self, aux)
 	if (ca->ca_ra.ra_vaddr)
 		fdc->sc_reg = (caddr_t)ca->ca_ra.ra_vaddr;
 	else
-		fdc->sc_reg = (caddr_t)mapiodev(ca->ca_ra.ra_paddr,
+		fdc->sc_reg = (caddr_t)mapiodev(ca->ca_ra.ra_reg, 0,
 						ca->ca_ra.ra_len,
 						ca->ca_bustype);
 
@@ -389,7 +389,7 @@ fdcattach(parent, self, aux)
 			printf(" CFGLOCK: unexpected response");
 	}
 
-	evcnt_attach(&fdc->sc_dk.dk_dev, "intr", &fdc->sc_intrcnt);
+	evcnt_attach(&fdc->sc_dev, "intr", &fdc->sc_intrcnt);
 
 	printf(" pri %d, softpri %d: chip 8207%c\n", pri, PIL_FDSOFT, code);
 
@@ -431,11 +431,11 @@ fdmatch(parent, match, aux)
 	if (fdc->sc_flags & FDC_82077) {
 		/* select drive and turn on motor */
 		*fdc->sc_reg_dor = drive | FDO_FRST | FDO_MOEN(drive);
+		/* wait for motor to spin up */
+		delay(250000);
 	} else {
 		auxregbisc(AUXIO_FDS, 0);
 	}
-	/* wait for motor to spin up */
-	delay(250000);
 
 	fdc->sc_nstat = 0;
 	out_fdc(fdc, NE7CMD_RECAL);
diff --git a/sys/arch/sparc/dev/if_ie.c b/sys/arch/sparc/dev/if_ie.c
index d7c2c803f6b..7122605734f 100644
--- a/sys/arch/sparc/dev/if_ie.c
+++ b/sys/arch/sparc/dev/if_ie.c
@@ -507,7 +507,7 @@ ieattach(parent, self, aux)
 		sc->memcopy = bcopy;
 		sc->memzero = bzero;
 		sc->sc_msize = 65536; /* XXX */
-		sc->sc_reg = mapiodev(ca->ca_ra.ra_paddr, sizeof(struct ieob),
+		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct ieob),
 		    ca->ca_bustype);
 		ieo = (volatile struct ieob *) sc->sc_reg;
 
@@ -571,14 +571,15 @@ ieattach(parent, self, aux)
 		sc->memcopy = wcopy;
 		sc->memzero = wzero;
 		sc->sc_msize = 65536;	/* XXX */
-		sc->sc_reg = mapiodev(ca->ca_ra.ra_paddr, sizeof(struct ievme),
+		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct ievme),
 		    ca->ca_bustype);
 		iev = (volatile struct ievme *) sc->sc_reg;
 		/* top 12 bits */
 		rampaddr = (u_long)ca->ca_ra.ra_paddr & 0xfff00000;
 		/* 4 more */
 		rampaddr = rampaddr | ((iev->status & IEVME_HADDR) << 16);
-		sc->sc_maddr = mapiodev((caddr_t)rampaddr, sc->sc_msize,
+		rampaddr -= (u_long)ca->ca_ra.ra_paddr;
+		sc->sc_maddr = mapiodev(ca->ca_ra.ra_reg, rampaddr, sc->sc_msize,
 		    ca->ca_bustype);
 		sc->sc_iobase = sc->sc_maddr;
 		iev->pectrl = iev->pectrl | IEVME_PARACK; /* clear to start */
diff --git a/sys/arch/sparc/dev/obio.c b/sys/arch/sparc/dev/obio.c
index f23157d2a89..858c729f7cc 100644
--- a/sys/arch/sparc/dev/obio.c
+++ b/sys/arch/sparc/dev/obio.c
@@ -346,6 +346,7 @@ bus_map(pa, len, bustype)
 	int len;
 	int bustype;
 {
+	struct rom_reg rr;
 	u_long	pf = (u_long)pa >> PGSHIFT;
 	u_long	va, pte;
 	int pgtype;
@@ -370,7 +371,8 @@ bus_map(pa, len, bustype)
 				return ((void *)va);
 		}
 	}
-	return mapiodev(pa, len, bustype);
+	rr.rr_paddr = pa;
+	return mapiodev(&rr, 0, len, bustype);
 }
 
 void *
diff --git a/sys/arch/sparc/dev/pfour.c b/sys/arch/sparc/dev/pfour.c
index 4b7582f4aa9..3ed22d7df5c 100644
--- a/sys/arch/sparc/dev/pfour.c
+++ b/sys/arch/sparc/dev/pfour.c
@@ -1,4 +1,4 @@
-/*	$Id: pfour.c,v 1.4 1995/11/09 21:26:13 deraadt Exp $ */
+/*	$Id: pfour.c,v 1.5 1995/12/15 13:56:26 deraadt Exp $ */
 
 /*
  * Copyright (c) 1995 Theo de Raadt
@@ -92,7 +92,7 @@ pfourattach(parent, self, args)
 		return;
 	}
 
-	sc->sc_vaddr = (u_long *)mapiodev((caddr_t)(ca->ca_ra.ra_paddr + PFOUR_REG),
+	sc->sc_vaddr = (u_long *)mapiodev(ca->ca_ra.ra_reg, PFOUR_REG,
 	    NBPG, ca->ca_bustype);
 	if (sc->sc_vaddr == NULL) {
 		printf("\n");
diff --git a/sys/arch/sparc/dev/si.c b/sys/arch/sparc/dev/si.c
index 3696a339d90..a368f958aa1 100644
--- a/sys/arch/sparc/dev/si.c
+++ b/sys/arch/sparc/dev/si.c
@@ -182,7 +182,7 @@ si_attach(parent, self, aux)
 	struct bootpath *bp;
 
 	/* Map the controller registers. */
-	regs = (struct si_regs *)mapiodev(ra->ra_paddr,
+	regs = (struct si_regs *)mapiodev(ra->ra_reg, 0,
 	    sizeof(struct si_regs), ca->ca_bustype);
 
 	/* Establish the interrupt. */
diff --git a/sys/arch/sparc/dev/xd.c b/sys/arch/sparc/dev/xd.c
index 6795aced19f..c4b9d55880e 100644
--- a/sys/arch/sparc/dev/xd.c
+++ b/sys/arch/sparc/dev/xd.c
@@ -1,4 +1,4 @@
-/* $NetBSD: xd.c,v 1.9 1995/09/25 20:12:44 chuck Exp $ */
+/* $NetBSD: xd.c,v 1.10 1995/12/11 12:40:20 pk Exp $ */
 
 /*
  *
@@ -36,7 +36,7 @@
  * x d . c   x y l o g i c s   7 5 3 / 7 0 5 3   v m e / s m d   d r i v e r
  *
  * author: Chuck Cranor <chuck@ccrc.wustl.edu>
- * id: $Id: xd.c,v 1.1 1995/10/18 08:51:40 deraadt Exp $
+ * id: $Id: xd.c,v 1.2 1995/12/15 13:56:27 deraadt Exp $
  * started: 27-Feb-95
  * references: [1] Xylogics Model 753 User's Manual
  *                 part number: 166-753-001, Revision B, May 21, 1988.
@@ -199,11 +199,6 @@
  * "xdc_*" functions are internal, all others are external interfaces
  */
 
-/* external (XXX should migrate to std include file?) */
-extern caddr_t dvma_malloc __P((size_t));
-extern void dvma_free __P((caddr_t, size_t));
-extern caddr_t dvma_mapin __P((struct vm_map *, vm_offset_t, int, int));
-extern void dvma_mapout __P((vm_offset_t, vm_offset_t, int));
 extern int pil_to_vme[];	/* from obio.c */
 
 /* internals */
@@ -262,7 +257,8 @@ struct cfdriver xdcd = {
 
 struct xdc_attach_args {	/* this is the "aux" args to xdattach */
 	int	driveno;	/* unit number */
-	char	*dvmabuf;	/* scratch buffer for reading disk label */
+	char	*buf;		/* scratch buffer for reading disk label */
+	char	*dvmabuf;	/* DVMA address of above */
 	int	fullmode;	/* submit mode */
 	int	booting;	/* are we booting or not? */
 };
@@ -396,7 +392,7 @@ xdcattach(parent, self, aux)
 	/* get addressing and intr level stuff from autoconfig and load it
 	 * into our xdc_softc. */
 
-	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_paddr,
+	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0,
 	    ca->ca_ra.ra_len, ca->ca_bustype);
 	if ((u_long) ca->ca_ra.ra_paddr & PGOFSET)
 		(u_long) ca->ca_ra.ra_vaddr |=
@@ -417,10 +413,13 @@ xdcattach(parent, self, aux)
 	 * iorq's up front.   thus, we avoid linked lists and the costs
 	 * associated with them in exchange for wasting a little memory. */
 
-	xdc->iopbase = (struct xd_iopb *)
-	    dvma_malloc(XDC_MAXIOPB * sizeof(struct xd_iopb));	/* KVA */
+	xdc->dvmaiopb = (struct xd_iopb *)
+	    dvma_malloc(XDC_MAXIOPB * sizeof(struct xd_iopb), &xdc->iopbase,
+			M_NOWAIT);
 	bzero(xdc->iopbase, XDC_MAXIOPB * sizeof(struct xd_iopb));
+	/* Setup device view of DVMA address */
 	xdc->dvmaiopb = (struct xd_iopb *) ((u_long) xdc->iopbase - DVMA_BASE);
+
 	xdc->reqs = (struct xd_iorq *)
 	    malloc(XDC_MAXIOPB * sizeof(struct xd_iorq), M_DEVBUF, M_NOWAIT);
 	bzero(xdc->reqs, XDC_MAXIOPB * sizeof(struct xd_iorq));
@@ -492,7 +491,7 @@ xdcattach(parent, self, aux)
 
 
 	/* now we must look for disks using autoconfig */
-	xa.dvmabuf = (char *) dvma_malloc(XDFM_BPS);
+	xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
 	xa.fullmode = XD_SUB_POLL;
 	xa.booting = 1;
 
@@ -504,7 +503,7 @@ xdcattach(parent, self, aux)
 	for (xa.driveno = 0; xa.driveno < XDC_MAXDEV; xa.driveno++)
 		(void) config_found(self, (void *) &xa, NULL);
 
-	dvma_free(xa.dvmabuf, XDFM_BPS);
+	dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
 	bootpath_store(1, NULL);
 
 	/* start the watchdog clock */
@@ -653,12 +652,12 @@ xdattach(parent, self, aux)
 	newstate = XD_DRIVE_NOLABEL;
 
 	xd->hw_spt = spt;
-	if (xdgetdisklabel(xd, xa->dvmabuf) != XD_ERR_AOK)
+	if (xdgetdisklabel(xd, xa->buf) != XD_ERR_AOK)
 		goto done;
 
 	/* inform the user of what is up */
 	printf("%s: <%s>, pcyl %d, hw_spt %d\n", xd->sc_dev.dv_xname,
-		xa->dvmabuf, xd->pcyl, spt);
+		xa->buf, xd->pcyl, spt);
 	mb = xd->ncyl * (xd->nhead * xd->nsect) / (1048576 / XDFM_BPS);
 	printf("%s: %dMB, %d cyl, %d head, %d sec, %d bytes/sec\n",
 		xd->sc_dev.dv_xname, mb, xd->ncyl, xd->nhead, xd->nsect,
@@ -691,7 +690,7 @@ xdattach(parent, self, aux)
 	}
 
 	/* check dkbad for sanity */
-	dkb = (struct dkbad *) xa->dvmabuf;
+	dkb = (struct dkbad *) xa->buf;
 	for (lcv = 0; lcv < 126; lcv++) {
 		if ((dkb->bt_bad[lcv].bt_cyl == 0xffff ||
 				dkb->bt_bad[lcv].bt_cyl == 0) &&
@@ -708,7 +707,7 @@ xdattach(parent, self, aux)
 		printf("%s: warning: invalid bad144 sector!\n",
 			xd->sc_dev.dv_xname);
 	} else {
-		bcopy(xa->dvmabuf, &xd->dkb, XDFM_BPS);
+		bcopy(xa->buf, &xd->dkb, XDFM_BPS);
 	}
 
 	if (xa->booting) {
@@ -921,11 +920,11 @@ xdopen(dev, flag, fmt)
 
 	if (xd->state == XD_DRIVE_UNKNOWN) {
 		xa.driveno = xd->xd_drive;
-		xa.dvmabuf = (char *) dvma_malloc(XDFM_BPS);
+		xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
 		xa.fullmode = XD_SUB_WAIT;
 		xa.booting = 0;
 		xdattach((struct device *) xd->parent, (struct device *) xd, &xa);
-		dvma_free(xa.dvmabuf, XDFM_BPS);
+		dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
 		if (xd->state == XD_DRIVE_UNKNOWN) {
 			return (EIO);
 		}
@@ -1029,11 +1028,11 @@ xdstrategy(bp)
 
 	if (xd->state == XD_DRIVE_UNKNOWN) {
 		xa.driveno = xd->xd_drive;
-		xa.dvmabuf = (char *) dvma_malloc(XDFM_BPS);
+		xa.dvmabuf = (char *)dvma_malloc(XDFM_BPS, &xa.buf, M_NOWAIT);
 		xa.fullmode = XD_SUB_WAIT;
 		xa.booting = 0;
 		xdattach((struct device *)xd->parent, (struct device *)xd, &xa);
-		dvma_free(xa.dvmabuf, XDFM_BPS);
+		dvma_free(xa.dvmabuf, XDFM_BPS, &xa.buf);
 		if (xd->state == XD_DRIVE_UNKNOWN) {
 			bp->b_error = EIO;
 			goto bad;
@@ -1066,41 +1065,17 @@ xdstrategy(bp)
 	 * algorithm built into the hardware.
 	 */
 
-	{			/* XXX DVMA mapin */
-
-		/* DVMA: if we've got a kernel buf structure we map it into
-		 * DVMA space here.   the advantage to this is that it allows
-		 * us to sleep if there isn't space in the DVMA area.   the
-		 * disadvantage to this is that we are mapping this in earlier
-		 * than we have to, and thus possibly wasting DVMA space.   in
-		 * an ideal world we would like to map it in once we know we
-		 * can submit an IOPB (at this point we don't know if we can
-		 * submit or not).   (XXX) If the DVMA system gets redone this
-		 * mapin can be moved elsewhere. */
-
-		caddr_t x;
-		if ((bp->b_flags & B_PHYS) == 0) {
-			x = dvma_mapin(kernel_map, (vm_offset_t)bp->b_data,
-					bp->b_bcount, 1);
-			if (x == NULL)
-				panic("xd mapin");
-			bp->b_resid = (long) x;	/* XXX we store DVMA addr in
-						 * b_resid, thus overloading
-						 * it */
-		}
-	} /* XXX end DVMA mapin */
-
 	s = splbio();		/* protect the queues */
 
 	/* first, give jobs in front of us a chance */
-
 	parent = xd->parent;
 	while (parent->nfree > 0 && parent->sc_wq.b_actf)
 		if (xdc_startbuf(parent, NULL, NULL) != XD_ERR_AOK)
 			break;
 
 	/* if there are no free iorq's, then we just queue and return. the
-	 * buffs will get picked up later by xdcintr(). */
+	 * buffs will get picked up later by xdcintr().
+	 */
 
 	if (parent->nfree == 0) {
 		wq = &xd->parent->sc_wq;
@@ -1111,8 +1086,8 @@ xdstrategy(bp)
 		splx(s);
 		return;
 	}
-	/* now we have free iopb's and we are at splbio... start 'em up */
 
+	/* now we have free iopb's and we are at splbio... start 'em up */
 	if (xdc_startbuf(parent, xd, bp) != XD_ERR_AOK) {
 		return;
 	}
@@ -1432,47 +1407,25 @@ xdc_startbuf(xdcsc, xdsc, bp)
 	 * load request.  we have to calculate the correct block number based
 	 * on partition info.
 	 * 
-	 * also, note that there are two kinds of buf structures, those with
-	 * B_PHYS set and those without B_PHYS.   if B_PHYS is set, then it is
-	 * a raw I/O (to a cdevsw) and we are doing I/O directly to the users'
-	 * buffer which has already been mapped into DVMA space. however, if
-	 * B_PHYS is not set, then the buffer is a normal system buffer which
-	 * does *not* live in DVMA space.   in that case we call dvma_mapin to
-	 * map it into DVMA space so we can do the DMA I/O to it.
-	 * 
-	 * in cases where we do a dvma_mapin, note that iorq points to the buffer
-	 * as mapped into DVMA space, where as the bp->b_data points to its
-	 * non-DVMA mapping.
+	 * note that iorq points to the buffer as mapped into DVMA space,
+	 * where as the bp->b_data points to its non-DVMA mapping.
 	 */
 
 	block = bp->b_blkno + ((partno == RAW_PART) ? 0 :
 	    xdsc->sc_dk.dk_label.d_partitions[partno].p_offset);
 
-	if ((bp->b_flags & B_PHYS) == 0) {
-		dbuf = (caddr_t) bp->b_resid;	/* XXX: overloaded resid from
-						 * xdstrategy() */
-		bp->b_resid = bp->b_bcount;	/* XXX? */
-#ifdef someday
-
-		/* XXX: this is where we would really like to do the DVMA
-		 * mapin, but we get called from intr here so we can't sleep
-		 * so we can't do it. */
-		/* allocate DVMA, map in */
-
-		if (dbuf == NULL) {	/* out of DVMA space */
-			printf("%s: warning: out of DVMA space\n", xdcsc->sc_dev.dv_xname);
-			XDC_FREE(xdcsc, rqno);
-			wq = &xdcsc->sc_wq;	/* put at end of queue */
-			bp->b_actf = 0;
-			bp->b_actb = wq->b_actb;
-			*wq->b_actb = bp;
-			wq->b_actb = &bp->b_actf;
-			return (XD_ERR_FAIL);	/* XXX: need some sort of
-						 * call-back scheme here? */
-		}
-#endif				/* someday */
-	} else {
-		dbuf = bp->b_data;
+	dbuf = kdvma_mapin(bp->b_data, bp->b_bcount, 0);
+	if (dbuf == NULL) {	/* out of DVMA space */
+		printf("%s: warning: out of DVMA space\n",
+			xdcsc->sc_dev.dv_xname);
+		XDC_FREE(xdcsc, rqno);
+		wq = &xdcsc->sc_wq;	/* put at end of queue */
+		bp->b_actf = 0;
+		bp->b_actb = wq->b_actb;
+		*wq->b_actb = bp;
+		wq->b_actb = &bp->b_actf;
+		return (XD_ERR_FAIL);	/* XXX: need some sort of
+					 * call-back scheme here? */
 	}
 
 	/* init iorq and load iopb from it */
@@ -1739,38 +1692,38 @@ xdc_reset(xdcsc, quiet, blastmode, error, xdsc)
 	/* fix queues based on "blast-mode" */
 
 	for (lcv = 0; lcv < XDC_MAXIOPB; lcv++) {
-		if (XD_STATE(xdcsc->reqs[lcv].mode) != XD_SUB_POLL &&
-		    XD_STATE(xdcsc->reqs[lcv].mode) != XD_SUB_WAIT &&
-		    XD_STATE(xdcsc->reqs[lcv].mode) != XD_SUB_NORM)
+		register struct xd_iorq *iorq = &xdcsc->reqs[lcv];
+
+		if (XD_STATE(iorq->mode) != XD_SUB_POLL &&
+		    XD_STATE(iorq->mode) != XD_SUB_WAIT &&
+		    XD_STATE(iorq->mode) != XD_SUB_NORM)
 			/* is it active? */
 			continue;
 
 		xdcsc->nrun--;	/* it isn't running any more */
 		if (blastmode == XD_RSET_ALL || blastmode != lcv) {
 			/* failed */
-			xdcsc->reqs[lcv].errno = error;
+			iorq->errno = error;
 			xdcsc->iopbase[lcv].done = xdcsc->iopbase[lcv].errs = 1;
 			switch (XD_STATE(xdcsc->reqs[lcv].mode)) {
 			case XD_SUB_NORM:
-			    xdcsc->reqs[lcv].buf->b_error = EIO;
-			    xdcsc->reqs[lcv].buf->b_flags |= B_ERROR;
-			    xdcsc->reqs[lcv].buf->b_resid =
-			       xdcsc->reqs[lcv].sectcnt * XDFM_BPS;
-			    if ((xdcsc->reqs[lcv].buf->b_flags & B_PHYS) == 0) {
-				dvma_mapout(
-				    (vm_offset_t)xdcsc->reqs[lcv].dbufbase,
-				    (vm_offset_t)xdcsc->reqs[lcv].buf->b_un.b_addr,
-				    xdcsc->reqs[lcv].buf->b_bcount);
-				}
-			    biodone(xdcsc->reqs[lcv].buf);
+			    iorq->buf->b_error = EIO;
+			    iorq->buf->b_flags |= B_ERROR;
+			    iorq->buf->b_resid =
+			       iorq->sectcnt * XDFM_BPS;
+			    dvma_mapout(
+				    (vm_offset_t)iorq->dbufbase,
+				    (vm_offset_t)iorq->buf->b_un.b_addr,
+				    iorq->buf->b_bcount);
+			    biodone(iorq->buf);
 			    XDC_FREE(xdcsc, lcv);	/* add to free list */
 			    break;
 			case XD_SUB_WAIT:
-			    wakeup(&xdcsc->reqs[lcv]);
+			    wakeup(iorq);
 			case XD_SUB_POLL:
 			    xdcsc->ndone++;
-			    xdcsc->reqs[lcv].mode =
-				XD_NEWSTATE(xdcsc->reqs[lcv].mode, XD_SUB_DONE);
+			    iorq->mode =
+				XD_NEWSTATE(iorq->mode, XD_SUB_DONE);
 			    break;
 			}
 
@@ -1963,11 +1916,9 @@ xdc_remove_iorq(xdcsc)
 			} else {
 				bp->b_resid = 0;	/* done */
 			}
-			if ((bp->b_flags & B_PHYS) == 0) {
-				dvma_mapout((vm_offset_t) iorq->dbufbase,
-					    (vm_offset_t) bp->b_un.b_addr,
-					    bp->b_bcount);
-			}
+			dvma_mapout((vm_offset_t) iorq->dbufbase,
+				    (vm_offset_t) bp->b_un.b_addr,
+				    bp->b_bcount);
 			XDC_FREE(xdcsc, rqno);
 			biodone(bp);
 			break;
@@ -2200,7 +2151,7 @@ xdc_ioctlcmd(xd, dev, xio)
 
 {
 	int     s, err, rqno, dummy;
-	caddr_t dvmabuf = NULL;
+	caddr_t dvmabuf = NULL, buf = NULL;
 	struct xdc_softc *xdcsc;
 
 	/* check sanity of requested command */
@@ -2284,10 +2235,10 @@ xdc_ioctlcmd(xd, dev, xio)
 	/* create DVMA buffer for request if needed */
 
 	if (xio->dlen) {
-		dvmabuf = dvma_malloc(xio->dlen);
+		dvmabuf = dvma_malloc(xio->dlen, &buf, M_WAITOK);
 		if (xio->cmd == XDCMD_WR || xio->cmd == XDCMD_XWR) {
-			if (err = copyin(xio->dptr, dvmabuf, xio->dlen)) {
-				dvma_free(dvmabuf, xio->dlen);
+			if (err = copyin(xio->dptr, buf, xio->dlen)) {
+				dvma_free(dvmabuf, xio->dlen, &buf);
 				return (err);
 			}
 		}
@@ -2308,12 +2259,12 @@ xdc_ioctlcmd(xd, dev, xio)
 	XDC_DONE(xdcsc, rqno, dummy);
 
 	if (xio->cmd == XDCMD_RD || xio->cmd == XDCMD_XRD)
-		err = copyout(dvmabuf, xio->dptr, xio->dlen);
+		err = copyout(buf, xio->dptr, xio->dlen);
 
 done:
 	splx(s);
 	if (dvmabuf)
-		dvma_free(dvmabuf, xio->dlen);
+		dvma_free(dvmabuf, xio->dlen, &buf);
 	return (err);
 }
 
diff --git a/sys/arch/sparc/dev/xy.c b/sys/arch/sparc/dev/xy.c
index 45282b856e9..1242776426a 100644
--- a/sys/arch/sparc/dev/xy.c
+++ b/sys/arch/sparc/dev/xy.c
@@ -1,4 +1,4 @@
-/* $NetBSD: xy.c,v 1.1 1995/09/25 20:35:14 chuck Exp $ */
+/* $NetBSD: xy.c,v 1.2 1995/12/11 12:40:25 pk Exp $ */
 
 /*
  *
@@ -36,7 +36,7 @@
  * x y . c   x y l o g i c s   4 5 0 / 4 5 1   s m d   d r i v e r
  *
  * author: Chuck Cranor <chuck@ccrc.wustl.edu>
- * id: $Id: xy.c,v 1.1 1995/10/18 08:51:41 deraadt Exp $
+ * id: $Id: xy.c,v 1.2 1995/12/15 13:56:29 deraadt Exp $
  * started: 14-Sep-95
  * references: [1] Xylogics Model 753 User's Manual
  *                 part number: 166-753-001, Revision B, May 21, 1988.
@@ -138,11 +138,6 @@
  * "xyc_*" functions are internal, all others are external interfaces
  */
 
-/* external (XXX should migrate to std include file?) */
-extern caddr_t dvma_malloc __P((size_t));
-extern void dvma_free __P((caddr_t, size_t));
-extern caddr_t dvma_mapin __P((struct vm_map *, vm_offset_t, int, int));
-extern void dvma_mapout __P((vm_offset_t, vm_offset_t, int));
 extern int pil_to_vme[];	/* from obio.c */
 
 /* internals */
@@ -205,7 +200,8 @@ struct cfdriver xycd = {
 
 struct xyc_attach_args {	/* this is the "aux" args to xyattach */
 	int	driveno;	/* unit number */
-	char	*dvmabuf;	/* scratch buffer for reading disk label */
+	char	*buf;		/* scratch buffer for reading disk label */
+	char	*dvmabuf;	/* DVMA address of above */
 	int	fullmode;	/* submit mode */
 	int	booting;	/* are we booting or not? */
 };
@@ -333,12 +329,13 @@ xycattach(parent, self, aux)
 	struct xyc_attach_args xa;
 	int     lcv, err, pri, res, pbsz;
 	void	*tmp, *tmp2;
+	void	*dtmp, *dtmp2;
 	u_long	ultmp;
 
 	/* get addressing and intr level stuff from autoconfig and load it
 	 * into our xyc_softc. */
 
-	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_paddr,
+	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0,
 	    ca->ca_ra.ra_len, ca->ca_bustype);
 	if ((u_long) ca->ca_ra.ra_paddr & PGOFSET)
 		(u_long) ca->ca_ra.ra_vaddr |=
@@ -361,21 +358,23 @@ xycattach(parent, self, aux)
 	 */
 
 	pbsz = XYC_MAXIOPB * sizeof(struct xy_iopb);
-	tmp = tmp2 = (struct xy_iopb *) dvma_malloc(pbsz);	/* KVA */
-	ultmp = (u_long) tmp;
+	dtmp = dtmp2 = (struct xy_iopb *)dvma_malloc(pbsz, &tmp, M_NOWAIT);
+	tmp2 = tmp;
+	ultmp = (u_long) dtmp;
 	if ((ultmp & 0xffff0000) != ((ultmp + pbsz) & 0xffff0000)) {
-		tmp = (struct xy_iopb *) dvma_malloc(pbsz); /* retry! */
-		dvma_free(tmp2, pbsz);
-		ultmp = (u_long) tmp;
+		dtmp = (struct xy_iopb *)
+		    dvma_malloc(pbsz, &tmp, M_NOWAIT); /* retry! */
+		dvma_free(dtmp2, pbsz, &tmp2);
+		ultmp = (u_long) dtmp;
 		if ((ultmp & 0xffff0000) != ((ultmp + pbsz) & 0xffff0000)) {
 			printf("%s: can't alloc IOPB mem in 64K\n", 
 				xyc->sc_dev.dv_xname);
 			return;
 		}
 	}
+	bzero(tmp, pbsz);
 	xyc->iopbase = tmp;
-	bzero(xyc->iopbase, pbsz);
-	xyc->dvmaiopb = (struct xy_iopb *) ((u_long) xyc->iopbase - DVMA_BASE);
+	xyc->dvmaiopb = (struct xy_iopb *) ((u_long)dtmp - DVMA_BASE);
 	xyc->reqs = (struct xy_iorq *)
 	    malloc(XYC_MAXIOPB * sizeof(struct xy_iorq), M_DEVBUF, M_NOWAIT);
 	bzero(xyc->reqs, XYC_MAXIOPB * sizeof(struct xy_iorq));
@@ -439,7 +438,7 @@ xycattach(parent, self, aux)
 
 
 	/* now we must look for disks using autoconfig */
-	xa.dvmabuf = (char *) dvma_malloc(XYFM_BPS);
+	xa.dvmabuf = (char *)dvma_malloc(XYFM_BPS, &xa.buf, M_NOWAIT);
 	xa.fullmode = XY_SUB_POLL;
 	xa.booting = 1;
 
@@ -451,7 +450,7 @@ xycattach(parent, self, aux)
 	for (xa.driveno = 0; xa.driveno < XYC_MAXDEV; xa.driveno++)
 		(void) config_found(self, (void *) &xa, NULL);
 
-	dvma_free(xa.dvmabuf, XYFM_BPS);
+	dvma_free(xa.dvmabuf, XYFM_BPS, &xa.buf);
 	bootpath_store(1, NULL);
 
 	/* start the watchdog clock */
@@ -587,12 +586,12 @@ xyattach(parent, self, aux)
 	newstate = XY_DRIVE_NOLABEL;
 
 	xy->hw_spt = spt = 0; /* XXX needed ? */
-	if (xygetdisklabel(xy, xa->dvmabuf) != XY_ERR_AOK)
+	if (xygetdisklabel(xy, xa->buf) != XY_ERR_AOK)
 		goto done;
 
 	/* inform the user of what is up */
 	printf("%s: <%s>, pcyl %d\n", xy->sc_dev.dv_xname,
-		xa->dvmabuf, xy->pcyl);
+		xa->buf, xy->pcyl);
 	mb = xy->ncyl * (xy->nhead * xy->nsect) / (1048576 / XYFM_BPS);
 	printf("%s: %dMB, %d cyl, %d head, %d sec, %d bytes/sec\n",
 		xy->sc_dev.dv_xname, mb, xy->ncyl, xy->nhead, xy->nsect,
@@ -655,7 +654,7 @@ xyattach(parent, self, aux)
 	}
 
 	/* check dkbad for sanity */
-	dkb = (struct dkbad *) xa->dvmabuf;
+	dkb = (struct dkbad *) xa->buf;
 	for (lcv = 0; lcv < 126; lcv++) {
 		if ((dkb->bt_bad[lcv].bt_cyl == 0xffff ||
 				dkb->bt_bad[lcv].bt_cyl == 0) &&
@@ -672,7 +671,7 @@ xyattach(parent, self, aux)
 		printf("%s: warning: invalid bad144 sector!\n",
 			xy->sc_dev.dv_xname);
 	} else {
-		bcopy(xa->dvmabuf, &xy->dkb, XYFM_BPS);
+		bcopy(xa->buf, &xy->dkb, XYFM_BPS);
 	}
 
 	if (xa->booting) {
@@ -886,12 +885,12 @@ xyopen(dev, flag, fmt)
 
 	if (xy->state == XY_DRIVE_UNKNOWN) {
 		xa.driveno = xy->xy_drive;
-		xa.dvmabuf = (char *) dvma_malloc(XYFM_BPS);
+		xa.dvmabuf = (char *)dvma_malloc(XYFM_BPS, &xa.buf, M_NOWAIT);
 		xa.fullmode = XY_SUB_WAIT;
 		xa.booting = 0;
 		xyattach((struct device *) xy->parent, 
 						(struct device *) xy, &xa);
-		dvma_free(xa.dvmabuf, XYFM_BPS);
+		dvma_free(xa.dvmabuf, XYFM_BPS, &xa.buf);
 		if (xy->state == XY_DRIVE_UNKNOWN) {
 			return (EIO);
 		}
@@ -996,11 +995,11 @@ xystrategy(bp)
 
 	if (xy->state == XY_DRIVE_UNKNOWN) {
 		xa.driveno = xy->xy_drive;
-		xa.dvmabuf = (char *) dvma_malloc(XYFM_BPS);
+		xa.dvmabuf = (char *)dvma_malloc(XYFM_BPS, &xa.buf, M_NOWAIT);
 		xa.fullmode = XY_SUB_WAIT;
 		xa.booting = 0;
 		xyattach((struct device *)xy->parent, (struct device *)xy, &xa);
-		dvma_free(xa.dvmabuf, XYFM_BPS);
+		dvma_free(xa.dvmabuf, XYFM_BPS, &xa.buf);
 		if (xy->state == XY_DRIVE_UNKNOWN) {
 			bp->b_error = EIO;
 			goto bad;
@@ -1029,34 +1028,6 @@ xystrategy(bp)
 	 * now we know we have a valid buf structure that we need to do I/O
 	 * on.
 	 */
-
-	{			/* XXX DVMA mapin */
-
-		/* DVMA: if we've got a kernel buf structure we map it into
-		 * DVMA space here.   the advantage to this is that it allows
-		 * us to sleep if there isn't space in the DVMA area.   the
-		 * disadvantage to this is that we are mapping this in earlier
-		 * than we have to, and thus possibly wasting DVMA space.   in
-		 * an ideal world we would like to map it in once we know we
-		 * can submit an IOPB (at this point we don't know if we can
-		 * submit or not).   (XXX) If the DVMA system gets redone this
-		 * mapin can be moved elsewhere. */
-
-		caddr_t x;
-		if ((bp->b_flags & B_PHYS) == 0) {
-			x = dvma_mapin(kernel_map, (vm_offset_t)bp->b_data,
-					bp->b_bcount, 1);
-			if (x == NULL)
-				panic("xy mapin");
-			bp->b_error = (int) x;	/* XXX we store DVMA addr in
-						 * b_error, thus overloading
-						 * it.    VERY ugly.  note
-						 * that xd.c uses b_resid, but
-						 * we can't because disksort
-						 * uses it */
-		}
-	} /* XXX end DVMA mapin */
-
 	s = splbio();		/* protect the queues */
 
 	disksort(&xy->xyq, bp);
@@ -1301,42 +1272,19 @@ xyc_startbuf(xycsc, xysc, bp)
 	 * load request.  we have to calculate the correct block number based
 	 * on partition info.
 	 * 
-	 * also, note that there are two kinds of buf structures, those with
-	 * B_PHYS set and those without B_PHYS.   if B_PHYS is set, then it is
-	 * a raw I/O (to a cdevsw) and we are doing I/O directly to the users'
-	 * buffer which has already been mapped into DVMA space. however, if
-	 * B_PHYS is not set, then the buffer is a normal system buffer which
-	 * does *not* live in DVMA space.   in that case we call dvma_mapin to
-	 * map it into DVMA space so we can do the DMA I/O to it.
-	 * 
-	 * in cases where we do a dvma_mapin, note that iorq points to the buffer
-	 * as mapped into DVMA space, where as the bp->b_data points to its
-	 * non-DVMA mapping.
+	 * note that iorq points to the buffer as mapped into DVMA space,
+	 * where as the bp->b_data points to its non-DVMA mapping.
 	 */
 
 	block = bp->b_blkno + ((partno == RAW_PART) ? 0 :
 	    xysc->sc_dk.dk_label.d_partitions[partno].p_offset);
 
-	if ((bp->b_flags & B_PHYS) == 0) {
-		dbuf = (caddr_t) bp->b_error;	/* XXX: overloaded error from
-						 * xystrategy() */
-		bp->b_error = 0;		/* XXX? */
-#ifdef someday
-
-		/* XXX: this is where we would really like to do the DVMA
-		 * mapin, but we get called from intr here so we can't sleep
-		 * so we can't do it. */
-		/* allocate DVMA, map in */
-
-		if (dbuf == NULL) {	/* out of DVMA space */
-			printf("%s: warning: out of DVMA space\n", 
-						xycsc->sc_dev.dv_xname);
-			return (XY_ERR_FAIL);	/* XXX: need some sort of
-						 * call-back scheme here? */
-		}
-#endif				/* someday */
-	} else {
-		dbuf = bp->b_data;
+	dbuf = kdvma_mapin(bp->b_data, bp->b_bcount, 0);
+	if (dbuf == NULL) {	/* out of DVMA space */
+		printf("%s: warning: out of DVMA space\n", 
+			xycsc->sc_dev.dv_xname);
+		return (XY_ERR_FAIL);	/* XXX: need some sort of
+					 * call-back scheme here? */
 	}
 
 	/* init iorq and load iopb from it */
@@ -1658,39 +1606,36 @@ xyc_reset(xycsc, quiet, blastmode, error, xysc)
 	/* fix queues based on "blast-mode" */
 
 	for (lcv = 0; lcv < XYC_MAXIOPB; lcv++) {
-		if (XY_STATE(xycsc->reqs[lcv].mode) != XY_SUB_POLL &&
-		    XY_STATE(xycsc->reqs[lcv].mode) != XY_SUB_WAIT &&
-		    XY_STATE(xycsc->reqs[lcv].mode) != XY_SUB_NORM)
+		register struct xy_iorq *iorq = &xycsc->reqs[lcv];
+
+		if (XY_STATE(iorq->mode) != XY_SUB_POLL &&
+		    XY_STATE(iorq->mode) != XY_SUB_WAIT &&
+		    XY_STATE(iorq->mode) != XY_SUB_NORM)
 			/* is it active? */
 			continue;
 
 		if (blastmode == XY_RSET_ALL || 
-				blastmode != &xycsc->reqs[lcv]) {
+				blastmode != iorq) {
 			/* failed */
-			xycsc->reqs[lcv].errno = error;
+			iorq->errno = error;
 			xycsc->iopbase[lcv].done = xycsc->iopbase[lcv].errs = 1;
-			switch (XY_STATE(xycsc->reqs[lcv].mode)) {
+			switch (XY_STATE(iorq->mode)) {
 			case XY_SUB_NORM:
-			    xycsc->reqs[lcv].buf->b_error = EIO;
-			    xycsc->reqs[lcv].buf->b_flags |= B_ERROR;
-			    xycsc->reqs[lcv].buf->b_resid =
-			       xycsc->reqs[lcv].sectcnt * XYFM_BPS;
-			    if ((xycsc->reqs[lcv].buf->b_flags & B_PHYS) == 0) {
-				dvma_mapout(
-				    (vm_offset_t)xycsc->reqs[lcv].dbufbase,
-				    (vm_offset_t)xycsc->reqs[lcv].buf->b_un.b_addr,
-				    xycsc->reqs[lcv].buf->b_bcount);
-				}
-			    xycsc->reqs[lcv].xy->xyq.b_actf =
-				xycsc->reqs[lcv].buf->b_actf;
-			    biodone(xycsc->reqs[lcv].buf);
-			    xycsc->reqs[lcv].mode = XY_SUB_FREE;
+			    iorq->buf->b_error = EIO;
+			    iorq->buf->b_flags |= B_ERROR;
+			    iorq->buf->b_resid = iorq->sectcnt * XYFM_BPS;
+			    dvma_mapout((vm_offset_t)iorq->dbufbase,
+					(vm_offset_t)iorq->buf->b_un.b_addr,
+					iorq->buf->b_bcount);
+			    iorq->xy->xyq.b_actf = iorq->buf->b_actf;
+			    biodone(iorq->buf);
+			    iorq->mode = XY_SUB_FREE;
 			    break;
 			case XY_SUB_WAIT:
-			    wakeup(&xycsc->reqs[lcv]);
+			    wakeup(iorq);
 			case XY_SUB_POLL:
-			    xycsc->reqs[lcv].mode =
-				XY_NEWSTATE(xycsc->reqs[lcv].mode, XY_SUB_DONE);
+			    iorq->mode =
+				XY_NEWSTATE(iorq->mode, XY_SUB_DONE);
 			    break;
 			}
 
@@ -1854,11 +1799,9 @@ xyc_remove_iorq(xycsc)
 			} else {
 				bp->b_resid = 0;	/* done */
 			}
-			if ((bp->b_flags & B_PHYS) == 0) {
-				dvma_mapout((vm_offset_t) iorq->dbufbase,
-					    (vm_offset_t) bp->b_un.b_addr,
-					    bp->b_bcount);
-			}
+			dvma_mapout((vm_offset_t) iorq->dbufbase,
+				    (vm_offset_t) bp->b_un.b_addr,
+				    bp->b_bcount);
 			iorq->mode = XY_SUB_FREE;
 			iorq->xy->xyq.b_actf = bp->b_actf;
 			biodone(bp);
@@ -2031,7 +1974,7 @@ xyc_ioctlcmd(xy, dev, xio)
 
 {
 	int     s, err, rqno, dummy;
-	caddr_t dvmabuf = NULL;
+	caddr_t dvmabuf = NULL, buf = NULL;
 	struct xyc_softc *xycsc;
 
 	/* check sanity of requested command */
@@ -2063,10 +2006,10 @@ xyc_ioctlcmd(xy, dev, xio)
 	/* create DVMA buffer for request if needed */
 
 	if (xio->dlen) {
-		dvmabuf = dvma_malloc(xio->dlen);
+		dvmabuf = dvma_malloc(xio->dlen, &buf, M_WAITOK);
 		if (xio->cmd == XYCMD_WR) {
-			if (err = copyin(xio->dptr, dvmabuf, xio->dlen)) {
-				dvma_free(dvmabuf, xio->dlen);
+			if (err = copyin(xio->dptr, buf, xio->dlen)) {
+				dvma_free(dvmabuf, xio->dlen, &buf);
 				return (err);
 			}
 		}
@@ -2087,12 +2030,12 @@ xyc_ioctlcmd(xy, dev, xio)
 	XYC_DONE(xycsc, dummy);
 
 	if (xio->cmd == XYCMD_RD)
-		err = copyout(dvmabuf, xio->dptr, xio->dlen);
+		err = copyout(buf, xio->dptr, xio->dlen);
 
 done:
 	splx(s);
 	if (dvmabuf)
-		dvma_free(dvmabuf, xio->dlen);
+		dvma_free(dvmabuf, xio->dlen, &buf);
 	return (err);
 }
 
diff --git a/sys/arch/sparc/include/autoconf.h b/sys/arch/sparc/include/autoconf.h
index 08b44eb4407..4cb7f4b25f6 100644
--- a/sys/arch/sparc/include/autoconf.h
+++ b/sys/arch/sparc/include/autoconf.h
@@ -138,13 +138,30 @@ char	*clockfreq __P((int freq));
  * it will use that instead of creating one, but you must only do this if
  * you get it from ../sparc/vaddrs.h.
  */
-void	*mapdev __P((void *pa, int va, int size, int bustype));
-#define	mapiodev(pa, size, bustype)	mapdev(pa, 0, size, bustype)
+void	*mapdev __P((struct rom_reg *rr, int va, int offset,
+	    int size, int bustype));
+#define	mapiodev(rr, offset, size, bustype)	mapdev(rr, 0, offset, size, bustype)
 
 void 	*bus_map __P((void *pa, int len, int bustype));
 void 	*bus_tmp __P((void *pa, int bustype));
 void	bus_untmp __P((void));
 
+#ifdef notyet
+/*
+ * REG2PHYS is provided for drivers with a `d_mmap' function.
+ */
+#define REG2PHYS(rr, offset, bt)				\
+	(((u_int)(rr)->rr_paddr + (offset)) |			\
+		((cputyp == CPU_SUN4M)				\
+			? ((rr)->rr_iospace << PMAP_SHFT4M)	\
+			: bt2pmt[bt])				\
+	)
+#else
+#define REG2PHYS(rr, offset, bt)				\
+	(((u_int)(rr)->rr_paddr + (offset)) | (bt2pmt[bt])	\
+	)
+#endif
+
 /*
  * Memory description arrays.  Shared between pmap.c and autoconf.c; no
  * one else should use this (except maybe mem.c, e.g., if we fix the VM to
diff --git a/sys/arch/sparc/include/param.h b/sys/arch/sparc/include/param.h
index c62dfcfe3cb..da5231519df 100644
--- a/sys/arch/sparc/include/param.h
+++ b/sys/arch/sparc/include/param.h
@@ -169,16 +169,21 @@ extern int nbpg, pgofset, pgshift;
  */
 #ifdef _KERNEL
 #ifndef LOCORE
-extern vm_offset_t	dvmabase;
+extern vm_offset_t	dvma_base;
+extern vm_offset_t	dvma_end;
 extern struct map	*dvmamap;
 #endif
-#endif
 /*
  * The dvma resource map is defined in page units, which are numbered 1 to N.
  * Use these macros to convert to/from virtual addresses.
  */
-#define rctov(n)		(ctob(((n)-1))+dvmabase)
-#define vtorc(v)		((btoc((v)-dvmabase))+1)
+#define rctov(n)		(ctob(((n)-1))+dvma_base)
+#define vtorc(v)		((btoc((v)-dvma_base))+1)
+
+extern caddr_t	kdvma_mapin __P((caddr_t, int, int));
+extern caddr_t	dvma_malloc __P((size_t, void *, int));
+extern void	dvma_free __P((caddr_t, size_t, void *));
+#endif
 
 
 #ifdef _KERNEL
@@ -188,9 +193,11 @@ extern struct map	*dvmamap;
 #endif
 
 #ifdef _KERNEL
+#ifndef LOCORE
 extern int cputyp;
 extern int cpumod;
 #endif
+#endif
 /*
  * Values for the cputyp variable.
  */
diff --git a/sys/arch/sparc/include/vmparam.h b/sys/arch/sparc/include/vmparam.h
index 989f8272933..ef899abd76a 100644
--- a/sys/arch/sparc/include/vmparam.h
+++ b/sys/arch/sparc/include/vmparam.h
@@ -139,3 +139,9 @@
 #define VM_KMEM_SIZE		(NKMEMCLUSTERS*CLBYTES)
 
 #define MACHINE_NONCONTIG	/* VM <=> pmap interface modifier */
+
+#if defined (_KERNEL) && !defined(LOCORE)
+struct vm_map;
+vm_offset_t	dvma_mapin __P((struct vm_map *, vm_offset_t, int, int));
+int		dvma_mapout __P((vm_offset_t, vm_offset_t, int));
+#endif
diff --git a/sys/arch/sparc/sparc/auxreg.c b/sys/arch/sparc/sparc/auxreg.c
index e39a0168c32..c61ab16f1d7 100644
--- a/sys/arch/sparc/sparc/auxreg.c
+++ b/sys/arch/sparc/sparc/auxreg.c
@@ -106,8 +106,10 @@ auxregattach(parent, self, aux)
 	struct confargs *ca = aux;
 	struct romaux *ra = &ca->ca_ra;
 
-	(void)mapdev(ra->ra_paddr, AUXREG_VA, sizeof(long), ca->ca_bustype);
-	auxio_reg = AUXIO_REG;
+	auxio_reg = mapdev(ra->ra_reg, AUXREG_VA, 0, sizeof(long),
+	    ca->ca_bustype);
+	if ((u_long)auxio_reg != AUXREG_VA)
+		panic("unable to map auxreg");
 	printf("\n");
 #ifdef BLINK
 	blink((caddr_t)0);
diff --git a/sys/arch/sparc/sparc/clock.c b/sys/arch/sparc/sparc/clock.c
index 43fe2528964..0993fa4e160 100644
--- a/sys/arch/sparc/sparc/clock.c
+++ b/sys/arch/sparc/sparc/clock.c
@@ -203,7 +203,7 @@ oclockattach(parent, self, aux)
 	oldclk = 1;  /* we've got an oldie! */
 	printf("\n");
 
-	i7 = (volatile struct intersil7170 *) mapiodev(ra->ra_paddr,
+	i7 = (volatile struct intersil7170 *) mapiodev(ra->ra_reg, 0,
 		sizeof(*i7), ca->ca_bustype);
 
 	idp = &idprom;
@@ -258,7 +258,7 @@ eeprom_attach(parent, self, aux)
 
 	printf("\n");
 
-	eeprom_va = (char *)mapiodev(ra->ra_paddr, sizeof(struct eeprom),
+	eeprom_va = (char *)mapiodev(ra->ra_reg, 0, sizeof(struct eeprom),
 	    ca->ca_bustype);
 
 	eeprom_nvram = 0;
@@ -322,7 +322,7 @@ clockattach(parent, self, aux)
 		/*
 		 * the MK48T08 is 8K
 		 */
-		cl = (struct clockreg *)mapiodev(ra->ra_paddr, 2 * NBPG,
+		cl = (struct clockreg *)mapiodev(ra->ra_reg, 0, 2 * NBPG,
 		    ca->ca_bustype);
 		pmap_changeprot(pmap_kernel(), (vm_offset_t)cl, VM_PROT_READ, 1);
 		pmap_changeprot(pmap_kernel(), (vm_offset_t)cl + NBPG, VM_PROT_READ, 1);
@@ -331,7 +331,7 @@ clockattach(parent, self, aux)
 		/*
 		 * the MK48T02 is 2K
 		 */
-		cl = (struct clockreg *)mapiodev(ra->ra_paddr, sizeof *clockreg,
+		cl = (struct clockreg *)mapiodev(ra->ra_reg, 0, sizeof *clockreg,
 		    ca->ca_bustype);
 		pmap_changeprot(pmap_kernel(), (vm_offset_t)cl, VM_PROT_READ, 1);
 		idp = &cl->cl_idprom;
@@ -391,8 +391,9 @@ timerattach(parent, self, aux)
 	 * we have a fixed virtual address for the timer, to make
 	 * microtime() faster.
 	 */
-	(void)mapdev(ra->ra_paddr, TIMERREG_VA, sizeof(struct timerreg),
-	    ca->ca_bustype);
+	if ((int)mapdev(ra->ra_reg, TIMERREG_VA, 0, sizeof(struct timerreg),
+	    ca->ca_bustype) != TIMERREG_VA)
+		panic("unable to map timer");
 	timerok = 1;
 	/* should link interrupt handlers here, rather than compiled-in? */
 }
diff --git a/sys/arch/sparc/sparc/machdep.c b/sys/arch/sparc/sparc/machdep.c
index beb7244f608..fbecc30b4f3 100644
--- a/sys/arch/sparc/sparc/machdep.c
+++ b/sys/arch/sparc/sparc/machdep.c
@@ -121,8 +121,8 @@ int   safepri = 0;
  * dvmamap is used to manage DVMA memory. Note: this coincides with
  * the memory range in `phys_map' (which is mostly a place-holder).
  */
+vm_offset_t dvma_base, dvma_end;
 struct map *dvmamap;
-vm_offset_t dvmabase;
 static int ndvmamap;	/* # of entries in dvmamap */
 
 caddr_t allocsys();
@@ -218,16 +218,28 @@ cpu_startup()
 	 * map, but we want one completely separate, even though it uses
 	 * the same pmap.
 	 */
-	phys_map = vm_map_create(pmap_kernel(), DVMA_BASE, DVMA_END, 1);
+#if defined(SUN4M) && 0
+	if (cputyp == CPU_SUN4M) {
+		dvma_base = DVMA4M_BASE;
+		dvma_end = (vm_offset_t)(0 - NBPG); /* want 4BG, but cant express */
+	} else
+#endif
+	{
+		dvma_base = DVMA_BASE;
+		dvma_end = DVMA_END;
+	}
+	phys_map = vm_map_create(pmap_kernel(), dvma_base, dvma_end, 1);
 	if (phys_map == NULL)
 		panic("unable to create DVMA map");
 	/*
-	 * For now, allocate half of DVMA space for a (privately managed)
-	 * pool of addresses for double mappings.
+	 * Allocate DVMA space and dump into a privately managed
+	 * resource map for double mappings which is usable from
+	 * interrupt contexts.
 	 */
-	dvmabase = kmem_alloc_wait(phys_map, (DVMA_END-DVMA_BASE)/2);
-	rminit(dvmamap, btoc((DVMA_END-DVMA_BASE)/2),
-	    vtorc(dvmabase), "dvmamap", ndvmamap);
+	if (kmem_alloc_wait(phys_map, (dvma_end-dvma_base)) != dvma_base)
+		panic("unable to allocate from DVMA map");
+	rminit(dvmamap, btoc((dvma_end-dvma_base)),
+		vtorc(dvma_base), "dvmamap", ndvmamap);
 
 	/*
 	 * Finally, allocate mbuf pool.  Since mclrefcnt is an off-size
@@ -841,20 +853,21 @@ int bt2pmt[] = {
 /*
  * Map an I/O device given physical address and size in bytes, e.g.,
  *
- *	mydev = (struct mydev *)mapdev(myioaddr, 0, sizeof(struct mydev), pmtype);
- *
+ *	mydev = (struct mydev *)mapdev(myioaddr, 0, 0,
+ *          sizeof(struct mydev), pmtype);
+ * 
  * See also machine/autoconf.h.
  */
 void *
-mapdev(phys, virt, size, bustype)
-	register void *phys;
-	register int virt, size;
+mapdev(rr, virt, offset, size, bustype)
+	register struct rom_reg *rr;
+	register int offset, virt, size;
 	register int bustype;
 {
-	register vm_offset_t v;
+	register vm_offset_t v, pa;
 	register void *ret;
 	static vm_offset_t iobase;
-	int pmtype = bt2pmt[bustype];
+	int pmtype;
 
 	if (iobase == NULL)
 		iobase = IODEV_BASE;
@@ -869,13 +882,19 @@ mapdev(phys, virt, size, bustype)
 			panic("mapiodev");
 	}
 	ret = (void *)v;
-	phys = (void *)trunc_page(phys);
+	pa = trunc_page(rr->rr_paddr + offset);
+#ifdef notyet
+	pmtype = (cputyp == CPU_SUN4M)
+			? (rr->rr_iospace << PMAP_SHFT4M)
+			: bt2pmt[bustype];
+#else
+	pmtype = bt2pmt[bustype];
+#endif
 	do {
-		pmap_enter(pmap_kernel(), v,
-		    (vm_offset_t)phys | pmtype | PMAP_NC,
+		pmap_enter(pmap_kernel(), v, pa | pmtype | PMAP_NC,
 		    VM_PROT_READ | VM_PROT_WRITE, 1);
 		v += PAGE_SIZE;
-		phys += PAGE_SIZE;
+		pa += PAGE_SIZE;
 	} while ((size -= PAGE_SIZE) > 0);
 	return (ret);
 }
diff --git a/sys/arch/sparc/sparc/memreg.c b/sys/arch/sparc/sparc/memreg.c
index 23f0f9fcf8b..b66b899cba9 100644
--- a/sys/arch/sparc/sparc/memreg.c
+++ b/sys/arch/sparc/sparc/memreg.c
@@ -93,7 +93,7 @@ memregattach(parent, self, aux)
 		ra->ra_vaddr = (caddr_t)par_err_reg;
 	} else {
 		par_err_reg = ra->ra_vaddr ? (volatile int *)ra->ra_vaddr :
-		    (volatile int *)mapiodev(ra->ra_paddr, sizeof(int),
+		    (volatile int *)mapiodev(ra->ra_reg, 0, sizeof(int),
 		    ca->ca_bustype);
 	}
 	printf("\n");
diff --git a/sys/arch/sparc/sparc/vm_machdep.c b/sys/arch/sparc/sparc/vm_machdep.c
index f825aa81acb..a4c3c9fa4c5 100644
--- a/sys/arch/sparc/sparc/vm_machdep.c
+++ b/sys/arch/sparc/sparc/vm_machdep.c
@@ -1,4 +1,4 @@
-/*	$NetBSD: vm_machdep.c,v 1.14 1995/06/26 22:46:04 pk Exp $ */
+/*	$NetBSD: vm_machdep.c,v 1.18 1995/12/11 12:44:39 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -88,8 +88,54 @@ pagemove(from, to, size)
 }
 
 /*
- * Map a range [va, va+len] in the given map to a kernel address
- * in DVMA space.
+ * Wrapper for dvma_mapin() in kernel space,
+ * so drivers need not include VM goo to get at kernel_map.
+ */
+caddr_t
+kdvma_mapin(va, len, canwait)
+	caddr_t	va;
+	int	len, canwait;
+{
+	return ((caddr_t)dvma_mapin(kernel_map, (vm_offset_t)va, len, canwait));
+}
+
+caddr_t
+dvma_malloc(len, kaddr, flags)
+	size_t	len;
+	void	*kaddr;
+	int	flags;
+{
+	vm_offset_t	kva;
+	vm_offset_t	dva;
+
+	kva = (vm_offset_t)malloc(len, M_DEVBUF, flags);
+	if (kva == NULL)
+		return (NULL);
+
+	*(vm_offset_t *)kaddr = kva;
+	dva = dvma_mapin(kernel_map, kva, len, (flags & M_NOWAIT) ? 0 : 1);
+	if (dva == NULL) {
+		free((void *)kva, M_DEVBUF);
+		return (NULL);
+	}
+	return (caddr_t)dva;
+}
+
+void
+dvma_free(dva, len, kaddr)
+	caddr_t	dva;
+	size_t	len;
+	void	*kaddr;
+{
+	vm_offset_t	kva = *(vm_offset_t *)kaddr;
+
+	dvma_mapout((vm_offset_t)dva, kva, len);
+	free((void *)kva, M_DEVBUF);
+}
+
+/*
+ * Map a range [va, va+len] of wired virtual addresses in the given map
+ * to a kernel address in DVMA space.
  */
 vm_offset_t
 dvma_mapin(map, va, len, canwait)
@@ -97,16 +143,23 @@ dvma_mapin(map, va, len, canwait)
 	vm_offset_t	va;
 	int		len, canwait;
 {
-	vm_offset_t	kva, tva, va_0 = va;
+	vm_offset_t	kva, tva;
 	register int npf, s;
 	register vm_offset_t pa;
-	long pn;
+	long off, pn;
 
-	npf = btoc(round_page(len));
+	off = (int)va & PGOFSET;
+	va -= off;
+	len = round_page(len + off);
+	npf = btoc(len);
+
+	kvm_uncache((caddr_t)va, len >> PGSHIFT);
 
 	s = splimp();
 	for (;;) {
+
 		pn = rmalloc(dvmamap, npf);
+
 		if (pn != 0)
 			break;
 		if (canwait) {
@@ -124,22 +177,33 @@ dvma_mapin(map, va, len, canwait)
 		pa = pmap_extract(vm_map_pmap(map), va);
 		if (pa == 0)
 			panic("dvma_mapin: null page frame");
-
+		pa = trunc_page(pa);
+
+#if defined(SUN4M) && 0
+		if (cputyp == CPU_SUN4M) {
+			iommu_enter(tva, pa);
+		} else
+#endif
+		{
 		/*
-		 * ###	pmap_enter distributes this mapping to all contexts...
-		 *      maybe we should avoid this extra work
+			 * pmap_enter distributes this mapping to all
+			 * contexts... maybe we should avoid this extra work
 		 */
+#ifdef notyet
+#if defined(SUN4)
+			if (have_iocache)
+				pa |= PG_IOC;
+#endif
+#endif
 		pmap_enter(pmap_kernel(), tva,
-		    trunc_page(pa) | PMAP_NC,
+				   pa | PMAP_NC,
 		    VM_PROT_READ|VM_PROT_WRITE, 1);
+		}
+
 		tva += PAGE_SIZE;
 		va += PAGE_SIZE;
 	}
-
-	if (vactype == VAC_WRITEBACK)
-		cache_flush((caddr_t)va_0, len); /* XXX only needed on write */
-
-	return kva;
+	return kva + off;
 }
 
 /*
@@ -150,8 +214,17 @@ dvma_mapout(kva, va, len)
 	vm_offset_t	kva, va;
 	int		len;
 {
-	register int s;
+	register int s, off;
+
+	off = (int)kva & PGOFSET;
+	kva -= off;
+	len = round_page(len + off);
 
+#if defined(SUN4M) && 0
+	if (cputyp == CPU_SUN4M)
+		iommu_remove(kva, len);
+	else
+#endif
 	pmap_remove(pmap_kernel(), kva, kva + len);
 
 	s = splimp();
@@ -169,20 +242,40 @@ dvma_mapout(kva, va, len)
 vmapbuf(bp)
 	register struct buf *bp;
 {
-	register int len;
-	register caddr_t addr;
+	register vm_offset_t addr, kva, pa;
+	register vm_size_t size, off;
+	register int npf;
 	struct proc *p;
-	int off;
-	vm_offset_t kva;
+	register struct vm_map *map;
 
 	if ((bp->b_flags & B_PHYS) == 0)
 		panic("vmapbuf");
-	addr = bp->b_saveaddr = bp->b_un.b_addr;
-	off = (int)addr & PGOFSET;
 	p = bp->b_proc;
-	len = round_page(bp->b_bcount + off);
-	kva = dvma_mapin(&p->p_vmspace->vm_map, addr-off, len, 1);
-	bp->b_un.b_addr = (caddr_t) (kva + off);
+	map = &p->p_vmspace->vm_map;
+	bp->b_saveaddr = bp->b_data;
+	addr = (vm_offset_t)bp->b_saveaddr;
+	off = addr & PGOFSET;
+	size = round_page(bp->b_bcount + off);
+	kva = kmem_alloc_wait(kernel_map, size);
+	bp->b_data = (caddr_t)(kva + off);
+	addr = trunc_page(addr);
+	npf = btoc(size);
+	while (npf--) {
+		pa = pmap_extract(vm_map_pmap(map), (vm_offset_t)addr);
+		if (pa == 0)
+			panic("vmapbuf: null page frame");
+
+		/*
+		 * pmap_enter distributes this mapping to all
+		 * contexts... maybe we should avoid this extra work
+		 */
+		pmap_enter(pmap_kernel(), kva,
+			   pa | PMAP_NC,
+			   VM_PROT_READ|VM_PROT_WRITE, 1);
+
+		addr += PAGE_SIZE;
+		kva += PAGE_SIZE;
+	}
 }
 
 /*
@@ -191,47 +284,20 @@ vmapbuf(bp)
 vunmapbuf(bp)
 	register struct buf *bp;
 {
-	register vm_offset_t kva = (vm_offset_t)bp->b_un.b_addr;
-	register int off, npf;
+	register vm_offset_t kva = (vm_offset_t)bp->b_data;
+	register vm_size_t size, off;
 
 	if ((bp->b_flags & B_PHYS) == 0)
 		panic("vunmapbuf");
 
-	bp->b_un.b_addr = bp->b_saveaddr;
+	kva = (vm_offset_t)bp->b_data;
+	off = kva & PGOFSET;
+	size = round_page(bp->b_bcount + off);
+	kmem_free_wakeup(kernel_map, trunc_page(kva), size);
+	bp->b_data = bp->b_saveaddr;
 	bp->b_saveaddr = NULL;
-
-	off = (int)kva & PGOFSET;
-	kva -= off;
-	dvma_mapout(kva, bp->b_un.b_addr, round_page(bp->b_bcount + off));
-}
-
-/*
- * Allocate physical memory space in the dvma virtual address range.
- */
-caddr_t
-dvma_malloc(size)
-	size_t size;
-{
-	vm_size_t vsize;
-	caddr_t va;
-
-	vsize = round_page(size);
-	va = (caddr_t)kmem_alloc(phys_map, vsize);
-	if (va == NULL)
-		panic("dvma_malloc");
-	kvm_uncache(va, vsize >> PGSHIFT);
-	return (va);
-}
-
-/*
- * Free dvma addresses allocated with dvma_malloc()
- */
-void
-dvma_free(ptr, size)
-	caddr_t ptr;
-	size_t size;
-{
-	kmem_free(phys_map, (vm_offset_t)ptr, size);
+	if (vactype != VAC_NONE)
+		cache_flush(bp->b_un.b_addr, bp->b_bcount - bp->b_resid);
 }