bussified and bus-split bustec scsi ha driver.

original port done by chris@ in '98 and pounded into
-current by me, plus support for wide mode.
tested on pci in both modes by me, on eisa (w/
half success, thus not enabled yet) by jason@.
niklas@, jason@, millert@ ok.

11 files changed, 2734 insertions, 1702 deletions

diff --git a/sys/dev/eisa/bha_eisa.c b/sys/dev/eisa/bha_eisa.c
index 78794a80f0e..397081d77c8 100644
--- a/sys/dev/eisa/bha_eisa.c
+++ b/sys/dev/eisa/bha_eisa.c
@@ -1,8 +1,12 @@
-/*	$OpenBSD: bha_eisa.c,v 1.1 1996/11/28 23:27:37 niklas Exp $	*/
-/*	$NetBSD: bha_eisa.c,v 1.5 1996/10/21 22:31:00 thorpej Exp $	*/
+/*	$OpenBSD: bha_eisa.c,v 1.2 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bha_eisa.c,v 1.16 1998/08/15 10:10:49 mycroft Exp $	*/
 
-/*
- * Copyright (c) 1994, 1996 Charles M. Hannum.  All rights reserved.
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -14,20 +18,23 @@
  *    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 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 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.
+ * 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 FOUNDATION 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/types.h>
@@ -47,9 +54,13 @@
 #include <dev/ic/bhareg.h>
 #include <dev/ic/bhavar.h>
 
-#define	BHA_EISA_SLOT_OFFSET	0xc00
-#define	BHA_EISA_IOSIZE		0x100
+#define BHA_EISA_SLOT_OFFSET	0x0c80
+#define	BHA_EISA_IOSIZE		0x0010
+#define	BHA_ISA_IOSIZE		0x0004
+
+#define	BHA_EISA_IOCONF		0x0c
 
+int	bha_eisa_address __P((bus_space_tag_t, bus_space_handle_t, int *));
 int	bha_eisa_match __P((struct device *, void *, void *));
 void	bha_eisa_attach __P((struct device *, struct device *, void *));
 
@@ -57,6 +68,41 @@ struct cfattach bha_eisa_ca = {
 	sizeof(struct bha_softc), bha_eisa_match, bha_eisa_attach
 };
 
+int
+bha_eisa_address(iot, ioh, portp)
+	bus_space_tag_t iot;
+	bus_space_handle_t ioh;
+	int *portp;
+{
+	int port;
+
+	switch (bus_space_read_1(iot, ioh, BHA_EISA_IOCONF) & 0x07) {
+	case 0x00:
+		port = 0x330;
+		break;
+	case 0x01:
+		port = 0x334;
+		break;
+	case 0x02:
+		port = 0x230;
+		break;
+	case 0x03:
+		port = 0x234;
+		break;
+	case 0x04:
+		port = 0x130;
+		break;
+	case 0x05:
+		port = 0x134;
+		break;
+	default:
+		return (1);
+	}
+
+	*portp = port;
+	return (0);
+}
+
 /*
  * Check the slots looking for a board we recognise
  * If we find one, note it's address (slot) and call
@@ -65,11 +111,12 @@ struct cfattach bha_eisa_ca = {
 int
 bha_eisa_match(parent, match, aux)
 	struct device *parent;
-	void *match, *aux;
+	void *aux, *match;
 {
 	struct eisa_attach_args *ea = aux;
 	bus_space_tag_t iot = ea->ea_iot;
-	bus_space_handle_t ioh;
+	bus_space_handle_t ioh, ioh2;
+	int port;
 	int rv;
 
 	/* must match one of our known ID strings */
@@ -77,12 +124,20 @@ bha_eisa_match(parent, match, aux)
 	    strcmp(ea->ea_idstring, "BUS4202"))
 		return (0);
 
-	if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
-	    BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE, 0, &ioh))
+	if (bus_space_map(iot,
+	    EISA_SLOT_ADDR(ea->ea_slot) + BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE,
+	    0, &ioh))
 		return (0);
 
-	rv = bha_find(iot, ioh, NULL);
+	if (bha_eisa_address(iot, ioh, &port) ||
+	    bus_space_map(iot, port, BHA_ISA_IOSIZE, 0, &ioh2)) {
+		bus_space_unmap(iot, ioh, BHA_EISA_IOSIZE);
+		return (0);
+	}
+
+	rv = bha_find(iot, ioh2, NULL);
 
+	bus_space_unmap(iot, ioh2, BHA_ISA_IOSIZE);
 	bus_space_unmap(iot, ioh, BHA_EISA_IOSIZE);
 
 	return (rv);
@@ -99,7 +154,9 @@ bha_eisa_attach(parent, self, aux)
 	struct eisa_attach_args *ea = aux;
 	struct bha_softc *sc = (void *)self;
 	bus_space_tag_t iot = ea->ea_iot;
-	bus_space_handle_t ioh;
+	bus_space_handle_t ioh, ioh2;
+	int port;
+	struct bha_probe_data bpd;
 	eisa_chipset_tag_t ec = ea->ea_ec;
 	eisa_intr_handle_t ih;
 	const char *model, *intrstr;
@@ -110,34 +167,45 @@ bha_eisa_attach(parent, self, aux)
 		model = EISA_PRODUCT_BUS4202;
 	else
 		model = "unknown model!";
-	printf(": %s\n", model);
 
-	if (bus_space_map(iot, EISA_SLOT_ADDR(ea->ea_slot) +
-	    BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE, 0, &ioh))
-		panic("bha_attach: could not map I/O addresses");
+	if (bus_space_map(iot,
+	    EISA_SLOT_ADDR(ea->ea_slot) + BHA_EISA_SLOT_OFFSET, BHA_EISA_IOSIZE,
+	    0, &ioh)) {
+		printf(": could not map EISA slot\n");
+		return;
+	}
+
+	if (bha_eisa_address(iot, ioh, &port) ||
+	    bus_space_map(iot, port, BHA_ISA_IOSIZE, 0, &ioh2)) {
+		printf(": could not map ISA address\n");
+		return;
+	}
 
 	sc->sc_iot = iot;
-	sc->sc_ioh = ioh;
-	if (!bha_find(iot, ioh, sc))
-		panic("bha_attach: bha_find failed!");
+	sc->sc_ioh = ioh2;
+	sc->sc_dmat = ea->ea_dmat;
+	if (!bha_find(iot, ioh2, &bpd)) {
+		printf(": bha_find failed\n");
+		return;
+	}
+
+	sc->sc_dmaflags = 0;
 
-	if (eisa_intr_map(ec, sc->sc_irq, &ih)) {
-		printf("%s: couldn't map interrupt (%d)\n",
-		    sc->sc_dev.dv_xname, sc->sc_irq);
+	if (eisa_intr_map(ec, bpd.sc_irq, &ih)) {
+		printf(": couldn't map interrupt (%d)\n", bpd.sc_irq);
 		return;
 	}
 	intrstr = eisa_intr_string(ec, ih);
 	sc->sc_ih = eisa_intr_establish(ec, ih, IST_LEVEL, IPL_BIO,
 	    bha_intr, sc, sc->sc_dev.dv_xname);
 	if (sc->sc_ih == NULL) {
-		printf("%s: couldn't establish interrupt",
-		    sc->sc_dev.dv_xname);
+		printf(": couldn't establish interrupt");
 		if (intrstr != NULL)
 			printf(" at %s", intrstr);
 		printf("\n");
 		return;
 	}
-	printf("%s: interrupting at %s\n", sc->sc_dev.dv_xname, intrstr);
+	printf(": %s, %s\n", intrstr, model);
 
-	bha_attach(sc);
+	bha_attach(sc, &bpd);
 }
