Mostly sync to NetBSD-current 970804.

GENERIC currently compiles and runs; some devices (isp) are not complete and
not yet enabled.

63 files changed, 3683 insertions, 2993 deletions

diff --git a/sys/arch/sparc/dev/amd7930.c b/sys/arch/sparc/dev/amd7930.c
index bb250924af1..998e89f5d1f 100644
--- a/sys/arch/sparc/dev/amd7930.c
+++ b/sys/arch/sparc/dev/amd7930.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: amd7930.c,v 1.8 1997/07/13 21:48:42 angelos Exp $	*/
+/*	$OpenBSD: amd7930.c,v 1.9 1997/08/08 08:24:37 downsj Exp $	*/
 /*	$NetBSD: amd7930.c,v 1.10 1996/03/31 22:38:29 pk Exp $	*/
 
 /*
@@ -304,8 +304,7 @@ amd7930attach(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_reg, 0, sizeof (*amd),
-					ca->ca_bustype));
+		ra->ra_vaddr : mapiodev(ra->ra_reg, 0, sizeof (*amd)));
 
 	sc->sc_map.mr_mmr1 = AMD_MMR1_GX | AMD_MMR1_GER |
 			     AMD_MMR1_GR | AMD_MMR1_STG;
diff --git a/sys/arch/sparc/dev/amd7930var.h b/sys/arch/sparc/dev/amd7930var.h
index 2d2e5f28257..8e6cf85e529 100644
--- a/sys/arch/sparc/dev/amd7930var.h
+++ b/sys/arch/sparc/dev/amd7930var.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: amd7930var.h,v 1.3 1997/08/08 08:24:38 downsj Exp $	*/
 /*	$NetBSD: amd7930var.h,v 1.3 1996/02/01 22:32:25 mycroft Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/bt_subr.c b/sys/arch/sparc/dev/bt_subr.c
index 2a1df0ad71b..11105ffa29d 100644
--- a/sys/arch/sparc/dev/bt_subr.c
+++ b/sys/arch/sparc/dev/bt_subr.c
@@ -1,3 +1,4 @@
+/*	$OpenBSD: bt_subr.c,v 1.3 1997/08/08 08:24:39 downsj Exp $	*/
 /*	$NetBSD: bt_subr.c,v 1.5 1996/03/14 19:44:32 christos Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/btreg.h b/sys/arch/sparc/dev/btreg.h
index aa3f5fbc0db..e146117c25b 100644
--- a/sys/arch/sparc/dev/btreg.h
+++ b/sys/arch/sparc/dev/btreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: btreg.h,v 1.3 1997/08/08 08:24:40 downsj Exp $	*/
 /*	$NetBSD: btreg.h,v 1.4 1996/02/27 22:09:21 thorpej Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/btvar.h b/sys/arch/sparc/dev/btvar.h
index 68be1189422..e08df3b8b1c 100644
--- a/sys/arch/sparc/dev/btvar.h
+++ b/sys/arch/sparc/dev/btvar.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: btvar.h,v 1.2 1997/08/08 08:24:41 downsj Exp $	*/
 /*	$NetBSD: btvar.h,v 1.2 1994/11/20 20:51:56 deraadt Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/bwtwo.c b/sys/arch/sparc/dev/bwtwo.c
index f629c0cffa4..e8f1177fea5 100644
--- a/sys/arch/sparc/dev/bwtwo.c
+++ b/sys/arch/sparc/dev/bwtwo.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: bwtwo.c,v 1.13 1996/08/13 08:05:18 downsj Exp $	*/
-/*	$NetBSD: bwtwo.c,v 1.26 1996/04/01 17:30:15 christos Exp $ */
+/*	$OpenBSD: bwtwo.c,v 1.14 1997/08/08 08:24:43 downsj Exp $	*/
+/*	$NetBSD: bwtwo.c,v 1.33 1997/05/24 20:16:02 pk Exp $ */
 
 /*
  * Copyright (c) 1996 Jason R. Thorpe.  All rights reserved.
@@ -105,14 +105,13 @@ struct bwtwo_softc {
 /* autoconfiguration driver */
 static void	bwtwoattach __P((struct device *, struct device *, void *));
 static int	bwtwomatch __P((struct device *, void *, void *));
-int		bwtwoopen __P((dev_t, int, int, struct proc *));
-int		bwtwoclose __P((dev_t, int, int, struct proc *));
-int		bwtwoioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		bwtwommap __P((dev_t, int, int));
 static void	bwtwounblank __P((struct device *));
 static void	bwtwo_set_video __P((struct bwtwo_softc *, int));
 static int	bwtwo_get_video __P((struct bwtwo_softc *));
 
+/* cdevsw prototypes */
+cdev_decl(bwtwo);
+
 struct cfattach bwtwo_ca = {
 	sizeof(struct bwtwo_softc), bwtwomatch, bwtwoattach
 };
@@ -212,14 +211,13 @@ bwtwoattach(parent, self, args)
 	 * Map the control register.
 	 */
 	if (fb->fb_flags & FB_PFOUR) {
-		fb->fb_pfour =
-		    (volatile u_int32_t *)mapiodev(ca->ca_ra.ra_reg, 0,
-		    sizeof(u_int32_t), ca->ca_bustype);
+		fb->fb_pfour = (volatile u_int32_t *)
+		    mapiodev(ca->ca_ra.ra_reg, 0, sizeof(u_int32_t));
 		sc->sc_reg = NULL;
 	} else {
-		sc->sc_reg =
-		    (volatile struct fbcontrol *)mapiodev(ca->ca_ra.ra_reg,
-		    BWREG_REG, sizeof(struct fbcontrol), ca->ca_bustype);
+		sc->sc_reg = (volatile struct fbcontrol *)
+		    mapiodev(ca->ca_ra.ra_reg, BWREG_REG,
+			     sizeof(struct fbcontrol));
 		fb->fb_pfour = NULL;
 	}
 
@@ -291,13 +289,13 @@ bwtwoattach(parent, self, args)
 #if defined(SUN4)
 	if (CPU_ISSUN4) {
 		struct eeprom *eep = (struct eeprom *)eeprom_va;
-		int constype = (fb->fb_flags & FB_PFOUR) ? EED_CONS_P4 :
-		    EED_CONS_BW;
+		int constype = (fb->fb_flags & FB_PFOUR) ? EE_CONS_P4OPT :
+		    EE_CONS_BW;
 		/*
 		 * Assume this is the console if there's no eeprom info
 		 * to be found.
 		 */
-		if (eep == NULL || eep->ee_diag.eed_console == constype)
+		if (eep == NULL || eep->eeConsole == constype)
 			isconsole = (fbconstty != NULL);
 		else
 			isconsole = 0;
@@ -316,8 +314,7 @@ bwtwoattach(parent, self, args)
 	if ((fb->fb_pixels = ca->ca_ra.ra_vaddr) == NULL && isconsole) {
 		/* this probably cannot happen (on sun4c), but what the heck */
 		fb->fb_pixels =
-		    mapiodev(ca->ca_ra.ra_reg, sc->sc_pixeloffset,
-		    ramsize, ca->ca_bustype);
+		    mapiodev(ca->ca_ra.ra_reg, sc->sc_pixeloffset, ramsize);
 	}
 
 	/* Insure video is enabled */
@@ -326,7 +323,16 @@ bwtwoattach(parent, self, args)
 	if (isconsole) {
 		printf(" (console)\n");
 #ifdef RASTERCONSOLE
-		fbrcons_init(fb);
+#if defined(SUN4)
+		/*
+		 * XXX rcons doesn't seem to work properly on the overlay
+		 * XXX plane.  This is a temporary kludge until someone
+		 * XXX fixes it.
+		 */
+		if ((fb->fb_flags & FB_PFOUR) == 0 ||
+		    (sc->sc_ovtype == BWO_NONE))
+#endif
+			fbrcons_init(fb);
 #endif
 	} else
 		printf("\n");
@@ -456,8 +462,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 (REG2PHYS(&sc->sc_phys, sc->sc_pixeloffset + off,
-	    sc->sc_bustype) | PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, sc->sc_pixeloffset + off) | PMAP_NC);
 }
 
 static int
diff --git a/sys/arch/sparc/dev/bwtworeg.h b/sys/arch/sparc/dev/bwtworeg.h
index 236f4a44929..f773d3c237e 100644
--- a/sys/arch/sparc/dev/bwtworeg.h
+++ b/sys/arch/sparc/dev/bwtworeg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: bwtworeg.h,v 1.3 1997/08/08 08:24:43 downsj Exp $	*/
 /*	$NetBSD: bwtworeg.h,v 1.3 1996/02/27 00:32:39 pk Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/cgeight.c b/sys/arch/sparc/dev/cgeight.c
index b720a24744a..48a1675266e 100644
--- a/sys/arch/sparc/dev/cgeight.c
+++ b/sys/arch/sparc/dev/cgeight.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: cgeight.c,v 1.7 1996/08/13 08:05:20 downsj Exp $	*/
-/*	$NetBSD: cgeight.c,v 1.7 1996/04/01 17:29:57 christos Exp $	*/
+/*	$OpenBSD: cgeight.c,v 1.8 1997/08/08 08:24:44 downsj Exp $	*/
+/*	$NetBSD: cgeight.c,v 1.13 1997/05/24 20:16:04 pk Exp $	*/
 
 /*
  * Copyright (c) 1996 Jason R. Thorpe.  All rights reserved.
@@ -91,14 +91,13 @@ struct cgeight_softc {
 /* autoconfiguration driver */
 static void	cgeightattach(struct device *, struct device *, void *);
 static int	cgeightmatch(struct device *, void *, void *);
-int		cgeightopen __P((dev_t, int, int, struct proc *));
-int		cgeightclose __P((dev_t, int, int, struct proc *));
-int		cgeightioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		cgeightmmap __P((dev_t, int, int));
 #if defined(SUN4)
 static void	cgeightunblank __P((struct device *));
 #endif
 
+/* cdevsw prototypes */
+cdev_decl(cgeight);
+
 struct cfattach cgeight_ca = {
 	sizeof(struct cgeight_softc), cgeightmatch, cgeightattach
 };
@@ -203,8 +202,8 @@ cgeightattach(parent, self, args)
 	}
 
 	/* Map the pfour register. */
-	fb->fb_pfour = (volatile u_int32_t *)mapiodev(ca->ca_ra.ra_reg, 0,
-	    sizeof(u_int32_t), ca->ca_bustype);
+	fb->fb_pfour = (volatile u_int32_t *)
+	    mapiodev(ca->ca_ra.ra_reg, 0, sizeof(u_int32_t));
 
 	ramsize = PFOUR_COLOR_OFF_END - PFOUR_COLOR_OFF_OVERLAY;
 
@@ -225,7 +224,7 @@ cgeightattach(parent, self, args)
 		 * Assume this is the console if there's no eeprom info
 		 * to be found.
 		 */
-		if (eep == NULL || eep->ee_diag.eed_console == EED_CONS_P4)
+		if (eep == NULL || eep->eeConsole == EE_CONS_P4OPT)
 			isconsole = (fbconstty != NULL);
 	}
 
@@ -248,13 +247,14 @@ cgeightattach(parent, self, args)
 	if (isconsole) {
 		/* XXX this is kind of a waste */
 		fb->fb_pixels = mapiodev(ca->ca_ra.ra_reg,
-		    PFOUR_COLOR_OFF_OVERLAY, ramsize, ca->ca_bustype);
+					 PFOUR_COLOR_OFF_OVERLAY, ramsize);
 	}
 #endif
 
 	/* Map the Brooktree. */
-	sc->sc_fbc = (volatile struct fbcontrol *)mapiodev(ca->ca_ra.ra_reg,
-	    PFOUR_COLOR_OFF_CMAP, sizeof(struct fbcontrol), ca->ca_bustype);
+	sc->sc_fbc = (volatile struct fbcontrol *)
+	    mapiodev(ca->ca_ra.ra_reg,
+		     PFOUR_COLOR_OFF_CMAP, sizeof(struct fbcontrol));
 
 	sc->sc_phys = ca->ca_ra.ra_reg[0];
 	sc->sc_bustype = ca->ca_bustype;
@@ -405,7 +405,7 @@ cgeightmmap(dev, off, prot)
 		panic("cgeightmap");
 
 	if ((u_int)off >= NOOVERLAY) {
-		off =- NOOVERLAY;
+		off -= NOOVERLAY;
 
 		/*
 		 * X11 maps a huge chunk of the frame buffer; far more than
@@ -426,7 +426,7 @@ cgeightmmap(dev, off, prot)
 		 * in enable plane
 		 */
 		poff = (off - START_ENABLE) + PFOUR_COLOR_OFF_ENABLE;
-	} else if ((u_int)off < END_COLOR) {
+	} else if ((u_int)off < sc->sc_fb.fb_type.fb_size) {
 		/*
 		 * in colour plane
 		 */
@@ -458,7 +458,7 @@ 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 (REG2PHYS(&sc->sc_phys, poff, sc->sc_bustype) | PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, poff) | PMAP_NC);
 }
 
 #if defined(SUN4)
diff --git a/sys/arch/sparc/dev/cgeightreg.h b/sys/arch/sparc/dev/cgeightreg.h
deleted file mode 100644
index 1fac1d4227c..00000000000
--- a/sys/arch/sparc/dev/cgeightreg.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*	$NetBSD: cgeightreg.h,v 1.4 1994/11/20 20:52:03 deraadt Exp $ */
-
-/*
- * Copyright (c) 1995 Theo de Raadt
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by Theo de Raadt.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * cgeight display registers.  Much like bwtwo registers, except that
- * there is a Brooktree Video DAC in there (so we also use btreg.h).
- */
-
-/* offsets */
-#define CG8REG_CMAP	0x200000
-#define CG8REG_P4REG	0x300000
-#define	CG8REG_OVERLAY	0x400000
-#define	CG8REG_ENABLE	0x600000
-#define	CG8REG_COLOUR	0x800000
-#define	CG8REG_END	0xa00000
-
-/* same, but for gdb */
-struct cgeight_all {
-	char	ba_nothing[0x200000];
-	struct	bt_regs ba_btreg;	/* Brooktree registers */
-	char	ba_xxx1[0x100000-sizeof(struct bt_regs)];
-	char	ba_pfourreg[0x100000];
-	char	ba_overlay[0x200000];
-	char	ba_enable[0x200000];
-	char	ba_color[0x200000];
-};
diff --git a/sys/arch/sparc/dev/cgfour.c b/sys/arch/sparc/dev/cgfour.c
index 279d1cb0fea..4284b1c5781 100644
--- a/sys/arch/sparc/dev/cgfour.c
+++ b/sys/arch/sparc/dev/cgfour.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: cgfour.c,v 1.7 1996/08/13 08:05:21 downsj Exp $	*/
-/*	$NetBSD: cgfour.c,v 1.7 1996/04/01 17:29:58 christos Exp $	*/
+/*	$OpenBSD: cgfour.c,v 1.8 1997/08/08 08:24:46 downsj Exp $	*/
+/*	$NetBSD: cgfour.c,v 1.13 1997/05/24 20:16:06 pk Exp $	*/
 
 /*
  * Copyright (c) 1996 Jason R. Thorpe.  All rights reserved.
@@ -95,14 +95,13 @@ struct cgfour_softc {
 /* autoconfiguration driver */
 static void	cgfourattach __P((struct device *, struct device *, void *));
 static int	cgfourmatch __P((struct device *, void *, void *));
-int		cgfouropen __P((dev_t, int, int, struct proc *));
-int		cgfourclose __P((dev_t, int, int, struct proc *));
-int		cgfourioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		cgfourmmap __P((dev_t, int, int));
 #if defined(SUN4)
 static void	cgfourunblank __P((struct device *));
 #endif
 
+/* cdevsw prototypes */
+cdev_decl(cgfour);
+
 struct cfattach cgfour_ca = {
 	sizeof(struct cgfour_softc), cgfourmatch, cgfourattach
 };
@@ -207,8 +206,8 @@ cgfourattach(parent, self, args)
 	}
 
 	/* Map the pfour register. */
-	fb->fb_pfour = (volatile u_int32_t *)mapiodev(ca->ca_ra.ra_reg, 0,
-	    sizeof(u_int32_t), ca->ca_bustype);
+	fb->fb_pfour = (volatile u_int32_t *)
+		mapiodev(ca->ca_ra.ra_reg, 0, sizeof(u_int32_t));
 
 	ramsize = PFOUR_COLOR_OFF_END - PFOUR_COLOR_OFF_OVERLAY;
 
@@ -229,7 +228,7 @@ cgfourattach(parent, self, args)
 		 * Assume this is the console if there's no eeprom info
 		 * to be found.
 		 */
-		if (eep == NULL || eep->ee_diag.eed_console == EED_CONS_P4)
+		if (eep == NULL || eep->eeConsole == EE_CONS_P4OPT)
 			isconsole = (fbconstty != NULL);
 	}
 
@@ -252,13 +251,14 @@ cgfourattach(parent, self, args)
 	if (isconsole) {
 		/* XXX this is kind of a waste */
 		fb->fb_pixels = mapiodev(ca->ca_ra.ra_reg,
-		    PFOUR_COLOR_OFF_OVERLAY, ramsize, ca->ca_bustype);
+					 PFOUR_COLOR_OFF_OVERLAY, ramsize);
 	}
 #endif
 
 	/* Map the Brooktree. */
-	sc->sc_fbc = (volatile struct fbcontrol *)mapiodev(ca->ca_ra.ra_reg,
-	    PFOUR_COLOR_OFF_CMAP, sizeof(struct fbcontrol), ca->ca_bustype);
+	sc->sc_fbc = (volatile struct fbcontrol *)
+		mapiodev(ca->ca_ra.ra_reg,
+			 PFOUR_COLOR_OFF_CMAP, sizeof(struct fbcontrol));
 
 	sc->sc_phys = ca->ca_ra.ra_reg[0];
 	sc->sc_bustype = ca->ca_bustype;
@@ -403,7 +403,7 @@ cgfourmmap(dev, off, prot)
 		panic("cgfourmap");
 
 	if ((u_int)off >= NOOVERLAY) {
-		off =- NOOVERLAY;
+		off -= NOOVERLAY;
 
 		/*
 		 * X11 maps a huge chunk of the frame buffer; far more than
@@ -424,7 +424,7 @@ cgfourmmap(dev, off, prot)
 		 * in enable plane
 		 */
 		poff = (off - START_ENABLE) + PFOUR_COLOR_OFF_ENABLE;
-	} else if ((u_int)off < END_COLOR) {
+	} else if ((u_int)off < sc->sc_fb.fb_type.fb_size) {
 		/*
 		 * in colour plane
 		 */
@@ -432,7 +432,7 @@ cgfourmmap(dev, off, prot)
 	} else
 		return (-1);
 
-	return (REG2PHYS(&sc->sc_phys, poff, sc->sc_bustype) | PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, poff) | PMAP_NC);
 }
 
 #if defined(SUN4)
diff --git a/sys/arch/sparc/dev/cgfourteen.c b/sys/arch/sparc/dev/cgfourteen.c
new file mode 100644
index 00000000000..2786bb6a9ff
--- /dev/null
+++ b/sys/arch/sparc/dev/cgfourteen.c
@@ -0,0 +1,877 @@
+/*	$OpenBSD: cgfourteen.c,v 1.1 1997/08/08 08:24:48 downsj Exp $	*/
+/*	$NetBSD: cgfourteen.c,v 1.7 1997/05/24 20:16:08 pk Exp $ */
+
+/*
+ * Copyright (c) 1996 
+ *	The President and Fellows of Harvard College. All rights reserved.
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This software was developed by the Computer Systems Engineering group
+ * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
+ * contributed to Berkeley.
+ *
+ * All advertising materials mentioning features or use of this software
+ * must display the following acknowledgement:
+ *	This product includes software developed by Harvard University.
+ *	This product includes software developed by the University of
+ *	California, Lawrence Berkeley Laboratory.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ *	This product includes software developed by Harvard University and
+ *	its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *   Based on:
+ *	NetBSD: cgthree.c,v 1.28 1996/05/31 09:59:22 pk Exp
+ *	NetBSD: cgsix.c,v 1.25 1996/04/01 17:30:00 christos Exp
+ */
+
+/*
+ * Driver for Campus-II on-board mbus-based video (cgfourteen).
+ * Provides minimum emulation of a Sun cgthree 8-bit framebuffer to
+ * allow X to run.
+ *
+ * Does not handle interrupts, even though they can occur.
+ *
+ * XXX should defer colormap updates to vertical retrace interrupts
+ */
+
+/* 
+ * The following is for debugging only; it opens up a security hole
+ * enabled by allowing any user to map the control registers for the 
+ * cg14 into their space.
+ */
+#undef CG14_MAP_REGS
+
+/*
+ * The following enables 24-bit operation: when opened, the framebuffer
+ * will switch to 24-bit mode (actually 32-bit mode), and provide a 
+ * simple cg8 emulation.
+ *
+ * XXX Note that the code enabled by this define is currently untested/broken.
+ */
+#undef CG14_CG8
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/device.h>
+#include <sys/ioctl.h>
+#include <sys/malloc.h>
+#include <sys/mman.h>
+#include <sys/tty.h>
+#include <sys/conf.h>
+
+#include <vm/vm.h>
+
+#include <machine/fbio.h>
+#include <machine/autoconf.h>
+#include <machine/pmap.h>
+#include <machine/fbvar.h>
+#include <machine/cpu.h>
+#include <machine/conf.h>
+
+#include <sparc/dev/cgfourteenreg.h>
+#include <sparc/dev/cgfourteenvar.h>
+
+/* autoconfiguration driver */
+static void	cgfourteenattach(struct device *, struct device *, void *);
+static int	cgfourteenmatch(struct device *, void *, void *);
+static void	cgfourteenunblank(struct device *);
+
+/* cdevsw prototypes */
+cdev_decl(cgfourteen);
+
+struct cfattach cgfourteen_ca = {
+	sizeof(struct cgfourteen_softc), cgfourteenmatch, cgfourteenattach
+};
+
+struct cfdriver cgfourteen_cd = {
+	NULL, "cgfourteen", DV_DULL
+};
+
+/* frame buffer generic driver */
+static struct fbdriver cgfourteenfbdriver = {
+	cgfourteenunblank, cgfourteenopen, cgfourteenclose, cgfourteenioctl, 
+	cgfourteenmmap
+};
+
+extern int fbnode;
+extern struct tty *fbconstty;
+
+static void cg14_set_video __P((struct cgfourteen_softc *, int));
+static int  cg14_get_video __P((struct cgfourteen_softc *));
+static int  cg14_get_cmap __P((struct fbcmap *, union cg14cmap *, int));
+static int  cg14_put_cmap __P((struct fbcmap *, union cg14cmap *, int));
+static void cg14_load_hwcmap __P((struct cgfourteen_softc *, int, int));
+static void cg14_init __P((struct cgfourteen_softc *));
+static void cg14_reset __P((struct cgfourteen_softc *));
+static void cg14_loadomap __P((struct cgfourteen_softc *));/* cursor overlay */
+static void cg14_setcursor __P((struct cgfourteen_softc *));/* set position */
+static void cg14_loadcursor __P((struct cgfourteen_softc *));/* set shape */
+
+/*
+ * Match a cgfourteen.
+ */
+int
+cgfourteenmatch(parent, vcf, aux)
+	struct device *parent;
+	void *vcf, *aux;
+{
+	struct cfdata *cf = vcf;
+	struct confargs *ca = aux;
+	struct romaux *ra = &ca->ca_ra;
+
+	/*
+	 * Mask out invalid flags from the user.
+	 */
+	cf->cf_flags &= FB_USERMASK;
+
+	/* Check driver name */
+	if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
+		return (0);
+
+	/*
+	 * The cgfourteen is a local-bus video adaptor, accessed directly
+	 * via the processor, and not through device space or an external
+	 * bus. Thus we look _only_ at the obio bus.
+	 * Additionally, these things exist only on the Sun4m.
+	 */
+	if (CPU_ISSUN4M && ca->ca_bustype == BUS_OBIO)
+		return(1);
+	return (0);
+}
+
+/*
+ * Attach a display.  We need to notice if it is the console, too.
+ */
+void
+cgfourteenattach(parent, self, args)
+	struct device *parent, *self;
+	void *args;
+{
+	register struct cgfourteen_softc *sc = (struct cgfourteen_softc *)self;
+	register struct confargs *ca = args;
+	register int node = 0, ramsize;
+	register u_int32_t *lut;
+	int i, isconsole;
+
+	sc->sc_fb.fb_driver = &cgfourteenfbdriver;
+	sc->sc_fb.fb_device = &sc->sc_dev;
+	sc->sc_fb.fb_flags = sc->sc_dev.dv_cfdata->cf_flags;
+
+	/*
+	 * We're emulating a cg3/8, so represent ourselves as one
+	 */
+#ifdef CG14_CG8
+	sc->sc_fb.fb_type.fb_type = FBTYPE_MEMCOLOR;
+#else
+	sc->sc_fb.fb_type.fb_type = FBTYPE_SUN3COLOR;
+#endif
+
+	node = ca->ca_ra.ra_node;
+#ifdef CG14_CG8
+	sc->sc_fb.fb_type.fb_depth = 32;
+#else
+	sc->sc_fb.fb_type.fb_depth = 8;
+#endif
+	fb_setsize(&sc->sc_fb, sc->sc_fb.fb_type.fb_depth,
+	    1152, 900, node, ca->ca_bustype);
+
+	ramsize = roundup(sc->sc_fb.fb_type.fb_height * sc->sc_fb.fb_linebytes,
+		NBPG);
+
+	sc->sc_fb.fb_type.fb_cmsize = CG14_CLUT_SIZE;
+	sc->sc_fb.fb_type.fb_size = ramsize;
+
+	/*
+	 * Now map in the 8 useful pages of registers
+	 */
+	if (ca->ca_ra.ra_len < 0x10000) {
+#ifdef DIAGNOSTIC
+		printf("warning: can't find all cgfourteen registers...\n");
+#endif
+		ca->ca_ra.ra_len = 0x10000;
+	}
+	sc->sc_ctl = (struct cg14ctl *) mapiodev(ca->ca_ra.ra_reg, 0, 
+						 ca->ca_ra.ra_len);
+
+	sc->sc_hwc = (struct cg14curs *) ((u_int)sc->sc_ctl + 
+					  CG14_OFFSET_CURS);
+	sc->sc_dac = (struct cg14dac *) ((u_int)sc->sc_ctl +
+					 CG14_OFFSET_DAC);
+	sc->sc_xlut = (struct cg14xlut *) ((u_int)sc->sc_ctl +
+					   CG14_OFFSET_XLUT);
+	sc->sc_clut1 = (struct cg14clut *) ((u_int)sc->sc_ctl +
+					    CG14_OFFSET_CLUT1);
+	sc->sc_clut2 = (struct cg14clut *) ((u_int)sc->sc_ctl +
+					    CG14_OFFSET_CLUT2);
+	sc->sc_clut3 = (struct cg14clut *) ((u_int)sc->sc_ctl +
+					    CG14_OFFSET_CLUT3);
+	sc->sc_clutincr = (u_int *) ((u_int)sc->sc_ctl +
+				     CG14_OFFSET_CLUTINCR);
+	
+	/*
+	 * Stash the physical address of the framebuffer for use by mmap
+	 */
+	if (ca->ca_ra.ra_nreg < 2)
+		panic("cgfourteen with only one register set; can't find"
+		      " framebuffer");
+	sc->sc_phys = ca->ca_ra.ra_reg[1];
+
+#if defined(DEBUG) && defined(CG14_MAP_REGS)
+	/* Store the physical address of the control registers */
+	sc->sc_regphys = ca->ca_ra.ra_reg[0];
+#endif
+
+	/*
+	 * Let the user know that we're here
+	 */
+#ifdef CG14_CG8
+	printf(": cgeight emulated at %dx%dx24bpp",
+	    sc->sc_fb.fb_type.fb_width, sc->sc_fb.fb_type.fb_height);
+#else
+	printf(": cgthree emulated at %dx%dx8bpp",
+	       sc->sc_fb.fb_type.fb_width, sc->sc_fb.fb_type.fb_height);
+#endif
+	/*
+	 * Enable the video, but don't change the pixel depth.
+	 */
+	cg14_set_video(sc, 1);
+
+	/*
+	 * Grab the initial colormap
+	 */
+	lut = (u_int32_t *) sc->sc_clut1->clut_lut;
+	for (i = 0; i < CG14_CLUT_SIZE; i++)
+		sc->sc_cmap.cm_chip[i] = lut[i];
+
+	/* See if we're the console */
+	isconsole = node == fbnode && fbconstty != NULL;
+
+	/*
+	 * We don't use the raster console since the cg14 is fast enough
+	 * already.
+	 */
+#ifdef notdef
+	/*
+	 * When the ROM has mapped in a cgfourteen display, the address
+	 * maps only the video RAM, so in any case we have to map the
+	 * registers ourselves.  We only need the video RAM if we are
+	 * going to print characters via rconsole.
+	 */
+	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(ca->ca_ra.ra_reg, CG3REG_MEM,
+					       ramsize);
+	}
+#endif /* notdef */
+
+
+	if (isconsole) {
+		printf(" (console)\n");
+#ifdef notdef
+#ifdef RASTERCONSOLE
+		fbrcons_init(&sc->sc_fb);
+#endif
+#endif /* notdef */
+	} else
+		printf("\n");
+
+	/* Attach to /dev/fb */
+	if (node == fbnode)
+		fb_attach(&sc->sc_fb, isconsole);
+}
+
+/*
+ * Keep track of the number of opens made. In the 24-bit driver, we need to 
+ * switch to 24-bit mode on the first open, and switch back to 8-bit on
+ * the last close. This kind of nonsense is needed to give screenblank
+ * a fighting chance of working.
+ */
+static int cg14_opens = 0;
+
+int
+cgfourteenopen(dev, flags, mode, p)
+	dev_t dev;
+	int flags, mode;
+	struct proc *p;
+{
+	register struct cgfourteen_softc *sc = cgfourteen_cd.cd_devs[minor(dev)];
+	int unit = minor(dev);
+	int s, oldopens;
+
+	if (unit >= cgfourteen_cd.cd_ndevs || 
+	    cgfourteen_cd.cd_devs[unit] == NULL)
+		return (ENXIO);
+
+	s = splhigh();
+	oldopens = cg14_opens++;
+	splx(s);
+
+	/* Setup the cg14 as we want it, and save the original PROM state */
+	if (oldopens == 0)	/* first open only, to make screenblank work */
+		cg14_init(sc);
+
+	return (0);
+}
+
+int
+cgfourteenclose(dev, flags, mode, p)
+	dev_t dev;
+	int flags, mode;
+	struct proc *p;
+{
+	register struct cgfourteen_softc *sc = cgfourteen_cd.cd_devs[minor(dev)];
+	int s, opens;
+
+	s = splhigh();
+	opens = --cg14_opens;
+	if (cg14_opens < 0)
+		opens = cg14_opens = 0;
+	splx(s);
+
+	/*
+	 * Restore video state to make the PROM happy, on last close.
+	 */
+	if (opens == 0)
+		cg14_reset(sc);
+
+	return (0);
+}
+
+int
+cgfourteenioctl(dev, cmd, data, flags, p)
+	dev_t dev;
+	u_long cmd;
+	register caddr_t data;
+	int flags;
+	struct proc *p;
+{
+	register struct cgfourteen_softc *sc = cgfourteen_cd.cd_devs[minor(dev)];
+	register struct fbgattr *fba;
+	union cg14cursor_cmap tcm;
+	int v, error;
+	u_int count;
+
+	switch (cmd) {
+
+	case FBIOGTYPE:
+		*(struct fbtype *)data = sc->sc_fb.fb_type;
+		break;
+
+	case FBIOGATTR:
+		fba = (struct fbgattr *)data;
+		fba->real_type = FBTYPE_MDICOLOR;
+		fba->owner = 0;		/* XXX ??? */
+		fba->fbtype = sc->sc_fb.fb_type;
+		fba->sattr.flags = 0;
+		fba->sattr.emu_type = sc->sc_fb.fb_type.fb_type;
+		fba->sattr.dev_specific[0] = -1;
+		fba->emu_types[0] = sc->sc_fb.fb_type.fb_type;
+		fba->emu_types[1] = -1;
+		break;
+
+	case FBIOGETCMAP:
+		return (cg14_get_cmap((struct fbcmap *)data, &sc->sc_cmap, 
+				     CG14_CLUT_SIZE));
+
+	case FBIOPUTCMAP:
+		/* copy to software map */
+#define p ((struct fbcmap *)data)
+#ifdef CG14_CG8
+		p->index &= 0xffffff;
+#endif
+		error = cg14_put_cmap(p, &sc->sc_cmap, CG14_CLUT_SIZE);
+		if (error)
+			return (error);
+		/* now blast them into the chip */
+		/* XXX should use retrace interrupt */
+		cg14_load_hwcmap(sc, p->index, p->count);
+#undef p
+		break;
+
+	case FBIOGVIDEO:
+		*(int *)data = cg14_get_video(sc);
+		break;
+
+	case FBIOSVIDEO:
+		cg14_set_video(sc, *(int *)data);
+		break;
+
+/* these are for both FBIOSCURSOR and FBIOGCURSOR */
+#define p ((struct fbcursor *)data)
+#define cc (&sc->sc_cursor)
+	case FBIOGCURSOR:
+		/* do not quite want everything here... */
+		p->set = FB_CUR_SETALL;	/* close enough, anyway */
+		p->enable = cc->cc_enable;
+		p->pos = cc->cc_pos;
+		p->hot = cc->cc_hot;
+		p->size = cc->cc_size;
+
+		/* begin ugh ... can we lose some of this crap?? */
+		if (p->image != NULL) {
+			count = cc->cc_size.y * 32 / NBBY;
+			error = copyout((caddr_t)cc->cc_cplane,
+			    (caddr_t)p->image, count);
+			if (error)
+				return (error);
+			error = copyout((caddr_t)cc->cc_eplane,
+			    (caddr_t)p->mask, count);
+			if (error)
+				return (error);
+		}
+		if (p->cmap.red != NULL) {
+			error = cg14_get_cmap(&p->cmap,
+			    (union cg14cmap *)&cc->cc_color, 2);
+			if (error)
+				return (error);
+		} else {
+			p->cmap.index = 0;
+			p->cmap.count = 2;
+		}
+		/* end ugh */
+		break;
+
+	case FBIOSCURSOR:
+		/*
+		 * For setcmap and setshape, verify parameters, so that
+		 * we do not get halfway through an update and then crap
+		 * out with the software state screwed up.
+		 */
+		v = p->set;
+		if (v & FB_CUR_SETCMAP) {
+			/*
+			 * This use of a temporary copy of the cursor
+			 * colormap is not terribly efficient, but these
+			 * copies are small (8 bytes)...
+			 */
+			tcm = cc->cc_color;
+			error = cg14_put_cmap(&p->cmap, (union cg14cmap *)&tcm,
+					      2);
+			if (error)
+				return (error);
+		}
+		if (v & FB_CUR_SETSHAPE) {
+			if ((u_int)p->size.x > 32 || (u_int)p->size.y > 32)
+				return (EINVAL);
+			count = p->size.y * 32 / NBBY;
+			if (!useracc(p->image, count, B_READ) ||
+			    !useracc(p->mask, count, B_READ))
+				return (EFAULT);
+		}
+
+		/* parameters are OK; do it */
+		if (v & (FB_CUR_SETCUR | FB_CUR_SETPOS | FB_CUR_SETHOT)) {
+			if (v & FB_CUR_SETCUR)
+				cc->cc_enable = p->enable;
+			if (v & FB_CUR_SETPOS)
+				cc->cc_pos = p->pos;
+			if (v & FB_CUR_SETHOT)
+				cc->cc_hot = p->hot;
+			cg14_setcursor(sc);
+		}
+		if (v & FB_CUR_SETCMAP) {
+			cc->cc_color = tcm;
+			cg14_loadomap(sc); /* XXX defer to vertical retrace */
+		}
+		if (v & FB_CUR_SETSHAPE) {
+			cc->cc_size = p->size;
+			count = p->size.y * 32 / NBBY;
+			bzero((caddr_t)cc->cc_eplane, sizeof cc->cc_eplane);
+			bzero((caddr_t)cc->cc_cplane, sizeof cc->cc_cplane);
+			bcopy(p->mask, (caddr_t)cc->cc_eplane, count);
+			bcopy(p->image, (caddr_t)cc->cc_cplane, count);
+			cg14_loadcursor(sc);
+		}
+		break;
+
+#undef cc
+#undef p
+	case FBIOGCURPOS:
+		*(struct fbcurpos *)data = sc->sc_cursor.cc_pos;
+		break;
+
+	case FBIOSCURPOS:
+		sc->sc_cursor.cc_pos = *(struct fbcurpos *)data;
+		cg14_setcursor(sc);
+		break;
+
+	case FBIOGCURMAX:
+		/* max cursor size is 32x32 */
+		((struct fbcurpos *)data)->x = 32;
+		((struct fbcurpos *)data)->y = 32;
+		break;
+
+	default:
+		return (ENOTTY);
+	}
+	return (0);
+}
+
+/*
+ * Undo the effect of an FBIOSVIDEO that turns the video off.
+ */
+static void
+cgfourteenunblank(dev)
+	struct device *dev;
+{
+
+	cg14_set_video((struct cgfourteen_softc *)dev, 1);
+}
+
+/*
+ * Return the address that would map the given device at the given
+ * offset, allowing for the given protection, or return -1 for error.
+ *
+ * The cg14 frame buffer can be mapped in either 8-bit or 32-bit mode
+ * starting at the address stored in the PROM. In 8-bit mode, the X
+ * channel is not present, and can be ignored. In 32-bit mode, mapping
+ * at 0K delivers a 32-bpp buffer where the upper 8 bits select the X
+ * channel information. We hardwire the Xlut to all zeroes to insure
+ * that, regardless of this value, direct 24-bit color access will be
+ * used.
+ * 
+ * Alternatively, mapping the frame buffer at an offset of 16M seems to 
+ * tell the chip to ignore the X channel. XXX where does it get the X value
+ * to use?
+ */
+int
+cgfourteenmmap(dev, off, prot)
+	dev_t dev;
+	int off, prot;
+{
+	register struct cgfourteen_softc *sc = cgfourteen_cd.cd_devs[minor(dev)];
+	
+#define CG3START		(128*1024 + 128*1024)
+#define CG8START		(256*1024)
+#define NOOVERLAY	(0x04000000)
+
+	if (off & PGOFSET)
+		panic("cgfourteenmmap");
+
+#if defined(DEBUG) && defined(CG14_MAP_REGS) /* XXX: security hole */
+	/*
+	 * Map the control registers into user space. Should only be 
+	 * used for debugging!
+	 */
+	if ((u_int)off >= 0x10000000 && (u_int)off < 0x10000000 + 16*4096) {
+		off -= 0x10000000;
+		return (REG2PHYS(&sc->sc_regphys, off, 0) | PMAP_NC);
+	}
+#endif
+	
+	if ((u_int)off >= NOOVERLAY)
+		off -= NOOVERLAY;
+#ifdef CG14_CG8
+	else if ((u_int)off >= CG8START) {
+		off -= CG8START;
+	}
+#else
+	else if ((u_int)off >= CG3START)
+		off -= CG3START;
+#endif
+	else
+		off = 0;
+
+	if ((unsigned)off >= sc->sc_fb.fb_type.fb_size *
+		sc->sc_fb.fb_type.fb_depth/8) {
+#ifdef DEBUG
+		printf("\nmmap request out of bounds: request 0x%x, "
+		    "bound 0x%x\n", (unsigned) off, 
+		    (unsigned)sc->sc_fb.fb_type.fb_size);
+#endif
+		return (-1);
+	}
+
+	/*
+	 * Use PMAP_NC to disable the cache, since otherwise refresh is
+	 * very confused.
+	 */
+	return (REG2PHYS(&sc->sc_phys, off) | PMAP_NC);
+}
+
+/*
+ * Miscellaneous helper functions 
+ */
+
+/* Initialize the framebuffer, storing away useful state for later reset */
+static void 
+cg14_init(sc)
+	struct cgfourteen_softc *sc;
+{
+	register u_int32_t *clut;
+	register u_int8_t  *xlut;
+	register int i;
+
+	/*
+	 * We stash away the following to restore on close:
+	 *
+	 * 	color look-up table 1 	(sc->sc_saveclut)
+	 *	x look-up table		(sc->sc_savexlut)
+	 *	control register	(sc->sc_savectl)
+	 *	cursor control register (sc->sc_savehwc)
+	 */
+	sc->sc_savectl = sc->sc_ctl->ctl_mctl;
+	sc->sc_savehwc = sc->sc_hwc->curs_ctl;
+
+	clut = (u_int32_t *) sc->sc_clut1->clut_lut;
+	xlut = (u_int8_t *) sc->sc_xlut->xlut_lut;
+	for (i = 0; i < CG14_CLUT_SIZE; i++) {
+		sc->sc_saveclut.cm_chip[i] = clut[i];
+		sc->sc_savexlut[i] = xlut[i];
+	}
+
+#ifdef CG14_CG8
+	/*
+	 * Enable the video, and put in 24 bit mode.
+	 */
+	sc->sc_ctl->ctl_mctl = CG14_MCTL_ENABLEVID | CG14_MCTL_PIXMODE_32 |
+		CG14_MCTL_POWERCTL;
+
+	/* 
+	 * Zero the xlut to enable direct-color mode
+	 */
+	bzero(sc->sc_xlut, CG14_CLUT_SIZE);
+#else
+	/*
+	 * Enable the video and put it in 8 bit mode
+	 */
+	sc->sc_ctl->ctl_mctl = CG14_MCTL_ENABLEVID | CG14_MCTL_PIXMODE_8 |
+		CG14_MCTL_POWERCTL;
+#endif
+}
+
+static void
+cg14_reset(sc)	/* Restore the state saved on cg14_init */
+	struct cgfourteen_softc *sc;
+{
+	register u_int32_t *clut;
+	register u_int8_t  *xlut;
+	register int i;
+
+	/*
+	 * We restore the following, saved in cg14_init:
+	 *
+	 * 	color look-up table 1 	(sc->sc_saveclut)
+	 *	x look-up table		(sc->sc_savexlut)
+	 *	control register	(sc->sc_savectl)
+	 *	cursor control register (sc->sc_savehwc)
+	 *
+	 * Note that we don't touch the video enable bits in the
+	 * control register; otherwise, screenblank wouldn't work.
+	 */
+	sc->sc_ctl->ctl_mctl = (sc->sc_ctl->ctl_mctl & (CG14_MCTL_ENABLEVID |
+							CG14_MCTL_POWERCTL)) |
+				(sc->sc_savectl & ~(CG14_MCTL_ENABLEVID |
+						    CG14_MCTL_POWERCTL));
+	sc->sc_hwc->curs_ctl = sc->sc_savehwc;
+
+	clut = (u_int32_t *) sc->sc_clut1->clut_lut;
+	xlut = (u_int8_t *) sc->sc_xlut->xlut_lut;
+	for (i = 0; i < CG14_CLUT_SIZE; i++) {
+		clut[i] = sc->sc_saveclut.cm_chip[i];
+		xlut[i] = sc->sc_savexlut[i];
+	}
+}
+
+/* Enable/disable video display; power down monitor if DPMS-capable */
+static void
+cg14_set_video(sc, enable)
+	struct cgfourteen_softc *sc;
+	int enable;
+{
+	/* 
+	 * We can only use DPMS to power down the display if the chip revision
+	 * is greater than 0.
+	 */
+	if (enable) {
+		if ((sc->sc_ctl->ctl_rsr & CG14_RSR_REVMASK) > 0)
+			sc->sc_ctl->ctl_mctl |= (CG14_MCTL_ENABLEVID |
+						 CG14_MCTL_POWERCTL);
+		else
+			sc->sc_ctl->ctl_mctl |= CG14_MCTL_ENABLEVID;
+	} else {
+		if ((sc->sc_ctl->ctl_rsr & CG14_RSR_REVMASK) > 0)
+			sc->sc_ctl->ctl_mctl &= ~(CG14_MCTL_ENABLEVID |
+						  CG14_MCTL_POWERCTL);
+		else
+			sc->sc_ctl->ctl_mctl &= ~CG14_MCTL_ENABLEVID;
+	}
+}
+
+/* Get status of video display */
+static int
+cg14_get_video(sc)
+	struct cgfourteen_softc *sc;
+{
+	return ((sc->sc_ctl->ctl_mctl & CG14_MCTL_ENABLEVID) != 0);
+}
+
+/* Read the software shadow colormap */
+static int 
+cg14_get_cmap(p, cm, cmsize)
+	register struct fbcmap *p;
+	union cg14cmap *cm;
+	int cmsize;
+{
+        register u_int i, start, count;
+        register u_char *cp;
+ 
+        start = p->index;
+        count = p->count;
+        if (start >= cmsize || start + count > cmsize)
+#ifdef DEBUG
+	{
+		printf("putcmaperror: start %d cmsize %d count %d\n",
+		    start,cmsize,count);
+#endif
+                return (EINVAL);
+#ifdef DEBUG
+	}
+#endif
+
+        if (!useracc(p->red, count, B_WRITE) ||
+            !useracc(p->green, count, B_WRITE) ||
+            !useracc(p->blue, count, B_WRITE))
+                return (EFAULT);
+        for (cp = &cm->cm_map[start][0], i = 0; i < count; cp += 4, i++) {
+                p->red[i] = cp[3];
+                p->green[i] = cp[2];
+                p->blue[i] = cp[1];
+        }
+        return (0);
+}
+
+/* Write the software shadow colormap */
+static int
+cg14_put_cmap(p, cm, cmsize)
+        register struct fbcmap *p;
+        union cg14cmap *cm;
+        int cmsize;
+{
+        register u_int i, start, count;
+        register u_char *cp;
+ 
+        start = p->index;
+        count = p->count;
+        if (start >= cmsize || start + count > cmsize)
+#ifdef DEBUG
+	{
+		printf("putcmaperror: start %d cmsize %d count %d\n",
+		    start,cmsize,count);
+#endif
+                return (EINVAL);
+#ifdef DEBUG
+	}
+#endif
+
+        if (!useracc(p->red, count, B_READ) ||
+            !useracc(p->green, count, B_READ) ||
+            !useracc(p->blue, count, B_READ))
+                return (EFAULT);
+        for (cp = &cm->cm_map[start][0], i = 0; i < count; cp += 4, i++) {
+                cp[3] = p->red[i];
+                cp[2] = p->green[i];
+                cp[1] = p->blue[i];
+		cp[0] = 0;	/* no alpha channel */
+        }
+        return (0);
+}
+
+static void
+cg14_load_hwcmap(sc, start, ncolors)
+	register struct cgfourteen_softc *sc;
+	register int start, ncolors;
+{
+	/* XXX switch to auto-increment, and on retrace intr */
+	
+	/* Setup pointers to source and dest */
+	register u_int32_t *colp = &sc->sc_cmap.cm_chip[start];
+	volatile register u_int32_t *lutp = &sc->sc_clut1->clut_lut[start];
+
+	/* Copy by words */
+	while (--ncolors >= 0)
+		*lutp++ = *colp++;
+}
+
+/*
+ * Load the cursor (overlay `foreground' and `background') colors.
+ */
+static void
+cg14_setcursor(sc)
+	register struct cgfourteen_softc *sc;
+{
+	/* we need to subtract the hot-spot value here */
+#define COORD(f) (sc->sc_cursor.cc_pos.f - sc->sc_cursor.cc_hot.f)
+
+	sc->sc_hwc->curs_ctl = (sc->sc_cursor.cc_enable ? CG14_CURS_ENABLE : 0);
+	sc->sc_hwc->curs_x = COORD(x);
+	sc->sc_hwc->curs_y = COORD(y);
+
+#undef COORD
+}
+
+static void
+cg14_loadcursor(sc)
+	register struct cgfourteen_softc *sc;
+{
+	register volatile struct cg14curs *hwc;
+	register u_int edgemask, m;
+	register int i;
+
+	/*
+	 * Keep the top size.x bits.  Here we *throw out* the top
+	 * size.x bits from an all-one-bits word, introducing zeros in
+	 * the top size.x bits, then invert all the bits to get what
+	 * we really wanted as our mask.  But this fails if size.x is
+	 * 32---a sparc uses only the low 5 bits of the shift count---
+	 * so we have to special case that.
+	 */
+	edgemask = ~0;
+	if (sc->sc_cursor.cc_size.x < 32)
+		edgemask = ~(edgemask >> sc->sc_cursor.cc_size.x);
+	hwc = sc->sc_hwc;
+	for (i = 0; i < 32; i++) {
+		m = sc->sc_cursor.cc_eplane[i] & edgemask;
+		hwc->curs_plane0[i] = m;
+		hwc->curs_plane1[i] = m & sc->sc_cursor.cc_cplane[i];
+	}
+}
+
+static void
+cg14_loadomap(sc)
+	register struct cgfourteen_softc *sc;
+{
+	/* set background color */
+	sc->sc_hwc->curs_color1 = sc->sc_cursor.cc_color.cm_chip[0];
+	/* set foreground color */
+	sc->sc_hwc->curs_color2 = sc->sc_cursor.cc_color.cm_chip[1];
+}
diff --git a/sys/arch/sparc/dev/cgfourteenreg.h b/sys/arch/sparc/dev/cgfourteenreg.h
new file mode 100644
index 00000000000..c0fdb1b5c0a
--- /dev/null
+++ b/sys/arch/sparc/dev/cgfourteenreg.h
@@ -0,0 +1,123 @@
+/*	$OpenBSD: cgfourteenreg.h,v 1.1 1997/08/08 08:24:49 downsj Exp $	*/
+/*	$NetBSD: cgfourteenreg.h,v 1.1 1996/09/30 22:41:02 abrown Exp $ */
+
+/*
+ * Copyright (c) 1996 
+ *	The President and Fellows of Harvard College. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Harvard University and
+ *	its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Register/dac/clut/cursor definitions for cgfourteen frame buffer
+ */
+
+/* Locations of control registers in cg14 register set */
+#define	CG14_OFFSET_CURS	0x1000
+#define CG14_OFFSET_DAC		0x2000
+#define CG14_OFFSET_XLUT	0x3000
+#define CG14_OFFSET_CLUT1	0x4000
+#define CG14_OFFSET_CLUT2	0x5000
+#define CG14_OFFSET_CLUT3	0x6000
+#define CG14_OFFSET_CLUTINCR	0xf000
+
+/* Main control register set */
+struct cg14ctl {
+	volatile u_int8_t	ctl_mctl;	/* main control register */
+#define CG14_MCTL_ENABLEINTR	0x80		/* interrupts */
+#define CG14_MCTL_ENABLEVID	0x40		/* enable video */
+#define CG14_MCTL_PIXMODE_MASK	0x30		      
+#define		CG14_MCTL_PIXMODE_8	0x00	/* data is 16 8-bit pixels */
+#define		CG14_MCTL_PIXMODE_16	0x20	/* data is 8 16-bit pixels */
+#define		CG14_MCTL_PIXMODE_32	0x30	/* data is 4 32-bit pixels */
+#define CG14_MCTL_PIXMODE_SHIFT	4
+#define	CG14_MCTL_TMR		0x0c
+#define CG14_MCTL_ENABLETMR	0x02
+#define CG14_MCTL_rev0RESET	0x01
+#define CG14_MCTL_POWERCTL	0x01
+
+	volatile u_int8_t	ctl_ppr;	/* packed pixel register */
+	volatile u_int8_t	ctl_tmsr0; 	/* test status reg. 0 */
+	volatile u_int8_t	ctl_tmsr1;	/* test status reg. 1 */
+	volatile u_int8_t	ctl_msr;	/* master status register */
+	volatile u_int8_t	ctl_fsr;	/* fault status register */
+	volatile u_int8_t	ctl_rsr;	/* revision status register */
+#define CG14_RSR_REVMASK	0xf0 		/*  mask to get revision */
+#define CG14_RSR_IMPLMASK	0x0f		/*  mask to get impl. code */
+	volatile u_int8_t	ctl_ccr;	/* clock control register */
+	/* XXX etc. */
+};
+
+/* Hardware cursor map */
+#define CG14_CURS_SIZE		32
+struct cg14curs {
+	volatile u_int32_t	curs_plane0[CG14_CURS_SIZE];	/* plane 0 */
+	volatile u_int32_t	curs_plane1[CG14_CURS_SIZE];
+	volatile u_int8_t	curs_ctl;	/* control register */
+#define CG14_CURS_ENABLE	0x4
+#define CG14_CURS_DOUBLEBUFFER	0x2 		/* use X-channel for curs */
+	volatile u_int8_t	pad0[3];
+	volatile u_int16_t	curs_x;		/* x position */
+	volatile u_int16_t	curs_y;		/* y position */
+	volatile u_int32_t	curs_color1;	/* color register 1 */
+	volatile u_int32_t	curs_color2;	/* color register 2 */
+	volatile u_int32_t	pad[444];	/* pad to 2KB boundary */
+	volatile u_int32_t	curs_plane0incr[CG14_CURS_SIZE]; /* autoincr */
+	volatile u_int32_t	curs_plane1incr[CG14_CURS_SIZE]; /* autoincr */
+};
+
+/* DAC */
+struct cg14dac {
+	volatile u_int8_t	dac_addr;	/* address register */
+	volatile u_int8_t	pad0[255];
+	volatile u_int8_t	dac_gammalut;	/* gamma LUT */
+	volatile u_int8_t	pad1[255];
+	volatile u_int8_t	dac_regsel;	/* register select */
+	volatile u_int8_t	pad2[255];
+	volatile u_int8_t	dac_mode;	/* mode register */
+};
+
+#define CG14_CLUT_SIZE	256
+
+/* XLUT registers */
+struct cg14xlut {
+	volatile u_int8_t	xlut_lut[CG14_CLUT_SIZE];	/* the LUT */
+	volatile u_int8_t	xlut_lutd[CG14_CLUT_SIZE];	/* ??? */
+	volatile u_int8_t	pad0[0x600];
+	volatile u_int8_t	xlut_lutinc[CG14_CLUT_SIZE];	/* autoincrLUT*/
+	volatile u_int8_t	xlut_lutincd[CG14_CLUT_SIZE];
+};
+
+/* Color Look-Up Table (CLUT) */
+struct cg14clut {
+	volatile u_int32_t	clut_lut[CG14_CLUT_SIZE];	/* the LUT */
+	volatile u_int32_t	clut_lutd[CG14_CLUT_SIZE];	/* ??? */
+	volatile u_int32_t	clut_lutinc[CG14_CLUT_SIZE];	/* autoincr */
+	volatile u_int32_t	clut_lutincd[CG14_CLUT_SIZE];
+};
diff --git a/sys/arch/sparc/dev/cgfourteenvar.h b/sys/arch/sparc/dev/cgfourteenvar.h
new file mode 100644
index 00000000000..654945e01bb
--- /dev/null
+++ b/sys/arch/sparc/dev/cgfourteenvar.h
@@ -0,0 +1,94 @@
+/*	$OpenBSD: cgfourteenvar.h,v 1.1 1997/08/08 08:24:50 downsj Exp $	*/
+/*	$NetBSD: cgfourteenvar.h,v 1.1 1996/09/30 22:41:03 abrown Exp $ */
+
+/*
+ * Copyright (c) 1996 
+ *	The President and Fellows of Harvard College. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Harvard University and
+ *	its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * Layout of cg14 hardware colormap
+ */
+union cg14cmap {
+	u_char  	cm_map[256][4];	/* 256 R/G/B/A entries (B is high)*/
+	u_int32_t   	cm_chip[256];	/* the way the chip gets loaded */
+};
+
+/*
+ * cg14 hardware cursor colormap
+ */
+union cg14cursor_cmap {		/* colormap, like bt_cmap, but tiny */
+	u_char		cm_map[2][4];	/* 2 R/G/B/A entries */
+	u_int32_t	cm_chip[2];	/* 2 chip equivalents */
+};
+
+/*
+ * cg14 hardware cursor status
+ */
+struct cg14_cursor {		/* cg14 hardware cursor status */
+	short	cc_enable;		/* cursor is enabled */
+	struct	fbcurpos cc_pos;	/* position */
+	struct	fbcurpos cc_hot;	/* hot-spot */
+	struct	fbcurpos cc_size;	/* size of mask & image fields */
+	u_int	cc_eplane[32];		/* enable plane */
+	u_int	cc_cplane[32];		/* color plane */
+	union	cg14cursor_cmap cc_color; /* cursor colormap */
+};
+
+/* 
+ * per-cg14 variables/state
+ */
+struct cgfourteen_softc {
+	struct	device sc_dev;		/* base device */
+	struct	fbdevice sc_fb;		/* frame buffer device */
+
+	struct 	rom_reg	sc_phys;	/* phys address of frame buffer */
+#if defined(DEBUG) && defined(CG14_MAP_REGS)
+	struct	rom_reg	sc_regphys;	/* phys addr of fb regs; for debug */
+#endif
+	union	cg14cmap sc_cmap;	/* current colormap */
+
+	struct	cg14_cursor sc_cursor;	/* Hardware cursor state */
+
+	union 	cg14cmap sc_saveclut; 	/* a place to stash PROM state */
+	u_int8_t	sc_savexlut[256];
+	u_int8_t	sc_savectl;
+	u_int8_t	sc_savehwc;
+
+	struct	cg14ctl  *sc_ctl; 	/* various registers */
+	struct	cg14curs *sc_hwc;
+	struct 	cg14dac	 *sc_dac;
+	struct	cg14xlut *sc_xlut;
+	struct 	cg14clut *sc_clut1;
+	struct	cg14clut *sc_clut2;
+	struct	cg14clut *sc_clut3;
+	u_int	*sc_clutincr;
+};
diff --git a/sys/arch/sparc/dev/cgsix.c b/sys/arch/sparc/dev/cgsix.c
index dd967ebf558..f7cf868f8bb 100644
--- a/sys/arch/sparc/dev/cgsix.c
+++ b/sys/arch/sparc/dev/cgsix.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: cgsix.c,v 1.7 1996/08/13 08:05:22 downsj Exp $	*/
-/*	$NetBSD: cgsix.c,v 1.25 1996/04/01 17:30:00 christos Exp $ */
+/*	$OpenBSD: cgsix.c,v 1.8 1997/08/08 08:24:51 downsj Exp $	*/
+/*	$NetBSD: cgsix.c,v 1.32 1997/07/29 09:58:04 fair Exp $ */
 
 /*
  * Copyright (c) 1993
@@ -122,12 +122,11 @@ struct cgsix_softc {
 /* autoconfiguration driver */
 static void	cgsixattach __P((struct device *, struct device *, void *));
 static int	cgsixmatch __P((struct device *, void *, void *));
-int		cgsixopen __P((dev_t, int, int, struct proc *));
-int		cgsixclose __P((dev_t, int, int, struct proc *));
-int		cgsixioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		cgsixmmap __P((dev_t, int, int));
 static void	cg6_unblank __P((struct device *));
 
+/* cdevsw prototypes */
+cdev_decl(cgsix);
+
 struct cfattach cgsix_ca = {
 	sizeof(struct cgsix_softc), cgsixmatch, cgsixattach
 };
@@ -186,7 +185,8 @@ cgsixmatch(parent, vcf, aux)
 		 * differently on the cgsix than other pfour framebuffers.
 		 */
 		bus_untmp();
-		tmp = bus_tmp(ra->ra_paddr + CGSIX_FHC_OFFSET, ca->ca_bustype);
+		tmp = (caddr_t)mapdev(ra->ra_reg, TMPMAP_VA, CGSIX_FHC_OFFSET,
+				      NBPG);
 		if (probeget(tmp, 4) == -1)
 			return (0);
 
@@ -231,17 +231,13 @@ cgsixattach(parent, self, args)
 	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);
+	   mapiodev(ca->ca_ra.ra_reg, O(cg6_bt_un.un_btregs),sizeof *sc->sc_bt);
 	sc->sc_fhc = (volatile int *)
-	    mapiodev(ca->ca_ra.ra_reg, O(cg6_fhc_un.un_fhc),
-		     sizeof *sc->sc_fhc, ca->ca_bustype);
+	   mapiodev(ca->ca_ra.ra_reg, O(cg6_fhc_un.un_fhc), sizeof *sc->sc_fhc);
 	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);
+	   mapiodev(ca->ca_ra.ra_reg, O(cg6_thc_un.un_thc), sizeof *sc->sc_thc);
 	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);
+	   mapiodev(ca->ca_ra.ra_reg, O(cg6_tec_un.un_tec), sizeof *sc->sc_tec);
 
 	switch (ca->ca_bustype) {
 	case BUS_OBIO:
@@ -292,13 +288,13 @@ cgsixattach(parent, self, args)
 #if defined(SUN4)
 	if (CPU_ISSUN4) {
 		struct eeprom *eep = (struct eeprom *)eeprom_va;
-		int constype = (fb->fb_flags & FB_PFOUR) ? EED_CONS_P4 :
-		    EED_CONS_COLOR;
+		int constype = (fb->fb_flags & FB_PFOUR) ? EE_CONS_P4OPT :
+		    EE_CONS_COLOR;
 		/*
 		 * Assume this is the console if there's no eeprom info
 		 * to be found.
 		 */
-		if (eep == NULL || eep->ee_diag.eed_console == constype)
+		if (eep == NULL || eep->eeConsole == constype)
 			isconsole = (fbconstty != NULL);
 		else
 			isconsole = 0;
@@ -329,8 +325,7 @@ cgsixattach(parent, self, args)
 		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);
+			mapiodev(ca->ca_ra.ra_reg, O(cg6_ram[0]), ramsize);
 		fbrcons_init(&sc->sc_fb);
 #endif
 	} else
@@ -535,7 +530,7 @@ cgsixioctl(dev, cmd, data, flags, p)
 
 	default:
 #ifdef DEBUG
-		log(LOG_NOTICE, "cgsixioctl(%lx) (%s[%d])\n", cmd,
+		log(LOG_NOTICE, "cgsixioctl(0x%lx) (%s[%d])\n", cmd,
 		    p->p_comm, p->p_pid);
 #endif
 		return (ENOTTY);
@@ -752,13 +747,14 @@ 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 (REG2PHYS(&sc->sc_physadr, u + mo->mo_physoff,
-					 sc->sc_bustype) | PMAP_NC);
+			return (REG2PHYS(&sc->sc_physadr, u + mo->mo_physoff) |
+				PMAP_NC);
 	}
 #ifdef DEBUG
 	{
 	  register struct proc *p = curproc;	/* XXX */
-	  log(LOG_NOTICE, "cgsixmmap(%x) (%s[%d])\n", off, p->p_comm, p->p_pid);
+	  log(LOG_NOTICE, "cgsixmmap(0x%x) (%s[%d])\n",
+		off, p->p_comm, p->p_pid);
 	}
 #endif
 	return (-1);	/* not a user-map offset */
diff --git a/sys/arch/sparc/dev/cgsixreg.h b/sys/arch/sparc/dev/cgsixreg.h
index d9b90977c85..a8a63d0a082 100644
--- a/sys/arch/sparc/dev/cgsixreg.h
+++ b/sys/arch/sparc/dev/cgsixreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: cgsixreg.h,v 1.3 1997/08/08 08:24:52 downsj Exp $	*/
 /*	$NetBSD: cgsixreg.h,v 1.4 1996/02/27 22:09:31 thorpej Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/cgthree.c b/sys/arch/sparc/dev/cgthree.c
index 1599048c61d..b978af5fde4 100644
--- a/sys/arch/sparc/dev/cgthree.c
+++ b/sys/arch/sparc/dev/cgthree.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: cgthree.c,v 1.27 1996/04/01 17:30:03 christos Exp $ */
+/*	$OpenBSD: cgthree.c,v 1.6 1997/08/08 08:24:53 downsj Exp $	*/
+/*	$NetBSD: cgthree.c,v 1.33 1997/05/24 20:16:11 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -90,12 +91,11 @@ struct cgthree_softc {
 /* autoconfiguration driver */
 static void	cgthreeattach(struct device *, struct device *, void *);
 static int	cgthreematch(struct device *, void *, void *);
-int		cgthreeopen __P((dev_t, int, int, struct proc *));
-int		cgthreeclose __P((dev_t, int, int, struct proc *));
-int		cgthreeioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		cgthreemmap __P((dev_t, int, int));
 static void	cgthreeunblank(struct device *);
 
+/* cdevsw prototypes */
+cdev_decl(cgthree);
+
 struct cfattach cgthree_ca = {
 	sizeof(struct cgthree_softc), cgthreematch, cgthreeattach
 };
@@ -116,6 +116,20 @@ static void cgthreeloadcmap __P((struct cgthree_softc *, int, int));
 static void cgthree_set_video __P((struct cgthree_softc *, int));
 static int cgthree_get_video __P((struct cgthree_softc *));
 
+/* Video control parameters */
+struct cg3_videoctrl {
+	unsigned char	sense;		/* Monitor sense value */
+	unsigned char	vctrl[12];
+} cg3_videoctrl[] = {
+/* Missing entries: sense 0x10, 0x30, 0x50 */
+	{ 0x40, /* this happens to be my 19'' 1152x900 gray-scale monitor */
+	   {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
+	},
+	{ 0x00, /* default? must be last */
+	   {0xbb, 0x2b, 0x3, 0xb, 0xb3, 0x3, 0xaf, 0x2b, 0x2, 0xa, 0xff, 0x1}
+	}
+};
+
 /*
  * Match a cgthree.
  */
@@ -206,11 +220,28 @@ cgthreeattach(parent, self, args)
 	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(ca->ca_ra.ra_reg, CG3REG_MEM,
-						ramsize, ca->ca_bustype);
+					       ramsize);
 	}
 	sc->sc_fbc = (volatile struct fbcontrol *)
 	    mapiodev(ca->ca_ra.ra_reg, CG3REG_REG,
-		     sizeof(struct fbcontrol), ca->ca_bustype);
+		     sizeof(struct fbcontrol));
+
+	/* Transfer video magic to board, if it's not running */
+	if ((sc->sc_fbc->fbc_ctrl & FBC_TIMING) == 0)
+		for (i = 0; i < sizeof(cg3_videoctrl)/sizeof(cg3_videoctrl[0]);
+		     i++) {
+			volatile struct fbcontrol *fbc = sc->sc_fbc;
+			if ((fbc->fbc_status & FBS_MSENSE) ==
+			     cg3_videoctrl[i].sense) {
+				int j;
+				printf(" setting video ctrl");
+				for (j = 0; j < 12; j++)
+					fbc->fbc_vcontrol[j] =
+						cg3_videoctrl[i].vctrl[j];
+				fbc->fbc_ctrl |= FBC_TIMING;
+				break;
+			}
+		}
 
 	sc->sc_phys = ca->ca_ra.ra_reg[0];
 	sc->sc_bustype = ca->ca_bustype;
@@ -408,5 +439,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 (REG2PHYS(&sc->sc_phys, CG3REG_MEM+off, sc->sc_bustype) | PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, CG3REG_MEM+off) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/cgthreereg.h b/sys/arch/sparc/dev/cgthreereg.h
index 073cc52e66c..89811921252 100644
--- a/sys/arch/sparc/dev/cgthreereg.h
+++ b/sys/arch/sparc/dev/cgthreereg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: cgthreereg.h,v 1.3 1997/08/08 08:24:54 downsj Exp $	*/
 /*	$NetBSD: cgthreereg.h,v 1.5 1996/02/27 00:14:17 pk Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/cgtwo.c b/sys/arch/sparc/dev/cgtwo.c
index 8c5dcc8f11a..e682f6b8a26 100644
--- a/sys/arch/sparc/dev/cgtwo.c
+++ b/sys/arch/sparc/dev/cgtwo.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: cgtwo.c,v 1.10 1996/08/13 08:05:23 downsj Exp $	*/
-/*	$NetBSD: cgtwo.c,v 1.16 1996/05/18 12:19:14 mrg Exp $ */
+/*	$OpenBSD: cgtwo.c,v 1.11 1997/08/08 08:24:55 downsj Exp $	*/
+/*	$NetBSD: cgtwo.c,v 1.22 1997/05/24 20:16:12 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -92,14 +92,13 @@ struct cgtwo_softc {
 /* autoconfiguration driver */
 static void	cgtwoattach __P((struct device *, struct device *, void *));
 static int	cgtwomatch __P((struct device *, void *, void *));
-int		cgtwoopen __P((dev_t, int, int, struct proc *));
-int		cgtwoclose __P((dev_t, int, int, struct proc *));
-int		cgtwoioctl __P((dev_t, u_long, caddr_t, int, struct proc *));
-int		cgtwommap __P((dev_t, int, int));
 static void	cgtwounblank __P((struct device *));
 int		cgtwogetcmap __P((struct cgtwo_softc *, struct fbcmap *));
 int		cgtwoputcmap __P((struct cgtwo_softc *, struct fbcmap *));
 
+/* cdevsw prototypes */
+cdev_decl(cgtwo);
+
 struct cfattach cgtwo_ca = {
 	sizeof(struct cgtwo_softc), cgtwomatch, cgtwoattach
 };
@@ -148,7 +147,7 @@ cgtwomatch(parent, vcf, aux)
 
 	/* XXX - Must do our own mapping at CG2_CTLREG_OFF */
 	bus_untmp();
-	tmp = (caddr_t)bus_tmp(ra->ra_paddr + CG2_CTLREG_OFF, ca->ca_bustype);
+	tmp = (caddr_t)mapdev(ra->ra_reg, TMPMAP_VA, CG2_CTLREG_OFF, NBPG);
 	if (probeget(tmp, 2) != -1)
 		return 1;
 #endif
@@ -207,20 +206,21 @@ cgtwoattach(parent, self, args)
 		 * Assume this is the console if there's no eeprom info
 		 * to be found.
 		 */
-		if (eep == NULL || eep->ee_diag.eed_console == EED_CONS_COLOR)
+		if (eep == NULL || eep->eeConsole == EE_CONS_COLOR)
 			isconsole = (fbconstty != NULL);
 		else
 			isconsole = 0;
 	}
 #endif
 	sc->sc_phys = ca->ca_ra.ra_reg[0];
+	/* Apparently, the pixels are 32-bit data space */
+	sc->sc_phys.rr_iospace = PMAP_VME32;
 	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(ca->ca_ra.ra_reg, CG2_PIXMAP_OFF,
-					       CG2_PIXMAP_SIZE,
-					       PMAP_VME32/*ca->ca_bustype*/);
+		sc->sc_fb.fb_pixels = mapiodev(&sc->sc_phys, CG2_PIXMAP_OFF,
+					       CG2_PIXMAP_SIZE);
 	}
 #ifndef offsetof
 #define	offsetof(type, member)  ((size_t)(&((type *)0)->member))
@@ -229,12 +229,12 @@ cgtwoattach(parent, self, args)
 	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);
+		     sizeof(struct cg2statusreg));
 
 	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);
+		     3 * CG2_CMSIZE);
 
 	if (isconsole) {
 		printf(" (console)\n");
@@ -432,5 +432,5 @@ cgtwommap(dev, off, prot)
 	if ((unsigned)off >= sc->sc_fb.fb_type.fb_size)
 		return (-1);
 
-	return (REG2PHYS(&sc->sc_phys, off, PMAP_VME32/*sc->sc_bustype*/) | PMAP_NC);
+	return (REG2PHYS(&sc->sc_phys, off) | PMAP_NC);
 }
diff --git a/sys/arch/sparc/dev/cons.c b/sys/arch/sparc/dev/cons.c
index 11a1606bae8..fba5c2e4eb1 100644
--- a/sys/arch/sparc/dev/cons.c
+++ b/sys/arch/sparc/dev/cons.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: cons.c,v 1.5 1996/08/13 08:05:24 downsj Exp $	*/
-/*	$NetBSD: cons.c,v 1.23.4.1 1996/06/02 09:07:53 mrg Exp $ */
+/*	$OpenBSD: cons.c,v 1.6 1997/08/08 08:24:56 downsj Exp $	*/
+/*	$NetBSD: cons.c,v 1.30 1997/07/07 23:30:23 pk Exp $	*/
 
 /*
  * Copyright (c) 1992, 1993
@@ -70,6 +70,11 @@
 #include <machine/autoconf.h>
 #include <machine/conf.h>
 
+#ifdef RASTERCONSOLE
+#include <machine/fbio.h>
+#include <machine/fbvar.h>
+#endif
+
 #include "zs.h"
 
 struct	tty *constty = 0;	/* virtual console output device */
@@ -286,20 +291,30 @@ cnopen(dev, flag, mode, p)
 		/* output queue doesn't need quoting */
 		clalloc(&tp->t_outq, 1024, 0);
 		tty_attach(tp);
+
 		/*
 		 * get the console struct winsize.
 		 */
+#ifdef RASTERCONSOLE
+		if (fbconstty) {
+			rows = fbrcons_rows();
+			cols = fbrcons_cols();
+		}
+#endif
+
 		if (CPU_ISSUN4COR4M) {
 			int i;
 			char *prop;
 
-			if ((prop = getpropstring(optionsnode, "screen-#rows"))) {
+			if (rows == 0 &&
+			    (prop = getpropstring(optionsnode, "screen-#rows"))) {
 				i = 0;
 				while (*prop != '\0')
 					i = i * 10 + *prop++ - '0';
 				rows = (unsigned short)i;
 			}
-			if ((prop = getpropstring(optionsnode, "screen-#columns"))) {
+			if (cols == 0 &&
+			    (prop = getpropstring(optionsnode, "screen-#columns"))) {
 				i = 0;
 				while (*prop != '\0')
 					i = i * 10 + *prop++ - '0';
@@ -310,8 +325,10 @@ cnopen(dev, flag, mode, p)
 			struct eeprom *ep = (struct eeprom *)eeprom_va;
 
 			if (ep) {
-				rows = (u_short)ep->ee_diag.eed_rowsize;
-				cols = (u_short)ep->ee_diag.eed_colsize;
+				if (rows == 0)
+					rows = (u_short)ep->eeTtyRows;
+				if (cols == 0)
+					cols = (u_short)ep->eeTtyCols;
 			}
 		}
 		firstopen = 0;
diff --git a/sys/arch/sparc/dev/dma.c b/sys/arch/sparc/dev/dma.c
index 4c961cac690..c01200a20c1 100644
--- a/sys/arch/sparc/dev/dma.c
+++ b/sys/arch/sparc/dev/dma.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: dma.c,v 1.28.2.2 1996/07/02 23:46:29 jtc Exp $ */
+/*	$OpenBSD: dma.c,v 1.8 1997/08/08 08:24:57 downsj Exp $	*/
+/*	$NetBSD: dma.c,v 1.45 1997/07/29 09:58:06 fair Exp $ */
 
 /*
  * Copyright (c) 1994 Paul Kranenburg.  All rights reserved.
@@ -45,19 +46,25 @@
 #include <sparc/autoconf.h>
 #include <sparc/cpu.h>
 
+#include <sparc/sparc/cpuvar.h>
+
 #include <scsi/scsi_all.h>
 #include <scsi/scsiconf.h>
 
+#include <dev/ic/ncr53c9xreg.h>
+#include <dev/ic/ncr53c9xvar.h>
+
 #include <sparc/dev/sbusvar.h>
 #include <sparc/dev/dmareg.h>
 #include <sparc/dev/dmavar.h>
-#include <sparc/dev/espreg.h>
 #include <sparc/dev/espvar.h>
 
 int dmaprint		__P((void *, const char *));
 void dmaattach		__P((struct device *, struct device *, void *));
 int dmamatch		__P((struct device *, void *, void *));
-void dma_reset		__P((struct dma_softc *));
+void dma_reset		__P((struct dma_softc *, int));
+void espdma_reset	__P((struct dma_softc *));
+void ledma_reset	__P((struct dma_softc *));
 void dma_enintr		__P((struct dma_softc *));
 int dma_isintr		__P((struct dma_softc *));
 int espdmaintr		__P((struct dma_softc *));
@@ -100,7 +107,7 @@ dmamatch(parent, vcf, aux)
 	struct device *parent;
 	void *vcf, *aux;
 {
-	struct cfdata *cf = vcf;
+	register struct cfdata *cf = vcf;
 	register struct confargs *ca = aux;
 	register struct romaux *ra = &ca->ca_ra;
 
@@ -131,8 +138,7 @@ dmaattach(parent, self, aux)
 
 	if (ca->ca_ra.ra_vaddr == NULL || ca->ca_ra.ra_nvaddrs == 0)
 		ca->ca_ra.ra_vaddr =
-		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len,
-			     ca->ca_bustype);
+		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len);
 
 	sc->sc_regs = (struct dma_regs *) ca->ca_ra.ra_vaddr;
 
@@ -156,35 +162,24 @@ dmaattach(parent, self, aux)
 		}
 		delay(20000);	/* manual says we need 20ms delay */
 	}
-	
+
 	/*
-	 * Get transfer burst size from PROM and plug it into the controller
-	 * registers. This is needed on the Sun4m; do others need it too?
-	 * XXX
+	 * Get transfer burst size from PROM and plug it into the
+	 * controller registers. This is needed on the Sun4m; do
+	 * others need it too?
 	 */
 	if (CPU_ISSUN4M) {
+		int sbusburst = ((struct sbus_softc *)parent)->sc_burst;
+		if (sbusburst == 0)
+			sbusburst = SBUS_BURST_32 - 1; /* 1->16 */
+
 		sc->sc_burst = getpropint(ca->ca_ra.ra_node,"burst-sizes", -1);
-		if (sc->sc_burst == -1) {
-			/* check parent SBus for burst sizes */
-			if (((struct sbus_softc *)parent)->sc_burst == 0)
-				sc->sc_burst = SBUS_BURST_32 - 1; /* 1->16 */
-			else
-				sc->sc_burst = 
-					((struct sbus_softc *)parent)->sc_burst;
-		}
-		sc->sc_regs->csr &= ~D_BURST_SIZE; /* must clear first */
-		if (sc->sc_burst & SBUS_BURST_32) {
-			sc->sc_regs->csr |= D_BURST_32;
-		} else if (sc->sc_burst & SBUS_BURST_16) {
-			sc->sc_regs->csr |= D_BURST_16;
-		} else if (strcmp(ca->ca_ra.ra_name,"espdma") == 0) {
-			/* only espdma supports non-burst */
-			sc->sc_regs->csr |= D_BURST_0;
-#ifdef DIAGNOSTIC
-		} else {
-			printf(" <unknown burst size 0x%x>", sc->sc_burst);
-#endif
-		}
+		if (sc->sc_burst == -1)
+			/* take SBus burst sizes */
+			sc->sc_burst = sbusburst;
+
+		/* Clamp at parent's burst sizes */
+		sc->sc_burst &= sbusburst;
 	}
 
 	printf(": rev ");
@@ -193,6 +188,9 @@ dmaattach(parent, self, aux)
 	case DMAREV_0:
 		printf("0");
 		break;
+	case DMAREV_ESC:
+		printf("esc");
+		break;
 	case DMAREV_1:
 		printf("1");
 		break;
@@ -203,19 +201,20 @@ dmaattach(parent, self, aux)
 		printf("2");
 		break;
 	default:
-		printf("unknown");
+		printf("unknown (0x%x)", sc->sc_rev);
 	}
 	printf("\n");
 
 	/* indirect functions */
 	if (sc->sc_dev.dv_cfdata->cf_attach == &dma_ca) {
+		sc->reset = espdma_reset;
 		sc->intr = espdmaintr;
 	} else {
+		sc->reset = ledma_reset;
 		sc->intr = ledmaintr;
 	}
 	sc->enintr = dma_enintr;
 	sc->isintr = dma_isintr;
-	sc->reset = dma_reset;
 	sc->setup = dma_setup;
 	sc->go = dma_go;
 
@@ -272,24 +271,94 @@ espsearch:
 	}
 }
 
+#define DMAWAIT(SC, COND, MSG, DONTPANIC) do if (COND) {		\
+	int count = 500000;						\
+	while ((COND) && --count > 0) DELAY(1);				\
+	if (count == 0) {						\
+		printf("%s: line %d: CSR = 0x%lx\n", __FILE__, __LINE__, \
+			(SC)->sc_regs->csr);				\
+		if (DONTPANIC)						\
+			printf(MSG);					\
+		else							\
+			panic(MSG);					\
+	}								\
+} while (0)
+
+#define DMA_DRAIN(sc, dontpanic) do {					\
+	/*								\
+	 * DMA rev0 & rev1: we are not allowed to touch the DMA "flush"	\
+	 *     and "drain" bits while it is still thinking about a	\
+	 *     request.							\
+	 * other revs: D_R_PEND bit reads as 0				\
+	 */								\
+	DMAWAIT(sc, sc->sc_regs->csr & D_R_PEND, "R_PEND", dontpanic);	\
+	/*								\
+	 * Select drain bit based on revision				\
+	 * also clears errors and D_TC flag				\
+	 */								\
+	if (sc->sc_rev == DMAREV_1 || sc->sc_rev == DMAREV_0)		\
+		DMACSR(sc) |= D_DRAIN;					\
+	else								\
+		DMACSR(sc) |= D_INVALIDATE;				\
+	/*								\
+	 * Wait for draining to finish					\
+	 *  rev0 & rev1 call this PACKCNT				\
+	 */								\
+	DMAWAIT(sc, sc->sc_regs->csr & D_DRAINING, "DRAINING", dontpanic);\
+} while(0)
+
 void
-dma_reset(sc)
+dma_reset(sc, isledma)
 	struct dma_softc *sc;
+	int isledma;
 {
-	DMAWAIT(sc);
-	DMA_DRAIN(sc);				/* Drain (DMA rev 1) */
+	DMA_DRAIN(sc, 1);
 	DMACSR(sc) &= ~D_EN_DMA;		/* Stop DMA */
-	DMAWAIT1(sc);				/* let things drain */
 	DMACSR(sc) |= D_RESET;			/* reset DMA */
 	DELAY(200);				/* what should this be ? */
-	DMAWAIT1(sc);
+	/*DMAWAIT1(sc); why was this here? */
 	DMACSR(sc) &= ~D_RESET;			/* de-assert reset line */
 	DMACSR(sc) |= D_INT_EN;			/* enable interrupts */
-	if (sc->sc_rev > DMAREV_1)
+	if (sc->sc_rev > DMAREV_1 && isledma == 0)
 		DMACSR(sc) |= D_FASTER;
+
+	switch (sc->sc_rev) {
+	case DMAREV_2:
+		sc->sc_regs->csr &= ~D_BURST_SIZE; /* must clear first */
+		if (sc->sc_burst & SBUS_BURST_32) {
+			DMACSR(sc) |= D_BURST_32;
+		} else if (sc->sc_burst & SBUS_BURST_16) {
+			DMACSR(sc) |= D_BURST_16;
+		} else {
+			DMACSR(sc) |= D_BURST_0;
+		}
+		break;
+	case DMAREV_ESC:
+		DMACSR(sc) |= D_AUTODRAIN;	/* Auto-drain */
+		if (sc->sc_burst & SBUS_BURST_32) {
+			DMACSR(sc) &= ~0x800;
+		} else
+			DMACSR(sc) |= 0x800;
+		break;
+	default:
+	}
+
 	sc->sc_active = 0;			/* and of course we aren't */
 }
 
+void
+espdma_reset(sc)
+	struct dma_softc *sc;
+{
+	dma_reset(sc, 0);
+}
+
+void
+ledma_reset(sc)
+	struct dma_softc *sc;
+{
+	dma_reset(sc, 1);
+}
 
 void
 dma_enintr(sc)
@@ -321,12 +390,7 @@ dma_setup(sc, addr, len, datain, dmasize)
 {
 	u_long csr;
 
-	/* clear errors and D_TC flag */
-	DMAWAIT(sc);
-	DMA_DRAIN(sc);		/* ? */
-	DMAWAIT1(sc);
-	DMACSR(sc) |= D_INVALIDATE;
-	DMAWAIT1(sc);
+	DMA_DRAIN(sc, 0);
 
 #if 0
 	DMACSR(sc) &= ~D_INT_EN;
@@ -334,7 +398,7 @@ dma_setup(sc, addr, len, datain, dmasize)
 	sc->sc_dmaaddr = addr;
 	sc->sc_dmalen = len;
 
-	ESP_DMA(("%s: start %d@%p,%d\n", sc->sc_dev.dv_xname,
+	NCR_DMA(("%s: start %d@%p,%d\n", sc->sc_dev.dv_xname,
 		*sc->sc_dmalen, *sc->sc_dmaaddr, datain ? 1 : 0));
 
 	/*
@@ -345,7 +409,7 @@ dma_setup(sc, addr, len, datain, dmasize)
 	*dmasize = sc->sc_dmasize =
 		min(*dmasize, DMAMAX((size_t) *sc->sc_dmaaddr));
 
-	ESP_DMA(("dma_setup: dmasize = %d\n", sc->sc_dmasize));
+	NCR_DMA(("dma_setup: dmasize = %d\n", sc->sc_dmasize));
 
 	/* Program the DMA address */
 	if (CPU_ISSUN4M && sc->sc_dmasize) {
@@ -361,6 +425,14 @@ dma_setup(sc, addr, len, datain, dmasize)
 	} else
 		DMADDR(sc) = *sc->sc_dmaaddr;
 
+	if (sc->sc_rev == DMAREV_ESC) {
+		/* DMA ESC chip bug work-around */
+		register long bcnt = sc->sc_dmasize;
+		register long eaddr = bcnt + (long)*sc->sc_dmaaddr;
+		if ((eaddr & PGOFSET) != 0)
+			bcnt = roundup(bcnt, NBPG);
+		DMACNT(sc) = bcnt;
+	}
 	/* Setup DMA control register */
 	csr = DMACSR(sc);
 	if (datain)
@@ -394,11 +466,12 @@ int
 espdmaintr(sc)
 	struct dma_softc *sc;
 {
+	struct ncr53c9x_softc *nsc = &sc->sc_esp->sc_ncr53c9x;
 	int trans, resid;
 	u_long csr;
 	csr = DMACSR(sc);
 
-	ESP_DMA(("%s: intr: addr %p, csr %b\n", sc->sc_dev.dv_xname,
+	NCR_DMA(("%s: intr: addr %p, csr %b\n", sc->sc_dev.dv_xname,
 		 DMADDR(sc), csr, DMACSRBITS));
 
 	if (csr & D_ERR_PEND) {
@@ -406,19 +479,14 @@ espdmaintr(sc)
 		DMACSR(sc) |= D_INVALIDATE;
 		printf("%s: error: csr=%b\n", sc->sc_dev.dv_xname,
 			csr, DMACSRBITS);
-		return 0;
+		return -1;
 	}
 
 	/* This is an "assertion" :) */
 	if (sc->sc_active == 0)
 		panic("dmaintr: DMA wasn't active");
 
-	/* clear errors and D_TC flag */
-	DMAWAIT(sc);
-	DMA_DRAIN(sc);		/* ? */
-	DMAWAIT1(sc);
-	DMACSR(sc) |= D_INVALIDATE;
-	DMAWAIT1(sc);
+	DMA_DRAIN(sc, 0);
 
 	/* DMA has stopped */
 	DMACSR(sc) &= ~D_EN_DMA;
@@ -426,11 +494,11 @@ espdmaintr(sc)
 
 	if (sc->sc_dmasize == 0) {
 		/* A "Transfer Pad" operation completed */
-		ESP_DMA(("dmaintr: discarded %d bytes (tcl=%d, tcm=%d)\n",
-			ESP_READ_REG(sc->sc_esp, ESP_TCL) |
-				(ESP_READ_REG(sc->sc_esp, ESP_TCM) << 8),
-			ESP_READ_REG(sc->sc_esp, ESP_TCL),
-			ESP_READ_REG(sc->sc_esp, ESP_TCM)));
+		NCR_DMA(("dmaintr: discarded %d bytes (tcl=%d, tcm=%d)\n",
+			NCR_READ_REG(nsc, NCR_TCL) |
+				(NCR_READ_REG(nsc, NCR_TCM) << 8),
+			NCR_READ_REG(nsc, NCR_TCL),
+			NCR_READ_REG(nsc, NCR_TCM)));
 		return 0;
 	}
 
@@ -442,44 +510,50 @@ espdmaintr(sc)
 	 * bytes are clocked into the FIFO.
 	 */
 	if (!(csr & D_WRITE) &&
-	    (resid = (ESP_READ_REG(sc->sc_esp, ESP_FFLAG) & ESPFIFO_FF)) != 0) {
-		ESP_DMA(("dmaintr: empty esp FIFO of %d ", resid));
-		ESPCMD(sc->sc_esp, ESPCMD_FLUSH);
+	    (resid = (NCR_READ_REG(nsc, NCR_FFLAG) & NCRFIFO_FF)) != 0) {
+		NCR_DMA(("dmaintr: empty esp FIFO of %d ", resid));
 	}
 
-	if ((sc->sc_esp->sc_espstat & ESPSTAT_TC) == 0) {
+	if ((nsc->sc_espstat & NCRSTAT_TC) == 0) {
 		/*
 		 * `Terminal count' is off, so read the residue
 		 * out of the ESP counter registers.
 		 */
-		resid += ( ESP_READ_REG(sc->sc_esp, ESP_TCL) |
-			  (ESP_READ_REG(sc->sc_esp, ESP_TCM) << 8) |
-			   ((sc->sc_esp->sc_cfg2 & ESPCFG2_FE)
-				? (ESP_READ_REG(sc->sc_esp, ESP_TCH) << 16)
+		resid += (NCR_READ_REG(nsc, NCR_TCL) |
+			  (NCR_READ_REG(nsc, NCR_TCM) << 8) |
+			   ((nsc->sc_cfg2 & NCRCFG2_FE)
+				? (NCR_READ_REG(nsc, NCR_TCH) << 16)
 				: 0));
 
 		if (resid == 0 && sc->sc_dmasize == 65536 &&
-		    (sc->sc_esp->sc_cfg2 & ESPCFG2_FE) == 0)
+		    (nsc->sc_cfg2 & NCRCFG2_FE) == 0)
 			/* A transfer of 64K is encoded as `TCL=TCM=0' */
 			resid = 65536;
 	}
 
 	trans = sc->sc_dmasize - resid;
 	if (trans < 0) {			/* transferred < 0 ? */
+#if 0
+		/*
+		 * This situation can happen in perfectly normal operation
+		 * if the ESP is reselected while using DMA to select
+		 * another target.  As such, don't print the warning.
+		 */
 		printf("%s: xfer (%d) > req (%d)\n",
 		    sc->sc_dev.dv_xname, trans, sc->sc_dmasize);
+#endif
 		trans = sc->sc_dmasize;
 	}
 
-	ESP_DMA(("dmaintr: tcl=%d, tcm=%d, tch=%d; trans=%d, resid=%d\n",
-		ESP_READ_REG(sc->sc_esp, ESP_TCL),
-		ESP_READ_REG(sc->sc_esp, ESP_TCM),
-		(sc->sc_esp->sc_cfg2 & ESPCFG2_FE)
-			? ESP_READ_REG(sc->sc_esp, ESP_TCH) : 0,
+	NCR_DMA(("dmaintr: tcl=%d, tcm=%d, tch=%d; trans=%d, resid=%d\n",
+		NCR_READ_REG(nsc, NCR_TCL),
+		NCR_READ_REG(nsc, NCR_TCM),
+		(nsc->sc_cfg2 & NCRCFG2_FE)
+			? NCR_READ_REG(nsc, NCR_TCH) : 0,
 		trans, resid));
 
 	if (csr & D_WRITE)
-		cache_flush(*sc->sc_dmaaddr, trans);
+		cpuinfo.cache_flush(*sc->sc_dmaaddr, trans);
 
 	if (CPU_ISSUN4M && sc->sc_dvmakaddr)
 		dvma_mapout((vm_offset_t)sc->sc_dvmakaddr,
@@ -490,7 +564,7 @@ espdmaintr(sc)
 
 #if 0	/* this is not normal operation just yet */
 	if (*sc->sc_dmalen == 0 ||
-	    sc->sc_esp->sc_phase != sc->sc_esp->sc_prevphase)
+	    nsc->sc_phase != nsc->sc_prevphase)
 		return 0;
 
 	/* and again */
@@ -515,11 +589,11 @@ ledmaintr(sc)
 	csr = DMACSR(sc);
 
 	if (csr & D_ERR_PEND) {
-		printf("Lance DMA error, see your doctor!\n");
 		DMACSR(sc) &= ~D_EN_DMA;	/* Stop DMA */
 		DMACSR(sc) |= D_INVALIDATE;
 		printf("%s: error: csr=%b\n", sc->sc_dev.dv_xname,
-			(u_int)csr, DMACSRBITS);
+			csr, DMACSRBITS);
+		DMA_RESET(sc);
 	}
 	return 1;
 }
diff --git a/sys/arch/sparc/dev/dmareg.h b/sys/arch/sparc/dev/dmareg.h
index 3998581845a..c9e575a262f 100644
--- a/sys/arch/sparc/dev/dmareg.h
+++ b/sys/arch/sparc/dev/dmareg.h
@@ -1,4 +1,5 @@
-/*	$NetBSD: dmareg.h,v 1.8 1996/04/22 02:34:58 abrown Exp $ */
+/*	$OpenBSD: dmareg.h,v 1.4 1997/08/08 08:24:58 downsj Exp $	*/
+/*	$NetBSD: dmareg.h,v 1.10 1996/11/28 09:37:34 pk Exp $ */
 
 /*
  * Copyright (c) 1994 Peter Galbavy.  All rights reserved.
@@ -38,19 +39,21 @@ struct dma_regs {
 #define  D_INT_EN		0x00000010	/* interrupt enable */
 #define  D_INVALIDATE		0x00000020	/* invalidate fifo */
 #define  D_SLAVE_ERR		0x00000040	/* slave access size error */
-#define  D_DRAIN		0x00000040	/* drain fifo if DMAREV_1 */
+#define  D_DRAIN		0x00000040	/* rev0,1,esc: drain fifo */
 #define  D_RESET		0x00000080	/* reset scsi */
 #define  D_WRITE		0x00000100	/* 1 = dev -> mem */
 #define  D_EN_DMA		0x00000200	/* enable DMA requests */
-#define  D_R_PEND		0x00000400	/* something only on ver < 2 */
+#define  D_R_PEND		0x00000400	/* rev0,1: request pending */
+#define  D_ESC_BURST		0x00000800	/* DMA ESC: 16 byte bursts */
 #define  D_EN_CNT		0x00002000	/* enable byte counter */
 #define  D_TC			0x00004000	/* terminal count */
 #define  D_DSBL_CSR_DRN		0x00010000	/* disable fifo drain on csr */
 #define  D_DSBL_SCSI_DRN	0x00020000	/* disable fifo drain on reg */
 #define  D_BURST_SIZE		0x000c0000	/* sbus read/write burst size */
 #define   D_BURST_0		0x00080000	/*   no bursts (SCSI-only) */
-#define   D_BURST_16		0x00040000	/*   16-byte bursts */
-#define   D_BURST_32    	0x00000000	/*   32-byte bursts */
+#define   D_BURST_16		0x00000000	/*   16-byte bursts */
+#define   D_BURST_32    	0x00040000	/*   32-byte bursts */
+#define  D_AUTODRAIN		0x00040000	/* DMA ESC: Auto-drain */
 #define  D_DIAG			0x00100000	/* disable fifo drain on addr */
 #define  D_TWO_CYCLE		0x00200000	/* 2 clocks per transfer */
 #define  D_FASTER		0x00400000	/* 3 clocks per transfer */
@@ -62,6 +65,7 @@ struct dma_regs {
 #define  D_NA_LOADED		0x08000000	/* next address loaded */
 #define  D_DEV_ID		0xf0000000	/* device ID */
 #define   DMAREV_0		0x00000000	/* Sunray DMA */
+#define   DMAREV_ESC		0x40000000	/*  DMA ESC array */
 #define   DMAREV_1		0x80000000	/* 'DMA' */
 #define   DMAREV_PLUS		0x90000000	/* 'DMA+' */
 #define   DMAREV_2		0xa0000000	/* 'DMA2' */
diff --git a/sys/arch/sparc/dev/dmavar.h b/sys/arch/sparc/dev/dmavar.h
index 6bc42333a98..57fbbcad5e4 100644
--- a/sys/arch/sparc/dev/dmavar.h
+++ b/sys/arch/sparc/dev/dmavar.h
@@ -1,4 +1,5 @@
-/*	$NetBSD: dmavar.h,v 1.8 1996/04/22 02:35:00 abrown Exp $ */
+/*	$OpenBSD: dmavar.h,v 1.4 1997/08/08 08:24:59 downsj Exp $	*/
+/*	$NetBSD: dmavar.h,v 1.11 1996/11/27 21:49:53 pk Exp $ */
 
 /*
  * Copyright (c) 1994 Peter Galbavy.  All rights reserved.
@@ -35,7 +36,7 @@ struct dma_softc {
 	struct le_softc *sc_le;			/* my ethernet */
 	struct dma_regs *sc_regs;		/* the registers */
 	int	sc_active;			/* DMA active ? */
-	int	sc_rev;				/* revision */
+	u_int	sc_rev;				/* revision */
 	int	sc_node;			/* PROM node ID */
 	int	sc_burst;			/* DVMA burst size in effect */
 	caddr_t	sc_dvmakaddr;			/* DVMA cookies */
@@ -53,32 +54,7 @@ struct dma_softc {
 
 #define DMACSR(sc)	(sc->sc_regs->csr)
 #define DMADDR(sc)	(sc->sc_regs->addr)
-
-/*
- * We are not allowed to touch the DMA "flush" and "drain" bits
- * while it is still thinking about a request (DMA_RP).
- */
-
-/*
- * TIME WAIT (to debug hanging machine problem)
- */
-
-#define TIME_WAIT(COND, MSG, SC) { int count = 500000; \
-				while (--count > 0 && (COND)) DELAY(1); \
-				if (count == 0) { \
-					printf("CSR = %lx\n",\
-					    SC->sc_regs->csr);\
-					panic(MSG); } \
-			     }
-
-#define DMAWAIT(sc)  TIME_WAIT((sc->sc_regs->csr & D_R_PEND), "DMAWAIT", sc)
-#define DMAWAIT1(sc) TIME_WAIT((sc->sc_regs->csr & D_DRAINING), "DMAWAIT1", sc)
-#define DMAREADY(sc) TIME_WAIT((!(sc->sc_regs->csr & D_DMA_ON)), "DMAREADY", sc)
-
-#define DMA_DRAIN(sc)	if (sc->sc_rev < DMAREV_2) { \
-				DMACSR(sc) |= D_DRAIN; \
-				DMAWAIT1(sc); \
-			}
+#define DMACNT(sc)	(sc->sc_regs->bcnt)
 
 /* DMA engine functions */
 #define DMA_ENINTR(r)		(((r)->enintr)(r))
diff --git a/sys/arch/sparc/dev/esp.c b/sys/arch/sparc/dev/esp.c
index 5cb9d216931..48c211f8ea2 100644
--- a/sys/arch/sparc/dev/esp.c
+++ b/sys/arch/sparc/dev/esp.c
@@ -1,4 +1,65 @@
-/*	$NetBSD: esp.c,v 1.47.2.1 1996/06/12 20:46:52 pk Exp $ */
+/*	$OpenBSD: esp.c,v 1.10 1997/08/08 08:25:00 downsj Exp $	*/
+/*	$NetBSD: esp.c,v 1.68 1997/07/19 21:57:01 pk Exp $	*/
+
+/*
+ * Copyright (c) 1997 Jason R. Thorpe.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed for the NetBSD Project
+ *	by Jason R. Thorpe.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copyright (c) 1996 Charles M. Hannum.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Charles M. Hannum.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 
 /*
  * Copyright (c) 1994 Peter Galbavy
@@ -58,35 +119,17 @@
 
 #include <machine/cpu.h>
 #include <machine/autoconf.h>
+
+#include <dev/ic/ncr53c9xreg.h>
+#include <dev/ic/ncr53c9xvar.h>
+
 #include <sparc/dev/sbusvar.h>
 #include <sparc/dev/dmareg.h>
 #include <sparc/dev/dmavar.h>
-#include <sparc/dev/espreg.h>
 #include <sparc/dev/espvar.h>
 
-int esp_debug = 0; /*ESP_SHOWPHASE|ESP_SHOWMISC|ESP_SHOWTRAC|ESP_SHOWCMDS;*/
-
-/*static*/ void	espattach	__P((struct device *, struct device *, void *));
-/*static*/ int	espmatch	__P((struct device *, void *, void *));
-/*static*/ int	espprint	__P((void *, const char *));
-/*static*/ u_int	esp_adapter_info __P((struct esp_softc *));
-/*static*/ void	espreadregs	__P((struct esp_softc *));
-/*static*/ void	espselect	__P((struct esp_softc *,
-				     u_char, u_char, u_char *, u_char));
-/*static*/ void	esp_scsi_reset	__P((struct esp_softc *));
-/*static*/ void	esp_reset	__P((struct esp_softc *));
-/*static*/ void	esp_init	__P((struct esp_softc *, int));
-/*static*/ int	esp_scsi_cmd	__P((struct scsi_xfer *));
-/*static*/ int	esp_poll	__P((struct esp_softc *, struct ecb *));
-/*static*/ void	esp_sched	__P((struct esp_softc *));
-/*static*/ void	esp_done	__P((struct ecb *));
-/*static*/ void	esp_msgin	__P((struct esp_softc *));
-/*static*/ void	esp_msgout	__P((struct esp_softc *));
-/*static*/ int	espintr		__P((struct esp_softc *));
-/*static*/ void	esp_timeout	__P((void *arg));
-/*static*/ void	esp_abort	__P((struct esp_softc *, struct ecb *));
-int esp_stp2cpb __P((struct esp_softc *, int));
-int esp_cpb2stp __P((struct esp_softc *, int));
+void	espattach	__P((struct device *, struct device *, void *));
+int	espmatch	__P((struct device *, void *, void *));
 
 /* Linkup to the rest of the kernel */
 struct cfattach esp_ca = {
@@ -98,7 +141,7 @@ struct cfdriver esp_cd = {
 };
 
 struct scsi_adapter esp_switch = {
-	esp_scsi_cmd,
+	ncr53c9x_scsi_cmd,
 	minphys,		/* no max at this level; handled by DMA code */
 	NULL,
 	NULL,
@@ -111,22 +154,39 @@ struct scsi_device esp_dev = {
 	NULL,			/* Use default 'done' routine */
 };
 
-int
-espprint(aux, name)
-	void *aux;
-	const char *name;
-{
-	if (name != NULL)
-		printf("%s: scsibus ", name);
-	return UNCONF;
-}
+/*
+ * Functions and the switch for the MI code.
+ */
+u_char	esp_read_reg __P((struct ncr53c9x_softc *, int));
+void	esp_write_reg __P((struct ncr53c9x_softc *, int, u_char));
+int	esp_dma_isintr __P((struct ncr53c9x_softc *));
+void	esp_dma_reset __P((struct ncr53c9x_softc *));
+int	esp_dma_intr __P((struct ncr53c9x_softc *));
+int	esp_dma_setup __P((struct ncr53c9x_softc *, caddr_t *,
+	    size_t *, int, size_t *));
+void	esp_dma_go __P((struct ncr53c9x_softc *));
+void	esp_dma_stop __P((struct ncr53c9x_softc *));
+int	esp_dma_isactive __P((struct ncr53c9x_softc *));
+
+struct ncr53c9x_glue esp_glue = {
+	esp_read_reg,
+	esp_write_reg,
+	esp_dma_isintr,
+	esp_dma_reset,
+	esp_dma_intr,
+	esp_dma_setup,
+	esp_dma_go,
+	esp_dma_stop,
+	esp_dma_isactive,
+	NULL,			/* gl_clear_latched_intr */
+};
 
 int
 espmatch(parent, vcf, aux)
 	struct device *parent;
 	void *vcf, *aux;
 {
-	struct cfdata *cf = vcf;
+	register struct cfdata *cf = vcf;
 	register struct confargs *ca = aux;
 	register struct romaux *ra = &ca->ca_ra;
 
@@ -147,11 +207,17 @@ espattach(parent, self, aux)
 	void *aux;
 {
 	register struct confargs *ca = aux;
-	struct esp_softc *sc = (void *)self;
+	struct esp_softc *esc = (void *)self;
+	struct ncr53c9x_softc *sc = &esc->sc_ncr53c9x;
 	struct bootpath *bp;
 	int dmachild = strncmp(parent->dv_xname, "dma", 3) == 0;
 
 	/*
+	 * Set up glue for MI code early; we use some of it here.
+	 */
+	sc->sc_glue = &esp_glue;
+
+	/*
 	 * Make sure things are sane. I don't know if this is ever
 	 * necessary, but it seem to be in all of Torek's code.
 	 */
@@ -160,25 +226,25 @@ espattach(parent, self, aux)
 		return;
 	}
 
-	sc->sc_pri = ca->ca_ra.ra_intr[0].int_pri;
-	printf(" pri %d", sc->sc_pri);
+	esc->sc_pri = ca->ca_ra.ra_intr[0].int_pri;
+	printf(" pri %d", esc->sc_pri);
 
 	/*
 	 * Map my registers in, if they aren't already in virtual
 	 * address space.
 	 */
 	if (ca->ca_ra.ra_vaddr)
-		sc->sc_reg = (volatile u_char *) ca->ca_ra.ra_vaddr;
+		esc->sc_reg = (volatile u_char *) ca->ca_ra.ra_vaddr;
 	else {
-		sc->sc_reg = (volatile u_char *)
-		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len, ca->ca_bustype);
+		esc->sc_reg = (volatile u_char *)
+		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len);
 	}
 
 	/* Other settings */
-	sc->sc_node = ca->ca_ra.ra_node;
+	esc->sc_node = ca->ca_ra.ra_node;
 	if (ca->ca_bustype == BUS_SBUS) {
-		sc->sc_id = getpropint(sc->sc_node, "initiator-id", 7);
-		sc->sc_freq = getpropint(sc->sc_node, "clock-frequency", -1);
+		sc->sc_id = getpropint(esc->sc_node, "initiator-id", 7);
+		sc->sc_freq = getpropint(esc->sc_node, "clock-frequency", -1);
 	} else {
 		sc->sc_id = 7;
 		sc->sc_freq = 24000000;
@@ -191,8 +257,8 @@ espattach(parent, self, aux)
 	sc->sc_freq /= 1000000;
 
 	if (dmachild) {
-		sc->sc_dma = (struct dma_softc *)parent;
-		sc->sc_dma->sc_esp = sc;
+		esc->sc_dma = (struct dma_softc *)parent;
+		esc->sc_dma->sc_esp = esc;
 	} else {
 		/*
 		 * find the DMA by poking around the dma device structures
@@ -202,56 +268,68 @@ espattach(parent, self, aux)
 		 * dma actually gets configured, it does the opposing test, and
 		 * if the sc->sc_esp field in it's softc is NULL, then tries to
 		 * find the matching esp driver.
-		 *
 		 */
-		sc->sc_dma = (struct dma_softc *)
+		esc->sc_dma = (struct dma_softc *)
 			getdevunit("dma", sc->sc_dev.dv_unit);
 
 		/*
 		 * and a back pointer to us, for DMA
 		 */
-		if (sc->sc_dma)
-			sc->sc_dma->sc_esp = sc;
-		else
+		if (esc->sc_dma)
+			esc->sc_dma->sc_esp = esc;
+		else {
+			printf("\n");
 			panic("espattach: no dma found");
+		}
 	}
 
 	/*
+	 * XXX More of this should be in ncr53c9x_attach(), but
+	 * XXX should we really poke around the chip that much in
+	 * XXX the MI code?  Think about this more...
+	 */
+
+	/*
 	 * It is necessary to try to load the 2nd config register here,
-	 * to find out what rev the esp chip is, else the esp_reset
+	 * to find out what rev the esp chip is, else the ncr53c9x_reset
 	 * will not set up the defaults correctly.
 	 */
-	sc->sc_cfg1 = sc->sc_id | ESPCFG1_PARENB;
-	sc->sc_cfg2 = ESPCFG2_SCSI2 | ESPCFG2_RPE;
-	sc->sc_cfg3 = ESPCFG3_CDB;
-	ESP_WRITE_REG(sc, ESP_CFG2, sc->sc_cfg2);
-
-	if ((ESP_READ_REG(sc, ESP_CFG2) & ~ESPCFG2_RSVD) != (ESPCFG2_SCSI2 | ESPCFG2_RPE)) {
-		printf(": ESP100");
-		sc->sc_rev = ESP100;
+	sc->sc_cfg1 = sc->sc_id | NCRCFG1_PARENB;
+	sc->sc_cfg2 = NCRCFG2_SCSI2 | NCRCFG2_RPE;
+	sc->sc_cfg3 = NCRCFG3_CDB;
+	NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
+
+	if ((NCR_READ_REG(sc, NCR_CFG2) & ~NCRCFG2_RSVD) !=
+	    (NCRCFG2_SCSI2 | NCRCFG2_RPE)) {
+		sc->sc_rev = NCR_VARIANT_ESP100;
 	} else {
-		sc->sc_cfg2 = ESPCFG2_SCSI2;
-		ESP_WRITE_REG(sc, ESP_CFG2, sc->sc_cfg2);
+		sc->sc_cfg2 = NCRCFG2_SCSI2;
+		NCR_WRITE_REG(sc, NCR_CFG2, sc->sc_cfg2);
 		sc->sc_cfg3 = 0;
-		ESP_WRITE_REG(sc, ESP_CFG3, sc->sc_cfg3);
-		sc->sc_cfg3 = (ESPCFG3_CDB | ESPCFG3_FCLK);
-		ESP_WRITE_REG(sc, ESP_CFG3, sc->sc_cfg3);
-		if (ESP_READ_REG(sc, ESP_CFG3) != (ESPCFG3_CDB | ESPCFG3_FCLK)) {
-			printf(": ESP100A");
-			sc->sc_rev = ESP100A;
+		NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
+		sc->sc_cfg3 = (NCRCFG3_CDB | NCRCFG3_FCLK);
+		NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
+		if (NCR_READ_REG(sc, NCR_CFG3) !=
+		    (NCRCFG3_CDB | NCRCFG3_FCLK)) {
+			sc->sc_rev = NCR_VARIANT_ESP100A;
 		} else {
-			/* ESPCFG2_FE enables > 64K transfers */
-			sc->sc_cfg2 |= ESPCFG2_FE;
+			/* NCRCFG2_FE enables > 64K transfers */
+			sc->sc_cfg2 |= NCRCFG2_FE;
 			sc->sc_cfg3 = 0;
-			ESP_WRITE_REG(sc, ESP_CFG3, sc->sc_cfg3);
-			printf(": ESP200");
-			sc->sc_rev = ESP200;
+			NCR_WRITE_REG(sc, NCR_CFG3, sc->sc_cfg3);
+			sc->sc_rev = NCR_VARIANT_ESP200;
 		}
 	}
 
 	/*
+	 * XXX minsync and maxxfer _should_ be set up in MI code,
+	 * XXX but it appears to have some dependency on what sort
+	 * XXX of DMA we're hooked up to, etc.
+	 */
+
+	/*
 	 * This is the value used to start sync negotiations
-	 * Note that the ESP register "SYNCTP" is programmed
+	 * Note that the NCR register "SYNCTP" is programmed
 	 * in "clocks per byte", and has a minimum value of 4.
 	 * The SCSI period used in negotiation is one-fourth
 	 * of the time (in nanoseconds) needed to transfer one byte.
@@ -262,78 +340,45 @@ espattach(parent, self, aux)
 
 	/*
 	 * Alas, we must now modify the value a bit, because it's
-	 * only valid when can switch on FASTCLK and FASTSCSI bits
-	 * in config register 3...
+	 * only valid when can switch on FASTCLK and FASTSCSI bits  
+	 * in config register 3... 
 	 */
 	switch (sc->sc_rev) {
-	case ESP100:
+	case NCR_VARIANT_ESP100:
 		sc->sc_maxxfer = 64 * 1024;
 		sc->sc_minsync = 0;	/* No synch on old chip? */
 		break;
-	case ESP100A:
+
+	case NCR_VARIANT_ESP100A:
 		sc->sc_maxxfer = 64 * 1024;
-		sc->sc_minsync = esp_cpb2stp(sc, 5); /* Min clocks/byte is 5 */
+		/* Min clocks/byte is 5 */
+		sc->sc_minsync = ncr53c9x_cpb2stp(sc, 5);
 		break;
-	case ESP200:
+
+	case NCR_VARIANT_ESP200:
 		sc->sc_maxxfer = 16 * 1024 * 1024;
 		/* XXX - do actually set FAST* bits */
+		break;
 	}
 
-	sc->sc_ccf = FREQTOCCF(sc->sc_freq);
-
-	/* The value *must not* be == 1. Make it 2 */
-	if (sc->sc_ccf == 1)
-		sc->sc_ccf = 2;
-
-	/*
-	 * The recommended timeout is 250ms. This register is loaded
-	 * with a value calculated as follows, from the docs:
-	 *
-	 *		(timout period) x (CLK frequency)
-	 *	reg = -------------------------------------
-	 *		 8192 x (Clock Conversion Factor)
-	 *
-	 * Since CCF has a linear relation to CLK, this generally computes
-	 * to the constant of 153.
-	 */
-	sc->sc_timeout = ((250 * 1000) * sc->sc_freq) / (8192 * sc->sc_ccf);
-
-	/* CCF register only has 3 bits; 0 is actually 8 */
-	sc->sc_ccf &= 7;
-
-	/* Reset state & bus */
-	sc->sc_state = 0;
-	esp_init(sc, 1);
-
-	printf(" %dMhz, target %d\n", sc->sc_freq, sc->sc_id);
-
 	/* add me to the sbus structures */
-	sc->sc_sd.sd_reset = (void *) esp_reset;
+	esc->sc_sd.sd_reset = (void *) ncr53c9x_reset;
 #if defined(SUN4C) || defined(SUN4M)
 	if (ca->ca_bustype == BUS_SBUS) {
 		if (dmachild)
-			sbus_establish(&sc->sc_sd, sc->sc_dev.dv_parent);
+			sbus_establish(&esc->sc_sd, sc->sc_dev.dv_parent);
 		else
-			sbus_establish(&sc->sc_sd, &sc->sc_dev);
+			sbus_establish(&esc->sc_sd, &sc->sc_dev);
 	}
 #endif /* SUN4C || SUN4M */
 
 	/* and the interuppts */
-	sc->sc_ih.ih_fun = (void *) espintr;
-	sc->sc_ih.ih_arg = sc;
-	intr_establish(sc->sc_pri, &sc->sc_ih);
+	esc->sc_ih.ih_fun = (void *) ncr53c9x_intr;
+	esc->sc_ih.ih_arg = sc;
+	intr_establish(esc->sc_pri, &esc->sc_ih);
 	evcnt_attach(&sc->sc_dev, "intr", &sc->sc_intrcnt);
 
 	/*
-	 * fill in the prototype scsi_link.
-	 */
-	sc->sc_link.adapter_softc = sc;
-	sc->sc_link.adapter_target = sc->sc_id;
-	sc->sc_link.adapter = &esp_switch;
-	sc->sc_link.device = &esp_dev;
-	sc->sc_link.openings = 2;
-
-	/*
 	 * If the boot path is "esp" at the moment and it's me, then
 	 * walk our pointer to the sub-device, ready for the config
 	 * below.
@@ -352,1622 +397,104 @@ espattach(parent, self, aux)
 		break;
 	}
 
-	/*
-	 * Now try to attach all the sub-devices
-	 */
-	config_found(self, &sc->sc_link, espprint);
-
-	bootpath_store(1, NULL);
-}
-
-/*
- * This is the generic esp reset function. It does not reset the SCSI bus,
- * only this controllers, but kills any on-going commands, and also stops
- * and resets the DMA.
- *
- * After reset, registers are loaded with the defaults from the attach
- * routine above.
- */
-void
-esp_reset(sc)
-	struct esp_softc *sc;
-{
-
-	/* reset DMA first */
-	DMA_RESET(sc->sc_dma);
+	/* Do the common parts of attachment. */
+	ncr53c9x_attach(sc, &esp_switch, &esp_dev);
 
-	/* reset SCSI chip */
-	ESPCMD(sc, ESPCMD_RSTCHIP);
-	ESPCMD(sc, ESPCMD_NOP);
-	DELAY(500);
+	/* Turn on target selection using the `dma' method */
+	ncr53c9x_dmaselect = 1;
 
-	/* do these backwards, and fall through */
-	switch (sc->sc_rev) {
-	case ESP200:
-		ESP_WRITE_REG(sc, ESP_CFG3, sc->sc_cfg3);
-	case ESP100A:
-		ESP_WRITE_REG(sc, ESP_CFG2, sc->sc_cfg2);
-	case ESP100:
-		ESP_WRITE_REG(sc, ESP_CFG1, sc->sc_cfg1);
-		ESP_WRITE_REG(sc, ESP_CCF, sc->sc_ccf);
-		ESP_WRITE_REG(sc, ESP_SYNCOFF, 0);
-		ESP_WRITE_REG(sc, ESP_TIMEOUT, sc->sc_timeout);
-		break;
-	default:
-		printf("%s: unknown revision code, assuming ESP100\n",
-		    sc->sc_dev.dv_xname);
-		ESP_WRITE_REG(sc, ESP_CFG1, sc->sc_cfg1);
-		ESP_WRITE_REG(sc, ESP_CCF, sc->sc_ccf);
-		ESP_WRITE_REG(sc, ESP_SYNCOFF, 0);
-		ESP_WRITE_REG(sc, ESP_TIMEOUT, sc->sc_timeout);
-	}
+	bootpath_store(1, NULL);
 }
 
 /*
- * Reset the SCSI bus, but not the chip
+ * Glue functions.
  */
-void
-esp_scsi_reset(sc)
-	struct esp_softc *sc;
-{
-	/* stop DMA first, as the chip will return to Bus Free phase */
-	DMACSR(sc->sc_dma) &= ~D_EN_DMA;
-
-	printf("esp: resetting SCSI bus\n");
-	ESPCMD(sc, ESPCMD_RSTSCSI);
-}
 
-/*
- * Initialize esp state machine
- */
-void
-esp_init(sc, doreset)
-	struct esp_softc *sc;
-	int doreset;
+u_char
+esp_read_reg(sc, reg)
+	struct ncr53c9x_softc *sc;
+	int reg;
 {
-	struct ecb *ecb;
-	int r;
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-	ESP_TRACE(("[ESP_INIT(%d)] ", doreset));
-
-	if (sc->sc_state == 0) {	/* First time through */
-		TAILQ_INIT(&sc->ready_list);
-		TAILQ_INIT(&sc->nexus_list);
-		TAILQ_INIT(&sc->free_list);
-		sc->sc_nexus = NULL;
-		ecb = sc->sc_ecb;
-		bzero(ecb, sizeof(sc->sc_ecb));
-		for (r = 0; r < sizeof(sc->sc_ecb) / sizeof(*ecb); r++) {
-			TAILQ_INSERT_TAIL(&sc->free_list, ecb, chain);
-			ECB_SETQ(ecb, ECB_QFREE);
-			ecb++;
-		}
-		bzero(sc->sc_tinfo, sizeof(sc->sc_tinfo));
-	} else {
-		sc->sc_flags |= ESP_ABORTING;
-		sc->sc_state = ESP_IDLE;
-		ecb = sc->sc_nexus;
-		if (ecb != NULL) {
-			ecb->xs->error = XS_TIMEOUT;
-			esp_done(ecb);
-			sc->sc_nexus = NULL;
-		}
-		while ((ecb = sc->nexus_list.tqh_first) != NULL) {
-			ecb->xs->error = XS_TIMEOUT;
-			esp_done(ecb);
-		}
-	}
-
-	/*
-	 * reset the chip to a known state
-	 */
-	esp_reset(sc);
-
-	sc->sc_phase = sc->sc_prevphase = INVALID_PHASE;
-	for (r = 0; r < 8; r++) {
-		struct esp_tinfo *tp = &sc->sc_tinfo[r];
-/* XXX - config flags per target: low bits: no reselect; high bits: no synch */
-		int fl = sc->sc_dev.dv_cfdata->cf_flags;
-
-		tp->flags = ((sc->sc_minsync && !(fl & (1<<(r+8))))
-				? T_NEGOTIATE : 0) |
-				((fl & (1<<r)) ? T_RSELECTOFF : 0) |
-				T_NEED_TO_RESET;
-		tp->period = sc->sc_minsync;
-		tp->offset = 0;
-	}
-	sc->sc_flags &= ~ESP_ABORTING;
-
-	if (doreset) {
-		sc->sc_state = ESP_SBR;
-		ESPCMD(sc, ESPCMD_RSTSCSI);
-		return;
-	}
-
-	sc->sc_state = ESP_IDLE;
-	esp_sched(sc);
-	return;
+	return (esc->sc_reg[reg * 4]);
 }
 
-/*
- * Read the ESP registers, and save their contents for later use.
- * ESP_STAT, ESP_STEP & ESP_INTR are mostly zeroed out when reading
- * ESP_INTR - so make sure it is the last read.
- *
- * I think that (from reading the docs) most bits in these registers
- * only make sense when he DMA CSR has an interrupt showing. Call only
- * if an interrupt is pending.
- */
 void
-espreadregs(sc)
-	struct esp_softc *sc;
+esp_write_reg(sc, reg, val)
+	struct ncr53c9x_softc *sc;
+	int reg;
+	u_char val;
 {
+	struct esp_softc *esc = (struct esp_softc *)sc;
+	u_char v = val;
 
-	sc->sc_espstat = ESP_READ_REG(sc, ESP_STAT);
-	/* Only the stepo bits are of interest */
-	sc->sc_espstep = ESP_READ_REG(sc, ESP_STEP) & ESPSTEP_MASK;
-	sc->sc_espintr = ESP_READ_REG(sc, ESP_INTR);
-
-	/*
-	 * Determine the SCSI bus phase, return either a real SCSI bus phase
-	 * or some pseudo phase we use to detect certain exceptions.
-	 */
-
-	sc->sc_phase = (sc->sc_espintr & ESPINTR_DIS)
-			? /* Disconnected */ BUSFREE_PHASE
-			: sc->sc_espstat & ESPSTAT_PHASE;
-
-	ESP_MISC(("regs[intr=%02x,stat=%02x,step=%02x] ",
-		sc->sc_espintr, sc->sc_espstat, sc->sc_espstep));
+	esc->sc_reg[reg * 4] = v;
 }
 
-/*
- * Convert Synchronous Transfer Period to chip register Clock Per Byte value.
- */
 int
-esp_stp2cpb(sc, period)
-	struct esp_softc *sc;
-	int period;
+esp_dma_isintr(sc)
+	struct ncr53c9x_softc *sc;
 {
-	int v;
-	v = (sc->sc_freq * period) / 250;
-	if (esp_cpb2stp(sc, v) < period)
-		/* Correct round-down error */
-		v++;
-	return v;
-}
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-/*
- * Convert chip register Clock Per Byte value to Synchronous Transfer Period.
- */
-int
-esp_cpb2stp(sc, cpb)
-	struct esp_softc *sc;
-	int cpb;
-{
-	return ((250 * cpb) / sc->sc_freq);
+	return (DMA_ISINTR(esc->sc_dma));
 }
 
-/*
- * Send a command to a target, set the driver state to ESP_SELECTING
- * and let the caller take care of the rest.
- *
- * Keeping this as a function allows me to say that this may be done
- * by DMA instead of programmed I/O soon.
- */
 void
-espselect(sc, target, lun, cmd, clen)
-	struct esp_softc *sc;
-	u_char target, lun;
-	u_char *cmd;
-	u_char clen;
+esp_dma_reset(sc)
+	struct ncr53c9x_softc *sc;
 {
-	struct esp_tinfo *ti = &sc->sc_tinfo[target];
-	int i;
-
-	ESP_TRACE(("[espselect(t%d,l%d,cmd:%x)] ", target, lun, *(u_char *)cmd));
-
-	/* new state ESP_SELECTING */
-	sc->sc_state = ESP_SELECTING;
-
-	ESPCMD(sc, ESPCMD_FLUSH);
-
-	/*
-	 * The docs say the target register is never reset, and I
-	 * can't think of a better place to set it
-	 */
-	ESP_WRITE_REG(sc, ESP_SELID, target);
-	if (ti->flags & T_SYNCMODE) {
-		ESP_WRITE_REG(sc, ESP_SYNCOFF, ti->offset);
-		ESP_WRITE_REG(sc, ESP_SYNCTP, esp_stp2cpb(sc, ti->period));
-	} else {
-		ESP_WRITE_REG(sc, ESP_SYNCOFF, 0);
-		ESP_WRITE_REG(sc, ESP_SYNCTP, 0);
-	}
-
-	/*
-	 * Who am I. This is where we tell the target that we are
-	 * happy for it to disconnect etc.
-	 */
-	ESP_WRITE_REG(sc, ESP_FIFO,
-		MSG_IDENTIFY(lun, (ti->flags & T_RSELECTOFF)?0:1));
-
-	if (ti->flags & T_NEGOTIATE) {
-		/* Arbitrate, select and stop after IDENTIFY message */
-		ESPCMD(sc, ESPCMD_SELATNS);
-		return;
-	}
-
-	/* Now the command into the FIFO */
-	for (i = 0; i < clen; i++)
-		ESP_WRITE_REG(sc, ESP_FIFO, *cmd++);
-
-	/* And get the targets attention */
-	ESPCMD(sc, ESPCMD_SELATN);
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
+	DMA_RESET(esc->sc_dma);
 }
 
-/*
- * DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS
- */
-
-/*
- * Start a SCSI-command
- * This function is called by the higher level SCSI-driver to queue/run
- * SCSI-commands.
- */
 int
-esp_scsi_cmd(xs)
-	struct scsi_xfer *xs;
+esp_dma_intr(sc)
+	struct ncr53c9x_softc *sc;
 {
-	struct scsi_link *sc_link = xs->sc_link;
-	struct esp_softc *sc = sc_link->adapter_softc;
-	struct ecb 	*ecb;
-	int s, flags;
-
-	ESP_TRACE(("[esp_scsi_cmd] "));
-	ESP_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
-	    sc_link->target));
-
-	flags = xs->flags;
-
-	/* Get a esp command block */
-	s = splbio();
-	ecb = sc->free_list.tqh_first;
-	if (ecb) {
-		TAILQ_REMOVE(&sc->free_list, ecb, chain);
-		ECB_SETQ(ecb, ECB_QNONE);
-	}
-	splx(s);
-
-	if (ecb == NULL) {
-		ESP_MISC(("TRY_AGAIN_LATER"));
-		return TRY_AGAIN_LATER;
-	}
-
-	/* Initialize ecb */
-	ecb->xs = xs;
-	bcopy(xs->cmd, &ecb->cmd, xs->cmdlen);
-	ecb->clen = xs->cmdlen;
-	ecb->daddr = xs->data;
-	ecb->dleft = xs->datalen;
-	ecb->stat = 0;
-
-	s = splbio();
-	TAILQ_INSERT_TAIL(&sc->ready_list, ecb, chain);
-	ECB_SETQ(ecb, ECB_QREADY);
-	timeout(esp_timeout, ecb, (xs->timeout*hz)/1000);
-
-	if (sc->sc_state == ESP_IDLE)
-		esp_sched(sc);
-
-	splx(s);
-
-	if (flags & SCSI_POLL) {
-		/* Not allowed to use interrupts, use polling instead */
-		return esp_poll(sc, ecb);
-	}
-
-	ESP_MISC(("SUCCESSFULLY_QUEUED"));
-	return SUCCESSFULLY_QUEUED;
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
+	return (DMA_INTR(esc->sc_dma));
 }
 
-/*
- * Used when interrupt driven I/O isn't allowed, e.g. during boot.
- */
 int
-esp_poll(sc, ecb)
-	struct esp_softc *sc;
-	struct ecb *ecb;
+esp_dma_setup(sc, addr, len, datain, dmasize)
+	struct ncr53c9x_softc *sc;
+	caddr_t *addr;
+	size_t *len;
+	int datain;
+	size_t *dmasize;
 {
-	struct scsi_xfer *xs = ecb->xs;
-	int count = xs->timeout * 100;
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-	ESP_TRACE(("[esp_poll] "));
-	while (count) {
-		if (DMA_ISINTR(sc->sc_dma)) {
-			espintr(sc);
-		}
-#if alternatively
-		if (ESP_READ_REG(sc, ESP_STAT) & ESPSTAT_INT)
-			espintr(sc);
-#endif
-		if (xs->flags & ITSDONE)
-			break;
-		DELAY(10);
-		if (sc->sc_state == ESP_IDLE) {
-			ESP_TRACE(("[esp_poll: rescheduling] "));
-			esp_sched(sc);
-		}
-		count--;
-	}
-
-	if (count == 0) {
-		ESP_MISC(("esp_poll: timeout"));
-		esp_timeout((caddr_t)ecb);
-	}
-
-	return COMPLETE;
+	return (DMA_SETUP(esc->sc_dma, addr, len, datain, dmasize));
 }
 
-
-/*
- * LOW LEVEL SCSI UTILITIES
- */
-
-/*
- * Schedule a scsi operation.  This has now been pulled out of the interrupt
- * handler so that we may call it from esp_scsi_cmd and esp_done.  This may
- * save us an unecessary interrupt just to get things going.  Should only be
- * called when state == ESP_IDLE and at bio pl.
- */
 void
-esp_sched(sc)
-	struct esp_softc *sc;
+esp_dma_go(sc)
+	struct ncr53c9x_softc *sc;
 {
-	struct scsi_link *sc_link;
-	struct ecb *ecb;
-	int t;
-
-	ESP_TRACE(("[esp_sched] "));
-	if (sc->sc_state != ESP_IDLE)
-		panic("esp_sched: not IDLE (state=%d)", sc->sc_state);
-
-	if (sc->sc_flags & ESP_ABORTING)
-		return;
-
-	/*
-	 * Find first ecb in ready queue that is for a target/lunit
-	 * combinations that is not busy.
-	 */
-	for (ecb = sc->ready_list.tqh_first; ecb; ecb = ecb->chain.tqe_next) {
-		sc_link = ecb->xs->sc_link;
-		t = sc_link->target;
-		if (!(sc->sc_tinfo[t].lubusy & (1 << sc_link->lun))) {
-			struct esp_tinfo *ti = &sc->sc_tinfo[t];
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-			if ((ecb->flags & ECB_QBITS) != ECB_QREADY)
-				panic("esp: busy entry on ready list");
-			TAILQ_REMOVE(&sc->ready_list, ecb, chain);
-			ECB_SETQ(ecb, ECB_QNONE);
-			sc->sc_nexus = ecb;
-			sc->sc_flags = 0;
-			sc->sc_prevphase = INVALID_PHASE;
-			sc->sc_dp = ecb->daddr;
-			sc->sc_dleft = ecb->dleft;
-			ti->lubusy |= (1<<sc_link->lun);
-/*XXX*/if (sc->sc_msgpriq) {
-	printf("esp: message queue not empty: %x!\n", sc->sc_msgpriq);
-}
-/*XXX*/sc->sc_msgpriq = sc->sc_msgout = 0;
-			espselect(sc, t, sc_link->lun,
-				  (u_char *)&ecb->cmd, ecb->clen);
-			break;
-		} else
-			ESP_MISC(("%d:%d busy\n", t, sc_link->lun));
-	}
+	DMA_GO(esc->sc_dma);
 }
 
-/*
- * POST PROCESSING OF SCSI_CMD (usually current)
- */
-void
-esp_done(ecb)
-	struct ecb *ecb;
-{
-	struct scsi_xfer *xs = ecb->xs;
-	struct scsi_link *sc_link = xs->sc_link;
-	struct esp_softc *sc = sc_link->adapter_softc;
-	struct esp_tinfo *ti = &sc->sc_tinfo[sc_link->target];
-
-	ESP_TRACE(("[esp_done(error:%x)] ", xs->error));
-
-	untimeout(esp_timeout, ecb);
-
-	/*
-	 * Now, if we've come here with no error code, i.e. we've kept the
-	 * initial XS_NOERROR, and the status code signals that we should
-	 * check sense, we'll need to set up a request sense cmd block and
-	 * push the command back into the ready queue *before* any other
-	 * commands for this target/lunit, else we lose the sense info.
-	 * We don't support chk sense conditions for the request sense cmd.
-	 */
-	if (xs->error == XS_NOERROR) {
-		if ((ecb->flags & ECB_ABORTED) != 0) {
-			xs->error = XS_TIMEOUT;
-		} else if ((ecb->flags & ECB_CHKSENSE) != 0) {
-			xs->error = XS_SENSE;
-		} else if ((ecb->stat & ST_MASK) == SCSI_CHECK) {
-			struct scsi_sense *ss = (void *)&ecb->cmd;
-			ESP_MISC(("requesting sense "));
-			/* First, save the return values */
-			xs->resid = ecb->dleft;
-			xs->status = ecb->stat;
-			/* Next, setup a request sense command block */
-			bzero(ss, sizeof(*ss));
-			ss->opcode = REQUEST_SENSE;
-			/*ss->byte2 = sc_link->lun << 5;*/
-			ss->length = sizeof(struct scsi_sense_data);
-			ecb->clen = sizeof(*ss);
-			ecb->daddr = (char *)&xs->sense;
-			ecb->dleft = sizeof(struct scsi_sense_data);
-			ecb->flags |= ECB_CHKSENSE;
-/*XXX - must take off queue here */
-			if (ecb != sc->sc_nexus) {
-				panic("%s: esp_sched: floating ecb %p",
-					sc->sc_dev.dv_xname, ecb);
-			}
-			TAILQ_INSERT_HEAD(&sc->ready_list, ecb, chain);
-			ECB_SETQ(ecb, ECB_QREADY);
-			ti->lubusy &= ~(1<<sc_link->lun);
-			ti->senses++;
-			timeout(esp_timeout, ecb, (xs->timeout*hz)/1000);
-			if (sc->sc_nexus == ecb) {
-				sc->sc_nexus = NULL;
-				sc->sc_state = ESP_IDLE;
-				esp_sched(sc);
-			}
-			return;
-		} else {
-			xs->resid = ecb->dleft;
-		}
-	}
-
-	xs->flags |= ITSDONE;
-
-#ifdef ESP_DEBUG
-	if (esp_debug & ESP_SHOWMISC) {
-		printf("err=0x%02x ",xs->error);
-		if (xs->error == XS_SENSE) {
-			printf("sense=%2x; ", xs->sense.error_code);
-		}
-	}
-	if ((xs->resid || xs->error > XS_SENSE) && esp_debug & ESP_SHOWMISC) {
-		if (xs->resid)
-			printf("esp_done: resid=%d\n", xs->resid);
-		if (xs->error)
-			printf("esp_done: error=%d\n", xs->error);
-	}
-#endif
-
-	/*
-	 * Remove the ECB from whatever queue it's on.
-	 */
-	switch (ecb->flags & ECB_QBITS) {
-	case ECB_QNONE:
-		if (ecb != sc->sc_nexus) {
-			panic("%s: floating ecb", sc->sc_dev.dv_xname);
-		}
-		sc->sc_nexus = NULL;
-		sc->sc_state = ESP_IDLE;
-		ti->lubusy &= ~(1<<sc_link->lun);
-		esp_sched(sc);
-		break;
-	case ECB_QREADY:
-		TAILQ_REMOVE(&sc->ready_list, ecb, chain);
-		break;
-	case ECB_QNEXUS:
-		TAILQ_REMOVE(&sc->nexus_list, ecb, chain);
-		ti->lubusy &= ~(1<<sc_link->lun);
-		break;
-	case ECB_QFREE:
-		panic("%s: dequeue: busy ecb on free list",
-			sc->sc_dev.dv_xname);
-		break;
-	default:
-		panic("%s: dequeue: unknown queue %d",
-			sc->sc_dev.dv_xname, ecb->flags & ECB_QBITS);
-	}
-
-	/* Put it on the free list, and clear flags. */
-	TAILQ_INSERT_HEAD(&sc->free_list, ecb, chain);
-	ecb->flags = ECB_QFREE;
-
-	ti->cmds++;
-	scsi_done(xs);
-	return;
-}
-
-/*
- * INTERRUPT/PROTOCOL ENGINE
- */
-
-/*
- * Schedule an outgoing message by prioritizing it, and asserting
- * attention on the bus. We can only do this when we are the initiator
- * else there will be an illegal command interrupt.
- */
-#define esp_sched_msgout(m) \
-	do {				\
-		ESP_MISC(("esp_sched_msgout %d ", m)); \
-		ESPCMD(sc, ESPCMD_SETATN);	\
-		sc->sc_msgpriq |= (m);	\
-	} while (0)
-
-#define IS1BYTEMSG(m) (((m) != 1 && (m) < 0x20) || (m) & 0x80)
-#define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
-#define ISEXTMSG(m) ((m) == 1)
-
-/*
- * Get an incoming message as initiator.
- *
- * The SCSI bus must already be in MESSAGE_IN_PHASE and there is a
- * byte in the FIFO
- */
 void
-esp_msgin(sc)
-	register struct esp_softc *sc;
+esp_dma_stop(sc)
+	struct ncr53c9x_softc *sc;
 {
-	register int v;
-
-	ESP_TRACE(("[esp_msgin(curmsglen:%d)] ", sc->sc_imlen));
-
-	if ((ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) == 0) {
-		printf("%s: msgin: no msg byte available\n",
-			sc->sc_dev.dv_xname);
-		return;
-	}
-
-	/*
-	 * Prepare for a new message.  A message should (according
-	 * to the SCSI standard) be transmitted in one single
-	 * MESSAGE_IN_PHASE. If we have been in some other phase,
-	 * then this is a new message.
-	 */
-	if (sc->sc_prevphase != MESSAGE_IN_PHASE) {
-		sc->sc_flags &= ~ESP_DROP_MSGI;
-		sc->sc_imlen = 0;
-	}
-
-	v = ESP_READ_REG(sc, ESP_FIFO);
-	ESP_MISC(("<msgbyte:0x%02x>", v));
-
-#if 0
-	if (sc->sc_state == ESP_RESELECTED && sc->sc_imlen == 0) {
-		/*
-		 * Which target is reselecting us? (The ID bit really)
-		 */
-		sc->sc_selid = v;
-		sc->sc_selid &= ~(1<<sc->sc_id);
-		ESP_MISC(("selid=0x%2x ", sc->sc_selid));
-		return;
-	}
-#endif
-
-	sc->sc_imess[sc->sc_imlen] = v;
-
-	/*
-	 * If we're going to reject the message, don't bother storing
-	 * the incoming bytes.  But still, we need to ACK them.
-	 */
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-	if ((sc->sc_flags & ESP_DROP_MSGI)) {
-		ESPCMD(sc, ESPCMD_SETATN);
-		ESPCMD(sc, ESPCMD_MSGOK);
-		printf("<dropping msg byte %x>",
-			sc->sc_imess[sc->sc_imlen]);
-		return;
-	}
-
-	if (sc->sc_imlen >= ESP_MAX_MSG_LEN) {
-		esp_sched_msgout(SEND_REJECT);
-		sc->sc_flags |= ESP_DROP_MSGI;
-	} else {
-		sc->sc_imlen++;
-		/*
-		 * This testing is suboptimal, but most
-		 * messages will be of the one byte variety, so
-		 * it should not effect performance
-		 * significantly.
-		 */
-		if (sc->sc_imlen == 1 && IS1BYTEMSG(sc->sc_imess[0]))
-			goto gotit;
-		if (sc->sc_imlen == 2 && IS2BYTEMSG(sc->sc_imess[0]))
-			goto gotit;
-		if (sc->sc_imlen >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
-		    sc->sc_imlen == sc->sc_imess[1] + 2)
-			goto gotit;
-	}
-	/* Ack what we have so far */
-	ESPCMD(sc, ESPCMD_MSGOK);
-	return;
-
-gotit:
-	ESP_MSGS(("gotmsg(%x)", sc->sc_imess[0]));
-	/*
-	 * Now we should have a complete message (1 byte, 2 byte
-	 * and moderately long extended messages).  We only handle
-	 * extended messages which total length is shorter than
-	 * ESP_MAX_MSG_LEN.  Longer messages will be amputated.
-	 */
-	if (sc->sc_state == ESP_HASNEXUS) {
-		struct ecb *ecb = sc->sc_nexus;
-		struct esp_tinfo *ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
-
-		switch (sc->sc_imess[0]) {
-		case MSG_CMDCOMPLETE:
-			ESP_MSGS(("cmdcomplete "));
-			if (sc->sc_dleft < 0) {
-				struct scsi_link *sc_link = ecb->xs->sc_link;
-				printf("esp: %d extra bytes from %d:%d\n",
-					-sc->sc_dleft,
-					sc_link->target, sc_link->lun);
-				sc->sc_dleft = 0;
-			}
-			ecb->xs->resid = ecb->dleft = sc->sc_dleft;
-			sc->sc_flags |= ESP_BUSFREE_OK;
-			break;
-
-		case MSG_MESSAGE_REJECT:
-			if (esp_debug & ESP_SHOWMSGS)
-				printf("%s: our msg rejected by target\n",
-				    sc->sc_dev.dv_xname);
-#if 1 /* XXX - must remember last message */
-sc_print_addr(ecb->xs->sc_link); printf("MSG_MESSAGE_REJECT>>");
-#endif
-			if (sc->sc_flags & ESP_SYNCHNEGO) {
-				ti->period = ti->offset = 0;
-				sc->sc_flags &= ~ESP_SYNCHNEGO;
-				ti->flags &= ~T_NEGOTIATE;
-			}
-			/* Not all targets understand INITIATOR_DETECTED_ERR */
-			if (sc->sc_msgout == SEND_INIT_DET_ERR)
-				esp_sched_msgout(SEND_ABORT);
-			break;
-		case MSG_NOOP:
-			ESP_MSGS(("noop "));
-			break;
-		case MSG_DISCONNECT:
-			ESP_MSGS(("disconnect "));
-			ti->dconns++;
-			sc->sc_flags |= ESP_DISCON;
-			sc->sc_flags |= ESP_BUSFREE_OK;
-			if ((ecb->xs->sc_link->quirks & SDEV_AUTOSAVE) == 0)
-				break;
-			/*FALLTHROUGH*/
-		case MSG_SAVEDATAPOINTER:
-			ESP_MSGS(("save datapointer "));
-			ecb->dleft = sc->sc_dleft;
-			ecb->daddr = sc->sc_dp;
-			break;
-		case MSG_RESTOREPOINTERS:
-			ESP_MSGS(("restore datapointer "));
-			if (!ecb) {
-				esp_sched_msgout(SEND_ABORT);
-				printf("%s: no DATAPOINTERs to restore\n",
-				    sc->sc_dev.dv_xname);
-				break;
-			}
-			sc->sc_dp = ecb->daddr;
-			sc->sc_dleft = ecb->dleft;
-			break;
-		case MSG_PARITY_ERROR:
-			printf("%s:target%d: MSG_PARITY_ERROR\n",
-				sc->sc_dev.dv_xname,
-				ecb->xs->sc_link->target);
-			break;
-		case MSG_EXTENDED:
-			ESP_MSGS(("extended(%x) ", sc->sc_imess[2]));
-			switch (sc->sc_imess[2]) {
-			case MSG_EXT_SDTR:
-				ESP_MSGS(("SDTR period %d, offset %d ",
-					sc->sc_imess[3], sc->sc_imess[4]));
-				ti->period = sc->sc_imess[3];
-				ti->offset = sc->sc_imess[4];
-				if (sc->sc_minsync == 0) {
-					/* We won't do synch */
-					ti->offset = 0;
-					esp_sched_msgout(SEND_SDTR);
-				} else if (ti->offset == 0) {
-					printf("%s:%d: async\n", "esp",
-						ecb->xs->sc_link->target);
-					ti->offset = 0;
-					sc->sc_flags &= ~ESP_SYNCHNEGO;
-				} else if (ti->period > 124) {
-					printf("%s:%d: async\n", "esp",
-						ecb->xs->sc_link->target);
-					ti->offset = 0;
-					esp_sched_msgout(SEND_SDTR);
-				} else {
-					int r = 250/ti->period;
-					int s = (100*250)/ti->period - 100*r;
-					int p;
-					p =  esp_stp2cpb(sc, ti->period);
-					ti->period = esp_cpb2stp(sc, p);
-#ifdef ESP_DEBUG
-					sc_print_addr(ecb->xs->sc_link);
-#endif
-					if ((sc->sc_flags&ESP_SYNCHNEGO) == 0) {
-						/* Target initiated negotiation */
-						if (ti->flags & T_SYNCMODE) {
-						    ti->flags &= ~T_SYNCMODE;
-#ifdef ESP_DEBUG
-						    printf("renegotiated ");
-#endif
-						}
-						ESP_WRITE_REG(sc, ESP_SYNCOFF,
-							      0);
-						ESP_WRITE_REG(sc, ESP_SYNCTP,
-							      0);
-						/* Clamp to our maxima */
-						if (ti->period < sc->sc_minsync)
-							ti->period = sc->sc_minsync;
-						if (ti->offset > 15)
-							ti->offset = 15;
-						esp_sched_msgout(SEND_SDTR);
-					} else {
-						/* we are sync */
-						sc->sc_flags &= ~ESP_SYNCHNEGO;
-						ESP_WRITE_REG(sc, ESP_SYNCOFF,
-							      ti->offset);
-						ESP_WRITE_REG(sc, ESP_SYNCTP,
-							      p);
-						ti->flags |= T_SYNCMODE;
-					}
-#ifdef ESP_DEBUG
-					printf("max sync rate %d.%02dMb/s\n",
-					        r, s);
-#endif
-				}
-				ti->flags &= ~T_NEGOTIATE;
-				break;
-			default: /* Extended messages we don't handle */
-				ESPCMD(sc, ESPCMD_SETATN);
-				break;
-			}
-			break;
-		default:
-			ESP_MSGS(("ident "));
-			/* thanks for that ident... */
-			if (!MSG_ISIDENTIFY(sc->sc_imess[0])) {
-				ESP_MISC(("unknown "));
-printf("%s: unimplemented message: %d\n", sc->sc_dev.dv_xname, sc->sc_imess[0]);
-				ESPCMD(sc, ESPCMD_SETATN);
-			}
-			break;
-		}
-	} else if (sc->sc_state == ESP_RESELECTED) {
-		struct scsi_link *sc_link = NULL;
-		struct ecb *ecb;
-		struct esp_tinfo *ti;
-		u_char lunit;
-
-		if (MSG_ISIDENTIFY(sc->sc_imess[0])) { 	/* Identify? */
-			ESP_MISC(("searching "));
-			/*
-			 * Search wait queue for disconnected cmd
-			 * The list should be short, so I haven't bothered with
-			 * any more sophisticated structures than a simple
-			 * singly linked list.
-			 */
-			lunit = sc->sc_imess[0] & 0x07;
-			for (ecb = sc->nexus_list.tqh_first; ecb;
-			     ecb = ecb->chain.tqe_next) {
-				sc_link = ecb->xs->sc_link;
-				if (sc_link->lun == lunit &&
-				    sc->sc_selid == (1<<sc_link->target)) {
-					TAILQ_REMOVE(&sc->nexus_list, ecb,
-					    chain);
-					ECB_SETQ(ecb, ECB_QNONE);
-					break;
-				}
-			}
-
-			if (!ecb) {		/* Invalid reselection! */
-				esp_sched_msgout(SEND_ABORT);
-				printf("esp: invalid reselect (idbit=0x%2x)\n",
-				    sc->sc_selid);
-			} else {		/* Reestablish nexus */
-				/*
-				 * Setup driver data structures and
-				 * do an implicit RESTORE POINTERS
-				 */
-				ti = &sc->sc_tinfo[sc_link->target];
-				sc->sc_nexus = ecb;
-				sc->sc_dp = ecb->daddr;
-				sc->sc_dleft = ecb->dleft;
-				sc->sc_tinfo[sc_link->target].lubusy
-					|= (1<<sc_link->lun);
-				if (ti->flags & T_SYNCMODE) {
-					ESP_WRITE_REG(sc, ESP_SYNCOFF,
-						ti->offset);
-					ESP_WRITE_REG(sc, ESP_SYNCTP,
-						esp_stp2cpb(sc, ti->period));
-				} else {
-					ESP_WRITE_REG(sc, ESP_SYNCOFF, 0);
-					ESP_WRITE_REG(sc, ESP_SYNCTP, 0);
-				}
-				ESP_MISC(("... found ecb"));
-				sc->sc_state = ESP_HASNEXUS;
-			}
-		} else {
-			printf("%s: bogus reselect (no IDENTIFY) %0x2x\n",
-			    sc->sc_dev.dv_xname, sc->sc_selid);
-			esp_sched_msgout(SEND_DEV_RESET);
-		}
-	} else { /* Neither ESP_HASNEXUS nor ESP_RESELECTED! */
-		printf("%s: unexpected message in; will send DEV_RESET\n",
-		    sc->sc_dev.dv_xname);
-		esp_sched_msgout(SEND_DEV_RESET);
-	}
-
-	/* Ack last message byte */
-	ESPCMD(sc, ESPCMD_MSGOK);
-
-	/* Done, reset message pointer. */
-	sc->sc_flags &= ~ESP_DROP_MSGI;
-	sc->sc_imlen = 0;
+	DMACSR(esc->sc_dma) &= ~D_EN_DMA;
 }
 
-
-/*
- * Send the highest priority, scheduled message
- */
-void
-esp_msgout(sc)
-	register struct esp_softc *sc;
-{
-	struct esp_tinfo *ti;
-	struct ecb *ecb;
-	size_t size;
-
-	ESP_TRACE(("[esp_msgout(priq:%x, prevphase:%x)]", sc->sc_msgpriq, sc->sc_prevphase));
-
-	if (sc->sc_prevphase != MESSAGE_OUT_PHASE) {
-		/* Pick up highest priority message */
-		sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
-		sc->sc_omlen = 1;		/* "Default" message len */
-		switch (sc->sc_msgout) {
-		case SEND_SDTR:
-			ecb = sc->sc_nexus;
-			ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
-			sc->sc_omess[0] = MSG_EXTENDED;
-			sc->sc_omess[1] = 3;
-			sc->sc_omess[2] = MSG_EXT_SDTR;
-			sc->sc_omess[3] = ti->period;
-			sc->sc_omess[4] = ti->offset;
-			sc->sc_omlen = 5;
-			break;
-		case SEND_IDENTIFY:
-			if (sc->sc_state != ESP_HASNEXUS) {
-				printf("esp at line %d: no nexus", __LINE__);
-			}
-			ecb = sc->sc_nexus;
-			sc->sc_omess[0] = MSG_IDENTIFY(ecb->xs->sc_link->lun,0);
-			break;
-		case SEND_DEV_RESET:
-			sc->sc_omess[0] = MSG_BUS_DEV_RESET;
-			sc->sc_flags |= ESP_BUSFREE_OK;
-			ecb = sc->sc_nexus;
-			ti = &sc->sc_tinfo[ecb->xs->sc_link->target];
-			ti->flags &= ~T_SYNCMODE;
-			ti->flags |= T_NEGOTIATE;
-			break;
-		case SEND_PARITY_ERROR:
-			sc->sc_omess[0] = MSG_PARITY_ERROR;
-			break;
-		case SEND_ABORT:
-			sc->sc_omess[0] = MSG_ABORT;
-			sc->sc_flags |= ESP_BUSFREE_OK;
-			break;
-		case SEND_INIT_DET_ERR:
-			sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
-			break;
-		case SEND_REJECT:
-			sc->sc_omess[0] = MSG_MESSAGE_REJECT;
-			break;
-		default:
-			sc->sc_omess[0] = MSG_NOOP;
-			break;
-		}
-		sc->sc_omp = sc->sc_omess;
-	}
-
-#if 1
-	/* (re)send the message */
-	size = min(sc->sc_omlen, sc->sc_maxxfer);
-	DMA_SETUP(sc->sc_dma, &sc->sc_omp, &sc->sc_omlen, 0, &size);
-	/* Program the SCSI counter */
-	ESP_WRITE_REG(sc, ESP_TCL, size);
-	ESP_WRITE_REG(sc, ESP_TCM, size >> 8);
-	if (sc->sc_cfg2 & ESPCFG2_FE) {
-		ESP_WRITE_REG(sc, ESP_TCH, size >> 16);
-	}
-	/* load the count in */
-	ESPCMD(sc, ESPCMD_NOP|ESPCMD_DMA);
-	ESPCMD(sc, (size==0?ESPCMD_TRPAD:ESPCMD_TRANS)|ESPCMD_DMA);
-	DMA_GO(sc->sc_dma);
-#else
-	{	int i;
-		ESPCMD(sc, ESPCMD_FLUSH);
-		for (i = 0; i < sc->sc_omlen; i++)
-			ESP_WRITE_REG(sc, FIFO, sc->sc_omess[i]);
-		ESPCMD(sc, ESPCMD_TRANS);
-#if test_stuck_on_msgout
-printf("<<XXXmsgoutdoneXXX>>");
-#endif
-	}
-#endif
-}
-
-/*
- * This is the most critical part of the driver, and has to know
- * how to deal with *all* error conditions and phases from the SCSI
- * bus. If there are no errors and the DMA was active, then call the
- * DMA pseudo-interrupt handler. If this returns 1, then that was it
- * and we can return from here without further processing.
- *
- * Most of this needs verifying.
- */
 int
-espintr(sc)
-	register struct esp_softc *sc;
+esp_dma_isactive(sc)
+	struct ncr53c9x_softc *sc;
 {
-	register struct ecb *ecb;
-	register struct scsi_link *sc_link;
-	struct esp_tinfo *ti;
-	int loop;
-	size_t size;
-
-	ESP_TRACE(("[espintr]"));
-
-	/*
-	 * I have made some (maybe seriously flawed) assumptions here,
-	 * but basic testing (uncomment the printf() below), show that
-	 * certainly something happens when this loop is here.
-	 *
-	 * The idea is that many of the SCSI operations take very little
-	 * time, and going away and getting interrupted is too high an
-	 * overhead to pay. For example, selecting, sending a message
-	 * and command and then doing some work can be done in one "pass".
-	 *
-	 * The DELAY is not variable because I do not understand that the
-	 * DELAY loop should be fixed-time regardless of CPU speed, but
-	 * I am *assuming* that the faster SCSI processors get things done
-	 * quicker (sending a command byte etc), and so there is no
-	 * need to be too slow.
-	 *
-	 * This is a heuristic. It is 2 when at 20Mhz, 2 at 25Mhz and 1
-	 * at 40Mhz. This needs testing.
-	 */
-	for (loop = 0; 1;loop++, DELAY(50/sc->sc_freq)) {
-		/* a feeling of deja-vu */
-		if (!DMA_ISINTR(sc->sc_dma))
-			return (loop != 0);
-#if 0
-		if (loop)
-			printf("*");
-#endif
-
-		/* and what do the registers say... */
-		espreadregs(sc);
-
-		sc->sc_intrcnt.ev_count++;
-
-		/*
-		 * At the moment, only a SCSI Bus Reset or Illegal
-		 * Command are classed as errors. A disconnect is a
-		 * valid condition, and we let the code check is the
-		 * "ESP_BUSFREE_OK" flag was set before declaring it
-		 * and error.
-		 *
-		 * Also, the status register tells us about "Gross
-		 * Errors" and "Parity errors". Only the Gross Error
-		 * is really bad, and the parity errors are dealt
-		 * with later
-		 *
-		 * TODO
-		 *	If there are too many parity error, go to slow
-		 *	cable mode ?
-		 */
-
-		/* SCSI Reset */
-		if (sc->sc_espintr & ESPINTR_SBR) {
-			if (ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) {
-				ESPCMD(sc, ESPCMD_FLUSH);
-				DELAY(1);
-			}
-			if (sc->sc_state != ESP_SBR) {
-				printf("%s: SCSI bus reset\n",
-					sc->sc_dev.dv_xname);
-				esp_init(sc, 0); /* Restart everything */
-				return 1;
-			}
-#if 0
-	/*XXX*/		printf("<expected bus reset: "
-				"[intr %x, stat %x, step %d]>\n",
-				sc->sc_espintr, sc->sc_espstat,
-				sc->sc_espstep);
-#endif
-			if (sc->sc_nexus)
-				panic("%s: nexus in reset state",
-				      sc->sc_dev.dv_xname);
-			sc->sc_state = ESP_IDLE;
-			esp_sched(sc);
-			return 1;
-		}
-
-		ecb = sc->sc_nexus;
-
-#define ESPINTR_ERR (ESPINTR_SBR|ESPINTR_ILL)
-		if (sc->sc_espintr & ESPINTR_ERR ||
-		    sc->sc_espstat & ESPSTAT_GE) {
-
-			if (sc->sc_espstat & ESPSTAT_GE) {
-				/* no target ? */
-				if (ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) {
-					ESPCMD(sc, ESPCMD_FLUSH);
-					DELAY(1);
-				}
-				if (sc->sc_state == ESP_HASNEXUS ||
-				    sc->sc_state == ESP_SELECTING) {
-					ecb->xs->error = XS_DRIVER_STUFFUP;
-					esp_done(ecb);
-				}
-				return 1;
-			}
-
-			if (sc->sc_espintr & ESPINTR_ILL) {
-				/* illegal command, out of sync ? */
-				printf("%s: illegal command: 0x%x (state %d, phase %x, prevphase %x)\n",
-					sc->sc_dev.dv_xname, sc->sc_lastcmd,
-					sc->sc_state, sc->sc_phase,
-					sc->sc_prevphase);
-				if (ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) {
-					ESPCMD(sc, ESPCMD_FLUSH);
-					DELAY(1);
-				}
-				esp_init(sc, 0); /* Restart everything */
-				return 1;
-			}
-		}
-
-		/*
-		 * Call if DMA is active.
-		 *
-		 * If DMA_INTR returns true, then maybe go 'round the loop
-		 * again in case there is no more DMA queued, but a phase
-		 * change is expected.
-		 */
-		if (DMA_ISACTIVE(sc->sc_dma)) {
-			DMA_INTR(sc->sc_dma);
-			/* If DMA active here, then go back to work... */
-			if (DMA_ISACTIVE(sc->sc_dma))
-				return 1;
-
-			if (sc->sc_dleft == 0 &&
-			    (sc->sc_espstat & ESPSTAT_TC) == 0)
-				printf("%s: !TC [intr %x, stat %x, step %d]"
-				       " prevphase %x, resid %x\n",
-					sc->sc_dev.dv_xname,
-					sc->sc_espintr,
-					sc->sc_espstat,
-					sc->sc_espstep,
-					sc->sc_prevphase,
-					ecb?ecb->dleft:-1);
-		}
-
-#if 0	/* Unreliable on some ESP revisions? */
-		if ((sc->sc_espstat & ESPSTAT_INT) == 0) {
-			printf("%s: spurious interrupt\n", sc->sc_dev.dv_xname);
-			return 1;
-		}
-#endif
-
-		/*
-		 * check for less serious errors
-		 */
-		if (sc->sc_espstat & ESPSTAT_PE) {
-			printf("%s: SCSI bus parity error\n",
-				sc->sc_dev.dv_xname);
-			if (sc->sc_prevphase == MESSAGE_IN_PHASE)
-				esp_sched_msgout(SEND_PARITY_ERROR);
-			else
-				esp_sched_msgout(SEND_INIT_DET_ERR);
-		}
+	struct esp_softc *esc = (struct esp_softc *)sc;
 
-		if (sc->sc_espintr & ESPINTR_DIS) {
-			ESP_MISC(("<DISC [intr %x, stat %x, step %d]>",
-				sc->sc_espintr,sc->sc_espstat,sc->sc_espstep));
-			if (ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) {
-				ESPCMD(sc, ESPCMD_FLUSH);
-				DELAY(1);
-			}
-			/*
-			 * This command must (apparently) be issued within
-			 * 250mS of a disconnect. So here you are...
-			 */
-			ESPCMD(sc, ESPCMD_ENSEL);
-			if (sc->sc_state != ESP_IDLE) {
-				if ((sc->sc_flags & ESP_SYNCHNEGO)) {
-#ifdef ESP_DEBUG
-					if (ecb)
-						sc_print_addr(ecb->xs->sc_link);
-					printf("sync nego not completed!\n");
-#endif
-					sc->sc_flags &= ~ESP_SYNCHNEGO;
-					sc->sc_tinfo[ecb->xs->sc_link->target].offset = 0;
-					sc->sc_tinfo[ecb->xs->sc_link->target].flags &= ~T_NEGOTIATE;
-				}
-			/*XXX*/sc->sc_msgpriq = sc->sc_msgout = 0;
-
-				/* it may be OK to disconnect */
-				if (!(sc->sc_flags & ESP_BUSFREE_OK)) {
-					if (sc->sc_state == ESP_HASNEXUS) {
-						sc_print_addr(ecb->xs->sc_link);
-						printf("disconnect without"
-							"warning\n");
-					}
-					ecb->xs->error = XS_TIMEOUT;
-				} else if (sc->sc_flags & ESP_DISCON) {
-					TAILQ_INSERT_HEAD(&sc->nexus_list, ecb, chain);
-					ECB_SETQ(ecb, ECB_QNEXUS);
-					sc->sc_nexus = NULL;
-					sc->sc_flags &= ~ESP_DISCON;
-					sc->sc_state = ESP_IDLE;
-#if ESP_DEBUG
-if ((esp_debug & 0x10000) && ecb->dleft == 0) {
-	printf("%s: silly disconnect (ecb %p [stat %x])\n",
-		sc->sc_dev.dv_xname, ecb, ecb->stat);
-}
-#endif
-					esp_sched(sc);
-					return 1;
-				}
-
-				esp_done(ecb);
-				return 1;
-			}
-			printf("%s: DISCONNECT in IDLE state!\n",
-				sc->sc_dev.dv_xname);
-		}
-
-		/* did a message go out OK ? This must be broken */
-		if (sc->sc_prevphase == MESSAGE_OUT_PHASE &&
-		    sc->sc_phase != MESSAGE_OUT_PHASE) {
-			/* we have sent it */
-			if (sc->sc_msgout == SEND_SDTR &&
-			    (sc->sc_flags & ESP_SYNCHNEGO) == 0) {
-				/* We've just accepted new sync parameters */
-				sc->sc_tinfo[ecb->xs->sc_link->target].flags |=
-					T_SYNCMODE;
-if (ecb) sc_print_addr(ecb->xs->sc_link);else printf("NO nexus: ");
-printf("target put in SYNC mode\n");
-			}
-			sc->sc_msgpriq &= ~sc->sc_msgout;
-			sc->sc_msgout = 0;
-		}
-
-		switch (sc->sc_state) {
-
-		case ESP_SBR:
-			printf("%s: waiting for SCSI Bus Reset to happen\n",
-				sc->sc_dev.dv_xname);
-			return 1;
-
-		case ESP_RESELECTED:
-			/*
-			 * we must be continuing a message ?
-			 */
-			if (sc->sc_phase != MESSAGE_IN_PHASE) {
-				printf("%s: target didn't identify\n",
-					sc->sc_dev.dv_xname);
-				esp_init(sc, 1);
-				return 1;
-			}
-printf("<<RESELECT CONT'd>>");
-#if XXXX
-			esp_msgin(sc);
-			if (sc->sc_state != ESP_HASNEXUS) {
-				/* IDENTIFY fail?! */
-				printf("%s: identify failed\n",
-					sc->sc_dev.dv_xname);
-				esp_init(sc, 1);
-				return 1;
-			}
-#endif
-			break;
-
-		case ESP_IDLE:
-if (sc->sc_flags & ESP_ICCS) printf("[[esp: BUMMER]]");
-		case ESP_SELECTING:
-
-			if (sc->sc_espintr & ESPINTR_RESEL) {
-				/*
-				 * If we're trying to select a
-				 * target ourselves, push our command
-				 * back into the ready list.
-				 */
-				if (sc->sc_state == ESP_SELECTING) {
-					ESP_MISC(("backoff selector "));
-					sc_link = sc->sc_nexus->xs->sc_link;
-					ti = &sc->sc_tinfo[sc_link->target];
-					TAILQ_INSERT_HEAD(&sc->ready_list,
-					    sc->sc_nexus, chain);
-					ECB_SETQ(sc->sc_nexus, ECB_QREADY);
-					ti->lubusy &= ~(1<<sc_link->lun);
-					ecb = sc->sc_nexus = NULL;
-				}
-				sc->sc_state = ESP_RESELECTED;
-				if (sc->sc_phase != MESSAGE_IN_PHASE) {
-					/*
-					 * Things are seriously fucked up.
-					 * Pull the brakes, i.e. reset
-					 */
-					printf("%s: target didn't identify\n",
-						sc->sc_dev.dv_xname);
-					esp_init(sc, 1);
-					return 1;
-				}
-				if ((ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) != 2) {
-					printf("%s: RESELECT: %d bytes in FIFO!\n",
-						sc->sc_dev.dv_xname,
-						ESP_READ_REG(sc, ESP_FFLAG) &
-						ESPFIFO_FF);
-					esp_init(sc, 1);
-					return 1;
-				}
-				sc->sc_selid = ESP_READ_REG(sc, ESP_FIFO);
-				sc->sc_selid &= ~(1<<sc->sc_id);
-				ESP_MISC(("selid=0x%2x ", sc->sc_selid));
-				esp_msgin(sc);	/* Handle identify message */
-				if (sc->sc_state != ESP_HASNEXUS) {
-					/* IDENTIFY fail?! */
-					printf("%s: identify failed\n",
-						sc->sc_dev.dv_xname);
-					esp_init(sc, 1);
-					return 1;
-				}
-				continue; /* ie. next phase expected soon */
-			}
-
-#define	ESPINTR_DONE	(ESPINTR_FC|ESPINTR_BS)
-			if ((sc->sc_espintr & ESPINTR_DONE) == ESPINTR_DONE) {
-				ecb = sc->sc_nexus;
-				if (!ecb)
-					panic("esp: not nexus at sc->sc_nexus");
-
-				sc_link = ecb->xs->sc_link;
-				ti = &sc->sc_tinfo[sc_link->target];
-
-				switch (sc->sc_espstep) {
-				case 0:
-					printf("%s: select timeout/no disconnect\n",
-						sc->sc_dev.dv_xname);
-					esp_abort(sc, ecb);
-					return 1;
-				case 1:
-					if ((ti->flags & T_NEGOTIATE) == 0) {
-						printf("%s: step 1 & !NEG\n",
-							sc->sc_dev.dv_xname);
-						esp_abort(sc, ecb);
-						return 1;
-					}
-					if (sc->sc_phase != MESSAGE_OUT_PHASE) {
-						printf("%s: !MSGOUT\n",
-							sc->sc_dev.dv_xname);
-						esp_abort(sc, ecb);
-						return 1;
-					}
-					/* Start negotiating */
-					ti->period = sc->sc_minsync;
-					ti->offset = 15;
-					sc->sc_msgpriq = SEND_SDTR;
-					sc->sc_flags |= ESP_SYNCHNEGO;
-					break;
-				case 3:
-					/*
-					 * Grr, this is supposed to mean
-					 * "target left command phase
-					 *  prematurely". It seems to happen
-					 * regularly when sync mode is on.
-					 * Look at FIFO to see if command
-					 * went out.
-					 * (Timing problems?)
-					 */
-					if ((ESP_READ_REG(sc, ESP_FFLAG)&ESPFIFO_FF) == 0) {
-						/* Hope for the best.. */
-						break;
-					}
-					printf("(%s:%d:%d): selection failed;"
-						" %d left in FIFO "
-						"[intr %x, stat %x, step %d]\n",
-						sc->sc_dev.dv_xname,
-						sc_link->target,
-						sc_link->lun,
-						ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF,
-						sc->sc_espintr, sc->sc_espstat,
-						sc->sc_espstep);
-					ESPCMD(sc, ESPCMD_FLUSH);
-					sc->sc_flags |= ESP_ABORTING;
-					esp_sched_msgout(SEND_ABORT);
-					return 1;
-				case 2:
-					/* Select stuck at Command Phase */
-					ESPCMD(sc, ESPCMD_FLUSH);
-				case 4:
-					/* So far, everything went fine */
-					sc->sc_msgpriq = 0;
-					break;
-				}
-#if 0
-/* Why set msgpriq? (and not raise ATN) */
-				if (ecb->xs->flags & SCSI_RESET)
-					sc->sc_msgpriq = SEND_DEV_RESET;
-				else if (ti->flags & T_NEGOTIATE)
-					sc->sc_msgpriq =
-					    SEND_IDENTIFY | SEND_SDTR;
-				else
-					sc->sc_msgpriq = SEND_IDENTIFY;
-#endif
-				sc->sc_state = ESP_HASNEXUS;
-				/*???sc->sc_flags = 0; */
-				sc->sc_prevphase = INVALID_PHASE; /* ?? */
-				sc->sc_dp = ecb->daddr;
-				sc->sc_dleft = ecb->dleft;
-				ti->lubusy |= (1<<sc_link->lun);
-				break;
-			} else {
-				printf("%s: unexpected status after select"
-					": [intr %x, stat %x, step %x]\n",
-					sc->sc_dev.dv_xname,
-					sc->sc_espintr, sc->sc_espstat,
-					sc->sc_espstep);
-				ESPCMD(sc, ESPCMD_FLUSH);
-				DELAY(1);
-				esp_abort(sc, ecb);
-			}
-			if (sc->sc_state == ESP_IDLE) {
-				printf("%s: stray interrupt\n", sc->sc_dev.dv_xname);
-					return 0;
-			}
-			break;
-
-		case ESP_HASNEXUS:
-			if (sc->sc_flags & ESP_ICCS) {
-				unsigned char msg;
-
-				sc->sc_flags &= ~ESP_ICCS;
-
-				if (!(sc->sc_espintr & ESPINTR_DONE)) {
-					printf("%s: ICCS: "
-					      ": [intr %x, stat %x, step %x]\n",
-						sc->sc_dev.dv_xname,
-						sc->sc_espintr, sc->sc_espstat,
-						sc->sc_espstep);
-				}
-				if ((ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) != 2) {
-					printf("%s: ICCS: expected 2, got %d "
-					      ": [intr %x, stat %x, step %x]\n",
-						sc->sc_dev.dv_xname,
-						ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF,
-						sc->sc_espintr, sc->sc_espstat,
-						sc->sc_espstep);
-					ESPCMD(sc, ESPCMD_FLUSH);
-					esp_abort(sc, ecb);
-					return 1;
-				}
-				ecb->stat = ESP_READ_REG(sc, ESP_FIFO);
-				msg = ESP_READ_REG(sc, ESP_FIFO);
-				ESP_PHASE(("<stat:(%x,%x)>", ecb->stat, msg));
-				if (msg == MSG_CMDCOMPLETE) {
-					sc->sc_flags |= ESP_BUSFREE_OK;
-					ecb->xs->resid = ecb->dleft = sc->sc_dleft;
-				} else
-					printf("%s: STATUS_PHASE: msg %d\n",
-						sc->sc_dev.dv_xname, msg);
-				ESPCMD(sc, ESPCMD_MSGOK);
-				continue; /* ie. wait for disconnect */
-			}
-			break;
-		default:
-			panic("%s: invalid state: %d",
-			      sc->sc_dev.dv_xname,
-			      sc->sc_state);
-		}
-
-		/*
-		 * Driver is now in state ESP_HASNEXUS, i.e. we
-		 * have a current command working the SCSI bus.
-		 */
-		if (sc->sc_state != ESP_HASNEXUS || ecb == NULL) {
-			panic("esp no nexus");
-		}
-
-		switch (sc->sc_phase) {
-		case MESSAGE_OUT_PHASE:
-			ESP_PHASE(("MESSAGE_OUT_PHASE "));
-			esp_msgout(sc);
-			sc->sc_prevphase = MESSAGE_OUT_PHASE;
-			break;
-		case MESSAGE_IN_PHASE:
-			ESP_PHASE(("MESSAGE_IN_PHASE "));
-			if (sc->sc_espintr & ESPINTR_BS) {
-				ESPCMD(sc, ESPCMD_FLUSH);
-				sc->sc_flags |= ESP_WAITI;
-				ESPCMD(sc, ESPCMD_TRANS);
-			} else if (sc->sc_espintr & ESPINTR_FC) {
-				if ((sc->sc_flags & ESP_WAITI) == 0) {
-					printf("%s: MSGIN: unexpected FC bit: "
-						"[intr %x, stat %x, step %x]\n",
-					sc->sc_dev.dv_xname,
-					sc->sc_espintr, sc->sc_espstat,
-					sc->sc_espstep);
-				}
-				sc->sc_flags &= ~ESP_WAITI;
-				esp_msgin(sc);
-			} else {
-				printf("%s: MSGIN: weird bits: "
-					"[intr %x, stat %x, step %x]\n",
-					sc->sc_dev.dv_xname,
-					sc->sc_espintr, sc->sc_espstat,
-					sc->sc_espstep);
-			}
-			sc->sc_prevphase = MESSAGE_IN_PHASE;
-			break;
-		case COMMAND_PHASE: {
-			/* well, this means send the command again */
-			u_char *cmd = (u_char *)&ecb->cmd;
-			int i;
-
-			ESP_PHASE(("COMMAND_PHASE 0x%02x (%d) ",
-				ecb->cmd.opcode, ecb->clen));
-			if (ESP_READ_REG(sc, ESP_FFLAG) & ESPFIFO_FF) {
-				ESPCMD(sc, ESPCMD_FLUSH);
-				DELAY(1);
-			}
-			/* Now the command into the FIFO */
-			for (i = 0; i < ecb->clen; i++)
-				ESP_WRITE_REG(sc, ESP_FIFO, *cmd++);
-			ESPCMD(sc, ESPCMD_TRANS);
-			sc->sc_prevphase = COMMAND_PHASE;
-			}
-			break;
-		case DATA_OUT_PHASE:
-			ESP_PHASE(("DATA_OUT_PHASE [%d] ",  sc->sc_dleft));
-			ESPCMD(sc, ESPCMD_FLUSH);
-			size = min(sc->sc_dleft, sc->sc_maxxfer);
-			DMA_SETUP(sc->sc_dma, &sc->sc_dp, &sc->sc_dleft,
-				  0, &size);
-			sc->sc_prevphase = DATA_OUT_PHASE;
-			goto setup_xfer;
-		case DATA_IN_PHASE:
-			ESP_PHASE(("DATA_IN_PHASE "));
-			if (sc->sc_rev == ESP100)
-				ESPCMD(sc, ESPCMD_FLUSH);
-			size = min(sc->sc_dleft, sc->sc_maxxfer);
-			DMA_SETUP(sc->sc_dma, &sc->sc_dp, &sc->sc_dleft,
-				  1, &size);
-			sc->sc_prevphase = DATA_IN_PHASE;
-		setup_xfer:
-			/* Program the SCSI counter */
-			ESP_WRITE_REG(sc, ESP_TCL, size);
-			ESP_WRITE_REG(sc, ESP_TCM, size >> 8);
-			if (sc->sc_cfg2 & ESPCFG2_FE) {
-				ESP_WRITE_REG(sc, ESP_TCH, size >> 16);
-			}
-			/* load the count in */
-			ESPCMD(sc, ESPCMD_NOP|ESPCMD_DMA);
-
-			/*
-			 * Note that if `size' is 0, we've already transceived
-			 * all the bytes we want but we're still in DATA PHASE.
-			 * Apparently, the device needs padding. Also, a
-			 * transfer size of 0 means "maximum" to the chip
-			 * DMA logic.
-			 */
-			ESPCMD(sc,
-			       (size==0?ESPCMD_TRPAD:ESPCMD_TRANS)|ESPCMD_DMA);
-			DMA_GO(sc->sc_dma);
-			return 1;
-		case STATUS_PHASE:
-			ESP_PHASE(("STATUS_PHASE "));
-			sc->sc_flags |= ESP_ICCS;
-			ESPCMD(sc, ESPCMD_ICCS);
-			sc->sc_prevphase = STATUS_PHASE;
-			break;
-		case INVALID_PHASE:
-			break;
-		case BUSFREE_PHASE:
-			if (sc->sc_flags & ESP_BUSFREE_OK) {
-				/*It's fun the 1st time.. */
-				sc->sc_flags &= ~ESP_BUSFREE_OK;
-			}
-			break;
-		default:
-			panic("esp: bogus bus phase\n");
-		}
-	}
-	panic("esp: should not get here..");
-}
-
-void
-esp_abort(sc, ecb)
-	struct esp_softc *sc;
-	struct ecb *ecb;
-{
-	if (ecb == sc->sc_nexus) {
-		if (sc->sc_state == ESP_HASNEXUS) {
-			sc->sc_flags |= ESP_ABORTING;
-			esp_sched_msgout(SEND_ABORT);
-		}
-	} else {
-		if (sc->sc_state == ESP_IDLE)
-			esp_sched(sc);
-	}
-}
-
-void
-esp_timeout(arg)
-	void *arg;
-{
-	int s = splbio();
-	struct ecb *ecb = (struct ecb *)arg;
-	struct esp_softc *sc;
-	struct scsi_xfer *xs = ecb->xs;
-
-	sc = xs->sc_link->adapter_softc;
-	sc_print_addr(xs->sc_link);
-again:
-	printf("%s: timed out [ecb %p (flags 0x%x, dleft %x, stat %x)], "
-	       "<state %d, nexus %p, phase(c %x, p %x), resid %x, msg(q %x,o %x) %s>",
-		sc->sc_dev.dv_xname,
-		ecb, ecb->flags, ecb->dleft, ecb->stat,
-		sc->sc_state, sc->sc_nexus, sc->sc_phase, sc->sc_prevphase,
-		sc->sc_dleft, sc->sc_msgpriq, sc->sc_msgout,
-		DMA_ISACTIVE(sc->sc_dma) ? "DMA active" : "");
-#if ESP_DEBUG > 0
-	printf("TRACE: %s.", ecb->trace);
-#endif
-
-	if (ecb->flags & ECB_ABORTED) {
-		/* abort timed out */
-		printf(" AGAIN\n");
-		esp_init(sc, 1);
-	} else {
-		/* abort the operation that has timed out */
-		printf("\n");
-		xs->error = XS_TIMEOUT;
-		ecb->flags |= ECB_ABORTED;
-		esp_abort(sc, ecb);
-		/* 2 secs for the abort */
-		if ((xs->flags & SCSI_POLL) == 0)
-			timeout(esp_timeout, ecb, 2 * hz);
-		else {
-			int count = 200000;
-			while (count) {
-				if (DMA_ISINTR(sc->sc_dma)) {
-					espintr(sc);
-				}
-				if (xs->flags & ITSDONE)
-					break;
-				DELAY(10);
-				--count;
-			}
-			if (count == 0)
-				goto again;
-		}
-	}
-	splx(s);
+	return (DMA_ISACTIVE(esc->sc_dma));
 }
diff --git a/sys/arch/sparc/dev/espreg.h b/sys/arch/sparc/dev/espreg.h
deleted file mode 100644
index e08eebcad7c..00000000000
--- a/sys/arch/sparc/dev/espreg.h
+++ /dev/null
@@ -1,148 +0,0 @@
-/*	$NetBSD: espreg.h,v 1.7 1995/12/18 23:58:39 pk Exp $ */
-
-/*
- * Copyright (c) 1994 Peter Galbavy.  All rights reserved.
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by Peter Galbavy.
- * 4. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * Register addresses, relative to some base address
- */
-
-#define	ESP_TCL		0x00		/* RW - Transfer Count Low	*/
-#define	ESP_TCM		0x01		/* RW - Transfer Count Mid	*/
-#define	ESP_TCH		0x0e		/* RW - Transfer Count High	*/
-					/*	NOT on 53C90		*/
-
-#define	ESP_FIFO	0x02		/* RW - FIFO data		*/
-
-#define	ESP_CMD		0x03		/* RW - Command (2 deep)	*/
-#define  ESPCMD_DMA	0x80		/*	DMA Bit			*/
-#define  ESPCMD_NOP	0x00		/*	No Operation		*/
-#define  ESPCMD_FLUSH	0x01		/*	Flush FIFO		*/
-#define  ESPCMD_RSTCHIP	0x02		/*	Reset Chip		*/
-#define  ESPCMD_RSTSCSI	0x03		/*	Reset SCSI Bus		*/
-#define  ESPCMD_RESEL	0x40		/*	Reselect Sequence	*/
-#define  ESPCMD_SELNATN	0x41		/*	Select without ATN	*/
-#define  ESPCMD_SELATN	0x42		/*	Select with ATN		*/
-#define  ESPCMD_SELATNS	0x43		/*	Select with ATN & Stop	*/
-#define  ESPCMD_ENSEL	0x44		/*	Enable (Re)Selection	*/
-#define  ESPCMD_DISSEL	0x45		/*	Disable (Re)Selection	*/
-#define  ESPCMD_SELATN3	0x46		/*	Select with ATN3	*/
-#define  ESPCMD_RESEL3	0x47		/*	Reselect3 Sequence	*/
-#define  ESPCMD_SNDMSG	0x20		/*	Send Message		*/
-#define  ESPCMD_SNDSTAT	0x21		/*	Send Status		*/
-#define  ESPCMD_SNDDATA	0x22		/*	Send Data		*/
-#define  ESPCMD_DISCSEQ	0x23		/*	Disconnect Sequence	*/
-#define  ESPCMD_TERMSEQ	0x24		/*	Terminate Sequence	*/
-#define  ESPCMD_TCCS	0x25		/*	Target Command Comp Seq	*/
-#define  ESPCMD_DISC	0x27		/*	Disconnect		*/
-#define  ESPCMD_RECMSG	0x28		/*	Receive Message		*/
-#define  ESPCMD_RECCMD	0x29		/*	Receive Command 	*/
-#define  ESPCMD_RECDATA	0x2a		/*	Receive Data		*/
-#define  ESPCMD_RECCSEQ	0x2b		/*	Receive Command Sequence*/
-#define  ESPCMD_ABORT	0x04		/*	Target Abort DMA	*/
-#define  ESPCMD_TRANS	0x10		/*	Transfer Information	*/
-#define  ESPCMD_ICCS	0x11		/*	Initiator Cmd Comp Seq 	*/
-#define  ESPCMD_MSGOK	0x12		/*	Message Accepted	*/
-#define  ESPCMD_TRPAD	0x18		/*	Transfer Pad		*/
-#define  ESPCMD_SETATN	0x1a		/*	Set ATN			*/
-#define  ESPCMD_RSTATN	0x1b		/*	Reset ATN		*/
-
-#define	ESP_STAT	0x04		/* RO - Status			*/
-#define  ESPSTAT_INT	0x80		/*	Interrupt		*/
-#define  ESPSTAT_GE	0x40		/*	Gross Error		*/
-#define  ESPSTAT_PE	0x20		/*	Parity Error		*/
-#define  ESPSTAT_TC	0x10		/*	Terminal Count		*/
-#define  ESPSTAT_VGC	0x08		/*	Valid Group Code	*/
-#define  ESPSTAT_PHASE	0x07		/*	Phase bits		*/
-
-#define	ESP_SELID	0x04		/* WO - Select/Reselect Bus ID	*/
-
-#define	ESP_INTR	0x05		/* RO - Interrupt		*/
-#define  ESPINTR_SBR	0x80		/*	SCSI Bus Reset		*/
-#define  ESPINTR_ILL	0x40		/*	Illegal Command		*/
-#define  ESPINTR_DIS	0x20		/*	Disconnect		*/
-#define  ESPINTR_BS	0x10		/*	Bus Service		*/
-#define  ESPINTR_FC	0x08		/*	Function Complete	*/
-#define  ESPINTR_RESEL	0x04		/*	Reselected		*/
-#define  ESPINTR_SELATN	0x02		/*	Select with ATN		*/
-#define  ESPINTR_SEL	0x01		/*	Selected		*/
-
-#define	ESP_TIMEOUT	0x05		/* WO - Select/Reselect Timeout */
-
-#define	ESP_STEP	0x06		/* RO - Sequence Step		*/
-#define  ESPSTEP_MASK	0x07		/*	the last 3 bits		*/
-#define  ESPSTEP_DONE	0x04		/*	command went out	*/
-
-#define	ESP_SYNCTP	0x06		/* WO - Synch Transfer Period	*/
-					/*	Default 5 (53C9X)	*/
-
-#define	ESP_FFLAG	0x07		/* RO - FIFO Flags		*/
-#define  ESPFIFO_SS	0xe0		/*	Sequence Step (Dup)	*/
-#define  ESPFIFO_FF	0x1f		/*	Bytes in FIFO		*/
-
-#define	ESP_SYNCOFF	0x07		/* WO - Synch Offset		*/
-					/*	0 = ASYNC		*/
-					/*	1 - 15 = SYNC bytes	*/
-
-#define	ESP_CFG1	0x08		/* RW - Configuration #1	*/
-#define  ESPCFG1_SLOW	0x80		/*	Slow Cable Mode		*/
-#define  ESPCFG1_SRR	0x40		/*	SCSI Reset Rep Int Dis	*/
-#define  ESPCFG1_PTEST	0x20		/*	Parity Test Mod		*/
-#define  ESPCFG1_PARENB	0x10		/*	Enable Parity Check	*/
-#define  ESPCFG1_CTEST	0x08		/*	Enable Chip Test	*/
-#define  ESPCFG1_BUSID	0x07		/*	Bus ID			*/
-
-#define	ESP_CCF		0x09		/* WO -	Clock Conversion Factor	*/
-					/*	0 = 35.01 - 40Mhz	*/
-					/*	NEVER SET TO 1		*/
-					/*	2 = 10Mhz		*/
-					/*	3 = 10.01 - 15Mhz	*/
-					/*	4 = 15.01 - 20Mhz	*/
-					/*	5 = 20.01 - 25Mhz	*/
-					/*	6 = 25.01 - 30Mhz	*/
-					/*	7 = 30.01 - 35Mhz	*/
-
-#define	ESP_TEST	0x0a		/* WO - Test (Chip Test Only)	*/
-
-#define	ESP_CFG2	0x0b		/* RW - Configuration #2	*/
-#define	 ESPCFG2_RSVD	0xa0		/*	reserved		*/
-#define  ESPCFG2_FE	0x40		/* 	Features Enable		*/
-#define  ESPCFG2_DREQ	0x10		/* 	DREQ High Impedance	*/
-#define  ESPCFG2_SCSI2	0x08		/* 	SCSI-2 Enable		*/
-#define  ESPCFG2_BPA	0x04		/* 	Target Bad Parity Abort	*/
-#define  ESPCFG2_RPE	0x02		/* 	Register Parity Error	*/
-#define  ESPCFG2_DPE	0x01		/* 	DMA Parity Error	*/
-
-/* Config #3 only on 53C9X */
-#define	ESP_CFG3	0x0c		/* RW - Configuration #3	*/
-#define	 ESPCFG3_RSVD	0xe0		/*	reserved		*/
-#define  ESPCFG3_IDM	0x10		/*	ID Message Res Check	*/
-#define  ESPCFG3_QTE	0x08		/*	Queue Tag Enable	*/
-#define  ESPCFG3_CDB	0x04		/*	CDB 10-bytes OK		*/
-#define  ESPCFG3_FSCSI	0x02		/*	Fast SCSI		*/
-#define  ESPCFG3_FCLK	0x01		/*	Fast Clock (>25Mhz)	*/
diff --git a/sys/arch/sparc/dev/espvar.h b/sys/arch/sparc/dev/espvar.h
index 8b0b414a08a..32f81278479 100644
--- a/sys/arch/sparc/dev/espvar.h
+++ b/sys/arch/sparc/dev/espvar.h
@@ -1,7 +1,10 @@
-/*	$NetBSD: espvar.h,v 1.13 1996/05/16 20:31:30 pk Exp $ */
+/*	$OpenBSD: espvar.h,v 1.5 1997/08/08 08:25:02 downsj Exp $	*/
+/*	$NetBSD: espvar.h,v 1.19 1997/02/27 01:16:21 thorpej Exp $	*/
 
 /*
- * Copyright (c) 1994 Peter Galbavy.  All rights reserved.
+ * Copyright (c) 1997 Jason R. Thorpe.
+ * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -12,7 +15,8 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *	This product includes software developed by Peter Galbavy.
+ *	This product includes software developed for the NetBSD Project
+ *	by Jason R. Thorpe.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
@@ -28,273 +32,20 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#define ESP_DEBUG 0
-
-#define FREQTOCCF(freq)	(((freq + 4) / 5))
-
-/* esp revisions */
-#define	ESP100		0x01
-#define	ESP100A		0x02
-#define	ESP200		0x03
-
-#if 0
-typedef caddr_t physaddr;
-
-struct esp_dma_seg {
-	physaddr	addr;
-	long		len;
-};
-#endif
-
-/*
- * ECB. Holds additional information for each SCSI command Comments: We
- * need a separate scsi command block because we may need to overwrite it
- * with a request sense command.  Basicly, we refrain from fiddling with
- * the scsi_xfer struct (except do the expected updating of return values).
- * We'll generally update: xs->{flags,resid,error,sense,status} and
- * occasionally xs->retries.
- */
-struct ecb {
-	TAILQ_ENTRY(ecb) chain;
-	struct scsi_xfer *xs;	/* SCSI xfer ctrl block from above */
-	int		flags;	/* Status */
-#define ECB_QNONE	0
-#define ECB_QFREE	1
-#define ECB_QREADY	2
-#define ECB_QNEXUS	3
-#define ECB_QBITS	0x07
-#define ECB_CHKSENSE	0x08
-#define ECB_ABORTED	0x10
-#define ECB_SETQ(e, q)	do (e)->flags = ((e)->flags&~ECB_QBITS)|(q); while(0)
-	struct scsi_generic cmd;  /* SCSI command block */
-	int	 clen;
-	char	*daddr;		/* Saved data pointer */
-	int	 dleft;		/* Residue */
-	u_char 	 stat;		/* SCSI status byte */
-#if ESP_DEBUG > 0
-	char trace[1000];
-#endif
-};
-#if ESP_DEBUG > 0
-#define ECB_TRACE(ecb, msg, a, b) do { \
-	const char *f = "[" msg "]"; \
-	int n = strlen((ecb)->trace); \
-	if (n < (sizeof((ecb)->trace)-100)) \
-		sprintf((ecb)->trace + n, f,  a, b); \
-} while(0)
-#else
-#define ECB_TRACE(ecb, msg, a, b)
-#endif
-
-/*
- * Some info about each (possible) target on the SCSI bus.  This should
- * probably have been a "per target+lunit" structure, but we'll leave it at
- * this for now.  Is there a way to reliably hook it up to sc->fordriver??
- */
-struct esp_tinfo {
-	int	cmds;		/* #commands processed */
-	int	dconns;		/* #disconnects */
-	int	touts;		/* #timeouts */
-	int	perrs;		/* #parity errors */
-	int	senses;		/* #request sense commands sent */
-	ushort	lubusy;		/* What local units/subr. are busy? */
-	u_char  flags;
-#define T_NEED_TO_RESET	0x01	/* Should send a BUS_DEV_RESET */
-#define T_NEGOTIATE	0x02	/* (Re)Negotiate synchronous options */
-#define T_BUSY		0x04	/* Target is busy, i.e. cmd in progress */
-#define T_SYNCMODE	0x08	/* sync mode has been negotiated */
-#define T_SYNCHOFF	0x10	/* .. */
-#define T_RSELECTOFF	0x20	/* .. */
-	u_char  period;		/* Period suggestion */
-	u_char  offset;		/* Offset suggestion */
-} tinfo_t;
-
-/* Register a linenumber (for debugging) */
-#define LOGLINE(p)
-
-#define ESP_SHOWECBS	0x01
-#define ESP_SHOWINTS	0x02
-#define ESP_SHOWCMDS	0x04
-#define ESP_SHOWMISC	0x08
-#define ESP_SHOWTRAC	0x10
-#define ESP_SHOWSTART	0x20
-#define ESP_SHOWPHASE	0x40
-#define ESP_SHOWDMA	0x80
-#define ESP_SHOWCCMDS	0x100
-#define ESP_SHOWMSGS	0x200
-
-#ifdef ESP_DEBUG
-extern int esp_debug;
-#define ESP_ECBS(str)  do {if (esp_debug & ESP_SHOWECBS) printf str;} while (0)
-#define ESP_MISC(str)  do {if (esp_debug & ESP_SHOWMISC) printf str;} while (0)
-#define ESP_INTS(str)  do {if (esp_debug & ESP_SHOWINTS) printf str;} while (0)
-#define ESP_TRACE(str) do {if (esp_debug & ESP_SHOWTRAC) printf str;} while (0)
-#define ESP_CMDS(str)  do {if (esp_debug & ESP_SHOWCMDS) printf str;} while (0)
-#define ESP_START(str) do {if (esp_debug & ESP_SHOWSTART) printf str;}while (0)
-#define ESP_PHASE(str) do {if (esp_debug & ESP_SHOWPHASE) printf str;}while (0)
-#define ESP_DMA(str)   do {if (esp_debug & ESP_SHOWDMA) printf str;}while (0)
-#define ESP_MSGS(str)  do {if (esp_debug & ESP_SHOWMSGS) printf str;}while (0)
-#else
-#define ESP_ECBS(str)
-#define ESP_MISC(str)
-#define ESP_INTS(str)
-#define ESP_TRACE(str)
-#define ESP_CMDS(str)
-#define ESP_START(str)
-#define ESP_PHASE(str)
-#define ESP_DMA(str)
-#endif
-
-#define ESP_MAX_MSG_LEN 8
-
 struct esp_softc {
-	struct device sc_dev;			/* us as a device */
+	struct ncr53c9x_softc sc_ncr53c9x;	/* glue to MI code */
+
 	struct sbusdev sc_sd;			/* sbus device */
 	struct intrhand sc_ih;			/* intr handler */
-	struct evcnt sc_intrcnt;		/* intr count */
-	struct scsi_link sc_link;		/* scsi lint struct */
+
 	volatile u_char *sc_reg;		/* the registers */
 	struct dma_softc *sc_dma;		/* pointer to my dma */
 
-	/* register defaults */
-	u_char	sc_cfg1;			/* Config 1 */
-	u_char	sc_cfg2;			/* Config 2, not ESP100 */
-	u_char	sc_cfg3;			/* Config 3, only ESP200 */
-	u_char	sc_ccf;				/* Clock Conversion */
-	u_char	sc_timeout;
-
-	/* register copies, see espreadregs() */
-	u_char	sc_espintr;
-	u_char	sc_espstat;
-	u_char	sc_espstep;
-	u_char	sc_espfflags;
-
-	/* Lists of command blocks */
-	TAILQ_HEAD(ecb_list, ecb) free_list,
-				  ready_list,
-				  nexus_list;
-
-	struct ecb *sc_nexus;			/* current command */
-	struct ecb sc_ecb[8];			/* one per target */
-	struct esp_tinfo sc_tinfo[8];
-
-	/* Data about the current nexus (updated for every cmd switch) */
-	caddr_t	sc_dp;				/* Current data pointer */
-	ssize_t	sc_dleft;			/* Data left to transfer */
-
-	/* Adapter state */
-	int	sc_phase;		/* Copy of what bus phase we are in */
-	int	sc_prevphase;		/* Copy of what bus phase we were in */
-	u_char	sc_state;		/* State applicable to the adapter */
-	u_char	sc_flags;
-	u_char	sc_selid;
-	u_char	sc_lastcmd;
-
-	/* Message stuff */
-	u_char	sc_msgpriq;	/* One or more messages to send (encoded) */
-	u_char	sc_msgout;	/* What message is on its way out? */
-	u_char	sc_omess[ESP_MAX_MSG_LEN];
-	caddr_t	sc_omp;	/* Message pointer (for multibyte messages) */
-	size_t	sc_omlen;
-	u_char	sc_imess[ESP_MAX_MSG_LEN + 1];
-	caddr_t	sc_imp;	/* Message pointer (for multibyte messages) */
-	size_t	sc_imlen;
-
-	/* hardware/openprom stuff */
+	/* openprom stuff */
 	int sc_node;				/* PROM node ID */
-	int sc_freq;				/* Freq in HZ */
 	int sc_pri;				/* SBUS priority */
-	int sc_id;				/* our scsi id */
-	int sc_rev;				/* esp revision */
-	int sc_minsync;				/* minimum sync period / 4 */
-	int sc_maxxfer;				/* maximum transfer size */
 };
 
-/*
- * Macros to read and write the chip's registers.
- */
-#define	ESP_READ_REG(sc, reg)			\
-	((sc)->sc_reg[(reg) * 4])
-#define	ESP_WRITE_REG(sc, reg, val)		\
-	do {					\
-		u_char v = (val);		\
-		(sc)->sc_reg[(reg) * 4] = v;	\
-	} while (0)
-
-/* values for sc_state */
-#define ESP_IDLE	0x01	/* waiting for something to do */
-#define ESP_TMP_UNAVAIL	0x02	/* Don't accept SCSI commands */
-#define ESP_SELECTING	0x03	/* SCSI command is arbiting  */
-#define ESP_RESELECTED	0x04	/* Has been reselected */
-#define ESP_HASNEXUS	0x05	/* Actively using the SCSI bus */
-#define ESP_CLEANING	0x06
-#define ESP_SBR		0x07	/* Expect a SCSI RST because we commanded it */
-
-/* values for sc_flags */
-#define ESP_DROP_MSGI	0x01	/* Discard all msgs (parity err detected) */
-#define ESP_DOINGDMA	0x02	/* The FIFO data path is active! */
-#define ESP_BUSFREE_OK	0x04	/* Bus free phase is OK. */
-#define ESP_SYNCHNEGO	0x08	/* Synch negotiation in progress. */
-/*#define ESP_BLOCKED	0x10	* Don't schedule new scsi bus operations */
-#define ESP_DISCON	0x10	/* Target sent DISCONNECT msg */
-#define ESP_ABORTING	0x20	/* Bailing out */
-#define ESP_ICCS	0x40	/* Expect status phase results */
-#define ESP_WAITI	0x80	/* Waiting for non-DMA data to arrive */
-
-/* values for sc_msgout */
-#define SEND_DEV_RESET		0x01
-#define SEND_PARITY_ERROR	0x02
-#define SEND_ABORT		0x04
-#define SEND_REJECT		0x08
-#define SEND_INIT_DET_ERR	0x10
-#define SEND_IDENTIFY  		0x20
-#define SEND_SDTR		0x40
-
-/* SCSI Status codes */
-#define ST_GOOD			0x00
-#define ST_CHKCOND		0x02
-#define ST_CONDMET		0x04
-#define ST_BUSY			0x08
-#define ST_INTERMED		0x10
-#define ST_INTERMED_CONDMET	0x14
-#define ST_RESERVATION_CONFLICT	0x18
-#define ST_CMD_TERM		0x22
-#define ST_QUEUE_FULL		0x28
-
-#define ST_MASK			0x3e /* bit 0,6,7 is reserved */
-
-/* phase bits */
-#define IOI			0x01
-#define CDI			0x02
-#define MSGI			0x04
-
-/* Information transfer phases */
-#define DATA_OUT_PHASE		(0)
-#define DATA_IN_PHASE		(IOI)
-#define COMMAND_PHASE		(CDI)
-#define STATUS_PHASE		(CDI|IOI)
-#define MESSAGE_OUT_PHASE	(MSGI|CDI)
-#define MESSAGE_IN_PHASE	(MSGI|CDI|IOI)
-
-#define PHASE_MASK		(MSGI|CDI|IOI)
-
-/* Some pseudo phases for getphase()*/
-#define BUSFREE_PHASE		0x100	/* Re/Selection no longer valid */
-#define INVALID_PHASE		0x101	/* Re/Selection valid, but no REQ yet */
-#define PSEUDO_PHASE		0x100	/* "pseudo" bit */
-
-#ifdef ESP_DEBUG
-#define	ESPCMD(sc, cmd) do {				\
-	if (esp_debug & ESP_SHOWCCMDS)			\
-		printf("<cmd:0x%x>", (unsigned)cmd);	\
-	sc->sc_lastcmd = cmd;				\
-	ESP_WRITE_REG(sc, ESP_CMD, cmd);		\
-} while (0)
-#else
-#define	ESPCMD(sc, cmd)		ESP_WRITE_REG(sc, ESP_CMD, cmd)
-#endif
-
 #define SAME_ESP(sc, bp, ca) \
 	((bp->val[0] == ca->ca_slot && bp->val[1] == ca->ca_offset) || \
 	 (bp->val[0] == -1 && bp->val[1] == sc->sc_dev.dv_unit))
-
diff --git a/sys/arch/sparc/dev/event.c b/sys/arch/sparc/dev/event.c
deleted file mode 100644
index 3e25c91edb4..00000000000
--- a/sys/arch/sparc/dev/event.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/*	$NetBSD: event.c,v 1.3 1994/11/20 20:52:13 deraadt Exp $ */
-
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This software was developed by the Computer Systems Engineering group
- * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
- * contributed to Berkeley.
- *
- * All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Lawrence Berkeley Laboratory.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)event.c	8.1 (Berkeley) 6/11/93
- */
-
-/*
- * Internal `Firm_event' interface for the keyboard and mouse drivers.
- */
-
-#include <sys/param.h>
-#include <sys/fcntl.h>
-#include <sys/malloc.h>
-#include <sys/proc.h>
-#include <sys/systm.h>
-#include <sys/vnode.h>
-
-#include <machine/vuid_event.h>
-#include <sparc/dev/event_var.h>
-
-/*
- * Initialize a firm_event queue.
- */
-void
-ev_init(ev)
-	register struct evvar *ev;
-{
-
-	ev->ev_get = ev->ev_put = 0;
-	ev->ev_q = malloc((u_long)EV_QSIZE * sizeof(struct firm_event),
-	    M_DEVBUF, M_WAITOK);
-	bzero((caddr_t)ev->ev_q, EV_QSIZE * sizeof(struct firm_event));
-}
-
-/*
- * Tear down a firm_event queue.
- */
-void
-ev_fini(ev)
-	register struct evvar *ev;
-{
-
-	free(ev->ev_q, M_DEVBUF);
-}
-
-/*
- * User-level interface: read, select.
- * (User cannot write an event queue.)
- */
-int
-ev_read(ev, uio, flags)
-	register struct evvar *ev;
-	struct uio *uio;
-	int flags;
-{
-	int s, n, cnt, error;
-
-	/*
-	 * Make sure we can return at least 1.
-	 */
-	if (uio->uio_resid < sizeof(struct firm_event))
-		return (EMSGSIZE);	/* ??? */
-	s = splev();
-	while (ev->ev_get == ev->ev_put) {
-		if (flags & IO_NDELAY) {
-			splx(s);
-			return (EWOULDBLOCK);
-		}
-		ev->ev_wanted = 1;
-		error = tsleep((caddr_t)ev, PEVENT | PCATCH, "firm_event", 0);
-		if (error) {
-			splx(s);
-			return (error);
-		}
-	}
-	/*
-	 * Move firm_events from tail end of queue (there is at least one
-	 * there).
-	 */
-	if (ev->ev_put < ev->ev_get)
-		cnt = EV_QSIZE - ev->ev_get;	/* events in [get..QSIZE) */
-	else
-		cnt = ev->ev_put - ev->ev_get;	/* events in [get..put) */
-	splx(s);
-	n = howmany(uio->uio_resid, sizeof(struct firm_event));
-	if (cnt > n)
-		cnt = n;
-	error = uiomove((caddr_t)&ev->ev_q[ev->ev_get],
-	    cnt * sizeof(struct firm_event), uio);
-	n -= cnt;
-	/*
-	 * If we do not wrap to 0, used up all our space, or had an error,
-	 * stop.  Otherwise move from front of queue to put index, if there
-	 * is anything there to move.
-	 */
-	if ((ev->ev_get = (ev->ev_get + cnt) % EV_QSIZE) != 0 ||
-	    n == 0 || error || (cnt = ev->ev_put) == 0)
-		return (error);
-	if (cnt > n)
-		cnt = n;
-	error = uiomove((caddr_t)&ev->ev_q[0],
-	    cnt * sizeof(struct firm_event), uio);
-	ev->ev_get = cnt;
-	return (error);
-}
-
-int
-ev_select(ev, rw, p)
-	register struct evvar *ev;
-	int rw;
-	struct proc *p;
-{
-	int s = splev();
-
-	switch (rw) {
-
-	case FREAD:
-		/* succeed if there is something to read */
-		if (ev->ev_get != ev->ev_put) {
-			splx(s);
-			return (1);
-		}
-		selrecord(p, &ev->ev_sel);
-		break;
-
-	case FWRITE:
-		return (1);	/* always fails => never blocks */
-	}
-	splx(s);
-	return (0);
-}
diff --git a/sys/arch/sparc/dev/event_var.h b/sys/arch/sparc/dev/event_var.h
deleted file mode 100644
index 8a7b24fec89..00000000000
--- a/sys/arch/sparc/dev/event_var.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*	$NetBSD: event_var.h,v 1.2 1994/11/20 20:52:14 deraadt Exp $ */
-
-/*
- * Copyright (c) 1992, 1993
- *	The Regents of the University of California.  All rights reserved.
- *
- * This software was developed by the Computer Systems Engineering group
- * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
- * contributed to Berkeley.
- *
- * All advertising materials mentioning features or use of this software
- * must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Lawrence Berkeley Laboratory.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *	This product includes software developed by the University of
- *	California, Berkeley and its contributors.
- * 4. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- *	@(#)event_var.h	8.1 (Berkeley) 6/11/93
- */
-
-/*
- * Internal `Firm_event' interface for the keyboard and mouse drivers.
- * The drivers are expected not to place events in the queue above spltty(),
- * i.e., are expected to run off serial ports.
- */
-
-/* EV_QSIZE should be a power of two so that `%' is fast */
-#define	EV_QSIZE	256	/* may need tuning; this uses 2k */
-
-struct evvar {
-	u_int	ev_get;		/* get (read) index (modified synchronously) */
-	volatile u_int ev_put;	/* put (write) index (modified by interrupt) */
-	struct	selinfo ev_sel;	/* process selecting */
-	struct	proc *ev_io;	/* process that opened queue (can get SIGIO) */
-	char	ev_wanted;	/* wake up on input ready */
-	char	ev_async;	/* send SIGIO on input ready */
-	struct	firm_event *ev_q;/* circular buffer (queue) of events */
-};
-
-#define	splev()	spltty()
-
-#define	EV_WAKEUP(ev) { \
-	selwakeup(&(ev)->ev_sel); \
-	if ((ev)->ev_wanted) { \
-		(ev)->ev_wanted = 0; \
-		wakeup((caddr_t)(ev)); \
-	} \
-	if ((ev)->ev_async) \
-		psignal((ev)->ev_io, SIGIO); \
-}
-
-void	ev_init __P((struct evvar *));
-void	ev_fini __P((struct evvar *));
-int	ev_read __P((struct evvar *, struct uio *, int));
-int	ev_select __P((struct evvar *, int, struct proc *));
-
-/*
- * PEVENT is set just above PSOCK, which is just above TTIPRI, on the
- * theory that mouse and keyboard `user' input should be quick.
- */
-#define	PEVENT	23
diff --git a/sys/arch/sparc/dev/fb.c b/sys/arch/sparc/dev/fb.c
index 37bf3b10be7..5c7e3c70916 100644
--- a/sys/arch/sparc/dev/fb.c
+++ b/sys/arch/sparc/dev/fb.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: fb.c,v 1.9 1996/08/13 08:05:25 downsj Exp $	*/
-/*	$NetBSD: fb.c,v 1.18 1996/04/01 17:29:54 christos Exp $ */
+/*	$OpenBSD: fb.c,v 1.10 1997/08/08 08:25:04 downsj Exp $	*/
+/*	$NetBSD: fb.c,v 1.23 1997/07/07 23:30:22 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -299,23 +299,23 @@ fb_setsize(fb, depth, def_width, def_height, node, bustype)
 					break;
 				}
 			} else if (eep != NULL) {
-				switch (eep->ee_diag.eed_scrsize) {
-				case EED_SCR_1152X900:
+				switch (eep->eeScreenSize) {
+				case EE_SCR_1152X900:
 					fb->fb_type.fb_width = 1152;
 					fb->fb_type.fb_height = 900;
 					break;
 
-				case EED_SCR_1024X1024:
+				case EE_SCR_1024X1024:
 					fb->fb_type.fb_width = 1024;
 					fb->fb_type.fb_height = 1024;
 					break;
 
-				case EED_SCR_1600X1280:
+				case EE_SCR_1600X1280:
 					fb->fb_type.fb_width = 1600;
 					fb->fb_type.fb_height = 1280;
 					break;
 
-				case EED_SCR_1440X1440:
+				case EE_SCR_1440X1440:
 					fb->fb_type.fb_width = 1440;
 					fb->fb_type.fb_height = 1440;
 					break;
@@ -354,12 +354,15 @@ fb_setsize(fb, depth, def_width, def_height, node, bustype)
 	}
 }
 
+
 #ifdef RASTERCONSOLE
 #include <machine/kbd.h>
 
-static int a2int __P((char *, int));
 static void fb_bell __P((int));
 
+#if !(defined(RASTERCONS_FULLSCREEN) || defined(RASTERCONS_SMALLFONT))
+static int a2int __P((char *, int));
+
 static int
 a2int(cp, deflt)
 	register char *cp;
@@ -373,6 +376,7 @@ a2int(cp, deflt)
 		i = i * 10 + *cp++ - '0';
 	return (i);
 }
+#endif
 
 static void
 fb_bell(on)
@@ -413,8 +417,8 @@ fbrcons_init(fb)
 			rc->rc_maxcol = 80;
 			rc->rc_maxrow = 34;
 		} else {
-			rc->rc_maxcol = eep->ee_diag.eed_colsize;
-			rc->rc_maxrow = eep->ee_diag.eed_rowsize;
+			rc->rc_maxcol = eep->eeTtyCols;
+			rc->rc_maxrow = eep->eeTtyRows;
 		}
 	}
 #endif /* SUN4 */
@@ -439,7 +443,19 @@ fbrcons_init(fb)
 	/* Hook up virtual console */
 	v_putc = rcons_cnputc;
 }
-#endif
+
+int
+fbrcons_rows()
+{
+	return (devfb ? devfb->fb_rcons.rc_maxrow : 0);
+}
+
+int
+fbrcons_cols()
+{
+	return (devfb ? devfb->fb_rcons.rc_maxcol : 0);
+}
+#endif /* RASTERCONSOLE */
 
 #if defined(SUN4)
 /*
diff --git a/sys/arch/sparc/dev/fd.c b/sys/arch/sparc/dev/fd.c
index 456ab415b6e..1643db5b031 100644
--- a/sys/arch/sparc/dev/fd.c
+++ b/sys/arch/sparc/dev/fd.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: fd.c,v 1.19 1997/06/25 13:04:20 downsj Exp $	*/
+/*	$OpenBSD: fd.c,v 1.20 1997/08/08 08:25:06 downsj Exp $	*/
 /*	$NetBSD: fd.c,v 1.51 1997/05/24 20:16:19 pk Exp $	*/
 
 /*-
@@ -369,8 +369,7 @@ fdcattach(parent, self, aux)
 		fdc->sc_reg = (caddr_t)ca->ca_ra.ra_vaddr;
 	else
 		fdc->sc_reg = (caddr_t)mapiodev(ca->ca_ra.ra_reg, 0,
-						ca->ca_ra.ra_len,
-						ca->ca_bustype);
+						ca->ca_ra.ra_len);
 
 	fdc->sc_state = DEVIDLE;
 	fdc->sc_istate = ISTATE_IDLE;
diff --git a/sys/arch/sparc/dev/i82586.h b/sys/arch/sparc/dev/i82586.h
index 02cd09ef98f..4c5ead2fec3 100644
--- a/sys/arch/sparc/dev/i82586.h
+++ b/sys/arch/sparc/dev/i82586.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: i82586.h,v 1.2 1997/08/08 08:25:07 downsj Exp $	*/
 /*	$NetBSD: i82586.h,v 1.3 1995/01/27 09:49:55 pk Exp $ */
 
 /*-
diff --git a/sys/arch/sparc/dev/if_en_sbus.c b/sys/arch/sparc/dev/if_en_sbus.c
index 9ba4cd3ca99..499f80901fc 100644
--- a/sys/arch/sparc/dev/if_en_sbus.c
+++ b/sys/arch/sparc/dev/if_en_sbus.c
@@ -1,4 +1,5 @@
-/*	$OpenBSD: if_en_sbus.c,v 1.2 1996/06/21 21:37:37 chuck Exp $	*/
+/*	$OpenBSD: if_en_sbus.c,v 1.3 1997/08/08 08:25:08 downsj Exp $	*/
+/*	$NetBSD: if_en_sbus.c,v 1.4 1997/05/24 20:16:22 pk Exp $	*/
 
 /*
  *
@@ -138,8 +139,7 @@ void *aux;
     return;
   }
 
-  sc->en_base = (caddr_t) mapiodev(ca->ca_ra.ra_reg, 0, 4*1024*1024,
-        ca->ca_bustype);
+  sc->en_base = (caddr_t) mapiodev(ca->ca_ra.ra_reg, 0, 4*1024*1024);
 
   if (ca->ca_ra.ra_nintr == 1) {
     sc->ipl = ca->ca_ra.ra_intr[0].int_pri;
diff --git a/sys/arch/sparc/dev/if_ie.c b/sys/arch/sparc/dev/if_ie.c
index 3bd3defb91a..d57746dbadc 100644
--- a/sys/arch/sparc/dev/if_ie.c
+++ b/sys/arch/sparc/dev/if_ie.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: if_ie.c,v 1.24 1996/05/07 01:28:28 thorpej Exp $	*/
+/*	$OpenBSD: if_ie.c,v 1.7 1997/08/08 08:25:09 downsj Exp $	*/
+/*	$NetBSD: if_ie.c,v 1.33 1997/07/29 17:55:38 fair Exp $	*/
 
 /*-
  * Copyright (c) 1993, 1994, 1995 Charles Hannum.
@@ -413,23 +414,22 @@ iematch(parent, vcf, aux)
 
 	if (strcmp(cf->cf_driver->cd_name, ra->ra_name))	/* correct name? */
 		return (0);
-	if (ca->ca_bustype == BUS_SBUS)
-		return (0);
-
-	if (CPU_ISSUN4) {
-		/*
-		 * XXX need better probe here so we can figure out what we've got
-		 */
-		if (ca->ca_bustype == BUS_OBIO) {
-			if (probeget(ra->ra_vaddr, 1) == -1)
-				return (0);
-			return(1);
-		}
-		if (probeget(ra->ra_vaddr, 2) == -1)
-			return (0);
 
+	switch (ca->ca_bustype) {
+	case BUS_SBUS:
+	default:
+		return (0);
+	case BUS_OBIO:
+		if (probeget(ra->ra_vaddr, 1) != -1)
+			return (1);
+		break;
+	case BUS_VME16:
+	case BUS_VME32:
+		if (probeget(ra->ra_vaddr, 2) != -1)
+			return (1);
+		break;
 	}
-	return (1);
+	return (0);
 }
 
 /*
@@ -530,8 +530,7 @@ ieattach(parent, self, aux)
 		sc->memcopy = bcopy;
 		sc->memzero = bzero;
 		sc->sc_msize = 65536; /* XXX */
-		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct ieob),
-		    ca->ca_bustype);
+		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct ieob));
 		ieo = (volatile struct ieob *) sc->sc_reg;
 
 		/*
@@ -594,8 +593,8 @@ ieattach(parent, self, aux)
 		sc->memcopy = wcopy;
 		sc->memzero = wzero;
 		sc->sc_msize = 65536;	/* XXX */
-		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct ievme),
-		    ca->ca_bustype);
+		sc->sc_reg = mapiodev(ca->ca_ra.ra_reg, 0,
+				      sizeof(struct ievme));
 		iev = (volatile struct ievme *) sc->sc_reg;
 		/* top 12 bits */
 		rampaddr = (u_long)ca->ca_ra.ra_paddr & 0xfff00000;
@@ -603,7 +602,7 @@ ieattach(parent, self, aux)
 		rampaddr = rampaddr | ((iev->status & IEVME_HADDR) << 16);
 		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_msize);
 		sc->sc_iobase = sc->sc_maddr;
 		iev->pectrl = iev->pectrl | IEVME_PARACK; /* clear to start */
 
@@ -731,7 +730,7 @@ void *v;
                 volatile struct ievme *iev = (volatile struct ievme *)sc->sc_reg
 ;
                 if (iev->status & IEVME_PERR) {
-                        printf("%s: parity error (ctrl %x @ %02x%04x)\n",
+                        printf("%s: parity error (ctrl 0x%x @ 0x%02x%04x)\n",
                                sc->sc_dev.dv_xname, iev->pectrl,
 			       iev->pectrl & IEVME_HADDR, iev->peaddr);
                         iev->pectrl = iev->pectrl | IEVME_PARACK;
@@ -1317,7 +1316,8 @@ ie_readframe(sc, num)
 
 #ifdef IEDEBUG
 	if (sc->sc_debug & IED_READFRAME)
-		printf("%s: frame from ether %s type %x\n", sc->sc_dev.dv_xname,
+		printf("%s: frame from ether %s type 0x%x\n",
+		    sc->sc_dev.dv_xname,
 		    ether_sprintf(eh.ether_shost), (u_int)eh.ether_type);
 #endif
 
@@ -1654,7 +1654,7 @@ run_tdr(sc, cmd)
 		printf("%s: TDR detected a short %d clocks away\n",
 		    sc->sc_dev.dv_xname, result & IE_TDR_TIME);
 	else
-		printf("%s: TDR returned unknown status %x\n",
+		printf("%s: TDR returned unknown status 0x%x\n",
 		    sc->sc_dev.dv_xname, result);
 }
 
diff --git a/sys/arch/sparc/dev/if_ie.h b/sys/arch/sparc/dev/if_ie.h
index 0008a85417d..b9860155b66 100644
--- a/sys/arch/sparc/dev/if_ie.h
+++ b/sys/arch/sparc/dev/if_ie.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: if_ie.h,v 1.2 1997/08/08 08:25:11 downsj Exp $	*/
 /*	$NetBSD: if_ie.h,v 1.4 1994/12/16 22:01:11 deraadt Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/if_le.c b/sys/arch/sparc/dev/if_le.c
index 4db240f0f62..b0bf63e56e6 100644
--- a/sys/arch/sparc/dev/if_le.c
+++ b/sys/arch/sparc/dev/if_le.c
@@ -1,6 +1,8 @@
-/*	$NetBSD: if_le.c,v 1.35.4.1 1996/07/17 01:46:00 jtc Exp $	*/
+/*	$OpenBSD: if_le.c,v 1.7 1997/08/08 08:25:12 downsj Exp $	*/
+/*	$NetBSD: if_le.c,v 1.49 1997/07/07 16:28:44 pk Exp $	*/
 
 /*-
+ * Copyright (c) 1997 Jason R. Thorpe.  All rights reserved.
  * Copyright (c) 1996
  *	The President and Fellows of Harvard College. All rights reserved.
  * Copyright (c) 1995 Charles M. Hannum.  All rights reserved.
@@ -22,6 +24,8 @@
  *    must display the following acknowledgement:
  *	This product includes software developed by Aaron Brown and
  *	Harvard University.
+ *	This product includes software developed for the NetBSD Project
+ *	by Jason R. Thorpe.
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
@@ -54,10 +58,18 @@
 #include <sys/malloc.h>
 
 #include <net/if.h>
+#if defined(__NetBSD__)
+#include <net/if_ether.h>
+#include <net/if_media.h>
+#endif	/* __NetBSD__ */
 
 #ifdef INET
 #include <netinet/in.h>
+#if defined(__NetBSD__)
+#include <netinet/if_inarp.h>
+#else
 #include <netinet/if_ether.h>
+#endif	/* __NetBSD__ */
 #endif
 
 #include <machine/autoconf.h>
@@ -66,6 +78,7 @@
 #include <sparc/dev/sbusvar.h>
 #include <sparc/dev/dmareg.h>
 #include <sparc/dev/dmavar.h>
+#include <sparc/dev/lebuffervar.h>
 
 #include <dev/ic/am7990reg.h>
 #include <dev/ic/am7990var.h>
@@ -73,7 +86,11 @@
 #include <sparc/dev/if_lereg.h>
 #include <sparc/dev/if_levar.h>
 
+#if defined(__NetBSD__)
+int	lematch __P((struct device *, struct cfdata *, void *));
+#else
 int	lematch __P((struct device *, void *, void *));
+#endif	/* __NetBSD__ */
 void	leattach __P((struct device *, struct device *, void *));
 
 #if defined(SUN4M)	/* XXX */
@@ -89,25 +106,41 @@ myleintr(arg)
 	if (lesc->sc_dma->sc_regs->csr & D_ERR_PEND)
 		return ledmaintr(lesc->sc_dma);
 
-	/*
-	 * XXX There is a bug somewhere in the interrupt code that causes stray
-	 * ethernet interrupts under high network load. This bug has been
-	 * impossible to locate, so until it is found, we just ignore stray
-	 * interrupts, as they do not in fact correspond to dropped packets.
-	 */
-
-	/* return */ am7990_intr(arg);
-	return 1;
+	return (am7990_intr(arg));
 }
 #endif
 
+#if defined(SUN4M)
+#if defined(__NetBSD__)
+/*
+ * Media types supported by the Sun4m.
+ */
+int lemediasun4m[] = {
+	IFM_ETHER|IFM_10_T,
+	IFM_ETHER|IFM_10_5,
+	IFM_ETHER|IFM_AUTO,
+};
+#define NLEMEDIASUN4M	(sizeof(lemediasun4m) / sizeof(lemediasun4m[0]))
+#endif	/* __NetBSD__ */
+
+void	lesetutp __P((struct am7990_softc *));
+void	lesetaui __P((struct am7990_softc *));
+
+int	lemediachange __P((struct am7990_softc *));
+#if defined(__NetBSD__)
+void	lemediastatus __P((struct am7990_softc *, struct ifmediareq *));
+#endif	/* __NetBSD__ */
+#endif /* SUN4M */
+
 struct cfattach le_ca = {
 	sizeof(struct le_softc), lematch, leattach
 };
 
 hide void lewrcsr __P((struct am7990_softc *, u_int16_t, u_int16_t));
 hide u_int16_t lerdcsr __P((struct am7990_softc *, u_int16_t));
+hide void lehwreset __P((struct am7990_softc *));
 hide void lehwinit __P((struct am7990_softc *));
+hide void lenocarrier __P((struct am7990_softc *));
 
 hide void
 lewrcsr(sc, port, val)
@@ -115,9 +148,21 @@ lewrcsr(sc, port, val)
 	u_int16_t port, val;
 {
 	register struct lereg1 *ler1 = ((struct le_softc *)sc)->sc_r1;
+#if defined(SUN4M)
+	volatile u_int16_t discard;
+#endif
 
 	ler1->ler1_rap = port;
 	ler1->ler1_rdp = val;
+#if defined(SUN4M)
+	/* 
+	 * We need to flush the Sbus->Mbus write buffers. This can most
+	 * easily be accomplished by reading back the register that we
+	 * just wrote (thanks to Chris Torek for this solution).
+	 */	   
+	if (CPU_ISSUN4M)
+		discard = ler1->ler1_rdp;
+#endif
 }
 
 hide u_int16_t
@@ -133,6 +178,109 @@ lerdcsr(sc, port)
 	return (val);
 }
 
+#if defined(SUN4M)
+void
+lesetutp(sc)
+	struct am7990_softc *sc;
+{
+	struct le_softc *lesc = (struct le_softc *)sc;
+
+	lesc->sc_dma->sc_regs->csr |= DE_AUI_TP;
+	delay(20000);	/* must not touch le for 20ms */
+}
+
+void
+lesetaui(sc)
+	struct am7990_softc *sc;
+{
+	struct le_softc *lesc = (struct le_softc *)sc;
+
+	lesc->sc_dma->sc_regs->csr &= ~DE_AUI_TP;
+	delay(20000);	/* must not touch le for 20ms */
+}
+
+int
+lemediachange(sc)
+	struct am7990_softc *sc;
+{
+#if defined(__NetBSD__)
+	struct ifmedia *ifm = &sc->sc_media;
+
+	if (IFM_TYPE(ifm->ifm_media) != IFM_ETHER)
+		return (EINVAL);
+
+	/*
+	 * Switch to the selected media.  If autoselect is
+	 * set, we don't really have to do anything.  We'll
+	 * switch to the other media when we detect loss of
+	 * carrier.
+	 */
+	switch (IFM_SUBTYPE(ifm->ifm_media)) {
+	case IFM_10_T:
+		lesetutp(sc);
+		break;
+
+	case IFM_10_5:
+		lesetaui(sc);
+		break;
+
+	case IFM_AUTO:
+		break;
+
+	default:
+		return (EINVAL);
+	}
+#else
+	struct ifnet *ifp = &sc->sc_arpcom.ac_if;
+
+	if (ifp->if_flags & IFF_LINK0)
+		lesetutp(sc);
+	else if (ifp->if_flags & IFF_LINK1)
+		lesetaui(sc);
+#endif	/* __NetBSD__ */
+	return (0);
+}
+
+#if defined(__NetBSD__)
+void
+lemediastatus(sc, ifmr)
+	struct am7990_softc *sc;
+	struct ifmediareq *ifmr;
+{
+	struct le_softc *lesc = (struct le_softc *)sc;
+
+	if (lesc->sc_dma == NULL)
+		return;
+
+	/*
+	 * Notify the world which media we're currently using.
+	 */
+	if (lesc->sc_dma->sc_regs->csr & DE_AUI_TP)
+		ifmr->ifm_active = IFM_ETHER|IFM_10_T;
+	else
+		ifmr->ifm_active = IFM_ETHER|IFM_10_5;
+}
+#endif	/* __NetBSD__ */
+#endif /* SUN4M */
+
+hide void
+lehwreset(sc)
+	struct am7990_softc *sc;
+{
+#if defined(SUN4M) 
+	struct le_softc *lesc = (struct le_softc *)sc;
+
+	/*
+	 * Reset DMA channel.
+	 */
+	if (CPU_ISSUN4M && lesc->sc_dma) {
+		DMA_RESET(lesc->sc_dma);
+		lesc->sc_dma->sc_regs->en_bar = lesc->sc_laddr & 0xff000000;
+		DMA_ENINTR(lesc->sc_dma);
+	}
+#endif
+}
+
 hide void
 lehwinit(sc)
 	struct am7990_softc *sc;
@@ -140,25 +288,100 @@ lehwinit(sc)
 #if defined(SUN4M) 
 	struct le_softc *lesc = (struct le_softc *)sc;
 
+	/*
+	 * Make sure we're using the currently-enabled media type.
+	 * XXX Actually, this is probably unnecessary, now.
+	 */
 	if (CPU_ISSUN4M && lesc->sc_dma) {
+#if defined(__NetBSD__)
+		switch (IFM_SUBTYPE(sc->sc_media.ifm_cur->ifm_media)) {
+		case IFM_10_T:
+			lesetutp(sc);
+			break;
+
+		case IFM_10_5:
+			lesetaui(sc);
+			break;
+		}
+#else
 		struct ifnet *ifp = &sc->sc_arpcom.ac_if;
 
 		if (ifp->if_flags & IFF_LINK0)
-			lesc->sc_dma->sc_regs->csr |= DE_AUI_TP;
+			lesetutp(sc);
 		else if (ifp->if_flags & IFF_LINK1)
-			lesc->sc_dma->sc_regs->csr &= ~DE_AUI_TP;
-
-		delay(20000);	/* must not touch le for 20ms */
+			lesetaui(sc);
+#endif	/* __NetBSD__ */
 	}
 #endif
 }
 
+hide void
+lenocarrier(sc)
+	struct am7990_softc *sc;
+{
+#if defined(SUN4M)
+	struct le_softc *lesc = (struct le_softc *)sc;
+#if !defined(__NetBSD__)
+	struct ifnet *ifp = &sc->sc_arpcom.ac_if;
+#endif	/* __NetBSD__ */
+
+	if (CPU_ISSUN4M && lesc->sc_dma) {
+		/* 
+		 * Check if the user has requested a certain cable type, and
+		 * if so, honor that request.
+		 */
+		printf("%s: lost carrier on ", sc->sc_dev.dv_xname);
+		if (lesc->sc_dma->sc_regs->csr & DE_AUI_TP) {
+			printf("UTP port");
+#if defined(__NetBSD__)
+			switch (IFM_SUBTYPE(sc->sc_media.ifm_media)) {
+			case IFM_10_5:
+			case IFM_AUTO:
+				printf(", switching to AUI port");
+				lesetaui(sc);
+			}
+#else
+			if (!(ifp->if_flags & IFF_LINK0)) {
+				printf(", switching to AUI port");
+				lesetaui(sc);
+			}
+#endif	/* __NetBSD__ */
+		} else {
+			printf("AUI port");
+#if defined(__NetBSD__)
+			switch (IFM_SUBTYPE(sc->sc_media.ifm_media)) {
+			case IFM_10_T:
+			case IFM_AUTO:
+				printf(", switching to UTP port");
+				lesetutp(sc);
+			}
+#else
+			if (!(ifp->if_flags & IFF_LINK1)) {
+				printf(", switching to UTP port");
+				lesetutp(sc);
+			}
+#endif	/* __NetBSD__ */
+		}
+		printf("\n");
+	} else
+#endif
+		printf("%s: lost carrier\n", sc->sc_dev.dv_xname);
+}
+
 int
-lematch(parent, match, aux)
+#if defined(__NetBSD__)
+lematch(parent, cf, aux)
 	struct device *parent;
-	void *match, *aux;
+	struct cfdata *cf;
+	void *aux;
 {
-	struct cfdata *cf = match;
+#else
+lematch(parent, vcf, aux)
+	struct device *parent;
+	void *vcf, *aux;
+{
+	struct cfdata *cf = vcf;
+#endif	/* __NetBSD__ */
 	struct confargs *ca = aux;
 	register struct romaux *ra = &ca->ca_ra;
 
@@ -180,9 +403,11 @@ leattach(parent, self, aux)
 	struct confargs *ca = aux;
 	int pri;
 	struct bootpath *bp;
-	u_long laddr;
 #if defined(SUN4C) || defined(SUN4M)
 	int sbuschild = strncmp(parent->dv_xname, "sbus", 4) == 0;
+	int lebufchild = strncmp(parent->dv_xname, "lebuffer", 8) == 0;
+	int dmachild = strncmp(parent->dv_xname, "ledma", 5) == 0;
+	struct lebuf_softc *lebuf;
 #endif
 
 	/* XXX the following declarations should be elsewhere */
@@ -195,31 +420,62 @@ leattach(parent, self, aux)
 	pri = ca->ca_ra.ra_intr[0].int_pri;
 	printf(" pri %d", pri);
 
-	lesc->sc_r1 = (struct lereg1 *)mapiodev(ca->ca_ra.ra_reg, 0,
-					      sizeof(struct lereg1),
-					      ca->ca_bustype);
-	sc->sc_conf3 = LE_C3_BSWP | LE_C3_ACON | LE_C3_BCON;
-	laddr = (u_long)dvma_malloc(MEMSIZE, &sc->sc_mem, M_NOWAIT);
+	lesc->sc_r1 = (struct lereg1 *)
+		mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct lereg1));
+
+#if defined(SUN4C) || defined(SUN4M)
+	lebuf = NULL;
+	if (lebufchild) {
+		lebuf = (struct lebuf_softc *)parent;
+	} else if (sbuschild) {
+		struct sbus_softc *sbus = (struct sbus_softc *)parent;
+		struct sbusdev *sd;
+
+		/*
+		 * Find last "unallocated" lebuffer and pair it with
+		 * this `le' device on the assumption that we're on
+		 * a pre-historic ROM that doesn't establish le<=>lebuffer
+		 * parent-child relationships.
+		 */
+		for (sd = sbus->sc_sbdev; sd != NULL; sd = sd->sd_bchain) {
+			if (strncmp("lebuffer", sd->sd_dev->dv_xname, 8) != 0)
+				continue;
+			if (((struct lebuf_softc *)sd->sd_dev)->attached == 0) {
+				lebuf = (struct lebuf_softc *)sd->sd_dev;
+				break;
+			}
+		}
+	}
+	if (lebuf != NULL) {
+		sc->sc_mem = lebuf->sc_buffer;
+		sc->sc_memsize = lebuf->sc_bufsiz;
+		sc->sc_addr = 0; /* Lance view is offset by buffer location */
+		lebuf->attached = 1;
+
+		/* That old black magic... */
+		sc->sc_conf3 = getpropint(ca->ca_ra.ra_node,
+			 	"busmaster-regval",
+				LE_C3_BSWP | LE_C3_ACON | LE_C3_BCON);
+	} else
+#endif
+	{
+		u_long laddr;
+		laddr = (u_long)dvma_malloc(MEMSIZE, &sc->sc_mem, M_NOWAIT);
 #if defined (SUN4M)
-	if ((laddr & 0xffffff) >= (laddr & 0xffffff) + MEMSIZE)
-		panic("if_le: Lance buffer crosses 16MB boundary");
+		if ((laddr & 0xffffff) >= (laddr & 0xffffff) + MEMSIZE)
+			panic("if_le: Lance buffer crosses 16MB boundary");
 #endif
-	sc->sc_addr = laddr & 0xffffff;
-	sc->sc_memsize = MEMSIZE;
-
-	myetheraddr(sc->sc_arpcom.ac_enaddr);
-
-	sc->sc_copytodesc = am7990_copytobuf_contig;
-	sc->sc_copyfromdesc = am7990_copyfrombuf_contig;
-	sc->sc_copytobuf = am7990_copytobuf_contig;
-	sc->sc_copyfrombuf = am7990_copyfrombuf_contig;
-	sc->sc_zerobuf = am7990_zerobuf_contig;
-
-	sc->sc_rdcsr = lerdcsr;
-	sc->sc_wrcsr = lewrcsr;
-	sc->sc_hwinit = lehwinit;
-
-	am7990_config(sc);
+		sc->sc_addr = laddr & 0xffffff;
+		sc->sc_memsize = MEMSIZE;
+		sc->sc_conf3 = LE_C3_BSWP | LE_C3_ACON | LE_C3_BCON;
+#if defined(SUN4C) || defined(SUN4M)
+		if (dmachild) {
+			lesc->sc_dma = (struct dma_softc *)parent;
+			lesc->sc_dma->sc_le = lesc;
+			lesc->sc_laddr = laddr;
+		}
+#endif
+	}
 
 	bp = ca->ca_ra.ra_bp;
 	switch (ca->ca_bustype) {
@@ -231,12 +487,8 @@ leattach(parent, self, aux)
 	case BUS_SBUS:
 		lesc->sc_sd.sd_reset = (void *)am7990_reset;
 		if (sbuschild) {
-			lesc->sc_dma = NULL;
 			sbus_establish(&lesc->sc_sd, &sc->sc_dev);
 		} else {
-			lesc->sc_dma = (struct dma_softc *)parent;
-			lesc->sc_dma->sc_le = lesc;
-			lesc->sc_dma->sc_regs->en_bar = laddr & 0xff000000;
 			/* Assume SBus is grandparent */
 			sbus_establish(&lesc->sc_sd, parent);
 		}
@@ -254,16 +506,44 @@ leattach(parent, self, aux)
 		break;
 	}
 
+#if defined(__NetBSD__)
+	myetheraddr(sc->sc_enaddr);
+#else
+	myetheraddr(sc->sc_arpcom.ac_enaddr);
+#endif	/* __NetBSD__ */
+
+	sc->sc_copytodesc = am7990_copytobuf_contig;
+	sc->sc_copyfromdesc = am7990_copyfrombuf_contig;
+	sc->sc_copytobuf = am7990_copytobuf_contig;
+	sc->sc_copyfrombuf = am7990_copyfrombuf_contig;
+	sc->sc_zerobuf = am7990_zerobuf_contig;
+
+	sc->sc_rdcsr = lerdcsr;
+	sc->sc_wrcsr = lewrcsr;
+	sc->sc_hwinit = lehwinit;
+	sc->sc_nocarrier = lenocarrier;
+	sc->sc_hwreset = lehwreset;
+
+#if defined(SUN4M) && defined(__NetBSD__)
+	if (CPU_ISSUN4M && lesc->sc_dma) {
+		sc->sc_mediachange = lemediachange;
+		sc->sc_mediastatus = lemediastatus;
+		sc->sc_supmedia = lemediasun4m;
+		sc->sc_nsupmedia = NLEMEDIASUN4M;
+		sc->sc_defaultmedia = IFM_ETHER|IFM_AUTO;
+	}
+#endif
+
+	am7990_config(sc);
+
 	lesc->sc_ih.ih_fun = am7990_intr;
 #if defined(SUN4M) /*XXX*/
-	if (CPU_ISSUN4M)
+	if (CPU_ISSUN4M && lesc->sc_dma)
 		lesc->sc_ih.ih_fun = myleintr;
 #endif
 	lesc->sc_ih.ih_arg = sc;
 	intr_establish(pri, &lesc->sc_ih);
 
 	/* now initialize DMA */
-	if (lesc->sc_dma) {
-		DMA_ENINTR(lesc->sc_dma);
-	}
+	lehwreset(sc);
 }
diff --git a/sys/arch/sparc/dev/if_lereg.h b/sys/arch/sparc/dev/if_lereg.h
index 5035566a439..429ba05a831 100644
--- a/sys/arch/sparc/dev/if_lereg.h
+++ b/sys/arch/sparc/dev/if_lereg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: if_lereg.h,v 1.3 1997/08/08 08:25:13 downsj Exp $	*/
 /*	$NetBSD: if_lereg.h,v 1.5 1995/12/10 10:15:07 mycroft Exp $ */
 
 /*-
diff --git a/sys/arch/sparc/dev/if_levar.h b/sys/arch/sparc/dev/if_levar.h
index 934d74c932e..2c73d8405d9 100644
--- a/sys/arch/sparc/dev/if_levar.h
+++ b/sys/arch/sparc/dev/if_levar.h
@@ -1,4 +1,5 @@
-/*	$NetBSD: if_levar.h,v 1.5 1996/05/07 01:27:32 thorpej Exp $	*/
+/*	$OpenBSD: if_levar.h,v 1.3 1997/08/08 08:25:14 downsj Exp $	*/
+/*	$NetBSD: if_levar.h,v 1.7 1997/04/04 20:29:23 pk Exp $	*/
 
 /*-
  * Copyright (c) 1995 Charles M. Hannum.  All rights reserved.
@@ -43,7 +44,7 @@
  * Ethernet software status per interface.
  *
  * Each interface is referenced by a network interface structure,
- * arpcom.ac_if, which the routing code uses to locate the interface.
+ * ethercom.ec_if, which the routing code uses to locate the interface.
  * This structure contains the output queue for the interface, its address, ...
  */
 struct	le_softc {
@@ -53,4 +54,5 @@ struct	le_softc {
 	struct	intrhand sc_ih;		/* interrupt vectoring */
 	struct	lereg1 *sc_r1;		/* LANCE registers */
 	struct	dma_softc *sc_dma;	/* pointer to my dma */
+	u_long	sc_laddr;		/* LANCE DMA address */
 };
diff --git a/sys/arch/sparc/dev/isp_sbus.c b/sys/arch/sparc/dev/isp_sbus.c
new file mode 100644
index 00000000000..24fcb5caec2
--- /dev/null
+++ b/sys/arch/sparc/dev/isp_sbus.c
@@ -0,0 +1,331 @@
+/*	$OpenBSD: isp_sbus.c,v 1.1 1997/08/08 08:25:15 downsj Exp $	*/
+/*	$NetBSD: isp_sbus.c,v 1.6 1997/06/08 06:35:45 thorpej Exp $	*/
+
+/*
+ * SBus specific probe and attach routines for Qlogic ISP SCSI adapters.
+ *
+ * Copyright (c) 1997 by Matthew Jacob 
+ * NASA AMES Research Center
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice immediately at the beginning of the file, without modification,
+ *    this list of conditions, and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/queue.h>
+#include <sys/device.h>
+#include <scsi/scsi_all.h>
+#include <scsi/scsiconf.h>
+
+#include <machine/autoconf.h>
+#include <sparc/cpu.h>
+#include <sparc/sparc/cpuvar.h>
+#include <sparc/dev/sbusvar.h>
+
+#include <dev/ic/ispreg.h>
+#include <dev/ic/ispvar.h>
+#include <dev/microcode/isp/asm_sbus.h>
+#include <machine/param.h>
+#include <machine/vmparam.h>
+
+
+static u_int16_t isp_sbus_rd_reg __P((struct ispsoftc *, int));
+static void isp_sbus_wr_reg __P((struct ispsoftc *, int, u_int16_t));
+static int isp_sbus_mbxdma __P((struct ispsoftc *));
+static int isp_sbus_dmasetup __P((struct ispsoftc *, struct scsi_xfer *,
+	ispreq_t *, u_int8_t *, u_int8_t));
+static void isp_sbus_dmateardown __P((struct ispsoftc *, struct scsi_xfer *,
+	u_int32_t));
+
+static struct ispmdvec mdvec = {
+	isp_sbus_rd_reg,
+	isp_sbus_wr_reg,
+	isp_sbus_mbxdma,
+	isp_sbus_dmasetup,
+	isp_sbus_dmateardown,
+	NULL,
+	NULL,
+	ISP_RISC_CODE,
+	ISP_CODE_LENGTH,
+	ISP_CODE_ORG,
+	0
+};
+
+struct isp_sbussoftc {
+	struct ispsoftc sbus_isp;
+	struct intrhand sbus_ih;
+	volatile u_char *sbus_reg;
+	int sbus_node;
+	int sbus_pri;
+	vm_offset_t sbus_kdma_allocs[RQUEST_QUEUE_LEN];
+};
+
+
+static int isp_match __P((struct device *, void *, void *));
+static void isp_sbus_attach __P((struct device *, struct device *, void *));
+struct cfattach isp_sbus_ca = {
+        sizeof (struct isp_sbussoftc), isp_match, isp_sbus_attach
+};
+
+static int
+isp_match(parent, vcf, aux)
+        struct device *parent;
+        void *vcf, *aux;
+{
+        struct cfdata *cf = vcf;
+        struct confargs *ca = aux;
+        register struct romaux *ra = &ca->ca_ra;
+
+        if (strcmp(cf->cf_driver->cd_name, ra->ra_name) &&
+	    strcmp("SUNW,isp", ra->ra_name) &&
+	    strcmp("QLGC,isp", ra->ra_name)) {
+                return (0);
+	}
+        if (ca->ca_bustype == BUS_SBUS)
+                return (1);
+        ra->ra_len = NBPG;
+        return (probeget(ra->ra_vaddr, 1) != -1);
+}
+
+static void    
+isp_sbus_attach(parent, self, aux)
+        struct device *parent, *self;
+        void *aux;
+{
+	struct confargs *ca = aux;
+	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) self;
+
+	if (ca->ca_ra.ra_nintr != 1) {
+		printf(": expected 1 interrupt, got %d\n", ca->ca_ra.ra_nintr);
+		return;
+	}
+
+	sbc->sbus_pri = ca->ca_ra.ra_intr[0].int_pri;
+	printf(" pri %d\n", sbc->sbus_pri);
+
+	if (ca->ca_ra.ra_vaddr) {
+		sbc->sbus_reg = (volatile u_char *) ca->ca_ra.ra_vaddr;
+	} else {
+		sbc->sbus_reg = (volatile u_char *)
+		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len);
+	}
+	sbc->sbus_node = ca->ca_ra.ra_node;
+
+	sbc->sbus_isp.isp_mdvec = &mdvec;
+	isp_reset(&sbc->sbus_isp);
+	if (sbc->sbus_isp.isp_state != ISP_RESETSTATE) {
+		return;
+	}
+	isp_init(&sbc->sbus_isp);
+	if (sbc->sbus_isp.isp_state != ISP_INITSTATE) {
+		isp_uninit(&sbc->sbus_isp);
+		return;
+	}
+	sbc->sbus_ih.ih_fun = (void *) isp_intr;
+	sbc->sbus_ih.ih_arg = sbc;
+	intr_establish(sbc->sbus_pri, &sbc->sbus_ih);
+
+	/*
+	 * Do Generic attach now.
+	 */
+	isp_attach(&sbc->sbus_isp);
+	if (sbc->sbus_isp.isp_state != ISP_RUNSTATE) {
+		isp_uninit(&sbc->sbus_isp);
+	}
+}
+
+#define  SBUS_BIU_REGS_OFF		0x00
+#define	 SBUS_MBOX_REGS_OFF		0x80
+#define	 SBUS_SXP_REGS_OFF		0x200
+#define	 SBUS_RISC_REGS_OFF		0x400
+
+static u_int16_t
+isp_sbus_rd_reg(isp, regoff)
+	struct ispsoftc *isp;
+	int regoff;
+{
+	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
+
+	int offset;
+	if ((regoff & BIU_BLOCK) != 0) {
+		offset = SBUS_BIU_REGS_OFF;
+	} else if ((regoff & MBOX_BLOCK) != 0) {
+		offset = SBUS_MBOX_REGS_OFF;
+	} else if ((regoff & SXP_BLOCK) != 0) {
+		offset = SBUS_SXP_REGS_OFF;
+	} else {
+		offset = SBUS_RISC_REGS_OFF;
+	}
+	regoff &= 0xff;
+	offset += regoff;
+	return (*((u_int16_t *) &sbc->sbus_reg[offset]));
+}
+
+static void
+isp_sbus_wr_reg (isp, regoff, val)
+	struct ispsoftc *isp;
+	int regoff;
+	u_int16_t val;
+{
+	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
+	int offset;
+
+	if ((regoff & BIU_BLOCK) != 0) {
+		offset = SBUS_BIU_REGS_OFF;
+	} else if ((regoff & MBOX_BLOCK) != 0) {
+		offset = SBUS_MBOX_REGS_OFF;
+	} else if ((regoff & SXP_BLOCK) != 0) {
+		offset = SBUS_SXP_REGS_OFF;
+	} else {
+		offset = SBUS_RISC_REGS_OFF;
+	}
+	regoff &= 0xff;
+	offset += regoff;
+	*((u_int16_t *) &sbc->sbus_reg[offset]) = val;
+}
+
+static int
+isp_sbus_mbxdma(isp)
+	struct ispsoftc *isp;
+{
+	size_t len;
+
+	/*
+	 * NOTE: Since most Sun machines aren't I/O coherent,
+	 * map the mailboxes through kdvma space to force them
+	 * to be uncached.
+	 */
+
+	/*
+	 * Allocate and map the request queue.
+	 */
+	len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN);
+	isp->isp_rquest = (volatile caddr_t)malloc(len, M_DEVBUF, M_NOWAIT);
+	if (isp->isp_rquest == 0)
+		return (1);
+	isp->isp_rquest_dma = (u_int32_t)kdvma_mapin((caddr_t)isp->isp_rquest,
+	    len, 0);
+	if (isp->isp_rquest_dma == 0)
+		return (1);
+
+	/*
+	 * Allocate and map the result queue.
+	 */
+	len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN);
+	isp->isp_result = (volatile caddr_t)malloc(len, M_DEVBUF, M_NOWAIT);
+	if (isp->isp_result == 0)
+		return (1);
+	isp->isp_result_dma = (u_int32_t)kdvma_mapin((caddr_t)isp->isp_result,
+	    len, 0);
+	if (isp->isp_result_dma == 0)
+		return (1);
+
+	return (0);
+}
+
+/*
+ * TODO: If kdvma_mapin fails, try using multiple smaller chunks..
+ */
+
+static int
+isp_sbus_dmasetup(isp, xs, rq, iptrp, optr)
+	struct ispsoftc *isp;
+	struct scsi_xfer *xs;
+	ispreq_t *rq;
+	u_int8_t *iptrp;
+	u_int8_t optr; 
+{
+	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
+	vm_offset_t kdvma;
+	int dosleep = (xs->flags & SCSI_NOSLEEP) != 0;
+
+	if (xs->datalen == 0) {
+		rq->req_seg_count = 1;
+		rq->req_flags |= REQFLAG_DATA_IN;
+		return (0);
+	}
+
+	if (rq->req_handle >= RQUEST_QUEUE_LEN) {
+		panic("%s: bad handle (%d) in isp_sbus_dmasetup\n",
+			isp->isp_name, rq->req_handle);
+		/* NOTREACHED */
+	}
+	if (CPU_ISSUN4M) {
+		kdvma = (vm_offset_t)
+			kdvma_mapin((caddr_t)xs->data, xs->datalen, dosleep);
+		if (kdvma == (vm_offset_t) 0) {
+			return (1);
+		}
+	} else {
+		kdvma = (vm_offset_t) xs->data;
+	}
+
+	if (sbc->sbus_kdma_allocs[rq->req_handle] != (vm_offset_t) 0) {
+		panic("%s: kdma handle already allocated\n", isp->isp_name);
+		/* NOTREACHED */
+	}
+	sbc->sbus_kdma_allocs[rq->req_handle] = kdvma;
+	if (xs->flags & SCSI_DATA_IN) {
+		rq->req_flags |= REQFLAG_DATA_IN;
+	} else {
+		rq->req_flags |= REQFLAG_DATA_OUT;
+	}
+	rq->req_dataseg[0].ds_count = xs->datalen;
+	rq->req_dataseg[0].ds_base =  (u_int32_t) kdvma;
+	rq->req_seg_count = 1;
+	return (0);
+}
+
+static void
+isp_sbus_dmateardown(isp, xs, handle)
+	struct ispsoftc *isp;
+	struct scsi_xfer *xs;
+	u_int32_t handle;
+{
+	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
+	vm_offset_t kdvma;
+
+	if (xs->flags & SCSI_DATA_IN) {
+		cpuinfo.cache_flush(xs->data, xs->datalen - xs->resid);
+	}
+
+	if (handle >= RQUEST_QUEUE_LEN) {
+		panic("%s: bad handle (%d) in isp_sbus_dmateardown\n",
+			isp->isp_name, handle);
+		/* NOTREACHED */
+	}
+	if (sbc->sbus_kdma_allocs[handle] == (vm_offset_t) 0) {
+		panic("%s: kdma handle not already allocated\n", isp->isp_name);
+		/* NOTREACHED */
+	}
+	kdvma = sbc->sbus_kdma_allocs[handle];
+	sbc->sbus_kdma_allocs[handle] = (vm_offset_t) 0;
+	if (CPU_ISSUN4M) {
+		dvma_mapout(kdvma, (vm_offset_t) xs->data, xs->datalen);
+	}
+}
diff --git a/sys/arch/sparc/dev/kbd.c b/sys/arch/sparc/dev/kbd.c
index c4ae36b0aab..9bf291e0a43 100644
--- a/sys/arch/sparc/dev/kbd.c
+++ b/sys/arch/sparc/dev/kbd.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: kbd.c,v 1.5 1996/08/11 23:34:01 downsj Exp $	*/
-/*	$NetBSD: kbd.c,v 1.23 1996/04/01 17:34:34 christos Exp $ */
+/*	$OpenBSD: kbd.c,v 1.6 1997/08/08 08:25:16 downsj Exp $	*/
+/*	$NetBSD: kbd.c,v 1.27 1996/10/13 03:00:01 christos Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -66,7 +66,7 @@
 #include <machine/conf.h>
 
 #include <machine/vuid_event.h>
-#include <sparc/dev/event_var.h>
+#include <dev/sun/event_var.h>
 #include <machine/kbd.h>
 #include <machine/kbio.h>
 
@@ -326,7 +326,6 @@ kbd_reset(ks)
 		break;
 	default:
 		printf("Unknown keyboard type %d\n", ks->kbd_id);
-		break;
 	}
 
 	ks->kbd_leds = 0;
@@ -720,6 +719,7 @@ kbdioctl(dev, cmd, data, flag, p)
 		*(char *)data = k->k_state.kbd_leds;
 		return (0);
 
+
 	case FIONBIO:		/* we will remove this someday (soon???) */
 		return (0);
 
diff --git a/sys/arch/sparc/dev/lebuffer.c b/sys/arch/sparc/dev/lebuffer.c
new file mode 100644
index 00000000000..b97675194c6
--- /dev/null
+++ b/sys/arch/sparc/dev/lebuffer.c
@@ -0,0 +1,143 @@
+/*	$OpenBSD: lebuffer.c,v 1.1 1997/08/08 08:25:16 downsj Exp $	*/
+/*	$NetBSD: lebuffer.c,v 1.3 1997/05/24 20:16:28 pk Exp $ */
+
+/*
+ * Copyright (c) 1996 Paul Kranenburg.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Peter Galbavy.
+ * 4. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/errno.h>
+#include <sys/ioctl.h>
+#include <sys/device.h>
+#include <sys/malloc.h>
+#include <sys/buf.h>
+#include <sys/proc.h>
+#include <sys/user.h>
+
+#include <sparc/autoconf.h>
+#include <sparc/cpu.h>
+
+#include <sparc/dev/sbusvar.h>
+#include <sparc/dev/lebuffervar.h>
+#include <sparc/dev/dmareg.h>/*XXX*/
+
+int	lebufprint __P((void *, const char *));
+void	lebufattach __P((struct device *, struct device *, void *));
+
+struct cfattach lebuffer_ca = {
+	sizeof(struct lebuf_softc), matchbyname, lebufattach
+};
+
+struct cfdriver lebuffer_cd = {
+	NULL, "lebuffer", DV_DULL
+};
+
+int
+lebufprint(aux, name)
+	void *aux;
+	const char *name;
+{
+	register struct confargs *ca = aux;
+
+	if (name)
+		printf("[%s at %s]", ca->ca_ra.ra_name, name);
+	printf(" slot 0x%x offset 0x%x", ca->ca_slot, ca->ca_offset);
+	return (UNCONF);
+}
+
+/*
+ * Attach all the sub-devices we can find
+ */
+void
+lebufattach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+#if defined(SUN4C) || defined(SUN4M)
+	register struct confargs *ca = aux;
+	struct lebuf_softc *sc = (void *)self;
+	int node;
+	struct confargs oca;
+	char *name;
+	int sbusburst;
+
+	if (ca->ca_ra.ra_vaddr == NULL || ca->ca_ra.ra_nvaddrs == 0)
+		ca->ca_ra.ra_vaddr =
+		    mapiodev(ca->ca_ra.ra_reg, 0, ca->ca_ra.ra_len);
+
+	/*
+	 * This device's "register space" is just a buffer where the
+	 * Lance ring-buffers can be stored. Note the buffer's location
+	 * and size, so the `le' driver can pick them up.
+	 */
+	sc->sc_buffer = (caddr_t)ca->ca_ra.ra_vaddr;
+	sc->sc_bufsiz = ca->ca_ra.ra_len;
+
+	/*
+	 * Get transfer burst size from PROM
+	 */
+	sbusburst = ((struct sbus_softc *)parent)->sc_burst;
+	if (sbusburst == 0)
+		sbusburst = SBUS_BURST_32 - 1; /* 1->16 */
+
+	sc->sc_burst = getpropint(ca->ca_ra.ra_node, "burst-sizes", -1);
+	if (sc->sc_burst == -1)
+		/* take SBus burst sizes */
+		sc->sc_burst = sbusburst;
+
+	/* Clamp at parent's burst sizes */
+	sc->sc_burst &= sbusburst;
+
+	printf("\n");
+
+	node = sc->sc_node = ca->ca_ra.ra_node;
+
+	if (ca->ca_bustype == BUS_SBUS)
+		sbus_establish(&sc->sc_sd, &sc->sc_dev);
+
+	/* Propagate bootpath */
+	if (ca->ca_ra.ra_bp != NULL)
+		oca.ca_ra.ra_bp = ca->ca_ra.ra_bp + 1;
+	else
+		oca.ca_ra.ra_bp = NULL;
+
+	/* search through children */
+	for (node = firstchild(node); node; node = nextsibling(node)) {
+		name = getpropstring(node, "name");
+		if (!romprop(&oca.ca_ra, name, node))
+			continue;
+
+		sbus_translate(parent, &oca);
+		oca.ca_bustype = BUS_SBUS;
+		(void) config_found(&sc->sc_dev, (void *)&oca, lebufprint);
+	}
+#endif /* SUN4C || SUN4M */
+}
diff --git a/sys/arch/sparc/dev/cgfourreg.h b/sys/arch/sparc/dev/lebuffervar.h
index 9d53b73de6e..edd47c7b8e9 100644
--- a/sys/arch/sparc/dev/cgfourreg.h
+++ b/sys/arch/sparc/dev/lebuffervar.h
@@ -1,9 +1,8 @@
-/*	$NetBSD: cgfourreg.h,v 1.4 1994/11/20 20:52:03 deraadt Exp $ */
+/*	$OpenBSD: lebuffervar.h,v 1.1 1997/08/08 08:25:18 downsj Exp $	*/
+/*	$NetBSD: lebuffervar.h,v 1.2 1997/03/10 22:56:54 pk Exp $ */
 
 /*
- * Copyright (c) 1995 Theo de Raadt
- * All rights reserved.
- *
+ * Copyright (c) 1996 Paul Kranenburg.  All rights reserved.
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -14,7 +13,7 @@
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *	This product includes software developed by Theo de Raadt.
+ *	This product includes software developed by Paul Kranenburg.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
@@ -30,25 +29,13 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-/*
- * cgfour display registers.  Much like bwtwo registers, except that
- * there is a Brooktree Video DAC in there (so we also use btreg.h).
- */
-
-/* offsets */
-#define CG4REG_CMAP	0x200000
-#define	CG4REG_OVERLAY	0x400000
-#define	CG4REG_ENABLE	0x600000
-#define	CG4REG_COLOUR	0x800000
-#define	CG4REG_END	0xa00000
-
-/* same, but for gdb */
-struct cgfour_all {
-	char	ba_nothing[0x200000];
-	struct	bt_regs ba_btreg;	/* Brooktree registers */
-	char	ba_xxx1[0x100000-sizeof(struct bt_regs)];
-	char	ba_pfourreg[0x100000];
-	char	ba_overlay[0x200000];
-	char	ba_enable[0x200000];
-	char	ba_color[0x200000];
+struct lebuf_softc {
+	struct device sc_dev;		/* us as a device */
+	struct sbusdev sc_sd;		/* sbus device */
+	u_int	sc_rev;			/* revision */
+	int	sc_node;		/* PROM node ID */
+	int	sc_burst;		/* DVMA burst size in effect */
+	caddr_t	sc_buffer;		/* VA of the buffer we provide */
+	int	sc_bufsiz;		/* Size of buffer */
+	int	attached;		/* 1: in use by `le' device */
 };
diff --git a/sys/arch/sparc/dev/ms.c b/sys/arch/sparc/dev/ms.c
index 4bf14f2c9b2..1049fb12e45 100644
--- a/sys/arch/sparc/dev/ms.c
+++ b/sys/arch/sparc/dev/ms.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: ms.c,v 1.5 1996/08/11 23:28:12 downsj Exp $	*/
-/*	$NetBSD: ms.c,v 1.8 1996/04/01 17:29:52 christos Exp $ */
+/*	$OpenBSD: ms.c,v 1.6 1997/08/08 08:25:19 downsj Exp $	*/
+/*	$NetBSD: ms.c,v 1.10 1996/09/12 01:36:18 mrg Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -64,7 +64,7 @@
 #include <machine/kbd.h>
 #include <machine/conf.h>
 
-#include <sparc/dev/event_var.h>
+#include <dev/sun/event_var.h>
 
 /*
  * Mouse state.  A Mouse Systems mouse is a fairly simple device,
@@ -255,6 +255,12 @@ msopen(dev, flags, mode, p)
 	ms_softc.ms_events.ev_io = p;
 	ev_init(&ms_softc.ms_events);	/* may cause sleep */
 
+	if (CPU_ISSUN4) {
+		/* We need to set the baud rate on the mouse. */
+		ms_softc.ms_mouse->t_ispeed =
+		    ms_softc.ms_mouse->t_ospeed = 1200;
+	}
+
 	(*ms_softc.ms_open)(ms_softc.ms_mouse);
 	ms_softc.ms_ready = 1;		/* start accepting events */
 	return (0);
diff --git a/sys/arch/sparc/dev/obio.c b/sys/arch/sparc/dev/obio.c
index 2787aa91c01..845d97dddd3 100644
--- a/sys/arch/sparc/dev/obio.c
+++ b/sys/arch/sparc/dev/obio.c
@@ -1,8 +1,9 @@
-/*	$NetBSD: obio.c,v 1.24 1996/05/18 12:22:49 mrg Exp $	*/
+/*	$OpenBSD: obio.c,v 1.7 1997/08/08 08:25:20 downsj Exp $	*/
+/*	$NetBSD: obio.c,v 1.37 1997/07/29 09:58:11 fair Exp $	*/
 
 /*
  * Copyright (c) 1993, 1994 Theo de Raadt
- * Copyright (c) 1995 Paul Kranenburg
+ * Copyright (c) 1995, 1997 Paul Kranenburg
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -50,28 +51,42 @@
 #include <machine/ctlreg.h>
 #include <sparc/sparc/asm.h>
 #include <sparc/sparc/vaddrs.h>
+#include <sparc/sparc/cpuvar.h>
 #include <sparc/dev/sbusvar.h>
+#include <sparc/dev/vmereg.h>
+
+struct vmebus_softc { 
+	struct device	 sc_dev;	/* base device */
+	struct vmebusreg *sc_reg; 	/* VME control registers */
+	struct vmebusvec *sc_vec;	/* VME interrupt vector */
+	struct rom_range *sc_range;	/* ROM range property */
+	int		 sc_nrange;
+};
+struct  vmebus_softc *vmebus_sc;/*XXX*/
 
 struct bus_softc {
 	union {
 		struct	device scu_dev;		/* base device */
 		struct	sbus_softc scu_sbus;	/* obio is another sbus slot */
+		struct	vmebus_softc scu_vme;
 	} bu;
-#define sc_dev	bu.scu_dev
 };
 
+
 /* autoconfiguration driver */
 static int	busmatch __P((struct device *, void *, void *));
 static void	obioattach __P((struct device *, struct device *, void *));
 static void	vmesattach __P((struct device *, struct device *, void *));
 static void	vmelattach __P((struct device *, struct device *, void *));
+static void	vmeattach __P((struct device *, struct device *, void *));
 
 int		busprint __P((void *, const char *));
+int		vmeprint __P((void *, const char *));
 static int	busattach __P((struct device *, void *, void *, int));
-void *		bus_map __P((struct rom_reg *, int, int));
 int		obio_scan __P((struct device *, void *, void *));
 int 		vmes_scan __P((struct device *, void *, void *));
 int 		vmel_scan __P((struct device *, void *, void *));
+void		vmebus_translate __P((struct device *, struct confargs *, int));
 int 		vmeintr __P((void *));
 
 struct cfattach obio_ca = {
@@ -98,6 +113,14 @@ struct cfdriver vmes_cd = {
 	NULL, "vmes", DV_DULL
 };
 
+struct cfattach vme_ca = {
+	sizeof(struct bus_softc), busmatch, vmeattach
+};
+
+struct cfdriver vme_cd = {
+	NULL, "vme", DV_DULL
+};
+
 struct intrhand **vmeints;
 
 
@@ -106,7 +129,7 @@ busmatch(parent, vcf, aux)
 	struct device *parent;
 	void *vcf, *aux;
 {
-	struct cfdata *cf = vcf;
+	register struct cfdata *cf = vcf;
 	register struct confargs *ca = aux;
 	register struct romaux *ra = &ca->ca_ra;
 
@@ -140,6 +163,17 @@ busprint(args, obio)
 	return (UNCONF);
 }
 
+int
+vmeprint(args, name)
+	void *args;
+	const char *name;
+{
+	register struct confargs *ca = args;
+
+	if (name)
+		printf("%s at %s", ca->ca_ra.ra_name, name);
+	return (UNCONF);
+}
 
 void
 obioattach(parent, self, args)
@@ -154,13 +188,16 @@ obioattach(parent, self, args)
 	register char *name;
 	register const char *sp;
 	const char *const *ssp;
+	int rlen;
 	extern int autoconf_nzs;
 
 	static const char *const special4m[] = {
 		/* find these first */
 		"eeprom",
 		"counter",
+#if 0 /* Not all sun4m's have an `auxio' */
 		"auxio",
+#endif
 		"",
 		/* place device to ignore here */
 		"interrupt",
@@ -187,7 +224,7 @@ obioattach(parent, self, args)
 	 * There is only one obio bus (it is in fact one of the Sbus slots)
 	 * How about VME?
 	 */
-	if (sc->sc_dev.dv_unit > 0) {
+	if (self->dv_unit > 0) {
 		printf(" unsupported\n");
 		return;
 	}
@@ -199,8 +236,16 @@ obioattach(parent, self, args)
 	else
 		oca.ca_ra.ra_bp = NULL;
 
-	sc->bu.scu_sbus.sc_range = ra->ra_range;
-	sc->bu.scu_sbus.sc_nrange = ra->ra_nrange;
+	node = ra->ra_node;
+	rlen = getproplen(node, "ranges");
+	if (rlen > 0) {
+		sc->bu.scu_sbus.sc_nrange = rlen / sizeof(struct rom_range);
+		sc->bu.scu_sbus.sc_range =
+			(struct rom_range *)malloc(rlen, M_DEVBUF, M_NOWAIT);
+		if (sc->bu.scu_sbus.sc_range == 0)
+			panic("obio: PROM ranges too large: %d", rlen);
+		(void)getprop(node, "ranges", sc->bu.scu_sbus.sc_range, rlen);
+	}
 
 	/*
 	 * Loop through ROM children, fixing any relative addresses
@@ -218,7 +263,7 @@ obioattach(parent, self, args)
 
 		sbus_translate(self, &oca);
 		oca.ca_bustype = BUS_OBIO;
-		(void) config_found(&sc->sc_dev, (void *)&oca, busprint);
+		(void) config_found(self, (void *)&oca, busprint);
 	}
 
 	for (node = node0; node; node = nextsibling(node)) {
@@ -237,7 +282,7 @@ obioattach(parent, self, args)
 		/* Translate into parent address spaces */
 		sbus_translate(self, &oca);
 		oca.ca_bustype = BUS_OBIO;
-		(void) config_found(&sc->sc_dev, (void *)&oca, busprint);
+		(void) config_found(self, (void *)&oca, busprint);
 	}
 #endif
 }
@@ -247,7 +292,8 @@ vmesattach(parent, self, args)
 	struct device *parent, *self;
 	void *args;
 {
-	if (CPU_ISSUN4M || self->dv_unit > 0) {
+	if (self->dv_unit > 0 ||
+	    (CPU_ISSUN4M && strncmp(parent->dv_xname, "vme", 3) != 0)) {
 		printf(" unsupported\n");
 		return;
 	}
@@ -267,7 +313,8 @@ vmelattach(parent, self, args)
 	struct device *parent, *self;
 	void *args;
 {
-	if (CPU_ISSUN4M || self->dv_unit > 0) {
+	if (self->dv_unit > 0 ||
+	    (CPU_ISSUN4M && strncmp(parent->dv_xname, "vme", 3) != 0)) {
 		printf(" unsupported\n");
 		return;
 	}
@@ -282,14 +329,116 @@ vmelattach(parent, self, args)
 	bus_untmp();
 }
 
+void
+vmeattach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct vmebus_softc *sc = (struct vmebus_softc *)self;
+	struct confargs *ca = aux;
+	register struct romaux *ra = &ca->ca_ra;
+	int node, rlen;
+	struct confargs oca;
+
+	if (!CPU_ISSUN4M || self->dv_unit > 0) {
+		printf(" unsupported\n");
+		return;
+	}
+
+	node = ra->ra_node;
+
+	sc->sc_reg = (struct vmebusreg *)
+		mapdev(&ra->ra_reg[0], 0, 0, ra->ra_reg[0].rr_len);
+	sc->sc_vec = (struct vmebusvec *)
+		mapdev(&ra->ra_reg[1], 0, 0, ra->ra_reg[1].rr_len);
+
+	/*
+	 * Get "range" property, though we don't do anything with it yet.
+	 */
+	rlen = getproplen(node, "ranges");
+	if (rlen > 0) {
+		sc->sc_nrange = rlen / sizeof(struct rom_range);
+		sc->sc_range =
+			(struct rom_range *)malloc(rlen, M_DEVBUF, M_NOWAIT);
+		if (sc->sc_range == 0)  
+			panic("vme: PROM ranges too large: %d", rlen);
+		(void)getprop(node, "ranges", sc->sc_range, rlen);
+	}
+
+	vmebus_sc = sc;
+	printf(": version 0x%x\n",
+	       sc->sc_reg->vmebus_cr & VMEBUS_CR_IMPL);
+
+	if (ra->ra_bp != NULL && strcmp(ra->ra_bp->name, "vme") == 0)
+		oca.ca_ra.ra_bp = ra->ra_bp + 1;
+	else
+		oca.ca_ra.ra_bp = NULL;
+
+	oca.ca_ra.ra_name = "vmes";
+	oca.ca_bustype = BUS_MAIN;
+	(void)config_found(self, (void *)&oca, vmeprint);
+
+	oca.ca_ra.ra_name = "vmel";
+	oca.ca_bustype = BUS_MAIN;
+	(void)config_found(self, (void *)&oca, vmeprint);
+}
+
+void
+vmebus_translate(dev, ca, bustype)
+	struct device *dev;
+	struct confargs *ca;
+	int bustype;
+{
+	struct vmebus_softc *sc = (struct vmebus_softc *)dev;
+	register int j;
+	int cspace;
+
+	if (sc->sc_nrange == 0)
+		panic("vmebus: no ranges");
+
+	/*
+	 * Find VMEbus modifier based on address space.
+	 * XXX - should not be encoded in `ra_paddr'
+	 */
+	if (((u_long)ca->ca_ra.ra_paddr & 0xffff0000) == 0xffff0000)
+		cspace = VMEMOD_A16_D_S;
+	else if (((u_long)ca->ca_ra.ra_paddr & 0xff000000) == 0xff000000)
+		cspace = VMEMOD_A24_D_S;
+	else
+		cspace = VMEMOD_A32_D_S;
+
+	cspace |= (bustype == BUS_VME32) ? VMEMOD_D32 : 0;
+
+	/* Translate into parent address spaces */
+	for (j = 0; j < sc->sc_nrange; j++) {
+		if (sc->sc_range[j].cspace == cspace) {
+#if notyet
+			(int)ca->ca_ra.ra_paddr +=
+				sc->sc_range[j].poffset;
+#endif
+			(int)ca->ca_ra.ra_iospace =
+				sc->sc_range[j].pspace;
+			break;
+		}
+	}
+}
+
+int bt2pmt[] = {
+	PMAP_OBIO,
+	PMAP_OBIO,
+	PMAP_VME16,
+	PMAP_VME32,
+	PMAP_OBIO 
+}; 
+
 int
-busattach(parent, child, args, bustype)
+busattach(parent, vcf, args, bustype)
 	struct device *parent;
-	void *args, *child;
+	void *vcf, *args;
 	int bustype;
 {
-#if defined(SUN4)
-	struct cfdata *cf = child;
+#if defined(SUN4) || defined(SUN4M)
+	register struct cfdata *cf = vcf;
 	register struct confargs *ca = args;
 	struct confargs oca;
 	caddr_t tmp;
@@ -309,24 +458,24 @@ busattach(parent, child, args, bustype)
 		 * XXX: We also assume that 4/[23]00 obio addresses
 		 * must be 0xZYYYYYYY, where (Z != 0)
 		 */
-		if (cpumod == SUN4_100 && (cf->cf_loc[0] & 0xf0000000))
+		if (cpuinfo.cpu_type == CPUTYP_4_100 &&
+		    (cf->cf_loc[0] & 0xf0000000))
 			return 0;
-		if (cpumod != SUN4_100 && !(cf->cf_loc[0] & 0xf0000000))
+		if (cpuinfo.cpu_type != CPUTYP_4_100 &&
+		    !(cf->cf_loc[0] & 0xf0000000))
 			return 0;
 	}
 
-	if (parent->dv_cfdata->cf_driver->cd_indirect) {
-		printf(" indirect devices not supported\n");
-		return 0;
-	}
-
-	oca.ca_ra.ra_iospace = -1;
 	oca.ca_ra.ra_paddr = (void *)cf->cf_loc[0];
 	oca.ca_ra.ra_len = 0;
 	oca.ca_ra.ra_nreg = 1;
+	if (CPU_ISSUN4M)
+		vmebus_translate(parent->dv_parent, &oca, bustype);
+	else
+		oca.ca_ra.ra_iospace = bt2pmt[bustype];
+
 	if (oca.ca_ra.ra_paddr)
-		tmp = (caddr_t)bus_tmp(oca.ca_ra.ra_paddr,
-		    bustype);
+		tmp = (caddr_t)mapdev(oca.ca_ra.ra_reg, TMPMAP_VA, 0, NBPG);
 	else
 		tmp = NULL;
 	oca.ca_ra.ra_vaddr = tmp;
@@ -364,8 +513,7 @@ busattach(parent, child, args, bustype)
 	 */
 	if (oca.ca_ra.ra_len)
 		oca.ca_ra.ra_vaddr =
-		    bus_map(oca.ca_ra.ra_reg,
-		    oca.ca_ra.ra_len, oca.ca_bustype);
+		    bus_map(oca.ca_ra.ra_reg, oca.ca_ra.ra_len);
 
 	config_attach(parent, cf, &oca, busprint);
 	return 1;
@@ -421,18 +569,19 @@ int
 vmeintr(arg)
 	void *arg;
 {
-	int level = (int)arg, vec;
+	int pil = (int)arg, level, vec;
 	struct intrhand *ih;
 	int i = 0;
 
-#ifdef DIAGNOSTIC
-	if (!CPU_ISSUN4) {
+	level = (pil_to_vme[pil] << 1) | 1;
+
+	if (CPU_ISSUN4) {
+		vec = ldcontrolb((caddr_t)(AC_VMEINTVEC | level));
+	} else if (CPU_ISSUN4M) {
+		vec = vmebus_sc->sc_vec->vmebusvec[level];
+	} else
 		panic("vme: spurious interrupt");
-	}
-#endif
 
-	vec = ldcontrolb((caddr_t)
-	    (AC_VMEINTVEC | (pil_to_vme[level] << 1) | 1));
 	if (vec == -1) {
 		printf("vme: spurious interrupt\n");
 		return 0;
@@ -451,13 +600,11 @@ vmeintr_establish(vec, level, ih)
 {
 	struct intrhand *ihs;
 
-	if (!CPU_ISSUN4) {
-		panic("vmeintr_establish: not supported on cpu-type %d",
-		      cputyp);
-	}
+	if (vmeints == NULL)
+		panic("vmeintr_establish: interrupt vector not allocated");
 
 	if (vec == -1)
-		panic("vmeintr_establish: uninitialized vec\n");
+		panic("vmeintr_establish: uninitialized vec");
 
 	if (vmeints[vec] == NULL)
 		vmeints[vec] = ih;
@@ -489,28 +636,16 @@ vmeintr_establish(vec, level, ih)
  * Else, create a new mapping.
  */
 void *
-bus_map(pa, len, bustype)
+bus_map(pa, len)
 	struct rom_reg *pa;
 	int len;
-	int bustype;
 {
-	u_long	pf = (u_long)(pa->rr_paddr) >> PGSHIFT;
-	u_long	va, pte;
-	int pgtype = -1;
-
-	switch (bt2pmt[bustype]) {
-	case PMAP_OBIO:
-		pgtype = PG_OBIO;
-		break;
-	case PMAP_VME32:
-		pgtype = PG_VME32;
-		break;
-	case PMAP_VME16:
-		pgtype = PG_VME16;
-		break;
-	}
 
-	if (len <= NBPG) {
+	if (CPU_ISSUN4 && len <= NBPG) {
+		u_long	pf = (u_long)(pa->rr_paddr) >> PGSHIFT;
+		int pgtype = PMAP_T2PTE_4(pa->rr_iospace);
+		u_long	va, pte;
+
 		for (va = OLDMON_STARTVADDR; va < OLDMON_ENDVADDR; va += NBPG) {
 			pte = getpte(va);
 			if ((pte & PG_V) != 0 && (pte & PG_TYPE) == pgtype &&
@@ -520,21 +655,8 @@ bus_map(pa, len, bustype)
 					/* note: preserve page offset */
 		}
 	}
-	return mapiodev(pa, 0, len, bustype);
-}
-
-void *
-bus_tmp(pa, bustype)
-	void *pa;
-	int bustype;
-{
-	vm_offset_t addr = (vm_offset_t)pa & ~PGOFSET;
-	int pmtype = bt2pmt[bustype];
 
-	pmap_enter(pmap_kernel(), TMPMAP_VA,
-		   addr | pmtype | PMAP_NC,
-		   VM_PROT_READ | VM_PROT_WRITE, 1);
-	return ((void *)(TMPMAP_VA | ((u_long) pa & PGOFSET)) );
+	return mapiodev(pa, 0, len);
 }
 
 void
diff --git a/sys/arch/sparc/dev/pfour.c b/sys/arch/sparc/dev/pfour.c
index 3ed22d7df5c..c903754515a 100644
--- a/sys/arch/sparc/dev/pfour.c
+++ b/sys/arch/sparc/dev/pfour.c
@@ -1,4 +1,4 @@
-/*	$Id: pfour.c,v 1.5 1995/12/15 13:56:26 deraadt Exp $ */
+/*	$OpenBSD: pfour.c,v 1.6 1997/08/08 08:25:20 downsj Exp $ */
 
 /*
  * Copyright (c) 1995 Theo de Raadt
diff --git a/sys/arch/sparc/dev/pfourreg.h b/sys/arch/sparc/dev/pfourreg.h
index 8ec422c2019..a0ef7094c05 100644
--- a/sys/arch/sparc/dev/pfourreg.h
+++ b/sys/arch/sparc/dev/pfourreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: pfourreg.h,v 1.4 1997/08/08 08:25:21 downsj Exp $	*/
 /*	$NetBSD: pfourreg.h,v 1.1 1996/02/27 22:09:36 thorpej Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/power.c b/sys/arch/sparc/dev/power.c
index d083500333f..0255c25c059 100644
--- a/sys/arch/sparc/dev/power.c
+++ b/sys/arch/sparc/dev/power.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: power.c,v 1.3 1997/06/22 22:45:34 downsj Exp $	*/
+/*	$OpenBSD: power.c,v 1.4 1997/08/08 08:25:22 downsj Exp $	*/
 /*	$NetBSD: power.c,v 1.2 1996/05/16 15:56:56 abrown Exp $ */
 
 /*
@@ -91,7 +91,7 @@ powerattach(parent, self, aux)
 	struct confargs *ca = aux;
 	struct romaux *ra = &ca->ca_ra;
 
-	power_reg = mapdev(ra->ra_reg, 0, 0, sizeof(long), ca->ca_bustype);
+	power_reg = mapdev(ra->ra_reg, 0, 0, sizeof(long));
 
 	power_attached = 1;
 
diff --git a/sys/arch/sparc/dev/rcons_font.h b/sys/arch/sparc/dev/rcons_font.h
index 3cbc847ea53..292ce909ba0 100644
--- a/sys/arch/sparc/dev/rcons_font.h
+++ b/sys/arch/sparc/dev/rcons_font.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: rcons_font.h,v 1.4 1997/08/08 08:25:25 downsj Exp $	*/
 /* $NetBSD: rcons_font.h,v 1.3 1995/11/29 22:03:53 pk Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/sbus.c b/sys/arch/sparc/dev/sbus.c
index 0f7ceff3bbf..aee7de7fbf8 100644
--- a/sys/arch/sparc/dev/sbus.c
+++ b/sys/arch/sparc/dev/sbus.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: sbus.c,v 1.10 1996/04/22 02:35:03 abrown Exp $ */
+/*	$OpenBSD: sbus.c,v 1.5 1997/08/08 08:25:27 downsj Exp $	*/
+/*	$NetBSD: sbus.c,v 1.17 1997/06/01 22:10:39 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -49,8 +50,10 @@
  */
 
 #include <sys/param.h>
+#include <sys/malloc.h>
 #include <sys/systm.h>
 #include <sys/device.h>
+#include <vm/vm.h>
 
 #include <machine/autoconf.h>
 
@@ -96,7 +99,7 @@ sbus_match(parent, vcf, aux)
 	struct device *parent;
 	void *vcf, *aux;
 {
-	struct cfdata *cf = vcf;
+	register struct cfdata *cf = vcf;
 	register struct confargs *ca = aux;
 	register struct romaux *ra = &ca->ca_ra;
 
@@ -121,6 +124,7 @@ sbus_attach(parent, self, aux)
 	register int node;
 	register char *name;
 	struct confargs oca;
+	int rlen;
 
 	/*
 	 * XXX there is only one Sbus, for now -- do not know how to
@@ -149,8 +153,15 @@ sbus_attach(parent, self, aux)
 	else
 		oca.ca_ra.ra_bp = NULL;
 
-	sc->sc_range = ra->ra_range;
-	sc->sc_nrange = ra->ra_nrange;
+	rlen = getproplen(node, "ranges");
+	if (rlen > 0) {
+		sc->sc_nrange = rlen / sizeof(struct rom_range);
+		sc->sc_range =
+			(struct rom_range *)malloc(rlen, M_DEVBUF, M_NOWAIT);
+		if (sc->sc_range == 0)
+			panic("sbus: PROM ranges too large: %d", rlen);
+		(void)getprop(node, "ranges", sc->sc_range, rlen);
+	}
 
 	/*
 	 * Loop through ROM children, fixing any relative addresses
@@ -183,15 +194,19 @@ sbus_translate(dev, ca)
 			ca->ca_slot = SBUS_ABS_TO_SLOT(base);
 			ca->ca_offset = SBUS_ABS_TO_OFFSET(base);
 		} else {
+			if (!CPU_ISSUN4C)
+				panic("relative sbus addressing not supported");
 			ca->ca_slot = slot = ca->ca_ra.ra_iospace;
 			ca->ca_offset = base;
-			ca->ca_ra.ra_paddr =
-				(void *)SBUS_ADDR(slot, base);
+			ca->ca_ra.ra_paddr = (void *)SBUS_ADDR(slot, base);
+			ca->ca_ra.ra_iospace = PMAP_OBIO;
+
 			/* Fix any remaining register banks */
 			for (i = 1; i < ca->ca_ra.ra_nreg; i++) {
 				base = (int)ca->ca_ra.ra_reg[i].rr_paddr;
 				ca->ca_ra.ra_reg[i].rr_paddr =
 					(void *)SBUS_ADDR(slot, base);
+				ca->ca_ra.ra_reg[i].rr_iospace = PMAP_OBIO;
 			}
 		}
 
@@ -237,12 +252,13 @@ sbus_establish(sd, dev)
 	 */
 	for (curdev = dev->dv_parent; ; curdev = curdev->dv_parent) {
 		if (!curdev || !curdev->dv_xname)
-		    panic("sbus_establish: can't find sbus parent for %s",
-			  (sd->sd_dev->dv_xname ? sd->sd_dev->dv_xname :
-			   "<unknown>"));
+			panic("sbus_establish: can't find sbus parent for %s",
+			      sd->sd_dev->dv_xname
+					? sd->sd_dev->dv_xname
+					: "<unknown>" );
 
 		if (strncmp(curdev->dv_xname, "sbus", 4) == 0)
-		    break;
+			break;
 	}
 	sc = (struct sbus_softc *) curdev;
 
diff --git a/sys/arch/sparc/dev/sbusreg.h b/sys/arch/sparc/dev/sbusreg.h
index 74c0b270292..3455f5eb366 100644
--- a/sys/arch/sparc/dev/sbusreg.h
+++ b/sys/arch/sparc/dev/sbusreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: sbusreg.h,v 1.2 1997/08/08 08:25:27 downsj Exp $	*/
 /*	$NetBSD: sbusreg.h,v 1.2 1994/11/20 20:52:26 deraadt Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/sbusvar.h b/sys/arch/sparc/dev/sbusvar.h
index 72fa1025523..21fd61967c2 100644
--- a/sys/arch/sparc/dev/sbusvar.h
+++ b/sys/arch/sparc/dev/sbusvar.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: sbusvar.h,v 1.4 1997/08/08 08:25:28 downsj Exp $	*/
 /*	$NetBSD: sbusvar.h,v 1.4 1996/04/22 02:35:05 abrown Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/si.c b/sys/arch/sparc/dev/si.c
index 5aa1f4f4946..a96caafb133 100644
--- a/sys/arch/sparc/dev/si.c
+++ b/sys/arch/sparc/dev/si.c
@@ -1,11 +1,13 @@
-/*	$NetBSD: si.c,v 1.24 1996/05/13 01:53:45 thorpej Exp $	*/
+/*	$OpenBSD: si.c,v 1.10 1997/08/08 08:25:29 downsj Exp $	*/
+/*	$NetBSD: si.c,v 1.37 1997/07/29 09:58:13 fair Exp $	*/
 
-/*
- * Copyright (c) 1995 Jason R. Thorpe
- * Copyright (c) 1995 David Jones, Gordon W. Ross
- * Copyright (c) 1994 Adam Glass
+/*-
+ * Copyright (c) 1996 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Adam Glass, David Jones, Gordon W. Ross, and Jason R. Thorpe.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ -14,23 +16,25 @@
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 3. The name of the authors may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- * 4. All advertising materials mentioning features or use of this software
+ * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
- *      This product includes software developed by
- *      Adam Glass, David Jones, Gordon Ross, and Jason R. Thorpe
+ *        This product includes software developed by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
  */
 
 /*
@@ -108,6 +112,7 @@
 #include <machine/pmap.h>
 
 #include <sparc/sparc/vaddrs.h>
+#include <sparc/sparc/cpuvar.h>
 
 #ifndef DDB
 #define	Debugger()
@@ -190,7 +195,7 @@ struct si_softc {
 #define	SI_DO_RESELECT	0x04	/* Allow disconnect/reselect */
 #define	SI_OPTIONS_MASK	(SI_ENABLE_DMA|SI_DMA_INTR|SI_DO_RESELECT)
 #define SI_OPTIONS_BITS	"\10\3RESELECT\2DMA_INTR\1DMA"
-int si_options = 0;		/* XXX SI_ENABLE_DMA when dma works */
+int si_options = SI_ENABLE_DMA;
 int sw_options = SI_ENABLE_DMA;
 
 /* How long to wait for DMA before declaring an error. */
@@ -201,7 +206,6 @@ static void	si_attach __P((struct device *, struct device *, void *));
 static int	si_intr __P((void *));
 static void	si_reset_adapter __P((struct ncr5380_softc *));
 static void	si_minphys __P((struct buf *));
-static int	si_print __P((void *, const char *));
 
 void si_dma_alloc __P((struct ncr5380_softc *));
 void si_dma_free __P((struct ncr5380_softc *));
@@ -259,22 +263,12 @@ struct cfdriver sw_cd = {
 };
 
 static int
-si_print(aux, name)
-	void *aux;
-	const char *name;
-{
-	if (name != NULL)
-		printf("%s: scsibus ", name);
-	return UNCONF;
-}
-
-static int
-si_match(parent, vcf, args)
+si_match(parent, vcf, aux)
 	struct device	*parent;
-	void		*vcf, *args;
+	void *vcf, *aux;
 {
-	struct cfdata	*cf = vcf;
-	struct confargs *ca = args;
+	struct cfdata *cf = vcf;
+	struct confargs *ca = aux;
 	struct romaux *ra = &ca->ca_ra;
 
 	/* Are we looking for the right thing? */
@@ -296,13 +290,15 @@ si_match(parent, vcf, args)
 	switch (ca->ca_bustype) {
 	case BUS_VME16:
 		/* AFAIK, the `si' can only exist on the vmes. */
-		if (strcmp(ra->ra_name, "si") || cpumod == SUN4_100)
+		if (strcmp(ra->ra_name, "si") ||
+		    cpuinfo.cpu_type == CPUTYP_4_100)
 			return (0);
 		break;
 
 	case BUS_OBIO:
 		/* AFAIK, an `sw' can only exist on the obio. */
-		if (strcmp(ra->ra_name, "sw") || cpumod != SUN4_100)
+		if (strcmp(ra->ra_name, "sw") ||
+		    cpuinfo.cpu_type != CPUTYP_4_100)
 			return (0);
 		break;
 
@@ -341,17 +337,20 @@ si_attach(parent, self, args)
 	struct bootpath *bp;
 	int i;
 
-	/* Pull in the options flags. */
-	if (ca->ca_bustype == BUS_OBIO)
-		sc->sc_options = sw_options;
+	/*
+	 * Pull in the options flags.  Allow the user to completely
+	 * override the default values.
+	 */
+	if ((ncr_sc->sc_dev.dv_cfdata->cf_flags & SI_OPTIONS_MASK) != 0)
+		sc->sc_options =
+		    (ncr_sc->sc_dev.dv_cfdata->cf_flags & SI_OPTIONS_MASK);
 	else
-		sc->sc_options = si_options;
-	sc->sc_options |=
-	    (ncr_sc->sc_dev.dv_cfdata->cf_flags & SI_OPTIONS_MASK);
+		sc->sc_options =
+		    (ca->ca_bustype == BUS_OBIO) ? sw_options : si_options;
 
 	/* Map the controller registers. */
-	regs = (struct si_regs *)mapiodev(ra->ra_reg, 0,
-	    sizeof(struct si_regs), ca->ca_bustype);
+	regs = (struct si_regs *)
+		mapiodev(ra->ra_reg, 0, sizeof(struct si_regs));
 
 	/*
 	 * Fill in the prototype scsi_link.
@@ -413,7 +412,7 @@ si_attach(parent, self, args)
 	}
 
 	ncr_sc->sc_flags = 0;
-	if (sc->sc_options & SI_DO_RESELECT)
+	if ((sc->sc_options & SI_DO_RESELECT) == 0)
 		ncr_sc->sc_flags |= NCR5380_PERMIT_RESELECT;
 	if ((sc->sc_options & SI_DMA_INTR) == 0)
 		ncr_sc->sc_flags |= NCR5380_FORCE_POLLING;
@@ -494,7 +493,7 @@ si_attach(parent, self, args)
 		bootpath_store(1, bp + 1);
 
 	/* Configure sub-devices */
-	config_found(self, &(ncr_sc->sc_link), si_print);
+	config_found(self, &(ncr_sc->sc_link), scsiprint);
 
 	bootpath_store(1, NULL);
 }
@@ -505,7 +504,7 @@ si_minphys(struct buf *bp)
 	if (bp->b_bcount > MAX_DMA_LEN) {
 #ifdef DEBUG
 		if (si_debug) {
-			printf("si_minphys len = %x.\n", MAX_DMA_LEN);
+			printf("si_minphys len = 0x%x.\n", MAX_DMA_LEN);
 			Debugger();
 		}
 #endif
@@ -658,21 +657,6 @@ si_dma_alloc(ncr_sc)
 	if (xlen < MIN_DMA_LEN)
 		panic("si_dma_alloc: xlen=0x%x\n", xlen);
 
-	/*
-	 * XXX SUN4 doesn't have this limitation?
-	 * Never attempt single transfers of more than 63k, because
-	 * our count register may be only 16 bits (an OBIO adapter).
-	 * This should never happen since already bounded by minphys().
-	 * XXX - Should just segment these...
-	 */
-	if (xlen > MAX_DMA_LEN) {
-		printf("si_dma_alloc: excessive xlen=0x%x\n", xlen);
-#ifdef DEBUG
-		Debugger();
-#endif
-		ncr_sc->sc_datalen = xlen = MAX_DMA_LEN;
-	}
-
 	/* Find free DMA handle.  Guaranteed to find one since we have
 	   as many DMA handles as the driver has processes. */
 	for (i = 0; i < SCI_OPENINGS; i++) {
@@ -701,7 +685,7 @@ found:
 	dh->dh_dvma = (long)kdvma_mapin((caddr_t)addr, xlen, 0);
 	if (dh->dh_dvma == 0) {
 		/* Can't remap segment */
-		printf("si_dma_alloc: can't remap %p/%x, doing PIO\n",
+		printf("si_dma_alloc: can't remap %p/0x%x, doing PIO\n",
 			dh->dh_addr, dh->dh_maplen);
 		dh->dh_flags = 0;
 		return;
diff --git a/sys/arch/sparc/dev/sireg.h b/sys/arch/sparc/dev/sireg.h
index 8f2ab6e40e3..d17fc344b74 100644
--- a/sys/arch/sparc/dev/sireg.h
+++ b/sys/arch/sparc/dev/sireg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: sireg.h,v 1.3 1997/08/08 08:25:30 downsj Exp $	*/
 /*	$NetBSD: sireg.h,v 1.3 1996/01/01 22:40:58 thorpej Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/tcx.c b/sys/arch/sparc/dev/tcx.c
new file mode 100644
index 00000000000..608fb4e64c0
--- /dev/null
+++ b/sys/arch/sparc/dev/tcx.c
@@ -0,0 +1,496 @@
+/*	$OpenBSD: tcx.c,v 1.1 1997/08/08 08:25:31 downsj Exp $	*/
+/*	$NetBSD: tcx.c,v 1.8 1997/07/29 09:58:14 fair Exp $ */
+
+/* 
+ *  Copyright (c) 1996 The NetBSD Foundation, Inc.
+ *  All rights reserved.
+ * 
+ *  This code is derived from software contributed to The NetBSD Foundation
+ *  by Paul Kranenburg.
+ * 
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. All advertising materials mentioning features or use of this software
+ *     must display the following acknowledgement:
+ *         This product includes software developed by the NetBSD
+ *         Foundation, Inc. and its contributors.
+ *  4. Neither the name of The NetBSD Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ * 
+ *  THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ *  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */ 
+
+/*
+ * color display (TCX) driver.
+ *
+ * Does not handle interrupts, even though they can occur.
+ *
+ * XXX should defer colormap updates to vertical retrace interrupts
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/buf.h>
+#include <sys/device.h>
+#include <machine/fbio.h>
+#include <sys/ioctl.h>
+#include <sys/malloc.h>
+#include <sys/mman.h>
+#include <sys/tty.h>
+#include <sys/conf.h>
+
+#ifdef DEBUG
+#include <sys/proc.h>
+#include <sys/syslog.h>
+#endif
+
+#include <vm/vm.h>
+
+#include <machine/autoconf.h>
+#include <machine/pmap.h>
+#include <machine/fbvar.h>
+#include <machine/cpu.h>
+#include <machine/conf.h>
+
+#include <sparc/dev/btreg.h>
+#include <sparc/dev/btvar.h>
+#include <sparc/dev/tcxreg.h>
+#include <sparc/dev/sbusvar.h>
+
+#if 0
+union cursor_cmap {		/* colormap, like bt_cmap, but tiny */
+	u_char	cm_map[2][3];	/* 2 R/G/B entries */
+	u_int	cm_chip[2];	/* 2 chip equivalents */
+};
+
+struct tcx_cursor {		/* tcx hardware cursor status */
+	short	cc_enable;		/* cursor is enabled */
+	struct	fbcurpos cc_pos;	/* position */
+	struct	fbcurpos cc_hot;	/* hot-spot */
+	struct	fbcurpos cc_size;	/* size of mask & image fields */
+	u_int	cc_bits[2][32];		/* space for mask & image bits */
+	union	cursor_cmap cc_color;	/* cursor colormap */
+};
+#endif
+
+/* per-display variables */
+struct tcx_softc {
+	struct	device sc_dev;		/* base device */
+	struct	sbusdev sc_sd;		/* sbus device */
+	struct	fbdevice sc_fb;		/* frame buffer device */
+	struct	rom_reg sc_physadr[TCX_NREG];	/* phys addr of h/w */
+	int	sc_bustype;		/* type of bus we live on */
+	volatile struct bt_regs *sc_bt;		/* Brooktree registers */
+	volatile struct tcx_thc *sc_thc;	/* THC registers */
+	short	sc_blanked;		/* true if blanked */
+	union	bt_cmap sc_cmap;	/* Brooktree color map */
+};
+
+/* autoconfiguration driver */
+static void	tcxattach __P((struct device *, struct device *, void *));
+static int	tcxmatch __P((struct device *, void *, void *));
+static void	tcx_unblank __P((struct device *));
+
+/* cdevsw prototypes */
+cdev_decl(tcx);
+
+struct cfattach tcx_ca = {
+	sizeof(struct tcx_softc), tcxmatch, tcxattach
+};
+
+struct cfdriver tcx_cd = {
+	NULL, "tcx", DV_DULL
+};
+
+/* frame buffer generic driver */
+static struct fbdriver tcx_fbdriver = {
+	tcx_unblank, tcxopen, tcxclose, tcxioctl, tcxmmap
+};
+
+extern int fbnode;
+
+static void tcx_reset __P((struct tcx_softc *));
+static void tcx_loadcmap __P((struct tcx_softc *, int, int));
+
+#define OBPNAME	"SUNW,tcx"
+/*
+ * Match a tcx.
+ */
+int
+tcxmatch(parent, vcf, aux)
+	struct device *parent;
+	void *vcf, *aux;
+{
+	struct cfdata *cf = vcf;
+	struct confargs *ca = aux;
+	struct romaux *ra = &ca->ca_ra;
+
+	if (strcmp(ra->ra_name, OBPNAME))
+		return (0);
+
+	/*
+	 * Mask out invalid flags from the user.
+	 */
+	cf->cf_flags &= FB_USERMASK;
+
+	if (ca->ca_bustype == BUS_SBUS)
+		return (1);
+
+	return (0);
+}
+
+/*
+ * Attach a display.
+ */
+void
+tcxattach(parent, self, args)
+	struct device *parent, *self;
+	void *args;
+{
+	register struct tcx_softc *sc = (struct tcx_softc *)self;
+	register struct confargs *ca = args;
+	register int node = 0, ramsize, i;
+	register volatile struct bt_regs *bt;
+	struct fbdevice *fb = &sc->sc_fb;
+	int isconsole = 0, sbus = 1;
+	extern struct tty *fbconstty;
+
+	fb->fb_driver = &tcx_fbdriver;
+	fb->fb_device = &sc->sc_dev;
+	fb->fb_flags = sc->sc_dev.dv_cfdata->cf_flags;
+
+	/*
+	 * XXX - should be set to FBTYPE_TCX.
+	 * XXX For CG3 emulation to work in current (96/6) X11 servers,
+	 * XXX `fbtype' must point to an "unregocnised" entry.
+	 */
+	fb->fb_type.fb_type = FBTYPE_RESERVED3;
+
+	if (ca->ca_ra.ra_nreg != TCX_NREG)
+		panic("tcx: oops");
+
+	/* Copy register address spaces */
+	for (i = 0; i < TCX_NREG; i++)
+		sc->sc_physadr[i] = ca->ca_ra.ra_reg[i];
+
+	/* XXX - fix THC and TEC offsets */
+	sc->sc_physadr[TCX_REG_TEC].rr_paddr += 0x1000;
+	sc->sc_physadr[TCX_REG_THC].rr_paddr += 0x1000;
+
+	sc->sc_bt = bt = (volatile struct bt_regs *)
+		mapiodev(&ca->ca_ra.ra_reg[TCX_REG_CMAP], 0, sizeof *sc->sc_bt);
+	sc->sc_thc = (volatile struct tcx_thc *)
+		mapiodev(&ca->ca_ra.ra_reg[TCX_REG_THC], 0, sizeof *sc->sc_thc);
+
+	switch (ca->ca_bustype) {
+	case BUS_SBUS:
+		node = ca->ca_ra.ra_node;
+		break;
+
+	case BUS_OBIO:
+	default:
+		printf("TCX on bus 0x%x?\n", ca->ca_bustype);
+		return;
+	}
+
+	fb->fb_type.fb_depth = node_has_property(node, "tcx-24-bit")
+		? 24
+		: (node_has_property(node, "tcx-8-bit")
+			? 8
+			: 8);
+
+	fb_setsize(fb, fb->fb_type.fb_depth, 1152, 900,
+		   node, ca->ca_bustype);
+
+	ramsize = fb->fb_type.fb_height * fb->fb_linebytes;
+	fb->fb_type.fb_cmsize = 256;
+	fb->fb_type.fb_size = ramsize;
+	printf(": %s, %d x %d", OBPNAME,
+		fb->fb_type.fb_width,
+		fb->fb_type.fb_height);
+
+	isconsole = node == fbnode && fbconstty != NULL;
+
+	printf(", id %d, rev %d, sense %d",
+		(sc->sc_thc->thc_config & THC_CFG_FBID) >> THC_CFG_FBID_SHIFT,
+		(sc->sc_thc->thc_config & THC_CFG_REV) >> THC_CFG_REV_SHIFT,
+		(sc->sc_thc->thc_config & THC_CFG_SENSE) >> THC_CFG_SENSE_SHIFT
+	);
+
+	/* reset cursor & frame buffer controls */
+	tcx_reset(sc);
+
+	/* grab initial (current) color map (DOES THIS WORK?) */
+	bt->bt_addr = 0;
+	for (i = 0; i < 256 * 3; i++)
+		((char *)&sc->sc_cmap)[i] = bt->bt_cmap >> 24;
+
+	/* enable video */
+	sc->sc_thc->thc_hcmisc |= THC_MISC_VIDEN;
+
+	if (isconsole) {
+		printf(" (console)\n");
+	} else
+		printf("\n");
+
+	if (sbus)
+		sbus_establish(&sc->sc_sd, &sc->sc_dev);
+	if (node == fbnode)
+		fb_attach(&sc->sc_fb, isconsole);
+}
+
+int
+tcxopen(dev, flags, mode, p)
+	dev_t dev;
+	int flags, mode;
+	struct proc *p;
+{
+	int unit = minor(dev);
+
+	if (unit >= tcx_cd.cd_ndevs || tcx_cd.cd_devs[unit] == NULL)
+		return (ENXIO);
+	return (0);
+}
+
+int
+tcxclose(dev, flags, mode, p)
+	dev_t dev;
+	int flags, mode;
+	struct proc *p;
+{
+	struct tcx_softc *sc = tcx_cd.cd_devs[minor(dev)];
+
+	tcx_reset(sc);
+	return (0);
+}
+
+int
+tcxioctl(dev, cmd, data, flags, p)
+	dev_t dev;
+	u_long cmd;
+	register caddr_t data;
+	int flags;
+	struct proc *p;
+{
+	register struct tcx_softc *sc = tcx_cd.cd_devs[minor(dev)];
+	int error;
+
+	switch (cmd) {
+
+	case FBIOGTYPE:
+		*(struct fbtype *)data = sc->sc_fb.fb_type;
+		break;
+
+	case FBIOGATTR:
+#define fba ((struct fbgattr *)data)
+		fba->real_type = sc->sc_fb.fb_type.fb_type;
+		fba->owner = 0;		/* XXX ??? */
+		fba->fbtype = sc->sc_fb.fb_type;
+		fba->sattr.flags = 0;
+		fba->sattr.emu_type = sc->sc_fb.fb_type.fb_type;
+		fba->sattr.dev_specific[0] = -1;
+		fba->emu_types[0] = sc->sc_fb.fb_type.fb_type;
+		fba->emu_types[1] = FBTYPE_SUN3COLOR;
+		fba->emu_types[2] = -1;
+#undef fba
+		break;
+
+	case FBIOGETCMAP:
+		return (bt_getcmap((struct fbcmap *)data, &sc->sc_cmap, 256));
+
+	case FBIOPUTCMAP:
+		/* copy to software map */
+#define	p ((struct fbcmap *)data)
+		error = bt_putcmap(p, &sc->sc_cmap, 256);
+		if (error)
+			return (error);
+		/* now blast them into the chip */
+		/* XXX should use retrace interrupt */
+		tcx_loadcmap(sc, p->index, p->count);
+#undef p
+		break;
+
+	case FBIOGVIDEO:
+		*(int *)data = sc->sc_blanked;
+		break;
+
+	case FBIOSVIDEO:
+		if (*(int *)data)
+			tcx_unblank(&sc->sc_dev);
+		else if (!sc->sc_blanked) {
+			sc->sc_blanked = 1;
+			sc->sc_thc->thc_hcmisc &= ~THC_MISC_VIDEN;
+			/* Put monitor in `power-saving mode' */
+			sc->sc_thc->thc_hcmisc |= THC_MISC_VSYNC_DISABLE;
+			sc->sc_thc->thc_hcmisc |= THC_MISC_HSYNC_DISABLE;
+		}
+		break;
+
+	default:
+#ifdef DEBUG
+		log(LOG_NOTICE, "tcxioctl(0x%lx) (%s[%d])\n", cmd,
+		    p->p_comm, p->p_pid);
+#endif
+		return (ENOTTY);
+	}
+	return (0);
+}
+
+/*
+ * Clean up hardware state (e.g., after bootup or after X crashes).
+ */
+static void
+tcx_reset(sc)
+	register struct tcx_softc *sc;
+{
+	register volatile struct bt_regs *bt;
+
+	/* Enable cursor in Brooktree DAC. */
+	bt = sc->sc_bt;
+	bt->bt_addr = 0x06 << 24;
+	bt->bt_ctrl |= 0x03 << 24;
+}
+
+/*
+ * Load a subset of the current (new) colormap into the color DAC.
+ */
+static void
+tcx_loadcmap(sc, start, ncolors)
+	register struct tcx_softc *sc;
+	register int start, ncolors;
+{
+	register volatile struct bt_regs *bt;
+	register u_int *ip, i;
+	register int count;
+
+	ip = &sc->sc_cmap.cm_chip[BT_D4M3(start)];	/* start/4 * 3 */
+	count = BT_D4M3(start + ncolors - 1) - BT_D4M3(start) + 3;
+	bt = sc->sc_bt;
+	bt->bt_addr = BT_D4M4(start) << 24;
+	while (--count >= 0) {
+		i = *ip++;
+		/* hardware that makes one want to pound boards with hammers */
+		bt->bt_cmap = i;
+		bt->bt_cmap = i << 8;
+		bt->bt_cmap = i << 16;
+		bt->bt_cmap = i << 24;
+	}
+}
+
+static void
+tcx_unblank(dev)
+	struct device *dev;
+{
+	struct tcx_softc *sc = (struct tcx_softc *)dev;
+
+	if (sc->sc_blanked) {
+		sc->sc_blanked = 0;
+		sc->sc_thc->thc_hcmisc &= ~THC_MISC_VSYNC_DISABLE;
+		sc->sc_thc->thc_hcmisc &= ~THC_MISC_HSYNC_DISABLE;
+		sc->sc_thc->thc_hcmisc |= THC_MISC_VIDEN;
+	}
+}
+
+/*
+ * Base addresses at which users can mmap() the various pieces of a tcx.
+ */
+#define	TCX_USER_RAM	0x00000000
+#define	TCX_USER_RAM24	0x01000000
+#define	TCX_USER_RAM_COMPAT	0x04000000	/* cg3 emulation */
+#define	TCX_USER_STIP	0x10000000
+#define	TCX_USER_BLIT	0x20000000
+#define	TCX_USER_RDFB32	0x28000000
+#define	TCX_USER_RSTIP	0x30000000
+#define	TCX_USER_RBLIT	0x38000000
+#define	TCX_USER_TEC	0x70001000
+#define	TCX_USER_BTREGS	0x70002000
+#define	TCX_USER_THC	0x70004000
+#define	TCX_USER_DHC	0x70008000
+#define	TCX_USER_ALT	0x7000a000
+#define	TCX_USER_UART	0x7000c000
+#define	TCX_USER_VRT	0x7000e000
+#define	TCX_USER_ROM	0x70010000
+
+struct mmo {
+	u_int	mo_uaddr;	/* user (virtual) address */
+	u_int	mo_size;	/* size, or 0 for video ram size */
+	u_int	mo_bank;	/* register bank number */
+};
+
+/*
+ * Return the address that would map the given device at the given
+ * offset, allowing for the given protection, or return -1 for error.
+ *
+ * XXX	needs testing against `demanding' applications (e.g., aviator)
+ */
+int
+tcxmmap(dev, off, prot)
+	dev_t dev;
+	int off, prot;
+{
+	register struct tcx_softc *sc = tcx_cd.cd_devs[minor(dev)];
+	register struct mmo *mo;
+	register u_int u, sz;
+	static struct mmo mmo[] = {
+		{ TCX_USER_RAM, 0, TCX_REG_DFB8 },
+		{ TCX_USER_RAM24, 0, TCX_REG_DFB24 },
+		{ TCX_USER_RAM_COMPAT, 0, TCX_REG_DFB8 },
+
+		{ TCX_USER_STIP, 1, TCX_REG_STIP },
+		{ TCX_USER_BLIT, 1, TCX_REG_BLIT },
+		{ TCX_USER_RDFB32, 1, TCX_REG_RDFB32 },
+		{ TCX_USER_RSTIP, 1, TCX_REG_RSTIP },
+		{ TCX_USER_RBLIT, 1, TCX_REG_RBLIT },
+		{ TCX_USER_TEC, 1, TCX_REG_TEC },
+		{ TCX_USER_BTREGS, 8192 /* XXX */, TCX_REG_CMAP },
+		{ TCX_USER_THC, sizeof(struct tcx_thc), TCX_REG_THC },
+		{ TCX_USER_DHC, 1, TCX_REG_DHC },
+		{ TCX_USER_ALT, 1, TCX_REG_ALT },
+		{ TCX_USER_ROM, 65536, TCX_REG_ROM },
+	};
+#define NMMO (sizeof mmo / sizeof *mmo)
+
+	if (off & PGOFSET)
+		panic("tcxmmap");
+
+	/*
+	 * Entries with size 0 map video RAM (i.e., the size in fb data).
+	 *
+	 * Since we work in pages, the fact that the map offset table's
+	 * sizes are sometimes bizarre (e.g., 1) is effectively ignored:
+	 * one byte is as good as one page.
+	 */
+	for (mo = mmo; mo < &mmo[NMMO]; mo++) {
+		if ((u_int)off < mo->mo_uaddr)
+			continue;
+		u = off - mo->mo_uaddr;
+		sz = mo->mo_size ? mo->mo_size : sc->sc_fb.fb_type.fb_size;
+		if (u < sz)
+			return (REG2PHYS(&sc->sc_physadr[mo->mo_bank], u) |
+				PMAP_NC);
+	}
+#ifdef DEBUG
+	{
+	  register struct proc *p = curproc;	/* XXX */
+	  log(LOG_NOTICE, "tcxmmap(0x%x) (%s[%d])\n", off, p->p_comm, p->p_pid);
+	}
+#endif
+	return (-1);	/* not a user-map offset */
+}
diff --git a/sys/arch/sparc/dev/tcxreg.h b/sys/arch/sparc/dev/tcxreg.h
new file mode 100644
index 00000000000..ef48a21955c
--- /dev/null
+++ b/sys/arch/sparc/dev/tcxreg.h
@@ -0,0 +1,151 @@
+/*	$OpenBSD: tcxreg.h,v 1.1 1997/08/08 08:25:32 downsj Exp $	*/
+/*	$NetBSD: tcxreg.h,v 1.1 1996/06/19 13:17:35 pk Exp $ */
+/* 
+ *  Copyright (c) 1996 The NetBSD Foundation, Inc.
+ *  All rights reserved.
+ * 
+ *  This code is derived from software contributed to The NetBSD Foundation
+ *  by Paul Kranenburg.
+ * 
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. All advertising materials mentioning features or use of this software
+ *     must display the following acknowledgement:
+ *         This product includes software developed by the NetBSD
+ *         Foundation, Inc. and its contributors.
+ *  4. Neither the name of The NetBSD Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ * 
+ *  THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ *  ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ *  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ *  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE
+ *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ */ 
+
+/*
+ * A TCX is composed of numerous groups of control registers, all with TLAs:
+ *	DHC - ???
+ *	TEC - transform engine control?
+ *	THC - TEC Hardware Configuration
+ *	ROM - a 128Kbyte ROM with who knows what in it.
+ *	STIP - ???
+ *	RSTIP - Raw ???
+ *	BLIT - ???
+ *	RBLIT - Raw ???
+ *	ALT - ???
+ *	colormap - see below
+ *	frame buffer memory (video RAM)
+ *	possible other stuff
+ *
+ */
+#define TCX_REG_DFB8	0
+#define TCX_REG_DFB24	1
+#define TCX_REG_STIP	2
+#define TCX_REG_BLIT	3
+#define TCX_REG_RDFB32	4
+#define TCX_REG_RSTIP	5
+#define TCX_REG_RBLIT	6
+#define TCX_REG_TEC	7
+#define TCX_REG_CMAP	8
+#define TCX_REG_THC	9
+#define TCX_REG_ROM	10
+#define TCX_REG_DHC	11
+#define TCX_REG_ALT	12
+
+#define TCX_NREG	13
+
+
+/*
+ * The layout of the THC.
+ */
+struct tcx_thc {
+	u_int	thc_config;
+	u_int	thc_xxx1[31];
+	u_int	thc_sensebus;
+	u_int	thc_xxx2[3];
+	u_int	thc_delay;
+	u_int	thc_strapping;
+	u_int	thc_xxx3[1];
+	u_int	thc_linecount;
+	u_int	thc_xxx4[478];
+	u_int	thc_hcmisc;
+	u_int	thc_xxx5[56];
+	u_int	thc_cursoraddr;
+	u_int	thc_cursorAdata[32];
+	u_int	thc_cursorBdata[32];
+
+};
+/* bits in thc_config ??? */
+#define THC_CFG_FBID		0xf0000000	/* id mask */
+#define THC_CFG_FBID_SHIFT	28
+#define THC_CFG_SENSE		0x07000000	/* sense mask */
+#define THC_CFG_SENSE_SHIFT	24
+#define THC_CFG_REV		0x00f00000	/* revision mask */
+#define THC_CFG_REV_SHIFT	20
+#define THC_CFG_RST		0x00008000	/* reset */
+
+/* bits in thc_hcmisc */
+#define	THC_MISC_OPENFLG	0x80000000	/* open flag (what's that?) */
+#define	THC_MISC_SWERR_EN	0x20000000	/* enable SW error interrupt */
+#define	THC_MISC_VSYNC_LEVEL	0x08000000	/* vsync level when disabled */
+#define	THC_MISC_HSYNC_LEVEL	0x04000000	/* hsync level when disabled */
+#define	THC_MISC_VSYNC_DISABLE	0x02000000	/* vsync disable */
+#define	THC_MISC_HSYNC_DISABLE	0x01000000	/* hsync disable */
+#define	THC_MISC_XXX1		0x00ffe000	/* unused */
+#define	THC_MISC_RESET		0x00001000	/* ??? */
+#define	THC_MISC_XXX2		0x00000800	/* unused */
+#define	THC_MISC_VIDEN		0x00000400	/* video enable */
+#define	THC_MISC_SYNC		0x00000200	/* not sure what ... */
+#define	THC_MISC_VSYNC		0x00000100	/* ... these really are */
+#define	THC_MISC_SYNCEN		0x00000080	/* sync enable */
+#define	THC_MISC_CURSRES	0x00000040	/* cursor resolution */
+#define	THC_MISC_INTEN		0x00000020	/* v.retrace intr enable */
+#define	THC_MISC_INTR		0x00000010	/* intr pending / ack bit */
+#define	THC_MISC_DACWAIT	0x0000000f	/* ??? */
+
+/*
+ * Partial description of TEC.
+ */
+struct tcx_tec {
+	u_int	tec_config;	/* what's in it? */
+	u_int	tec_xxx0[35];
+	u_int	tec_delay;	/* */
+#define TEC_DELAY_SYNC		0x00000f00
+#define TEC_DELAY_WR_F		0x000000c0
+#define TEC_DELAY_WR_R		0x00000030
+#define TEC_DELAY_SOE_F		0x0000000c
+#define TEC_DELAY_SOE_S		0x00000003
+	u_int	tec_strapping;	/* */
+#define TEC_STRAP_FIFO_LIMIT	0x00f00000
+#define TEC_STRAP_CACHE_EN	0x00010000
+#define TEC_STRAP_ZERO_OFFSET	0x00008000
+#define TEC_STRAP_REFRSH_DIS	0x00004000
+#define TEC_STRAP_REF_LOAD	0x00001000
+#define TEC_STRAP_REFRSH_PERIOD	0x000003ff
+	u_int	tec_hcmisc;	/* */
+	u_int	tec_linecount;	/* */
+	u_int	tec_hss;	/* */
+	u_int	tec_hse;	/* */
+	u_int	tec_hds;	/* */
+	u_int	tec_hsedvs;	/* */
+	u_int	tec_hde;	/* */
+	u_int	tec_vss;	/* */
+	u_int	tec_vse;	/* */
+	u_int	tec_vds;	/* */
+	u_int	tec_vde;	/* */
+};
+
diff --git a/sys/arch/sparc/dev/vmereg.h b/sys/arch/sparc/dev/vmereg.h
new file mode 100644
index 00000000000..5e7eb708ea4
--- /dev/null
+++ b/sys/arch/sparc/dev/vmereg.h
@@ -0,0 +1,75 @@
+/*	$OpenBSD: vmereg.h,v 1.1 1997/08/08 08:25:32 downsj Exp $	*/
+/*	$NetBSD: vmereg.h,v 1.2 1997/06/07 19:10:57 pk Exp $ */
+
+/*
+ * Copyright (c) 1997 	Paul Kranenburg
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Paul Kranenburg.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ */
+
+struct vmebusreg {
+	u_int32_t	vmebus_cr;	/* VMEbus control register */
+	u_int32_t	vmebus_afar;	/* VMEbus async fault address */
+	u_int32_t	vmebus_afsr;	/* VMEbus async fault status */
+};
+
+/* Control Register bits */
+#define VMEBUS_CR_C	0x80000000	/* I/O cache enable */
+#define VMEBUS_CR_S	0x40000000	/* VME slave enable */
+#define VMEBUS_CR_L	0x20000000	/* Loopback enable (diagnostic) */
+#define VMEBUS_CR_R	0x10000000	/* VMEbus reset */
+#define VMEBUS_CR_RSVD	0x0ffffff0	/* reserved */
+#define VMEBUS_CR_IMPL	0x0000000f	/* VMEbus interface implementation */
+
+/* Asynchronous Fault Status bits */
+#define VMEBUS_AFSR_SZ	0xe0000000	/* Error transaction size */
+#define    VMEBUS_AFSR_SZ4	0	/* 4 byte */
+#define    VMEBUS_AFSR_SZ1	1	/* 1 byte */
+#define    VMEBUS_AFSR_SZ2	2	/* 2 byte */
+#define    VMEBUS_AFSR_SZ32	5	/* 32 byte */
+#define VMEBUS_AFSR_TO	0x10000000	/* VME master access time-out */
+#define VMEBUS_AFSR_BERR 0x08000000	/* VME master got BERR */
+#define VMEBUS_AFSR_WB	0x04000000	/* IOC write-back error (if SZ == 32) */
+					/* Non-IOC write error (id SZ != 32) */
+#define VMEBUS_AFSR_ERR	0x02000000	/* Error summary bit */
+#define VMEBUS_AFSR_S	0x01000000	/* MVME error in supervisor space */
+#define VMEBUS_AFSR_ME	0x00800000	/* Multiple error */
+#define VMEBUS_AFSR_RSVD 0x007fffff	/* reserved */
+
+struct vmebusvec {
+	volatile u_int8_t	vmebusvec[16];
+};
+
+/* VME address modifiers */
+#define VMEMOD_A16_D_S	0x2d		/* 16-bit address, data, supervisor */
+#define VMEMOD_A24_D_S	0x3d		/* 24-bit address, data, supervisor */
+#define VMEMOD_A32_D_S	0x0d		/* 32-bit address, data, supervisor */
+
+#define VMEMOD_D32	0x40		/* 32-bit access */
+
diff --git a/sys/arch/sparc/dev/xd.c b/sys/arch/sparc/dev/xd.c
index 70caf5e3e48..5bf36fe6db2 100644
--- a/sys/arch/sparc/dev/xd.c
+++ b/sys/arch/sparc/dev/xd.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: xd.c,v 1.25 1996/04/22 02:42:06 christos Exp $	*/
+/*	$OpenBSD: xd.c,v 1.10 1997/08/08 08:25:35 downsj Exp $	*/
+/*	$NetBSD: xd.c,v 1.37 1997/07/29 09:58:16 fair Exp $	*/
 
 /*
  *
@@ -36,7 +37,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: $NetBSD: xd.c,v 1.25 1996/04/22 02:42:06 christos Exp $
+ * id: $NetBSD: xd.c,v 1.37 1997/07/29 09:58:16 fair Exp $
  * started: 27-Feb-95
  * references: [1] Xylogics Model 753 User's Manual
  *                 part number: 166-753-001, Revision B, May 21, 1988.
@@ -85,6 +86,7 @@
 #include <sparc/dev/xdvar.h>
 #include <sparc/dev/xio.h>
 #include <sparc/sparc/vaddrs.h>
+#include <sparc/sparc/cpuvar.h>
 
 /*
  * macros
@@ -346,11 +348,11 @@ xdgetdisklabel(xd, b)
  * soft reset to detect the xdc.
  */
 
-int xdcmatch(parent, match, aux)
+int xdcmatch(parent, vcf, aux)
 	struct device *parent;
-	void   *match, *aux;
+	void *vcf, *aux;
 {
-	struct cfdata *cf = match;
+	struct cfdata *cf = vcf;
 	struct confargs *ca = aux;
 	struct romaux *ra = &ca->ca_ra;
 	struct xdc *xdc;
@@ -359,7 +361,13 @@ int xdcmatch(parent, match, aux)
 	if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
 		return (0);
 
-	if (CPU_ISSUN4) {
+	switch (ca->ca_bustype) {
+	case BUS_OBIO:
+	case BUS_SBUS:
+	case BUS_VME16:
+	default:
+		return (0);
+	case BUS_VME32:
 		xdc = (struct xdc *) ra->ra_vaddr;
 		if (probeget((caddr_t) &xdc->xdc_csr, 1) == -1)
 			return (0);
@@ -367,8 +375,8 @@ int xdcmatch(parent, match, aux)
 		XDC_WAIT(xdc, del, XDC_RESETUSEC, XDC_RESET);
 		if (del <= 0)
 			return (0);
+		return (1);
 	}
-	return (1);
 }
 
 /*
@@ -389,8 +397,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_reg, 0,
-	    sizeof(struct xdc), ca->ca_bustype);
+	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct xdc));
 
 	xdc->xdc = (struct xdc *) ca->ca_ra.ra_vaddr;
 	pri = ca->ca_ra.ra_intr[0].int_pri;
@@ -463,7 +470,7 @@ xdcattach(parent, self, aux)
 		XDC_DONE(xdc, rqno, err);
 		return;
 	}
-	printf(": Xylogics 753/7053, PROM=%x.%02x.%02x\n",
+	printf(": Xylogics 753/7053, PROM=0x%x.%02x.%02x\n",
 	    ctl->eprom_partno, ctl->eprom_lvl, ctl->eprom_rev);
 	XDC_DONE(xdc, rqno, err);
 
@@ -514,12 +521,11 @@ xdcattach(parent, self, aux)
  * call xdattach!).
  */
 int
-xdmatch(parent, match, aux)
+xdmatch(parent, vcf, aux)
 	struct device *parent;
-	void   *match, *aux;
-
+	void *vcf, *aux;
 {
-	struct cfdata *cf = match;
+	struct cfdata *cf = vcf;
 	struct xdc_attach_args *xa = aux;
 
 	/* looking for autoconf wildcard or exact match */
@@ -987,24 +993,28 @@ xdsize(dev)
 
 {
 	struct xd_softc *xdsc;
-	int     part, size;
+	int     unit, part, size, omask;
 
-	/* valid unit?  try an open */
+	/* valid unit? */
+	unit = DISKUNIT(dev);
+	if (unit >= xd_cd.cd_ndevs || (xdsc = xd_cd.cd_devs[unit]) == NULL)
+		return (-1);
 
-	if (xdopen(dev, 0, S_IFBLK, NULL) != 0)
+	part = DISKPART(dev);
+	omask = xdsc->sc_dk.dk_openmask & (1 << part);
+
+	if (omask == 0 && xdopen(dev, 0, S_IFBLK, NULL) != 0)
 		return (-1);
 
 	/* do it */
-
-	xdsc = xd_cd.cd_devs[DISKUNIT(dev)];
-	part = DISKPART(dev);
 	if (xdsc->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
 		size = -1;	/* only give valid size for swap partitions */
 	else
-		size = xdsc->sc_dk.dk_label->d_partitions[part].p_size;
-	if (xdclose(dev, 0, S_IFBLK, NULL) != 0)
-		return -1;
-	return size;
+		size = xdsc->sc_dk.dk_label->d_partitions[part].p_size *
+		    (xdsc->sc_dk.dk_label->d_secsize / DEV_BSIZE);
+	if (omask == 0 && xdclose(dev, 0, S_IFBLK, NULL) != 0)
+		return (-1);
+	return (size);
 }
 /*
  * xdstrategy: buffering system interface to xd.
@@ -1221,7 +1231,7 @@ xdc_rqtopb(iorq, iopb, cmd, subfun)
 					XDPC_RBC | XDPC_ECC2;
 			ctrl->throttle = XDC_THROTTLE;
 #ifdef sparc
-			if (CPU_ISSUN4 && cpumod == SUN4_300)
+			if (CPU_ISSUN4 && cpuinfo.cpu_type == CPUTYP_4_300)
 				ctrl->delay = XDC_DELAY_4_300;
 			else
 				ctrl->delay = XDC_DELAY_SPARC;
diff --git a/sys/arch/sparc/dev/xdreg.h b/sys/arch/sparc/dev/xdreg.h
index c723d018d0d..c2e19564ced 100644
--- a/sys/arch/sparc/dev/xdreg.h
+++ b/sys/arch/sparc/dev/xdreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: xdreg.h,v 1.3 1997/08/08 08:25:36 downsj Exp $	*/
 /*	$NetBSD: xdreg.h,v 1.3 1996/03/31 22:38:54 pk Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/xdvar.h b/sys/arch/sparc/dev/xdvar.h
index 294f3a8c84b..c3e35672ba4 100644
--- a/sys/arch/sparc/dev/xdvar.h
+++ b/sys/arch/sparc/dev/xdvar.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: xdvar.h,v 1.4 1997/08/08 08:25:37 downsj Exp $	*/
 /*	$NetBSD: xdvar.h,v 1.5 1996/03/31 22:38:56 pk Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/xio.h b/sys/arch/sparc/dev/xio.h
index 1ad5662b6be..c55c733712e 100644
--- a/sys/arch/sparc/dev/xio.h
+++ b/sys/arch/sparc/dev/xio.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: xio.h,v 1.3 1997/08/08 08:25:37 downsj Exp $	*/
 /* $NetBSD: xio.h,v 1.2 1996/03/31 22:38:58 pk Exp $ */
 
 /*
diff --git a/sys/arch/sparc/dev/xy.c b/sys/arch/sparc/dev/xy.c
index 2841bd9ba84..2dc3413f2fe 100644
--- a/sys/arch/sparc/dev/xy.c
+++ b/sys/arch/sparc/dev/xy.c
@@ -1,4 +1,5 @@
-/*	$NetBSD: xy.c,v 1.17 1996/04/22 02:42:04 christos Exp $	*/
+/*	$OpenBSD: xy.c,v 1.9 1997/08/08 08:25:39 downsj Exp $	*/
+/*	$NetBSD: xy.c,v 1.26 1997/07/19 21:43:56 pk Exp $	*/
 
 /*
  *
@@ -36,7 +37,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: $NetBSD: xy.c,v 1.17 1996/04/22 02:42:04 christos Exp $
+ * id: $NetBSD: xy.c,v 1.26 1997/07/19 21:43:56 pk Exp $
  * started: 14-Sep-95
  * references: [1] Xylogics Model 753 User's Manual
  *                 part number: 166-753-001, Revision B, May 21, 1988.
@@ -287,11 +288,11 @@ xygetdisklabel(xy, b)
  * soft reset to detect the xyc.
  */
 
-int xycmatch(parent, match, aux)
+int xycmatch(parent, vcf, aux)
 	struct device *parent;
-	void   *match, *aux;
+	void *vcf, *aux;
 {
-	struct cfdata *cf = match;
+	struct cfdata *cf = vcf;
 	struct confargs *ca = aux;
 	struct romaux *ra = &ca->ca_ra;
 	struct xyc *xyc;
@@ -299,14 +300,20 @@ int xycmatch(parent, match, aux)
 	if (strcmp(cf->cf_driver->cd_name, ra->ra_name))
 		return (0);
 
-	if (CPU_ISSUN4) {
+	switch (ca->ca_bustype) {
+	case BUS_OBIO:
+	case BUS_SBUS:
+	case BUS_VME32:
+	default:
+		return (0);
+	case BUS_VME16:
 		xyc = (struct xyc *) ra->ra_vaddr;
 		if (probeget((caddr_t) &xyc->xyc_rsetup, 1) == -1)
 			return (0);
 		if (xyc_unbusy(xyc, XYC_RESETUSEC) == XY_ERR_FAIL)
 			return(0);
+		return (1);
 	}
-	return (1);
 }
 
 /*
@@ -329,8 +336,7 @@ xycattach(parent, self, aux)
 	/* 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_reg, 0,
-	    sizeof(struct xyc), ca->ca_bustype);
+	ca->ca_ra.ra_vaddr = mapiodev(ca->ca_ra.ra_reg, 0, sizeof(struct xyc));
 
 	xyc->xyc = (struct xyc *) ca->ca_ra.ra_vaddr;
 	pri = ca->ca_ra.ra_intr[0].int_pri;
@@ -458,12 +464,11 @@ xycattach(parent, self, aux)
  * call xyattach!).
  */
 int
-xymatch(parent, match, aux)
+xymatch(parent, vcf, aux)
 	struct device *parent;
-	void   *match, *aux;
-
+	void *vcf, *aux;
 {
-	struct cfdata *cf = match;
+	struct cfdata *cf = vcf;
 	struct xyc_attach_args *xa = aux;
 
 	/* looking for autoconf wildcard or exact match */
@@ -951,24 +956,28 @@ xysize(dev)
 
 {
 	struct xy_softc *xysc;
-	int     part, size;
+	int     unit, part, size, omask;
 
-	/* valid unit?  try an open */
+	/* valid unit? */
+	unit = DISKUNIT(dev);
+	if (unit >= xy_cd.cd_ndevs || (xysc = xy_cd.cd_devs[unit]) == NULL)
+		return (-1);
 
-	if (xyopen(dev, 0, S_IFBLK, NULL) != 0)
+	part = DISKPART(dev);
+	omask = xysc->sc_dk.dk_openmask & (1 << part);
+
+	if (omask == 0 && xyopen(dev, 0, S_IFBLK, NULL) != 0)
 		return (-1);
 
 	/* do it */
-
-	xysc = xy_cd.cd_devs[DISKUNIT(dev)];
-	part = DISKPART(dev);
 	if (xysc->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
 		size = -1;	/* only give valid size for swap partitions */
 	else
-		size = xysc->sc_dk.dk_label->d_partitions[part].p_size;
-	if (xyclose(dev, 0, S_IFBLK, NULL) != 0)
-		return -1;
-	return size;
+		size = xysc->sc_dk.dk_label->d_partitions[part].p_size *
+		    (xysc->sc_dk.dk_label->d_secsize / DEV_BSIZE);
+	if (omask == 0 && xyclose(dev, 0, S_IFBLK, NULL) != 0)
+		return (-1);
+	return (size);
 }
 
 /*
diff --git a/sys/arch/sparc/dev/xyreg.h b/sys/arch/sparc/dev/xyreg.h
index 2508bb97a8e..2d8c2704685 100644
--- a/sys/arch/sparc/dev/xyreg.h
+++ b/sys/arch/sparc/dev/xyreg.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: xyreg.h,v 1.3 1997/08/08 08:25:40 downsj Exp $	*/
 /*	$NetBSD: xyreg.h,v 1.3 1996/03/31 22:39:02 pk Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/xyvar.h b/sys/arch/sparc/dev/xyvar.h
index e7ec8305980..f6f80cee49d 100644
--- a/sys/arch/sparc/dev/xyvar.h
+++ b/sys/arch/sparc/dev/xyvar.h
@@ -1,3 +1,4 @@
+/*	$OpenBSD: xyvar.h,v 1.4 1997/08/08 08:25:41 downsj Exp $	*/
 /*	$NetBSD: xyvar.h,v 1.4 1996/03/31 22:39:04 pk Exp $	*/
 
 /*
diff --git a/sys/arch/sparc/dev/zs.c b/sys/arch/sparc/dev/zs.c
index c44f4aefe72..b9cb8b8eb56 100644
--- a/sys/arch/sparc/dev/zs.c
+++ b/sys/arch/sparc/dev/zs.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: zs.c,v 1.14 1997/06/25 13:01:00 downsj Exp $	*/
-/*	$NetBSD: zs.c,v 1.37.4.1 1996/06/02 09:07:55 mrg Exp $ */
+/*	$OpenBSD: zs.c,v 1.15 1997/08/08 08:25:43 downsj Exp $	*/
+/*	$NetBSD: zs.c,v 1.48 1997/07/29 09:58:18 fair Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -72,21 +72,18 @@
 #include <machine/autoconf.h>
 #include <machine/conf.h>
 #include <machine/cpu.h>
+#include <machine/kbd.h>
 
 #include <sparc/sparc/vaddrs.h>
 #include <sparc/sparc/auxreg.h>
-
-
-#include <machine/kbd.h>
 #include <dev/ic/z8530reg.h>
-
 #include <sparc/dev/zsvar.h>
 
 #ifdef KGDB
 #include <machine/remote-sl.h>
 #endif
 
-#define	ZSMAJOR		12	/* XXX */
+#define	ZSMAJOR	12		/* XXX */
 
 #define	ZS_KBD		2	/* XXX */
 #define	ZS_MOUSE	3	/* XXX */
@@ -113,8 +110,8 @@
 struct zs_softc {
 	struct	device sc_dev;			/* base device */
 	volatile struct zsdevice *sc_zs;	/* chip registers */
-	struct	evcnt sc_intrcnt;
-	struct	zs_chanstate sc_cs[2];		/* channel A/B software state */
+	struct	evcnt sc_intrcnt;		/* count interrupts */
+	struct	zs_chanstate sc_cs[2];		/* chan A/B software state */
 };
 
 /* Definition of the driver for autoconfig. */
@@ -154,10 +151,11 @@ static void	zs_loadchannelregs __P((volatile struct zschan *, u_char *));
 /* Console stuff. */
 static struct tty *zs_ctty;	/* console `struct tty *' */
 static int zs_consin = -1, zs_consout = -1;
+static struct zs_chanstate *zs_conscs = NULL; /*console channel state */
 static void zscnputc __P((int));	/* console putc function */
 static volatile struct zschan *zs_conschan;
 static struct tty *zs_checkcons __P((struct zs_softc *, int,
-				     struct zs_chanstate *));
+    struct zs_chanstate *));
 
 #ifdef KGDB
 /* KGDB stuff.  Must reboot to change zs_kgdbunit. */
@@ -176,7 +174,6 @@ static int zssint __P((struct zs_chanstate *, volatile struct zschan *));
 void zsabort __P((void));
 static void zsoverrun __P((int, long *, char *));
 
-extern void *findzs __P((int));
 static volatile struct zsdevice *zsaddr[NZS];	/* XXX, but saves work */
 
 /*
@@ -272,7 +269,7 @@ zsattach(parent, dev, aux)
 
 	if ((addr = zsaddr[zs]) == NULL)
 		addr = zsaddr[zs] = (volatile struct zsdevice *)findzs(zs);
-	if (ca->ca_bustype == BUS_MAIN)
+	if (ca->ca_bustype==BUS_MAIN)
 		if ((void *)addr != ra->ra_vaddr)
 			panic("zsattach");
 	if (ra->ra_nintr != 1) {
@@ -311,11 +308,12 @@ zsattach(parent, dev, aux)
 		tp->t_dev = makedev(ZSMAJOR, unit);
 		tp->t_oproc = zsstart;
 		tp->t_param = zsparam;
+	}
+	cs->cs_ttyp = tp;
 #ifdef KGDB
+	if (ctp == NULL)
 		zs_checkkgdb(unit, cs, tp);
 #endif
-	}
-	cs->cs_ttyp = tp;
 	if (unit == ZS_KBD) {
 		/*
 		 * Keyboard: tell /dev/kbd driver how to talk to us.
@@ -329,14 +327,15 @@ zsattach(parent, dev, aux)
 		if (tp != ctp)
 			tty_attach(tp);
 		ringsize = 4096;
+		if (unit == zs_consout)
+			zs_conscs = cs;
 	}
-
 	cs->cs_ringmask = ringsize - 1;
 	cs->cs_rbuf = malloc((u_long)ringsize * sizeof(*cs->cs_rbuf),
 			      M_DEVBUF, M_NOWAIT);
+
 	unit++;
 	cs++;
-
 	cs->cs_unit = unit;
 	cs->cs_speed = zs_getspeed(&addr->zs_chan[ZS_CHAN_B]);
 	cs->cs_zc = &addr->zs_chan[ZS_CHAN_B];
@@ -347,11 +346,12 @@ zsattach(parent, dev, aux)
 		tp->t_dev = makedev(ZSMAJOR, unit);
 		tp->t_oproc = zsstart;
 		tp->t_param = zsparam;
+	}
+	cs->cs_ttyp = tp;
 #ifdef KGDB
+	if (ctp == NULL)
 		zs_checkkgdb(unit, cs, tp);
 #endif
-	}
-	cs->cs_ttyp = tp;
 	if (unit == ZS_MOUSE) {
 		/*
 		 * Mouse: tell /dev/mouse driver how to talk to us.
@@ -364,6 +364,8 @@ zsattach(parent, dev, aux)
 		if (tp != ctp)
 			tty_attach(tp);
 		ringsize = 4096;
+		if (unit == zs_consout)
+			zs_conscs = cs;
 	}
 	cs->cs_ringmask = ringsize - 1;
 	cs->cs_rbuf = malloc((u_long)ringsize * sizeof(*cs->cs_rbuf),
@@ -439,7 +441,7 @@ zsconsole(tp, unit, out, fnstop)
 		v_putc = zscnputc;
 	} else
 		zs_consin = unit;
-	if(fnstop)
+	if (fnstop)
 		*fnstop = &zsstop;
 	zs_ctty = tp;
 }
@@ -465,6 +467,24 @@ zscnputc(c)
 		(void) splzs();
 	while ((zc->zc_csr & ZSRR0_TX_READY) == 0)
 		ZS_DELAY();
+	/*
+	 * If transmitter was busy doing regular tty I/O (ZSWR1_TIE on),
+	 * defer our output until the transmit interrupt runs. We still
+	 * sync with TX_READY so we can get by with a single-char "queue".
+	 */
+	if (zs_conscs != NULL && (zs_conscs->cs_creg[1] & ZSWR1_TIE)) {
+		/*
+		 * If previous not yet done, send it now; zsxint()
+		 * will field the interrupt for our char, but doesn't
+		 * care. We're running at sufficiently high spl for
+		 * this to work.
+		 */
+		if (zs_conscs->cs_deferred_cc != 0)
+			zc->zc_data = zs_conscs->cs_deferred_cc;
+		zs_conscs->cs_deferred_cc = c;
+		splx(s);
+		return;
+	}
 	zc->zc_data = c;
 	ZS_DELAY();
 	splx(s);
@@ -483,7 +503,7 @@ zs_checkcons(sc, unit, cs)
 	register struct tty *tp;
 	char *i, *o;
 
-	if ((tp = zs_ctty) == NULL)
+	if ((tp = zs_ctty) == NULL) /* XXX */
 		return (0);
 	i = zs_consin == unit ? "input" : NULL;
 	o = zs_consout == unit ? "output" : NULL;
@@ -623,7 +643,7 @@ zsopen(dev, flags, mode, p)
 		return (EBUSY);
 	}
 	error = 0;
-	while (1) {
+	for (;;) {
 		register int rr0;
 
 		/* loop, turning on the device, until carrier present */
@@ -720,6 +740,7 @@ zsread(dev, uio, flags)
 	tp = cs->cs_ttyp;
 
 	return (linesw[tp->t_line].l_read(tp, uio, flags));
+
 }
 
 int
@@ -850,7 +871,7 @@ zshard(intrarg)
 			raise(0, PIL_TTY);
 		else
 #endif
-			ienab_bis(IE_ZSSOFT);
+		ienab_bis(IE_ZSSOFT);
 	}
 	return (intflags & ZSHARD_WAS_SERVICED);
 }
@@ -860,11 +881,9 @@ zsrint(cs, zc)
 	register struct zs_chanstate *cs;
 	register volatile struct zschan *zc;
 {
-	register u_int c;
+	register u_int c = zc->zc_data;
 
-	c = zc->zc_data;
 	ZS_DELAY();
-
 	if (cs->cs_conk) {
 		register struct conk_state *conk = &zsconk_state;
 
@@ -922,6 +941,15 @@ zsxint(cs, zc)
 {
 	register int i = cs->cs_tbc;
 
+	if (cs->cs_deferred_cc != 0) {
+		/* Handle deferred zscnputc() output first */
+		zc->zc_data = cs->cs_deferred_cc;
+		cs->cs_deferred_cc = 0;
+		ZS_DELAY();
+		zc->zc_csr = ZSWR0_CLR_INTR;
+		ZS_DELAY();
+		return (0);
+	}
 	if (i == 0) {
 		zc->zc_csr = ZSWR0_RESET_TXINT;
 		ZS_DELAY();
@@ -1145,7 +1173,7 @@ again:
 				break;
 
 			default:
-				log(LOG_ERR, "zs%d%c: bad ZRING_TYPE (%x)\n",
+				log(LOG_ERR, "zs%d%c: bad ZRING_TYPE (0x%x)\n",
 				    unit >> 1, (unit & 1) + 'a', c);
 				break;
 			}
@@ -1166,9 +1194,9 @@ zsioctl(dev, cmd, data, flag, p)
 {
 	int unit = minor(dev);
 	struct zs_softc *sc = zs_cd.cd_devs[unit >> 1];
-	register struct tty *tp = sc->sc_cs[unit & 1].cs_ttyp;
-	register int error, s;
 	register struct zs_chanstate *cs = &sc->sc_cs[unit & 1];
+	register struct tty *tp = cs->cs_ttyp;
+	register int error, s;
 
 	error = linesw[tp->t_line].l_ioctl(tp, cmd, data, flag, p);
 	if (error >= 0)
@@ -1262,14 +1290,8 @@ zsioctl(dev, cmd, data, flag, p)
 	case TIOCCDTR:
 		zs_modem(cs, 0);
 		break;
-	case TIOCMGET:
-		/* XXX: fixme */
-		*(int *)data = TIOCM_CAR | TIOCM_CTS | TIOCM_DTR | TIOCM_RTS;
-		return (0);
 	case TIOCMSET:
-		/* XXX: fixme */
-		zs_modem(cs, *(int *)data & (TIOCM_DTR|TIOCM_RTS));
-		return (0);
+	case TIOCMGET:
 	case TIOCMBIS:
 	case TIOCMBIC:
 	default:
@@ -1396,7 +1418,11 @@ zsparam(tp, t)
 		return (0);
 	}
 	tmp = BPS_TO_TCONST(PCLK / 16, tmp);
-	if (tmp < 2)
+#ifdef ALLOW_TC_EQUAL_ZERO
+	if (tmp < 0)
+#else
+	if (tmp < 1)
+#endif
 		return (EINVAL);
 
 	cflag = t->c_cflag;
diff --git a/sys/arch/sparc/dev/zsvar.h b/sys/arch/sparc/dev/zsvar.h
index 8f9274573ee..79b8c6cd2c9 100644
--- a/sys/arch/sparc/dev/zsvar.h
+++ b/sys/arch/sparc/dev/zsvar.h
@@ -1,5 +1,5 @@
-/*	$OpenBSD: zsvar.h,v 1.9 1996/08/12 03:14:50 downsj Exp $	*/
-/*	$NetBSD: zsvar.h,v 1.8 1996/03/31 22:39:08 pk Exp $ */
+/*	$OpenBSD: zsvar.h,v 1.10 1997/08/08 08:25:44 downsj Exp $	*/
+/*	$NetBSD: zsvar.h,v 1.10 1997/04/14 21:26:28 pk Exp $ */
 
 /*
  * Copyright (c) 1992, 1993
@@ -91,9 +91,12 @@ struct zsdevice {
 #define	ZRING_VALUE(x)	((x) >> 8)
 #define	ZRING_MAKE(t, v)	((t) | (v) << 8)
 
+/* forard decl */
+struct zs_softc;
+
 struct zs_chanstate {
-	struct zs_chanstate *cs_next;	/* linked list for zshard() */
-	struct zs_softc *cs_sc;		/* points to my softc */
+	struct	zs_chanstate *cs_next;	/* linked list for zshard() */
+	struct	zs_softc *cs_sc;	/* pointer to softc */
 	volatile struct zschan *cs_zc;	/* points to hardware regs */
 	int	cs_unit;		/* unit number */
 	struct	tty *cs_ttyp;		/* ### */
@@ -123,6 +126,7 @@ struct zs_chanstate {
 	char	cs_kgdb;		/* enter debugger on frame char */
 	char	cs_consio;		/* port does /dev/console I/O */
 	char	cs_xxx;			/* (spare) */
+	char	cs_deferred_cc;		/* deferred zscnputc() output */
 	int	cs_speed;		/* default baud rate (from ROM) */
 
 	/*