diff --git a/sys/dev/ic/bha.c b/sys/dev/ic/bha.c
new file mode 100644
index 00000000000..cf1ba450d47
--- /dev/null
+++ b/sys/dev/ic/bha.c
@@ -0,0 +1,1613 @@
+/*	$OpenBSD: bha.c,v 1.1 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bha.c,v 1.27 1998/11/19 21:53:00 thorpej Exp $	*/
+
+#undef BHADEBUG
+#ifdef DDB
+#define	integrate
+#else
+#define	integrate	static inline
+#endif
+
+/*-
+ * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
+ * Simulation Facility, NASA Ames Research Center.
+ *
+ * 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 FOUNDATION 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.
+ */
+
+/*
+ * Originally written by Julian Elischer (julian@tfs.com)
+ * for TRW Financial Systems for use under the MACH(2.5) operating system.
+ *
+ * TRW Financial Systems, in accordance with their agreement with Carnegie
+ * Mellon University, makes this software available to CMU to distribute
+ * or use in any manner that they see fit as long as this message is kept with
+ * the software. For this reason TFS also grants any other persons or
+ * organisations permission to use or modify this software.
+ *
+ * TFS supplies this software to be publicly redistributed
+ * on the understanding that TFS is not responsible for the correct
+ * functioning of this software in any circumstances.
+ */
+
+#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 <machine/bus.h>
+#include <machine/intr.h>
+
+#include <scsi/scsi_all.h>
+#include <scsi/scsiconf.h>
+
+#include <dev/ic/bhareg.h>
+#include <dev/ic/bhavar.h>
+
+#ifndef DDB
+#define Debugger() panic("should call debugger here (bha.c)")
+#endif /* ! DDB */
+
+#define	BHA_MAXXFER	((BHA_NSEG - 1) << PGSHIFT)
+#define	ISWIDE(sc)	((sc)->sc_iswide)
+
+#ifdef BHADEBUG
+int     bha_debug = 1;
+#endif /* BHADEBUG */
+
+integrate void bha_finish_ccbs __P((struct bha_softc *));
+integrate void bha_reset_ccb __P((struct bha_softc *, struct bha_ccb *));
+void bha_free_ccb __P((struct bha_softc *, struct bha_ccb *));
+integrate int bha_init_ccb __P((struct bha_softc *, struct bha_ccb *));
+struct bha_ccb *bha_get_ccb __P((struct bha_softc *, int));
+struct bha_ccb *bha_ccb_phys_kv __P((struct bha_softc *, u_long));
+void bha_queue_ccb __P((struct bha_softc *, struct bha_ccb *));
+void bha_collect_mbo __P((struct bha_softc *));
+void bha_start_ccbs __P((struct bha_softc *));
+void bha_done __P((struct bha_softc *, struct bha_ccb *));
+int bha_init __P((struct bha_softc *));
+void bhaminphys __P((struct buf *));
+int bha_scsi_cmd __P((struct scsi_xfer *));
+int bha_poll __P((struct bha_softc *, struct scsi_xfer *, int));
+void bha_timeout __P((void *arg));
+int bha_create_ccbs __P((struct bha_softc *, struct bha_ccb *, int));
+void bha_enqueue __P((struct bha_softc *, struct scsi_xfer *, int));
+struct scsi_xfer *bha_dequeue __P((struct bha_softc *));
+
+struct cfdriver bha_cd = {
+	NULL, "bha", DV_DULL
+};
+
+/* the below structure is so we have a default dev struct for out link struct */
+struct scsi_device bha_dev = {
+	NULL,			/* Use default error handler */
+	NULL,			/* have a queue, served by this */
+	NULL,			/* have no async handler */
+	NULL,			/* Use default 'done' routine */
+};
+
+#define BHA_RESET_TIMEOUT	2000	/* time to wait for reset (mSec) */
+#define	BHA_ABORT_TIMEOUT	2000	/* time to wait for abort (mSec) */
+
+/*
+ * Insert a scsi_xfer into the software queue.  We overload xs->free_list
+ * to avoid having to allocate additional resources (since we're used
+ * only during resource shortages anyhow.
+ */
+void
+bha_enqueue(sc, xs, infront)
+	struct bha_softc *sc;
+	struct scsi_xfer *xs;
+	int infront;
+{
+
+	if (infront || sc->sc_queue.lh_first == NULL) {
+		if (sc->sc_queue.lh_first == NULL)
+			sc->sc_queuelast = xs;
+		LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
+		return;
+	}
+
+	LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
+	sc->sc_queuelast = xs;
+}
+
+/*
+ * Pull a scsi_xfer off the front of the software queue.
+ */
+struct scsi_xfer *
+bha_dequeue(sc)
+	struct bha_softc *sc;
+{
+	struct scsi_xfer *xs;
+
+	xs = sc->sc_queue.lh_first;
+	LIST_REMOVE(xs, free_list);
+
+	if (sc->sc_queue.lh_first == NULL)
+		sc->sc_queuelast = NULL;
+
+	return (xs);
+}
+
+/*
+ * bha_cmd(iot, ioh, sc, icnt, ibuf, ocnt, obuf)
+ *
+ * Activate Adapter command
+ *    icnt:   number of args (outbound bytes including opcode)
+ *    ibuf:   argument buffer
+ *    ocnt:   number of expected returned bytes
+ *    obuf:   result buffer
+ *    wait:   number of seconds to wait for response
+ *
+ * Performs an adapter command through the ports.  Not to be confused with a
+ * scsi command, which is read in via the dma; one of the adapter commands
+ * tells it to read in a scsi command.
+ */
+int
+bha_cmd(iot, ioh, sc, icnt, ibuf, ocnt, obuf)
+	bus_space_tag_t iot;
+	bus_space_handle_t ioh;
+	struct bha_softc *sc;
+	int icnt, ocnt;
+	u_char *ibuf, *obuf;
+{
+	const char *name;
+	register int i;
+	int wait;
+	u_char sts;
+	u_char opcode = ibuf[0];
+
+	if (sc != NULL)
+		name = sc->sc_dev.dv_xname;
+	else
+		name = "(bha probe)";
+
+	/*
+	 * Calculate a reasonable timeout for the command.
+	 */
+	switch (opcode) {
+	case BHA_INQUIRE_DEVICES:
+	case BHA_INQUIRE_DEVICES_2:
+		wait = 90 * 20000;
+		break;
+	default:
+		wait = 1 * 20000;
+		break;
+	}
+
+	/*
+	 * Wait for the adapter to go idle, unless it's one of
+	 * the commands which don't need this
+	 */
+	if (opcode != BHA_MBO_INTR_EN) {
+		for (i = 20000; i; i--) {	/* 1 sec? */
+			sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT);
+			if (sts & BHA_STAT_IDLE)
+				break;
+			delay(50);
+		}
+		if (!i) {
+			printf("%s: bha_cmd, host not idle(0x%x)\n",
+			    name, sts);
+			return (1);
+		}
+	}
+	/*
+	 * Now that it is idle, if we expect output, preflush the
+	 * queue feeding to us.
+	 */
+	if (ocnt) {
+		while ((bus_space_read_1(iot, ioh, BHA_STAT_PORT)) &
+		    BHA_STAT_DF)
+			bus_space_read_1(iot, ioh, BHA_DATA_PORT);
+	}
+	/*
+	 * Output the command and the number of arguments given
+	 * for each byte, first check the port is empty.
+	 */
+	while (icnt--) {
+		for (i = wait; i; i--) {
+			sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT);
+			if (!(sts & BHA_STAT_CDF))
+				break;
+			delay(50);
+		}
+		if (!i) {
+			if (opcode != BHA_INQUIRE_REVISION)
+				printf("%s: bha_cmd, cmd/data port full\n",
+				    name);
+			goto bad;
+		}
+		bus_space_write_1(iot, ioh, BHA_CMD_PORT, *ibuf++);
+	}
+	/*
+	 * If we expect input, loop that many times, each time,
+	 * looking for the data register to have valid data
+	 */
+	while (ocnt--) {
+		for (i = wait; i; i--) {
+			sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT);
+			if (sts & BHA_STAT_DF)
+				break;
+			delay(50);
+		}
+		if (!i) {
+			if (opcode != BHA_INQUIRE_REVISION)
+				printf("%s: bha_cmd, cmd/data port empty %d\n",
+				    name, ocnt);
+			goto bad;
+		}
+		*obuf++ = bus_space_read_1(iot, ioh, BHA_DATA_PORT);
+	}
+	/*
+	 * Wait for the board to report a finished instruction.
+	 * We may get an extra interrupt for the HACC signal, but this is
+	 * unimportant.
+	 */
+	if (opcode != BHA_MBO_INTR_EN && opcode != BHA_MODIFY_IOPORT) {
+		for (i = 20000; i; i--) {	/* 1 sec? */
+			sts = bus_space_read_1(iot, ioh, BHA_INTR_PORT);
+			/* XXX Need to save this in the interrupt handler? */
+			if (sts & BHA_INTR_HACC)
+				break;
+			delay(50);
+		}
+		if (!i) {
+			printf("%s: bha_cmd, host not finished(0x%x)\n",
+			    name, sts);
+			return (1);
+		}
+	}
+	bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_IRST);
+	return (0);
+
+bad:
+	bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_SRST);
+	return (1);
+}
+
+/*
+ * Attach all the sub-devices we can find
+ */
+void
+bha_attach(sc, bpd)
+	struct bha_softc *sc;
+	struct bha_probe_data *bpd;
+{
+	int s;
+
+	/*
+	 * Fill in the adapter.
+	 */
+	sc->sc_adapter.scsi_cmd = bha_scsi_cmd;
+	sc->sc_adapter.scsi_minphys = bhaminphys;
+
+	/*
+	 * fill in the prototype scsi_link.
+	 */
+	sc->sc_link.adapter_softc = sc;
+	sc->sc_link.adapter_target = bpd->sc_scsi_dev;
+	sc->sc_link.adapter = &sc->sc_adapter;
+	sc->sc_link.device = &bha_dev;
+	sc->sc_link.openings = 4;
+
+	TAILQ_INIT(&sc->sc_free_ccb);
+	TAILQ_INIT(&sc->sc_waiting_ccb);
+	LIST_INIT(&sc->sc_queue);
+
+	s = splbio();
+	bha_inquire_setup_information(sc);
+
+	printf("%s: model BT-%s, firmware %s\n", sc->sc_dev.dv_xname,
+	    sc->sc_model, sc->sc_firmware);
+
+	if (bha_init(sc) != 0) {
+		/* Error during initialization! */
+		splx(s);
+		return;
+	}
+
+	splx(s);
+
+	/*
+	 * ask the adapter what subunits are present
+	 */
+	config_found(&sc->sc_dev, &sc->sc_link, scsiprint);
+}
+
+integrate void
+bha_finish_ccbs(sc)
+	struct bha_softc *sc;
+{
+	struct bha_mbx_in *wmbi;
+	struct bha_ccb *ccb;
+	int i;
+
+	wmbi = wmbx->tmbi;
+
+	bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+	    0, sc->sc_dmamap_control->dm_mapsize,
+	    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+
+	if (wmbi->comp_stat == BHA_MBI_FREE) {
+		for (i = 0; i < BHA_MBX_SIZE; i++) {
+			if (wmbi->comp_stat != BHA_MBI_FREE) {
+				printf("%s: mbi not in round-robin order\n",
+				    sc->sc_dev.dv_xname);
+				goto AGAIN;
+			}
+			bha_nextmbx(wmbi, wmbx, mbi);
+			bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+			    0, sc->sc_dmamap_control->dm_mapsize,
+			    BUS_DMASYNC_POSTREAD);
+		}
+#ifdef BHADIAGnot
+		printf("%s: mbi interrupt with no full mailboxes\n",
+		    sc->sc_dev.dv_xname);
+#endif
+		return;
+	}
+
+AGAIN:
+	do {
+		ccb = bha_ccb_phys_kv(sc, phystol(wmbi->ccb_addr));
+		if (!ccb) {
+			printf("%s: bad mbi ccb pointer; skipping\n",
+			    sc->sc_dev.dv_xname);
+			goto next;
+		}
+
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+
+#ifdef BHADEBUG
+		if (bha_debug) {
+			u_int8_t *cp = ccb->scsi_cmd.bytes;
+			printf("op=%x %x %x %x %x %x\n",
+				ccb->scsi_cmd.opcode,
+				cp[0], cp[1], cp[2], cp[3], cp[4]);
+			printf("stat %x for mbi addr = 0x%08x, ",
+				wmbi->comp_stat, wmbi);
+			printf("ccb addr = 0x%x\n", ccb);
+		}
+#endif /* BHADEBUG */
+
+		switch (wmbi->comp_stat) {
+		case BHA_MBI_OK:
+		case BHA_MBI_ERROR:
+			if ((ccb->flags & CCB_ABORT) != 0) {
+				/*
+				 * If we already started an abort, wait for it
+				 * to complete before clearing the CCB.  We
+				 * could instead just clear CCB_SENDING, but
+				 * what if the mailbox was already received?
+				 * The worst that happens here is that we clear
+				 * the CCB a bit later than we need to.  BFD.
+				 */
+				goto next;
+			}
+			break;
+
+		case BHA_MBI_ABORT:
+		case BHA_MBI_UNKNOWN:
+			/*
+			 * Even if the CCB wasn't found, we clear it anyway.
+			 * See preceeding comment.
+			 */
+			break;
+
+		default:
+			printf("%s: bad mbi status %02x; skipping\n",
+			    sc->sc_dev.dv_xname, wmbi->comp_stat);
+			goto next;
+		}
+
+		timeout_del(&ccb->xs->stimeout);
+		bha_done(sc, ccb);
+
+	next:
+		wmbi->comp_stat = BHA_MBI_FREE;
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+		bha_nextmbx(wmbi, wmbx, mbi);
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+	} while (wmbi->comp_stat != BHA_MBI_FREE);
+
+	wmbx->tmbi = wmbi;
+}
+
+/*
+ * Catch an interrupt from the adaptor
+ */
+int
+bha_intr(arg)
+	void *arg;
+{
+	struct bha_softc *sc = arg;
+	bus_space_tag_t iot = sc->sc_iot;
+	bus_space_handle_t ioh = sc->sc_ioh;
+	u_char sts;
+
+#ifdef BHADEBUG
+	printf("%s: bha_intr ", sc->sc_dev.dv_xname);
+#endif /* BHADEBUG */
+
+	/*
+	 * First acknowlege the interrupt, Then if it's not telling about
+	 * a completed operation just return.
+	 */
+	sts = bus_space_read_1(iot, ioh, BHA_INTR_PORT);
+	if ((sts & BHA_INTR_ANYINTR) == 0)
+		return (0);
+	bus_space_write_1(iot, ioh, BHA_CTRL_PORT, BHA_CTRL_IRST);
+
+#ifdef BHADIAG
+	/* Make sure we clear CCB_SENDING before finishing a CCB. */
+	bha_collect_mbo(sc);
+#endif
+
+	/* Mail box out empty? */
+	if (sts & BHA_INTR_MBOA) {
+		struct bha_toggle toggle;
+
+		toggle.cmd.opcode = BHA_MBO_INTR_EN;
+		toggle.cmd.enable = 0;
+		bha_cmd(iot, ioh, sc,
+		    sizeof(toggle.cmd), (u_char *)&toggle.cmd,
+		    0, (u_char *)0);
+		bha_start_ccbs(sc);
+	}
+
+	/* Mail box in full? */
+	if (sts & BHA_INTR_MBIF)
+		bha_finish_ccbs(sc);
+
+	return (1);
+}
+
+integrate void
+bha_reset_ccb(sc, ccb)
+	struct bha_softc *sc;
+	struct bha_ccb *ccb;
+{
+
+	ccb->flags = 0;
+}
+
+/*
+ * A ccb is put onto the free list.
+ */
+void
+bha_free_ccb(sc, ccb)
+	struct bha_softc *sc;
+	struct bha_ccb *ccb;
+{
+	int s;
+
+	s = splbio();
+
+	bha_reset_ccb(sc, ccb);
+	TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain);
+
+	/*
+	 * If there were none, wake anybody waiting for one to come free,
+	 * starting with queued entries.
+	 */
+	if (ccb->chain.tqe_next == 0)
+		wakeup(&sc->sc_free_ccb);
+
+	splx(s);
+}
+
+integrate int
+bha_init_ccb(sc, ccb)
+	struct bha_softc *sc;
+	struct bha_ccb *ccb;
+{
+	bus_dma_tag_t dmat = sc->sc_dmat;
+	int hashnum, error;
+
+	/*
+	 * Create the DMA map for this CCB.
+	 */
+	error = bus_dmamap_create(dmat, BHA_MAXXFER, BHA_NSEG, BHA_MAXXFER,
+	    0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW | sc->sc_dmaflags,
+	    &ccb->dmamap_xfer);
+	if (error) {
+		printf("%s: unable to create ccb DMA map, error = %d\n",
+		    sc->sc_dev.dv_xname, error);
+		return (error);
+	}
+
+	/*
+	 * put in the phystokv hash table
+	 * Never gets taken out.
+	 */
+	ccb->hashkey = sc->sc_dmamap_control->dm_segs[0].ds_addr +
+	    BHA_CCB_OFF(ccb);
+	hashnum = CCB_HASH(ccb->hashkey);
+	ccb->nexthash = sc->sc_ccbhash[hashnum];
+	sc->sc_ccbhash[hashnum] = ccb;
+	bha_reset_ccb(sc, ccb);
+	return (0);
+}
+
+/*
+ * Create a set of ccbs and add them to the free list.  Called once
+ * by bha_init().  We return the number of CCBs successfully created.
+ */
+int
+bha_create_ccbs(sc, ccbstore, count)
+	struct bha_softc *sc;
+	struct bha_ccb *ccbstore;
+	int count;
+{
+	struct bha_ccb *ccb;
+	int i, error;
+
+	bzero(ccbstore, sizeof(struct bha_ccb) * count);
+	for (i = 0; i < count; i++) {
+		ccb = &ccbstore[i];
+		if ((error = bha_init_ccb(sc, ccb)) != 0) {
+			printf("%s: unable to initialize ccb, error = %d\n",
+			    sc->sc_dev.dv_xname, error);
+			goto out;
+		}
+		TAILQ_INSERT_TAIL(&sc->sc_free_ccb, ccb, chain);
+	}
+ out:
+	return (i);
+}
+
+/*
+ * Get a free ccb
+ *
+ * If there are none, see if we can allocate a new one.  If so, put it in
+ * the hash table too otherwise either return an error or sleep.
+ */
+struct bha_ccb *
+bha_get_ccb(sc, flags)
+	struct bha_softc *sc;
+	int flags;
+{
+	struct bha_ccb *ccb;
+	int s;
+
+	s = splbio();
+
+	/*
+	 * If we can and have to, sleep waiting for one to come free
+	 * but only if we can't allocate a new one.
+	 */
+	for (;;) {
+		ccb = sc->sc_free_ccb.tqh_first;
+		if (ccb) {
+			TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain);
+			break;
+		}
+		if ((flags & SCSI_NOSLEEP) != 0)
+			goto out;
+		tsleep(&sc->sc_free_ccb, PRIBIO, "bhaccb", 0);
+	}
+
+	ccb->flags |= CCB_ALLOC;
+
+out:
+	splx(s);
+	return (ccb);
+}
+
+/*
+ * Given a physical address, find the ccb that it corresponds to.
+ */
+struct bha_ccb *
+bha_ccb_phys_kv(sc, ccb_phys)
+	struct bha_softc *sc;
+	u_long ccb_phys;
+{
+	int hashnum = CCB_HASH(ccb_phys);
+	struct bha_ccb *ccb = sc->sc_ccbhash[hashnum];
+
+	while (ccb) {
+		if (ccb->hashkey == ccb_phys)
+			break;
+		ccb = ccb->nexthash;
+	}
+	return (ccb);
+}
+
+/*
+ * Queue a CCB to be sent to the controller, and send it if possible.
+ */
+void
+bha_queue_ccb(sc, ccb)
+	struct bha_softc *sc;
+	struct bha_ccb *ccb;
+{
+
+	timeout_set(&ccb->xs->stimeout, bha_timeout, ccb);
+	TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain);
+	bha_start_ccbs(sc);
+}
+
+/*
+ * Garbage collect mailboxes that are no longer in use.
+ */
+void
+bha_collect_mbo(sc)
+	struct bha_softc *sc;
+{
+	struct bha_mbx_out *wmbo;	/* Mail Box Out pointer */
+#ifdef BHADIAG
+	struct bha_ccb *ccb;
+#endif
+
+	wmbo = wmbx->cmbo;
+
+	while (sc->sc_mbofull > 0) {
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_POSTREAD|BUS_DMASYNC_POSTWRITE);
+		if (wmbo->cmd != BHA_MBO_FREE)
+			break;
+
+#ifdef BHADIAG
+		ccb = bha_ccb_phys_kv(sc, phystol(wmbo->ccb_addr));
+		ccb->flags &= ~CCB_SENDING;
+#endif
+
+		--sc->sc_mbofull;
+		bha_nextmbx(wmbo, wmbx, mbo);
+	}
+
+	wmbx->cmbo = wmbo;
+}
+
+/*
+ * Send as many CCBs as we have empty mailboxes for.
+ */
+void
+bha_start_ccbs(sc)
+	struct bha_softc *sc;
+{
+	bus_space_tag_t iot = sc->sc_iot;
+	bus_space_handle_t ioh = sc->sc_ioh;
+	struct bha_mbx_out *wmbo;	/* Mail Box Out pointer */
+	struct bha_ccb *ccb;
+	struct scsi_xfer *xs;
+
+	wmbo = wmbx->tmbo;
+
+	while ((ccb = sc->sc_waiting_ccb.tqh_first) != NULL) {
+
+		xs = ccb->xs;
+		if (sc->sc_mbofull >= BHA_MBX_SIZE) {
+			bha_collect_mbo(sc);
+			if (sc->sc_mbofull >= BHA_MBX_SIZE) {
+				struct bha_toggle toggle;
+
+				toggle.cmd.opcode = BHA_MBO_INTR_EN;
+				toggle.cmd.enable = 1;
+				bha_cmd(iot, ioh, sc,
+				    sizeof(toggle.cmd), (u_char *)&toggle.cmd,
+				    0, (u_char *)0);
+				break;
+			}
+		}
+
+		TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain);
+#ifdef BHADIAG
+		ccb->flags |= CCB_SENDING;
+#endif
+
+		/* Link ccb to mbo. */
+		ltophys(sc->sc_dmamap_control->dm_segs[0].ds_addr +
+		    BHA_CCB_OFF(ccb), wmbo->ccb_addr);
+		if (ccb->flags & CCB_ABORT)
+			wmbo->cmd = BHA_MBO_ABORT;
+		else
+			wmbo->cmd = BHA_MBO_START;
+
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+
+		/* Tell the card to poll immediately. */
+		bus_space_write_1(iot, ioh, BHA_CMD_PORT, BHA_START_SCSI);
+
+		if ((xs->flags & SCSI_POLL) == 0)
+			timeout_add(&xs->stimeout, (ccb->timeout * hz) / 1000);
+
+		++sc->sc_mbofull;
+		bha_nextmbx(wmbo, wmbx, mbo);
+	}
+
+	wmbx->tmbo = wmbo;
+}
+
+/*
+ * We have a ccb which has been processed by the
+ * adaptor, now we look to see how the operation
+ * went. Wake up the owner if waiting
+ */
+void
+bha_done(sc, ccb)
+	struct bha_softc *sc;
+	struct bha_ccb *ccb;
+{
+	bus_dma_tag_t dmat = sc->sc_dmat;
+	struct scsi_sense_data *s1, *s2;
+	struct scsi_xfer *xs = ccb->xs;
+
+	SC_DEBUG(xs->sc_link, SDEV_DB2, ("bha_done\n"));
+
+	/*
+	 * If we were a data transfer, unload the map that described
+	 * the data buffer.
+	 */
+	if (xs->datalen) {
+		bus_dmamap_sync(dmat, ccb->dmamap_xfer,
+		    0, ccb->dmamap_xfer->dm_mapsize,
+		    (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
+		    BUS_DMASYNC_POSTWRITE);
+		bus_dmamap_unload(dmat, ccb->dmamap_xfer);
+	}
+
+	/*
+	 * Otherwise, put the results of the operation
+	 * into the xfer and call whoever started it
+	 */
+#ifdef BHADIAG
+	if (ccb->flags & CCB_SENDING) {
+		printf("%s: exiting ccb still in transit!\n",
+		    sc->sc_dev.dv_xname);
+		Debugger();
+		return;
+	}
+#endif
+	if ((ccb->flags & CCB_ALLOC) == 0) {
+		printf("%s: exiting ccb not allocated!\n",
+		    sc->sc_dev.dv_xname);
+		Debugger();
+		return;
+	}
+	if (xs->error == XS_NOERROR) {
+		if (ccb->host_stat != BHA_OK) {
+			switch (ccb->host_stat) {
+			case BHA_SEL_TIMEOUT:	/* No response */
+				xs->error = XS_SELTIMEOUT;
+				break;
+			default:	/* Other scsi protocol messes */
+				printf("%s: host_stat %x\n",
+				    sc->sc_dev.dv_xname, ccb->host_stat);
+				xs->error = XS_DRIVER_STUFFUP;
+				break;
+			}
+		} else if (ccb->target_stat != SCSI_OK) {
+			switch (ccb->target_stat) {
+			case SCSI_CHECK:
+				s1 = &ccb->scsi_sense;
+				s2 = &xs->sense;
+				*s2 = *s1;
+				xs->error = XS_SENSE;
+				break;
+			case SCSI_BUSY:
+				xs->error = XS_BUSY;
+				break;
+			default:
+				printf("%s: target_stat %x\n",
+				    sc->sc_dev.dv_xname, ccb->target_stat);
+				xs->error = XS_DRIVER_STUFFUP;
+				break;
+			}
+		} else
+			xs->resid = 0;
+	}
+	bha_free_ccb(sc, ccb);
+	xs->flags |= ITSDONE;
+	scsi_done(xs);
+
+	/*
+	 * If there are queue entries in the software queue, try to
+	 * run the first one.  We should be more or less guaranteed
+	 * to succeed, since we just freed a CCB.
+	 *
+	 * NOTE: bha_scsi_cmd() relies on our calling it with
+	 * the first entry in the queue.
+	 */
+	if ((xs = sc->sc_queue.lh_first) != NULL)
+		(void) bha_scsi_cmd(xs);
+}
+
+/*
+ * Find the board and find it's irq/drq
+ */
+int
+bha_find(iot, ioh, sc)
+	bus_space_tag_t iot;
+	bus_space_handle_t ioh;
+	struct bha_probe_data *sc;
+{
+	int i, iswide;
+	u_char sts;
+	struct bha_extended_inquire inquire;
+	struct bha_config config;
+	int irq, drq;
+
+	/* Check something is at the ports we need to access */
+	sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT);
+	if (sts == 0xFF) {
+#ifdef BHADEBUG
+		if (bha_debug)
+			printf("bha_find: Not present\n");
+#endif /* BHADEBUG */
+		return (0);
+	}
+
+	/*
+	 * Reset board, If it doesn't respond, assume
+	 * that it's not there.. good for the probe
+	 */
+
+	bus_space_write_1(iot, ioh, BHA_CTRL_PORT,
+	    BHA_CTRL_HRST | BHA_CTRL_SRST);
+
+	for (i = BHA_RESET_TIMEOUT; i--;) {
+		delay(100);
+		sts = bus_space_read_1(iot, ioh, BHA_STAT_PORT);
+		if (sts == (BHA_STAT_IDLE | BHA_STAT_INIT))
+			break;
+	}
+	if (i < 0) {
+#ifdef BHADEBUG
+		if (bha_debug)
+			printf("bha_find: No answer from board a=%x sts=%b\n",
+			    ioh, sts, BHA_STAT_BITS);
+#endif /* BHADEBUG */
+		return (0);
+	}
+
+	/*
+	 * The BusLogic cards implement an Adaptec 1542 (aha)-compatible
+	 * interface. The native bha interface is not compatible with 
+	 * an aha. 1542. We need to ensure that we never match an
+	 * Adaptec 1542. We must also avoid sending Adaptec-compatible
+	 * commands to a real bha, lest it go into 1542 emulation mode.
+	 * (On an indirect bus like ISA, we should always probe for BusLogic
+	 * interfaces  before Adaptec interfaces).
+	 */
+
+	/*
+	 * Make sure we don't match an AHA-1542A or AHA-1542B, by checking
+	 * for an extended-geometry register.  The 1542[AB] don't have one.
+	 */
+	sts = bus_space_read_1(iot, ioh, BHA_EXTGEOM_PORT);
+	if (sts == 0xFF)
+		return (0);
+
+	/*
+	 * Check that we actually know how to use this board.
+	 */
+	delay(1000);
+	inquire.cmd.opcode = BHA_INQUIRE_EXTENDED;
+	inquire.cmd.len = sizeof(inquire.reply);
+	i = bha_cmd(iot, ioh, NULL,
+	    sizeof(inquire.cmd), (u_char *)&inquire.cmd,
+	    sizeof(inquire.reply), (u_char *)&inquire.reply);
+
+	/*
+	 * Some 1542Cs (CP, perhaps not CF, may depend on firmware rev)
+	 * have the extended-geometry register and also respond to
+	 * BHA_INQUIRE_EXTENDED.  Make sure we never  match such cards,
+	 * by checking the size of the reply is what a BusLogic card returns.
+	 */
+	if (i) {
+#ifdef BHADEBUG
+		printf("bha_find: board returned %d instead of %d to %s\n",
+		       i, sizeof(inquire.reply), "INQUIRE_EXTENDED");
+#endif
+		return (0);
+	}
+
+	/* OK, we know we've found a buslogic adaptor. */
+
+	switch (inquire.reply.bus_type) {
+	case BHA_BUS_TYPE_24BIT:
+	case BHA_BUS_TYPE_32BIT:
+		break;
+	case BHA_BUS_TYPE_MCA:
+		/* We don't grok MicroChannel (yet). */
+		return (0);
+	default:
+		printf("bha_find: illegal bus type %c\n",
+		    inquire.reply.bus_type);
+		return (0);
+	}
+
+	/* Note if we have a wide bus. */
+	iswide = inquire.reply.scsi_flags & BHA_SCSI_WIDE;
+
+	/*
+	 * Assume we have a board at this stage setup dma channel from
+	 * jumpers and save int level
+	 */
+	delay(1000);
+	config.cmd.opcode = BHA_INQUIRE_CONFIG;
+	bha_cmd(iot, ioh, NULL,
+	    sizeof(config.cmd), (u_char *)&config.cmd,
+	    sizeof(config.reply), (u_char *)&config.reply);
+	switch (config.reply.chan) {
+	case EISADMA:
+		drq = -1;
+		break;
+	case CHAN0:
+		drq = 0;
+		break;
+	case CHAN5:
+		drq = 5;
+		break;
+	case CHAN6:
+		drq = 6;
+		break;
+	case CHAN7:
+		drq = 7;
+		break;
+	default:
+		printf("bha_find: illegal drq setting %x\n",
+		    config.reply.chan);
+		return (0);
+	}
+
+	switch (config.reply.intr) {
+	case INT9:
+		irq = 9;
+		break;
+	case INT10:
+		irq = 10;
+		break;
+	case INT11:
+		irq = 11;
+		break;
+	case INT12:
+		irq = 12;
+		break;
+	case INT14:
+		irq = 14;
+		break;
+	case INT15:
+		irq = 15;
+		break;
+	default:
+		printf("bha_find: illegal irq setting %x\n",
+		    config.reply.intr);
+		return (0);
+	}
+
+	/* if we want to fill in softc, do so now */
+	if (sc != NULL) {
+		sc->sc_irq = irq;
+		sc->sc_drq = drq;
+		sc->sc_scsi_dev = config.reply.scsi_dev;
+		sc->sc_iswide = iswide;
+	}
+
+	return (1);
+}
+
+
+/*
+ * Disable the ISA-compatiblity ioports on  PCI bha devices,
+ * to ensure they're not autoconfigured a second time as an ISA bha.
+ */
+int
+bha_disable_isacompat(sc)
+	struct bha_softc *sc;
+{
+	struct bha_isadisable isa_disable;
+
+	isa_disable.cmd.opcode = BHA_MODIFY_IOPORT;
+	isa_disable.cmd.modifier = BHA_IOMODIFY_DISABLE1;
+	bha_cmd(sc->sc_iot, sc->sc_ioh, sc,
+	    sizeof(isa_disable.cmd), (u_char*)&isa_disable.cmd,
+	    0, (u_char *)0);
+	return (0);
+}
+
+
+/*
+ * Start the board, ready for normal operation
+ */
+int
+bha_init(sc)
+	struct bha_softc *sc;
+{
+	bus_space_tag_t iot = sc->sc_iot;
+	bus_space_handle_t ioh = sc->sc_ioh;
+	bus_dma_segment_t seg;
+	struct bha_devices devices;
+	struct bha_setup setup;
+	struct bha_mailbox mailbox;
+	struct bha_period period;
+	int error, i, j, initial_ccbs, rlen, rseg;
+
+	/* Enable round-robin scheme - appeared at firmware rev. 3.31. */
+	if (strcmp(sc->sc_firmware, "3.31") >= 0) {
+		struct bha_toggle toggle;
+
+		toggle.cmd.opcode = BHA_ROUND_ROBIN;
+		toggle.cmd.enable = 1;
+		bha_cmd(iot, ioh, sc,
+		    sizeof(toggle.cmd), (u_char *)&toggle.cmd,
+		    0, (u_char *)0);
+	}
+
+	/*
+	 * Inquire installed devices (to force synchronous negotiation).
+	 */
+
+	/*
+	 * Poll targets 0 - 7.
+	 */
+	devices.cmd.opcode = BHA_INQUIRE_DEVICES;
+	bha_cmd(iot, ioh, sc,
+	    sizeof(devices.cmd), (u_char *)&devices.cmd,
+	    sizeof(devices.reply), (u_char *)&devices.reply);
+
+	/* Count installed units. */
+	initial_ccbs = 0;
+	for (i = 0; i < 8; i++) {
+		for (j = 0; j < 8; j++) {
+			if (((devices.reply.lun_map[i] >> j) & 1) == 1)
+				initial_ccbs++;
+		}
+	}
+
+	/*
+	 * Poll targets 8 - 15 if we have a wide bus.
+         */
+	if (ISWIDE(sc)) {
+		devices.cmd.opcode = BHA_INQUIRE_DEVICES_2;
+		bha_cmd(iot, ioh, sc,
+		    sizeof(devices.cmd), (u_char *)&devices.cmd,
+		    sizeof(devices.reply), (u_char *)&devices.reply);
+
+		for (i = 0; i < 8; i++) {
+			for (j = 0; j < 8; j++) {
+				if (((devices.reply.lun_map[i] >> j) & 1) == 1)
+					initial_ccbs++;
+			}
+		}
+	}
+
+	initial_ccbs *= sc->sc_link.openings;
+	if (initial_ccbs > BHA_CCB_MAX)
+		initial_ccbs = BHA_CCB_MAX;
+	if (initial_ccbs == 0)	/* yes, this can happen */
+		initial_ccbs = sc->sc_link.openings;
+
+	/* Obtain setup information from. */
+	rlen = sizeof(setup.reply) +
+	    (ISWIDE(sc) ? sizeof(setup.reply_w) : 0);
+	setup.cmd.opcode = BHA_INQUIRE_SETUP;
+	setup.cmd.len = rlen;
+	bha_cmd(iot, ioh, sc,
+	    sizeof(setup.cmd), (u_char *)&setup.cmd,
+	    rlen, (u_char *)&setup.reply);
+
+	printf("%s: %s, %s\n", sc->sc_dev.dv_xname,
+	    setup.reply.sync_neg ? "sync" : "async",
+	    setup.reply.parity ? "parity" : "no parity");
+
+	for (i = 0; i < 8; i++)
+		period.reply.period[i] = setup.reply.sync[i].period * 5 + 20;
+	if (ISWIDE(sc)) {
+		for (i = 0; i < 8; i++)
+			period.reply_w.period[i] =
+			    setup.reply_w.sync_high[i].period * 5 + 20;
+	}
+
+	if (sc->sc_firmware[0] >= '3') {
+		rlen = sizeof(period.reply) +
+		    (ISWIDE(sc) ? sizeof(period.reply_w) : 0);
+		period.cmd.opcode = BHA_INQUIRE_PERIOD;
+		period.cmd.len = sizeof(period.reply);
+		bha_cmd(iot, ioh, sc,
+		    sizeof(period.cmd), (u_char *)&period.cmd,
+		    rlen, (u_char *)&period.reply);
+	}
+
+	for (i = 0; i < 8; i++) {
+		if (!setup.reply.sync[i].valid ||
+		    (!setup.reply.sync[i].offset &&
+		     !setup.reply.sync[i].period))
+			continue;
+		printf("%s targ %d: sync, offset %d, period %dnsec\n",
+		    sc->sc_dev.dv_xname, i,
+		    setup.reply.sync[i].offset, period.reply.period[i] * 10);
+	}
+	if (ISWIDE(sc)) {
+		for (i = 0; i < 8; i++) {
+			if (!setup.reply_w.sync_high[i].valid ||
+			    (!setup.reply_w.sync_high[i].offset &&
+			     !setup.reply_w.sync_high[i].period))
+				continue;
+			printf("%s targ %d: sync, offset %d, period %dnsec\n",
+			    sc->sc_dev.dv_xname, i + 8,
+			    setup.reply_w.sync_high[i].offset,
+			    period.reply_w.period[i] * 10);
+		}
+	}
+
+	/*
+	 * Allocate the mailbox and control blocks.
+	 */
+	if ((error = bus_dmamem_alloc(sc->sc_dmat, sizeof(struct bha_control),
+	    NBPG, 0, &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
+		printf("%s: unable to allocate control structures, "
+		    "error = %d\n", sc->sc_dev.dv_xname, error);
+		return (error);
+	}
+	if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg,
+	    sizeof(struct bha_control), (caddr_t *)&sc->sc_control,
+	    BUS_DMA_NOWAIT)) != 0) {
+		printf("%s: unable to map control structures, error = %d\n",
+		    sc->sc_dev.dv_xname, error);
+		return (error);
+	}
+
+	/*
+	 * Create and load the DMA map used for the mailbox and
+	 * control blocks.
+	 */
+	if ((error = bus_dmamap_create(sc->sc_dmat, sizeof(struct bha_control),
+	    1, sizeof(struct bha_control), 0, BUS_DMA_NOWAIT | sc->sc_dmaflags,
+	    &sc->sc_dmamap_control)) != 0) {
+		printf("%s: unable to create control DMA map, error = %d\n",
+		    sc->sc_dev.dv_xname, error);
+		return (error);
+	}
+	if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_control,
+	    sc->sc_control, sizeof(struct bha_control), NULL,
+	    BUS_DMA_NOWAIT)) != 0) {
+		printf("%s: unable to load control DMA map, error = %d\n",
+		    sc->sc_dev.dv_xname, error);
+		return (error);
+	}
+
+	/*
+	 * Initialize the control blocks.
+	 */
+	i = bha_create_ccbs(sc, sc->sc_control->bc_ccbs, initial_ccbs);
+	if (i == 0) {
+		printf("%s: unable to create control blocks\n",
+		    sc->sc_dev.dv_xname);
+		return (ENOMEM);
+	} else if (i != initial_ccbs) {
+		printf("%s: WARNING: only %d of %d control blocks created\n",
+		    sc->sc_dev.dv_xname, i, initial_ccbs);
+	}
+
+	/*
+	 * Set up initial mail box for round-robin operation.
+	 */
+	for (i = 0; i < BHA_MBX_SIZE; i++) {
+		wmbx->mbo[i].cmd = BHA_MBO_FREE;
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+		wmbx->mbi[i].comp_stat = BHA_MBI_FREE;
+		bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+		    0, sc->sc_dmamap_control->dm_mapsize,
+		    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+	}
+	wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0];
+	wmbx->tmbi = &wmbx->mbi[0];
+	sc->sc_mbofull = 0;
+
+	/* Initialize mail box. */
+	mailbox.cmd.opcode = BHA_MBX_INIT_EXTENDED;
+	mailbox.cmd.nmbx = BHA_MBX_SIZE;
+	ltophys(sc->sc_dmamap_control->dm_segs[0].ds_addr +
+	    offsetof(struct bha_control, bc_mbx), mailbox.cmd.addr);
+	bha_cmd(iot, ioh, sc,
+	    sizeof(mailbox.cmd), (u_char *)&mailbox.cmd,
+	    0, (u_char *)0);
+	return (0);
+}
+
+void
+bha_inquire_setup_information(sc)
+	struct bha_softc *sc;
+{
+	bus_space_tag_t iot = sc->sc_iot;
+	bus_space_handle_t ioh = sc->sc_ioh;
+	struct bha_model model;
+	struct bha_revision revision;
+	struct bha_digit digit;
+	char *p;
+
+	/*
+	 * Get the firmware revision.
+	 */
+	p = sc->sc_firmware;
+	revision.cmd.opcode = BHA_INQUIRE_REVISION;
+	bha_cmd(iot, ioh, sc,
+	    sizeof(revision.cmd), (u_char *)&revision.cmd,
+	    sizeof(revision.reply), (u_char *)&revision.reply);
+	*p++ = revision.reply.firm_revision;
+	*p++ = '.';
+	*p++ = revision.reply.firm_version;
+	digit.cmd.opcode = BHA_INQUIRE_REVISION_3;
+	bha_cmd(iot, ioh, sc,
+	    sizeof(digit.cmd), (u_char *)&digit.cmd,
+	    sizeof(digit.reply), (u_char *)&digit.reply);
+	*p++ = digit.reply.digit;
+	if (revision.reply.firm_revision >= '3' ||
+	    (revision.reply.firm_revision == '3' &&
+	     revision.reply.firm_version >= '3')) {
+		digit.cmd.opcode = BHA_INQUIRE_REVISION_4;
+		bha_cmd(iot, ioh, sc,
+		    sizeof(digit.cmd), (u_char *)&digit.cmd,
+		    sizeof(digit.reply), (u_char *)&digit.reply);
+		*p++ = digit.reply.digit;
+	}
+	while (p > sc->sc_firmware && (p[-1] == ' ' || p[-1] == '\0'))
+		p--;
+	*p = '\0';
+
+	/*
+	 * Get the model number.
+	 */
+	if (revision.reply.firm_revision >= '3') {
+		p = sc->sc_model;
+		model.cmd.opcode = BHA_INQUIRE_MODEL;
+		model.cmd.len = sizeof(model.reply);
+		bha_cmd(iot, ioh, sc,
+		    sizeof(model.cmd), (u_char *)&model.cmd,
+		    sizeof(model.reply), (u_char *)&model.reply);
+		*p++ = model.reply.id[0];
+		*p++ = model.reply.id[1];
+		*p++ = model.reply.id[2];
+		*p++ = model.reply.id[3];
+		while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0'))
+			p--;
+		*p++ = model.reply.version[0];
+		*p++ = model.reply.version[1];
+		while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0'))
+			p--;
+		*p = '\0';
+	} else
+		strcpy(sc->sc_model, "542B");
+}
+
+void
+bhaminphys(bp)
+	struct buf *bp;
+{
+
+	if (bp->b_bcount > BHA_MAXXFER)
+		bp->b_bcount = BHA_MAXXFER;
+	minphys(bp);
+}
+
+/*
+ * start a scsi operation given the command and the data address.  Also needs
+ * the unit, target and lu.
+ */
+int
+bha_scsi_cmd(xs)
+	struct scsi_xfer *xs;
+{
+	struct scsi_link *sc_link = xs->sc_link;
+	struct bha_softc *sc = sc_link->adapter_softc;
+	bus_dma_tag_t dmat = sc->sc_dmat;
+	struct bha_ccb *ccb;
+	int error, seg, flags, s;
+	int fromqueue = 0, dontqueue = 0;
+
+	SC_DEBUG(sc_link, SDEV_DB2, ("bha_scsi_cmd\n"));
+
+	s = splbio();		/* protect the queue */
+
+	/*
+	 * If we're running the queue from bha_done(), we've been
+	 * called with the first queue entry as our argument.
+	 */
+	if (xs == sc->sc_queue.lh_first) {
+		xs = bha_dequeue(sc);
+		fromqueue = 1;
+		goto get_ccb;
+	}
+
+	/* Polled requests can't be queued for later. */
+	dontqueue = xs->flags & SCSI_POLL;
+
+	/*
+	 * If there are jobs in the queue, run them first.
+	 */
+	if (sc->sc_queue.lh_first != NULL) {
+		/*
+		 * If we can't queue, we have to abort, since
+		 * we have to preserve order.
+		 */
+		if (dontqueue) {
+			splx(s);
+			xs->error = XS_DRIVER_STUFFUP;
+			return (TRY_AGAIN_LATER);
+		}
+
+		/*
+		 * Swap with the first queue entry.
+		 */
+		bha_enqueue(sc, xs, 0);
+		xs = bha_dequeue(sc);
+		fromqueue = 1;
+	}
+
+ get_ccb:
+	/*
+	 * get a ccb to use. If the transfer
+	 * is from a buf (possibly from interrupt time)
+	 * then we can't allow it to sleep
+	 */
+	flags = xs->flags;
+	if ((ccb = bha_get_ccb(sc, flags)) == NULL) {
+		/*
+		 * If we can't queue, we lose.
+		 */
+		if (dontqueue) {
+			splx(s);
+			xs->error = XS_DRIVER_STUFFUP;
+			return (TRY_AGAIN_LATER);
+		}
+
+		/*
+		 * Stuff ourselves into the queue, in front
+		 * if we came off in the first place.
+		 */
+		bha_enqueue(sc, xs, fromqueue);
+		splx(s);
+		return (SUCCESSFULLY_QUEUED);
+	}
+
+	splx(s);		/* done playing with the queue */
+
+	ccb->xs = xs;
+	ccb->timeout = xs->timeout;
+
+	/*
+	 * Put all the arguments for the xfer in the ccb
+	 */
+	if (flags & SCSI_RESET) {
+		ccb->opcode = BHA_RESET_CCB;
+		ccb->scsi_cmd_length = 0;
+	} else {
+		/* can't use S/G if zero length */
+		ccb->opcode = (xs->datalen ? BHA_INIT_SCAT_GATH_CCB
+					   : BHA_INITIATOR_CCB);
+		bcopy(xs->cmd, &ccb->scsi_cmd,
+		    ccb->scsi_cmd_length = xs->cmdlen);
+	}
+
+	if (xs->datalen) {
+		/*
+		 * Map the DMA transfer.
+		 */
+#ifdef TFS
+		if (flags & SCSI_DATA_UIO) {
+			error = bus_dmamap_load_uio(dmat,
+			    ccb->dmamap_xfer, (struct uio *)xs->data,
+			    (flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT :
+			    BUS_DMA_WAITOK);
+		} else
+#endif /* TFS */
+		{
+			error = bus_dmamap_load(dmat,
+			    ccb->dmamap_xfer, xs->data, xs->datalen, NULL,
+			    (flags & SCSI_NOSLEEP) ? BUS_DMA_NOWAIT :
+			    BUS_DMA_WAITOK);
+		}
+
+		if (error) {
+			if (error == EFBIG) {
+				printf("%s: bha_scsi_cmd, more than %d"
+				    " dma segments\n",
+				    sc->sc_dev.dv_xname, BHA_NSEG);
+			} else {
+				printf("%s: bha_scsi_cmd, error %d loading"
+				    " dma map\n",
+				    sc->sc_dev.dv_xname, error);
+			}
+			goto bad;
+		}
+
+		bus_dmamap_sync(dmat, ccb->dmamap_xfer,
+		    0, ccb->dmamap_xfer->dm_mapsize,
+		    (flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
+		    BUS_DMASYNC_PREWRITE);
+
+		/*
+		 * Load the hardware scatter/gather map with the
+		 * contents of the DMA map.
+		 */
+		for (seg = 0; seg < ccb->dmamap_xfer->dm_nsegs; seg++) {
+			ltophys(ccb->dmamap_xfer->dm_segs[seg].ds_addr,
+			    ccb->scat_gath[seg].seg_addr);
+			ltophys(ccb->dmamap_xfer->dm_segs[seg].ds_len,
+			    ccb->scat_gath[seg].seg_len);
+		}
+
+		ltophys(sc->sc_dmamap_control->dm_segs[0].ds_addr +
+		    BHA_CCB_OFF(ccb) + offsetof(struct bha_ccb, scat_gath),
+		    ccb->data_addr);
+		ltophys(ccb->dmamap_xfer->dm_nsegs *
+		    sizeof(struct bha_scat_gath), ccb->data_length);
+	} else {
+		/*
+		 * No data xfer, use non S/G values.
+		 */
+		ltophys(0, ccb->data_addr);
+		ltophys(0, ccb->data_length);
+	}
+
+	ccb->data_out = 0;
+	ccb->data_in = 0;
+	ccb->target = sc_link->target;
+	ccb->lun = sc_link->lun;
+	ltophys(sc->sc_dmamap_control->dm_segs[0].ds_addr +
+	    BHA_CCB_OFF(ccb) + offsetof(struct bha_ccb, scsi_sense),
+	    ccb->sense_ptr);
+	ccb->req_sense_length = sizeof(ccb->scsi_sense);
+	ccb->host_stat = 0x00;
+	ccb->target_stat = 0x00;
+	ccb->link_id = 0;
+	ltophys(0, ccb->link_addr);
+
+	bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_control,
+	    0, sc->sc_dmamap_control->dm_mapsize,
+	    BUS_DMASYNC_PREREAD|BUS_DMASYNC_PREWRITE);
+
+	s = splbio();
+	bha_queue_ccb(sc, ccb);
+	splx(s);
+
+	/*
+	 * Usually return SUCCESSFULLY QUEUED
+	 */
+	SC_DEBUG(sc_link, SDEV_DB3, ("cmd_sent\n"));
+	if ((flags & SCSI_POLL) == 0)
+		return (SUCCESSFULLY_QUEUED);
+
+	/*
+	 * If we can't use interrupts, poll on completion
+	 */
+	if (bha_poll(sc, xs, ccb->timeout)) {
+		bha_timeout(ccb);
+		if (bha_poll(sc, xs, ccb->timeout))
+			bha_timeout(ccb);
+	}
+	return (COMPLETE);
+
+bad:
+	xs->error = XS_DRIVER_STUFFUP;
+	bha_free_ccb(sc, ccb);
+	return (COMPLETE);
+}
+
+/*
+ * Poll a particular unit, looking for a particular xs
+ */
+int
+bha_poll(sc, xs, count)
+	struct bha_softc *sc;
+	struct scsi_xfer *xs;
+	int count;
+{
+	bus_space_tag_t iot = sc->sc_iot;
+	bus_space_handle_t ioh = sc->sc_ioh;
+
+	/* timeouts are in msec, so we loop in 1000 usec cycles */
+	while (count) {
+		/*
+		 * If we had interrupts enabled, would we
+		 * have got an interrupt?
+		 */
+		if (bus_space_read_1(iot, ioh, BHA_INTR_PORT) &
+		    BHA_INTR_ANYINTR)
+			bha_intr(sc);
+		if (xs->flags & ITSDONE)
+			return (0);
+		delay(1000);	/* only happens in boot so ok */
+		count--;
+	}
+	return (1);
+}
+
+void
+bha_timeout(arg)
+	void *arg;
+{
+	struct bha_ccb *ccb = arg;
+	struct scsi_xfer *xs = ccb->xs;
+	struct scsi_link *sc_link = xs->sc_link;
+	struct bha_softc *sc = sc_link->adapter_softc;
+	int s;
+
+	sc_print_addr(sc_link);
+	printf("timed out");
+
+	s = splbio();
+
+#ifdef BHADIAG
+	/*
+	 * If the ccb's mbx is not free, then the board has gone Far East?
+	 */
+	bha_collect_mbo(sc);
+	if (ccb->flags & CCB_SENDING) {
+		printf("%s: not taking commands!\n", sc->sc_dev.dv_xname);
+		Debugger();
+	}
+#endif
+
+	/*
+	 * If it has been through before, then
+	 * a previous abort has failed, don't
+	 * try abort again
+	 */
+	if (ccb->flags & CCB_ABORT) {
+		/* abort timed out */
+		printf(" AGAIN\n");
+		/* XXX Must reset! */
+	} else {
+		/* abort the operation that has timed out */
+		printf("\n");
+		ccb->xs->error = XS_TIMEOUT;
+		ccb->timeout = BHA_ABORT_TIMEOUT;
+		ccb->flags |= CCB_ABORT;
+		bha_queue_ccb(sc, ccb);
+	}
+
+	splx(s);
+}
diff --git a/sys/dev/ic/bhareg.h b/sys/dev/ic/bhareg.h
new file mode 100644
index 00000000000..11ff58cbda9
--- /dev/null
+++ b/sys/dev/ic/bhareg.h
@@ -0,0 +1,503 @@
+/*	$OpenBSD: bhareg.h,v 1.1 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bhareg.h,v 1.12 1998/08/17 00:26:33 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1997, 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
+ * Simulation Facility, NASA Ames Research Center.
+ *
+ * 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 FOUNDATION 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.
+ */
+
+/*
+ * Originally written by Julian Elischer (julian@tfs.com)
+ * for TRW Financial Systems for use under the MACH(2.5) operating system.
+ *
+ * TRW Financial Systems, in accordance with their agreement with Carnegie
+ * Mellon University, makes this software available to CMU to distribute
+ * or use in any manner that they see fit as long as this message is kept with
+ * the software. For this reason TFS also grants any other persons or
+ * organisations permission to use or modify this software.
+ *
+ * TFS supplies this software to be publicly redistributed
+ * on the understanding that TFS is not responsible for the correct
+ * functioning of this software in any circumstances.
+ */
+
+typedef u_int8_t physaddr[4];
+typedef u_int8_t physlen[4];
+#define	ltophys	_lto4l
+#define	phystol	_4ltol
+
+/*
+ * I/O port offsets
+ */
+#define	BHA_CTRL_PORT		0	/* control (wo) */
+#define	BHA_STAT_PORT		0	/* status (ro) */
+#define	BHA_CMD_PORT		1	/* command (wo) */
+#define	BHA_DATA_PORT		1	/* data (ro) */
+#define	BHA_INTR_PORT		2	/* interrupt status (ro) */
+#define	BHA_EXTGEOM_PORT	3	/* extended geometry (ro) */
+
+/*
+ * BHA_CTRL bits
+ */
+#define BHA_CTRL_HRST		0x80	/* Hardware reset */
+#define BHA_CTRL_SRST		0x40	/* Software reset */
+#define BHA_CTRL_IRST		0x20	/* Interrupt reset */
+#define BHA_CTRL_SCRST		0x10	/* SCSI bus reset */
+
+/*
+ * BHA_STAT bits
+ */
+#define BHA_STAT_STST		0x80	/* Self test in Progress */
+#define BHA_STAT_DIAGF		0x40	/* Diagnostic Failure */
+#define BHA_STAT_INIT		0x20	/* Mbx Init required */
+#define BHA_STAT_IDLE		0x10	/* Host Adapter Idle */
+#define BHA_STAT_CDF		0x08	/* cmd/data out port full */
+#define BHA_STAT_DF		0x04	/* Data in port full */
+#define BHA_STAT_INVDCMD	0x01	/* Invalid command */
+#define	BHA_STAT_BITS	"\020\1invcmd\3df\4cdf\5idle\6init\7diagf\10stst"
+
+/*
+ * BHA_CMD opcodes
+ */
+#define	BHA_NOP			0x00	/* No operation */
+#define BHA_MBX_INIT		0x01	/* Mbx initialization */
+#define BHA_START_SCSI		0x02	/* start scsi command */
+#define	BHA_EXECUTE_BIOS_CMD	0x03	/* execute BIOS command */
+#define BHA_INQUIRE_REVISION	0x04	/* Adapter Inquiry */
+#define BHA_MBO_INTR_EN		0x05	/* Enable MBO available interrupt */
+#define BHA_SEL_TIMEOUT_SET	0x06	/* set selection time-out */
+#define BHA_BUS_ON_TIME_SET	0x07	/* set bus-on time */
+#define BHA_BUS_OFF_TIME_SET	0x08	/* set bus-off time */
+#define BHA_BUS_SPEED_SET	0x09	/* set bus transfer speed */
+#define BHA_INQUIRE_DEVICES	0x0a	/* return installed devices 0-7 */
+#define BHA_INQUIRE_CONFIG	0x0b	/* return configuration data */
+#define BHA_TARGET_EN		0x0c	/* enable target mode */
+#define BHA_INQUIRE_SETUP	0x0d	/* return setup data */
+#define	BHA_WRITE_LRAM		0x1a	/* write adapter local RAM */
+#define	BHA_READ_LRAM		0x1b	/* read adapter local RAM */
+#define	BHA_WRITE_CHIP_FIFO	0x1c	/* write bus master chip FIFO */
+#define	BHA_READ_CHIP_FIFO	0x1d	/* read bus master chip FIFO */
+#define BHA_ECHO		0x1f	/* Echo command byte */
+#define	BHA_ADAPTER_DIAGNOSTICS	0x20	/* host adapter diagnostics */
+#define	BHA_SET_ADAPTER_OPTIONS	0x21	/* set adapter options */
+#define BHA_INQUIRE_DEVICES_2	0x23	/* return installed devices 8-15 */
+#define	BHA_INQUIRE_TARG_DEVS	0x24	/* inquire target devices */
+#define	BHA_DISABLE_HAC_INTR	0x25	/* disable host adapter interrupt */
+#define BHA_MBX_INIT_EXTENDED	0x81	/* Mbx initialization */
+#define	BHA_EXECUTE_SCSI_CMD	0x83	/* execute SCSI command */
+#define BHA_INQUIRE_REVISION_3	0x84	/* Get 3rd firmware version byte */
+#define BHA_INQUIRE_REVISION_4	0x85	/* Get 4th firmware version byte */
+#define	BHA_INQUIRE_PCI_INFO	0x86	/* get PCI host adapter information */
+#define BHA_INQUIRE_MODEL	0x8b	/* Get hardware ID and revision */
+#define	BHA_INQUIRE_PERIOD	0x8c	/* Get synchronous period */
+#define BHA_INQUIRE_EXTENDED	0x8d	/* Adapter Setup Inquiry */
+#define	BHA_ROUND_ROBIN		0x8f	/* Enable/Disable(default)
+					   round robin */
+#define	BHA_STORE_LRAM		0x90	/* store host adapter local RAM */
+#define	BHA_FETCH_LRAM		0x91	/* fetch host adapter local RAM */
+#define	BHA_SAVE_TO_EEPROM	0x92	/* store local RAM data in EEPROM */
+#define	BHA_UPLOAD_AUTOSCSI	0x94	/* upload AutoSCSI code */
+#define BHA_MODIFY_IOPORT	0x95	/* change or disable I/O port */
+#define	BHA_SET_CCB_FORMAT	0x96	/* set CCB format (legacy/wide lun) */
+#define	BHA_WRITE_INQUIRY_BUF	0x9a	/* write inquiry buffer */
+#define	BHA_READ_INQUIRY_BUF	0x9b	/* read inquiry buffer */
+#define	BHA_FLASH_UP_DOWNLOAD	0xa7	/* flash upload/downlod */
+#define	BHA_READ_SCAM_DATA	0xa8	/* read SCAM data */
+#define	BHA_WRITE_SCAM_DATA	0xa9	/* write SCAM data */
+
+/*
+ * BHA_INTR bits
+ */
+#define BHA_INTR_ANYINTR	0x80	/* Any interrupt */
+#define BHA_INTR_SCRD		0x08	/* SCSI reset detected */
+#define BHA_INTR_HACC		0x04	/* Command complete */
+#define BHA_INTR_MBOA		0x02	/* MBX out empty */
+#define BHA_INTR_MBIF		0x01	/* MBX in full */
+
+#pragma pack(1)
+
+struct bha_mbx_out {
+	physaddr ccb_addr;
+	u_int8_t reserved[3];
+	u_int8_t cmd;
+};
+
+struct bha_mbx_in {
+	physaddr ccb_addr;
+	u_int8_t host_stat;
+	u_int8_t target_stat;
+	u_int8_t reserved;
+	u_int8_t comp_stat;
+};
+
+/*
+ * mbo.cmd values
+ */
+#define BHA_MBO_FREE	0x0	/* MBO entry is free */
+#define BHA_MBO_START	0x1	/* MBO activate entry */
+#define BHA_MBO_ABORT	0x2	/* MBO abort entry */
+
+/*
+ * mbi.comp_stat values
+ */
+#define BHA_MBI_FREE	0x0	/* MBI entry is free */
+#define BHA_MBI_OK	0x1	/* completed without error */
+#define BHA_MBI_ABORT	0x2	/* aborted ccb */
+#define BHA_MBI_UNKNOWN	0x3	/* Tried to abort invalid CCB */
+#define BHA_MBI_ERROR	0x4	/* Completed with error */
+
+#if	defined(BIG_DMA)
+WARNING...THIS WON'T WORK(won't fit on 1 page)
+#if 0
+#define      BHA_NSEG 2048    /* Number of scatter gather segments - to much vm */
+#endif
+#define	BHA_NSEG	128
+#else
+#define	BHA_NSEG	33
+#endif /* BIG_DMA */
+
+struct bha_scat_gath {
+	physlen seg_len;
+	physaddr seg_addr;
+};
+
+struct bha_ccb {
+	u_int8_t	opcode;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	u_int8_t				:3,
+			data_in			:1,
+			data_out		:1,
+			wide_tag_enable		:1, /* Wide Lun CCB format */
+			wide_tag_type		:2; /* Wide Lun CCB format */
+#else
+	u_int8_t	wide_tag_type		:2, /* Wide Lun CCB format */
+			wide_tag_enable		:1, /* Wide Lun CCB format */
+			data_out		:1,
+			data_in			:1,
+						:3;
+#endif
+	u_int8_t	scsi_cmd_length;
+	u_int8_t	req_sense_length;
+	/*------------------------------------longword boundary */
+	physlen data_length;
+	/*------------------------------------longword boundary */
+	physaddr data_addr;
+	/*------------------------------------longword boundary */
+	u_int8_t	reserved1[2];
+	u_int8_t	host_stat;
+	u_int8_t	target_stat;
+	/*------------------------------------longword boundary */
+	u_int8_t	target;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	u_int8_t	lun			:5,
+			tag_enable		:1,
+			tag_type		:2;
+#else
+	u_int8_t	tag_type		:2,
+			tag_enable		:1,
+			lun			:5;
+#endif
+	struct scsi_generic scsi_cmd;
+	u_int8_t	reserved2[1];
+	u_int8_t	link_id;
+	/*------------------------------------longword boundary */
+	physaddr link_addr;
+	/*------------------------------------longword boundary */
+	physaddr sense_ptr;
+/*-----end of HW fields-----------------------longword boundary */
+	struct scsi_sense_data scsi_sense;
+	/*------------------------------------longword boundary */
+	struct bha_scat_gath scat_gath[BHA_NSEG];
+	/*------------------------------------longword boundary */
+	TAILQ_ENTRY(bha_ccb) chain;
+	struct bha_ccb *nexthash;
+	bus_addr_t	hashkey;
+
+	struct scsi_xfer *xs;		/* the scsipi_xfer for this cmd */
+
+	int flags;
+#define	CCB_ALLOC	0x01
+#define	CCB_ABORT	0x02
+#ifdef BHADIAG
+#define	CCB_SENDING	0x04
+#endif
+	int timeout;
+
+	/*
+	 * This DMA map maps the buffer involved in the transfer.
+	 * Its contents are loaded into "scat_gath" above.
+	 */
+	bus_dmamap_t	dmamap_xfer;
+};
+
+/*
+ * opcode fields
+ */
+#define BHA_INITIATOR_CCB	0x00	/* SCSI Initiator CCB */
+#define BHA_TARGET_CCB		0x01	/* SCSI Target CCB */
+#define BHA_INIT_SCAT_GATH_CCB	0x02	/* SCSI Initiator with S/G */
+#define	BHA_INIT_RESID_CCB	0x03	/* SCSI Initiator w/ residual */
+#define	BHA_INIT_RESID_SG_CCB	0x04	/* SCSI Initiator w/ residual and S/G */
+#define BHA_RESET_CCB		0x81	/* SCSI Bus reset */
+
+/*
+ * bha_ccb.host_stat values
+ */
+#define BHA_OK		0x00	/* cmd ok */
+#define BHA_LINK_OK	0x0a	/* Link cmd ok */
+#define BHA_LINK_IT	0x0b	/* Link cmd ok + int */
+#define	BHA_DATA_UNDRN		0x0c	/* data underrun error */
+#define BHA_SEL_TIMEOUT	0x11	/* Selection time out */
+#define BHA_OVER_UNDER	0x12	/* Data over/under run */
+#define BHA_BUS_FREE	0x13	/* Bus dropped at unexpected time */
+#define BHA_INV_BUS	0x14	/* Invalid bus phase/sequence */
+#define BHA_BAD_MBO	0x15	/* Incorrect MBO cmd */
+#define BHA_BAD_CCB	0x16	/* Incorrect ccb opcode */
+#define BHA_BAD_LINK	0x17	/* Not same values of LUN for links */
+#define BHA_INV_TARGET	0x18	/* Invalid target direction */
+#define BHA_CCB_DUP	0x19	/* Duplicate CCB received */
+#define BHA_INV_CCB	0x1a	/* Invalid CCB or segment list */
+#define	BHA_AUTOSENSE_FAILED	0x1b	/* auto REQUEST SENSE failed */
+#define	BHA_TAGGED_MSG_REJ	0x1c	/* tagged queueing message rejected */
+#define	BHA_UNSUP_MSG_RECVD	0x1d	/* unsupported message received */
+#define	BHA_HARDWARE_FAILURE	0x20	/* host adapter hardware failure */
+#define	BHA_TARG_IGNORED_ATN	0x21	/* target ignored ATN signal */
+#define	BHA_HA_SCSI_BUS_RESET	0x22	/* host adapter asserted RST */
+#define	BHA_OTHER_SCSI_BUS_RESET 0x23	/* other device asserted RST */
+#define	BHA_BAD_RECONNECT	0x24	/* target reconnected improperly */
+#define	BHA_HA_BUS_DEVICE_RESET	0x25	/* host adapter performed BDR */
+#define	BHA_ABORT_QUEUE		0x26	/* abort queue generated */
+#define	BHA_SOFTWARE_FAILURE	0x27	/* host adapter software failure */
+#define	BHA_HARDWARE_WATCHDOG	0x30	/* host adapter watchdog timer fired */
+#define	BHA_SCSI_PARITY_ERROR	0x34	/* SCSI parity error detected */
+
+struct bha_extended_inquire {
+	struct {
+		u_char	opcode;
+		u_char	len;
+	} cmd;
+	struct {
+		u_char	bus_type;	/* Type of bus connected to */
+#define	BHA_BUS_TYPE_24BIT	'A'	/* ISA bus */
+#define	BHA_BUS_TYPE_32BIT	'E'	/* EISA/VLB/PCI bus */
+#define	BHA_BUS_TYPE_MCA	'M'	/* MicroChannel bus */
+		u_char	bios_address;	/* Address of adapter BIOS */
+		u_short sg_limit;
+		u_char	mbox_count;
+		u_char	mbox_baseaddr[4]; /* packed/unaligned u_int32_t */
+		u_char	intrflags;
+#define	BHA_INTR_FASTEISA	0x04
+#define BHA_INTR_LEVEL	0x40		/* bit 6: level-sensitive interrupt */
+		u_char	firmware_level[3]; /* last 3 digits of firmware rev */
+		u_char	scsi_flags;	/* supported SCSI  features */
+#define BHA_SCSI_WIDE		0x01	/* host adapter is wide */
+#define BHA_SCSI_DIFFERENTIAL	0x02	/* host adapter is differential */
+#define BHA_SCSI_SCAM		0x04	/* host adapter supports SCAM */
+#define BHA_SCSI_ULTRA		0x08	/* host adapter supports Ultra */
+#define BHA_SCSI_TERMINATION	0x10	/* host adapter supports smart
+					   termination */
+	} reply;
+};
+
+struct bha_config {
+	struct {
+		u_char	opcode;
+	} cmd;
+	struct {
+		u_char  chan;
+		u_char  intr;
+#if BYTE_ORDER == LITTLE_ENDIAN
+		u_char  scsi_dev :3,
+				 :5;
+#else
+		u_char		 :5,
+			scsi_dev :3;
+#endif
+	} reply;
+};
+
+struct bha_toggle {
+	struct {
+		u_char	opcode;
+		u_char	enable;
+	} cmd;
+};
+
+struct bha_mailbox {
+	struct {
+		u_char	opcode;
+		u_char	nmbx;
+		physaddr addr;
+	} cmd;
+};
+
+struct bha_model {
+	struct {
+		u_char	opcode;
+		u_char	len;
+	} cmd;
+	struct {
+		u_char	id[4];		/* i.e bt742a -> '7','4','2','A' */
+		u_char	version[2];	/* i.e Board Revision 'H' -> 'H', 0x00 */
+	} reply;
+};
+
+struct bha_revision {
+	struct {
+		u_char	opcode;
+	} cmd;
+	struct {
+		u_char  board_type;
+		u_char  custom_feature;
+		char    firm_revision;
+		u_char  firm_version;
+	} reply;
+};
+
+struct bha_digit {
+	struct {
+		u_char	opcode;
+	} cmd;
+	struct {
+		u_char  digit;
+	} reply;
+};
+
+struct bha_devices {
+	struct {
+		u_char	opcode;
+	} cmd;
+	struct {
+		u_char	lun_map[8];
+	} reply;
+};
+
+struct bha_sync {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	u_char	offset	:4,
+		period	:3,
+		valid	:1;
+#else
+	u_char	valid	:1,
+		period	:3,
+		offset	:4;
+#endif
+};
+
+struct bha_setup_reply {
+#if BYTE_ORDER == LITTLE_ENDIAN
+	u_int8_t	sync_neg	:1,
+			parity		:1,
+					:6;
+#else
+	u_int8_t			:6,
+			parity		:1,
+			sync_neg	:1;
+#endif
+	u_int8_t	speed;
+	u_int8_t	bus_on;
+	u_int8_t	bus_off;
+	u_int8_t	num_mbx;
+	u_int8_t	mbx[3];		/*XXX */
+	/* doesn't make sense with 32bit addresses */
+	struct bha_sync	sync[8];
+	u_int8_t	disc_sts;
+};
+
+/* additional reply data supplied by wide controlers */
+struct bha_setup_reply_wide {
+	u_int8_t	signature;
+	u_int8_t	letter_d;
+	u_int8_t	ha_type;
+	u_int8_t	low_wide_allowed;
+	u_int8_t	low_wide_active;
+	struct bha_sync	sync_high[8];
+	u_int8_t	high_disc_info;
+	u_int8_t	reserved;
+	u_int8_t	high_wide_allowed;
+	u_int8_t	high_wide_active;
+};
+
+struct bha_setup {
+	struct {
+		u_char	opcode;
+		u_char	len;
+	} cmd;
+	struct bha_setup_reply reply;
+	struct bha_setup_reply_wide reply_w;	/* for wide controllers */
+};
+
+struct bha_period_reply {
+	u_char	period[8];
+};
+
+struct bha_period {
+	struct {
+		u_char	opcode;
+		u_char	len;
+	} cmd;
+	struct bha_period_reply reply;
+	struct bha_period_reply reply_w;	/* for wide controllers */
+};
+
+struct bha_isadisable {
+	struct {
+		u_char	opcode;
+		u_char	modifier;
+	} cmd;
+};
+
+#pragma pack()
+
+/*
+ * bha_isadisable.modifier parameters
+ */
+#define BHA_IOMODIFY_330	0x00
+#define BHA_IOMODIFY_334	0x01
+#define BHA_IOMODIFY_DISABLE1	0x06
+#define BHA_IOMODIFY_DISABLE2	0x07
+
+#define INT9	0x01
+#define INT10	0x02
+#define INT11	0x04
+#define INT12	0x08
+#define INT14	0x20
+#define INT15	0x40
+
+#define EISADMA	0x00
+#define CHAN0	0x01
+#define CHAN5	0x20
+#define CHAN6	0x40
+#define CHAN7	0x80
diff --git a/sys/dev/ic/bhavar.h b/sys/dev/ic/bhavar.h
new file mode 100644
index 00000000000..3d5b763de78
--- /dev/null
+++ b/sys/dev/ic/bhavar.h
@@ -0,0 +1,135 @@
+/*	$OpenBSD: bhavar.h,v 1.1 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bhavar.h,v 1.12 1998/11/19 21:53:00 thorpej Exp $	*/
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum and by Jason R. Thorpe of the Numerical Aerospace
+ * Simulation Facility, NASA Ames Research Center.
+ *
+ * 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 FOUNDATION 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/queue.h>
+
+/*
+ * Mail box defs  etc.
+ * these could be bigger but we need the bha_softc to fit on a single page..
+ */
+#define BHA_MBX_SIZE	32	/* mail box size  (MAX 255 MBxs) */
+				/* don't need that many really */
+#define BHA_CCB_MAX	32	/* store up to 32 CCBs at one time */
+#define	CCB_HASH_SIZE	32	/* hash table size for phystokv */
+#define	CCB_HASH_SHIFT	9
+#define CCB_HASH(x)	((((long)(x))>>CCB_HASH_SHIFT) & (CCB_HASH_SIZE - 1))
+
+#define bha_nextmbx(wmb, mbx, mbio) \
+	if ((wmb) == &(mbx)->mbio[BHA_MBX_SIZE - 1])	\
+		(wmb) = &(mbx)->mbio[0];		\
+	else						\
+		(wmb)++;
+
+struct bha_mbx {
+	struct bha_mbx_out mbo[BHA_MBX_SIZE];
+	struct bha_mbx_in mbi[BHA_MBX_SIZE];
+	struct bha_mbx_out *cmbo;	/* Collection Mail Box out */
+	struct bha_mbx_out *tmbo;	/* Target Mail Box out */
+	struct bha_mbx_in *tmbi;	/* Target Mail Box in */
+};
+
+struct bha_control {
+	struct bha_mbx bc_mbx;		/* all our mailboxes */
+	struct bha_ccb bc_ccbs[BHA_CCB_MAX]; /* all our control blocks */
+};
+
+struct bha_softc {
+	struct device sc_dev;
+
+	bus_space_tag_t sc_iot;
+	bus_space_handle_t sc_ioh;
+	bus_dma_tag_t sc_dmat;
+	bus_dmamap_t sc_dmamap_control;	/* maps the control structures */
+	int sc_dmaflags;		/* bus-specific dma map flags */
+	void *sc_ih;
+
+	struct bha_control *sc_control;	/* control structures */
+	int sc_iswide;
+
+#define	wmbx	(&sc->sc_control->bc_mbx)
+
+	struct bha_ccb *sc_ccbhash[CCB_HASH_SIZE];
+	TAILQ_HEAD(, bha_ccb) sc_free_ccb, sc_waiting_ccb;
+	int sc_mbofull;
+	struct scsi_link sc_link;	/* prototype for devs */
+	struct scsi_adapter sc_adapter;
+
+	LIST_HEAD(, scsi_xfer) sc_queue;
+	struct scsi_xfer *sc_queuelast;
+
+	char sc_model[7],
+	     sc_firmware[6];
+};
+
+/*
+ * Offset of a Mail Box In from the beginning of the control DMA mapping.
+ */
+#define	BHA_MBI_OFF(m)	(offsetof(struct bha_control, bc_mbx.mbi[0]) +	\
+			    (((u_long)(m)) - ((u_long)&wmbx->mbi[0])))
+
+/*
+ * Offset of a Mail Box Out from the beginning of the control DMA mapping.
+ */
+#define	BHA_MBO_OFF(m)	(offsetof(struct bha_control, bc_mbx.mbo[0]) +	\
+			    (((u_long)(m)) - ((u_long)&wmbx->mbo[0])))
+
+/*
+ * Offset of a CCB from the beginning of the control DMA mapping.
+ */
+#define	BHA_CCB_OFF(c)	(offsetof(struct bha_control, bc_ccbs[0]) +	\
+		    (((u_long)(c)) - ((u_long)&sc->sc_control->bc_ccbs[0])))
+
+struct bha_probe_data {
+	int sc_irq, sc_drq;
+	int sc_scsi_dev;		/* adapters scsi id */
+	int sc_iswide;			/* adapter is wide */
+};
+
+/*#define	ISWIDE(sc)	(sc->sc_link.max_target >= 8)*/
+
+int	bha_cmd __P((bus_space_tag_t, bus_space_handle_t, struct bha_softc *,
+	    int, u_char *, int, u_char *));
+int	bha_find __P((bus_space_tag_t, bus_space_handle_t,
+	    struct bha_probe_data *));
+void	bha_attach __P((struct bha_softc *, struct bha_probe_data *));
+int	bha_intr __P((void *));
+
+int	bha_disable_isacompat __P((struct bha_softc *));
+void	bha_inquire_setup_information __P((struct bha_softc *));
diff --git a/sys/dev/isa/aha.c b/sys/dev/isa/aha.c
index d7fbda87ccb..fbc80a59965 100644
--- a/sys/dev/isa/aha.c
+++ b/sys/dev/isa/aha.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: aha.c,v 1.41 2001/12/08 02:24:07 art Exp $	*/
+/*	$OpenBSD: aha.c,v 1.42 2002/01/24 22:38:03 mickey Exp $	*/
 /*	$NetBSD: aha.c,v 1.11 1996/05/12 23:51:23 mycroft Exp $	*/
 
 #undef AHADIAG
@@ -193,7 +193,7 @@ struct cfdriver aha_cd = {
 #define AHA_RESET_TIMEOUT	2000	/* time to wait for reset (mSec) */
 #define	AHA_ABORT_TIMEOUT	2000	/* time to wait for abort (mSec) */
 
-#include "bt.h"
+#include "bha.h"
 
 /*
  * aha_cmd(iobase, sc, icnt, ibuf, ocnt, obuf)
@@ -348,7 +348,7 @@ ahaprobe(parent, match, aux)
 	void *match, *aux;
 {
 	register struct isa_attach_args *ia = aux;
-#if NBT > 0
+#if NBHA > 0
 	extern int btports[], nbtports;
 	int i;
 
diff --git a/sys/dev/isa/bha_isa.c b/sys/dev/isa/bha_isa.c
new file mode 100644
index 00000000000..a920acf974a
--- /dev/null
+++ b/sys/dev/isa/bha_isa.c
@@ -0,0 +1,200 @@
+/*	$OpenBSD: bha_isa.c,v 1.1 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bha_isa.c,v 1.14 1998/08/15 10:10:51 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum.
+ *
+ * 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 FOUNDATION 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/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+
+#include <machine/bus.h>
+#include <machine/intr.h>
+
+#include <scsi/scsi_all.h>
+#include <scsi/scsiconf.h>
+
+#include <dev/isa/isavar.h>
+#include <dev/isa/isadmavar.h>
+
+#include <dev/ic/bhareg.h>
+#include <dev/ic/bhavar.h>
+
+#include "aha.h"
+#if NAHA > 0
+int btports[8];	/* cannot be more */
+int nbtports;
+#endif
+
+#define	BHA_ISA_IOSIZE	4
+
+int	bha_isa_probe __P((struct device *, void *, void *));
+void	bha_isa_attach __P((struct device *, struct device *, void *));
+
+struct cfattach bha_isa_ca = {
+	sizeof(struct bha_softc), bha_isa_probe, bha_isa_attach
+};
+
+/*
+ * Check the slots looking for a board we recognise
+ * If we find one, note it's address (slot) and call
+ * the actual probe routine to check it out.
+ */
+int
+bha_isa_probe(parent, match, aux)
+	struct device *parent;
+	void *aux, *match;
+{
+	struct isa_attach_args *ia = aux;
+	bus_space_tag_t iot = ia->ia_iot;
+	bus_space_handle_t ioh;
+	struct bha_probe_data bpd;
+#if NAHA > 0
+	struct bha_digit digit; 
+#endif
+	int rv;
+
+	/* Disallow wildcarded i/o address. */
+	if (ia->ia_iobase == IOBASEUNK)
+		return (0);
+
+	if (bus_space_map(iot, ia->ia_iobase, BHA_ISA_IOSIZE, 0, &ioh))
+		return (0);
+
+	rv = bha_find(iot, ioh, &bpd);
+
+#if NAHA > 0
+	if (rv) {
+		/* Adaptec 1542 cards do not support this */
+		digit.reply.digit = '@';
+		digit.cmd.opcode = BHA_INQUIRE_REVISION_3;
+		bha_cmd(iot, ioh, NULL, sizeof(digit.cmd), (u_char *)&digit.cmd,
+		    sizeof(digit.reply), (u_char *)&digit.reply);
+		if (digit.reply.digit == '@')
+			return 1;
+	}
+#endif
+
+	bus_space_unmap(iot, ioh, BHA_ISA_IOSIZE);
+
+	if (rv) {
+		if (ia->ia_irq != -1 && ia->ia_irq != bpd.sc_irq)
+			return (0);
+		if (ia->ia_drq != -1 && ia->ia_drq != bpd.sc_drq)
+			return (0);
+		ia->ia_irq = bpd.sc_irq;
+		ia->ia_drq = bpd.sc_drq;
+		ia->ia_msize = 0;
+		ia->ia_iosize = BHA_ISA_IOSIZE;
+	}
+	return (rv);
+}
+
+/*
+ * Attach all the sub-devices we can find
+ */
+void
+bha_isa_attach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct isa_attach_args *ia = aux;
+	struct bha_softc *sc = (void *)self;
+	bus_space_tag_t iot = ia->ia_iot;
+	bus_space_handle_t ioh;
+	struct bha_probe_data bpd;
+	isa_chipset_tag_t ic = ia->ia_ic;
+#ifndef __OpenBSD__
+	int error;
+#endif
+
+	printf("\n");
+
+	if (bus_space_map(iot, ia->ia_iobase, ia->ia_iosize, 0, &ioh)) {
+		printf("%s: can't map i/o space\n", sc->sc_dev.dv_xname);
+		return;
+	}
+
+	sc->sc_iot = iot;
+	sc->sc_ioh = ioh;
+	sc->sc_dmat = ia->ia_dmat;
+	if (!bha_find(iot, ioh, &bpd)) {
+		printf("%s: bha_find failed\n", sc->sc_dev.dv_xname);
+		return;
+	}
+
+	sc->sc_dmaflags = 0;
+	if (bpd.sc_drq != DRQUNK) {
+#ifdef __OpenBSD__
+		isa_dmacascade(ic, bpd.sc_drq);
+#else
+		if ((error = isa_dmacascade(ic, bpd.sc_drq)) != 0) {
+			printf("%s: unable to cascade DRQ, error = %d\n",
+			    sc->sc_dev.dv_xname, error);
+			return;
+		}
+#endif
+	} else {
+		/*
+		 * We have a VLB controller.  If we're at least both
+		 * hardware revision E and firmware revision 3.37,
+		 * we can do 32-bit DMA (earlier revisions are buggy
+		 * in this regard).
+		 */
+		bha_inquire_setup_information(sc);
+		if (strcmp(sc->sc_firmware, "3.37") < 0)
+		    printf("%s: buggy VLB controller, disabling 32-bit DMA\n",
+		        sc->sc_dev.dv_xname);
+		else
+			sc->sc_dmaflags = ISABUS_DMA_32BIT;
+	}
+
+	sc->sc_ih = isa_intr_establish(ic, bpd.sc_irq, IST_EDGE, IPL_BIO,
+	    bha_intr, sc, sc->sc_dev.dv_xname);
+	if (sc->sc_ih == NULL) {
+		printf("%s: couldn't establish interrupt\n",
+		    sc->sc_dev.dv_xname);
+		return;
+	}
+
+	bha_attach(sc, &bpd);
+
+#if NAHA > 0
+	/* XXXX To avoid conflicting with the aha1542 probe */
+	btports[nbtports++] = ia->ia_iobase;
+#endif
+}
diff --git a/sys/dev/isa/bt.c b/sys/dev/isa/bt.c
deleted file mode 100644
index fa964e8736e..00000000000
--- a/sys/dev/isa/bt.c
+++ /dev/null
@@ -1,1347 +0,0 @@
-/*	$OpenBSD: bt.c,v 1.24 2001/01/29 07:17:00 mickey Exp $	*/
-/*	$NetBSD: bt.c,v 1.10 1996/05/12 23:51:54 mycroft Exp $	*/
-
-#undef BTDIAG
-#define integrate
-
-/*
- * Copyright (c) 1994, 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.
- */
-
-/*
- * Originally written by Julian Elischer (julian@tfs.com)
- * for TRW Financial Systems for use under the MACH(2.5) operating system.
- *
- * TRW Financial Systems, in accordance with their agreement with Carnegie
- * Mellon University, makes this software available to CMU to distribute
- * or use in any manner that they see fit as long as this message is kept with
- * the software. For this reason TFS also grants any other persons or
- * organisations permission to use or modify this software.
- *
- * TFS supplies this software to be publicly redistributed
- * on the understanding that TFS is not responsible for the correct
- * functioning of this software in any circumstances.
- */
-
-#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 <machine/intr.h>
-#include <machine/pio.h>
-
-#include <scsi/scsi_all.h>
-#include <scsi/scsiconf.h>
-
-#include <dev/isa/isavar.h>
-#include <dev/isa/isadmavar.h>
-#include <dev/isa/btreg.h>
-
-#ifndef DDB
-#define Debugger() panic("should call debugger here (bt742a.c)")
-#endif /* ! DDB */
-
-/*
- * Mail box defs  etc.
- * these could be bigger but we need the bt_softc to fit on a single page..
- */
-#define BT_MBX_SIZE	32	/* mail box size  (MAX 255 MBxs) */
-				/* don't need that many really */
-#define BT_CCB_MAX	32	/* store up to 32 CCBs at one time */
-#define	CCB_HASH_SIZE	32	/* hash table size for phystokv */
-#define	CCB_HASH_SHIFT	9
-#define CCB_HASH(x)	((((long)(x))>>CCB_HASH_SHIFT) & (CCB_HASH_SIZE - 1))
-
-#define bt_nextmbx(wmb, mbx, mbio) \
-	if ((wmb) == &(mbx)->mbio[BT_MBX_SIZE - 1])	\
-		(wmb) = &(mbx)->mbio[0];		\
-	else						\
-		(wmb)++;
-
-struct bt_mbx {
-	struct bt_mbx_out mbo[BT_MBX_SIZE];
-	struct bt_mbx_in mbi[BT_MBX_SIZE];
-	struct bt_mbx_out *cmbo;	/* Collection Mail Box out */
-	struct bt_mbx_out *tmbo;	/* Target Mail Box out */
-	struct bt_mbx_in *tmbi;		/* Target Mail Box in */
-};
-
-#define KVTOPHYS(x)	vtophys(x)
-
-#include "aha.h"
-#include "bt.h"
-#if NAHA > 0
-int btports[NBT];
-int nbtports;
-#endif
-
-struct bt_softc {
-	struct device sc_dev;
-	struct isadev sc_id;
-	void *sc_ih;
-
-	int sc_iobase;
-	int sc_irq, sc_drq;
-
-	char sc_model[7],
-	     sc_firmware[6];
-
-	struct bt_mbx sc_mbx;		/* all our mailboxes */
-#define	wmbx	(&sc->sc_mbx)
-	struct bt_ccb *sc_ccbhash[CCB_HASH_SIZE];
-	TAILQ_HEAD(, bt_ccb) sc_free_ccb, sc_waiting_ccb;
-	int sc_numccbs, sc_mbofull;
-	int sc_scsi_dev;		/* adapters scsi id */
-	struct scsi_link sc_link;	/* prototype for devs */
-};
-
-#ifdef BTDEBUG
-int     bt_debug = 0;
-#endif /* BTDEBUG */
-
-int bt_cmd __P((int, struct bt_softc *, int, u_char *, int, u_char *));
-integrate void bt_finish_ccbs __P((struct bt_softc *));
-int btintr __P((void *));
-integrate void bt_reset_ccb __P((struct bt_softc *, struct bt_ccb *));
-void bt_free_ccb __P((struct bt_softc *, struct bt_ccb *));
-integrate void bt_init_ccb __P((struct bt_softc *, struct bt_ccb *));
-struct bt_ccb *bt_get_ccb __P((struct bt_softc *, int));
-struct bt_ccb *bt_ccb_phys_kv __P((struct bt_softc *, u_long));
-void bt_queue_ccb __P((struct bt_softc *, struct bt_ccb *));
-void bt_collect_mbo __P((struct bt_softc *));
-void bt_start_ccbs __P((struct bt_softc *));
-void bt_done __P((struct bt_softc *, struct bt_ccb *));
-int bt_find __P((struct isa_attach_args *, struct bt_softc *));
-void bt_init __P((struct bt_softc *));
-void bt_inquire_setup_information __P((struct bt_softc *));
-void btminphys __P((struct buf *));
-int bt_scsi_cmd __P((struct scsi_xfer *));
-int bt_poll __P((struct bt_softc *, struct scsi_xfer *, int));
-void bt_timeout __P((void *arg));
-
-struct scsi_adapter bt_switch = {
-	bt_scsi_cmd,
-	btminphys,
-	0,
-	0,
-};
-
-/* the below structure is so we have a default dev struct for out link struct */
-struct scsi_device bt_dev = {
-	NULL,			/* Use default error handler */
-	NULL,			/* have a queue, served by this */
-	NULL,			/* have no async handler */
-	NULL,			/* Use default 'done' routine */
-};
-
-int	btprobe __P((struct device *, void *, void *));
-void	btattach __P((struct device *, struct device *, void *));
-
-struct cfattach bt_ca = {
-	sizeof(struct bt_softc), btprobe, btattach
-};
-
-struct cfdriver bt_cd = {
-	NULL, "bt", DV_DULL
-};
-
-#define BT_RESET_TIMEOUT	2000	/* time to wait for reset (mSec) */
-#define	BT_ABORT_TIMEOUT	2000	/* time to wait for abort (mSec) */
-
-/*
- * bt_cmd(iobase, sc, icnt, ibuf, ocnt, obuf)
- *
- * Activate Adapter command
- *    icnt:   number of args (outbound bytes including opcode)
- *    ibuf:   argument buffer
- *    ocnt:   number of expected returned bytes
- *    obuf:   result buffer
- *    wait:   number of seconds to wait for response
- *
- * Performs an adapter command through the ports.  Not to be confused with a
- * scsi command, which is read in via the dma; one of the adapter commands
- * tells it to read in a scsi command.
- */
-int
-bt_cmd(iobase, sc, icnt, ibuf, ocnt, obuf)
-	int iobase;
-	struct bt_softc *sc;
-	int icnt, ocnt;
-	u_char *ibuf, *obuf;
-{
-	const char *name;
-	register int i;
-	int wait;
-	u_char sts;
-	u_char opcode = ibuf[0];
-
-	if (sc != NULL)
-		name = sc->sc_dev.dv_xname;
-	else
-		name = "(bt probe)";
-
-	/*
-	 * Calculate a reasonable timeout for the command.
-	 */
-	switch (opcode) {
-	case BT_INQUIRE_DEVICES:
-		wait = 15 * 20000;
-		break;
-	default:
-		wait = 1 * 20000;
-		break;
-	}
-
-	/*
-	 * Wait for the adapter to go idle, unless it's one of
-	 * the commands which don't need this
-	 */
-	if (opcode != BT_MBO_INTR_EN) {
-		for (i = 20000; i; i--) {	/* 1 sec? */
-			sts = inb(iobase + BT_STAT_PORT);
-			if (sts & BT_STAT_IDLE)
-				break;
-			delay(50);
-		}
-		if (!i) {
-			printf("%s: bt_cmd, host not idle(0x%x)\n",
-			    name, sts);
-			return ENXIO;
-		}
-	}
-	/*
-	 * Now that it is idle, if we expect output, preflush the
-	 * queue feeding to us.
-	 */
-	if (ocnt) {
-		while ((inb(iobase + BT_STAT_PORT)) & BT_STAT_DF)
-			inb(iobase + BT_DATA_PORT);
-	}
-	/*
-	 * Output the command and the number of arguments given
-	 * for each byte, first check the port is empty.
-	 */
-	while (icnt--) {
-		for (i = wait; i; i--) {
-			sts = inb(iobase + BT_STAT_PORT);
-			if (!(sts & BT_STAT_CDF))
-				break;
-			delay(50);
-		}
-		if (!i) {
-			if (opcode != BT_INQUIRE_REVISION &&
-			    opcode != BT_INQUIRE_REVISION_3)
-				printf("%s: bt_cmd, cmd/data port full\n", name);
-			outb(iobase + BT_CTRL_PORT, BT_CTRL_SRST);
-			return ENXIO;
-		}
-		outb(iobase + BT_CMD_PORT, *ibuf++);
-	}
-	/*
-	 * If we expect input, loop that many times, each time,
-	 * looking for the data register to have valid data
-	 */
-	while (ocnt--) {
-		for (i = wait; i; i--) {
-			sts = inb(iobase + BT_STAT_PORT);
-			if (sts & BT_STAT_DF)
-				break;
-			delay(50);
-		}
-		if (!i) {
-			if (opcode != BT_INQUIRE_REVISION &&
-			    opcode != BT_INQUIRE_REVISION_3)
-				printf("%s: bt_cmd, cmd/data port empty %d\n",
-				    name, ocnt);
-			outb(iobase + BT_CTRL_PORT, BT_CTRL_SRST);
-			return ENXIO;
-		}
-		*obuf++ = inb(iobase + BT_DATA_PORT);
-	}
-	/*
-	 * Wait for the board to report a finished instruction.
-	 * We may get an extra interrupt for the HACC signal, but this is
-	 * unimportant.
-	 */
-	if (opcode != BT_MBO_INTR_EN) {
-		for (i = 20000; i; i--) {	/* 1 sec? */
-			sts = inb(iobase + BT_INTR_PORT);
-			/* XXX Need to save this in the interrupt handler? */
-			if (sts & BT_INTR_HACC)
-				break;
-			delay(50);
-		}
-		if (!i) {
-			printf("%s: bt_cmd, host not finished(0x%x)\n",
-			    name, sts);
-			return ENXIO;
-		}
-	}
-	outb(iobase + BT_CTRL_PORT, BT_CTRL_IRST);
-	return 0;
-}
-
-/*
- * Check if the device can be found at the port given
- * and if so, set it up ready for further work
- * as an argument, takes the isa_device structure from
- * autoconf.c
- */
-int
-btprobe(parent, match, aux)
-	struct device *parent;
-	void *match, *aux;
-{
-	register struct isa_attach_args *ia = aux;
-
-	/* See if there is a unit at this location. */
-	if (bt_find(ia, NULL) != 0)
-		return 0;
-
-	ia->ia_msize = 0;
-	ia->ia_iosize = 4;
-	/* IRQ and DRQ set by bt_find(). */
-	return 1;
-}
-
-/*
- * Attach all the sub-devices we can find
- */
-void
-btattach(parent, self, aux)
-	struct device *parent, *self;
-	void *aux;
-{
-	struct isa_attach_args *ia = aux;
-	struct bt_softc *sc = (void *)self;
-
-	if (bt_find(ia, sc) != 0)
-		panic("btattach: bt_find of %s failed", self->dv_xname);
-	sc->sc_iobase = ia->ia_iobase;
-
-	if (sc->sc_drq != DRQUNK)
-		isadma_cascade(sc->sc_drq);
-
-	bt_inquire_setup_information(sc);
-	bt_init(sc);
-	TAILQ_INIT(&sc->sc_free_ccb);
-	TAILQ_INIT(&sc->sc_waiting_ccb);
-
-	/*
-	 * fill in the prototype scsi_link.
-	 */
-	sc->sc_link.adapter_softc = sc;
-	sc->sc_link.adapter_target = sc->sc_scsi_dev;
-	sc->sc_link.adapter = &bt_switch;
-	sc->sc_link.device = &bt_dev;
-	sc->sc_link.openings = 4;
-
-	sc->sc_ih = isa_intr_establish(ia->ia_ic, sc->sc_irq, IST_EDGE,
-	    IPL_BIO, btintr, sc, sc->sc_dev.dv_xname);
-
-	/*
-	 * ask the adapter what subunits are present
-	 */
-	config_found(self, &sc->sc_link, scsiprint);
-}
-
-integrate void
-bt_finish_ccbs(sc)
-	struct bt_softc *sc;
-{
-	struct bt_mbx_in *wmbi;
-	struct bt_ccb *ccb;
-	int i;
-
-	wmbi = wmbx->tmbi;
-
-	if (wmbi->stat == BT_MBI_FREE) {
-		for (i = 0; i < BT_MBX_SIZE; i++) {
-			if (wmbi->stat != BT_MBI_FREE) {
-				printf("%s: mbi not in round-robin order\n",
-				    sc->sc_dev.dv_xname);
-				goto AGAIN;
-			}
-			bt_nextmbx(wmbi, wmbx, mbi);
-		}
-#ifdef BTDIAGnot
-		printf("%s: mbi interrupt with no full mailboxes\n",
-		    sc->sc_dev.dv_xname);
-#endif
-		return;
-	}
-
-AGAIN:
-	do {
-		ccb = bt_ccb_phys_kv(sc, phystol(wmbi->ccb_addr));
-		if (!ccb) {
-			printf("%s: bad mbi ccb pointer; skipping\n",
-			    sc->sc_dev.dv_xname);
-			goto next;
-		}
-
-#ifdef BTDEBUG
-		if (bt_debug) {
-			u_char *cp = &ccb->scsi_cmd;
-			printf("op=%x %x %x %x %x %x\n",
-			    cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
-			printf("stat %x for mbi addr = 0x%08x, ",
-			    wmbi->stat, wmbi);
-			printf("ccb addr = 0x%x\n", ccb);
-		}
-#endif /* BTDEBUG */
-
-		switch (wmbi->stat) {
-		case BT_MBI_OK:
-		case BT_MBI_ERROR:
-			if ((ccb->flags & CCB_ABORT) != 0) {
-				/*
-				 * If we already started an abort, wait for it
-				 * to complete before clearing the CCB.  We
-				 * could instead just clear CCB_SENDING, but
-				 * what if the mailbox was already received?
-				 * The worst that happens here is that we clear
-				 * the CCB a bit later than we need to.  BFD.
-				 */
-				goto next;
-			}
-			break;
-
-		case BT_MBI_ABORT:
-		case BT_MBI_UNKNOWN:
-			/*
-			 * Even if the CCB wasn't found, we clear it anyway.
-			 * See preceeding comment.
-			 */
-			break;
-
-		default:
-			printf("%s: bad mbi status %02x; skipping\n",
-			    sc->sc_dev.dv_xname, wmbi->stat);
-			goto next;
-		}
-
-		timeout_del(&ccb->xs->stimeout);
-		bt_done(sc, ccb);
-
-	next:
-		wmbi->stat = BT_MBI_FREE;
-		bt_nextmbx(wmbi, wmbx, mbi);
-	} while (wmbi->stat != BT_MBI_FREE);
-
-	wmbx->tmbi = wmbi;
-}
-
-/*
- * Catch an interrupt from the adaptor
- */
-int
-btintr(arg)
-	void *arg;
-{
-	struct bt_softc *sc = arg;
-	int iobase = sc->sc_iobase;
-	u_char sts;
-
-#ifdef BTDEBUG
-	printf("%s: btintr ", sc->sc_dev.dv_xname);
-#endif /* BTDEBUG */
-
-	/*
-	 * First acknowlege the interrupt, Then if it's not telling about
-	 * a completed operation just return.
-	 */
-	sts = inb(iobase + BT_INTR_PORT);
-	if ((sts & BT_INTR_ANYINTR) == 0)
-		return 0;
-	outb(iobase + BT_CTRL_PORT, BT_CTRL_IRST);
-
-#ifdef BTDIAG
-	/* Make sure we clear CCB_SENDING before finishing a CCB. */
-	bt_collect_mbo(sc);
-#endif
-
-	/* Mail box out empty? */
-	if (sts & BT_INTR_MBOA) {
-		struct bt_toggle toggle;
-
-		toggle.cmd.opcode = BT_MBO_INTR_EN;
-		toggle.cmd.enable = 0;
-		bt_cmd(iobase, sc, sizeof(toggle.cmd), (u_char *)&toggle.cmd, 0,
-		    (u_char *)0);
-		bt_start_ccbs(sc);
-	}
-
-	/* Mail box in full? */
-	if (sts & BT_INTR_MBIF)
-		bt_finish_ccbs(sc);
-
-	return 1;
-}
-
-integrate void
-bt_reset_ccb(sc, ccb)
-	struct bt_softc *sc;
-	struct bt_ccb *ccb;
-{
-
-	ccb->flags = 0;
-}
-
-/*
- * A ccb is put onto the free list.
- */
-void
-bt_free_ccb(sc, ccb)
-	struct bt_softc *sc;
-	struct bt_ccb *ccb;
-{
-	int s;
-
-	s = splbio();
-
-	bt_reset_ccb(sc, ccb);
-	TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, chain);
-
-	/*
-	 * If there were none, wake anybody waiting for one to come free,
-	 * starting with queued entries.
-	 */
-	if (ccb->chain.tqe_next == 0)
-		wakeup(&sc->sc_free_ccb);
-
-	splx(s);
-}
-
-integrate void
-bt_init_ccb(sc, ccb)
-	struct bt_softc *sc;
-	struct bt_ccb *ccb;
-{
-	int hashnum;
-
-	bzero(ccb, sizeof(struct bt_ccb));
-	/*
-	 * put in the phystokv hash table
-	 * Never gets taken out.
-	 */
-	ccb->hashkey = KVTOPHYS(ccb);
-	hashnum = CCB_HASH(ccb->hashkey);
-	ccb->nexthash = sc->sc_ccbhash[hashnum];
-	sc->sc_ccbhash[hashnum] = ccb;
-	bt_reset_ccb(sc, ccb);
-}
-
-/*
- * Get a free ccb
- *
- * If there are none, see if we can allocate a new one.  If so, put it in
- * the hash table too otherwise either return an error or sleep.
- */
-struct bt_ccb *
-bt_get_ccb(sc, flags)
-	struct bt_softc *sc;
-	int flags;
-{
-	struct bt_ccb *ccb;
-	int s;
-
-	s = splbio();
-
-	/*
-	 * If we can and have to, sleep waiting for one to come free
-	 * but only if we can't allocate a new one.
-	 */
-	for (;;) {
-		ccb = sc->sc_free_ccb.tqh_first;
-		if (ccb) {
-			TAILQ_REMOVE(&sc->sc_free_ccb, ccb, chain);
-			break;
-		}
-		if (sc->sc_numccbs < BT_CCB_MAX) {
-			ccb = (struct bt_ccb *) malloc(sizeof(struct bt_ccb),
-			    M_TEMP, M_NOWAIT);
-			if (!ccb) {
-				printf("%s: can't malloc ccb\n",
-				    sc->sc_dev.dv_xname);
-				goto out;
-			}
-			bt_init_ccb(sc, ccb);
-			sc->sc_numccbs++;
-			break;
-		}
-		if ((flags & SCSI_NOSLEEP) != 0)
-			goto out;
-		tsleep(&sc->sc_free_ccb, PRIBIO, "btccb", 0);
-	}
-
-	ccb->flags |= CCB_ALLOC;
-
-out:
-	splx(s);
-	return ccb;
-}
-
-/*
- * Given a physical address, find the ccb that it corresponds to.
- */
-struct bt_ccb *
-bt_ccb_phys_kv(sc, ccb_phys)
-	struct bt_softc *sc;
-	u_long ccb_phys;
-{
-	int hashnum = CCB_HASH(ccb_phys);
-	struct bt_ccb *ccb = sc->sc_ccbhash[hashnum];
-
-	while (ccb) {
-		if (ccb->hashkey == ccb_phys)
-			break;
-		ccb = ccb->nexthash;
-	}
-	return ccb;
-}
-
-/*
- * Queue a CCB to be sent to the controller, and send it if possible.
- */
-void
-bt_queue_ccb(sc, ccb)
-	struct bt_softc *sc;
-	struct bt_ccb *ccb;
-{
-
-	TAILQ_INSERT_TAIL(&sc->sc_waiting_ccb, ccb, chain);
-	bt_start_ccbs(sc);
-}
-
-/*
- * Garbage collect mailboxes that are no longer in use.
- */
-void
-bt_collect_mbo(sc)
-	struct bt_softc *sc;
-{
-	struct bt_mbx_out *wmbo;	/* Mail Box Out pointer */
-#ifdef BTDIAG
-	struct bt_ccb *ccb;
-#endif
-	wmbo = wmbx->cmbo;
-
-	while (sc->sc_mbofull > 0) {
-		if (wmbo->cmd != BT_MBO_FREE)
-			break;
-
-#ifdef BTDIAG
-		ccb = bt_ccb_phys_kv(sc, phystol(wmbo->ccb_addr));
-		ccb->flags &= ~CCB_SENDING;
-#endif
-
-		--sc->sc_mbofull;
-		bt_nextmbx(wmbo, wmbx, mbo);
-	}
-
-	wmbx->cmbo = wmbo;
-}
-
-/*
- * Send as many CCBs as we have empty mailboxes for.
- */
-void
-bt_start_ccbs(sc)
-	struct bt_softc *sc;
-{
-	int iobase = sc->sc_iobase;
-	struct bt_mbx_out *wmbo;	/* Mail Box Out pointer */
-	struct bt_ccb *ccb;
-
-	wmbo = wmbx->tmbo;
-
-	while ((ccb = sc->sc_waiting_ccb.tqh_first) != NULL) {
-		if (sc->sc_mbofull >= BT_MBX_SIZE) {
-			bt_collect_mbo(sc);
-			if (sc->sc_mbofull >= BT_MBX_SIZE) {
-				struct bt_toggle toggle;
-
-				toggle.cmd.opcode = BT_MBO_INTR_EN;
-				toggle.cmd.enable = 1;
-				bt_cmd(iobase, sc, sizeof(toggle.cmd),
-				    (u_char *)&toggle.cmd, 0, (u_char *)0);
-				break;
-			}
-		}
-
-		TAILQ_REMOVE(&sc->sc_waiting_ccb, ccb, chain);
-#ifdef BTDIAG
-		ccb->flags |= CCB_SENDING;
-#endif
-
-		/* Link ccb to mbo. */
-		ltophys(KVTOPHYS(ccb), wmbo->ccb_addr);
-		if (ccb->flags & CCB_ABORT)
-			wmbo->cmd = BT_MBO_ABORT;
-		else
-			wmbo->cmd = BT_MBO_START;
-
-		/* Tell the card to poll immediately. */
-		outb(iobase + BT_CMD_PORT, BT_START_SCSI);
-
-		if ((ccb->xs->flags & SCSI_POLL) == 0) {
-			timeout_set(&ccb->xs->stimeout, bt_timeout, ccb);
-			timeout_add(&ccb->xs->stimeout, (ccb->timeout * hz) / 1000);
-		}
-
-		++sc->sc_mbofull;
-		bt_nextmbx(wmbo, wmbx, mbo);
-	}
-
-	wmbx->tmbo = wmbo;
-}
-
-/*
- * We have a ccb which has been processed by the
- * adaptor, now we look to see how the operation
- * went. Wake up the owner if waiting
- */
-void
-bt_done(sc, ccb)
-	struct bt_softc *sc;
-	struct bt_ccb *ccb;
-{
-	struct scsi_sense_data *s1, *s2;
-	struct scsi_xfer *xs = ccb->xs;
-
-	SC_DEBUG(xs->sc_link, SDEV_DB2, ("bt_done\n"));
-	/*
-	 * Otherwise, put the results of the operation
-	 * into the xfer and call whoever started it
-	 */
-#ifdef BTDIAG
-	if (ccb->flags & CCB_SENDING) {
-		printf("%s: exiting ccb still in transit!\n", sc->sc_dev.dv_xname);
-		Debugger();
-		return;
-	}
-#endif
-	if ((ccb->flags & CCB_ALLOC) == 0) {
-		printf("%s: exiting ccb not allocated!\n", sc->sc_dev.dv_xname);
-		Debugger();
-		return;
-	}
-	if (xs->error == XS_NOERROR) {
-		if (ccb->host_stat != BT_OK) {
-			switch (ccb->host_stat) {
-			case BT_SEL_TIMEOUT:	/* No response */
-				xs->error = XS_SELTIMEOUT;
-				break;
-			default:	/* Other scsi protocol messes */
-				printf("%s: host_stat %x\n",
-				    sc->sc_dev.dv_xname, ccb->host_stat);
-				xs->error = XS_DRIVER_STUFFUP;
-				break;
-			}
-		} else if (ccb->target_stat != SCSI_OK) {
-			switch (ccb->target_stat) {
-			case SCSI_CHECK:
-				s1 = &ccb->scsi_sense;
-				s2 = &xs->sense;
-				*s2 = *s1;
-				xs->error = XS_SENSE;
-				break;
-			case SCSI_BUSY:
-				xs->error = XS_BUSY;
-				break;
-			default:
-				printf("%s: target_stat %x\n",
-				    sc->sc_dev.dv_xname, ccb->target_stat);
-				xs->error = XS_DRIVER_STUFFUP;
-				break;
-			}
-		} else
-			xs->resid = 0;
-	}
-	bt_free_ccb(sc, ccb);
-	xs->flags |= ITSDONE;
-	scsi_done(xs);
-}
-
-/*
- * Find the board and find it's irq/drq
- */
-int
-bt_find(ia, sc)
-	struct isa_attach_args *ia;
-	struct bt_softc *sc;
-{
-	int iobase = ia->ia_iobase;
-	int i;
-	u_char sts;
-	struct bt_extended_inquire inquire;
-	struct bt_config config;
-#if NAHA > 0
-	struct bt_digit digit;
-#endif
-	int irq, drq;
-
-	/*
-	 * reset board, If it doesn't respond, assume
-	 * that it's not there.. good for the probe
-	 */
-
-	outb(iobase + BT_CTRL_PORT, BT_CTRL_HRST | BT_CTRL_SRST);
-
-	delay(100);
-	for (i = BT_RESET_TIMEOUT; i; i--) {
-		sts = inb(iobase + BT_STAT_PORT);
-		if (sts == (BT_STAT_IDLE | BT_STAT_INIT))
-			break;
-		delay(1000);
-	}
-	if (!i) {
-#ifdef BTDEBUG
-		if (bt_debug)
-			printf("bt_find: No answer from buslogic board\n");
-#endif /* BTDEBUG */
-		return 1;
-	}
-
-	/*
-	 * Check that we actually know how to use this board.
-	 */
-	delay(1000);
-	bzero(&inquire, sizeof inquire);
-	inquire.cmd.opcode = BT_INQUIRE_EXTENDED;
-	inquire.cmd.len = sizeof(inquire.reply);
-	bt_cmd(iobase, sc, sizeof(inquire.cmd), (u_char *)&inquire.cmd,
-	    sizeof(inquire.reply), (u_char *)&inquire.reply);
-	switch (inquire.reply.bus_type) {
-	case BT_BUS_TYPE_24BIT:
-	case BT_BUS_TYPE_32BIT:
-		break;
-	case BT_BUS_TYPE_MCA:
-		/* We don't grok MicroChannel (yet). */
-		return 1;
-	default:
-		if (inquire.reply.bus_type != 'F')
-			printf("bt_find: illegal bus type %c\n",
-			    inquire.reply.bus_type);
-		return 1;
-	}
-
-#if NAHA > 0
-	/* Adaptec 1542 cards do not support this */
-	digit.reply.digit = '@';
-	digit.cmd.opcode = BT_INQUIRE_REVISION_3;
-	bt_cmd(iobase, sc, sizeof(digit.cmd), (u_char *)&digit.cmd,
-	    sizeof(digit.reply), (u_char *)&digit.reply);
-	if (digit.reply.digit == '@')
-		return 1;
-#endif
-
-	/*
-	 * Assume we have a board at this stage setup dma channel from
-	 * jumpers and save int level
-	 */
-	delay(1000);
-	config.cmd.opcode = BT_INQUIRE_CONFIG;
-	bt_cmd(iobase, sc, sizeof(config.cmd), (u_char *)&config.cmd,
-	    sizeof(config.reply), (u_char *)&config.reply);
-	switch (config.reply.chan) {
-	case EISADMA:
-		drq = DRQUNK;
-		break;
-	case CHAN0:
-		drq = 0;
-		break;
-	case CHAN5:
-		drq = 5;
-		break;
-	case CHAN6:
-		drq = 6;
-		break;
-	case CHAN7:
-		drq = 7;
-		break;
-	default:
-		printf("bt_find: illegal drq setting %x\n", config.reply.chan);
-		return 1;
-	}
-
-	switch (config.reply.intr) {
-	case INT9:
-		irq = 9;
-		break;
-	case INT10:
-		irq = 10;
-		break;
-	case INT11:
-		irq = 11;
-		break;
-	case INT12:
-		irq = 12;
-		break;
-	case INT14:
-		irq = 14;
-		break;
-	case INT15:
-		irq = 15;
-		break;
-	default:
-		printf("bt_find: illegal irq setting %x\n", config.reply.intr);
-		return 1;
-	}
-
-	if (sc != NULL) {
-		/* who are we on the scsi bus? */
-		sc->sc_scsi_dev = config.reply.scsi_dev;
-
-		sc->sc_iobase = iobase;
-		sc->sc_irq = irq;
-		sc->sc_drq = drq;
-	} else {
-		if (ia->ia_irq == IRQUNK)
-			ia->ia_irq = irq;
-		else if (ia->ia_irq != irq)
-			return 1;
-		if (ia->ia_drq == DRQUNK)
-			ia->ia_drq = drq;
-		else if (ia->ia_drq != drq)
-			return 1;
-	}
-
-#if NAHA > 0
-	/* XXXX To avoid conflicting with the aha1542 probe */
-	btports[nbtports++] = iobase;
-#endif
-	return 0;
-}
-
-/*
- * Start the board, ready for normal operation
- */
-void
-bt_init(sc)
-	struct bt_softc *sc;
-{
-	int iobase = sc->sc_iobase;
-	struct bt_devices devices;
-	struct bt_setup setup;
-	struct bt_mailbox mailbox;
-	struct bt_period period;
-	int i;
-
-	/* Enable round-robin scheme - appeared at firmware rev. 3.31. */
-	if (strcmp(sc->sc_firmware, "3.31") >= 0) {
-		struct bt_toggle toggle;
-
-		toggle.cmd.opcode = BT_ROUND_ROBIN;
-		toggle.cmd.enable = 1;
-		bt_cmd(iobase, sc, sizeof(toggle.cmd), (u_char *)&toggle.cmd,
-		    0, (u_char *)0);
-	}
-
-	/* Inquire Installed Devices (to force synchronous negotiation). */
-	devices.cmd.opcode = BT_INQUIRE_DEVICES;
-	bt_cmd(iobase, sc, sizeof(devices.cmd), (u_char *)&devices.cmd,
-	    sizeof(devices.reply), (u_char *)&devices.reply);
-
-	/* Obtain setup information from. */
-	setup.cmd.opcode = BT_INQUIRE_SETUP;
-	setup.cmd.len = sizeof(setup.reply);
-	bt_cmd(iobase, sc, sizeof(setup.cmd), (u_char *)&setup.cmd,
-	    sizeof(setup.reply), (u_char *)&setup.reply);
-
-	printf("%s: %s, %s\n",
-	    sc->sc_dev.dv_xname,
-	    setup.reply.sync_neg ? "sync" : "async",
-	    setup.reply.parity ? "parity" : "no parity");
-
-	for (i = 0; i < 8; i++)
-		period.reply.period[i] = setup.reply.sync[i].period * 5 + 20;
-
-	if (sc->sc_firmware[0] >= '3') {
-		period.cmd.opcode = BT_INQUIRE_PERIOD;
-		period.cmd.len = sizeof(period.reply);
-		bt_cmd(iobase, sc, sizeof(period.cmd), (u_char *)&period.cmd,
-		    sizeof(period.reply), (u_char *)&period.reply);
-	}
-
-	for (i = 0; i < 8; i++) {
-		if (!setup.reply.sync[i].valid ||
-		    (!setup.reply.sync[i].offset && !setup.reply.sync[i].period))
-			continue;
-		printf("%s targ %d: sync, offset %d, period %dnsec\n",
-		    sc->sc_dev.dv_xname, i,
-		    setup.reply.sync[i].offset, period.reply.period[i] * 10);
-	}
-
-	/*
-	 * Set up initial mail box for round-robin operation.
-	 */
-	for (i = 0; i < BT_MBX_SIZE; i++) {
-		wmbx->mbo[i].cmd = BT_MBO_FREE;
-		wmbx->mbi[i].stat = BT_MBI_FREE;
-	}
-	wmbx->cmbo = wmbx->tmbo = &wmbx->mbo[0];
-	wmbx->tmbi = &wmbx->mbi[0];
-	sc->sc_mbofull = 0;
-
-	/* Initialize mail box. */
-	mailbox.cmd.opcode = BT_MBX_INIT_EXTENDED;
-	mailbox.cmd.nmbx = BT_MBX_SIZE;
-	ltophys(KVTOPHYS(wmbx), mailbox.cmd.addr);
-	bt_cmd(iobase, sc, sizeof(mailbox.cmd), (u_char *)&mailbox.cmd,
-	    0, (u_char *)0);
-}
-
-void
-bt_inquire_setup_information(sc)
-	struct bt_softc *sc;
-{
-	int iobase = sc->sc_iobase;
-	struct bt_model model;
-	struct bt_revision revision;
-	struct bt_digit digit;
-	char *p;
-
-	/*
-	 * Get the firmware revision.
-	 */
-	p = sc->sc_firmware;
-	revision.cmd.opcode = BT_INQUIRE_REVISION;
-	bt_cmd(iobase, sc, sizeof(revision.cmd), (u_char *)&revision.cmd,
-	    sizeof(revision.reply), (u_char *)&revision.reply);
-	*p++ = revision.reply.firm_revision;
-	*p++ = '.';
-	*p++ = revision.reply.firm_version;
-	digit.cmd.opcode = BT_INQUIRE_REVISION_3;
-	bt_cmd(iobase, sc, sizeof(digit.cmd), (u_char *)&digit.cmd,
-	    sizeof(digit.reply), (u_char *)&digit.reply);
-	*p++ = digit.reply.digit;
-	if (revision.reply.firm_revision >= '3' ||
-	    (revision.reply.firm_revision == '3' && revision.reply.firm_version >= '3')) {
-		digit.cmd.opcode = BT_INQUIRE_REVISION_4;
-		bt_cmd(iobase, sc, sizeof(digit.cmd), (u_char *)&digit.cmd,
-		    sizeof(digit.reply), (u_char *)&digit.reply);
-		*p++ = digit.reply.digit;
-	}
-	while (p > sc->sc_firmware && (p[-1] == ' ' || p[-1] == '\0'))
-		p--;
-	*p = '\0';
-
-	/*
-	 * Get the model number.
-	 */
-	if (revision.reply.firm_revision >= '3') {
-		p = sc->sc_model;
-		model.cmd.opcode = BT_INQUIRE_MODEL;
-		model.cmd.len = sizeof(model.reply);
-		bt_cmd(iobase, sc, sizeof(model.cmd), (u_char *)&model.cmd,
-		    sizeof(model.reply), (u_char *)&model.reply);
-		*p++ = model.reply.id[0];
-		*p++ = model.reply.id[1];
-		*p++ = model.reply.id[2];
-		*p++ = model.reply.id[3];
-		while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0'))
-			p--;
-		*p++ = model.reply.version[0];
-		*p++ = model.reply.version[1];
-		while (p > sc->sc_model && (p[-1] == ' ' || p[-1] == '\0'))
-			p--;
-		*p = '\0';
-	} else
-		strcpy(sc->sc_model, "542B");
-
-	printf(": model BT-%s, firmware %s\n", sc->sc_model, sc->sc_firmware);
-}
-
-void
-btminphys(bp)
-	struct buf *bp;
-{
-
-	if (bp->b_bcount > ((BT_NSEG - 1) << PGSHIFT))
-		bp->b_bcount = ((BT_NSEG - 1) << PGSHIFT);
-	minphys(bp);
-}
-
-/*
- * start a scsi operation given the command and the data address.  Also needs
- * the unit, target and lu.
- */
-int
-bt_scsi_cmd(xs)
-	struct scsi_xfer *xs;
-{
-	struct scsi_link *sc_link = xs->sc_link;
-	struct bt_softc *sc = sc_link->adapter_softc;
-	struct bt_ccb *ccb;
-	struct bt_scat_gath *sg;
-	int seg;		/* scatter gather seg being worked on */
-	u_long thiskv, thisphys, nextphys;
-	int bytes_this_seg, bytes_this_page, datalen, flags;
-#ifdef TFS
-	struct iovec *iovp;
-#endif
-	int s;
-
-	SC_DEBUG(sc_link, SDEV_DB2, ("bt_scsi_cmd\n"));
-	/*
-	 * get a ccb to use. If the transfer
-	 * is from a buf (possibly from interrupt time)
-	 * then we can't allow it to sleep
-	 */
-	flags = xs->flags;
-	if ((ccb = bt_get_ccb(sc, flags)) == NULL) {
-		xs->error = XS_DRIVER_STUFFUP;
-		return TRY_AGAIN_LATER;
-	}
-	ccb->xs = xs;
-	ccb->timeout = xs->timeout;
-
-	/*
-	 * Put all the arguments for the xfer in the ccb
-	 */
-	if (flags & SCSI_RESET) {
-		ccb->opcode = BT_RESET_CCB;
-		ccb->scsi_cmd_length = 0;
-	} else {
-		/* can't use S/G if zero length */
-		ccb->opcode = (xs->datalen ? BT_INIT_SCAT_GATH_CCB
-					   : BT_INITIATOR_CCB);
-		bcopy(xs->cmd, &ccb->scsi_cmd,
-		    ccb->scsi_cmd_length = xs->cmdlen);
-	}
-
-	if (xs->datalen) {
-		sg = ccb->scat_gath;
-		seg = 0;
-#ifdef	TFS
-		if (flags & SCSI_DATA_UIO) {
-			iovp = ((struct uio *)xs->data)->uio_iov;
-			datalen = ((struct uio *)xs->data)->uio_iovcnt;
-			xs->datalen = 0;
-			while (datalen && seg < BT_NSEG) {
-				ltophys(iovp->iov_base, sg->seg_addr);
-				ltophys(iovp->iov_len, sg->seg_len);
-				xs->datalen += iovp->iov_len;
-				SC_DEBUGN(sc_link, SDEV_DB4, ("(0x%x@0x%x)",
-				    iovp->iov_len, iovp->iov_base));
-				sg++;
-				iovp++;
-				seg++;
-				datalen--;
-			}
-		} else
-#endif	/* TFS */
-		{
-			/*
-			 * Set up the scatter-gather block.
-			 */
-			SC_DEBUG(sc_link, SDEV_DB4,
-			    ("%d @0x%x:- ", xs->datalen, xs->data));
-
-			datalen = xs->datalen;
-			thiskv = (int)xs->data;
-			thisphys = KVTOPHYS(thiskv);
-
-			while (datalen && seg < BT_NSEG) {
-				bytes_this_seg = 0;
-
-				/* put in the base address */
-				ltophys(thisphys, sg->seg_addr);
-
-				SC_DEBUGN(sc_link, SDEV_DB4, ("0x%x", thisphys));
-
-				/* do it at least once */
-				nextphys = thisphys;
-				while (datalen && thisphys == nextphys) {
-					/*
-					 * This page is contiguous (physically)
-					 * with the the last, just extend the
-					 * length
-					 */
-					/* how far to the end of the page */
-					nextphys = (thisphys & ~PGOFSET) + NBPG;
-					bytes_this_page = nextphys - thisphys;
-					/**** or the data ****/
-					bytes_this_page = min(bytes_this_page,
-							      datalen);
-					bytes_this_seg += bytes_this_page;
-					datalen -= bytes_this_page;
-
-					/* get more ready for the next page */
-					thiskv = (thiskv & ~PGOFSET) + NBPG;
-					if (datalen)
-						thisphys = KVTOPHYS(thiskv);
-				}
-				/*
-				 * next page isn't contiguous, finish the seg
-				 */
-				SC_DEBUGN(sc_link, SDEV_DB4,
-				    ("(0x%x)", bytes_this_seg));
-				ltophys(bytes_this_seg, sg->seg_len);
-				sg++;
-				seg++;
-			}
-		}
-		/* end of iov/kv decision */
-		SC_DEBUGN(sc_link, SDEV_DB4, ("\n"));
-		if (datalen) {
-			/*
-			 * there's still data, must have run out of segs!
-			 */
-			printf("%s: bt_scsi_cmd, more than %d dma segs\n",
-			    sc->sc_dev.dv_xname, BT_NSEG);
-			goto bad;
-		}
-		ltophys(KVTOPHYS(ccb->scat_gath), ccb->data_addr);
-		ltophys(seg * sizeof(struct bt_scat_gath), ccb->data_length);
-	} else {		/* No data xfer, use non S/G values */
-		ltophys(0, ccb->data_addr);
-		ltophys(0, ccb->data_length);
-	}
-
-	ccb->data_out = 0;
-	ccb->data_in = 0;
-	ccb->target = sc_link->target;
-	ccb->lun = sc_link->lun;
-	ltophys(KVTOPHYS(&ccb->scsi_sense), ccb->sense_ptr);
-	ccb->req_sense_length = sizeof(ccb->scsi_sense);
-	ccb->host_stat = 0x00;
-	ccb->target_stat = 0x00;
-	ccb->link_id = 0;
-	ltophys(0, ccb->link_addr);
-
-	s = splbio();
-	bt_queue_ccb(sc, ccb);
-	splx(s);
-
-	/*
-	 * Usually return SUCCESSFULLY QUEUED
-	 */
-	SC_DEBUG(sc_link, SDEV_DB3, ("cmd_sent\n"));
-	if ((flags & SCSI_POLL) == 0)
-		return SUCCESSFULLY_QUEUED;
-
-	/*
-	 * If we can't use interrupts, poll on completion
-	 */
-	if (bt_poll(sc, xs, ccb->timeout)) {
-		bt_timeout(ccb);
-		if (bt_poll(sc, xs, ccb->timeout))
-			bt_timeout(ccb);
-	}
-	return COMPLETE;
-
-bad:
-	xs->error = XS_DRIVER_STUFFUP;
-	bt_free_ccb(sc, ccb);
-	return COMPLETE;
-}
-
-/*
- * Poll a particular unit, looking for a particular xs
- */
-int
-bt_poll(sc, xs, count)
-	struct bt_softc *sc;
-	struct scsi_xfer *xs;
-	int count;
-{
-	int iobase = sc->sc_iobase;
-
-	/* timeouts are in msec, so we loop in 1000 usec cycles */
-	while (count) {
-		/*
-		 * If we had interrupts enabled, would we
-		 * have got an interrupt?
-		 */
-		if (inb(iobase + BT_INTR_PORT) & BT_INTR_ANYINTR)
-			btintr(sc);
-		if (xs->flags & ITSDONE)
-			return 0;
-		delay(1000);	/* only happens in boot so ok */
-		count--;
-	}
-	return 1;
-}
-
-void
-bt_timeout(arg)
-	void *arg;
-{
-	struct bt_ccb *ccb = arg;
-	struct scsi_xfer *xs = ccb->xs;
-	struct scsi_link *sc_link = xs->sc_link;
-	struct bt_softc *sc = sc_link->adapter_softc;
-	int s;
-
-	sc_print_addr(sc_link);
-	printf("timed out");
-
-	s = splbio();
-
-#ifdef BTDIAG
-	/*
-	 * If the ccb's mbx is not free, then the board has gone Far East?
-	 */
-	bt_collect_mbo(sc);
-	if (ccb->flags & CCB_SENDING) {
-		printf("%s: not taking commands!\n", sc->sc_dev.dv_xname);
-		Debugger();
-	}
-#endif
-
-	/*
-	 * If it has been through before, then
-	 * a previous abort has failed, don't
-	 * try abort again
-	 */
-	if (ccb->flags & CCB_ABORT) {
-		/* abort timed out */
-		printf(" AGAIN\n");
-		/* XXX Must reset! */
-	} else {
-		/* abort the operation that has timed out */
-		printf("\n");
-		ccb->xs->error = XS_TIMEOUT;
-		ccb->timeout = BT_ABORT_TIMEOUT;
-		ccb->flags |= CCB_ABORT;
-		bt_queue_ccb(sc, ccb);
-	}
-
-	splx(s);
-}
diff --git a/sys/dev/isa/btreg.h b/sys/dev/isa/btreg.h
deleted file mode 100644
index 720a971d499..00000000000
--- a/sys/dev/isa/btreg.h
+++ /dev/null
@@ -1,310 +0,0 @@
-/*	$OpenBSD: btreg.h,v 1.5 1997/11/07 08:06:43 niklas Exp $	*/
-
-typedef u_int8_t physaddr[4];
-typedef u_int8_t physlen[4];
-#define	ltophys	_lto4l
-#define	phystol	_4ltol
-
-/*
- * I/O port offsets
- */
-#define	BT_CTRL_PORT		0	/* control (wo) */
-#define	BT_STAT_PORT		0	/* status (ro) */
-#define	BT_CMD_PORT		1	/* command (wo) */
-#define	BT_DATA_PORT		1	/* data (ro) */
-#define	BT_INTR_PORT		2	/* interrupt status (ro) */
-
-/*
- * BT_CTRL bits
- */
-#define BT_CTRL_HRST		0x80	/* Hardware reset */
-#define BT_CTRL_SRST		0x40	/* Software reset */
-#define BT_CTRL_IRST		0x20	/* Interrupt reset */
-#define BT_CTRL_SCRST		0x10	/* SCSI bus reset */
-
-/*
- * BT_STAT bits
- */
-#define BT_STAT_STST		0x80	/* Self test in Progress */
-#define BT_STAT_DIAGF		0x40	/* Diagnostic Failure */
-#define BT_STAT_INIT		0x20	/* Mbx Init required */
-#define BT_STAT_IDLE		0x10	/* Host Adapter Idle */
-#define BT_STAT_CDF		0x08	/* cmd/data out port full */
-#define BT_STAT_DF		0x04	/* Data in port full */
-#define BT_STAT_INVDCMD		0x01	/* Invalid command */
-
-/*
- * BT_CMD opcodes
- */
-#define	BT_NOP			0x00	/* No operation */
-#define BT_MBX_INIT		0x01	/* Mbx initialization */
-#define BT_START_SCSI		0x02	/* start scsi command */
-#define BT_INQUIRE_REVISION	0x04	/* Adapter Inquiry */
-#define BT_MBO_INTR_EN		0x05	/* Enable MBO available interrupt */
-#if 0
-#define BT_SEL_TIMEOUT_SET	0x06	/* set selection time-out */
-#define BT_BUS_ON_TIME_SET	0x07	/* set bus-on time */
-#define BT_BUS_OFF_TIME_SET	0x08	/* set bus-off time */
-#define BT_SPEED_SET		0x09	/* set transfer speed */
-#endif
-#define BT_INQUIRE_DEVICES	0x0a	/* return installed devices 0-7 */
-#define BT_INQUIRE_CONFIG	0x0b	/* return configuration data */
-#define BT_TARGET_EN		0x0c	/* enable target mode */
-#define BT_INQUIRE_SETUP	0x0d	/* return setup data */
-#define BT_ECHO			0x1e	/* Echo command data */
-#define BT_INQUIRE_DEVICES_2	0x23	/* return installed devices 8-15 */
-#define BT_MBX_INIT_EXTENDED	0x81	/* Mbx initialization */
-#define BT_INQUIRE_REVISION_3	0x84	/* Get 3rd firmware version byte */
-#define BT_INQUIRE_REVISION_4	0x85	/* Get 4th firmware version byte */
-#define BT_INQUIRE_MODEL	0x8b	/* Get hardware ID and revision */
-#define	BT_INQUIRE_PERIOD	0x8c	/* Get synchronous period */
-#define BT_INQUIRE_EXTENDED	0x8d	/* Adapter Setup Inquiry */
-#define	BT_ROUND_ROBIN		0x8f	/* Enable/Disable(default) round robin */
-
-/*
- * BT_INTR bits
- */
-#define BT_INTR_ANYINTR		0x80	/* Any interrupt */
-#define BT_INTR_SCRD		0x08	/* SCSI reset detected */
-#define BT_INTR_HACC		0x04	/* Command complete */
-#define BT_INTR_MBOA		0x02	/* MBX out empty */
-#define BT_INTR_MBIF		0x01	/* MBX in full */
-
-struct bt_mbx_out {
-	physaddr ccb_addr;
-	u_char dummy[3];
-	u_char cmd;
-};
-
-struct bt_mbx_in {
-	physaddr ccb_addr;
-	u_char dummy[3];
-	u_char stat;
-};
-
-/*
- * mbo.cmd values
- */
-#define BT_MBO_FREE	0x0	/* MBO entry is free */
-#define BT_MBO_START	0x1	/* MBO activate entry */
-#define BT_MBO_ABORT	0x2	/* MBO abort entry */
-
-/*
- * mbi.stat values
- */
-#define BT_MBI_FREE	0x0	/* MBI entry is free */
-#define BT_MBI_OK	0x1	/* completed without error */
-#define BT_MBI_ABORT	0x2	/* aborted ccb */
-#define BT_MBI_UNKNOWN	0x3	/* Tried to abort invalid CCB */
-#define BT_MBI_ERROR	0x4	/* Completed with error */
-
-#if	defined(BIG_DMA)
-WARNING...THIS WON'T WORK(won't fit on 1 page)
-#if 0
-#define      BT_NSEG 2048    /* Number of scatter gather segments - to much vm */
-#endif
-#define	BT_NSEG	128
-#else
-#define	BT_NSEG	33
-#endif /* BIG_DMA */
-
-struct bt_scat_gath {
-	physlen seg_len;
-	physaddr seg_addr;
-};
-
-struct bt_ccb {
-	u_char opcode;
-	u_char:3, data_in:1, data_out:1,:3;
-	u_char scsi_cmd_length;
-	u_char req_sense_length;
-	/*------------------------------------longword boundary */
-	physlen data_length;
-	/*------------------------------------longword boundary */
-	physaddr data_addr;
-	/*------------------------------------longword boundary */
-	u_char dummy1[2];
-	u_char host_stat;
-	u_char target_stat;
-	/*------------------------------------longword boundary */
-	u_char target;
-	u_char lun;
-	struct scsi_generic scsi_cmd;
-	u_char dummy2[1];
-	u_char link_id;
-	/*------------------------------------longword boundary */
-	physaddr link_addr;
-	/*------------------------------------longword boundary */
-	physaddr sense_ptr;
-/*-----end of HW fields-----------------------longword boundary */
-	struct scsi_sense_data scsi_sense;
-	/*------------------------------------longword boundary */
-	struct bt_scat_gath scat_gath[BT_NSEG];
-	/*------------------------------------longword boundary */
-	TAILQ_ENTRY(bt_ccb) chain;
-	struct bt_ccb *nexthash;
-	long hashkey;
-	struct scsi_xfer *xs;		/* the scsi_xfer for this cmd */
-	int flags;
-#define	CCB_ALLOC	0x01
-#define	CCB_ABORT	0x02
-#ifdef BTDIAG
-#define	CCB_SENDING	0x04
-#endif
-	int timeout;
-};
-
-/*
- * opcode fields
- */
-#define BT_INITIATOR_CCB	0x00	/* SCSI Initiator CCB */
-#define BT_TARGET_CCB		0x01	/* SCSI Target CCB */
-#define BT_INIT_SCAT_GATH_CCB	0x02	/* SCSI Initiator with scattter gather */
-#define BT_RESET_CCB		0x81	/* SCSI Bus reset */
-
-/*
- * bt_ccb.host_stat values
- */
-#define BT_OK		0x00	/* cmd ok */
-#define BT_LINK_OK	0x0a	/* Link cmd ok */
-#define BT_LINK_IT	0x0b	/* Link cmd ok + int */
-#define BT_SEL_TIMEOUT	0x11	/* Selection time out */
-#define BT_OVER_UNDER	0x12	/* Data over/under run */
-#define BT_BUS_FREE	0x13	/* Bus dropped at unexpected time */
-#define BT_INV_BUS	0x14	/* Invalid bus phase/sequence */
-#define BT_BAD_MBO	0x15	/* Incorrect MBO cmd */
-#define BT_BAD_CCB	0x16	/* Incorrect ccb opcode */
-#define BT_BAD_LINK	0x17	/* Not same values of LUN for links */
-#define BT_INV_TARGET	0x18	/* Invalid target direction */
-#define BT_CCB_DUP	0x19	/* Duplicate CCB received */
-#define BT_INV_CCB	0x1a	/* Invalid CCB or segment list */
-
-struct bt_extended_inquire {
-	struct {
-		u_char	opcode;
-		u_char	len;
-	} cmd;
-	struct {
-		u_char	bus_type;	/* Type of bus connected to */
-#define	BT_BUS_TYPE_24BIT	'A'	/* ISA bus */
-#define	BT_BUS_TYPE_32BIT	'E'	/* EISA/VLB/PCI bus */
-#define	BT_BUS_TYPE_MCA		'M'	/* MicroChannel bus */
-		u_char	bios_address;	/* Address of adapter BIOS */
-		u_short	max_segment;	/* ? */
-	} reply;
-};
-
-struct bt_config {
-	struct {
-		u_char	opcode;
-	} cmd;
-	struct {
-		u_char  chan;
-		u_char  intr;
-		u_char  scsi_dev:3;
-		u_char	:5;
-	} reply;
-};
-
-struct bt_toggle {
-	struct {
-		u_char	opcode;
-		u_char	enable;
-	} cmd;
-};
-
-struct bt_mailbox {
-	struct {
-		u_char	opcode;
-		u_char	nmbx;
-		physaddr addr;
-	} cmd;
-};
-
-struct bt_model {
-	struct {
-		u_char	opcode;
-		u_char	len;
-	} cmd;
-	struct {
-		u_char	id[4];		/* i.e bt742a -> '7','4','2','A' */
-		u_char	version[2];	/* i.e Board Revision 'H' -> 'H', 0x00 */
-	} reply;
-};
-
-struct bt_revision {
-	struct {
-		u_char	opcode;
-	} cmd;
-	struct {
-		u_char  board_type;
-		u_char  custom_feature;
-		char    firm_revision;
-		u_char  firm_version;
-	} reply;
-};
-
-struct bt_digit {
-	struct {
-		u_char	opcode;
-	} cmd;
-	struct {
-		u_char  digit;
-	} reply;
-};
-
-struct bt_devices {
-	struct {
-		u_char	opcode;
-	} cmd;
-	struct {
-		u_char	junk[8];
-	} reply;
-};
-
-struct bt_setup {
-	struct {
-		u_char	opcode;
-		u_char	len;
-	} cmd;
-	struct {
-		u_char  sync_neg:1;
-		u_char  parity:1;
-		u_char	:6;
-		u_char  speed;
-		u_char  bus_on;
-		u_char  bus_off;
-		u_char  num_mbx;
-		u_char  mbx[3];		/*XXX */
-		/* doesn't make sense with 32bit addresses */
-		struct {
-			u_char  offset:4;
-			u_char  period:3;
-			u_char  valid:1;
-		} sync[8];
-		u_char  disc_sts;
-	} reply;
-};
-
-struct bt_period {
-	struct {
-		u_char	opcode;
-		u_char	len;
-	} cmd;
-	struct {
-		u_char	period[8];
-	} reply;
-};
-
-#define INT9	0x01
-#define INT10	0x02
-#define INT11	0x04
-#define INT12	0x08
-#define INT14	0x20
-#define INT15	0x40
-
-#define EISADMA	0x00
-#define CHAN0	0x01
-#define CHAN5	0x20
-#define CHAN6	0x40
-#define CHAN7	0x80
diff --git a/sys/dev/isa/files.isa b/sys/dev/isa/files.isa
index b3cbb3e587d..d5df43bb828 100644
--- a/sys/dev/isa/files.isa
+++ b/sys/dev/isa/files.isa
@@ -1,4 +1,4 @@
-#	$OpenBSD: files.isa,v 1.72 2001/12/05 10:29:45 mickey Exp $
+#	$OpenBSD: files.isa,v 1.73 2002/01/24 22:38:03 mickey Exp $
 #	$NetBSD: files.isa,v 1.21 1996/05/16 03:45:55 mycroft Exp $
 #
 # Config file and device description for machine-independent ISA code.
@@ -96,6 +96,10 @@ device	bt: scsi, isa_dma
 attach	bt at isa
 file	dev/isa/bt.c			bt needs-count
 
+# 
+attach	bha at isa with bha_isa: isa_dma
+file	dev/isa/bha_isa.c		bha_isa
+
 # Adaptec AIC-6[32]60 ICs
 attach	aic at isa with aic_isa: isa_dma
 file	dev/isa/aic_isa.c		aic_isa
diff --git a/sys/dev/pci/bha_pci.c b/sys/dev/pci/bha_pci.c
new file mode 100644
index 00000000000..81866316401
--- /dev/null
+++ b/sys/dev/pci/bha_pci.c
@@ -0,0 +1,167 @@
+/*	$OpenBSD: bha_pci.c,v 1.1 2002/01/24 22:38:03 mickey Exp $	*/
+/*	$NetBSD: bha_pci.c,v 1.16 1998/08/15 10:10:53 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Charles M. Hannum.
+ *
+ * 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 FOUNDATION 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/types.h>
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+
+#include <machine/bus.h>
+#include <machine/intr.h>
+
+#include <scsi/scsi_all.h>
+#include <scsi/scsiconf.h>
+
+#include <dev/pci/pcivar.h>
+#include <dev/pci/pcidevs.h>
+
+#include <dev/ic/bhareg.h>
+#include <dev/ic/bhavar.h>
+
+#define	PCI_CBIO	0x10
+
+int	bha_pci_match __P((struct device *, void *, void *));
+void	bha_pci_attach __P((struct device *, struct device *, void *));
+
+struct cfattach bha_pci_ca = {
+	sizeof(struct bha_softc), bha_pci_match, bha_pci_attach
+};
+
+/*
+ * Check the slots looking for a board we recognise
+ * If we find one, note it's address (slot) and call
+ * the actual probe routine to check it out.
+ */
+int
+bha_pci_match(parent, match, aux)
+	struct device *parent;
+	void *match, *aux;
+{
+	struct pci_attach_args *pa = aux;
+	bus_space_tag_t iot;
+	bus_space_handle_t ioh;
+	bus_size_t iosize;
+	int rv;
+
+	if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_BUSLOGIC)
+		return (0);
+
+	if (PCI_PRODUCT(pa->pa_id) != PCI_PRODUCT_BUSLOGIC_MULTIMASTER_NC &&
+	    PCI_PRODUCT(pa->pa_id) != PCI_PRODUCT_BUSLOGIC_MULTIMASTER)
+		return (0);
+
+	if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0, &iot, &ioh,
+	    NULL, &iosize, 0))
+		return (0);
+
+	rv = bha_find(iot, ioh, NULL);
+	bus_space_unmap(iot, ioh, iosize);
+
+	return (rv);
+}
+
+/*
+ * Attach all the sub-devices we can find
+ */
+void
+bha_pci_attach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct pci_attach_args *pa = aux;
+	struct bha_softc *sc = (void *)self;
+	bus_space_tag_t iot;
+	bus_space_handle_t ioh;
+	bus_size_t iosize;
+	struct bha_probe_data bpd;
+	pci_chipset_tag_t pc = pa->pa_pc;
+	pci_intr_handle_t ih;
+	pcireg_t csr;
+	const char *model, *intrstr;
+
+	if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BUSLOGIC_MULTIMASTER_NC)
+		model = "BusLogic 9xxC SCSI";
+	else if (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_BUSLOGIC_MULTIMASTER)
+		model = "BusLogic 9xxC SCSI";
+	else
+		model = "unknown model!";
+
+	if (pci_mapreg_map(pa, PCI_CBIO, PCI_MAPREG_TYPE_IO, 0, &iot, &ioh,
+	    NULL, &iosize, 0)) {
+		printf(": unable to map I/O space\n");
+		return;
+	}
+
+	sc->sc_iot = iot;
+	sc->sc_ioh = ioh;
+	sc->sc_dmat = pa->pa_dmat;
+	if (!bha_find(iot, ioh, &bpd)) {
+		printf(": bha_find failed\n");
+		bus_space_unmap(iot, ioh, iosize);
+		return;
+	}
+
+	sc->sc_dmaflags = 0;
+
+	csr = pci_conf_read(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
+	pci_conf_write(pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
+	    csr | PCI_COMMAND_MASTER_ENABLE | PCI_COMMAND_IO_ENABLE);
+
+	if (pci_intr_map(pa, &ih)) {
+		printf(": couldn't map interrupt\n");
+		bus_space_unmap(iot, ioh, iosize);
+		return;
+	}
+	intrstr = pci_intr_string(pc, ih);
+	sc->sc_ih = pci_intr_establish(pc, ih, IPL_BIO, bha_intr, sc,
+	    sc->sc_dev.dv_xname);
+	if (sc->sc_ih == NULL) {
+		printf(": couldn't establish interrupt");
+		if (intrstr != NULL)
+			printf(" at %s", intrstr);
+		printf("\n");
+		bus_space_unmap(iot, ioh, iosize);
+		return;
+	}
+	printf(": %s, %s\n", intrstr, model);
+
+	bha_attach(sc, &bpd);
+
+	bha_disable_isacompat(sc);
+}
diff --git a/sys/dev/pci/files.pci b/sys/dev/pci/files.pci
index 181e40ff47c..bc30676e02d 100644
--- a/sys/dev/pci/files.pci
+++ b/sys/dev/pci/files.pci
@@ -1,4 +1,4 @@
-#	$OpenBSD: files.pci,v 1.124 2002/01/08 23:06:01 jason Exp $
+#	$OpenBSD: files.pci,v 1.125 2002/01/24 22:38:03 mickey Exp $
 #	$NetBSD: files.pci,v 1.20 1996/09/24 17:47:15 christos Exp $
 #
 # Config file and device description for machine-independent PCI code.
@@ -58,7 +58,6 @@ file	dev/ic/adwlib.c			adw_pci
 file	dev/microcode/adw/adwmcode.c	adw_pci
 
 # BusLogic BT-9xx PCI family
-# device declaration in sys/dev/isa/files.isa
 attach	bha at pci with bha_pci
 file	dev/pci/bha_pci.c		bha_pci