Major update to isp driver, mostly from mjacob via FreeBSD.

Everything that worked before should still work so in it goes. Newer
boards (2300, 2400) may now work but are still a work in progress.
Thanks to many testers but especially kettenis@ for finding a show
stopper bug and stomping it.

ok deraadt@

14 files changed, 7988 insertions, 3969 deletions

diff --git a/sys/dev/ic/isp.c b/sys/dev/ic/isp.c
index 8ccfe47c05f..2d0f10fdd18 100644
--- a/sys/dev/ic/isp.c
+++ b/sys/dev/ic/isp.c
@@ -1,33 +1,35 @@
-/* 	$OpenBSD: isp.c,v 1.45 2009/06/03 05:11:09 krw Exp $ */
+/* 	$OpenBSD: isp.c,v 1.46 2009/06/24 11:00:53 krw Exp $ */
 /*	$FreeBSD: src/sys/dev/isp/isp.c,v 1.150 2008/12/15 21:42:38 marius Exp $*/
+/*-
+ *  Copyright (c) 1997-2007 by Matthew Jacob
+ *  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.
+ * 
+ *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ *  SUCH DAMAGE.
+ */
+
 /*
  * Machine and OS Independent (well, as best as possible)
- * code for the QLogic ISP SCSI adapters.
- *
- * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob
- * Feral Software
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice immediately at the beginning of the file, without modification,
- *    this list of conditions, and the following disclaimer.
- * 2. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * code for the Qlogic ISP SCSI and FC-SCSI adapters.
  */
 
 /*
@@ -39,11 +41,14 @@
 /*
  * Include header file appropriate for platform we're building on.
  */
-
 #ifdef	__NetBSD__
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD$");
 #include <dev/ic/isp_netbsd.h>
 #endif
 #ifdef	__FreeBSD__
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: src/sys/dev/isp/isp.c,v 1.149 2007/07/10 07:55:04 mjacob Exp $");
 #include <dev/isp/isp_freebsd.h>
 #endif
 #ifdef	__OpenBSD__
@@ -61,30 +66,16 @@
  */
 
 #define	MBOX_DELAY_COUNT	1000000 / 100
+#define	ISP_MARK_PORTDB(a, b)	\
+    isp_prt(isp, ISP_LOGSANCFG, "line %d: markportdb", __LINE__); \
+    isp_mark_portdb(a, b)
 
 /*
  * Local static data
  */
-static const char portshift[] =
-    "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
-static const char portdup[] =
-    "Target %d duplicates Target %d- killing off both";
-static const char retained[] =
-    "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
-static const char lretained[] =
-    "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
-static const char plogout[] =
-    "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
-static const char plogierr[] =
-    "Command Error in PLOGI for Port 0x%x (0x%x)";
-static const char nopdb[] =
-    "Could not get PDB for Device @ Port 0x%x";
-static const char pdbmfail1[] =
-    "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
-static const char pdbmfail2[] =
-    "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
-static const char ldumped[] =
-    "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
+static const char fconf[] =
+    "PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n"
+    " database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
 static const char notresp[] =
   "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
 static const char xact1[] =
@@ -96,11 +87,11 @@ static const char xact3[] =
 static const char pskip[] =
     "SCSI phase skipped for target %d.%d.%d";
 static const char topology[] =
-    "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
-static const char swrej[] =
-    "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x";
+    "HBA PortID 0x%06x N-Port Handle %d, Connection Topology '%s'";
+static const char ourwwn[] =
+    "HBA WWNN 0x%08x%08x HBA WWPN 0x%08x%08x";
 static const char finmsg[] =
-    "(%d.%d.%d): FIN dl%d resid %lu STS 0x%x SKEY %c XS_ERR=0x%x";
+    "%d.%d.%d: FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
 static const char sc0[] =
     "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
 static const char sc1[] =
@@ -114,40 +105,54 @@ static const char bun[] =
 /*
  * Local function prototypes.
  */
-static int isp_parse_async(struct ispsoftc *, u_int16_t);
-static int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *,
-    u_int16_t *);
-static void
-isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *);
-static void isp_fastpost_complete(struct ispsoftc *, u_int16_t);
-static int isp_mbox_continue(struct ispsoftc *);
-static void isp_scsi_init(struct ispsoftc *);
-static void isp_scsi_channel_init(struct ispsoftc *, int);
-static void isp_fibre_init(struct ispsoftc *);
-static void isp_mark_getpdb_all(struct ispsoftc *);
-static int isp_getmap(struct ispsoftc *, fcpos_map_t *);
-static int isp_getpdb(struct ispsoftc *, int, isp_pdb_t *);
-static u_int64_t isp_get_portname(struct ispsoftc *, int, int);
-static int isp_fclink_test(struct ispsoftc *, int);
-static char *isp2100_fw_statename(int);
-static int isp_pdb_sync(struct ispsoftc *);
-static int isp_scan_loop(struct ispsoftc *);
-static int isp_fabric_mbox_cmd(struct ispsoftc *, mbreg_t *);
-static int isp_scan_fabric(struct ispsoftc *, int);
-static void isp_register_fc4_type(struct ispsoftc *);
-static void isp_fw_state(struct ispsoftc *);
-static void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int);
-static void isp_mboxcmd(struct ispsoftc *, mbreg_t *, int);
-
-static void isp_update(struct ispsoftc *);
-static void isp_update_bus(struct ispsoftc *, int);
-static void isp_setdfltparm(struct ispsoftc *, int);
-static int isp_read_nvram(struct ispsoftc *);
-static void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *);
-static void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *);
-static void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *);
-static void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *);
-static void isp_parse_nvram_2100(struct ispsoftc *, u_int8_t *);
+int isp_parse_async(struct ispsoftc *, u_int16_t);
+int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *,
+    u_int32_t *);
+void
+isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *, long *);
+void
+isp_parse_status_24xx(struct ispsoftc *, isp24xx_statusreq_t *, XS_T *, long *);
+void isp_fastpost_complete(struct ispsoftc *, u_int16_t);
+int isp_mbox_continue(struct ispsoftc *);
+void isp_scsi_init(struct ispsoftc *);
+void isp_scsi_channel_init(struct ispsoftc *, int);
+void isp_fibre_init(struct ispsoftc *);
+void isp_fibre_init_2400(struct ispsoftc *);
+void isp_mark_portdb(struct ispsoftc *, int);
+int isp_plogx(struct ispsoftc *, u_int16_t, u_int32_t, int, int);
+int isp_port_login(struct ispsoftc *, u_int16_t, u_int32_t);
+int isp_port_logout(struct ispsoftc *, u_int16_t, u_int32_t);
+int isp_getpdb(struct ispsoftc *, u_int16_t, isp_pdb_t *, int);
+u_int64_t isp_get_portname(struct ispsoftc *, int, int);
+int isp_fclink_test(struct ispsoftc *, int);
+const char *ispfc_fw_statename(int);
+int isp_pdb_sync(struct ispsoftc *);
+int isp_scan_loop(struct ispsoftc *);
+int isp_gid_ft_sns(struct ispsoftc *);
+int isp_gid_ft_ct_passthru(struct ispsoftc *);
+int isp_scan_fabric(struct ispsoftc *);
+int isp_login_device(struct ispsoftc *, u_int32_t, isp_pdb_t *, u_int16_t *);
+int isp_register_fc4_type(struct ispsoftc *);
+int isp_register_fc4_type_24xx(struct ispsoftc *);
+u_int16_t isp_nxt_handle(struct ispsoftc *, u_int16_t);
+void isp_fw_state(struct ispsoftc *);
+void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int);
+void isp_mboxcmd(struct ispsoftc *, mbreg_t *);
+
+void isp_update(struct ispsoftc *);
+void isp_update_bus(struct ispsoftc *, int);
+void isp_setdfltparm(struct ispsoftc *, int);
+void isp_setdfltfcparm(struct ispsoftc *);
+int isp_read_nvram(struct ispsoftc *);
+int isp_read_nvram_2400(struct ispsoftc *);
+void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *);
+void isp_rd_2400_nvram(struct ispsoftc *, u_int32_t, u_int32_t *);
+void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *);
+void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *);
+void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *);
+void isp_fix_nvram_wwns(struct ispsoftc *);
+void isp_parse_nvram_2100(struct ispsoftc *, u_int8_t *);
+void isp_parse_nvram_2400(struct ispsoftc *, u_int8_t *);
 
 /*
  * Reset Hardware.
@@ -161,9 +166,10 @@ void
 isp_reset(struct ispsoftc *isp)
 {
 	mbreg_t mbs;
-	u_int16_t code_org;
+	u_int32_t code_org, val;
 	int loops, i, dodnld = 1;
-	char *btype = "????";
+	static const char *btype = "????";
+	static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
 
 	isp->isp_state = ISP_NILSTATE;
 
@@ -203,10 +209,16 @@ isp_reset(struct ispsoftc *isp)
 			/*
 			 * Just in case it was paused...
 			 */
-			ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
+			if (IS_24XX(isp)) {
+				ISP_WRITE(isp, BIU2400_HCCR,
+				    HCCR_2400_CMD_RELEASE);
+			} else {
+				ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
+			}
 			MEMZERO(&mbs, sizeof (mbs));
 			mbs.param[0] = MBOX_ABOUT_FIRMWARE;
-			isp_mboxcmd(isp, &mbs, MBLOGNONE);
+			mbs.logval = MBLOGNONE;
+			isp_mboxcmd(isp, &mbs);
 			if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 				isp->isp_romfw_rev[0] = mbs.param[1];
 				isp->isp_romfw_rev[1] = mbs.param[2];
@@ -216,13 +228,47 @@ isp_reset(struct ispsoftc *isp)
 		isp->isp_touched = 1;
 	}
 
-	DISABLE_INTS(isp);
+	ISP_DISABLE_INTS(isp);
+
+	/*
+	 * Pick an initial maxcmds value which will be used
+	 * to allocate xflist pointer space. It may be changed
+	 * later by the firmware.
+	 */
+	if (IS_24XX(isp)) {
+		isp->isp_maxcmds = 4096;
+	} else if (IS_2322(isp)) {
+		isp->isp_maxcmds = 2048;
+	} else if (IS_23XX(isp) || IS_2200(isp)) {
+		isp->isp_maxcmds = 1024;
+ 	} else {
+		isp->isp_maxcmds = 512;
+	}
+
+	/*
+	 * Set up DMA for the request and result queues.
+	 *
+	 * We do this now so we can use the request queue
+	 * for a dma
+	 */
+	if (ISP_MBOXDMASETUP(isp) != 0) {
+		isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
+		return;
+	}
+
 
 	/*
 	 * Set up default request/response queue in-pointer/out-pointer
 	 * register indices.
 	 */
-	if (IS_23XX(isp)) {
+	if (IS_24XX(isp)) {
+		isp->isp_rqstinrp = BIU2400_REQINP;
+		isp->isp_rqstoutrp = BIU2400_REQOUTP;
+		isp->isp_respinrp = BIU2400_RSPINP;
+		isp->isp_respoutrp = BIU2400_RSPOUTP;
+		isp->isp_atioinrp = BIU2400_ATIO_RSPINP;
+		isp->isp_atiooutrp = BIU2400_ATIO_REQINP;
+	} else if (IS_23XX(isp)) {
 		isp->isp_rqstinrp = BIU_REQINP;
 		isp->isp_rqstoutrp = BIU_REQOUTP;
 		isp->isp_respinrp = BIU_RSPINP;
@@ -238,7 +284,13 @@ isp_reset(struct ispsoftc *isp)
 	 * Put the board into PAUSE mode (so we can read the SXP registers
 	 * or write FPM/FBM registers).
 	 */
-	ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
+	}
 
 	if (IS_FC(isp)) {
 		switch (isp->isp_type) {
@@ -254,17 +306,27 @@ isp_reset(struct ispsoftc *isp)
 		case ISP_HA_FC_2312:
 			btype = "2312";
 			break;
+		case ISP_HA_FC_2322:
+			btype = "2322";
+			break;
+		case ISP_HA_FC_2400:
+			btype = "2422";
+			break;
 		default:
 			break;
 		}
-		/*
-		 * While we're paused, reset the FPM module and FBM fifos.
-		 */
-		ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
-		ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
-		ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
-		ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
-		ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
+
+		if (!IS_24XX(isp)) {
+			/*
+			 * While we're paused, reset the FPM module and FBM
+			 * fifos.
+			 */
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
+			ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
+			ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
+		}
 	} else if (IS_1240(isp)) {
 		sdparam *sdp = isp->isp_param;
 		btype = "1240";
@@ -447,8 +509,6 @@ isp_reset(struct ispsoftc *isp)
 	 */
 	ISP_RESET0(isp);
 
-again:
-
 	/*
 	 * Hit the chip over the head with hammer,
 	 * and give the ISP a chance to recover.
@@ -470,6 +530,44 @@ again:
 		    DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 
 
+	} else if (IS_24XX(isp)) {
+		/*
+		 * Stop DMA and wait for it to stop.
+		 */
+		ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
+		for (val = loops = 0; loops < 30000; loops++) {
+			USEC_DELAY(10);
+			val = ISP_READ(isp, BIU2400_CSR);
+			if ((val & BIU2400_DMA_ACTIVE) == 0) {
+				break;
+			}
+		} 
+		if (val & BIU2400_DMA_ACTIVE) {
+			ISP_RESET0(isp);
+			isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
+			return;
+		}
+		/*
+		 * Hold it in SOFT_RESET and STOP state for 100us.
+		 */
+		ISP_WRITE(isp, BIU2400_CSR,
+		    BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
+		USEC_DELAY(100);
+		for (loops = 0; loops < 10000; loops++) {
+			USEC_DELAY(5);
+			val = ISP_READ(isp, OUTMAILBOX0);
+		}
+		for (val = loops = 0; loops < 500000; loops ++) {
+			val = ISP_READ(isp, BIU2400_CSR);
+			if ((val & BIU2400_SOFT_RESET) == 0) {
+				break;
+			}
+		}
+		if (val & BIU2400_SOFT_RESET) {
+			ISP_RESET0(isp);
+			isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
+			return;
+		}
 	} else {
 		ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 		/*
@@ -494,8 +592,13 @@ again:
 	loops = MBOX_DELAY_COUNT;
 	for (;;) {
 		if (IS_SCSI(isp)) {
-			if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
+			if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
 				break;
+			}
+		} else if (IS_24XX(isp)) {
+			if (ISP_READ(isp, OUTMAILBOX0) == 0) {
+				break;
+			}
 		} else {
 			if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
 				break;
@@ -503,6 +606,7 @@ again:
 		USEC_DELAY(100);
 		if (--loops < 0) {
 			ISP_DUMPREGS(isp, "chip reset timed out");
+			ISP_RESET0(isp);
 			return;
 		}
 	}
@@ -514,24 +618,41 @@ again:
 
 	if (IS_SCSI(isp)) {
 		ISP_WRITE(isp, BIU_CONF1, 0);
-	} else {
+	} else if (!IS_24XX(isp)) {
 		ISP_WRITE(isp, BIU2100_CSR, 0);
 	}
 
 	/*
 	 * Reset RISC Processor
 	 */
-	ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
-	USEC_DELAY(100);
-	/* Clear semaphore register (just to be sure) */
-	ISP_WRITE(isp, BIU_SEMA, 0);
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
+		USEC_DELAY(100);
+		ISP_WRITE(isp, BIU_SEMA, 0);
+	}
 
+	
 	/*
-	 * Establish some initial burst rate stuff.
-	 * (only for the 1XX0 boards). This really should
-	 * be done later after fetching from NVRAM.
+	 * Post-RISC Reset stuff.
 	 */
-	if (IS_SCSI(isp)) {
+	if (IS_24XX(isp)) {
+		for (val = loops = 0; loops < 5000000; loops++) {
+			USEC_DELAY(5);
+			val = ISP_READ(isp, OUTMAILBOX0);
+			if (val == 0) {
+				break;
+			}
+		}
+		if (val != 0) {
+			ISP_RESET0(isp);
+			isp_prt(isp, ISP_LOGERR, "reset didn't clear");
+			return;
+		}
+	} else if (IS_SCSI(isp)) {
 		u_int16_t tmp = isp->isp_mdvec->dv_conf1;
 		/*
 		 * Busted FIFO. Turn off all but burst enables.
@@ -544,30 +665,36 @@ again:
 			ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
 			ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
 		}
-#ifdef	PTI_CARDS
-		if (((sdparam *) isp->isp_param)->isp_ultramode) {
-			while (ISP_READ(isp, RISC_MTR) != 0x1313) {
-				ISP_WRITE(isp, RISC_MTR, 0x1313);
-				ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
+		if (SDPARAM(isp)->isp_ptisp) {
+			if (SDPARAM(isp)->isp_ultramode) {
+				while (ISP_READ(isp, RISC_MTR) != 0x1313) {
+					ISP_WRITE(isp, RISC_MTR, 0x1313);
+					ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
+				}
+			} else {
+				ISP_WRITE(isp, RISC_MTR, 0x1212);
 			}
+			/*
+			 * PTI specific register
+			 */
+			ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
 		} else {
 			ISP_WRITE(isp, RISC_MTR, 0x1212);
 		}
-		/*
-		 * PTI specific register
-		 */
-		ISP_WRITE(isp, RISC_EMB, DUAL_BANK)
-#else
-		ISP_WRITE(isp, RISC_MTR, 0x1212);
-#endif
+		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 	} else {
 		ISP_WRITE(isp, RISC_MTR2100, 0x1212);
 		if (IS_2200(isp) || IS_23XX(isp)) {
 			ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
 		}
+		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 	}
 
-	ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
+	ISP_WRITE(isp, isp->isp_rqstinrp, 0);
+	ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
+	ISP_WRITE(isp, isp->isp_respinrp, 0);
+	ISP_WRITE(isp, isp->isp_respoutrp, 0);
+
 
 	/*
 	 * Do MD specific post initialization
@@ -580,13 +707,14 @@ again:
 	 * Avoid doing this on the 2312 because you can generate a PCI
 	 * parity error (chip breakage).
 	 */
-	if (IS_23XX(isp)) {
-		USEC_DELAY(5);
+	if (IS_2312(isp)) {
+		USEC_DELAY(100);
 	} else {
 		loops = MBOX_DELAY_COUNT;
 		while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
 			USEC_DELAY(100);
 			if (--loops < 0) {
+				ISP_RESET0(isp);
 				isp_prt(isp, ISP_LOGERR,
 				    "MBOX_BUSY never cleared on reset");
 				return;
@@ -605,12 +733,14 @@ again:
 	 */
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_NO_OP;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		ISP_RESET0(isp);
 		return;
 	}
 
-	if (IS_SCSI(isp)) {
+	if (IS_SCSI(isp) || IS_24XX(isp)) {
 		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_MAILBOX_REG_TEST;
 		mbs.param[1] = 0xdead;
@@ -618,13 +748,18 @@ again:
 		mbs.param[3] = 0xffff;
 		mbs.param[4] = 0x1111;
 		mbs.param[5] = 0xa5a5;
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.param[6] = 0x0000;
+		mbs.param[7] = 0x0000;
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			ISP_RESET0(isp);
 			return;
 		}
 		if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
 		    mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
 		    mbs.param[5] != 0xa5a5) {
+			ISP_RESET0(isp);
 			isp_prt(isp, ISP_LOGERR,
 			    "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
 			    mbs.param[1], mbs.param[2], mbs.param[3],
@@ -648,26 +783,193 @@ again:
 		dodnld = 0;
 	}
 
-	if (IS_23XX(isp))
+	if (IS_24XX(isp)) {
+		code_org = ISP_CODE_ORG_2400;
+	} else if (IS_23XX(isp)) {
 		code_org = ISP_CODE_ORG_2300;
-	else
+	} else {
 		code_org = ISP_CODE_ORG;
+	}
+
+	if (dodnld && IS_24XX(isp)) {
+		const u_int32_t *ptr = isp->isp_mdvec->dv_ispfw;
+
+		/*
+		 * NB: Whatever you do do, do *not* issue the VERIFY FIRMWARE
+		 * NB: command to the 2400 while loading new firmware. This
+		 * NB: causes the new f/w to start and immediately crash back
+		 * NB: to the ROM.
+		 */
+
+		/*
+		 * Keep loading until we run out of f/w.
+		 */
+		code_org = ptr[2];	/* 1st load address is our start addr */
+
+		for (;;) {
+			u_int32_t la, wi, wl;
+
+			isp_prt(isp, ISP_LOGDEBUG0,
+			    "load 0x%x words of code at load address 0x%x",
+			    ptr[3], ptr[2]);
+
+			wi = 0;
+			la = ptr[2];
+			wl = ptr[3];
+
+			while (wi < ptr[3]) {
+				u_int32_t *cp;
+				u_int32_t nw;
+
+				nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 2;
+				if (nw > wl) {
+					nw = wl;
+				}
+				cp = isp->isp_rquest;
+				for (i = 0; i < nw; i++) {
+					ISP_IOXPUT_32(isp,  ptr[wi++], &cp[i]);
+					wl--;
+				}
+				MEMORYBARRIER(isp, SYNC_REQUEST,
+				    0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
+				MEMZERO(&mbs, sizeof (mbs));
+				mbs.param[0] = MBOX_LOAD_RISC_RAM;
+				mbs.param[1] = la;
+				mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
+				mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
+				mbs.param[4] = nw >> 16;
+				mbs.param[5] = nw;
+				mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
+				mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
+				mbs.param[8] = la >> 16;
+				mbs.logval = MBLOGALL;
+				isp_mboxcmd(isp, &mbs);
+				if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+					isp_prt(isp, ISP_LOGERR,
+					    "F/W Risc Ram Load Failed");
+					ISP_RESET0(isp);
+					return;
+				}
+				la += nw;
+			}
+
+			if (ptr[1] == 0) {
+				break;
+			}
+			ptr += ptr[3];
+		} 
+		isp->isp_loaded_fw = 1;
+	} else if (dodnld && IS_23XX(isp)) {
+		const u_int16_t *ptr = isp->isp_mdvec->dv_ispfw;
+		u_int16_t wi, wl, segno;
+		u_int32_t la;
+
+		la = code_org;
+		segno = 0;
+
+		for (;;) {
+			u_int32_t nxtaddr;
+
+			isp_prt(isp, ISP_LOGDEBUG0,
+			    "load 0x%x words of code at load address 0x%x",
+			    ptr[3], la);
+
+			wi = 0;
+			wl = ptr[3];
+
+			while (wi < ptr[3]) {
+				u_int16_t *cp;
+				u_int32_t nw;
+				
+				nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 1;
+				if (nw > wl) {
+					nw = wl;
+				}
+				if (nw > (1 << 15)) {
+					nw = 1 << 15;
+				}
+				cp = isp->isp_rquest;
+				for (i = 0; i < nw; i++) {
+					ISP_IOXPUT_16(isp,  ptr[wi++], &cp[i]);
+					wl--;
+				}
+				MEMORYBARRIER(isp, SYNC_REQUEST,
+				    0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
+				MEMZERO(&mbs, sizeof (mbs));
+				mbs.param[0] = MBOX_LOAD_RISC_RAM;
+				mbs.param[1] = la;
+				mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
+				mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
+				mbs.param[4] = nw;
+				mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
+				mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
+				mbs.param[8] = la >> 16;
+				mbs.logval = MBLOGALL;
+				isp_mboxcmd(isp, &mbs);
+				if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+					isp_prt(isp, ISP_LOGERR,
+					    "F/W Risc Ram Load Failed");
+					ISP_RESET0(isp);
+					return;
+				}
+				la += nw;
+			}
+
+			if (!IS_2322(isp)) {
+				/*
+				 * Verify that it downloaded correctly.
+				 */
+				MEMZERO(&mbs, sizeof (mbs));
+				mbs.param[0] = MBOX_VERIFY_CHECKSUM;
+				mbs.param[1] = code_org;
+				mbs.logval = MBLOGNONE;
+				isp_mboxcmd(isp, &mbs);
+				if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+					isp_prt(isp, ISP_LOGERR, dcrc);
+					ISP_RESET0(isp);
+					return;
+				}
+				break;
+			}
+
+			if (++segno == 3) {
+				break;
+			}
+
+			/*
+			 * If we're a 2322, the firmware actually comes in
+			 * three chunks. We loaded the first at the code_org
+			 * address. The other two chunks, which follow right
+			 * after each other in memory here, get loaded at
+			 * addresses specfied at offset 0x9..0xB.
+			 */
 
-	if (dodnld) {
-		isp->isp_mbxworkp = (void *) &isp->isp_mdvec->dv_ispfw[1];
-		isp->isp_mbxwrk0 = isp->isp_mdvec->dv_ispfw[3] - 1;
+			nxtaddr = ptr[3];
+			ptr = &ptr[nxtaddr];
+			la = ptr[5] | ((ptr[4] & 0x3f) << 16);
+		}
+		isp->isp_loaded_fw = 1;
+	} else if (dodnld) {
+		union {
+			const u_int16_t *cp;
+			u_int16_t *np;
+		} u;
+		u.cp = isp->isp_mdvec->dv_ispfw;
+		isp->isp_mbxworkp = &u.np[1];
+		isp->isp_mbxwrk0 = u.np[3] - 1;
 		isp->isp_mbxwrk1 = code_org + 1;
 		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_WRITE_RAM_WORD;
 		mbs.param[1] = code_org;
-		mbs.param[2] = isp->isp_mdvec->dv_ispfw[0];
-		isp_mboxcmd(isp, &mbs, MBLOGNONE);
+		mbs.param[2] = u.np[0];
+		mbs.logval = MBLOGNONE;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			isp_prt(isp, ISP_LOGERR,
 			    "F/W download failed at word %d",
 			    isp->isp_mbxwrk1 - code_org);
-			dodnld = 0;
-			goto again;
+			ISP_RESET0(isp);
+			return;
 		}
 		/*
 		 * Verify that it downloaded correctly.
@@ -675,9 +977,11 @@ again:
 		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_VERIFY_CHECKSUM;
 		mbs.param[1] = code_org;
-		isp_mboxcmd(isp, &mbs, MBLOGNONE);
+		mbs.logval = MBLOGNONE;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
-			isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
+			isp_prt(isp, ISP_LOGERR, dcrc);
+			ISP_RESET0(isp);
 			return;
 		}
 		isp->isp_loaded_fw = 1;
@@ -695,13 +999,40 @@ again:
 
 
 	MEMZERO(&mbs, sizeof (mbs));
+	mbs.timeout = 1000000;
 	mbs.param[0] = MBOX_EXEC_FIRMWARE;
-	mbs.param[1] = code_org;
-	isp_mboxcmd(isp, &mbs, MBLOGNONE);
+	if (IS_24XX(isp)) {
+		mbs.param[1] = code_org >> 16;
+		mbs.param[2] = code_org;
+		if (isp->isp_loaded_fw) {
+			mbs.param[3] = 0;
+		} else {
+			mbs.param[3] = 1;
+		}
+	} else if (IS_2322(isp)) {
+		mbs.param[1] = code_org;
+		if (isp->isp_loaded_fw) {
+			mbs.param[2] = 0;
+		} else {
+			mbs.param[2] = 1;
+		}
+	} else {
+		mbs.param[1] = code_org;
+	}
+
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
+	if (IS_2322(isp) || IS_24XX(isp)) {
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			ISP_RESET0(isp);
+			return;
+		}
+	}
+
 	/*
-	 * Give it a chance to start.
+	 * Give it a chance to finish starting up.
 	 */
-	USEC_DELAY(500);
+	USEC_DELAY(250000);
 
 	if (IS_SCSI(isp)) {
 		/*
@@ -711,15 +1042,24 @@ again:
 			MEMZERO(&mbs, sizeof (mbs));
 			mbs.param[0] = MBOX_SET_CLOCK_RATE;
 			mbs.param[1] = isp->isp_clock;
-			isp_mboxcmd(isp, &mbs, MBLOGALL);
+			mbs.logval = MBLOGNONE;
+			isp_mboxcmd(isp, &mbs);
 			/* we will try not to care if this fails */
 		}
 	}
 
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_ABOUT_FIRMWARE;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		ISP_RESET0(isp);
+		return;
+	}
+
+	if (IS_24XX(isp) && mbs.param[1] == 0xdead) {
+		isp_prt(isp, ISP_LOGERR, "f/w didn't *really* start");
+		ISP_RESET0(isp);
 		return;
 	}
 
@@ -744,7 +1084,8 @@ again:
 		isp->isp_fwrev[1] = mbs.param[2];
 		isp->isp_fwrev[2] = mbs.param[3];
 	}
-	isp_prt(isp, ISP_LOGCONFIG,
+
+	isp_prt(isp, ISP_LOGALL,
 	    "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
 	    btype, isp->isp_revision, dodnld? "loaded" : "resident",
 	    isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
@@ -755,9 +1096,9 @@ again:
 		 * than 1.17.0, unless it's the firmware we specifically
 		 * are loading.
 		 *
-		 * Note that all 22XX and 23XX f/w is greater than 1.X.0.
+		 * Note that all 22XX and later f/w is greater than 1.X.0.
 		 */
-		if (!(ISP_FW_NEWER_THAN(isp, 1, 17, 0))) {
+		if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
 #ifdef	USE_SMALLER_2100_FIRMWARE
 			FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
 #else
@@ -768,9 +1109,27 @@ again:
 			isp_prt(isp, ISP_LOGDEBUG0,
 			    "Firmware Attributes = 0x%x", mbs.param[6]);
 		}
-		if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) {
-			isp_prt(isp, ISP_LOGCONFIG,
-			    "Installed in 64-Bit PCI slot");
+		FCPARAM(isp)->isp_2klogin = 0;
+		FCPARAM(isp)->isp_sccfw = 0;
+		FCPARAM(isp)->isp_tmode = 0;
+		if (IS_24XX(isp)) {
+			FCPARAM(isp)->isp_2klogin = 1;
+			FCPARAM(isp)->isp_sccfw = 1;
+			FCPARAM(isp)->isp_tmode = 1;
+		} else {
+			if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
+				FCPARAM(isp)->isp_sccfw = 1;
+			}
+			if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_2KLOGINS) {
+				FCPARAM(isp)->isp_2klogin = 1;
+				FCPARAM(isp)->isp_sccfw = 1;
+			}
+			if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_TMODE) {
+				FCPARAM(isp)->isp_tmode = 1;
+			}
+		}
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported");
 		}
 	}
 
@@ -781,24 +1140,23 @@ again:
 		    isp->isp_romfw_rev[2]);
 	}
 
-	MEMZERO(&mbs, sizeof (mbs));
-	mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
-	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
-		return;
+	if (!IS_24XX(isp)) {
+		MEMZERO(&mbs, sizeof (mbs));
+		mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			ISP_RESET0(isp);
+			return;
+		}
+		if (isp->isp_maxcmds >= mbs.param[2]) {
+			isp->isp_maxcmds = mbs.param[2];
+		}
 	}
-	isp->isp_maxcmds = mbs.param[2];
-	isp_prt(isp, ISP_LOGINFO,
-	    "%d max I/O commands supported", mbs.param[2]);
+	isp_prt(isp, ISP_LOGCONFIG,
+	    "%d max I/O command limit set", isp->isp_maxcmds);
 	isp_fw_state(isp);
 
-	/*
-	 * Set up DMA for the request and result mailboxes.
-	 */
-	if (ISP_MBOXDMASETUP(isp) != 0) {
-		isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
-		return;
-	}
 	isp->isp_state = ISP_RESETSTATE;
 
 	/*
@@ -829,12 +1187,24 @@ again:
 			isp->isp_maxluns = 8;
 		}
 	} else {
-		if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
+		if (FCPARAM(isp)->isp_sccfw) {
 			isp->isp_maxluns = 16384;
 		} else {
 			isp->isp_maxluns = 16;
 		}
 	}
+	/*
+	 * Must do this first to get defaults established.
+	 */
+	if (IS_SCSI(isp)) {
+		isp_setdfltparm(isp, 0);
+		if (IS_DUALBUS(isp)) {
+			isp_setdfltparm(isp, 1);
+		}
+	} else {
+		isp_setdfltfcparm(isp);
+	}
+
 }
 
 /*
@@ -846,21 +1216,27 @@ again:
 void
 isp_init(struct ispsoftc *isp)
 {
-	/*
-	 * Must do this first to get defaults established.
-	 */
-	isp_setdfltparm(isp, 0);
-	if (IS_DUALBUS(isp)) {
-		isp_setdfltparm(isp, 1);
-	}
 	if (IS_FC(isp)) {
-		isp_fibre_init(isp);
+		/*
+		 * Do this *before* initializing the firmware.
+		 */
+		ISP_MARK_PORTDB(isp, 0);
+		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
+		FCPARAM(isp)->isp_loopstate = LOOP_NIL;
+
+		if (isp->isp_role != ISP_ROLE_NONE) {
+			if (IS_24XX(isp)) {
+				isp_fibre_init_2400(isp);
+			} else {
+				isp_fibre_init(isp);
+			}
+		}
 	} else {
 		isp_scsi_init(isp);
 	}
 }
 
-static void
+void
 isp_scsi_init(struct ispsoftc *isp)
 {
 	sdparam *sdp_chan0, *sdp_chan1;
@@ -898,8 +1274,8 @@ isp_scsi_init(struct ispsoftc *isp)
 	mbs.param[2] = sdp_chan0->isp_retry_delay;
 	mbs.param[6] = sdp_chan1->isp_retry_count;
 	mbs.param[7] = sdp_chan1->isp_retry_delay;
-
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		return;
 	}
@@ -911,7 +1287,8 @@ isp_scsi_init(struct ispsoftc *isp)
 	mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
 	mbs.param[1] = sdp_chan0->isp_async_data_setup;
 	mbs.param[2] = sdp_chan1->isp_async_data_setup;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		return;
 	}
@@ -927,8 +1304,8 @@ isp_scsi_init(struct ispsoftc *isp)
 	mbs.param[2] =
 	    (sdp_chan1->isp_req_ack_active_neg << 4) |
 	    (sdp_chan1->isp_data_line_active_neg << 5);
-
-	isp_mboxcmd(isp, &mbs, MBLOGNONE);
+	mbs.logval = MBLOGNONE;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		isp_prt(isp, ISP_LOGERR,
 		    "failed to set active negation state (%d,%d), (%d,%d)",
@@ -948,7 +1325,8 @@ isp_scsi_init(struct ispsoftc *isp)
 	mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
 	mbs.param[1] = sdp_chan0->isp_tag_aging;
 	mbs.param[2] = sdp_chan1->isp_tag_aging;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
 		    sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
@@ -962,7 +1340,8 @@ isp_scsi_init(struct ispsoftc *isp)
 	mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
 	mbs.param[1] = sdp_chan0->isp_selection_timeout;
 	mbs.param[2] = sdp_chan1->isp_selection_timeout;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		return;
 	}
@@ -985,7 +1364,8 @@ isp_scsi_init(struct ispsoftc *isp)
 		mbs.param[4] = 0;
 		mbs.param[6] = DMA_WD3(isp->isp_result_dma);
 		mbs.param[7] = DMA_WD2(isp->isp_result_dma);
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			return;
 		}
@@ -999,7 +1379,8 @@ isp_scsi_init(struct ispsoftc *isp)
 		mbs.param[5] = 0;
 		mbs.param[6] = DMA_WD3(isp->isp_result_dma);
 		mbs.param[7] = DMA_WD2(isp->isp_result_dma);
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			return;
 		}
@@ -1011,7 +1392,8 @@ isp_scsi_init(struct ispsoftc *isp)
 		mbs.param[2] = DMA_WD1(isp->isp_result_dma);
 		mbs.param[3] = DMA_WD0(isp->isp_result_dma);
 		mbs.param[4] = 0;
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			return;
 		}
@@ -1023,7 +1405,8 @@ isp_scsi_init(struct ispsoftc *isp)
 		mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 		mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 		mbs.param[5] = 0;
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			return;
 		}
@@ -1048,14 +1431,13 @@ isp_scsi_init(struct ispsoftc *isp)
 	if (IS_ULTRA2(isp) || IS_1240(isp))
 		mbs.param[1] |= FW_FEATURE_RIO_16BIT;
 #else
-#ifndef	ISP_NO_FASTPOST
 	if (IS_ULTRA2(isp) || IS_1240(isp))
 		mbs.param[1] |= FW_FEATURE_FAST_POST;
 #endif
-#endif
 	if (mbs.param[1] != 0) {
 		u_int16_t sfeat = mbs.param[1];
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 			isp_prt(isp, ISP_LOGINFO,
 			    "Enabled FW features (0x%x)", sfeat);
@@ -1068,7 +1450,7 @@ isp_scsi_init(struct ispsoftc *isp)
 	isp->isp_state = ISP_INITSTATE;
 }
 
-static void
+void
 isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 {
 	sdparam *sdp;
@@ -1084,7 +1466,8 @@ isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
 	mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		return;
 	}
@@ -1140,7 +1523,8 @@ isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 		    "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
 		    channel, tgt, mbs.param[2], mbs.param[3] >> 8,
 		    mbs.param[3] & 0xff);
-		isp_mboxcmd(isp, &mbs, MBLOGNONE);
+		mbs.logval = MBLOGNONE;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			sdf = DPARM_SAFE_DFLT;
 			MEMZERO(&mbs, sizeof (mbs));
@@ -1148,7 +1532,8 @@ isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 			mbs.param[1] = (tgt << 8) | (channel << 15);
 			mbs.param[2] = sdf;
 			mbs.param[3] = 0;
-			isp_mboxcmd(isp, &mbs, MBLOGALL);
+			mbs.logval = MBLOGALL;
+			isp_mboxcmd(isp, &mbs);
 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 				continue;
 			}
@@ -1172,7 +1557,8 @@ isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 			mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
 			mbs.param[2] = sdp->isp_max_queue_depth;
 			mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
-			isp_mboxcmd(isp, &mbs, MBLOGALL);
+			mbs.logval = MBLOGALL;
+			isp_mboxcmd(isp, &mbs);
 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 				break;
 			}
@@ -1189,37 +1575,21 @@ isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 
 /*
  * Fibre Channel specific initialization.
- *
- * Locks are held before coming here.
  */
-static void
+void
 isp_fibre_init(struct ispsoftc *isp)
 {
 	fcparam *fcp;
 	isp_icb_t local, *icbp = &local;
 	mbreg_t mbs;
-	int loopid;
+	int ownloopid;
 	u_int64_t nwwn, pwwn;
 
 	fcp = isp->isp_param;
 
-	/*
-	 * Do this *before* initializing the firmware.
-	 */
-	isp_mark_getpdb_all(isp);
-	fcp->isp_fwstate = FW_CONFIG_WAIT;
-	fcp->isp_loopstate = LOOP_NIL;
-
-	/*
-	 * If we have no role (neither target nor initiator), return.
-	 */
-	if (isp->isp_role == ISP_ROLE_NONE) {
-		return;
-	}
-
-	loopid = fcp->isp_loopid;
 	MEMZERO(icbp, sizeof (*icbp));
 	icbp->icb_version = ICB_VERSION1;
+	icbp->icb_fwoptions = fcp->isp_fwoptions;
 
 	/*
 	 * Firmware Options are either retrieved from NVRAM or
@@ -1231,8 +1601,8 @@ isp_fibre_init(struct ispsoftc *isp)
 	/*
 	 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
 	 */
-	if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
-		fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
+	if (IS_2100(isp) && isp->isp_revision < 5) {
+		icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
 	}
 
 	/*
@@ -1241,27 +1611,29 @@ isp_fibre_init(struct ispsoftc *isp)
 	 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
 	 */
 	if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
-		fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
+		icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
 	}
 
 	/*
 	 * Insist on Port Database Update Async notifications
 	 */
-	fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
+	icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
 
 	/*
 	 * Make sure that target role reflects into fwoptions.
 	 */
 	if (isp->isp_role & ISP_ROLE_TARGET) {
-		fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
+		icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
 	} else {
-		fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
+		icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
+	}
+
+	if (isp->isp_role & ISP_ROLE_INITIATOR) {
+		icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
+	} else {
+		icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
 	}
 
-	/*
-	 * Propagate all of this into the ICB structure.
-	 */
-	icbp->icb_fwoptions = fcp->isp_fwoptions;
 	icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
 	if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
 	    icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
@@ -1285,7 +1657,21 @@ isp_fibre_init(struct ispsoftc *isp)
 	}
 	icbp->icb_retry_delay = fcp->isp_retry_delay;
 	icbp->icb_retry_count = fcp->isp_retry_count;
-	icbp->icb_hardaddr = loopid;
+	icbp->icb_hardaddr = fcp->isp_loopid;
+	ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
+	if (icbp->icb_hardaddr > 125) {
+		icbp->icb_hardaddr = 0;
+		ownloopid = 0;
+	}
+
+	/*
+	 * Our life seems so much better with 2200s and later with
+	 * the latest f/w if we set Hard Address.
+	 */
+	if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
+		icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
+	}
+
 	/*
 	 * Right now we just set extended options to prefer point-to-point
 	 * over loop based upon some soft config options.
@@ -1311,26 +1697,21 @@ isp_fibre_init(struct ispsoftc *isp)
 			icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
 			break;
 		}
-		if (IS_23XX(isp)) {
+		if (IS_2200(isp)) {
+			icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
+		} else {
 			/*
 			 * QLogic recommends that FAST Posting be turned
 			 * off for 23XX cards and instead allow the HBA
 			 * to write response queue entries and interrupt
 			 * after a delay (ZIO).
-			 *
-			 * If we set ZIO, it will disable fast posting,
-			 * so we don't need to clear it in fwoptions.
-			 */
-			icbp->icb_xfwoptions |= ICBXOPT_ZIO;
-#if	0
-			/*
-			 * Values, in 100us increments. The default
-			 * is 2 (200us) if a value 0 (default) is
-			 * selected.
 			 */
-			icbp->icb_idelaytimer = 2;
-#endif
-
+			icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
+			if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) ==
+			    ICBXOPT_ZIO) {
+				icbp->icb_xfwoptions |= ICBXOPT_ZIO;
+				icbp->icb_idelaytimer = 10;
+			}
 			if (isp->isp_confopts & ISP_CFG_ONEGB) {
 				icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
 			} else if (isp->isp_confopts & ISP_CFG_TWOGB) {
@@ -1338,32 +1719,15 @@ isp_fibre_init(struct ispsoftc *isp)
 			} else {
 				icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
 			}
+			if (fcp->isp_zfwoptions & ICBZOPT_50_OHM) {
+				icbp->icb_zfwoptions |= ICBZOPT_50_OHM;
+			}
 		}
 	}
 
-#ifndef	ISP_NO_RIO_FC
-	/*
-	 * RIO seems to be enabled in 2100s for fw >= 1.17.0.
-	 *
-	 * I've had some questionable problems with RIO on 2200.
-	 * More specifically, on a 2204 I had problems with RIO
-	 * on a Linux system where I was dropping commands right
-	 * and left. It's not clear to me what the actual problem
-	 * was.
-	 *
-	 * 23XX Cards do not support RIO. Instead they support ZIO.
-	 */
-#if	0
-	if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
-		icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
-		icbp->icb_racctimer = 4;
-		icbp->icb_idelaytimer = 8;
-	}
-#endif
-#endif
 
 	/*
-	 * For 22XX > 2.1.26 && 23XX, set someoptions.
+	 * For 22XX > 2.1.26 && 23XX, set some options.
 	 * XXX: Probably okay for newer 2100 f/w too.
 	 */
 	if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
@@ -1377,16 +1741,14 @@ isp_fibre_init(struct ispsoftc *isp)
 		mbs.param[1] = 0xb;
 		mbs.param[2] = 0;
 		mbs.param[3] = 0;
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
-	}
-	icbp->icb_logintime = 30;	/* 30 second login timeout */
-
-	if (IS_23XX(isp)) {
-		ISP_WRITE(isp, isp->isp_rqstinrp, 0);
-        	ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
-        	ISP_WRITE(isp, isp->isp_respinrp, 0);
-		ISP_WRITE(isp, isp->isp_respoutrp, 0);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			return;
+		}
 	}
+	icbp->icb_logintime = ICB_LOGIN_TOV;
+	icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
 
 	nwwn = ISP_NODEWWN(isp);
 	pwwn = ISP_PORTWWN(isp);
@@ -1400,12 +1762,25 @@ isp_fibre_init(struct ispsoftc *isp)
 		    ((u_int32_t) (nwwn & 0xffffffff)),
 		    ((u_int32_t) (pwwn >> 32)),
 		    ((u_int32_t) (pwwn & 0xffffffff)));
+	} else if (pwwn) {
+		icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
+		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
+		isp_prt(isp, ISP_LOGDEBUG1,
+		    "Setting ICB Port 0x%08x%08x",
+		    ((u_int32_t) (pwwn >> 32)),
+		    ((u_int32_t) (pwwn & 0xffffffff)));
 	} else {
-		isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
-		icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN);
+		isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
+		return;
 	}
 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
+	if (icbp->icb_rqstqlen < 1) {
+		isp_prt(isp, ISP_LOGERR, "bad request queue length");
+	}
 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
+	if (icbp->icb_rsltqlen < 1) {
+		isp_prt(isp, ISP_LOGERR, "bad result queue length");
+	}
 	icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
 	icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
 	icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
@@ -1414,6 +1789,7 @@ isp_fibre_init(struct ispsoftc *isp)
 	icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
 	icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
 	icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
+
 	isp_prt(isp, ISP_LOGDEBUG0,
 	    "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
 	    icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
@@ -1430,17 +1806,21 @@ isp_fibre_init(struct ispsoftc *isp)
 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
+	mbs.logval = MBLOGALL;
+	mbs.timeout = 30 * 1000000;
 	isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
-	    fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
-	    (uint32_t) fcp->isp_scdma);
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	    fcp->isp_scratch, (u_int32_t) ((u_int64_t)fcp->isp_scdma >> 32),
+	    (u_int32_t) fcp->isp_scdma);
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
+	isp_mboxcmd(isp, &mbs);
 	FC_SCRATCH_RELEASE(isp);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		isp_print_bytes(isp, "isp_fibre_init", sizeof (*icbp), icbp);
 		return;
 	}
-	isp->isp_reqidx = isp->isp_reqodx = 0;
+	isp->isp_reqidx = 0;
+	isp->isp_reqodx = 0;
 	isp->isp_residx = 0;
-	isp->isp_sendmarker = 1;
 
 	/*
 	 * Whatever happens, we're now committed to being here.
@@ -1448,84 +1828,615 @@ isp_fibre_init(struct ispsoftc *isp)
 	isp->isp_state = ISP_INITSTATE;
 }
 
-/*
- * Fibre Channel Support- get the port database for the id.
- *
- * Locks are held before coming here. Return 0 if success,
- * else failure.
- */
-
-static int
-isp_getmap(struct ispsoftc *isp, fcpos_map_t *map)
+void
+isp_fibre_init_2400(struct ispsoftc *isp)
 {
-	fcparam *fcp = (fcparam *) isp->isp_param;
+	fcparam *fcp;
+	isp_icb_2400_t local, *icbp = &local;
 	mbreg_t mbs;
+	int ownloopid;
+	u_int64_t nwwn, pwwn;
+
+	fcp = isp->isp_param;
+
+	/*
+	 * Turn on LIP F8 async event (1)
+	 */
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
+	mbs.param[1] = 1;
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		return;
+	}
+
+	/*
+	 * XXX: This should be applied to icb- not fwoptions
+	 */
+	if (isp->isp_role & ISP_ROLE_TARGET) {
+		fcp->isp_fwoptions |= ICB2400_OPT1_TGT_ENABLE;
+	} else {
+		fcp->isp_fwoptions &= ~ICB2400_OPT1_TGT_ENABLE;
+	}
+
+	if (isp->isp_role & ISP_ROLE_INITIATOR) {
+		fcp->isp_fwoptions &= ~ICB2400_OPT1_INI_DISABLE;
+	} else {
+		fcp->isp_fwoptions |= ICB2400_OPT1_INI_DISABLE;
+	}
+
+	MEMZERO(icbp, sizeof (*icbp));
+	icbp->icb_version = ICB_VERSION1;
+	icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
+	if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
+	    icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
+		isp_prt(isp, ISP_LOGERR,
+		    "bad frame length (%d) from NVRAM- using %d",
+		    fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
+		icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
+	}
+
+	icbp->icb_execthrottle = fcp->isp_execthrottle;
+	if (icbp->icb_execthrottle < 1) {
+		isp_prt(isp, ISP_LOGERR,
+		    "bad execution throttle of %d- using 16",
+		    fcp->isp_execthrottle);
+		icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
+	}
+
+	if (isp->isp_role & ISP_ROLE_TARGET) {
+		/*
+		 * Get current resource count
+		 */
+		MEMZERO(&mbs, sizeof (mbs));
+		mbs.param[0] = MBOX_GET_RESOURCE_COUNT;
+		mbs.obits = 0x4cf;
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			return;
+		}
+		icbp->icb_xchgcnt = mbs.param[3];
+	}
 
- 	MEMZERO(&mbs, sizeof (mbs));
-	mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP;
+	icbp->icb_fwoptions1 = fcp->isp_fwoptions;
+
+	icbp->icb_hardaddr = fcp->isp_loopid;
+	ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
+	if (icbp->icb_hardaddr > 125) {
+		icbp->icb_hardaddr = 0;
+		ownloopid = 0;
+	}
+	if (ownloopid) {
+		icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
+	}
+
+	icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
+	switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
+	case ISP_CFG_NPORT:
+		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
+		icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_2_LOOP;
+		break;
+	case ISP_CFG_NPORT_ONLY:
+		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
+		icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
+		break;
+	case ISP_CFG_LPORT_ONLY:
+		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
+		icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
+		break;
+	default:
+		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
+		icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
+		break;
+	}
+
+	switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
+	case ICB2400_OPT2_ZIO:
+	case ICB2400_OPT2_ZIO1:
+		icbp->icb_idelaytimer = 0;
+		break;
+	case 0:
+		break;
+	default:
+		isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field",
+		    icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
+		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
+		break;
+	}
+
+	icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
+	icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_AUTO;
+	if (isp->isp_confopts & ISP_CFG_ONEGB) {
+		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_ONEGB;
+	} else if (isp->isp_confopts & ISP_CFG_TWOGB) {
+		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_TWOGB;
+	} else if (isp->isp_confopts & ISP_CFG_FOURGB) {
+		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_FOURGB;
+	} else {
+		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
+	}
+
+	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
+		icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
+	}
+	icbp->icb_logintime = ICB_LOGIN_TOV;
+
+	nwwn = ISP_NODEWWN(isp);
+	pwwn = ISP_PORTWWN(isp);
+
+	if (nwwn && pwwn) {
+		icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
+		MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
+		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
+		isp_prt(isp, ISP_LOGDEBUG1,
+		    "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
+		    ((u_int32_t) (nwwn >> 32)),
+		    ((u_int32_t) (nwwn & 0xffffffff)),
+		    ((u_int32_t) (pwwn >> 32)),
+		    ((u_int32_t) (pwwn & 0xffffffff)));
+	} else if (pwwn) {
+		icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
+		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
+		isp_prt(isp, ISP_LOGDEBUG1,
+		    "Setting ICB Port 0x%08x%08x",
+		    ((u_int32_t) (pwwn >> 32)),
+		    ((u_int32_t) (pwwn & 0xffffffff)));
+	} else {
+		isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
+		return;
+	}
+	icbp->icb_retry_count = fcp->isp_retry_count;
+
+	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
+	if (icbp->icb_rqstqlen < 8) {
+		isp_prt(isp, ISP_LOGERR, "bad request queue length %d",
+		    icbp->icb_rqstqlen);
+		return;
+	}
+	icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
+	if (icbp->icb_rsltqlen < 8) {
+		isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
+		    icbp->icb_rsltqlen);
+		return;
+	}
+	icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
+	icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
+	icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
+	icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
+
+	icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
+	icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
+	icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
+	icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
+
+#ifdef	ISP_TARGET_MODE
+	if (isp->isp_role & ISP_ROLE_TARGET) {
+		icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
+		if (icbp->icb_atioqlen < 8) {
+			isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d",
+			    icbp->icb_atioqlen);
+			return;
+		}
+		icbp->icb_atioqaddr[RQRSP_ADDR0015] =
+		    DMA_WD0(isp->isp_atioq_dma);
+		icbp->icb_atioqaddr[RQRSP_ADDR1631] =
+		    DMA_WD1(isp->isp_atioq_dma);
+		icbp->icb_atioqaddr[RQRSP_ADDR3247] =
+		    DMA_WD2(isp->isp_atioq_dma);
+		icbp->icb_atioqaddr[RQRSP_ADDR4863] =
+		    DMA_WD3(isp->isp_atioq_dma);
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "isp_fibre_init_2400: atioq %04x%04x%04x%04x",
+		    DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
+		    DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
+	}
+#endif
+
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
+	    icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
+
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x",
+	    DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
+	    DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma),
+	    DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
+	    DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
+
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "isp_fibre_init_2400", sizeof (*icbp),
+		    icbp);
+	}
+	FC_SCRATCH_ACQUIRE(isp);
+	isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
+
+
+	/*
+	 * Init the firmware
+	 */
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_INIT_FIRMWARE;
 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
-	FC_SCRATCH_ACQUIRE(isp);
-	isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
-	if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
-		MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t));
-		map->fwmap = mbs.param[1] != 0;
-		FC_SCRATCH_RELEASE(isp);
-		return (0);
-	}
+	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
+	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
+	mbs.logval = MBLOGALL;
+	mbs.timeout = 30 * 1000000;
+	isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x",
+	    DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma),
+	    DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
+	isp_mboxcmd(isp, &mbs);
 	FC_SCRATCH_RELEASE(isp);
-	return (-1);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		return;
+	}
+	isp->isp_reqidx = 0;
+	isp->isp_reqodx = 0;
+	isp->isp_residx = 0;
+
+	/*
+	 * Whatever happens, we're now committed to being here.
+	 */
+	isp->isp_state = ISP_INITSTATE;
 }
 
-static void
-isp_mark_getpdb_all(struct ispsoftc *isp)
+void
+isp_mark_portdb(struct ispsoftc *isp, int onprobation)
 {
 	fcparam *fcp = (fcparam *) isp->isp_param;
 	int i;
+
 	for (i = 0; i < MAX_FC_TARG; i++) {
-		fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0;
+		if (onprobation == 0) {
+			MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
+		} else {
+			switch (fcp->portdb[i].state) {
+			case FC_PORTDB_STATE_CHANGED:
+			case FC_PORTDB_STATE_PENDING_VALID:
+			case FC_PORTDB_STATE_VALID:
+			case FC_PORTDB_STATE_PROBATIONAL:
+				fcp->portdb[i].state =
+					FC_PORTDB_STATE_PROBATIONAL;
+				break;
+			case FC_PORTDB_STATE_ZOMBIE:
+				break;
+			case FC_PORTDB_STATE_NIL:
+			default:
+				MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
+				fcp->portdb[i].state =
+					FC_PORTDB_STATE_NIL;
+				break;
+			}
+		}
+	}
+}
+
+/*
+ * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
+ * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
+ */
+int
+isp_plogx(struct ispsoftc *isp, u_int16_t handle, u_int32_t portid, int flags, int gs)
+{
+	mbreg_t mbs;
+	u_int8_t q[QENTRY_LEN];
+	isp_plogx_t *plp;
+	u_int8_t *scp;
+	u_int32_t sst, parm1;
+	int rval;
+
+	if (!IS_24XX(isp)) {
+		int action = flags & PLOGX_FLG_CMD_MASK;
+		if (action == PLOGX_FLG_CMD_PLOGI) {
+			return (isp_port_login(isp, handle, portid));
+		} else if (action == PLOGX_FLG_CMD_LOGO) {
+			return (isp_port_logout(isp, handle, portid));
+		} else {
+			return (MBOX_INVALID_COMMAND);
+		}
+	}
+
+	MEMZERO(q, QENTRY_LEN);
+	plp = (isp_plogx_t *) q;
+	plp->plogx_header.rqs_entry_count = 1;
+	plp->plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
+	plp->plogx_handle = 0xffffffff;
+	plp->plogx_nphdl = handle;
+	plp->plogx_portlo = portid;
+	plp->plogx_rspsz_porthi = (portid >> 16) & 0xff;
+	plp->plogx_flags = flags;
+
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, plp);
+	}
+
+	if (gs == 0) {
+		FC_SCRATCH_ACQUIRE(isp);
+	}
+	scp = FCPARAM(isp)->isp_scratch;
+	isp_put_plogx(isp, plp, (isp_plogx_t *) scp);
+
+
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
+	mbs.param[1] = QENTRY_LEN;
+	mbs.param[2] = DMA_WD1(FCPARAM(isp)->isp_scdma);
+	mbs.param[3] = DMA_WD0(FCPARAM(isp)->isp_scdma);
+	mbs.param[6] = DMA_WD3(FCPARAM(isp)->isp_scdma);
+	mbs.param[7] = DMA_WD2(FCPARAM(isp)->isp_scdma);
+	mbs.timeout = 500000;
+	mbs.logval = MBLOGALL;
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN);
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		rval = mbs.param[0];
+		goto out;
+	}
+	MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN);
+	scp += QENTRY_LEN;
+	isp_get_plogx(isp, (isp_plogx_t *) scp, plp);
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, plp);
+	}
+
+	if (plp->plogx_status == PLOGX_STATUS_OK) {
+		rval = 0;
+		goto out;
+	} else if (plp->plogx_status != PLOGX_STATUS_IOCBERR) {
+		isp_prt(isp, ISP_LOGWARN, "status 0x%x on port login IOCB",
+		    plp->plogx_status);
+		rval = -1;
+		goto out;
+	}
+
+	sst = plp->plogx_ioparm[0].lo16 | (plp->plogx_ioparm[0].hi16 << 16);
+	parm1 = plp->plogx_ioparm[1].lo16 | (plp->plogx_ioparm[1].hi16 << 16);
+
+	rval = -1;
+
+	switch (sst) {
+	case PLOGX_IOCBERR_NOLINK:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no link");
+		break;
+	case PLOGX_IOCBERR_NOIOCB:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no IOCB buffer");
+		break;
+	case PLOGX_IOCBERR_NOXGHG:
+		isp_prt(isp, ISP_LOGERR,
+		    "PLOGX failed- no Exchange Control Block");
+		break;
+	case PLOGX_IOCBERR_FAILED:
+		isp_prt(isp, ISP_LOGERR,
+		    "PLOGX(0x%x) of Port 0x%06x failed: reason 0x%x (last LOGIN"
+		    " state 0x%x)", flags, portid, parm1 & 0xff,
+		    (parm1 >> 8) & 0xff);
+		break;
+	case PLOGX_IOCBERR_NOFABRIC:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no fabric");
+		break;
+	case PLOGX_IOCBERR_NOTREADY:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- f/w not ready");
+		break;
+	case PLOGX_IOCBERR_NOLOGIN:
+		isp_prt(isp, ISP_LOGERR,
+		    "PLOGX failed- not logged in (last LOGIN state 0x%x)",
+		    parm1);
+		rval = MBOX_NOT_LOGGED_IN;
+		break;
+	case PLOGX_IOCBERR_REJECT:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed: LS_RJT = 0x%x", parm1);
+		break;
+	case PLOGX_IOCBERR_NOPCB:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no PCB allocated");
+		break;
+	case PLOGX_IOCBERR_EINVAL:
+		isp_prt(isp, ISP_LOGERR,
+		    "PLOGX failed: invalid parameter at offset 0x%x", parm1);
+		break;
+	case PLOGX_IOCBERR_PORTUSED:
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "portid 0x%x already logged in with N-port handle 0x%x",
+		    portid, parm1);
+		rval = MBOX_PORT_ID_USED | (handle << 16);
+		break;
+	case PLOGX_IOCBERR_HNDLUSED:
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "N-port handle 0x%x already used for portid 0x%x",
+		    handle, parm1);
+		rval = MBOX_LOOP_ID_USED;
+		break;
+	case PLOGX_IOCBERR_NOHANDLE:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no handle allocated");
+		break;
+	case PLOGX_IOCBERR_NOFLOGI:
+		isp_prt(isp, ISP_LOGERR, "PLOGX failed- no FLOGI_ACC");
+		break;
+	default:
+		isp_prt(isp, ISP_LOGERR, "status %x from %x", plp->plogx_status,
+		    flags);
+		rval = -1;
+		break;
 	}
+out:
+	if (gs == 0) {
+		FC_SCRATCH_RELEASE(isp);
+	}
+	return (rval);
 }
 
-static int
-isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp)
+int
+isp_port_login(struct ispsoftc *isp, u_int16_t handle, u_int32_t portid)
+{
+	mbreg_t mbs;
+
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_FABRIC_LOGIN;
+	if (FCPARAM(isp)->isp_2klogin) {
+		mbs.param[1] = handle;
+		mbs.ibits = (1 << 10);
+	} else {
+		mbs.param[1] = handle << 8;
+	}
+	mbs.param[2] = portid >> 16;
+	mbs.param[3] = portid;
+	mbs.logval = MBLOGNONE;
+	mbs.timeout = 500000;
+	isp_mboxcmd(isp, &mbs);
+
+	switch (mbs.param[0]) {
+	case MBOX_PORT_ID_USED:
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "isp_plogi_old: portid 0x%06x already logged in as %u",
+		    portid, mbs.param[1]);
+		return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
+
+	case MBOX_LOOP_ID_USED:
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "isp_plogi_old: handle %u in use for port id 0x%02xXXXX",
+		    handle, mbs.param[1] & 0xff);
+		return (MBOX_LOOP_ID_USED);
+
+	case MBOX_COMMAND_COMPLETE:
+		return (0);
+
+	case MBOX_COMMAND_ERROR:
+		isp_prt(isp, ISP_LOGINFO,
+		    "isp_plogi_old: error 0x%x in PLOGI to port 0x%06x",
+		    mbs.param[1], portid);
+		return (MBOX_COMMAND_ERROR);
+
+	case MBOX_ALL_IDS_USED:
+		isp_prt(isp, ISP_LOGINFO,
+		    "isp_plogi_old: all IDs used for fabric login");
+		return (MBOX_ALL_IDS_USED);
+
+	default:
+		isp_prt(isp, ISP_LOGINFO,
+		    "isp_plogi_old: error 0x%x on port login of 0x%06x@0x%0x",
+		    mbs.param[0], portid, handle);
+		return (mbs.param[0]);
+	}
+}
+
+int
+isp_port_logout(struct ispsoftc *isp, u_int16_t handle, u_int32_t portid)
+{
+	mbreg_t mbs;
+
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_FABRIC_LOGOUT;
+	if (FCPARAM(isp)->isp_2klogin) {
+		mbs.param[1] = handle;
+		mbs.ibits = (1 << 10);
+	} else {
+		mbs.param[1] = handle << 8;
+	}
+	mbs.logval = MBLOGNONE;
+	mbs.timeout = 100000;
+	isp_mboxcmd(isp, &mbs);
+	return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
+}
+
+int
+isp_getpdb(struct ispsoftc *isp, u_int16_t id, isp_pdb_t *pdb, int dolock)
 {
 	fcparam *fcp = (fcparam *) isp->isp_param;
 	mbreg_t mbs;
+	union {
+		isp_pdb_21xx_t fred;
+		isp_pdb_24xx_t bill;
+	} un;
 
- 	MEMZERO(&mbs, sizeof (mbs));
+	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_GET_PORT_DB;
-	mbs.param[1] = id << 8;
+	if (IS_24XX(isp)) {
+		mbs.ibits = 0x3ff;
+		mbs.param[1] = id;
+	} else if (FCPARAM(isp)->isp_2klogin) {
+		mbs.param[1] = id;
+		mbs.ibits = (1 << 10);
+	} else {
+		mbs.param[1] = id << 8;
+	}
 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-	FC_SCRATCH_ACQUIRE(isp);
-	isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
-	if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
-		isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp);
+	mbs.timeout = 250000;
+	mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
+	if (dolock) {
+		FC_SCRATCH_ACQUIRE(isp);
+	}
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (un));
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		if (dolock) {
+			FC_SCRATCH_RELEASE(isp);
+		}
+		return (-1);
+	}
+	if (IS_24XX(isp)) {
+		isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
+		pdb->handle = un.bill.pdb_handle;
+		pdb->s3_role = un.bill.pdb_prli_svc3;
+		pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
+		MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
+		MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
+	} else {
+		isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
+		pdb->handle = un.fred.pdb_loopid;
+		pdb->s3_role = un.fred.pdb_prli_svc3;
+		pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
+		MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
+		MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
+	}
+	if (dolock) {
 		FC_SCRATCH_RELEASE(isp);
-		return (0);
 	}
-	FC_SCRATCH_RELEASE(isp);
-	return (-1);
+	return (0);
 }
 
-static u_int64_t
+u_int64_t
 isp_get_portname(struct ispsoftc *isp, int loopid, int nodename)
 {
-	u_int64_t wwn = 0;
+	u_int64_t wwn = (u_int64_t) -1;
 	mbreg_t mbs;
 
- 	MEMZERO(&mbs, sizeof (mbs));
+	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_GET_PORT_NAME;
-	mbs.param[1] = loopid << 8;
-	if (nodename)
-		mbs.param[1] |= 1;
-	isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
-	if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
+	if (FCPARAM(isp)->isp_2klogin || IS_24XX(isp)) {
+		mbs.param[1] = loopid;
+		mbs.ibits = (1 << 10);
+		if (nodename) {
+			mbs.param[10] = 1;
+		}
+	} else {
+		mbs.param[1] = loopid << 8;
+		if (nodename) {
+			mbs.param[1] |= 1;
+		}
+	}
+	mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		return (wwn);
+	}
+	if (IS_24XX(isp)) {
 		wwn =
-		    (((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
+		    (((u_int64_t)(mbs.param[2] >> 8))   << 56) |
+		    (((u_int64_t)(mbs.param[2] & 0xff))	<< 48) |
+		    (((u_int64_t)(mbs.param[3] >> 8))	<< 40) |
+		    (((u_int64_t)(mbs.param[3] & 0xff))	<< 32) |
+		    (((u_int64_t)(mbs.param[6] >> 8))	<< 24) |
+		    (((u_int64_t)(mbs.param[6] & 0xff))	<< 16) |
+		    (((u_int64_t)(mbs.param[7] >> 8))	<<  8) |
+		    (((u_int64_t)(mbs.param[7] & 0xff)));
+	} else {
+		wwn =
+		    (((u_int64_t)(mbs.param[2] & 0xff))  << 56) |
 		    (((u_int64_t)(mbs.param[2] >> 8))	<< 48) |
 		    (((u_int64_t)(mbs.param[3] & 0xff))	<< 40) |
 		    (((u_int64_t)(mbs.param[3] >> 8))	<< 32) |
@@ -1538,13 +2449,13 @@ isp_get_portname(struct ispsoftc *isp, int loopid, int nodename)
 }
 
 /*
- * Make sure we have good FC link and know our Loop ID.
+ * Make sure we have good FC link.
  */
 
-static int
+int
 isp_fclink_test(struct ispsoftc *isp, int usdelay)
 {
-	static char *toponames[] = {
+	static const char *toponames[] = {
 		"Private Loop",
 		"FL Port",
 		"N-Port to N-Port",
@@ -1554,15 +2465,15 @@ isp_fclink_test(struct ispsoftc *isp, int usdelay)
 	mbreg_t mbs;
 	int count, check_for_fabric;
 	u_int8_t lwfs;
+	int loopid;
 	fcparam *fcp;
-	struct lportdb *lp;
+	fcportdb_t *lp;
 	isp_pdb_t pdb;
 
 	fcp = isp->isp_param;
 
-	/*
-	 * XXX: Here is where we would start a 'loop dead' timeout
-	 */
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Entry");
+	ISP_MARK_PORTDB(isp, 1);
 
 	/*
 	 * Wait up to N microseconds for F/W to go to a ready state.
@@ -1577,12 +2488,14 @@ isp_fclink_test(struct ispsoftc *isp, int usdelay)
 		GET_NANOTIME(&hra);
 		isp_fw_state(isp);
 		if (lwfs != fcp->isp_fwstate) {
-			isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
-			    isp2100_fw_statename((int)lwfs),
-			    isp2100_fw_statename((int)fcp->isp_fwstate));
+			isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG,
+			    "Firmware State <%s->%s>",
+			    ispfc_fw_statename((int)lwfs),
+			    ispfc_fw_statename((int)fcp->isp_fwstate));
 			lwfs = fcp->isp_fwstate;
 		}
-		if (fcp->isp_fwstate == FW_READY) {
+		if (fcp->isp_fwstate == FW_READY &&
+		    fcp->isp_loopstate >= LOOP_PDB_RCVD) {
 			break;
 		}
 		GET_NANOTIME(&hrb);
@@ -1631,36 +2544,38 @@ isp_fclink_test(struct ispsoftc *isp, int usdelay)
 	 * If we haven't gone to 'ready' state, return.
 	 */
 	if (fcp->isp_fwstate != FW_READY) {
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "isp_fclink_test: not at FW_READY state");
 		return (-1);
 	}
 
 	/*
-	 * Get our Loop ID (if possible). We really need to have it.
+	 * Get our Loop ID and Port ID.
 	 */
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_GET_LOOP_ID;
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	isp_mboxcmd(isp, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		return (-1);
 	}
-	fcp->isp_loopid = mbs.param[1];
-	if (IS_2200(isp) || IS_23XX(isp)) {
+
+	if (FCPARAM(isp)->isp_2klogin) {
+		fcp->isp_loopid = mbs.param[1];
+	} else {
+		fcp->isp_loopid = mbs.param[1] & 0xff;
+	}
+
+	if (IS_2100(isp)) {
+		fcp->isp_topo = TOPO_NL_PORT;
+	} else {
 		int topo = (int) mbs.param[6];
-		if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
+		if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
 			topo = TOPO_PTP_STUB;
+		}
 		fcp->isp_topo = topo;
-	} else {
-		fcp->isp_topo = TOPO_NL_PORT;
 	}
-	fcp->isp_portid = fcp->isp_alpa = mbs.param[2] & 0xff;
-
-	/*
-	 * Check to see if we're on a fabric by trying to see if we
-	 * can talk to the fabric name server. This can be a bit
-	 * tricky because if we're a 2100, we should check always
-	 * (in case we're connected to a server doing aliasing).
-	 */
-	fcp->isp_onfabric = 0;
+	fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
 
 	if (IS_2100(isp)) {
 		/*
@@ -1675,122 +2590,92 @@ isp_fclink_test(struct ispsoftc *isp, int usdelay)
 	} else if (fcp->isp_topo == TOPO_FL_PORT ||
 	    fcp->isp_topo == TOPO_F_PORT) {
 		check_for_fabric = 1;
-	} else
+	} else {
 		check_for_fabric = 0;
+	}
 
-	if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
-		int loopid = FL_PORT_ID;
+	if (IS_24XX(isp)) {
+		loopid = NPH_FL_ID;
+	} else {
+		loopid = FL_ID;
+	}
+
+	if (check_for_fabric && isp_getpdb(isp, loopid, &pdb, 1) == 0) {
+		int r;
 		if (IS_2100(isp)) {
 			fcp->isp_topo = TOPO_FL_PORT;
 		}
-
-		if (BITS2WORD(pdb.pdb_portid_bits) == 0) {
+		if (pdb.portid == 0) {
 			/*
 			 * Crock.
 			 */
 			fcp->isp_topo = TOPO_NL_PORT;
 			goto not_on_fabric;
 		}
-		fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16);
 
 		/*
 		 * Save the Fabric controller's port database entry.
 		 */
-		lp = &fcp->portdb[loopid];
-		lp->node_wwn =
-		    (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_nodename[7]));
-		lp->port_wwn =
-		    (((u_int64_t)pdb.pdb_portname[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_portname[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_portname[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_portname[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_portname[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_portname[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_portname[7]));
-		lp->roles =
-		    (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
-		lp->portid = BITS2WORD(pdb.pdb_portid_bits);
-		lp->loopid = pdb.pdb_loopid;
-		lp->loggedin = lp->valid = 1;
-		fcp->isp_onfabric = 1;
-		(void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
-		isp_register_fc4_type(isp);
+		lp = &fcp->portdb[FL_ID];
+		lp->state = FC_PORTDB_STATE_PENDING_VALID;
+		MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
+		MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
+		lp->roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
+		lp->portid = pdb.portid;
+		lp->handle = pdb.handle;
+		lp->new_portid = lp->portid;
+		lp->new_roles = lp->roles;
+		if (IS_24XX(isp)) {
+			r = isp_register_fc4_type_24xx(isp);
+		} else {
+			r = isp_register_fc4_type(isp);
+		}
+		if (r) {
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "isp_fclink_test: register fc4 type failed");
+			return (-1);
+		}
 	} else {
 not_on_fabric:
-		fcp->isp_onfabric = 0;
-		fcp->portdb[FL_PORT_ID].valid = 0;
+		fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
 	}
 
 	fcp->isp_gbspeed = 1;
-	if (IS_23XX(isp)) {
- 		MEMZERO(&mbs, sizeof (mbs));
+	if (IS_23XX(isp) || IS_24XX(isp)) {
+		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_GET_SET_DATA_RATE;
 		mbs.param[1] = MBGSD_GET_RATE;
 		/* mbs.param[2] undefined if we're just getting rate */
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		mbs.timeout = 3000000;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
-			if (mbs.param[1] == MBGSD_TWOGB) {
+			if (mbs.param[1] == MBGSD_FOURGB) {
+				isp_prt(isp, ISP_LOGINFO, "4Gb link speed/s");
+				fcp->isp_gbspeed = 4;
+			} if (mbs.param[1] == MBGSD_TWOGB) {
 				isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
 				fcp->isp_gbspeed = 2;
 			}
 		}
 	}
 
-	isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid, fcp->isp_alpa,
-	    fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
-
 	/*
-	 * Announce ourselves, too. This involves synthesizing an entry.
+	 * Announce ourselves, too.
 	 */
-	if (fcp->isp_iid_set == 0) {
-		fcp->isp_iid_set = 1;
-		fcp->isp_iid = fcp->isp_loopid;
-		lp = &fcp->portdb[fcp->isp_iid];
-	} else {
-		lp = &fcp->portdb[fcp->isp_iid];
-		if (fcp->isp_portid != lp->portid ||
-		    fcp->isp_loopid != lp->loopid ||
-		    fcp->isp_nodewwn != ISP_NODEWWN(isp) ||
-		    fcp->isp_portwwn != ISP_PORTWWN(isp)) {
-			lp->valid = 0;
-			count = fcp->isp_iid;
-			(void) isp_async(isp, ISPASYNC_PROMENADE, &count);
-		}
-	}
-	lp->loopid = fcp->isp_loopid;
-	lp->portid = fcp->isp_portid;
-	lp->node_wwn = ISP_NODEWWN(isp);
-	lp->port_wwn = ISP_PORTWWN(isp);
-	switch (isp->isp_role) {
-	case ISP_ROLE_NONE:
-		lp->roles = 0;
-		break;
-	case ISP_ROLE_TARGET:
-		lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
-		break;
-	case ISP_ROLE_INITIATOR:
-		lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
-		break;
-	case ISP_ROLE_BOTH:
-		lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
-		break;
-	}
-	lp->loggedin = lp->valid = 1;
-	count = fcp->isp_iid;
-	(void) isp_async(isp, ISPASYNC_PROMENADE, &count);
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, fcp->isp_portid,
+	    fcp->isp_loopid, toponames[fcp->isp_topo]);
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, ourwwn,
+	    (u_int32_t) (ISP_NODEWWN(isp) >> 32),
+	    (u_int32_t) ISP_NODEWWN(isp),
+	    (u_int32_t) (ISP_PORTWWN(isp) >> 32),
+	    (u_int32_t) ISP_PORTWWN(isp));
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Complete");
 	return (0);
 }
 
-static char *
-isp2100_fw_statename(int state)
+const char *
+ispfc_fw_statename(int state)
 {
 	switch(state) {
 	case FW_CONFIG_WAIT:	return "Config Wait";
@@ -1806,17 +2691,35 @@ isp2100_fw_statename(int state)
 }
 
 /*
- * Synchronize our soft copy of the port database with what the f/w thinks
- * (with a view toward possibly for a specific target....)
+ * Complete the synchronization of our Port Database.
+ *
+ * At this point, we've scanned the local loop (if any) and the fabric
+ * and performed fabric logins on all new devices.
+ *
+ * Our task here is to go through our port database and remove any entities
+ * that are still marked probational (issuing PLOGO for ones which we had
+ * PLOGI'd into) or are dead.
+ *
+ * Our task here is to also check policy to decide whether devices which
+ * have *changed* in some way should still be kept active. For example,
+ * if a device has just changed PortID, we can either elect to treat it
+ * as an old device or as a newly arrived device (and notify the outer
+ * layer appropriately).
+ *
+ * We also do initiator map target id assignment here for new initiator
+ * devices and refresh old ones ot make sure that they point to the corret
+ * entities.
  */
-
-static int
+int
 isp_pdb_sync(struct ispsoftc *isp)
 {
-	struct lportdb *lp;
 	fcparam *fcp = isp->isp_param;
-	isp_pdb_t pdb;
-	int loopid, base, lim;
+	fcportdb_t *lp;
+	u_int16_t dbidx;
+
+	if (fcp->isp_loopstate == LOOP_READY) {
+		return (0);
+	}
 
 	/*
 	 * Make sure we're okay for doing this right now.
@@ -1824,289 +2727,127 @@ isp_pdb_sync(struct ispsoftc *isp)
 	if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
 	    fcp->isp_loopstate != LOOP_FSCAN_DONE &&
 	    fcp->isp_loopstate != LOOP_LSCAN_DONE) {
+		isp_prt(isp, ISP_LOGWARN, "isp_pdb_sync: bad loopstate %d",
+		    fcp->isp_loopstate);
 		return (-1);
 	}
 
-	if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT ||
+	if (fcp->isp_topo == TOPO_FL_PORT ||
+	    fcp->isp_topo == TOPO_NL_PORT ||
 	    fcp->isp_topo == TOPO_N_PORT) {
 		if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
 			if (isp_scan_loop(isp) != 0) {
+				isp_prt(isp, ISP_LOGWARN,
+				    "isp_pdb_sync: isp_scan_loop failed");
 				return (-1);
 			}
 		}
 	}
-	fcp->isp_loopstate = LOOP_SYNCING_PDB;
-
-	/*
-	 * If we get this far, we've settled our differences with the f/w
-	 * (for local loop device) and we can say that the loop state is ready.
-	 */
-
-	if (fcp->isp_topo == TOPO_NL_PORT) {
-		fcp->loop_seen_once = 1;
-		fcp->isp_loopstate = LOOP_READY;
-		return (0);
-	}
 
-	/*
-	 * Find all Fabric Entities that didn't make it from one scan to the
-	 * next and let the world know they went away. Scan the whole database.
-	 */
-	for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
-		if (lp->was_fabric_dev && lp->fabric_dev == 0) {
-			loopid = lp - fcp->portdb;
-			lp->valid = 0;	/* should already be set */
-			(void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
-			MEMZERO((void *) lp, sizeof (*lp));
-			continue;
+	if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
+		if (fcp->isp_loopstate < LOOP_FSCAN_DONE) {
+			if (isp_scan_fabric(isp) != 0) {
+				isp_prt(isp, ISP_LOGWARN,
+				    "isp_pdb_sync: isp_scan_fabric failed");
+				return (-1);
+			}
 		}
-		lp->was_fabric_dev = lp->fabric_dev;
 	}
 
-	if (fcp->isp_topo == TOPO_FL_PORT)
-		base = FC_SNS_ID+1;
-	else
-		base = 0;
-
-	if (fcp->isp_topo == TOPO_N_PORT)
-		lim = 1;
-	else
-		lim = MAX_FC_TARG;
-
-	/*
-	 * Now log in any fabric devices that the outer layer has
-	 * left for us to see. This seems the most sane policy
-	 * for the moment.
-	 */
-	for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
-		u_int32_t portid;
-		mbreg_t mbs;
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Synchronizing PDBs");
 
-		loopid = lp - fcp->portdb;
-		if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) {
-			continue;
-		}
+	fcp->isp_loopstate = LOOP_SYNCING_PDB;
 
-		/*
-		 * Anything here?
-		 */
-		if (lp->port_wwn == 0) {
-			continue;
-		}
+	for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
+		lp = &fcp->portdb[dbidx];
 
-		/*
-		 * Don't try to log into yourself.
-		 */
-		if ((portid = lp->portid) == fcp->isp_portid) {
+		if (lp->state == FC_PORTDB_STATE_NIL) {
 			continue;
 		}
 
-
-		/*
-		 * If we'd been logged in- see if we still are and we haven't
-		 * changed. If so, no need to log ourselves out, etc..
-		 *
-		 * Unfortunately, our charming QLogic f/w has decided to
-		 * return a valid port database entry for a fabric device
-		 * that has, in fact, gone away. And it hangs trying to
-		 * log it out.
-		 */
-		if (lp->loggedin && lp->force_logout == 0 &&
-		    isp_getpdb(isp, lp->loopid, &pdb) == 0) {
-			int nrole;
-			u_int64_t nwwnn, nwwpn;
-			nwwnn =
-			    (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
-			    (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
-			    (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
-			    (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
-			    (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
-			    (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
-			    (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
-			    (((u_int64_t)pdb.pdb_nodename[7]));
-			nwwpn =
-			    (((u_int64_t)pdb.pdb_portname[0]) << 56) |
-			    (((u_int64_t)pdb.pdb_portname[1]) << 48) |
-			    (((u_int64_t)pdb.pdb_portname[2]) << 40) |
-			    (((u_int64_t)pdb.pdb_portname[3]) << 32) |
-			    (((u_int64_t)pdb.pdb_portname[4]) << 24) |
-			    (((u_int64_t)pdb.pdb_portname[5]) << 16) |
-			    (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
-			    (((u_int64_t)pdb.pdb_portname[7]));
-			nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
-			    SVC3_ROLE_SHIFT;
-			if (pdb.pdb_loopid == lp->loopid && lp->portid ==
-			    (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) &&
-			    nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
-			    lp->roles == nrole && lp->force_logout == 0) {
-				lp->loggedin = lp->valid = 1;
-				isp_prt(isp, ISP_LOGCONFIG, lretained,
-				    (int) (lp - fcp->portdb),
-				    (int) lp->loopid, lp->portid);
-				continue;
+		if (lp->state == FC_PORTDB_STATE_VALID) {
+			if (dbidx != FL_ID) {
+				isp_prt(isp,
+				    ISP_LOGERR, "portdb idx %d already valid",
+			    	    dbidx);
 			}
+			continue;
 		}
 
-		if (fcp->isp_fwstate != FW_READY ||
-		    fcp->isp_loopstate != LOOP_SYNCING_PDB) {
-			return (-1);
-		}
-
-		/*
-		 * Force a logout if we were logged in.
-		 */
-		if (lp->loggedin) {
-			if (lp->force_logout ||
-			    isp_getpdb(isp, lp->loopid, &pdb) == 0) {
-				MEMZERO(&mbs, sizeof (mbs));
-				mbs.param[0] = MBOX_FABRIC_LOGOUT;
-				mbs.param[1] = lp->loopid << 8;
-				isp_mboxcmd(isp, &mbs, MBLOGNONE);
-				isp_prt(isp, ISP_LOGINFO, plogout,
-				    (int) (lp - fcp->portdb), lp->loopid,
-				    lp->portid);
+		switch (lp->state) {
+		case FC_PORTDB_STATE_PROBATIONAL:
+		case FC_PORTDB_STATE_DEAD:
+			/*
+			 * It's up to the outer layers to clear isp_ini_map.
+			 */
+			lp->state = FC_PORTDB_STATE_NIL;
+			isp_async(isp, ISPASYNC_DEV_GONE, lp);
+			if (lp->autologin == 0) {
+				(void) isp_plogx(isp, lp->handle, lp->portid,
+				    PLOGX_FLG_CMD_LOGO |
+				    PLOGX_FLG_IMPLICIT |
+				    PLOGX_FLG_FREE_NPHDL, 0);
+			} else {
+				lp->autologin = 0;
 			}
-			lp->force_logout = lp->loggedin = 0;
-			if (fcp->isp_fwstate != FW_READY ||
-			    fcp->isp_loopstate != LOOP_SYNCING_PDB) {
-				return (-1);
+			lp->new_roles = 0;
+			lp->new_portid = 0;
+			/*
+			 * Note that we might come out of this with our state
+			 * set to FC_PORTDB_STATE_ZOMBIE.
+			 */
+			break;
+		case FC_PORTDB_STATE_NEW:
+			/*
+			 * It's up to the outer layers to assign a virtual
+			 * target id in isp_ini_map (if any).
+			 */
+			lp->portid = lp->new_portid;
+			lp->roles = lp->new_roles;
+			lp->state = FC_PORTDB_STATE_VALID;
+			isp_async(isp, ISPASYNC_DEV_ARRIVED, lp);
+			lp->new_roles = 0;
+			lp->new_portid = 0;
+			lp->reserved = 0;
+			lp->new_reserved = 0;
+			break;
+		case FC_PORTDB_STATE_CHANGED:
+/*
+ * XXXX FIX THIS
+ */
+			lp->state = FC_PORTDB_STATE_VALID;
+			isp_async(isp, ISPASYNC_DEV_CHANGED, lp);
+			lp->new_roles = 0;
+			lp->new_portid = 0;
+			lp->reserved = 0;
+			lp->new_reserved = 0;
+			break;
+		case FC_PORTDB_STATE_PENDING_VALID:
+			lp->portid = lp->new_portid;
+			lp->roles = lp->new_roles;
+			if (lp->ini_map_idx) {
+				int t = lp->ini_map_idx - 1;
+				fcp->isp_ini_map[t] = dbidx + 1;
 			}
-		}
-
-		/*
-		 * And log in....
-		 */
-		loopid = lp - fcp->portdb;
-		lp->loopid = FL_PORT_ID;
-		do {
-			MEMZERO(&mbs, sizeof (mbs));
-			mbs.param[0] = MBOX_FABRIC_LOGIN;
-			mbs.param[1] = loopid << 8;
-			mbs.param[2] = portid >> 16;
-			mbs.param[3] = portid & 0xffff;
-			isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
-			    MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
-			if (fcp->isp_fwstate != FW_READY ||
-			    fcp->isp_loopstate != LOOP_SYNCING_PDB) {
-				return (-1);
+			lp->state = FC_PORTDB_STATE_VALID;
+			isp_async(isp, ISPASYNC_DEV_STAYED, lp);
+			if (dbidx != FL_ID) {
+				lp->new_roles = 0;
+				lp->new_portid = 0;
 			}
-			switch (mbs.param[0]) {
-			case MBOX_LOOP_ID_USED:
-				/*
-				 * Try the next available loop id.
-				 */
-				loopid++;
-				break;
-			case MBOX_PORT_ID_USED:
-				/*
-				 * This port is already logged in.
-				 * Snaffle the loop id it's using if it's
-				 * nonzero, otherwise we're hosed.
-				 */
-				if (mbs.param[1] != 0) {
-					loopid = mbs.param[1];
-					isp_prt(isp, ISP_LOGINFO, retained,
-					    loopid, (int) (lp - fcp->portdb),
-					    lp->portid);
-				} else {
-					loopid = MAX_FC_TARG;
-					break;
-				}
-				/* FALLTHROUGH */
-			case MBOX_COMMAND_COMPLETE:
-				lp->loggedin = 1;
-				lp->loopid = loopid;
-				break;
-			case MBOX_COMMAND_ERROR:
-				isp_prt(isp, ISP_LOGINFO, plogierr,
-				    portid, mbs.param[1]);
-				/* FALLTHROUGH */
-			case MBOX_ALL_IDS_USED: /* We're outta IDs */
-			default:
-				loopid = MAX_FC_TARG;
-				break;
-			}
-		} while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
-
-		/*
-		 * If we get here and we haven't set a Loop ID,
-		 * we failed to log into this device.
-		 */
-
-		if (lp->loopid == FL_PORT_ID) {
-			lp->loopid = 0;
-			continue;
-		}
-
-		/*
-		 * Make sure we can get the appropriate port information.
-		 */
-		if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
-			isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
-			goto dump_em;
-		}
-
-		if (fcp->isp_fwstate != FW_READY ||
-		    fcp->isp_loopstate != LOOP_SYNCING_PDB) {
-			return (-1);
-		}
-
-		if (pdb.pdb_loopid != lp->loopid) {
-			isp_prt(isp, ISP_LOGWARN, pdbmfail1,
-			    lp->portid, pdb.pdb_loopid);
-			goto dump_em;
-		}
-
-		if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
-			isp_prt(isp, ISP_LOGWARN, pdbmfail2,
-			    lp->portid, BITS2WORD(pdb.pdb_portid_bits));
-			goto dump_em;
-		}
-
-		lp->roles =
-		    (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
-		lp->node_wwn =
-		    (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_nodename[7]));
-		lp->port_wwn =
-		    (((u_int64_t)pdb.pdb_portname[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_portname[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_portname[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_portname[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_portname[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_portname[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_portname[7]));
-		/*
-		 * Check to make sure this all makes sense.
-		 */
-		if (lp->node_wwn && lp->port_wwn) {
-			lp->valid = 1;
-			loopid = lp - fcp->portdb;
-			(void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
-			continue;
-		}
-dump_em:
-		lp->valid = 0;
-		isp_prt(isp, ISP_LOGINFO,
-		    ldumped, loopid, lp->loopid, lp->portid);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_FABRIC_LOGOUT;
-		mbs.param[1] = lp->loopid << 8;
-		mbs.param[2] = 0;
-		mbs.param[3] = 0;
-		isp_mboxcmd(isp, &mbs, MBLOGNONE);
-		if (fcp->isp_fwstate != FW_READY ||
-		    fcp->isp_loopstate != LOOP_SYNCING_PDB) {
-			return (-1);
+			lp->reserved = 0;
+			lp->new_reserved = 0;
+			break;
+		case FC_PORTDB_STATE_ZOMBIE:
+			break;
+		default:
+			isp_prt(isp, ISP_LOGWARN,
+			    "isp_scan_loop: state %d for idx %d",
+			    lp->state, dbidx);
+			isp_dump_portdb(isp);
 		}
 	}
+
 	/*
 	 * If we get here, we've for sure seen not only a valid loop
 	 * but know what is or isn't on it, so mark this for usage
@@ -2117,799 +2858,969 @@ dump_em:
 	return (0);
 }
 
-static int
+/*
+ * Scan local loop for devices.
+ */
+int
 isp_scan_loop(struct ispsoftc *isp)
 {
-	struct lportdb *lp;
+	fcportdb_t *lp, tmp;
 	fcparam *fcp = isp->isp_param;
+	int i;
 	isp_pdb_t pdb;
-	int loopid, lim, hival;
+	u_int16_t handle, lim = 0;
 
+	if (fcp->isp_fwstate < FW_READY ||
+	    fcp->isp_loopstate < LOOP_PDB_RCVD) {
+		return (-1);
+	}
+
+	if (fcp->isp_loopstate > LOOP_SCANNING_LOOP) {
+		return (0);
+	}
+
+	/*
+	 * Check our connection topology.
+	 *
+	 * If we're a public or private loop, we scan 0..125 as handle values.
+	 * The firmware has (typically) peformed a PLOGI for us.
+	 *
+	 * If we're a N-port connection, we treat this is a short loop (0..1).
+	 *
+	 * If we're in target mode, we can all possible handles to see who
+	 * might have logged into us.
+	 */
 	switch (fcp->isp_topo) {
 	case TOPO_NL_PORT:
-		hival = FL_PORT_ID;
+	case TOPO_FL_PORT:
+		lim = LOCAL_LOOP_LIM;
 		break;
 	case TOPO_N_PORT:
-		hival = 2;
-		break;
-	case TOPO_FL_PORT:
-		hival = FC_PORT_ID;
+		lim = 2;
 		break;
 	default:
+		isp_prt(isp, ISP_LOGDEBUG0, "no loop topology to scan");
 		fcp->isp_loopstate = LOOP_LSCAN_DONE;
 		return (0);
 	}
+
 	fcp->isp_loopstate = LOOP_SCANNING_LOOP;
 
-	/*
-	 * make sure the temp port database is clean...
-	 */
-	MEMZERO((void *)fcp->tport, sizeof (fcp->tport));
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC scan loop 0..%d", lim-1);
+
 
 	/*
-	 * Run through the local loop ports and get port database info
-	 * for each loop ID.
-	 *
-	 * There's a somewhat unexplained situation where the f/w passes back
-	 * the wrong database entity- if that happens, just restart (up to
-	 * FL_PORT_ID times).
+	 * Run through the list and get the port database info for each one.
 	 */
-	for (lim = loopid = 0; loopid < hival; loopid++) {
-		lp = &fcp->tport[loopid];
-
+	for (handle = 0; handle < lim; handle++) {
 		/*
-		 * Don't even try for ourselves...
+		 * But don't even try for ourselves...
 	 	 */
-		if (loopid == fcp->isp_loopid)
+		if (handle == fcp->isp_loopid) {
 			continue;
+		}
 
-		lp->node_wwn = isp_get_portname(isp, loopid, 1);
-		if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
-			return (-1);
-		if (lp->node_wwn == 0)
-			continue;
-		lp->port_wwn = isp_get_portname(isp, loopid, 0);
-		if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
-			return (-1);
-		if (lp->port_wwn == 0) {
-			lp->node_wwn = 0;
-			continue;
+		/*
+		 * In older cards with older f/w GET_PORT_DATABASE has been
+		 * known to hang. This trick gets around that problem.
+		 */
+		if (IS_2100(isp) || IS_2200(isp)) {
+			u_int64_t node_wwn = isp_get_portname(isp, handle, 1);
+			if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
+				return (-1);
+			}
+			if (node_wwn == 0) {
+				continue;
+			}
 		}
 
 		/*
-		 * Get an entry....
+		 * Get the port database entity for this index.
 		 */
-		if (isp_getpdb(isp, loopid, &pdb) != 0) {
-			if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
+		if (isp_getpdb(isp, handle, &pdb, 1) != 0) {
+			if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
+				ISP_MARK_PORTDB(isp, 1);
 				return (-1);
+			}
 			continue;
 		}
+
 		if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
+			ISP_MARK_PORTDB(isp, 1);
 			return (-1);
 		}
 
 		/*
-		 * If the returned database element doesn't match what we
-		 * asked for, restart the process entirely (up to a point...).
+		 * On *very* old 2100 firmware we would end up sometimes
+		 * with the firmware returning the port database entry
+		 * for something else. We used to restart this, but
+		 * now we just punt.
 		 */
-		if (pdb.pdb_loopid != loopid) {
-			loopid = 0;
-			if (lim++ < hival) {
-				continue;
-			}
+		if (IS_2100(isp) && pdb.handle != handle) {
 			isp_prt(isp, ISP_LOGWARN,
 			    "giving up on synchronizing the port database");
+			ISP_MARK_PORTDB(isp, 1);
 			return (-1);
 		}
 
 		/*
 		 * Save the pertinent info locally.
 		 */
-		lp->node_wwn =
-		    (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_nodename[7]));
-		lp->port_wwn =
-		    (((u_int64_t)pdb.pdb_portname[0]) << 56) |
-		    (((u_int64_t)pdb.pdb_portname[1]) << 48) |
-		    (((u_int64_t)pdb.pdb_portname[2]) << 40) |
-		    (((u_int64_t)pdb.pdb_portname[3]) << 32) |
-		    (((u_int64_t)pdb.pdb_portname[4]) << 24) |
-		    (((u_int64_t)pdb.pdb_portname[5]) << 16) |
-		    (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
-		    (((u_int64_t)pdb.pdb_portname[7]));
-		lp->roles =
-		    (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
-		lp->portid = BITS2WORD(pdb.pdb_portid_bits);
-		lp->loopid = pdb.pdb_loopid;
-	}
-
-	/*
-	 * Mark all of the permanent local loop database entries as invalid
-	 * (except our own entry).
-	 */
-	for (loopid = 0; loopid < hival; loopid++) {
-		if (loopid == fcp->isp_iid) {
-			fcp->portdb[loopid].valid = 1;
-			fcp->portdb[loopid].loopid = fcp->isp_loopid;
-			continue;
-		}
-		fcp->portdb[loopid].valid = 0;
-	}
-
-	/*
-	 * Now merge our local copy of the port database into our saved copy.
-	 * Notify the outer layers of new devices arriving.
-	 */
-	for (loopid = 0; loopid < hival; loopid++) {
-		int i;
-
-		/*
-		 * If we don't have a non-zero Port WWN, we're not here.
-		 */
-		if (fcp->tport[loopid].port_wwn == 0) {
-			continue;
-		}
+		MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
+		MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
+		tmp.roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
+		tmp.portid = pdb.portid;
+		tmp.handle = pdb.handle;
 
 		/*
-		 * Skip ourselves.
+		 * Check to make sure it's still a valid entry. The 24XX seems
+		 * to return a portid but not a WWPN/WWNN or role for devices
+		 * which shift on a loop.
 		 */
-		if (loopid == fcp->isp_iid) {
+		if (tmp.node_wwn == 0 || tmp.port_wwn == 0 || tmp.portid == 0) {
+			int a, b, c;
+			a = (tmp.node_wwn == 0);
+			b = (tmp.port_wwn == 0);
+			c = (tmp.portid == 0);
+			isp_prt(isp, ISP_LOGWARN,
+			    "bad pdb (%1d%1d%1d) @ handle 0x%x", a, b, c,
+			    handle);
+			isp_dump_portdb(isp);
 			continue;
 		}
 
 		/*
-		 * For the purposes of deciding whether this is the
-		 * 'same' device or not, we only search for an identical
-		 * Port WWN. Node WWNs may or may not be the same as
-		 * the Port WWN, and there may be multiple different
-		 * Port WWNs with the same Node WWN. It would be chaos
-		 * to have multiple identical Port WWNs, so we don't
-		 * allow that.
+		 * Now search the entire port database
+		 * for the same Port and Node WWN.
 		 */
-
-		for (i = 0; i < hival; i++) {
-			int j;
-			if (fcp->portdb[i].port_wwn == 0)
+		for (i = 0; i < MAX_FC_TARG; i++) {
+			lp = &fcp->portdb[i];
+			if (lp->state == FC_PORTDB_STATE_NIL) {
 				continue;
-			if (fcp->portdb[i].port_wwn !=
-			    fcp->tport[loopid].port_wwn)
+			}
+			if (lp->node_wwn != tmp.node_wwn) {
+				continue;
+			}
+			if (lp->port_wwn != tmp.port_wwn) {
 				continue;
+			}
+
 			/*
-			 * We found this WWN elsewhere- it's changed
-			 * loopids then. We don't change its actual
-			 * position in our cached port database- we
-			 * just change the actual loop ID we'd use.
+			 * Okay- we've found a non-nil entry that matches.
+			 * Check to make sure it's probational or a zombie.
 			 */
-			if (fcp->portdb[i].loopid != loopid) {
-				isp_prt(isp, ISP_LOGINFO, portshift, i,
-				    fcp->portdb[i].loopid,
-				    fcp->portdb[i].portid, loopid,
-				    fcp->tport[loopid].portid);
+			if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
+			    lp->state != FC_PORTDB_STATE_ZOMBIE) {
+				isp_prt(isp, ISP_LOGERR,
+				    "[%d] not probational/zombie (0x%x)",
+				    i, lp->state);
+				isp_dump_portdb(isp);
+				ISP_MARK_PORTDB(isp, 1);
+				return (-1);
 			}
-			fcp->portdb[i].portid = fcp->tport[loopid].portid;
-			fcp->portdb[i].loopid = loopid;
-			fcp->portdb[i].valid = 1;
-			fcp->portdb[i].roles = fcp->tport[loopid].roles;
 
 			/*
-			 * Now make sure this Port WWN doesn't exist elsewhere
-			 * in the port database.
+			 * Mark the device as something the f/w logs into
+			 * automatically.
 			 */
-			for (j = i+1; j < hival; j++) {
-				if (fcp->portdb[i].port_wwn !=
-				    fcp->portdb[j].port_wwn) {
-					continue;
-				}
-				isp_prt(isp, ISP_LOGWARN, portdup, j, i);
-				/*
-				 * Invalidate the 'old' *and* 'new' ones.
-				 * This is really harsh and not quite right,
-				 * but if this happens, we really don't know
-				 * who is what at this point.
-				 */
-				fcp->portdb[i].valid = 0;
-				fcp->portdb[j].valid = 0;
+			lp->autologin = 1;
+
+			/*
+			 * Check to make see if really still the same
+			 * device. If it is, we mark it pending valid.
+			 */
+			if (lp->portid == tmp.portid &&
+			    lp->handle == tmp.handle &&
+			    lp->roles == tmp.roles) {
+				lp->new_portid = tmp.portid;
+				lp->new_roles = tmp.roles;
+				lp->state = FC_PORTDB_STATE_PENDING_VALID;
+				isp_prt(isp, ISP_LOGSANCFG,
+				    "Loop Port 0x%02x@0x%x Pending Valid",
+				    tmp.portid, tmp.handle);
+				break;
 			}
+		
+			/*
+			 * We can wipe out the old handle value
+			 * here because it's no longer valid.
+			 */
+			lp->handle = tmp.handle;
+
+			/*
+			 * Claim that this has changed and let somebody else
+			 * decide what to do.
+			 */
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "Loop Port 0x%02x@0x%x changed",
+			    tmp.portid, tmp.handle);
+			lp->state = FC_PORTDB_STATE_CHANGED;
+			lp->new_portid = tmp.portid;
+			lp->new_roles = tmp.roles;
 			break;
 		}
 
 		/*
-		 * If we didn't traverse the entire port database,
-		 * then we found (and remapped) an existing entry.
-		 * No need to notify anyone- go for the next one.
+		 * Did we find and update an old entry?
 		 */
-		if (i < hival) {
-			isp_prt(isp, ISP_LOGINFO, retained,
-			    fcp->portdb[i].loopid, i, fcp->portdb[i].portid);
+		if (i < MAX_FC_TARG) {
 			continue;
 		}
 
 		/*
-		 * We've not found this Port WWN anywhere. It's a new entry.
-		 * See if we can leave it where it is (with target == loopid).
+		 * Ah. A new device entry. Find an empty slot
+		 * for it and save info for later disposition.
 		 */
-		if (fcp->portdb[loopid].port_wwn != 0) {
-			for (lim = 0; lim < hival; lim++) {
-				if (fcp->portdb[lim].port_wwn == 0)
-					break;
-			}
-			/* "Cannot Happen" */
-			if (lim == hival) {
-				isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
-				continue;
+		for (i = 0; i < MAX_FC_TARG; i++) {
+			if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL) {
+				break;
 			}
-			i = lim;
-		} else {
-			i = loopid;
 		}
-
-		/*
-		 * NB:	The actual loopid we use here is loopid- we may
-		 *	in fact be at a completely different index (target).
-		 */
-		fcp->portdb[i].loopid = loopid;
-		fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn;
-		fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn;
-		fcp->portdb[i].roles = fcp->tport[loopid].roles;
-		fcp->portdb[i].portid = fcp->tport[loopid].portid;
-		fcp->portdb[i].valid = 1;
-
-		/*
-		 * Tell the outside world we've arrived.
-		 */
-		(void) isp_async(isp, ISPASYNC_PROMENADE, &i);
-	}
-
-	/*
-	 * Now find all previously used targets that are now invalid and
-	 * notify the outer layers that they're gone.
-	 */
-	for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
-		if (lp->valid || lp->port_wwn == 0) {
+		if (i == MAX_FC_TARG) {
+			isp_prt(isp, ISP_LOGERR, "out of portdb entries");
 			continue;
 		}
+		lp = &fcp->portdb[i];
 
-		/*
-		 * Tell the outside world we've gone
-		 * away and erase our pdb entry.
-		 *
-		 */
-		loopid = lp - fcp->portdb;
-		(void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
-		MEMZERO((void *) lp, sizeof (*lp));
+		MEMZERO(lp, sizeof (fcportdb_t));
+		lp->autologin = 1;
+		lp->state = FC_PORTDB_STATE_NEW;
+		lp->new_portid = tmp.portid;
+		lp->new_roles = tmp.roles;
+		lp->handle = tmp.handle;
+		lp->port_wwn = tmp.port_wwn;
+		lp->node_wwn = tmp.node_wwn;
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "Loop Port 0x%02x@0x%x is New Entry",
+		    tmp.portid, tmp.handle);
 	}
 	fcp->isp_loopstate = LOOP_LSCAN_DONE;
 	return (0);
 }
 
+/*
+ * Scan the fabric for devices and add them to our port database.
+ *
+ * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
+ *
+ * For 2100-23XX cards, we can use the SNS mailbox command to pass simple
+ * name server commands to the switch management server via the QLogic f/w.
+ *
+ * For the 24XX card, we have to use CT-Pass through run via the Execute IOCB
+ * mailbox command.
+ *
+ * The net result is to leave the list of Port IDs setting untranslated in
+ * offset IGPOFF of the FC scratch area, whereupon we'll canonicalize it to
+ * host order at OGPOFF.
+ */
+
+/*
+ * Take less than half of our scratch area to store Port IDs 
+ */
+#define	GIDLEN	((ISP2100_SCRLEN >> 1) - 16 - SNS_GID_FT_REQ_SIZE)
+#define	NGENT	((GIDLEN - 16) >> 2)
+
+#define	IGPOFF	(2 * QENTRY_LEN)
+#define	OGPOFF	(ISP2100_SCRLEN >> 1)
+#define	ZTXOFF	(ISP2100_SCRLEN - (1 * QENTRY_LEN))
+#define	CTXOFF	(ISP2100_SCRLEN - (2 * QENTRY_LEN))
+#define	XTXOFF	(ISP2100_SCRLEN - (3 * QENTRY_LEN))
 
-static int
-isp_fabric_mbox_cmd(struct ispsoftc *isp, mbreg_t *mbp)
+int
+isp_gid_ft_sns(struct ispsoftc *isp)
 {
-	/* the caller sets up the mailbox */
-	isp_mboxcmd(isp, mbp, MBLOGNONE);
-	if (mbp->param[0] != MBOX_COMMAND_COMPLETE) {
-		if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) {
-			FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
-		}
-		if (mbp->param[0] == MBOX_COMMAND_ERROR) {
-			char tbuf[16];
-			char *m;
-			switch (mbp->param[1]) {
-			case 1:
-				m = "No Loop";
-				break;
-			case 2:
-				m = "Failed to allocate IOCB buffer";
-				break;
-			case 3:
-				m = "Failed to allocate XCB buffer";
-				break;
-			case 4:
-				m = "timeout or transmit failed";
-				break;
-			case 5:
-				m = "no fabric loop";
-				break;
-			case 6:
-				m = "remote device not a target";
-				break;
-			default:
-				SNPRINTF(tbuf, sizeof tbuf, "%x",
-				    mbp->param[1]);
-				m = tbuf;
-				break;
-			}
-			isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m);
-		}
-		return (-1);
-	}
+	union {
+		sns_gid_ft_req_t _x;
+		u_int8_t _y[SNS_GID_FT_REQ_SIZE];
+	} un;
+	fcparam *fcp = FCPARAM(isp);
+	sns_gid_ft_req_t *rq = &un._x;
+	mbreg_t mbs;
 
-	if (FCPARAM(isp)->isp_fwstate != FW_READY ||
-	    FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) {
-		return (-1);
+	isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via SNS");
+
+	MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
+	rq->snscb_rblen = GIDLEN >> 1;
+	rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
+	rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
+	rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
+	rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
+	rq->snscb_sblen = 6;
+	rq->snscb_cmd = SNS_GID_FT;
+	rq->snscb_mword_div_2 = NGENT;
+	rq->snscb_fc4_type = FC4_SCSI;
+
+	isp_put_gid_ft_request(isp, rq, fcp->isp_scratch);
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
+
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_SEND_SNS;
+	mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
+	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
+	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
+	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
+	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
+	mbs.logval = MBLOGALL;
+	mbs.timeout = 10000000;
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		if (mbs.param[0] == MBOX_INVALID_COMMAND) {
+			return (1);
+		} else {
+			return (-1);
+		}
 	}
-	return(0);
+	return (0);
 }
 
-#ifdef	ISP_USE_GA_NXT
-static int
-isp_scan_fabric(struct ispsoftc *isp, int ftype)
+int
+isp_gid_ft_ct_passthru(struct ispsoftc *isp)
 {
-	fcparam *fcp = isp->isp_param;
-	u_int32_t portid, first_portid, last_portid;
-	int hicap, last_port_same;
-
-	if (fcp->isp_onfabric == 0) {
-		fcp->isp_loopstate = LOOP_FSCAN_DONE;
-		return (0);
+	mbreg_t mbs;
+	fcparam *fcp = FCPARAM(isp);
+	union {
+		isp_ct_pt_t plocal;
+		ct_hdr_t clocal;
+		u_int8_t q[QENTRY_LEN];
+	} un;
+	isp_ct_pt_t *pt;
+	ct_hdr_t *ct;
+	u_int32_t *rp;
+	u_int8_t *scp = fcp->isp_scratch;
+
+	isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via CT");
+
+	if (!IS_24XX(isp)) {
+		return (1);
 	}
 
-	FC_SCRATCH_ACQUIRE(isp);
-
 	/*
-	 * Since Port IDs are 24 bits, we can check against having seen
-	 * anything yet with this value.
+	 * Build a Passthrough IOCB in memory.
 	 */
-	last_port_same = 0;
-	last_portid = 0xffffffff;	/* not a port */
-	first_portid = portid = fcp->isp_portid;
-	fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
-
-	for (hicap = 0; hicap < GA_NXT_MAX; hicap++) {
-		mbreg_t mbs;
-		sns_screq_t *rq;
-		sns_ga_nxt_rsp_t *rs0, *rs1;
-		struct lportdb lcl;
-		u_int8_t sc[SNS_GA_NXT_RESP_SIZE];
-
-		rq = (sns_screq_t *)sc;
-		MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE);
-		rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1;
-		rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100);
-		rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100);
-		rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100);
-		rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100);
-		rq->snscb_sblen = 6;
-		rq->snscb_data[0] = SNS_GA_NXT;
-		rq->snscb_data[4] = portid & 0xffff;
-		rq->snscb_data[5] = (portid >> 16) & 0xff;
-		isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch);
-		MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_SEND_SNS;
-		mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1;
-		mbs.param[2] = DMA_WD1(fcp->isp_scdma);
-		mbs.param[3] = DMA_WD0(fcp->isp_scdma);
-		/*
-		 * Leave 4 and 5 alone
-		 */
-		mbs.param[6] = DMA_WD3(fcp->isp_scdma);
-		mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-		if (isp_fabric_mbox_cmd(isp, &mbs)) {
-			if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
-				fcp->isp_loopstate = LOOP_PDB_RCVD;
-			}
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
-		}
-		MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE);
-		rs1 = (sns_ga_nxt_rsp_t *) sc;
-		rs0 = (sns_ga_nxt_rsp_t *) ((u_int8_t *)fcp->isp_scratch+0x100);
-		isp_get_ga_nxt_response(isp, rs0, rs1);
-		if (rs1->snscb_cthdr.ct_response != FS_ACC) {
-			int level;
-			if (rs1->snscb_cthdr.ct_reason == 9 &&
-			    rs1->snscb_cthdr.ct_explanation == 7)
-				level = ISP_LOGDEBUG0;
-			else
-				level = ISP_LOGWARN;
-			isp_prt(isp, level, swrej, "GA_NXT",
-			    rs1->snscb_cthdr.ct_reason,
-			    rs1->snscb_cthdr.ct_explanation, portid);
-			FC_SCRATCH_RELEASE(isp);
-			fcp->isp_loopstate = LOOP_FSCAN_DONE;
-			return (0);
-		}
-		portid =
-		    (((u_int32_t) rs1->snscb_port_id[0]) << 16) |
-		    (((u_int32_t) rs1->snscb_port_id[1]) << 8) |
-		    (((u_int32_t) rs1->snscb_port_id[2]));
+	pt = &un.plocal;
+	MEMZERO(un.q, QENTRY_LEN);
+	pt->ctp_header.rqs_entry_count = 1;
+	pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
+	pt->ctp_handle = 0xffffffff;
+	pt->ctp_nphdl = NPH_SNS_ID;
+	pt->ctp_cmd_cnt = 1;
+	pt->ctp_time = 30;
+	pt->ctp_rsp_cnt = 1;
+	pt->ctp_rsp_bcnt = GIDLEN;
+	pt->ctp_cmd_bcnt = sizeof (*ct) + sizeof (u_int32_t);
+	pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
+	pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
+	pt->ctp_dataseg[0].ds_count = sizeof (*ct) + sizeof (u_int32_t);
+	pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
+	pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
+	pt->ctp_dataseg[1].ds_count = GIDLEN;
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "ct IOCB", QENTRY_LEN, pt);
+	}
+	isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
 
-		/*
-		 * XXX: We should check to make sure that this entry
-		 * XXX: supports the type(s) we are interested in.
-		 */
-		/*
-		 * Okay, we now have information about a fabric object.
-		 * If it is the type we're interested in, tell the outer layers
-		 * about it. The outer layer needs to  know: Port ID, WWNN,
-		 * WWPN, FC4 type, and port type.
-		 *
-		 * The lportdb structure is adequate for this.
-		 */
-		MEMZERO(&lcl, sizeof (lcl));
-		lcl.port_type = rs1->snscb_port_type;
-		lcl.fc4_type = ftype;
-		lcl.portid = portid;
-		lcl.node_wwn =
-		    (((u_int64_t)rs1->snscb_nodename[0]) << 56) |
-		    (((u_int64_t)rs1->snscb_nodename[1]) << 48) |
-		    (((u_int64_t)rs1->snscb_nodename[2]) << 40) |
-		    (((u_int64_t)rs1->snscb_nodename[3]) << 32) |
-		    (((u_int64_t)rs1->snscb_nodename[4]) << 24) |
-		    (((u_int64_t)rs1->snscb_nodename[5]) << 16) |
-		    (((u_int64_t)rs1->snscb_nodename[6]) <<  8) |
-		    (((u_int64_t)rs1->snscb_nodename[7]));
-		lcl.port_wwn =
-		    (((u_int64_t)rs1->snscb_portname[0]) << 56) |
-		    (((u_int64_t)rs1->snscb_portname[1]) << 48) |
-		    (((u_int64_t)rs1->snscb_portname[2]) << 40) |
-		    (((u_int64_t)rs1->snscb_portname[3]) << 32) |
-		    (((u_int64_t)rs1->snscb_portname[4]) << 24) |
-		    (((u_int64_t)rs1->snscb_portname[5]) << 16) |
-		    (((u_int64_t)rs1->snscb_portname[6]) <<  8) |
-		    (((u_int64_t)rs1->snscb_portname[7]));
+	/*
+	 * Build the CT header and command in memory.
+	 *
+	 * Note that the CT header has to end up as Big Endian format in memory.
+	 */
+	ct = &un.clocal;
+	MEMZERO(ct, sizeof (*ct));
+	ct->ct_revision = CT_REVISION;
+	ct->ct_fcs_type = CT_FC_TYPE_FC;
+	ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
+	ct->ct_cmd_resp = SNS_GID_FT;
+	ct->ct_bcnt_resid = (GIDLEN - 16) >> 2;
+
+	isp_put_ct_hdr(isp, ct, (ct_hdr_t *) &scp[XTXOFF]);
+	rp = (u_int32_t *) &scp[XTXOFF+sizeof (*ct)];
+	ISP_IOZPUT_32(isp, FC4_SCSI, rp);
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "CT HDR + payload after put",
+		    sizeof (*ct) + sizeof (u_int32_t), &scp[XTXOFF]);
+	}
+	MEMZERO(&scp[ZTXOFF], QENTRY_LEN);
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
+	mbs.param[1] = QENTRY_LEN;
+	mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
+	mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
+	mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
+	mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
+	mbs.timeout = 500000;
+	mbs.logval = MBLOGALL;
+	MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		return (-1);
+	}
+	MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
+	pt = &un.plocal;
+	isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
+	}
 
-		/*
-		 * Does this fabric object support the type we want?
-		 * If not, skip it.
-		 */
-		if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) {
-			if (first_portid == portid) {
-				lcl.last_fabric_dev = 1;
-			} else {
-				lcl.last_fabric_dev = 0;
-			}
-			(void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
-		} else {
-			isp_prt(isp, ISP_LOGDEBUG0,
-			    "PortID 0x%x doesn't support FC4 type 0x%x",
-			    portid, ftype);
-		}
-		if (first_portid == portid) {
-			fcp->isp_loopstate = LOOP_FSCAN_DONE;
-			FC_SCRATCH_RELEASE(isp);
-			return (0);
-		}
-		if (portid == last_portid) {
-			if (last_port_same++ > 20) {
-				isp_prt(isp, ISP_LOGWARN,
-				    "tangled fabric database detected");
-				break;
-			}
-		} else {
-			last_port_same = 0 ;
-			last_portid = portid;
-		}
+	if (pt->ctp_status && pt->ctp_status != RQCS_DATA_UNDERRUN) {
+		isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
+		    pt->ctp_status);
+		return (-1);
 	}
-	FC_SCRATCH_RELEASE(isp);
-	if (hicap >= GA_NXT_MAX) {
-		isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX);
+	MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN + 16);
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "CT response", GIDLEN+16, &scp[IGPOFF]);
 	}
-	fcp->isp_loopstate = LOOP_FSCAN_DONE;
 	return (0);
 }
-#else
-#define	GIDLEN	((ISP2100_SCRLEN >> 1) + 16)
-#define	NGENT	((GIDLEN - 16) >> 2)
-
-#define	IGPOFF	(ISP2100_SCRLEN - GIDLEN)
-#define	GXOFF	(256)
 
-static int
-isp_scan_fabric(struct ispsoftc *isp, int ftype)
+int
+isp_scan_fabric(struct ispsoftc *isp)
 {
 	fcparam *fcp = FCPARAM(isp);
-	mbreg_t mbs;
-	int i;
-	sns_gid_ft_req_t *rq;
+	u_int32_t portid;
+	u_int16_t handle, oldhandle;
+	int portidx, portlim, r;
 	sns_gid_ft_rsp_t *rs0, *rs1;
 
-	if (fcp->isp_onfabric == 0) {
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric");
+	if (fcp->isp_fwstate != FW_READY ||
+	    fcp->isp_loopstate < LOOP_LSCAN_DONE) {
+		return (-1);
+	}
+	if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
+		return (0);
+	}
+	if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
 		fcp->isp_loopstate = LOOP_FSCAN_DONE;
+		isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+		    "FC Scan Fabric Done (no fabric)");
 		return (0);
 	}
 
 	FC_SCRATCH_ACQUIRE(isp);
 	fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
 
-	rq = (sns_gid_ft_req_t *)fcp->tport;
-	MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE);
-	rq->snscb_rblen = GIDLEN >> 1;
-	rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF);
-	rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF);
-	rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF);
-	rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF);
-	rq->snscb_sblen = 6;
-	rq->snscb_cmd = SNS_GID_FT;
-	rq->snscb_mword_div_2 = NGENT;
-	rq->snscb_fc4_type = ftype;
-	isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch);
-	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
-	MEMZERO(&mbs, sizeof (mbs));
-	mbs.param[0] = MBOX_SEND_SNS;
-	mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
-	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
-	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
+	if (IS_24XX(isp)) {
+		r = isp_gid_ft_ct_passthru(isp);
+	} else {
+		r = isp_gid_ft_sns(isp);
+	}
 
-	/*
-	 * Leave 4 and 5 alone
-	 */
-	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
-	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-	if (isp_fabric_mbox_cmd(isp, &mbs)) {
-		if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
-			fcp->isp_loopstate = LOOP_PDB_RCVD;
-		}
+	if (r > 0) {
+		fcp->isp_loopstate = LOOP_FSCAN_DONE;
 		FC_SCRATCH_RELEASE(isp);
-		return (-1);
+		return (0);
+	} else if (r < 0) {
+		fcp->isp_loopstate = LOOP_PDB_RCVD;	/* try again */
+		FC_SCRATCH_RELEASE(isp);
+		return (0);
 	}
 	if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
 		FC_SCRATCH_RELEASE(isp);
 		return (-1);
 	}
+
 	MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
-	rs1 = (sns_gid_ft_rsp_t *) fcp->tport;
 	rs0 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+IGPOFF);
+	rs1 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+OGPOFF);
 	isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
-	if (rs1->snscb_cthdr.ct_response != FS_ACC) {
+	if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
 		int level;
 		if (rs1->snscb_cthdr.ct_reason == 9 &&
-		    rs1->snscb_cthdr.ct_explanation == 7)
-			level = ISP_LOGDEBUG0;
-		else
+		    rs1->snscb_cthdr.ct_explanation == 7) {
+			level = ISP_LOGSANCFG|ISP_LOGDEBUG0;
+		} else {
 			level = ISP_LOGWARN;
-		isp_prt(isp, level, swrej, "GID_FT",
-		    rs1->snscb_cthdr.ct_reason,
-		    rs1->snscb_cthdr.ct_explanation, 0);
+		}
+		isp_prt(isp, level, "Fabric Nameserver rejected GID_FT "
+		    "(Reason=0x%x Expl=0x%x)", rs1->snscb_cthdr.ct_reason,
+		    rs1->snscb_cthdr.ct_explanation);
 		FC_SCRATCH_RELEASE(isp);
 		fcp->isp_loopstate = LOOP_FSCAN_DONE;
 		return (0);
 	}
 
+
 	/*
-	 * Okay, we now have a list of Port IDs for this class of device.
-	 * Go through the list and for each one get the WWPN/WWNN for it
-	 * and tell the outer layers about it. The outer layer needs to
-	 * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type.
+	 * If we get this far, we certainly still have the fabric controller.
+	 */
+	fcp->portdb[FL_ID].state = FC_PORTDB_STATE_PENDING_VALID;
+
+	/*
+	 * Prime the handle we will start using.
+	 */
+	oldhandle = NIL_HANDLE;
+
+	/*
+	 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
+	 * that the Fabric Name server knows about. Go through the list
+	 * and remove duplicate port ids.
+	 */
+
+	portlim = 0;
+	portidx = 0;
+	for (portidx = 0; portidx < NGENT-1; portidx++) {
+		if (rs1->snscb_ports[portidx].control & 0x80) {
+			break;
+		}
+	}
+
+	/*
+	 * If we're not at the last entry, our list wasn't big enough.
+	 */
+	if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
+		isp_prt(isp, ISP_LOGWARN,
+		    "fabric too big for scratch area: increase ISP2100_SCRLEN");
+	}
+	portlim = portidx + 1;
+	isp_prt(isp, ISP_LOGSANCFG,
+	    "got %d ports back from name server", portlim);
+
+	for (portidx = 0; portidx < portlim; portidx++) {
+		int npidx;
+
+		portid =
+		    ((rs1->snscb_ports[portidx].portid[0]) << 16) |
+		    ((rs1->snscb_ports[portidx].portid[1]) << 8) |
+		    ((rs1->snscb_ports[portidx].portid[2]));
+
+		for (npidx = portidx + 1; npidx < portlim; npidx++) {
+			u_int32_t new_portid =
+			    ((rs1->snscb_ports[npidx].portid[0]) << 16) |
+			    ((rs1->snscb_ports[npidx].portid[1]) << 8) |
+			    ((rs1->snscb_ports[npidx].portid[2]));
+			if (new_portid == portid) {
+				break;
+			}
+		}
+
+		if (npidx < portlim) {
+			rs1->snscb_ports[npidx].portid[0] = 0;
+			rs1->snscb_ports[npidx].portid[1] = 0;
+			rs1->snscb_ports[npidx].portid[2] = 0;
+			isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+			    "removing duplicate PortID 0x%x entry from list",
+			    portid);
+		}
+	}
+
+	/*
+	 * Okay, we now have a list of Port IDs for all FC4 SCSI devices
+	 * that the Fabric Name server knows about.
+	 *
+	 * For each entry on this list go through our port database looking
+	 * for probational entries- if we find one, then an old entry is
+	 * is maybe still this one. We get some information to find out.
 	 *
-	 * The lportdb structure is adequate for this.
+	 * Otherwise, it's a new fabric device, and we log into it
+	 * (unconditionally). After searching the entire database
+	 * again to make sure that we never ever ever ever have more
+	 * than one entry that has the same PortID or the same
+	 * WWNN/WWPN duple, we enter the device into our database.
 	 */
-	i = -1;
-	do {
-		sns_gxn_id_req_t grqbuf, *gq = &grqbuf;
-		sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf;
-		struct lportdb lcl;
-#if	0
-		sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf;
-#endif
 
-		i++;
-		MEMZERO(&lcl, sizeof (lcl));
-		lcl.fc4_type = ftype;
-		lcl.portid =
-		    (((u_int32_t) rs1->snscb_ports[i].portid[0]) << 16) |
-		    (((u_int32_t) rs1->snscb_ports[i].portid[1]) << 8) |
-		    (((u_int32_t) rs1->snscb_ports[i].portid[2]));
-
-		MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
-		gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
-		gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
-		gq->snscb_sblen = 6;
-		gq->snscb_cmd = SNS_GPN_ID;
-		gq->snscb_portid = lcl.portid;
-		isp_put_gxn_id_request(isp, gq,
-		    (sns_gxn_id_req_t *) fcp->isp_scratch);
-		MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_SEND_SNS;
-		mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
-		mbs.param[2] = DMA_WD1(fcp->isp_scdma);
-		mbs.param[3] = DMA_WD0(fcp->isp_scdma);
+	for (portidx = 0; portidx < portlim; portidx++) {
+		fcportdb_t *lp;
+		isp_pdb_t pdb;
+		u_int64_t wwnn, wwpn;
+		int dbidx, nr;
+
+		portid =
+		    ((rs1->snscb_ports[portidx].portid[0]) << 16) |
+		    ((rs1->snscb_ports[portidx].portid[1]) << 8) |
+		    ((rs1->snscb_ports[portidx].portid[2]));
+
+		if (portid == 0) {
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "skipping null PortID at idx %d", portidx);
+			continue;
+		}
+
 		/*
-		 * Leave 4 and 5 alone
+		 * Skip ourselves...
 		 */
-		mbs.param[6] = DMA_WD3(fcp->isp_scdma);
-		mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-		if (isp_fabric_mbox_cmd(isp, &mbs)) {
-			if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
-				fcp->isp_loopstate = LOOP_PDB_RCVD;
-			}
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
+		if (portid == fcp->isp_portid) {
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "skip ourselves @ PortID 0x%06x", portid);
+			continue;
 		}
-		if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "Checking Fabric Port 0x%06x", portid);
+
+		/*
+		 * We now search our Port Database for any
+		 * probational entries with this PortID. We don't
+		 * look for zombies here- only probational
+		 * entries (we've already logged out of zombies).
+		 */
+		for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
+			lp = &fcp->portdb[dbidx];
+
+			if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
+				continue;
+			}
+			if (lp->portid == portid) {
+				break;
+			}
 		}
-		MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
-		gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
-		isp_get_gxn_id_response(isp, gs0, gs1);
-		if (gs1->snscb_cthdr.ct_response != FS_ACC) {
-			isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID",
-			    gs1->snscb_cthdr.ct_reason,
-			    gs1->snscb_cthdr.ct_explanation, lcl.portid);
+
+		/*
+		 * We found a probational entry with this Port ID.
+		 */
+		if (dbidx < MAX_FC_TARG) {
+			int handle_changed = 0;
+
+			lp = &fcp->portdb[dbidx];
+
+			/*
+			 * See if we're still logged into it.
+			 *
+			 * If we aren't, mark it as a dead device and
+			 * leave the new portid in the database entry
+			 * for somebody further along to decide what to
+			 * do (policy choice).
+			 *
+			 * If we are, check to see if it's the same
+			 * device still (it should be). If for some
+			 * reason it isn't, mark it as a changed device
+			 * and leave the new portid and role in the
+			 * database entry for somebody further along to
+			 * decide what to do (policy choice).
+			 *
+			 */
+
+			r = isp_getpdb(isp, lp->handle, &pdb, 0);
 			if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
 				FC_SCRATCH_RELEASE(isp);
+				ISP_MARK_PORTDB(isp, 1);
 				return (-1);
 			}
+			if (r != 0) {
+				lp->new_portid = portid;
+				lp->state = FC_PORTDB_STATE_DEAD;
+				isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+				    "Fabric Port 0x%06x considered dead",
+				    portid);
+				continue;
+			}
+
+
+			/*
+			 * Check to make sure that handle, portid, WWPN and
+			 * WWNN agree. If they don't, then the association
+			 * between this PortID and the stated handle has been
+			 * broken by the firmware.
+			 */
+			MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
+			MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
+			if (pdb.handle != lp->handle ||
+			    pdb.portid != portid ||
+			    wwpn != lp->port_wwn ||
+			    wwnn != lp->node_wwn) {
+				isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+				    fconf, dbidx, pdb.handle, pdb.portid,
+				    (u_int32_t) (wwnn >> 32), (u_int32_t) wwnn,
+				    (u_int32_t) (wwpn >> 32), (u_int32_t) wwpn,
+				    lp->handle, portid,
+				    (u_int32_t) (lp->node_wwn >> 32),
+				    (u_int32_t) lp->node_wwn,
+				    (u_int32_t) (lp->port_wwn >> 32),
+				    (u_int32_t) lp->port_wwn);
+				/*
+				 * Try to re-login to this device using a
+				 * new handle. If that fails, mark it dead.
+				 * 
+				 * isp_login_device will check for handle and
+				 * portid consistency after re-login.
+				 * 
+				 */
+				if (isp_login_device(isp, portid, &pdb,
+				    &oldhandle)) {
+					lp->new_portid = portid;
+					lp->state = FC_PORTDB_STATE_DEAD;
+					if (fcp->isp_loopstate !=
+					    LOOP_SCANNING_FABRIC) {
+						FC_SCRATCH_RELEASE(isp);
+						ISP_MARK_PORTDB(isp, 1);
+						return (-1);
+					}
+					continue;
+				}
+				MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
+				MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
+				if (wwpn != lp->port_wwn ||
+				    wwnn != lp->node_wwn) {
+					isp_prt(isp, ISP_LOGWARN, "changed WWN"
+					    " after relogin");
+					lp->new_portid = portid;
+					lp->state = FC_PORTDB_STATE_DEAD;
+					continue;
+				}
+
+				lp->handle = pdb.handle;
+				handle_changed++;
+			}
+
+			nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
+
+			/*
+			 * Check to see whether the portid and roles have
+			 * stayed the same. If they have stayed the same,
+			 * we believe that this is the same device and it
+			 * hasn't become disconnected and reconnected, so
+			 * mark it as pending valid.
+			 *
+			 * If they aren't the same, mark the device as a
+			 * changed device and save the new port id and role
+			 * and let somebody else decide.
+			 */
+
+			lp->new_portid = portid;
+			lp->new_roles = nr;
+			if (pdb.portid != lp->portid || nr != lp->roles ||
+			    handle_changed) {
+				isp_prt(isp, ISP_LOGSANCFG,
+				    "Fabric Port 0x%06x changed", portid);
+				lp->state = FC_PORTDB_STATE_CHANGED;
+			} else {
+				isp_prt(isp, ISP_LOGSANCFG,
+				    "Fabric Port 0x%06x Now Pending Valid",
+				    portid);
+				lp->state = FC_PORTDB_STATE_PENDING_VALID;
+			}
 			continue;
 		}
-		lcl.port_wwn = 
-		    (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
-		    (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
-		    (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
-		    (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
-		    (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
-		    (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
-		    (((u_int64_t)gs1->snscb_wwn[6]) <<  8) |
-		    (((u_int64_t)gs1->snscb_wwn[7]));
-
-		MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
-		gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
-		gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
-		gq->snscb_sblen = 6;
-		gq->snscb_cmd = SNS_GNN_ID;
-		gq->snscb_portid = lcl.portid;
-		isp_put_gxn_id_request(isp, gq,
-		    (sns_gxn_id_req_t *) fcp->isp_scratch);
-		MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_SEND_SNS;
-		mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
-		mbs.param[2] = DMA_WD1(fcp->isp_scdma);
-		mbs.param[3] = DMA_WD0(fcp->isp_scdma);
+
 		/*
-		 * Leave 4 and 5 alone
+		 * Ah- a new entry. Search the database again for all non-NIL
+		 * entries to make sure we never ever make a new database entry
+		 * with the same port id. While we're at it, mark where the
+		 * last free entry was.
 		 */
-		mbs.param[6] = DMA_WD3(fcp->isp_scdma);
-		mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-		if (isp_fabric_mbox_cmd(isp, &mbs)) {
-			if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
-				fcp->isp_loopstate = LOOP_PDB_RCVD;
+	
+		dbidx = MAX_FC_TARG;
+		for (lp = fcp->portdb; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
+			if (lp >= &fcp->portdb[FL_ID] &&
+			    lp <= &fcp->portdb[SNS_ID]) {
+				continue;
 			}
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
-		}
-		if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
-		}
-		MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
-		gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
-		isp_get_gxn_id_response(isp, gs0, gs1);
-		if (gs1->snscb_cthdr.ct_response != FS_ACC) {
-			isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID",
-			    gs1->snscb_cthdr.ct_reason,
-			    gs1->snscb_cthdr.ct_explanation, lcl.portid);
-			if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
-				FC_SCRATCH_RELEASE(isp);
-				return (-1);
+			if (lp->state == FC_PORTDB_STATE_NIL) {
+				if (dbidx == MAX_FC_TARG) {
+					dbidx = lp - fcp->portdb;
+				}
+				continue;
+			}
+			if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
+				continue;
 			}
+			if (lp->portid == portid) {
+				break;
+			}
+		}
+
+		if (lp < &fcp->portdb[MAX_FC_TARG]) {
+			isp_prt(isp, ISP_LOGWARN,
+			    "PortID 0x%06x already at %d handle %d state %d",
+			    portid, dbidx, lp->handle, lp->state);
 			continue;
 		}
-		lcl.node_wwn = 
-		    (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
-		    (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
-		    (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
-		    (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
-		    (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
-		    (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
-		    (((u_int64_t)gs1->snscb_wwn[6]) <<  8) |
-		    (((u_int64_t)gs1->snscb_wwn[7]));
 
 		/*
-		 * The QLogic f/w is bouncing this with a parameter error.
+		 * We should have the index of the first free entry seen.
 		 */
-#if	0
+		if (dbidx == MAX_FC_TARG) {
+			isp_prt(isp, ISP_LOGERR,
+			    "port database too small to login PortID 0x%06x"
+			    "- increase MAX_FC_TARG", portid);
+			continue;
+		}
+
 		/*
-		 * Try and get FC4 Features (FC-GS-3 only).
-		 * We can use the sns_gxn_id_req_t for this request.
+		 * Otherwise, point to our new home.
 		 */
-		MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
-		gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1;
-		gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
-		gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
-		gq->snscb_sblen = 6;
-		gq->snscb_cmd = SNS_GFF_ID;
-		gq->snscb_portid = lcl.portid;
-		isp_put_gxn_id_request(isp, gq,
-		    (sns_gxn_id_req_t *) fcp->isp_scratch);
-		MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_SEND_SNS;
-		mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
-		mbs.param[2] = DMA_WD1(fcp->isp_scdma);
-		mbs.param[3] = DMA_WD0(fcp->isp_scdma);
+		lp = &fcp->portdb[dbidx];
+
 		/*
-		 * Leave 4 and 5 alone
+		 * Try to see if we are logged into this device,
+		 * and maybe log into it.
+		 *
+		 * isp_login_device will check for handle and
+		 * portid consistency after login.
 		 */
-		mbs.param[6] = DMA_WD3(fcp->isp_scdma);
-		mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-		if (isp_fabric_mbox_cmd(isp, &mbs)) {
-			if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
-				fcp->isp_loopstate = LOOP_PDB_RCVD;
-			}
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
-		}
-		if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
-			FC_SCRATCH_RELEASE(isp);
-			return (-1);
-		}
-		MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE);
-		fs0 = (sns_gff_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
-		isp_get_gff_id_response(isp, fs0, fs1);
-		if (fs1->snscb_cthdr.ct_response != FS_ACC) {
-			isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN,
-			    swrej, "GFF_ID",
-			    fs1->snscb_cthdr.ct_reason,
-			    fs1->snscb_cthdr.ct_explanation, lcl.portid);
+		if (isp_login_device(isp, portid, &pdb, &oldhandle)) {
 			if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
 				FC_SCRATCH_RELEASE(isp);
+				ISP_MARK_PORTDB(isp, 1);
 				return (-1);
 			}
-		} else {
-			int index = (ftype >> 3);
-			int bshft = (ftype & 0x7) * 4;
-			int fc4_fval =
-			    (fs1->snscb_fc4_features[index] >> bshft) & 0xf;
-			if (fc4_fval & 0x1) {
-				lcl.roles |=
-				    (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT);
+			continue;
+		}
+
+		handle = pdb.handle;
+		MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
+		MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
+		nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
+
+		/*
+		 * And go through the database *one* more time to make sure
+		 * that we do not make more than one entry that has the same
+		 * WWNN/WWPN duple
+		 */
+		for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
+			if (dbidx >= FL_ID && dbidx <= SNS_ID) {
+				continue;
+			}
+			if (fcp->portdb[dbidx].state == FC_PORTDB_STATE_NIL) {
+				continue;
 			}
-			if (fc4_fval & 0x2) {
-				lcl.roles |=
-				    (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT);
+			if (fcp->portdb[dbidx].node_wwn == wwnn &&
+			    fcp->portdb[dbidx].port_wwn == wwpn) {
+				break;
 			}
 		}
-#endif
+
+		if (dbidx == MAX_FC_TARG) {
+			MEMZERO(lp, sizeof (fcportdb_t));
+			lp->handle = handle;
+			lp->node_wwn = wwnn;
+			lp->port_wwn = wwpn;
+			lp->new_portid = portid;
+			lp->new_roles = nr;
+			lp->state = FC_PORTDB_STATE_NEW;
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "Fabric Port 0x%06x is New Entry", portid);
+			continue;
+		}
+
+    		if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
+			isp_prt(isp, ISP_LOGWARN,
+			    "PortID 0x%x 0x%08x%08x/0x%08x%08x %ld already at "
+			    "idx %d, state 0x%x", portid,
+			    (u_int32_t) (wwnn >> 32), (u_int32_t) wwnn,
+			    (u_int32_t) (wwpn >> 32), (u_int32_t) wwpn,
+			    (long) (lp - fcp->portdb), dbidx,
+			    fcp->portdb[dbidx].state);
+			continue;
+		}
 
 		/*
-		 * If we really want to know what kind of port type this is,
-		 * we have to run another CT command. Otherwise, we'll leave
-		 * it as undefined.
-		 *
-		lcl.port_type = 0;
+		 * We found a zombie entry that matches us.
+		 * Revive it. We know that WWN and WWPN
+		 * are the same. For fabric devices, we
+		 * don't care that handle is different
+		 * as we assign that. If role or portid
+		 * are different, it maybe a changed device.
 		 */
-		if (rs1->snscb_ports[i].control & 0x80) {
-			lcl.last_fabric_dev = 1;
+		lp = &fcp->portdb[dbidx];
+		lp->handle = handle;
+		lp->new_portid = portid;
+		lp->new_roles = nr;
+		if (lp->portid != portid || lp->roles != nr) {
+			isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+			    "Zombie Fabric Port 0x%06x Now Changed", portid);
+			lp->state = FC_PORTDB_STATE_CHANGED;
 		} else {
-			lcl.last_fabric_dev = 0;
+			isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+			    "Zombie Fabric Port 0x%06x Now Pending Valid",
+			    portid);
+			lp->state = FC_PORTDB_STATE_PENDING_VALID;
 		}
-		(void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
+	}
 
-	} while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1);
+	FC_SCRATCH_RELEASE(isp);
+	if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
+		ISP_MARK_PORTDB(isp, 1);
+		return (-1);
+	}
+	fcp->isp_loopstate = LOOP_FSCAN_DONE;
+	isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric Done");
+	return (0);
+}
+
+/*
+ * Find an unused handle and try and use to login to a port.
+ */
+int
+isp_login_device(struct ispsoftc *isp, u_int32_t portid, isp_pdb_t *p, u_int16_t *ohp)
+{
+	int lim, i, r;
+	u_int16_t handle;
+
+	if (FCPARAM(isp)->isp_2klogin) {
+		lim = NPH_MAX_2K;
+	} else {
+		lim = NPH_MAX;
+	}
+
+	handle = isp_nxt_handle(isp, *ohp);
+	for (i = 0; i < lim; i++) {
+		/*
+		 * See if we're still logged into something with
+		 * this handle and that something agrees with this
+		 * port id.
+		 */
+		r = isp_getpdb(isp, handle, p, 0);
+		if (r == 0 && p->portid != portid) {
+			(void) isp_plogx(isp, handle, portid,
+			    PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT, 1);
+		} else if (r == 0) {
+			break;
+		}
+		if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
+			return (-1);
+		}
+		/*
+		 * Now try and log into the device
+		 */
+		r = isp_plogx(isp, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
+		if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
+			return (-1);
+		}
+		if (r == 0) {
+			*ohp = handle;
+			break;
+		} else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
+			handle = r >> 16;
+			break;
+		} else if (r != MBOX_LOOP_ID_USED) {
+			i = lim;
+			break;
+		} else {
+			*ohp = handle;
+			handle = isp_nxt_handle(isp, *ohp);
+		}
+	}
+
+	if (i == lim) {
+		isp_prt(isp, ISP_LOGWARN, "PLOGI 0x%06x failed", portid);
+		return (-1);
+	}
 
 	/*
-	 * If we're not at the last entry, our list isn't big enough.
+	 * If we successfully logged into it, get the PDB for it
+	 * so we can crosscheck that it is still what we think it
+	 * is and that we also have the role it plays
 	 */
-	if ((rs1->snscb_ports[i].control & 0x80) == 0) {
-		isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area");
+	r = isp_getpdb(isp, handle, p, 0);
+	if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
+		return (-1);
+	}
+	if (r != 0) {
+		isp_prt(isp, ISP_LOGERR, "new device 0x%06x@0x%x disappeared",
+		    portid, handle);
+		return (-1);
 	}
 
-	FC_SCRATCH_RELEASE(isp);
-	fcp->isp_loopstate = LOOP_FSCAN_DONE;
+	if (p->handle != handle || p->portid != portid) {
+		isp_prt(isp, ISP_LOGERR,
+		    "new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
+		    portid, handle, p->portid, p->handle);
+		return (-1);
+	}
 	return (0);
 }
-#endif
 
-static void
+int
 isp_register_fc4_type(struct ispsoftc *isp)
 {
 	fcparam *fcp = isp->isp_param;
@@ -2928,9 +3839,6 @@ isp_register_fc4_type(struct ispsoftc *isp)
 	reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
 	reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
 	reqp->snscb_data[6] = (1 << FC4_SCSI);
-#if	0
-	reqp->snscb_data[6] |= (1 << FC4_IP);	/* ISO/IEC 8802-2 LLC/SNAP */
-#endif
 	FC_SCRATCH_ACQUIRE(isp);
 	isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
 	MEMZERO(&mbs, sizeof (mbs));
@@ -2938,18 +3846,167 @@ isp_register_fc4_type(struct ispsoftc *isp)
 	mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
-	/*
-	 * Leave 4 and 5 alone
-	 */
 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
-	isp_mboxcmd(isp, &mbs, MBLOGALL);
+	mbs.logval = MBLOGALL;
+	mbs.timeout = 10000000;
+	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_RFT_ID_REQ_SIZE);
+	isp_mboxcmd(isp, &mbs);
 	FC_SCRATCH_RELEASE(isp);
 	if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
-		isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded");
+		return (0);
+	} else {
+		return (-1);
 	}
 }
 
+int
+isp_register_fc4_type_24xx(struct ispsoftc *isp)
+{
+	mbreg_t mbs;
+	fcparam *fcp = FCPARAM(isp);
+	union {
+		isp_ct_pt_t plocal;
+		rft_id_t clocal;
+		u_int8_t q[QENTRY_LEN];
+	} un;
+	isp_ct_pt_t *pt;
+	ct_hdr_t *ct;
+	rft_id_t *rp;
+	u_int8_t *scp = fcp->isp_scratch;
+
+	FC_SCRATCH_ACQUIRE(isp);
+	/*
+	 * Build a Passthrough IOCB in memory.
+	 */
+	MEMZERO(un.q, QENTRY_LEN);
+	pt = &un.plocal;
+	pt->ctp_header.rqs_entry_count = 1;
+	pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
+	pt->ctp_handle = 0xffffffff;
+	pt->ctp_nphdl = NPH_SNS_ID;
+	pt->ctp_cmd_cnt = 1;
+	pt->ctp_time = 1;
+	pt->ctp_rsp_cnt = 1;
+	pt->ctp_rsp_bcnt = sizeof (ct_hdr_t);
+	pt->ctp_cmd_bcnt = sizeof (rft_id_t);
+	pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
+	pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
+	pt->ctp_dataseg[0].ds_count = sizeof (rft_id_t);
+	pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
+	pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
+	pt->ctp_dataseg[1].ds_count = sizeof (ct_hdr_t);
+	isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
+
+	/*
+	 * Build the CT header and command in memory.
+	 *
+	 * Note that the CT header has to end up as Big Endian format in memory.
+	 */
+	MEMZERO(&un.clocal, sizeof (un.clocal));
+	ct = &un.clocal.rftid_hdr;
+	ct->ct_revision = CT_REVISION;
+	ct->ct_fcs_type = CT_FC_TYPE_FC;
+	ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
+	ct->ct_cmd_resp = SNS_RFT_ID;
+	ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
+	rp = &un.clocal;
+	rp->rftid_portid[0] = fcp->isp_portid >> 16;
+	rp->rftid_portid[1] = fcp->isp_portid >> 8;
+	rp->rftid_portid[2] = fcp->isp_portid;
+	rp->rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
+	isp_put_rft_id(isp, rp, (rft_id_t *) &scp[XTXOFF]);
+
+	MEMZERO(&scp[ZTXOFF], sizeof (ct_hdr_t));
+
+	MEMZERO(&mbs, sizeof (mbs));
+	mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
+	mbs.param[1] = QENTRY_LEN;
+	mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
+	mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
+	mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
+	mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
+	mbs.timeout = 500000;
+	mbs.logval = MBLOGALL;
+	MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
+	isp_mboxcmd(isp, &mbs);
+	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+		FC_SCRATCH_RELEASE(isp);
+		return (-1);
+	}
+	MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
+	pt = &un.plocal;
+	isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
+	if (isp->isp_dblev & ISP_LOGDEBUG1) {
+		isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
+	}
+	if (pt->ctp_status) {
+		FC_SCRATCH_RELEASE(isp);
+		isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
+		    pt->ctp_status);
+		return (-1);
+	}
+
+	isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
+	FC_SCRATCH_RELEASE(isp);
+
+	if (ct->ct_cmd_resp == LS_RJT) {
+		isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+		    "Register FC4 Type rejected");
+		return (-1);
+	} else if (ct->ct_cmd_resp == LS_ACC) {
+		isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
+		    "Register FC4 Type accepted");
+		return(0);
+	} else {
+		isp_prt(isp, ISP_LOGWARN,
+		    "Register FC4 Type: 0x%x", ct->ct_cmd_resp);
+		return (-1);
+	}
+}
+
+u_int16_t
+isp_nxt_handle(struct ispsoftc *isp, u_int16_t handle)
+{
+	int i;
+	if (handle == NIL_HANDLE) {
+		if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
+			handle = 0;
+		} else {
+			handle = SNS_ID+1;
+		}
+	} else {
+		handle += 1;
+		if (handle >= FL_ID && handle <= SNS_ID) {
+			handle = SNS_ID+1;
+		}
+		if (handle >= NPH_RESERVED && handle <= NPH_FL_ID) {
+			handle = NPH_FL_ID+1;
+		}
+		if (FCPARAM(isp)->isp_2klogin) {
+			if (handle == NPH_MAX_2K) {
+				handle = 0;
+			}
+		} else {
+			if (handle == NPH_MAX) {
+				handle = 0;
+			}
+		}
+	}
+	if (handle == FCPARAM(isp)->isp_loopid) {
+		return (isp_nxt_handle(isp, handle));
+	}
+	for (i = 0; i < MAX_FC_TARG; i++) {
+		if (FCPARAM(isp)->portdb[i].state == FC_PORTDB_STATE_NIL) {
+			continue;
+		}
+		if (FCPARAM(isp)->portdb[i].handle == handle) {
+			return (isp_nxt_handle(isp, handle));
+		}
+	}
+	return (handle);
+}
+
 /*
  * Start a command. Locking is assumed done in the caller.
  */
@@ -2958,10 +4015,12 @@ int
 isp_start(XS_T *xs)
 {
 	struct ispsoftc *isp;
-	u_int16_t nxti, optr, handle;
+	u_int32_t nxti, optr, handle;
 	u_int8_t local[QENTRY_LEN];
 	ispreq_t *reqp, *qep;
-	int target, i;
+	void *cdbp;
+	u_int16_t *tptr;
+	int target, i, hdlidx = 0;
 
 	XS_INITERR(xs);
 	isp = XS_ISP(xs);
@@ -3000,201 +4059,54 @@ isp_start(XS_T *xs)
 	}
 
 	/*
-	 * Check to see whether we have good firmware state still or
-	 * need to refresh our port database for this target.
+	 * Translate the target to device handle as appropriate, checking
+	 * for correct device state as well.
 	 */
 	target = XS_TGT(xs);
 	if (IS_FC(isp)) {
 		fcparam *fcp = isp->isp_param;
-		struct lportdb *lp;
-#ifdef	HANDLE_LOOPSTATE_IN_OUTER_LAYERS
-		if (fcp->isp_fwstate != FW_READY ||
-		    fcp->isp_loopstate != LOOP_READY) {
-			return (CMD_RQLATER);
-		}
-
-		/*
-		 * If we're not on a Fabric, we can't have a target
-		 * above FL_PORT_ID-1.
-		 *
-		 * If we're on a fabric and *not* connected as an F-port,
-		 * we can't have a target less than FC_SNS_ID+1. This
-		 * keeps us from having to sort out the difference between
-		 * local public loop devices and those which we might get
-		 * from a switch's database.
-		 */
-		if (fcp->isp_onfabric == 0) {
-			if (target >= FL_PORT_ID) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				return (CMD_COMPLETE);
-			}
-		} else {
-			if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				return (CMD_COMPLETE);
-			}
-			/*
-			 * We used to exclude having local loop ports
-			 * at the same time that we have fabric ports.
-			 * That is, we used to exclude having ports
-			 * at < FL_PORT_ID if we're FL-port.
-			 *
-			 * That's wrong. The only thing that could be
-			 * dicey is if the switch you're connected to
-			 * has these local loop ports appear on the
-			 * fabric and we somehow attach them twice.
-			 */
-		}
-#else
-		/*
-		 * Check for f/w being in ready state. If the f/w
-		 * isn't in ready state, then we don't know our
-		 * loop ID and the f/w hasn't completed logging
-		 * into all targets on the loop. If this is the
-		 * case, then bounce the command. We pretend this is
-		 * a SELECTION TIMEOUT error if we've never gone to
-		 * FW_READY state at all- in this case we may not
-		 * be hooked to a loop at all and we shouldn't hang
-		 * the machine for this. Otherwise, defer this command
-		 * until later.
-		 */
-		if (fcp->isp_fwstate != FW_READY) {
-			/*
-			 * Give ourselves at most a 250ms delay.
-			 */
-			if (isp_fclink_test(isp, 250000)) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				if (fcp->loop_seen_once) {
-					return (CMD_RQLATER);
-				} else {
-					return (CMD_COMPLETE);
-				}
-			}
-		}
 
 		/*
-		 * If we're not on a Fabric, we can't have a target
-		 * above FL_PORT_ID-1.
-		 *
-		 * If we're on a fabric and *not* connected as an F-port,
-		 * we can't have a target less than FC_SNS_ID+1. This
-		 * keeps us from having to sort out the difference between
-		 * local public loop devices and those which we might get
-		 * from a switch's database.
+		 * Try again later.
 		 */
-		if (fcp->isp_onfabric == 0) {
-			if (target >= FL_PORT_ID) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				return (CMD_COMPLETE);
-			}
-		} else {
-			if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				return (CMD_COMPLETE);
-			}
-			if (fcp->isp_topo != TOPO_F_PORT &&
-			    target < FL_PORT_ID) {
-				XS_SETERR(xs, HBA_SELTIMEOUT);
-				return (CMD_COMPLETE);
-			}
-		}
-
-		/*
-		 * If our loop state is such that we haven't yet received
-		 * a "Port Database Changed" notification (after a LIP or
-		 * a Loop Reset or firmware initialization), then defer
-		 * sending commands for a little while, but only if we've
-		 * seen a valid loop at one point (otherwise we can get
-		 * stuck at initialization time).
-		 */
-		if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
-			XS_SETERR(xs, HBA_SELTIMEOUT);
-			if (fcp->loop_seen_once) {
-				return (CMD_RQLATER);
-			} else {
-				return (CMD_COMPLETE);
-			}
-		}
-
-		/*
-		 * If we're in the middle of loop or fabric scanning
-		 * or merging the port databases, retry this command later.
-		 */
-		if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC ||
-		    fcp->isp_loopstate == LOOP_SCANNING_LOOP ||
-		    fcp->isp_loopstate == LOOP_SYNCING_PDB) {
+		if (fcp->isp_fwstate != FW_READY ||
+		    fcp->isp_loopstate != LOOP_READY) {
 			return (CMD_RQLATER);
 		}
 
-		/*
-		 * If our loop state is now such that we've just now
-		 * received a Port Database Change notification, then
-		 * we have to go off and (re)scan the fabric. We back
-		 * out and try again later if this doesn't work.
-		 */
-		if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) {
-			if (isp_scan_fabric(isp, FC4_SCSI)) {
-				return (CMD_RQLATER);
-			}
-			if (fcp->isp_fwstate != FW_READY ||
-			    fcp->isp_loopstate < LOOP_FSCAN_DONE) {
-				return (CMD_RQLATER);
-			}
-		}
-
-		/*
-		 * If our loop state is now such that we've just now
-		 * received a Port Database Change notification, then
-		 * we have to go off and (re)synchronize our port
-		 * database.
-		 */
-		if (fcp->isp_loopstate < LOOP_READY) {
-			if (isp_pdb_sync(isp)) {
-				return (CMD_RQLATER);
-			}
-			if (fcp->isp_fwstate != FW_READY ||
-			    fcp->isp_loopstate != LOOP_READY) {
-				return (CMD_RQLATER);
-			}
+		if (XS_TGT(xs) >= MAX_FC_TARG) {
+			XS_SETERR(xs, HBA_SELTIMEOUT);
+			return (CMD_COMPLETE);
 		}
 
-		/*
-		 * XXX: Here's were we would cancel any loop_dead flag
-		 * XXX: also cancel in dead_loop timeout that's running
-		 */
-#endif
-
-		/*
-		 * Now check whether we should even think about pursuing this.
-		 */
-		lp = &fcp->portdb[target];
-		if (lp->valid == 0) {
+		hdlidx = fcp->isp_ini_map[XS_TGT(xs)] - 1;
+		isp_prt(isp, ISP_LOGDEBUG1, "XS_TGT(xs)=%d- hdlidx value %d",
+		    XS_TGT(xs), hdlidx);
+		if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
 			XS_SETERR(xs, HBA_SELTIMEOUT);
 			return (CMD_COMPLETE);
 		}
-		if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
-			isp_prt(isp, ISP_LOGDEBUG2,
-			    "Target %d does not have target service", target);
+		if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
+			return (CMD_RQLATER);
+		}
+		if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
 			XS_SETERR(xs, HBA_SELTIMEOUT);
 			return (CMD_COMPLETE);
 		}
-		/*
-		 * Now turn target into what the actual Loop ID is.
-		 */
-		target = lp->loopid;
-		xs->sc_link->node_wwn = lp->node_wwn;
-		xs->sc_link->port_wwn = lp->port_wwn;
-
+		target = fcp->portdb[hdlidx].handle;
+		xs->sc_link->node_wwn = fcp->portdb[hdlidx].node_wwn;
+		xs->sc_link->port_wwn = fcp->portdb[hdlidx].port_wwn;
 	}
 
 	/*
-	 * Next check to see if any HBA or Device
-	 * parameters need to be updated.
+	 * Next check to see if any HBA or Device parameters need to be updated.
 	 */
 	if (isp->isp_update != 0) {
 		isp_update(isp);
 	}
 
+ start_again:
+
 	if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
 		isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
 		XS_SETERR(xs, HBA_BOTCH);
@@ -3208,34 +4120,40 @@ isp_start(XS_T *xs)
 	 */
 	reqp = (ispreq_t *) local;
 	if (isp->isp_sendmarker) {
-		u_int8_t n = (IS_DUALBUS(isp)? 2: 1);
-		/*
-		 * Check ports to send markers for...
-		 */
-		for (i = 0; i < n; i++) {
-			if ((isp->isp_sendmarker & (1 << i)) == 0) {
-				continue;
-			}
-			MEMZERO((void *) reqp, QENTRY_LEN);
-			reqp->req_header.rqs_entry_count = 1;
-			reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
-			reqp->req_modifier = SYNC_ALL;
-			reqp->req_target = i << 7;	/* insert bus number */
-			isp_put_request(isp, reqp, qep);
+		if (IS_24XX(isp)) {
+			isp_marker_24xx_t *m = (isp_marker_24xx_t *) qep;
+			MEMZERO(m, QENTRY_LEN);
+			m->mrk_header.rqs_entry_count = 1;
+			m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
+			m->mrk_modifier = SYNC_ALL;
+			isp_put_marker_24xx(isp, m, (isp_marker_24xx_t *)qep);
 			ISP_ADD_REQUEST(isp, nxti);
-			isp->isp_sendmarker &= ~(1 << i);
-			if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) {
-				isp_prt(isp, ISP_LOGDEBUG0,
-				    "Request Queue Overflow+");
-				XS_SETERR(xs, HBA_BOTCH);
-				return (CMD_EAGAIN);
+			isp->isp_sendmarker = 0;
+			goto start_again;
+		} else {
+			for (i = 0; i < (IS_DUALBUS(isp)? 2: 1); i++) {
+				isp_marker_t *m = (isp_marker_t *) qep;
+				if ((isp->isp_sendmarker & (1 << i)) == 0) {
+					continue;
+				}
+				MEMZERO(m, QENTRY_LEN);
+				m->mrk_header.rqs_entry_count = 1;
+				m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
+				m->mrk_target = (i << 7);	/* bus # */
+				m->mrk_modifier = SYNC_ALL;
+				isp_put_marker(isp, m, (isp_marker_t *) qep);
+				ISP_ADD_REQUEST(isp, nxti);
+				isp->isp_sendmarker &= ~(1 << i);
+				goto start_again;
 			}
 		}
 	}
 
 	MEMZERO((void *)reqp, QENTRY_LEN);
 	reqp->req_header.rqs_entry_count = 1;
-	if (IS_FC(isp)) {
+	if (IS_24XX(isp)) {
+		reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
+	} else if (IS_FC(isp)) {
 		reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
 	} else {
 		if (XS_CDBLEN(xs) > 12)
@@ -3245,7 +4163,26 @@ isp_start(XS_T *xs)
 	}
 	/* reqp->req_header.rqs_flags = 0; */
 	/* reqp->req_header.rqs_seqno = 0; */
-	if (IS_FC(isp)) {
+	if (IS_24XX(isp)) {
+		int ttype;
+		if (XS_TAG_P(xs)) {
+			ttype = XS_TAG_TYPE(xs);
+		} else {
+			if (XS_CDBP(xs)[0] == 0x3) {
+				ttype = REQFLAG_HTAG;
+			} else {
+				ttype = REQFLAG_STAG;
+			}
+		}
+		if (ttype == REQFLAG_OTAG) {
+			ttype = FCP_CMND_TASK_ATTR_ORDERED;
+		} else if (ttype == REQFLAG_HTAG) {
+			ttype = FCP_CMND_TASK_ATTR_HEAD;
+		} else {
+			ttype = FCP_CMND_TASK_ATTR_SIMPLE;
+		}
+		((ispreqt7_t *)reqp)->req_task_attribute = ttype;
+	} else if (IS_FC(isp)) {
 		/*
 		 * See comment in isp_intr
 		 */
@@ -3253,7 +4190,7 @@ isp_start(XS_T *xs)
 
 		/*
 		 * Fibre Channel always requires some kind of tag.
-		 * The QLogic drivers seem be happy not to use a tag,
+		 * The Qlogic drivers seem be happy not to use a tag,
 		 * but this breaks for some devices (IBM drives).
 		 */
 		if (XS_TAG_P(xs)) {
@@ -3276,21 +4213,45 @@ isp_start(XS_T *xs)
 			reqp->req_flags = XS_TAG_TYPE(xs);
 		}
 	}
-	reqp->req_target = target | (XS_CHANNEL(xs) << 7);
+	cdbp = reqp->req_cdb;
+	tptr = &reqp->req_time;
+
 	if (IS_SCSI(isp)) {
+		reqp->req_target = target | (XS_CHANNEL(xs) << 7);
 		reqp->req_lun_trn = XS_LUN(xs);
 		reqp->req_cdblen = XS_CDBLEN(xs);
+	} else if (IS_24XX(isp)) {
+		fcportdb_t *lp;
+
+		lp = &FCPARAM(isp)->portdb[hdlidx];
+		((ispreqt7_t *)reqp)->req_nphdl = target;
+		((ispreqt7_t *)reqp)->req_tidlo = lp->portid;
+		((ispreqt7_t *)reqp)->req_tidhi = lp->portid >> 16;
+		if (XS_LUN(xs) > 256) {
+			((ispreqt7_t *)reqp)->req_lun[0] = XS_LUN(xs) >> 8;
+			((ispreqt7_t *)reqp)->req_lun[0] |= 0x40;
+		}
+		((ispreqt7_t *)reqp)->req_lun[1] = XS_LUN(xs);
+		cdbp = ((ispreqt7_t *)reqp)->req_cdb;
+		tptr = &((ispreqt7_t *)reqp)->req_time;
+	} else if (FCPARAM(isp)->isp_2klogin) {
+		((ispreqt2e_t *)reqp)->req_target = target;
+		((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs);
+	} else if (FCPARAM(isp)->isp_sccfw) {
+		((ispreqt2_t *)reqp)->req_target = target;
+		((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
 	} else {
-		if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)
-			((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
-		else
-			((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
+		((ispreqt2_t *)reqp)->req_target = target;
+		((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
 	}
-	MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
+	MEMCPY(cdbp, XS_CDBP(xs), XS_CDBLEN(xs));
 
-	reqp->req_time = XS_TIME(xs) / 1000;
-	if (reqp->req_time == 0 && XS_TIME(xs)) {
-		reqp->req_time = 1;
+	*tptr = XS_TIME(xs) / 1000;
+	if (*tptr == 0 && XS_TIME(xs)) {
+		*tptr = 1;
+	}
+	if (IS_24XX(isp) && *tptr > 0x1999) {
+		*tptr = 0x1999;
 	}
 
 	if (isp_save_xs(isp, xs, &handle)) {
@@ -3298,11 +4259,12 @@ isp_start(XS_T *xs)
 		XS_SETERR(xs, HBA_BOTCH);
 		return (CMD_EAGAIN);
 	}
+	/* Whew. Thankfully the same for type 7 requests */
 	reqp->req_handle = handle;
 
 	/*
 	 * Set up DMA and/or do any bus swizzling of the request entry
-	 * so that the QLogic F/W understands what is being asked of it.
+	 * so that the Qlogic F/W understands what is being asked of it.
 	 */
 	i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
 	if (i != CMD_QUEUED) {
@@ -3314,7 +4276,7 @@ isp_start(XS_T *xs)
 		return (i);
 	}
 	XS_SETERR(xs, HBA_NOERROR);
-	isp_prt(isp, ISP_LOGDEBUG2,
+	isp_prt(isp, ISP_LOGDEBUG0,
 	    "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
 	    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
 	    (long) XS_XFRLEN(xs));
@@ -3334,7 +4296,9 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 	XS_T *xs;
 	mbreg_t mbs;
 	int bus, tgt;
-	u_int16_t handle;
+	u_int32_t handle;
+
+	MEMZERO(&mbs, sizeof (mbs));
 
 	switch (ctl) {
 	default:
@@ -3345,22 +4309,26 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 		/*
 		 * Issue a bus reset.
 		 */
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_BUS_RESET;
-		if (IS_SCSI(isp)) {
-			mbs.param[1] =
-			    ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
-			if (mbs.param[1] < 2)
+		if (IS_24XX(isp)) {
+			isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLEMENTED");
+			break;
+		} else if (IS_FC(isp)) {
+			mbs.param[1] = 10;
+			bus = 0;
+		} else {
+			mbs.param[1] = SDPARAM(isp)->isp_bus_reset_delay;
+			if (mbs.param[1] < 2) {
 				mbs.param[1] = 2;
+			}
 			bus = *((int *) arg);
-			if (IS_DUALBUS(isp))
+			if (IS_DUALBUS(isp)) {
 				mbs.param[2] = bus;
-		} else {
-			mbs.param[1] = 10;
-			bus = 0;
+			}
 		}
+		mbs.param[0] = MBOX_BUS_RESET;
 		isp->isp_sendmarker |= (1 << bus);
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			break;
 		}
@@ -3370,12 +4338,25 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 
 	case ISPCTL_RESET_DEV:
 		tgt = (*((int *) arg)) & 0xffff;
-		bus = (*((int *) arg)) >> 16;
-		MEMZERO(&mbs, sizeof (mbs));
+		if (IS_24XX(isp)) {
+			isp_prt(isp, ISP_LOGWARN, "RESET DEV NOT IMPLEMENTED");
+			break;
+		} else if (IS_FC(isp)) {
+			if (FCPARAM(isp)->isp_2klogin) {
+				mbs.param[1] = tgt;
+				mbs.ibits = (1 << 10);
+			} else {
+				mbs.param[1] = (tgt << 8);
+			}
+			bus = 0;
+		} else {
+			bus = (*((int *) arg)) >> 16;
+			mbs.param[1] = (bus << 15) | (tgt << 8);
+		}
 		mbs.param[0] = MBOX_ABORT_TARGET;
-		mbs.param[1] = (tgt << 8) | (bus << 15);
 		mbs.param[2] = 3;	/* 'delay', in seconds */
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			break;
 		}
@@ -3387,38 +4368,39 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 	case ISPCTL_ABORT_CMD:
 		xs = (XS_T *) arg;
 		tgt = XS_TGT(xs);
+
 		handle = isp_find_handle(isp, xs);
 		if (handle == 0) {
 			isp_prt(isp, ISP_LOGWARN,
 			    "cannot find handle for command to abort");
 			break;
 		}
-		bus = XS_CHANNEL(xs);
-		MEMZERO(&mbs, sizeof (mbs));
-		mbs.param[0] = MBOX_ABORT;
-		if (IS_FC(isp)) {
-			if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)  {
-				mbs.param[1] = tgt << 8;
-				mbs.param[4] = 0;
-				mbs.param[5] = 0;
+		if (IS_24XX(isp)) {
+			isp_prt(isp, ISP_LOGWARN, "ABORT CMD NOT IMPLEMENTED");
+			break;
+		} else if (IS_FC(isp)) {
+			if (FCPARAM(isp)->isp_sccfw) {
+				if (FCPARAM(isp)->isp_2klogin) {
+					mbs.param[1] = tgt;
+				} else {
+					mbs.param[1] = tgt << 8;
+				}
 				mbs.param[6] = XS_LUN(xs);
 			} else {
 				mbs.param[1] = tgt << 8 | XS_LUN(xs);
 			}
 		} else {
-			mbs.param[1] =
-			    (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
+			bus = XS_CHANNEL(xs);
+			mbs.param[1] = (bus << 15) | (tgt << 8) | XS_LUN(xs);
 		}
+		mbs.param[0] = MBOX_ABORT;
 		mbs.param[2] = handle;
-		isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
-		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
-			return (0);
+		mbs.logval = MBLOGALL & ~MBOX_COMMAND_ERROR;
+		isp_mboxcmd(isp, &mbs);
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			break;
 		}
-		/*
-		 * XXX: Look for command in the REQUEST QUEUE. That is,
-		 * XXX: It hasn't been picked up by firmware yet.
-		 */
-		break;
+		return (0);
 
 	case ISPCTL_UPDATE_PARAMS:
 
@@ -3428,7 +4410,10 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 	case ISPCTL_FCLINK_TEST:
 
 		if (IS_FC(isp)) {
-			int usdelay = (arg)? *((int *) arg) : 250000;
+			int usdelay = *((int *) arg);
+			if (usdelay == 0) {
+				usdelay =  250000;
+			}
 			return (isp_fclink_test(isp, usdelay));
 		}
 		break;
@@ -3436,8 +4421,7 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 	case ISPCTL_SCAN_FABRIC:
 
 		if (IS_FC(isp)) {
-			int ftype = (arg)? *((int *) arg) : FC4_SCSI;
-			return (isp_scan_fabric(isp, ftype));
+			return (isp_scan_fabric(isp));
 		}
 		break;
 
@@ -3457,28 +4441,64 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 
 	case ISPCTL_SEND_LIP:
 
-		if (IS_FC(isp)) {
-			MEMZERO(&mbs, sizeof (mbs));
+		if (IS_FC(isp) && !IS_24XX(isp)) {
 			mbs.param[0] = MBOX_INIT_LIP;
-			isp_mboxcmd(isp, &mbs, MBLOGALL);
+			if (FCPARAM(isp)->isp_2klogin) {
+				mbs.ibits = (1 << 10);
+			}
+			mbs.logval = MBLOGALL;
+			isp_mboxcmd(isp, &mbs);
 			if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 				return (0);
 			}
 		}
 		break;
 
-	case ISPCTL_GET_POSMAP:
-
+	case ISPCTL_GET_PDB:
 		if (IS_FC(isp) && arg) {
-			return (isp_getmap(isp, arg));
+			int id = *((int *)arg);
+			isp_pdb_t *pdb = arg;
+			return (isp_getpdb(isp, id, pdb, 1));
 		}
 		break;
 
+	case ISPCTL_GET_PORTNAME:
+	{
+		u_int64_t *wwnp = arg;
+		int loopid = *wwnp;
+		*wwnp = isp_get_portname(isp, loopid, 0);
+		if (*wwnp == (u_int64_t) -1) {
+			break;
+		} else {
+			return (0);
+		}
+	}
 	case ISPCTL_RUN_MBOXCMD:
 
-		isp_mboxcmd(isp, arg, MBLOGALL);
+		isp_mboxcmd(isp, arg);
 		return(0);
 
+	case ISPCTL_PLOGX:
+	{
+		isp_plcmd_t *p = arg;
+		int r;
+
+		if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI ||
+		    (p->handle != NIL_HANDLE)) {
+			return (isp_plogx(isp, p->handle, p->portid,
+			    p->flags, 0));
+		}
+		do {
+			p->handle = isp_nxt_handle(isp, p->handle);
+			r = isp_plogx(isp, p->handle, p->portid, p->flags, 0);
+			if ((r & 0xffff) == MBOX_PORT_ID_USED) {
+				p->handle = r >> 16;
+				r = 0;
+				break;
+			}
+		} while ((r & 0xffff) == MBOX_LOOP_ID_USED);
+		return (r);
+	}
 #ifdef	ISP_TARGET_MODE
 	case ISPCTL_TOGGLE_TMODE:
 	{
@@ -3489,11 +4509,11 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 		 */
 		if (IS_SCSI(isp)) {
 			int param = *(int *)arg;
-			MEMZERO(&mbs, sizeof (mbs));
 			mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
 			mbs.param[1] = param & 0xffff;
 			mbs.param[2] = param >> 16;
-			isp_mboxcmd(isp, &mbs, MBLOGALL);
+			mbs.logval = MBLOGALL;
+			isp_mboxcmd(isp, &mbs);
 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 				break;
 			}
@@ -3517,17 +4537,18 @@ isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
  * of completions on a request queue at any one time.
  */
 #ifndef	MAX_REQUESTQ_COMPLETIONS
-#define	MAX_REQUESTQ_COMPLETIONS	64
+#define	MAX_REQUESTQ_COMPLETIONS	32
 #endif
 
 void
-isp_intr(struct ispsoftc *isp, u_int16_t isr, u_int16_t sema, u_int16_t mbox)
+isp_intr(struct ispsoftc *isp, u_int32_t isr, u_int16_t sema, u_int16_t mbox)
 {
 	XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
-	u_int16_t iptr, optr, junk;
+	u_int32_t iptr, optr, junk;
 	int i, nlooked = 0, ndone = 0;
 
 again:
+	optr = isp->isp_residx;
 	/*
 	 * Is this a mailbox related interrupt?
 	 * The mailbox semaphore will be nonzero if so.
@@ -3538,7 +4559,7 @@ again:
 			if (isp->isp_mboxbsy) {
 				int obits = isp->isp_obits;
 				isp->isp_mboxtmp[0] = mbox;
-				for (i = 1; i < MAX_MAILBOX; i++) {
+				for (i = 1; i < MAX_MAILBOX(isp); i++) {
 					if ((obits & (1 << i)) == 0) {
 						continue;
 					}
@@ -3553,17 +4574,14 @@ again:
 				MBOX_NOTIFY_COMPLETE(isp);
 			} else {
 				isp_prt(isp, ISP_LOGWARN,
-				    "Mbox Command Async (0x%x) with no waiters",
-				    mbox);
+				    "mailbox cmd (0x%x) with no waiters", mbox);
 			}
 		} else if (isp_parse_async(isp, mbox) < 0) {
 			return;
 		}
 		if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
 		    isp->isp_state != ISP_RUNSTATE) {
-			ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
-			ISP_WRITE(isp, BIU_SEMA, 0);
-			return;
+			goto out;
 		}
 	}
 
@@ -3571,32 +4589,73 @@ again:
 	 * We can't be getting this now.
 	 */
 	if (isp->isp_state != ISP_RUNSTATE) {
-		isp_prt(isp, ISP_LOGWARN,
+		isp_prt(isp, ISP_LOGINFO,
 		    "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
 		/*
 		 * Thank you very much!  *Burrrp*!
 		 */
-		WRITE_RESPONSE_QUEUE_OUT_POINTER(isp,
-		    READ_RESPONSE_QUEUE_IN_POINTER(isp));
+		ISP_WRITE(isp, isp->isp_respoutrp,
+		    ISP_READ(isp, isp->isp_respinrp));
+		if (IS_24XX(isp)) {
+			ISP_DISABLE_INTS(isp);
+		}
+		goto out;
+	}
 
-		ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
-		ISP_WRITE(isp, BIU_SEMA, 0);
-		return;
+#ifdef	ISP_TARGET_MODE
+	/*
+	 * Check for ATIO Queue entries.
+	 */
+	if (isp->isp_rspbsy == 0 && (isp->isp_role & ISP_ROLE_TARGET) &&
+	    IS_24XX(isp)) {
+		iptr = ISP_READ(isp, isp->isp_atioinrp);
+		optr = ISP_READ(isp, isp->isp_atiooutrp);
+
+		isp->isp_rspbsy = 1;
+		while (optr != iptr) {
+			u_int8_t qe[QENTRY_LEN];
+			isphdr_t *hp;
+			u_int32_t oop;
+			void *addr;
+
+			oop = optr;
+			MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN);
+			addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
+			isp_get_hdr(isp, addr, (isphdr_t *)qe);
+			hp = (isphdr_t *)qe;
+			switch (hp->rqs_entry_type) {
+			case RQSTYPE_NOTIFY:
+			case RQSTYPE_ATIO:
+				(void) isp_target_notify(isp, addr, &oop);
+				break;
+			default:
+				isp_print_qentry(isp, "?ATIOQ entry?",
+				    oop, addr);
+				break;
+			}
+			optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
+			ISP_WRITE(isp, isp->isp_atiooutrp, optr);
+		}
+		isp->isp_rspbsy = 0;
+		optr = isp->isp_residx;
 	}
+#endif
 
 	/*
 	 * Get the current Response Queue Out Pointer.
 	 *
-	 * If we're a 2300, we can ask what hardware what it thinks.
+	 * If we're a 2300 or 2400, we can ask what hardware what it thinks.
 	 */
-	if (IS_23XX(isp)) {
+	if (IS_23XX(isp) || IS_24XX(isp)) {
 		optr = ISP_READ(isp, isp->isp_respoutrp);
 		/*
 		 * Debug: to be taken out eventually
 		 */
 		if (isp->isp_residx != optr) {
-			isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x",
+			isp_prt(isp, ISP_LOGINFO,
+			    "isp_intr: hard optr=%x, soft optr %x",
 			    optr, isp->isp_residx);
+			isp->isp_residx = optr;
 		}
 	} else {
 		optr = isp->isp_residx;
@@ -3611,19 +4670,18 @@ again:
 	if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
 		i = 0;
 		do {
-			iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
-			junk = READ_RESPONSE_QUEUE_IN_POINTER(isp);
+			iptr = ISP_READ(isp, isp->isp_respinrp);
+			junk = ISP_READ(isp, isp->isp_respinrp);
 		} while (junk != iptr && ++i < 1000);
 
 		if (iptr != junk) {
-			ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
 			isp_prt(isp, ISP_LOGWARN,
 			    "Response Queue Out Pointer Unstable (%x, %x)",
 			    iptr, junk);
-			return;
+			goto out;
 		}
 	} else {
-		iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
+		iptr = ISP_READ(isp, isp->isp_respinrp);
 	}
 	isp->isp_resodx = iptr;
 
@@ -3637,15 +4695,17 @@ again:
 		 * make sure the old interrupt went away (to avoid 'ringing'
 		 * effects), but that didn't stop this from occurring.
 		 */
-		if (IS_23XX(isp)) {
+		if (IS_24XX(isp)) {
+			junk = 0;
+		} else if (IS_23XX(isp)) {
 			USEC_DELAY(100);
-			iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
+			iptr = ISP_READ(isp, isp->isp_respinrp);
 			junk = ISP_READ(isp, BIU_R2HSTSLO);
 		} else {
 			junk = ISP_READ(isp, BIU_ISR);
 		}
 		if (optr == iptr) {
-			if (IS_23XX(isp)) {
+			if (IS_23XX(isp) || IS_24XX(isp)) {
 				;
 			} else {
 				sema = ISP_READ(isp, BIU_SEMA);
@@ -3661,42 +4721,75 @@ again:
 		}
 	}
 	isp->isp_resodx = iptr;
-	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
-	ISP_WRITE(isp, BIU_SEMA, 0);
+
 
 	if (isp->isp_rspbsy) {
-		return;
+		goto out;
 	}
 	isp->isp_rspbsy = 1;
-
 	while (optr != iptr) {
-		ispstatusreq_t local, *sp = &local;
+		u_int8_t qe[QENTRY_LEN];
+		ispstatusreq_t *sp = (ispstatusreq_t *) qe;
 		isphdr_t *hp;
-		int type;
+		int buddaboom, etype, scsi_status, completion_status;
+		int req_status_flags, req_state_flags;
+		u_int8_t *snsp, *resp;
+		u_int32_t rlen, slen;
+		long resid;
 		u_int16_t oop;
-		int buddaboom = 0;
 
 		hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
 		oop = optr;
 		optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
 		nlooked++;
+ read_again:
+		buddaboom = req_status_flags = req_state_flags = 0;
+		resid = 0L;
+
 		/*
 		 * Synchronize our view of this response queue entry.
 		 */
 		MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
-
-		type = isp_get_response_type(isp, hp);
-
-		if (type == RQSTYPE_RESPONSE) {
+		isp_get_hdr(isp, hp, &sp->req_header);
+		etype = sp->req_header.rqs_entry_type;
+
+		if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
+			isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
+			isp_get_24xx_response(isp,
+			    (isp24xx_statusreq_t *)hp, sp2);
+			if (isp->isp_dblev & ISP_LOGDEBUG1) {
+				isp_print_bytes(isp,
+				    "Response Queue Entry", QENTRY_LEN, sp2);
+			}
+			scsi_status = sp2->req_scsi_status;
+			completion_status = sp2->req_completion_status;
+			req_state_flags = 0;
+			resid = sp2->req_resid;
+		} else if (etype == RQSTYPE_RESPONSE) {
 			isp_get_response(isp, (ispstatusreq_t *) hp, sp);
-		} else if (type == RQSTYPE_RIO2) {
-			isp_rio2_t rio;
-			isp_get_rio2(isp, (isp_rio2_t *) hp, &rio);
-			for (i = 0; i < rio.req_header.rqs_seqno; i++) {
-				isp_fastpost_complete(isp, rio.req_handles[i]);
+			if (isp->isp_dblev & ISP_LOGDEBUG1) {
+				isp_print_bytes(isp,
+				    "Response Queue Entry", QENTRY_LEN, sp);
+			}
+			scsi_status = sp->req_scsi_status;
+			completion_status = sp->req_completion_status;
+			req_status_flags = sp->req_status_flags;
+			req_state_flags = sp->req_state_flags;
+			resid = sp->req_resid;
+		} else if (etype == RQSTYPE_RIO2) {
+			isp_rio2_t *rio = (isp_rio2_t *)qe;
+			isp_get_rio2(isp, (isp_rio2_t *) hp, rio);
+			if (isp->isp_dblev & ISP_LOGDEBUG1) {
+				isp_print_bytes(isp,
+				    "Response Queue Entry", QENTRY_LEN, rio);
+			}
+			for (i = 0; i < rio->req_header.rqs_seqno; i++) {
+				isp_fastpost_complete(isp, rio->req_handles[i]);
+			}
+			if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
+				isp->isp_fpcchiwater =
+				    rio->req_header.rqs_seqno;
 			}
-			if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno)
-				isp->isp_fpcchiwater = rio.req_header.rqs_seqno;
 			MEMZERO(hp, QENTRY_LEN);	/* PERF */
 			continue;
 		} else {
@@ -3705,7 +4798,12 @@ again:
 			 * may have updated the response queue pointers for
 			 * us, so we reload our goal index.
 			 */
-			if (isp_handle_other_response(isp, type, hp, &optr)) {
+			int r;
+			r = isp_handle_other_response(isp, etype, hp, &optr);
+			if (r < 0) {
+				goto read_again;
+			}
+			if (r > 0) {
 				iptr = isp->isp_resodx;
 				MEMZERO(hp, QENTRY_LEN);	/* PERF */
 				continue;
@@ -3716,34 +4814,33 @@ again:
 			 * we don't know how to deal with the rest of the
 			 * response.
 			 */
-			isp_get_response(isp, (ispstatusreq_t *) hp, sp);
 
 			/*
 			 * It really has to be a bounced request just copied
 			 * from the request queue to the response queue. If
 			 * not, something bad has happened.
 			 */
-			if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
+			if (etype != RQSTYPE_REQUEST) {
 				isp_prt(isp, ISP_LOGERR, notresp,
-				    sp->req_header.rqs_entry_type, oop, optr,
-				    nlooked);
-				if (isp->isp_dblev & ISP_LOGDEBUG0) {
-					isp_print_bytes(isp, "Queue Entry",
-					    QENTRY_LEN, sp);
-				}
+				    etype, oop, optr, nlooked);
+				isp_print_bytes(isp,
+				    "Request Queue Entry", QENTRY_LEN, sp);
 				MEMZERO(hp, QENTRY_LEN);	/* PERF */
 				continue;
 			}
 			buddaboom = 1;
+			scsi_status = sp->req_scsi_status;
+			completion_status = sp->req_completion_status;
+			req_status_flags = sp->req_status_flags;
+			req_state_flags = sp->req_state_flags;
+			resid = sp->req_resid;
 		}
 
-		if (sp->req_header.rqs_flags & 0xf) {
-#define	_RQS_OFLAGS	\
-	~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
+		if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
 			if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
 				isp_prt(isp, ISP_LOGWARN,
 				    "continuation segment");
-				WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
+				ISP_WRITE(isp, isp->isp_respoutrp, optr);
 				continue;
 			}
 			if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
@@ -3754,53 +4851,47 @@ again:
 				 */
 			}
 			if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
-				isp_prt(isp, ISP_LOGERR,  "bad header flag");
+				isp_print_bytes(isp, "bad header flag",
+				    QENTRY_LEN, sp);
 				buddaboom++;
 			}
 			if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
-				isp_prt(isp, ISP_LOGERR, "bad request packet");
+				isp_print_bytes(isp, "bad request packet",
+				    QENTRY_LEN, sp);
 				buddaboom++;
 			}
-			if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
-				isp_prt(isp, ISP_LOGERR,
-				    "unknown flags (0x%x) in response",
-				    sp->req_header.rqs_flags);
-				buddaboom++;
-			}
-#undef	_RQS_OFLAGS
 		}
+
 		if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
-			MEMZERO(hp, QENTRY_LEN);	/* PERF */
 			isp_prt(isp, ISP_LOGERR,
-			    "bad request handle %d (type 0x%x, flags 0x%x)",
-			    sp->req_handle, sp->req_header.rqs_entry_type,
-			    sp->req_header.rqs_flags);
-			WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
+			    "bad request handle %d (type 0x%x)",
+			    sp->req_handle, etype);
+			MEMZERO(hp, QENTRY_LEN);	/* PERF */
+			ISP_WRITE(isp, isp->isp_respoutrp, optr);
 			continue;
 		}
 		xs = isp_find_xs(isp, sp->req_handle);
 		if (xs == NULL) {
-			u_int8_t ts = sp->req_completion_status & 0xff;
-			MEMZERO(hp, QENTRY_LEN);	/* PERF */
+			u_int8_t ts = completion_status & 0xff;
 			/*
 			 * Only whine if this isn't the expected fallout of
 			 * aborting the command.
 			 */
-			if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
+			if (etype != RQSTYPE_RESPONSE) {
 				isp_prt(isp, ISP_LOGERR,
 				    "cannot find handle 0x%x (type 0x%x)",
-				    sp->req_handle,
-				    sp->req_header.rqs_entry_type);
+				    sp->req_handle, etype);
 			} else if (ts != RQCS_ABORTED) {
 				isp_prt(isp, ISP_LOGERR,
 				    "cannot find handle 0x%x (status 0x%x)",
 				    sp->req_handle, ts);
 			}
-			WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
+			MEMZERO(hp, QENTRY_LEN);	/* PERF */
+			ISP_WRITE(isp, isp->isp_respoutrp, optr);
 			continue;
 		}
 		isp_destroy_handle(isp, sp->req_handle);
-		if (sp->req_status_flags & RQSTF_BUS_RESET) {
+		if (req_status_flags & RQSTF_BUS_RESET) {
 			XS_SETERR(xs, HBA_BUSRESET);
 			isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
 		}
@@ -3808,39 +4899,71 @@ again:
 			XS_SETERR(xs, HBA_BOTCH);
 		}
 
-		if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
+		resp = NULL;
+		rlen = 0;
+		snsp = NULL;
+		slen = 0;
+		if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
+			resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
+			rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
+		} else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
+			resp = sp->req_response;
+			rlen = sp->req_response_len;
+		}
+		if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
 			/*
 			 * Fibre Channel F/W doesn't say we got status
 			 * if there's Sense Data instead. I guess they
 			 * think it goes w/o saying.
 			 */
-			sp->req_state_flags |= RQSF_GOT_STATUS;
+			req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
+			if (IS_24XX(isp)) {
+				snsp =
+				    ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
+				snsp += rlen;
+				slen =
+				    ((isp24xx_statusreq_t *)sp)->req_sense_len;
+			} else {
+				snsp = sp->req_sense_data;
+				slen = sp->req_sense_len;
+			}
+		} else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
+			snsp = sp->req_sense_data;
+			slen = sp->req_sense_len;
 		}
-		if (sp->req_state_flags & RQSF_GOT_STATUS) {
-			*XS_STSP(xs) = sp->req_scsi_status & 0xff;
+		if (req_state_flags & RQSF_GOT_STATUS) {
+			*XS_STSP(xs) = scsi_status & 0xff;
 		}
 
-		switch (sp->req_header.rqs_entry_type) {
+		switch (etype) {
 		case RQSTYPE_RESPONSE:
 			XS_SET_STATE_STAT(isp, xs, sp);
-			isp_parse_status(isp, sp, xs);
+			if (resp && rlen >= 4 &&
+			    resp[FCP_RSPNS_CODE_OFFSET] != 0) {
+				isp_prt(isp, ISP_LOGWARN,
+				    "%d.%d.%d FCP RESPONSE: 0x%x",
+				    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
+				    resp[FCP_RSPNS_CODE_OFFSET]);
+				XS_SETERR(xs, HBA_BOTCH);
+			}
+			if (IS_24XX(isp)) {
+				isp_parse_status_24xx(isp,
+				    (isp24xx_statusreq_t *)sp, xs, &resid);
+			} else {
+				isp_parse_status(isp, (void *)sp, xs, &resid);
+			}
 			if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
 			    (*XS_STSP(xs) == SCSI_BUSY)) {
 				XS_SETERR(xs, HBA_TGTBSY);
 			}
 			if (IS_SCSI(isp)) {
-				XS_RESID(xs) = sp->req_resid;
-				if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
-				    (*XS_STSP(xs) == SCSI_CHECK) &&
-				    (sp->req_state_flags & RQSF_GOT_SENSE)) {
-					XS_SAVE_SENSE(xs, sp);
-				}
+				XS_RESID(xs) = resid;
 				/*
 				 * A new synchronous rate was negotiated for
 				 * this target. Mark state such that we'll go
 				 * look up that which has changed later.
 				 */
-				if (sp->req_status_flags & RQSTF_NEGOTIATION) {
+				if (req_status_flags & RQSTF_NEGOTIATION) {
 					int t = XS_TGT(xs);
 					sdparam *sdp = isp->isp_param;
 					sdp += XS_CHANNEL(xs);
@@ -3849,26 +4972,26 @@ again:
 					    (1 << XS_CHANNEL(xs));
 				}
 			} else {
-				if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
+				if (req_status_flags & RQSF_XFER_COMPLETE) {
 					XS_RESID(xs) = 0;
-				} else if (sp->req_scsi_status & RQCS_RESID) {
-					XS_RESID(xs) = sp->req_resid;
+				} else if (scsi_status & RQCS_RESID) {
+					XS_RESID(xs) = resid;
 				} else {
 					XS_RESID(xs) = 0;
 				}
-				if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
-				    (*XS_STSP(xs) == SCSI_CHECK) &&
-				    (sp->req_scsi_status & RQCS_SV)) {
-					XS_SAVE_SENSE(xs, sp);
-					/* solely for the benefit of debug */
-					sp->req_state_flags |= RQSF_GOT_SENSE;
-				}
+			}
+			if (snsp && slen) {
+				XS_SAVE_SENSE(xs, snsp, slen);
 			}
 			isp_prt(isp, ISP_LOGDEBUG2,
-			   "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
-			   (long) sp->req_resid);
+			   "asked for %ld got raw resid %ld settled for %ld",
+			    (long) XS_XFRLEN(xs), resid, (long) XS_RESID(xs));
 			break;
 		case RQSTYPE_REQUEST:
+		case RQSTYPE_A64:
+		case RQSTYPE_T2RQS:
+		case RQSTYPE_T3RQS:
+		case RQSTYPE_T7RQS:
 			if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
 				/*
 				 * Force Queue Full status.
@@ -3879,16 +5002,19 @@ again:
 				/*
 				 * ????
 				 */
+				XS_SETERR(xs, HBA_BOTCH);
 				isp_prt(isp, ISP_LOGDEBUG0,
 				    "Request Queue Entry bounced back");
-				XS_SETERR(xs, HBA_BOTCH);
+				if ((isp->isp_dblev & ISP_LOGDEBUG1) == 0) {
+					isp_print_bytes(isp, "Bounced Request",
+					    QENTRY_LEN, qe);
+				}
 			}
 			XS_RESID(xs) = XS_XFRLEN(xs);
 			break;
 		default:
-			isp_prt(isp, ISP_LOGWARN,
-			    "unhandled response queue type 0x%x",
-			    sp->req_header.rqs_entry_type);
+			isp_print_bytes(isp, "Unhandled Response Type",
+			    QENTRY_LEN, qe);
 			if (XS_NOERR(xs)) {
 				XS_SETERR(xs, HBA_BOTCH);
 			}
@@ -3896,17 +5022,18 @@ again:
 		}
 
 		/*
-		 * Free any dma resources. As a side effect, this may
-		 * also do any cache flushing necessary for data coherence.			 */
+		 * Free any DMA resources. As a side effect, this may
+		 * also do any cache flushing necessary for data coherence.
+		 */
 		if (XS_XFRLEN(xs)) {
 			ISP_DMAFREE(isp, xs, sp->req_handle);
 		}
 
 		if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
-		    ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
+		    ((isp->isp_dblev & ISP_LOGDEBUG0) && ((!XS_NOERR(xs)) ||
 		    (*XS_STSP(xs) != SCSI_GOOD)))) {
 			char skey;
-			if (sp->req_state_flags & RQSF_GOT_SENSE) {
+			if (req_state_flags & RQSF_GOT_SENSE) {
 				skey = XS_SNSKEY(xs) & 0xf;
 				if (skey < 10)
 					skey += '0';
@@ -3918,8 +5045,7 @@ again:
 				skey = '.';
 			}
 			isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
-			    XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs),
-			    (ulong)XS_RESID(xs),
+			    XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
 			    *XS_STSP(xs), skey, XS_ERR(xs));
 		}
 
@@ -3938,13 +5064,23 @@ again:
 	 * ISP's notion of what we've seen so far.
 	 */
 	if (nlooked) {
-		WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
+		ISP_WRITE(isp, isp->isp_respoutrp, optr);
 		/*
-		 * While we're at it, read the request queue out pointer.
+		 * While we're at it, read the requst queue out pointer.
 		 */
-		isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
-		if (isp->isp_rscchiwater < ndone)
+		isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
+		if (isp->isp_rscchiwater < ndone) {
 			isp->isp_rscchiwater = ndone;
+		}
+	}
+
+out:
+
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
+		ISP_WRITE(isp, BIU_SEMA, 0);
 	}
 
 	isp->isp_residx = optr;
@@ -3962,7 +5098,7 @@ again:
  * Support routines.
  */
 
-static int
+int
 isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 {
 	int rval = 0;
@@ -3979,26 +5115,32 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 	case ASYNC_BUS_RESET:
 		isp->isp_sendmarker |= (1 << bus);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		isp_async(isp, ISPASYNC_BUS_RESET, &bus);
 		break;
 	case ASYNC_SYSTEM_ERROR:
-#ifdef	ISP_FW_CRASH_DUMP
+		isp->isp_state = ISP_CRASHED;
+		if (IS_FC(isp)) {
+			FCPARAM(isp)->isp_loopstate = LOOP_NIL;
+			FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
+		}
 		/*
-		 * If we have crash dumps enabled, it's up to the handler
-		 * for isp_async to reinit stuff and restart the firmware
-		 * after performing the crash dump. The reason we do things
-		 * this way is that we may need to activate a kernel thread
-		 * to do all the crash dump goop.
+		 * Were we waiting for a mailbox command to complete?
+		 * If so, it's dead, so wake up the waiter.
+		 */
+		if (isp->isp_mboxbsy) {
+			isp->isp_obits = 1;
+			isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
+			MBOX_NOTIFY_COMPLETE(isp);
+		}
+		/*
+		 * It's up to the handler for isp_async to reinit stuff and
+		 * restart the firmware
 		 */
 		isp_async(isp, ISPASYNC_FW_CRASH, NULL);
-#else
-		isp_async(isp, ISPASYNC_FW_CRASH, NULL);
-		isp_reinit(isp);
-		isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
-#endif
 		rval = -1;
 		break;
 
@@ -4016,7 +5158,7 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		 * We don't need to be chatty about this- just unlatch things
 		 * and move on.
 		 */
-		mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp);
+		mbox = ISP_READ(isp, isp->isp_rqstoutrp);
 		break;
 
 	case ASYNC_TIMEOUT_RESET:
@@ -4024,8 +5166,9 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		    "timeout initiated SCSI bus reset of bus %d", bus);
 		isp->isp_sendmarker |= (1 << bus);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		break;
 
@@ -4033,8 +5176,9 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
 		isp->isp_sendmarker |= (1 << bus);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		break;
 
@@ -4125,29 +5269,33 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		int handle =
 		    (ISP_READ(isp, OUTMAILBOX2) << 16) | 
 		    (ISP_READ(isp, OUTMAILBOX1));
-		if (isp_target_async(isp, handle, mbox))
+		if (isp_target_async(isp, handle, mbox)) {
 			rval = -1;
+		} else {
+			/* count it as a fast posting intr */
+			isp->isp_fphccmplt++;
+		}
 #else
 		isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
-#endif
 		isp->isp_fphccmplt++;	/* count it as a fast posting intr */
+#endif
 		break;
 	}
+	case ASYNC_LIP_ERROR:
 	case ASYNC_LIP_F8:
 	case ASYNC_LIP_OCCURRED:
-		FCPARAM(isp)->isp_lipseq =
-		    ISP_READ(isp, OUTMAILBOX1);
 		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
 		FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
 		isp->isp_sendmarker = 1;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_LIP, NULL);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		/*
-		 * We've had problems with data corruption occurring on
+		 * We've had problems with data corruption occuring on
 		 * commands that complete (with no apparent error) after
 		 * we receive a LIP. This has been observed mostly on
 		 * Local Loop topologies. To be safe, let's just mark
@@ -4175,11 +5323,12 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		isp->isp_sendmarker = 1;
 		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
 		FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_LOOP_UP, NULL);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		break;
 
@@ -4187,11 +5336,12 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		isp->isp_sendmarker = 1;
 		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
 		FCPARAM(isp)->isp_loopstate = LOOP_NIL;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		break;
 
@@ -4199,50 +5349,49 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		isp->isp_sendmarker = 1;
 		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
 		FCPARAM(isp)->isp_loopstate = LOOP_NIL;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		break;
 
 	case ASYNC_PDB_CHANGED:
 		isp->isp_sendmarker = 1;
 		FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
 		break;
 
 	case ASYNC_CHANGE_NOTIFY:
-		/*
-		 * Not correct, but it will force us to rescan the loop.
-		 */
-		FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
-		isp_mark_getpdb_all(isp);
+	    	if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
+			FCPARAM(isp)->isp_loopstate = LOOP_LSCAN_DONE;
+		} else {
+			FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
+		}
+		ISP_MARK_PORTDB(isp, 1);
 		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
 		break;
 
 	case ASYNC_PTPMODE:
-		if (FCPARAM(isp)->isp_onfabric)
-			FCPARAM(isp)->isp_topo = TOPO_F_PORT;
-		else
-			FCPARAM(isp)->isp_topo = TOPO_N_PORT;
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		isp->isp_sendmarker = 1;
 		FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
 		FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
 		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
 #ifdef	ISP_TARGET_MODE
-		if (isp_target_async(isp, bus, mbox))
+		if (isp_target_async(isp, bus, mbox)) {
 			rval = -1;
+		}
 #endif
 		isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
 		break;
 
 	case ASYNC_CONNMODE:
 		mbox = ISP_READ(isp, OUTMAILBOX1);
-		isp_mark_getpdb_all(isp);
+		ISP_MARK_PORTDB(isp, 1);
 		switch (mbox) {
 		case ISP_CONN_LOOP:
 			isp_prt(isp, ISP_LOGINFO,
@@ -4258,13 +5407,7 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 			break;
 		case ISP_CONN_FATAL:
 			isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
-#ifdef	ISP_FW_CRASH_DUMP
 			isp_async(isp, ISPASYNC_FW_CRASH, NULL);
-#else
-			isp_async(isp, ISPASYNC_FW_CRASH, NULL);
-			isp_reinit(isp);
-			isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
-#endif
 			return (-1);
 		case ISP_CONN_LOOPBACK:
 			isp_prt(isp, ISP_LOGWARN,
@@ -4281,6 +5424,15 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 		FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
 		break;
 
+	case ASYNC_RJT_SENT:	/* same as ASYNC_QFULL_SENT */
+		if (IS_24XX(isp)) {
+			isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
+			break;
+		} else if (IS_2200(isp)) {
+			isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
+			break;
+		}
+		/* FALLTHROUGH */
 	default:
 		isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
 		break;
@@ -4288,9 +5440,9 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 
 	if (bus & 0x100) {
 		int i, nh;
-		u_int16_t handles[5];
+		u_int16_t handles[16];
 
-		for (nh = 0, i = 1; i < MAX_MAILBOX; i++) {
+		for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) {
 			if ((bus & (1 << i)) == 0) {
 				continue;
 			}
@@ -4301,8 +5453,9 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 			isp_prt(isp,  ISP_LOGDEBUG3,
 			    "fast post completion of %u", handles[i]);
 		}
-		if (isp->isp_fpcchiwater < nh)
+		if (isp->isp_fpcchiwater < nh) {
 			isp->isp_fpcchiwater = nh;
+		}
 	} else {
 		isp->isp_intoasync++;
 	}
@@ -4315,13 +5468,16 @@ isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
  * this is not used currently.
  */
 
-static int
+int
 isp_handle_other_response(struct ispsoftc *isp, int type,
-    isphdr_t *hp, u_int16_t *optrp)
+    isphdr_t *hp, u_int32_t *optrp)
 {
 	switch (type) {
 	case RQSTYPE_STATUS_CONT:
-		isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response");
+		isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
+		return (1);
+	case RQSTYPE_MARKER:
+		isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
 		return (1);
 	case RQSTYPE_ATIO:
 	case RQSTYPE_CTIO:
@@ -4333,6 +5489,9 @@ isp_handle_other_response(struct ispsoftc *isp, int type,
 	case RQSTYPE_ATIO2:
 	case RQSTYPE_CTIO2:
 	case RQSTYPE_CTIO3:
+	case RQSTYPE_CTIO7:
+	case RQSTYPE_ABTS_RCVD:
+	case RQSTYPE_ABTS_RSP:
 		isp->isp_rsltccmplt++;	/* count as a response completion */
 #ifdef	ISP_TARGET_MODE
 		if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
@@ -4342,17 +5501,31 @@ isp_handle_other_response(struct ispsoftc *isp, int type,
 		/* FALLTHROUGH */
 	case RQSTYPE_REQUEST:
 	default:
-		if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
-			return (1);
+		USEC_DELAY(100);
+		if (type != isp_get_response_type(isp, hp)) {
+			/*
+			 * This is questionable- we're just papering over
+			 * something we've seen on SMP linux in target
+			 * mode- we don't really know what's happening
+			 * here that causes us to think we've gotten
+			 * an entry, but that either the entry isn't
+			 * filled out yet or our CPU read data is stale.
+			 */
+			isp_prt(isp, ISP_LOGINFO,
+				"unstable type in response queue");
+			return (-1);
 		}
 		isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
 		    isp_get_response_type(isp, hp));
+		if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
+			return (1);
+		}
 		return (0);
 	}
 }
 
-static void
-isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
+void
+isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs, long *rp)
 {
 	switch (sp->req_completion_status & 0xff) {
 	case RQCS_COMPLETE:
@@ -4368,6 +5541,7 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 			    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 			if (XS_NOERR(xs)) {
 				XS_SETERR(xs, HBA_SELTIMEOUT);
+				*rp = XS_XFRLEN(xs);
 			}
 			return;
 		}
@@ -4380,6 +5554,7 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 	case RQCS_DMA_ERROR:
 		isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
 		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		*rp = XS_XFRLEN(xs);
 		break;
 
 	case RQCS_TRANSPORT_ERROR:
@@ -4435,6 +5610,7 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 		isp_prt(isp, ISP_LOGERR, "%s", buf);
 		isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
 		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
+		*rp = XS_XFRLEN(xs);
 		break;
 	}
 	case RQCS_RESET_OCCURRED:
@@ -4445,6 +5621,7 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 		if (XS_NOERR(xs)) {
 			XS_SETERR(xs, HBA_BUSRESET);
 		}
+		*rp = XS_XFRLEN(xs);
 		return;
 
 	case RQCS_ABORTED:
@@ -4460,15 +5637,8 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 		isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
 		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 		/*
-	 	 * Check to see if we logged out the device.
+	 	 * XXX: Check to see if we logged out of the device.
 		 */
-		if (IS_FC(isp)) {
-			if ((sp->req_completion_status & RQSTF_LOGOUT) &&
-			    FCPARAM(isp)->portdb[XS_TGT(xs)].valid &&
-			    FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) {
-				FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1;
-			}
-		}
 		if (XS_NOERR(xs)) {
 			XS_SETERR(xs, HBA_CMDTIMEOUT);
 		}
@@ -4675,40 +5845,214 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 		 * No such port on the loop. Moral equivalent of SELTIMEO
 		 */
 	case RQCS_PORT_LOGGED_OUT:
+	{
+		const char *reason;
+		u_int8_t sts = sp->req_completion_status & 0xff;
+
 		/*
 		 * It was there (maybe)- treat as a selection timeout.
 		 */
-		if ((sp->req_completion_status & 0xff) == RQCS_PORT_UNAVAILABLE)
-			isp_prt(isp, ISP_LOGINFO,
-			    "port unavailable for target %d", XS_TGT(xs));
-		else
-			isp_prt(isp, ISP_LOGINFO,
-			    "port logout for target %d", XS_TGT(xs));
+		if (sts == RQCS_PORT_UNAVAILABLE) {
+			reason = "unavailable";
+		} else {
+			reason = "logout";
+		}
+
+		isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
+		    reason, XS_TGT(xs));
+
 		/*
 		 * If we're on a local loop, force a LIP (which is overkill)
 		 * to force a re-login of this unit. If we're on fabric,
-		 * then we'll have to relogin as a matter of course.
+		 * then we'll have to log in again as a matter of course.
 		 */
 		if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
 		    FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
 			mbreg_t mbs;
 			MEMZERO(&mbs, sizeof (mbs));
 			mbs.param[0] = MBOX_INIT_LIP;
+			if (FCPARAM(isp)->isp_2klogin) {
+				mbs.ibits = (1 << 10);
+			}
+			mbs.logval = MBLOGALL;
 			isp_mboxcmd_qnw(isp, &mbs, 1);
 		}
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_SELTIMEOUT);
+		}
+		return;
+	}
+	case RQCS_PORT_CHANGED:
+		isp_prt(isp, ISP_LOGWARN,
+		    "port changed for target %d", XS_TGT(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_SELTIMEOUT);
+		}
+		return;
+
+	case RQCS_PORT_BUSY:
+		isp_prt(isp, ISP_LOGWARN,
+		    "port busy for target %d", XS_TGT(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_TGTBSY);
+		}
+		return;
+
+	default:
+		isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
+		    sp->req_completion_status);
+		break;
+	}
+	if (XS_NOERR(xs)) {
+		XS_SETERR(xs, HBA_BOTCH);
+	}
+}
+
+void
+isp_parse_status_24xx(struct ispsoftc *isp, isp24xx_statusreq_t *sp,
+    XS_T *xs, long *rp)
+{
+	int ru_marked, sv_marked;
+	switch (sp->req_completion_status) {
+	case RQCS_COMPLETE:
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_NOERROR);
+		}
+		return;
+
+	case RQCS_DMA_ERROR:
+		isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		break;
 
+	case RQCS_TRANSPORT_ERROR:
+		isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		break;
+
+	case RQCS_RESET_OCCURRED:
+		isp_prt(isp, ISP_LOGWARN,
+		    "bus reset destroyed command for %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_BUSRESET);
+		}
+		return;
+
+	case RQCS_ABORTED:
+		isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_ABORTED);
+		}
+		return;
+
+	case RQCS_TIMEOUT:
+		isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_CMDTIMEOUT);
+		}
+		return;
+
+	case RQCS_DATA_OVERRUN:
+		XS_RESID(xs) = sp->req_resid;
+		isp_prt(isp, ISP_LOGERR,
+		    "data overrun for command on %d.%d.%d",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_DATAOVR);
+		}
+		return;
+
+	case RQCS_24XX_DRE:	/* data reassembly error */
+		isp_prt(isp, ISP_LOGERR, "data reassembly error for target %d",
+		    XS_TGT(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_ABORTED);
+		}
+		*rp = XS_XFRLEN(xs);
+		return;
+
+	case RQCS_24XX_TABORT:	/* aborted by target */
+		isp_prt(isp, ISP_LOGERR, "target %d sent ABTS",
+		    XS_TGT(xs));
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_ABORTED);
+		}
+		return;
+
+	case RQCS_DATA_UNDERRUN:
+		ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
 		/*
-		 * Probably overkill.
+		 * We can get an underrun w/o things being marked 
+		 * if we got a non-zero status.
 		 */
-		isp->isp_sendmarker = 1;
-		FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
-		isp_mark_getpdb_all(isp);
-		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
+		sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
+		if ((ru_marked == 0 && sv_marked == 0) ||
+		    (sp->req_resid > XS_XFRLEN(xs))) {
+			isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
+			    XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
+			    (ru_marked)? "marked" : "not marked");
+			if (XS_NOERR(xs)) {
+				XS_SETERR(xs, HBA_BOTCH);
+			}
+			return;
+		}
+		XS_RESID(xs) = sp->req_resid;
+		isp_prt(isp, ISP_LOGDEBUG0,
+		    "%d.%d.%d data underrun (%d) for command 0x%x",
+		    XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
+		    sp->req_resid, XS_CDBP(xs)[0] & 0xff);
 		if (XS_NOERR(xs)) {
-			XS_SETERR(xs, HBA_SELTIMEOUT);
+			XS_SETERR(xs, HBA_NOERROR);
 		}
 		return;
 
+	case RQCS_PORT_UNAVAILABLE:
+		/*
+		 * No such port on the loop. Moral equivalent of SELTIMEO
+		 */
+	case RQCS_PORT_LOGGED_OUT:
+	{
+		const char *reason;
+		u_int8_t sts = sp->req_completion_status & 0xff;
+
+		/*
+		 * It was there (maybe)- treat as a selection timeout.
+		 */
+		if (sts == RQCS_PORT_UNAVAILABLE) {
+			reason = "unavailable";
+		} else {
+			reason = "logout";
+		}
+
+		isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
+		    reason, XS_TGT(xs));
+
+		/*
+		 * If we're on a local loop, force a LIP (which is overkill)
+		 * to force a re-login of this unit. If we're on fabric,
+		 * then we'll have to log in again as a matter of course.
+		 */
+		if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
+		    FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
+			mbreg_t mbs;
+			MEMZERO(&mbs, sizeof (mbs));
+			mbs.param[0] = MBOX_INIT_LIP;
+			if (FCPARAM(isp)->isp_2klogin) {
+				mbs.ibits = (1 << 10);
+			}
+			mbs.logval = MBLOGALL;
+			isp_mboxcmd_qnw(isp, &mbs, 1);
+		}
+		if (XS_NOERR(xs)) {
+			XS_SETERR(xs, HBA_SELTIMEOUT);
+		}
+		return;
+	}
 	case RQCS_PORT_CHANGED:
 		isp_prt(isp, ISP_LOGWARN,
 		    "port changed for target %d", XS_TGT(xs));
@@ -4717,10 +6061,22 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 		}
 		return;
 
-	case RQCS_PORT_BUSY:
+
+	case RQCS_24XX_ENOMEM:	/* f/w resource unavailable */
 		isp_prt(isp, ISP_LOGWARN,
-		    "port busy for target %d", XS_TGT(xs));
+		    "f/w resource unavailable for target %d", XS_TGT(xs));
+		if (XS_NOERR(xs)) {
+			*XS_STSP(xs) = SCSI_BUSY;
+			XS_SETERR(xs, HBA_TGTBSY);
+		}
+		return;
+
+	case RQCS_24XX_TMO:	/* task management overrun */
+		isp_prt(isp, ISP_LOGWARN,
+		    "command for target %d overlapped task management",
+		    XS_TGT(xs));
 		if (XS_NOERR(xs)) {
+			*XS_STSP(xs) = SCSI_BUSY;
 			XS_SETERR(xs, HBA_TGTBSY);
 		}
 		return;
@@ -4735,7 +6091,7 @@ isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 	}
 }
 
-static void
+void
 isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph)
 {
 	XS_T *xs;
@@ -4745,7 +6101,7 @@ isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph)
 	}
 	xs = isp_find_xs(isp, fph);
 	if (xs == NULL) {
-		isp_prt(isp, ISP_LOGWARN,
+		isp_prt(isp, ISP_LOGDEBUG1,
 		    "Command for fast post handle 0x%x not found", fph);
 		return;
 	}
@@ -4768,15 +6124,17 @@ isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph)
 	isp_done(xs);
 }
 
-static int
+int
 isp_mbox_continue(struct ispsoftc *isp)
 {
 	mbreg_t mbs;
 	u_int16_t *ptr;
+	u_int32_t offset;
 
 	switch (isp->isp_lastmbxcmd) {
 	case MBOX_WRITE_RAM_WORD:
 	case MBOX_READ_RAM_WORD:
+	case MBOX_WRITE_RAM_WORD_EXTENDED:
 	case MBOX_READ_RAM_WORD_EXTENDED:
 		break;
 	default:
@@ -4787,12 +6145,15 @@ isp_mbox_continue(struct ispsoftc *isp)
 		return (-1);
 	}
 
-
 	/*
 	 * Clear the previous interrupt.
 	 */
-	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
-	ISP_WRITE(isp, BIU_SEMA, 0);
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
+		ISP_WRITE(isp, BIU_SEMA, 0);
+	}
 
 	/*
 	 * Continue with next word.
@@ -4801,27 +6162,46 @@ isp_mbox_continue(struct ispsoftc *isp)
 	ptr = isp->isp_mbxworkp;
 	switch (isp->isp_lastmbxcmd) {
 	case MBOX_WRITE_RAM_WORD:
-		mbs.param[2] = *ptr++;
-		mbs.param[1] = isp->isp_mbxwrk1++;
+		mbs.param[1] = isp->isp_mbxwrk1++;;
+		mbs.param[2] = *ptr++;;
 		break;
 	case MBOX_READ_RAM_WORD:
-	case MBOX_READ_RAM_WORD_EXTENDED:
 		*ptr++ = isp->isp_mboxtmp[2];
 		mbs.param[1] = isp->isp_mbxwrk1++;
 		break;
+	case MBOX_WRITE_RAM_WORD_EXTENDED:
+		offset = isp->isp_mbxwrk1;
+		offset |= isp->isp_mbxwrk8 << 16;
+
+		mbs.param[2] = *ptr++;;
+		mbs.param[1] = offset;
+		mbs.param[8] = offset >> 16;
+		isp->isp_mbxwrk1 = ++offset;
+		isp->isp_mbxwrk8 = offset >> 16;
+		break;
+	case MBOX_READ_RAM_WORD_EXTENDED:
+		offset = isp->isp_mbxwrk1;
+		offset |= isp->isp_mbxwrk8 << 16;
+
+		*ptr++ = isp->isp_mboxtmp[2];
+		mbs.param[1] = offset;
+		mbs.param[8] = offset >> 16;
+		isp->isp_mbxwrk1 = ++offset;
+		isp->isp_mbxwrk8 = offset >> 16;
+		break;
 	}
 	isp->isp_mbxworkp = ptr;
+	isp->isp_mbxwrk0--;
 	mbs.param[0] = isp->isp_lastmbxcmd;
-	isp->isp_mbxwrk0 -= 1;
+	mbs.logval = MBLOGALL;
 	isp_mboxcmd_qnw(isp, &mbs, 0);
 	return (0);
 }
 
-
-#define	HIBYT(x)			((x) >> 0x8)
-#define	LOBYT(x)			((x)  & 0xff)
-#define	ISPOPMAP(a, b)			(((a) << 8) | (b))
-static const u_int16_t mbpscsi[] = {
+#define	HIWRD(x)			((x) >> 16)
+#define	LOWRD(x)			((x)  & 0xffff)
+#define	ISPOPMAP(a, b)			(((a) << 16) | (b))
+static const u_int32_t mbpscsi[] = {
 	ISPOPMAP(0x01, 0x01),	/* 0x00: MBOX_NO_OP */
 	ISPOPMAP(0x1f, 0x01),	/* 0x01: MBOX_LOAD_RAM */
 	ISPOPMAP(0x03, 0x01),	/* 0x02: MBOX_EXEC_FIRMWARE */
@@ -4829,7 +6209,7 @@ static const u_int16_t mbpscsi[] = {
 	ISPOPMAP(0x07, 0x07),	/* 0x04: MBOX_WRITE_RAM_WORD */
 	ISPOPMAP(0x03, 0x07),	/* 0x05: MBOX_READ_RAM_WORD */
 	ISPOPMAP(0x3f, 0x3f),	/* 0x06: MBOX_MAILBOX_REG_TEST */
-	ISPOPMAP(0x03, 0x07),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
+	ISPOPMAP(0x07, 0x07),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
 	ISPOPMAP(0x01, 0x0f),	/* 0x08: MBOX_ABOUT_FIRMWARE */
 	ISPOPMAP(0x00, 0x00),	/* 0x09: */
 	ISPOPMAP(0x00, 0x00),	/* 0x0a: */
@@ -4906,7 +6286,7 @@ static const u_int16_t mbpscsi[] = {
 	ISPOPMAP(0xdf, 0xdf),	/* 0x51: DUMP RAM A64 */
 	ISPOPMAP(0xdf, 0xff),	/* 0x52: INITIALIZE REQUEST QUEUE A64 */
 	ISPOPMAP(0xef, 0xff),	/* 0x53: INITIALIZE RESPONSE QUEUE A64 */
-	ISPOPMAP(0xcf, 0x01),	/* 0x54: EXECUTE IOCB A64 */
+	ISPOPMAP(0xcf, 0x01),	/* 0x54: EXECUCUTE COMMAND IOCB A64 */
 	ISPOPMAP(0x07, 0x01),	/* 0x55: ENABLE TARGET MODE */
 	ISPOPMAP(0x03, 0x0f),	/* 0x56: GET TARGET STATUS */
 	ISPOPMAP(0x00, 0x00),	/* 0x57: */
@@ -4922,8 +6302,8 @@ static const u_int16_t mbpscsi[] = {
 #define ISP_STRIPPED
 #endif
 
-#ifndef	ISP_STRIPPED
-static char *scsi_mbcmd_names[] = {
+#ifndef		ISP_STRIPPED
+static const char *scsi_mbcmd_names[] = {
 	"NO-OP",
 	"LOAD RAM",
 	"EXEC FIRMWARE",
@@ -5021,23 +6401,23 @@ static char *scsi_mbcmd_names[] = {
 };
 #endif
 
-static const u_int16_t mbpfc[] = {
+static const u_int32_t mbpfc[] = {
 	ISPOPMAP(0x01, 0x01),	/* 0x00: MBOX_NO_OP */
 	ISPOPMAP(0x1f, 0x01),	/* 0x01: MBOX_LOAD_RAM */
-	ISPOPMAP(0x03, 0x01),	/* 0x02: MBOX_EXEC_FIRMWARE */
+	ISPOPMAP(0x0f, 0x01),	/* 0x02: MBOX_EXEC_FIRMWARE */
 	ISPOPMAP(0xdf, 0x01),	/* 0x03: MBOX_DUMP_RAM */
 	ISPOPMAP(0x07, 0x07),	/* 0x04: MBOX_WRITE_RAM_WORD */
 	ISPOPMAP(0x03, 0x07),	/* 0x05: MBOX_READ_RAM_WORD */
 	ISPOPMAP(0xff, 0xff),	/* 0x06: MBOX_MAILBOX_REG_TEST */
-	ISPOPMAP(0x03, 0x05),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
+	ISPOPMAP(0x03, 0x07),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
 	ISPOPMAP(0x01, 0x4f),	/* 0x08: MBOX_ABOUT_FIRMWARE */
-	ISPOPMAP(0xdf, 0x01),	/* 0x09: LOAD RAM */
+	ISPOPMAP(0xdf, 0x01),	/* 0x09: MBOX_LOAD_RISC_RAM_2100 */
 	ISPOPMAP(0xdf, 0x01),	/* 0x0a: DUMP RAM */
-	ISPOPMAP(0x00, 0x00),	/* 0x0b: */
+	ISPOPMAP(0x1ff, 0x01),	/* 0x0b: MBOX_LOAD_RISC_RAM */
 	ISPOPMAP(0x00, 0x00),	/* 0x0c: */
-	ISPOPMAP(0x00, 0x00),	/* 0x0d: */
+	ISPOPMAP(0x10f, 0x01),	/* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
 	ISPOPMAP(0x01, 0x05),	/* 0x0e: MBOX_CHECK_FIRMWARE */
-	ISPOPMAP(0x03, 0x07),	/* 0x0f: MBOX_READ_RAM_WORD_EXTENDED(1) */
+	ISPOPMAP(0x10f, 0x05),	/* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
 	ISPOPMAP(0x1f, 0x11),	/* 0x10: MBOX_INIT_REQ_QUEUE */
 	ISPOPMAP(0x2f, 0x21),	/* 0x11: MBOX_INIT_RES_QUEUE */
 	ISPOPMAP(0x0f, 0x01),	/* 0x12: MBOX_EXECUTE_IOCB */
@@ -5088,8 +6468,8 @@ static const u_int16_t mbpfc[] = {
 	ISPOPMAP(0x00, 0x00),	/* 0x3f: */
 	ISPOPMAP(0x03, 0x01),	/* 0x40: MBOX_LOOP_PORT_BYPASS */
 	ISPOPMAP(0x03, 0x01),	/* 0x41: MBOX_LOOP_PORT_ENABLE */
-	ISPOPMAP(0x03, 0x07),	/* 0x42: MBOX_GET_RESOURCE_COUNTS */
-	ISPOPMAP(0x01, 0x01),	/* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */
+	ISPOPMAP(0x03, 0x07),	/* 0x42: MBOX_GET_RESOURCE_COUNT */
+	ISPOPMAP(0x01, 0x01),	/* 0x43: MBOX_REQUEST_OFFLINE_MODE */
 	ISPOPMAP(0x00, 0x00),	/* 0x44: */
 	ISPOPMAP(0x00, 0x00),	/* 0x45: */
 	ISPOPMAP(0x00, 0x00),	/* 0x46: */
@@ -5118,7 +6498,7 @@ static const u_int16_t mbpfc[] = {
 	ISPOPMAP(0x07, 0x03),	/* 0x5d: MBOX_GET_SET_DATA_RATE */
 	ISPOPMAP(0x00, 0x00),	/* 0x5e: */
 	ISPOPMAP(0x00, 0x00),	/* 0x5f: */
-	ISPOPMAP(0xfd, 0x31),	/* 0x60: MBOX_INIT_FIRMWARE */
+	ISPOPMAP(0xcd, 0x01),	/* 0x60: MBOX_INIT_FIRMWARE */
 	ISPOPMAP(0x00, 0x00),	/* 0x61: */
 	ISPOPMAP(0x01, 0x01),	/* 0x62: MBOX_INIT_LIP */
 	ISPOPMAP(0xcd, 0x03),	/* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
@@ -5148,18 +6528,19 @@ static const u_int16_t mbpfc[] = {
 	ISPOPMAP(0x00, 0x00),	/* 0x7b: */
 	ISPOPMAP(0x4f, 0x03),	/* 0x7c: Get ID List */
 	ISPOPMAP(0xcf, 0x01),	/* 0x7d: SEND LFA */
-	ISPOPMAP(0x07, 0x01)	/* 0x7e: Lun RESET */
+	ISPOPMAP(0x0f, 0x01)	/* 0x7e: LUN RESET */
 };
 /*
  * Footnotes
  *
  * (1): this sets bits 21..16 in mailbox register #8, which we nominally 
  *	do not access at this time in the core driver. The caller is
- *	responsible for setting this register first (Gross!).
+ *	responsible for setting this register first (Gross!). The assumption
+ *	is that we won't overflow.
  */
 
-#ifndef	ISP_STRIPPED
-static char *fc_mbcmd_names[] = {
+#ifndef		ISP_STRIPPED
+static const char *fc_mbcmd_names[] = {
 	"NO-OP",
 	"LOAD RAM",
 	"EXEC FIRMWARE",
@@ -5171,7 +6552,7 @@ static char *fc_mbcmd_names[] = {
 	"ABOUT FIRMWARE",
 	"LOAD RAM",
 	"DUMP RAM",
-	NULL,
+	"WRITE RAM WORD EXTENDED",
 	NULL,
 	"READ RAM WORD EXTENDED",
 	"CHECK FIRMWARE",
@@ -5226,12 +6607,12 @@ static char *fc_mbcmd_names[] = {
 	NULL,
 	"LOOP PORT BYPASS",
 	"LOOP PORT ENABLE",
-	"GET RESOURCE COUNTS",
+	"GET RESOURCE COUNT",
 	"REQUEST NON PARTICIPATING MODE",
 	NULL,
 	NULL,
 	NULL,
-	"GET PORT DATABASE,, ENHANCED",
+	"GET PORT DATABASE ENHANCED",
 	NULL,
 	NULL,
 	NULL,
@@ -5290,26 +6671,24 @@ static char *fc_mbcmd_names[] = {
 };
 #endif
 
-static void
+void
 isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay)
 {
-	unsigned int lim, ibits, obits, box, opcode;
-	const u_int16_t *mcp;
+	unsigned int ibits, obits, box, opcode;
+	const u_int32_t *mcp;
 
 	if (IS_FC(isp)) {
 		mcp = mbpfc;
-		lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
 	} else {
 		mcp = mbpscsi;
-		lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
 	}
 	opcode = mbp->param[0];
-	ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
-	obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
-	for (box = 0; box < MAX_MAILBOX; box++) {
+	ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
+	obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
+	ibits |= mbp->ibits;
+	obits |= mbp->obits;
+	for (box = 0; box < MAX_MAILBOX(isp); box++) {
 		if (ibits & (1 << box)) {
-			isp_prt(isp, ISP_LOGDEBUG1, "IN mbox %d = 0x%x", box,
-			    mbp->param[box]);
 			ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
 		}
 		if (nodelay == 0) {
@@ -5321,7 +6700,11 @@ isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay)
 		isp->isp_obits = obits;
 		isp->isp_mboxbsy = 1;
 	}
-	ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
+	}
 	/*
 	 * Oddly enough, if we're not delaying for an answer,
 	 * delay a bit to give the f/w a chance to pick up the
@@ -5332,12 +6715,13 @@ isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay)
 	}
 }
 
-static void
-isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
+void
+isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp)
 {
-	char *cname, *xname, tname[16], mname[16];
+	const char *cname, *xname;
+	char tname[16], mname[16];
 	unsigned int lim, ibits, obits, box, opcode;
-	const u_int16_t *mcp;
+	const u_int32_t *mcp;
 
 	if (IS_FC(isp)) {
 		mcp = mbpfc;
@@ -5353,8 +6737,14 @@ isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 		return;
 	}
 
-	ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
-	obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
+	ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
+	obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
+
+	/*
+	 * Pick up any additional bits that the caller might have set.
+	 */
+	ibits |= mbp->ibits;
+	obits |= mbp->obits;
 
 	if (ibits == 0 && obits == 0) {
 		mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
@@ -5365,10 +6755,15 @@ isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 	/*
 	 * Get exclusive usage of mailbox registers.
 	 */
-	MBOX_ACQUIRE(isp);
+	if (MBOX_ACQUIRE(isp)) {
+		mbp->param[0] = MBOX_REGS_BUSY;
+		goto out;
+	}
 
-	for (box = 0; box < MAX_MAILBOX; box++) {
+	for (box = 0; box < MAX_MAILBOX(isp); box++) {
 		if (ibits & (1 << box)) {
+			isp_prt(isp, ISP_LOGDEBUG1, "IN mbox %d = 0x%04x", box,
+			    mbp->param[box]);
 			ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
 		}
 		isp->isp_mboxtmp[box] = mbp->param[box] = 0;
@@ -5385,39 +6780,43 @@ isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 	/*
 	 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
 	 */
-	ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
+	if (IS_24XX(isp)) {
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
+	} else {
+		ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
+	}
 
 	/*
 	 * While we haven't finished the command, spin our wheels here.
 	 */
-	MBOX_WAIT_COMPLETE(isp);
+	MBOX_WAIT_COMPLETE(isp, mbp);
 
-	if (isp->isp_mboxbsy) {
-		/*
-		 * Command timed out.
-		 */
-		isp->isp_mboxbsy = 0;
+	/*
+	 * Did the command time out?
+	 */
+	if (mbp->param[0] == MBOX_TIMEOUT) {
 		MBOX_RELEASE(isp);
-		return;
+		goto out;
 	}
 
 	/*
 	 * Copy back output registers.
 	 */
-	for (box = 0; box < MAX_MAILBOX; box++) {
+	for (box = 0; box < MAX_MAILBOX(isp); box++) {
 		if (obits & (1 << box)) {
 			mbp->param[box] = isp->isp_mboxtmp[box];
-			isp_prt(isp, ISP_LOGDEBUG1, "OUT mbox %d = 0x%x", box,
+			isp_prt(isp, ISP_LOGDEBUG1, "OUT mbox %d = 0x%04x", box,
 			    mbp->param[box]);
 		}
 	}
 
 	MBOX_RELEASE(isp);
-
-	if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
+ out:
+	isp->isp_mboxbsy = 0;
+	if (mbp->logval == 0 || opcode == MBOX_EXEC_FIRMWARE) {
 		return;
 	}
-#ifdef	ISP_STRIPPED
+#ifdef ISP_STRIPPED
 	cname = NULL;
 #else
 	cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
@@ -5435,38 +6834,49 @@ isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 	case MBOX_COMMAND_COMPLETE:
 		break;
 	case MBOX_INVALID_COMMAND:
-		if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
+		if (mbp->logval & MBLOGMASK(MBOX_COMMAND_COMPLETE)) {
 			xname = "INVALID COMMAND";
+		}
 		break;
 	case MBOX_HOST_INTERFACE_ERROR:
-		if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
+		if (mbp->logval & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) {
 			xname = "HOST INTERFACE ERROR";
+		}
 		break;
 	case MBOX_TEST_FAILED:
-		if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
+		if (mbp->logval & MBLOGMASK(MBOX_TEST_FAILED)) {
 			xname = "TEST FAILED";
+		}
 		break;
 	case MBOX_COMMAND_ERROR:
-		if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
+		if (mbp->logval & MBLOGMASK(MBOX_COMMAND_ERROR)) {
 			xname = "COMMAND ERROR";
+		}
 		break;
 	case MBOX_COMMAND_PARAM_ERROR:
-		if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
+		if (mbp->logval & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) {
 			xname = "COMMAND PARAMETER ERROR";
+		}
 		break;
 	case MBOX_LOOP_ID_USED:
-		if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
+		if (mbp->logval & MBLOGMASK(MBOX_LOOP_ID_USED)) {
 			xname = "LOOP ID ALREADY IN USE";
+		}
 		break;
 	case MBOX_PORT_ID_USED:
-		if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
+		if (mbp->logval & MBLOGMASK(MBOX_PORT_ID_USED)) {
 			xname = "PORT ID ALREADY IN USE";
+		}
 		break;
 	case MBOX_ALL_IDS_USED:
-		if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
+		if (mbp->logval & MBLOGMASK(MBOX_ALL_IDS_USED)) {
 			xname = "ALL LOOP IDS IN USE";
+		}
+		break;
+	case MBOX_REGS_BUSY:
+		xname = "REGISTERS BUSY";
 		break;
-	case 0:		/* special case */
+	case MBOX_TIMEOUT:
 		xname = "TIMEOUT";
 		break;
 	default:
@@ -5474,12 +6884,13 @@ isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 		xname = mname;
 		break;
 	}
-	if (xname)
+	if (xname) {
 		isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
 		    cname, xname);
+	}
 }
 
-static void
+void
 isp_fw_state(struct ispsoftc *isp)
 {
 	if (IS_FC(isp)) {
@@ -5488,14 +6899,15 @@ isp_fw_state(struct ispsoftc *isp)
 
 		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_GET_FW_STATE;
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 			fcp->isp_fwstate = mbs.param[1];
 		}
 	}
 }
 
-static void
+void
 isp_update(struct ispsoftc *isp)
 {
 	int bus, upmask;
@@ -5508,7 +6920,7 @@ isp_update(struct ispsoftc *isp)
 	}
 }
 
-static void
+void
 isp_update_bus(struct ispsoftc *isp, int bus)
 {
 	int tgt;
@@ -5550,17 +6962,16 @@ isp_update_bus(struct ispsoftc *isp, int bus)
 		 */
 		if (sdp->isp_devparam[tgt].dev_refresh) {
 			mbs.param[0] = MBOX_GET_TARGET_PARAMS;
-			sdp->isp_devparam[tgt].dev_refresh = 0;
 			get = 1;
 		} else if (sdp->isp_devparam[tgt].dev_update) {
 			mbs.param[0] = MBOX_SET_TARGET_PARAMS;
+
 			/*
 			 * Make sure goal_flags has "Renegotiate on Error"
 			 * on and "Freeze Queue on Error" off.
 			 */
 			sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
 			sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
-
 			mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
 
 			/*
@@ -5594,26 +7005,31 @@ isp_update_bus(struct ispsoftc *isp, int bus)
 			    "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
 			    bus, tgt, mbs.param[2], mbs.param[3] >> 8,
 			    mbs.param[3] & 0xff);
-			sdp->isp_devparam[tgt].dev_update = 0;
-			sdp->isp_devparam[tgt].dev_refresh = 1;
 			get = 0;
 		} else {
 			continue;
 		}
 		mbs.param[1] = (bus << 15) | (tgt << 8);
-		isp_mboxcmd(isp, &mbs, MBLOGALL);
+		mbs.logval = MBLOGALL;
+		isp_mboxcmd(isp, &mbs);
+		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+			continue;
+		}
 		if (get == 0) {
 			isp->isp_sendmarker |= (1 << bus);
-			continue;
+			sdp->isp_devparam[tgt].dev_update = 0;
+			sdp->isp_devparam[tgt].dev_refresh = 1;
+		} else {
+			sdp->isp_devparam[tgt].dev_refresh = 0;
+			flags = mbs.param[2];
+			period = mbs.param[3] & 0xff;
+			offset = mbs.param[3] >> 8;
+			sdp->isp_devparam[tgt].actv_flags = flags;
+			sdp->isp_devparam[tgt].actv_period = period;
+			sdp->isp_devparam[tgt].actv_offset = offset;
+			get = (bus << 16) | tgt;
+			(void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
 		}
-		flags = mbs.param[2];
-		period = mbs.param[3] & 0xff;
-		offset = mbs.param[3] >> 8;
-		sdp->isp_devparam[tgt].actv_flags = flags;
-		sdp->isp_devparam[tgt].actv_period = period;
-		sdp->isp_devparam[tgt].actv_offset = offset;
-		get = (bus << 16) | tgt;
-		(void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
 	}
 
 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
@@ -5625,100 +7041,16 @@ isp_update_bus(struct ispsoftc *isp, int bus)
 	}
 }
 
-#ifndef	DEFAULT_FRAMESIZE
-#define	DEFAULT_FRAMESIZE(isp)		ICB_DFLT_FRMLEN
-#endif
 #ifndef	DEFAULT_EXEC_THROTTLE
 #define	DEFAULT_EXEC_THROTTLE(isp)	ISP_EXEC_THROTTLE
 #endif
 
-static void
+void
 isp_setdfltparm(struct ispsoftc *isp, int channel)
 {
 	int tgt;
 	sdparam *sdp;
 
-	if (IS_FC(isp)) {
-		fcparam *fcp = (fcparam *) isp->isp_param;
-		int nvfail;
-
-		fcp += channel;
-		if (fcp->isp_gotdparms) {
-			return;
-		}
-		fcp->isp_gotdparms = 1;
-		fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
-		fcp->isp_maxalloc = ICB_DFLT_ALLOC;
-		fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
-		fcp->isp_retry_delay = ICB_DFLT_RDELAY;
-		fcp->isp_retry_count = ICB_DFLT_RCOUNT;
-		/* Platform specific.... */
-		fcp->isp_loopid = DEFAULT_LOOPID(isp);
-		fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
-		fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
-		fcp->isp_fwoptions = 0;
-		fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
-		fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
-		fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
-#ifndef	ISP_NO_FASTPOST_FC
-		fcp->isp_fwoptions |= ICBOPT_FAST_POST;
-#endif
-		if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
-			fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
-
-		/*
-		 * Make sure this is turned off now until we get
-		 * extended options from NVRAM
-		 */
-		fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
-
-		/*
-		 * Now try and read NVRAM unless told to not do so.
-		 * This will set fcparam's isp_nodewwn && isp_portwwn.
-		 */
-		if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
-		    	nvfail = isp_read_nvram(isp);
-			if (nvfail)
-				isp->isp_confopts |= ISP_CFG_NONVRAM;
-		} else {
-			nvfail = 1;
-		}
-		/*
-		 * Set node && port to override platform set defaults
-		 * unless the nvram read failed (or none was done),
-		 * or the platform code wants to use what had been
-		 * set in the defaults.
-		 */
-		if (nvfail) {
-			isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
-		}
-		if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
-			isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
-			    (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32),
-			    (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
-			ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
-		} else {
-			/*
-			 * We always start out with values derived
-			 * from NVRAM or our platform default.
-			 */
-			ISP_NODEWWN(isp) = fcp->isp_nodewwn;
-		}
-		if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
-			isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
-			    (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32),
-			    (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
-			ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
-		} else {
-			/*
-			 * We always start out with values derived
-			 * from NVRAM or our platform default.
-			 */
-			ISP_PORTWWN(isp) = fcp->isp_portwwn;
-		}
-		return;
-	}
-
 	sdp = (sdparam *) isp->isp_param;
 	sdp += channel;
 
@@ -5729,7 +7061,7 @@ isp_setdfltparm(struct ispsoftc *isp, int channel)
 		return;
 	}
 	sdp->isp_gotdparms = 1;
-
+	sdp->isp_bad_nvram = 0;
 	/*
 	 * Establish some default parameters.
 	 */
@@ -5769,6 +7101,7 @@ isp_setdfltparm(struct ispsoftc *isp, int channel)
 		if (isp_read_nvram(isp) == 0) {
 			return;
 		}
+		sdp->isp_bad_nvram = 1;
 	}
 
 	/*
@@ -5779,7 +7112,8 @@ isp_setdfltparm(struct ispsoftc *isp, int channel)
 
 		MEMZERO(&mbs, sizeof (mbs));
 		mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
-		isp_mboxcmd(isp, &mbs, MBLOGNONE);
+		mbs.logval = MBLOGNONE;
+		isp_mboxcmd(isp, &mbs);
 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 			sdp->isp_req_ack_active_neg = 1;
 			sdp->isp_data_line_active_neg = 1;
@@ -5817,7 +7151,7 @@ isp_setdfltparm(struct ispsoftc *isp, int channel)
 
 		/*
 		 * We default to Wide/Fast for versions less than a 1040
-		 * (unless its SBus).
+		 * (unless it's SBus).
 		 */
 		if (IS_ULTRA3(isp)) {
 			off = ISP_80M_SYNCPARMS >> 8;
@@ -5852,20 +7186,125 @@ isp_setdfltparm(struct ispsoftc *isp, int channel)
 	}
 }
 
+#ifndef	DEFAULT_FRAMESIZE
+#define	DEFAULT_FRAMESIZE(isp)		ICB_DFLT_FRMLEN
+#endif
+void
+isp_setdfltfcparm(struct ispsoftc *isp)
+{
+	fcparam *fcp = FCPARAM(isp);
+
+	if (fcp->isp_gotdparms) {
+		return;
+	}
+	fcp->isp_gotdparms = 1;
+	fcp->isp_bad_nvram = 0;
+	fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
+	fcp->isp_maxalloc = ICB_DFLT_ALLOC;
+	fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
+	fcp->isp_retry_delay = ICB_DFLT_RDELAY;
+	fcp->isp_retry_count = ICB_DFLT_RCOUNT;
+	/* Platform specific.... */
+	fcp->isp_loopid = DEFAULT_LOOPID(isp);
+	fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp);
+	fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp);
+	fcp->isp_fwoptions = 0;
+	fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
+	fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
+	fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
+	fcp->isp_fwoptions |= ICBOPT_FAST_POST;
+	if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
+		fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
+	}
+
+	/*
+	 * Make sure this is turned off now until we get
+	 * extended options from NVRAM
+	 */
+	fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
+
+	/*
+	 * Now try and read NVRAM unless told to not do so.
+	 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
+	 */
+	if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
+		int i, j = 0;
+		/*
+		 * Give a couple of tries at reading NVRAM.
+		 */
+		for (i = 0; i < 2; i++) {
+			j = isp_read_nvram(isp);
+			if (j == 0) {
+				break;
+			}
+		}
+		if (j) {
+			fcp->isp_bad_nvram = 1;
+			isp->isp_confopts |= ISP_CFG_NONVRAM;
+			isp->isp_confopts |= ISP_CFG_OWNWWPN;
+			isp->isp_confopts |= ISP_CFG_OWNWWNN;
+		}
+	} else {
+		isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
+	}
+
+	/*
+	 * Set node && port to override platform set defaults
+	 * unless the nvram read failed (or none was done),
+	 * or the platform code wants to use what had been
+	 * set in the defaults.
+	 */
+	if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
+		isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
+		    (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32),
+		    (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
+		ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
+	} else {
+		/*
+		 * We always start out with values derived
+		 * from NVRAM or our platform default.
+		 */
+		ISP_NODEWWN(isp) = fcp->isp_wwnn_nvram;
+		if (fcp->isp_wwnn_nvram == 0) {
+			isp_prt(isp, ISP_LOGCONFIG,
+			    "bad WWNN- using default");
+			ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
+		}
+	}
+	if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
+		isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
+		    (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32),
+		    (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
+		ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
+	} else {
+		/*
+		 * We always start out with values derived
+		 * from NVRAM or our platform default.
+		 */
+		ISP_PORTWWN(isp) = fcp->isp_wwpn_nvram;
+		if (fcp->isp_wwpn_nvram == 0) {
+			isp_prt(isp, ISP_LOGCONFIG,
+			    "bad WWPN- using default");
+			ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
+		}
+	}
+}
+
 /*
  * Re-initialize the ISP and complete all orphaned commands
  * with a 'botched' notice. The reset/init routines should
  * not disturb an already active list of commands.
- *
- * Locks held prior to coming here.
  */
 
 void
 isp_reinit(struct ispsoftc *isp)
 {
 	XS_T *xs;
-	u_int16_t handle;
+	u_int32_t tmp;
 
+	if (IS_FC(isp)) {
+		ISP_MARK_PORTDB(isp, 0);
+	}
 	isp_reset(isp);
 	if (isp->isp_state != ISP_RESETSTATE) {
 		isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
@@ -5877,15 +7316,36 @@ isp_reinit(struct ispsoftc *isp)
 		if (isp->isp_state != ISP_RUNSTATE) {
 			isp_prt(isp, ISP_LOGERR,
 			    "isp_reinit cannot restart card");
+			ISP_DISABLE_INTS(isp);
 		}
-	}
+	} else {
+		ISP_DISABLE_INTS(isp);
+		if (IS_FC(isp)) {
+			/*
+			 * If we're in ISP_ROLE_NONE, turn off the lasers.
+			 */
+			if (!IS_24XX(isp)) {
+				ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
+				ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
+				ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
+				ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
+				ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
+			}
+		}
+ 	}
 	isp->isp_nactive = 0;
 
-	for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) {
-		xs = isp_find_xs(isp, handle);
+	for (tmp = 0; tmp < isp->isp_maxcmds; tmp++) {
+		u_int32_t handle;
+
+		xs = isp->isp_xflist[tmp];
 		if (xs == NULL) {
 			continue;
 		}
+		handle = isp_find_handle(isp, xs);
+		if (handle == 0) {
+			continue;
+		}
 		isp_destroy_handle(isp, handle);
 		if (XS_XFRLEN(xs)) {
 			ISP_DMAFREE(isp, xs, handle);
@@ -5896,15 +7356,18 @@ isp_reinit(struct ispsoftc *isp)
 		XS_SETERR(xs, HBA_BUSRESET);
 		isp_done(xs);
 	}
+#ifdef	ISP_TARGET_MODE
+	MEMZERO(isp->isp_tgtlist, isp->isp_maxcmds * sizeof (void **));
+#endif
 }
 
 /*
  * NVRAM Routines
  */
-static int
+int
 isp_read_nvram(struct ispsoftc *isp)
 {
-	int i, amt;
+	int i, amt, retval;
 	u_int8_t csum, minversion;
 	union {
 		u_int8_t _x[ISP2100_NVRAM_SIZE];
@@ -5913,7 +7376,9 @@ isp_read_nvram(struct ispsoftc *isp)
 #define	nvram_data	_n._x
 #define	nvram_words	_n._s
 
-	if (IS_FC(isp)) {
+	if (IS_24XX(isp)) {
+		return (isp_read_nvram_2400(isp));
+	} else if (IS_FC(isp)) {
 		amt = ISP2100_NVRAM_SIZE;
 		minversion = 1;
 	} else if (IS_ULTRA2(isp)) {
@@ -5924,13 +7389,10 @@ isp_read_nvram(struct ispsoftc *isp)
 		minversion = 2;
 	}
 
-	/*
-	 * Just read the first two words first to see if we have a valid
-	 * NVRAM to continue reading the rest with.
-	 */
-	for (i = 0; i < 2; i++) {
+	for (i = 0; i < amt>>1; i++) {
 		isp_rdnvram_word(isp, i, &nvram_words[i]);
 	}
+
 	if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
 	    nvram_data[2] != 'P') {
 		if (isp->isp_bustype != ISP_BT_SBUS) {
@@ -5938,22 +7400,24 @@ isp_read_nvram(struct ispsoftc *isp)
 			isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
 			    nvram_data[0], nvram_data[1], nvram_data[2]);
 		}
-		return (-1);
-	}
-	for (i = 2; i < amt>>1; i++) {
-		isp_rdnvram_word(isp, i, &nvram_words[i]);
+		retval = -1;
+		goto out;
 	}
+
 	for (csum = 0, i = 0; i < amt; i++) {
 		csum += nvram_data[i];
 	}
 	if (csum != 0) {
 		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
-		return (-1);
+		retval = -1;
+		goto out;
 	}
+
 	if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
 		isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
 		    ISP_NVRAM_VERSION(nvram_data));
-		return (-1);
+		retval = -1;
+		goto out;
 	}
 
 	if (IS_ULTRA3(isp)) {
@@ -5970,24 +7434,66 @@ isp_read_nvram(struct ispsoftc *isp)
 	} else {
 		isp_parse_nvram_2100(isp, nvram_data);
 	}
-	return (0);
+	retval = 0;
+out:
+	return (retval);
 #undef	nvram_data
 #undef	nvram_words
 }
 
-static void
+int
+isp_read_nvram_2400(struct ispsoftc *isp)
+{
+	u_int8_t *nvram_data = FCPARAM(isp)->isp_scratch;
+	int retval = 0;
+	u_int32_t addr, csum, lwrds, *dptr;
+	
+	if (isp->isp_port) {
+		addr = ISP2400_NVRAM_PORT1_ADDR;
+	} else {
+		addr = ISP2400_NVRAM_PORT0_ADDR;
+	}
+	
+	dptr = (u_int32_t *) nvram_data;
+	for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
+		isp_rd_2400_nvram(isp, addr++, dptr++);
+	}
+	if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
+	    nvram_data[2] != 'P') {
+		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
+		    nvram_data[0], nvram_data[1], nvram_data[2]);
+		retval = -1;
+		goto out;
+	}
+	dptr = (u_int32_t *) nvram_data;
+	for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
+		u_int32_t tmp;
+		ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
+		csum += tmp;
+	}
+	if (csum != 0) {
+		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
+		retval = -1;
+		goto out;
+	}
+	isp_parse_nvram_2400(isp, nvram_data);
+out:
+	return (retval);
+}
+
+void
 isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp)
 {
 	int i, cbits;
-	u_int16_t bit, rqst;
+	u_int16_t bit, rqst, junk;
 
 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
-	USEC_DELAY(2);
+	USEC_DELAY(10);
 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
-	USEC_DELAY(2);
+	USEC_DELAY(10);
 
 	if (IS_FC(isp)) {
-		wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
+		wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); 
 		if (IS_2312(isp) && isp->isp_port) {
 			wo += 128;
 		}
@@ -6013,11 +7519,14 @@ isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp)
 			bit = BIU_NVRAM_SELECT;
 		}
 		ISP_WRITE(isp, BIU_NVRAM, bit);
-		USEC_DELAY(2);
+		USEC_DELAY(10);
+		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
 		ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
-		USEC_DELAY(2);
+		USEC_DELAY(10);
+		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
 		ISP_WRITE(isp, BIU_NVRAM, bit);
-		USEC_DELAY(2);
+		USEC_DELAY(10);
+		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
 	}
 	/*
 	 * Now read the result back in (bits come back in MSB format).
@@ -6027,21 +7536,46 @@ isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp)
 		u_int16_t rv;
 		*rp <<= 1;
 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
-		USEC_DELAY(2);
+		USEC_DELAY(10);
 		rv = ISP_READ(isp, BIU_NVRAM);
 		if (rv & BIU_NVRAM_DATAIN) {
 			*rp |= 1;
 		}
-		USEC_DELAY(2);
+		USEC_DELAY(10);
 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
-		USEC_DELAY(2);
+		USEC_DELAY(10);
+		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
 	}
 	ISP_WRITE(isp, BIU_NVRAM, 0);
-	USEC_DELAY(2);
+	USEC_DELAY(10);
+	junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
 	ISP_SWIZZLE_NVRAM_WORD(isp, rp);
 }
 
-static void
+void
+isp_rd_2400_nvram(struct ispsoftc *isp, u_int32_t addr, u_int32_t *rp)
+{
+	int loops = 0;
+	const u_int32_t base = 0x7ffe0000;
+	u_int32_t tmp = 0;
+
+	ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
+	for (loops = 0; loops < 5000; loops++) {
+		USEC_DELAY(10);
+		tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
+		if ((tmp & (1U << 31)) != 0) {
+			break;
+		}
+	}
+	if (tmp & (1U << 31)) {
+		*rp = ISP_READ(isp, BIU2400_FLASH_DATA);
+		ISP_SWIZZLE_NVRAM_LONG(isp, rp);
+	} else {
+		*rp = 0xffffffff;
+	}
+}
+
+void
 isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data)
 {
 	sdparam *sdp = (sdparam *) isp->isp_param;
@@ -6167,7 +7701,7 @@ isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data)
 	}
 }
 
-static void
+void
 isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 {
 	sdparam *sdp = (sdparam *) isp->isp_param;
@@ -6259,7 +7793,7 @@ isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 	}
 }
 
-static void
+void
 isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 {
 	sdparam *sdp = (sdparam *) isp->isp_param;
@@ -6350,10 +7884,42 @@ isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 	}
 }
 
-static void
+void
+isp_fix_nvram_wwns(struct ispsoftc *isp)
+{
+	fcparam *fcp = FCPARAM(isp);
+
+	/*
+	 * Make sure we have both Node and Port as non-zero values.
+	 */
+	if (fcp->isp_wwnn_nvram != 0 && fcp->isp_wwpn_nvram == 0) {
+		fcp->isp_wwpn_nvram = fcp->isp_wwnn_nvram;
+	} else if (fcp->isp_wwnn_nvram == 0 && fcp->isp_wwpn_nvram != 0) {
+		fcp->isp_wwnn_nvram = fcp->isp_wwpn_nvram;
+	}
+
+	/*
+	 * Make the Node and Port values sane if they're NAA == 2.
+	 * This means to clear bits 48..56 for the Node WWN and
+	 * make sure that there's some non-zero value in 48..56
+	 * for the Port WWN.
+	 */
+	if (fcp->isp_wwnn_nvram && fcp->isp_wwpn_nvram) {
+		if ((fcp->isp_wwnn_nvram & (((u_int64_t) 0xfff) << 48)) != 0 &&
+		    (fcp->isp_wwnn_nvram >> 60) == 2) {
+			fcp->isp_wwnn_nvram &= ~((u_int64_t) 0xfff << 48);
+		}
+		if ((fcp->isp_wwpn_nvram & (((u_int64_t) 0xfff) << 48)) == 0 &&
+		    (fcp->isp_wwpn_nvram >> 60) == 2) {
+			fcp->isp_wwpn_nvram |= ((u_int64_t) 1 << 56);
+		}
+	}
+}
+
+void
 isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
 {
-	fcparam *fcp = (fcparam *) isp->isp_param;
+	fcparam *fcp = FCPARAM(isp);
 	u_int64_t wwn;
 
 	/*
@@ -6362,7 +7928,7 @@ isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
 	 * I can find. However, we should account for this being set
 	 * at some point in the future.
 	 *
-	 * QLogic WWNs have an NAA of 2, but usually nothing shows up in
+	 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
 	 * bits 48..60. In the case of the 2202, it appears that they do
 	 * use bit 48 to distinguish between the two instances on the card.
 	 * The 2204, which I've never seen, *probably* extends this method.
@@ -6375,9 +7941,9 @@ isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
 			wwn |= (((u_int64_t) 2)<< 60);
 		}
 	}
-	fcp->isp_portwwn = wwn;
+	fcp->isp_wwpn_nvram = wwn;
 	if (IS_2200(isp) || IS_23XX(isp)) {
-		wwn = ISP2200_NVRAM_NODE_NAME(nvram_data);
+		wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
 		if (wwn) {
 			isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
 			    (u_int32_t) (wwn >> 32),
@@ -6389,70 +7955,113 @@ isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
 	} else {
 		wwn &= ~((u_int64_t) 0xfff << 48);
 	}
-	fcp->isp_nodewwn = wwn;
+	fcp->isp_wwnn_nvram = wwn;
 
-	/*
-	 * Make sure we have both Node and Port as non-zero values.
-	 */
-	if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) {
-		fcp->isp_portwwn = fcp->isp_nodewwn;
-	} else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) {
-		fcp->isp_nodewwn = fcp->isp_portwwn;
+	isp_fix_nvram_wwns(isp);
+
+	fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
+	if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
+		fcp->isp_maxfrmlen = ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
 	}
+	fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
+	fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
+	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
+		fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
+	}
+	if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
+		fcp->isp_execthrottle =
+			ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
+	}
+	fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
+	    (u_int32_t) (fcp->isp_wwnn_nvram >> 32), (u_int32_t) fcp->isp_wwnn_nvram,
+	    (u_int32_t) (fcp->isp_wwpn_nvram >> 32), (u_int32_t) fcp->isp_wwpn_nvram,
+	    ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
+	    ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
+	    ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
+	    ISP2100_NVRAM_OPTIONS(nvram_data),
+	    ISP2100_NVRAM_HARDLOOPID(nvram_data),
+	    ISP2100_NVRAM_TOV(nvram_data));
+	fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
+	fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "xfwoptions 0x%x zfw options 0x%x",
+	    ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
+}
 
-	/*
-	 * Make the Node and Port values sane if they're NAA == 2.
-	 * This means to clear bits 48..56 for the Node WWN and
-	 * make sure that there's some non-zero value in 48..56
-	 * for the Port WWN.
-	 */
-	if (fcp->isp_nodewwn && fcp->isp_portwwn) {
-		if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 &&
-		    (fcp->isp_nodewwn >> 60) == 2) {
-			fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48);
+void
+isp_parse_nvram_2400(struct ispsoftc *isp, u_int8_t *nvram_data)
+{
+	fcparam *fcp = FCPARAM(isp);
+	u_int64_t wwn;
+
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
+	    (u_int32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
+	    (u_int32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
+	    (u_int32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
+	    (u_int32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
+	    ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
+	    ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
+	isp_prt(isp, ISP_LOGDEBUG0,
+	    "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
+	    ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
+	    ISP2400_NVRAM_HARDLOOPID(nvram_data),
+	    ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
+	    ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
+	    ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
+
+	wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
+	if (wwn) {
+		if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
+			wwn = 0;
 		}
-		if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 &&
-		    (fcp->isp_portwwn >> 60) == 2) {
-			fcp->isp_portwwn |= ((u_int64_t) 1 << 56);
+	}
+	fcp->isp_wwpn_nvram = wwn;
+
+	wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
+	if (wwn) {
+		if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
+			wwn = 0;
 		}
 	}
+	fcp->isp_wwnn_nvram = wwn;
 
-	isp_prt(isp, ISP_LOGDEBUG0,
-	    "NVRAM: maxfrmlen %d execthrottle %d fwoptions 0x%x loopid %x",
-	    ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data),
-	    ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
-	    ISP2100_NVRAM_OPTIONS(nvram_data),
-	    ISP2100_NVRAM_HARDLOOPID(nvram_data));
-
-	fcp->isp_maxalloc =
-		ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
-	if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0)
-		fcp->isp_maxfrmlen =
-			ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
-	fcp->isp_retry_delay =
-		ISP2100_NVRAM_RETRY_DELAY(nvram_data);
-	fcp->isp_retry_count =
-		ISP2100_NVRAM_RETRY_COUNT(nvram_data);
-	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
-		fcp->isp_loopid =
-			ISP2100_NVRAM_HARDLOOPID(nvram_data);
-	if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0)
+	isp_fix_nvram_wwns(isp);
+
+	if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
+		fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
+	}
+	if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
+		fcp->isp_maxfrmlen = ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
+	}
+	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
+		fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
+	}
+	if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
 		fcp->isp_execthrottle =
-			ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
-	fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
+			ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
+	}
+	fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
+	fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
+	fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
 }
 
 #ifdef	ISP_FW_CRASH_DUMP
-static void isp2200_fw_dump(struct ispsoftc *);
-static void isp2300_fw_dump(struct ispsoftc *);
+void isp2200_fw_dump(struct ispsoftc *);
+void isp2300_fw_dump(struct ispsoftc *);
 
-static void
+void
 isp2200_fw_dump(struct ispsoftc *isp)
 {
 	int i, j;
 	mbreg_t mbs;
 	u_int16_t *ptr;
 
+	MEMZERO(&mbs, sizeof (mbs));
 	ptr = FCPARAM(isp)->isp_dump_data;
 	if (ptr == NULL) {
 		isp_prt(isp, ISP_LOGERR,
@@ -6571,8 +8180,7 @@ isp2200_fw_dump(struct ispsoftc *isp)
 			break;
 		}
 	}
-	ENABLE_INTS(isp);
-	MEMZERO(&mbs, sizeof (mbs));
+	ISP_ENABLE_INTS(isp);
 	mbs.param[0] = MBOX_READ_RAM_WORD;
 	mbs.param[1] = 0x1000;
 	isp->isp_mbxworkp = (void *) ptr;
@@ -6591,13 +8199,14 @@ isp2200_fw_dump(struct ispsoftc *isp)
 	(void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
 }
 
-static void
+void
 isp2300_fw_dump(struct ispsoftc *isp)
 {
 	int i, j;
 	mbreg_t mbs;
 	u_int16_t *ptr;
 
+	MEMZERO(&mbs, sizeof (mbs));
 	ptr = FCPARAM(isp)->isp_dump_data;
 	if (ptr == NULL) {
 		isp_prt(isp, ISP_LOGERR,
@@ -6714,7 +8323,7 @@ isp2300_fw_dump(struct ispsoftc *isp)
 		isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
 		return;
 	}
-	ENABLE_INTS(isp);
+	ISP_ENABLE_INTS(isp);
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_READ_RAM_WORD;
 	mbs.param[1] = 0x800;
@@ -6729,20 +8338,13 @@ isp2300_fw_dump(struct ispsoftc *isp)
 	}
 	ptr = isp->isp_mbxworkp;	/* finish fetch of final word */
 	*ptr++ = isp->isp_mboxtmp[2];
-
-	/*
-	 * We don't have access to mailbox registers 8.. onward
-	 * in our 'common' device model- so we have to set it
-	 * here and hope it stays the same!
-	 */
-	ISP_WRITE(isp, PCI_MBOX_REGS2300_OFF + (8 << 1), 0x1);
-
 	MEMZERO(&mbs, sizeof (mbs));
 	mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
-	mbs.param[1] = 0;
+	mbs.param[8] = 1;
 	isp->isp_mbxworkp = (void *) ptr;
 	isp->isp_mbxwrk0 = 0xffff;	/* continuation count */
 	isp->isp_mbxwrk1 = 0x1;		/* next SRAM address */
+	isp->isp_mbxwrk8 = 0x1;
 	isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 		isp_prt(isp, ISP_LOGWARN,
@@ -6763,5 +8365,8 @@ isp_fw_dump(struct ispsoftc *isp)
 		isp2200_fw_dump(isp);
 	else if (IS_23XX(isp))
 		isp2300_fw_dump(isp);
+	else if (IS_24XX(isp))
+		isp_prt(isp, ISP_LOGERR, "24XX dump method undefined");
+
 }
 #endif
diff --git a/sys/dev/ic/isp_library.c b/sys/dev/ic/isp_library.c
index bf67fdbcd28..ffc955c0120 100644
--- a/sys/dev/ic/isp_library.c
+++ b/sys/dev/ic/isp_library.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: isp_library.c,v 1.1 2008/11/16 00:00:13 krw Exp $ */
+/*	$OpenBSD: isp_library.c,v 1.2 2009/06/24 11:00:53 krw Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
  *  All rights reserved.
@@ -28,15 +28,32 @@
 /*
  * Qlogic Host Adapter Internal Library Functions
  */
-
+#ifdef	__NetBSD__
+#include <sys/cdefs.h>
+__KERNEL_RCSID(0, "$NetBSD$");
+#include <dev/ic/isp_netbsd.h>
+#endif
+#ifdef	__FreeBSD__
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: src/sys/dev/isp/isp_library.c,v 1.14 2007/07/02 20:08:20 mjacob Exp $");
+#include <dev/isp/isp_freebsd.h>
+#endif
+#ifdef	__OpenBSD__
 #include <dev/ic/isp_openbsd.h>
+#endif
+#ifdef	__linux__
+#include "isp_linux.h"
+#endif
+#ifdef	__svr4__
+#include "isp_solaris.h"
+#endif
 
 int
-isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int16_t *handlep)
+isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int32_t *handlep)
 {
-	int i, j;
+	u_int16_t i, j;
 
-	for (j = isp->isp_lasthdls, i = 0; i < (int) isp->isp_maxcmds; i++) {
+	for (j = isp->isp_lasthdls, i = 0; i < isp->isp_maxcmds; i++) {
 		if (isp->isp_xflist[j] == NULL) {
 			break;
 		}
@@ -49,66 +66,58 @@ isp_save_xs(struct ispsoftc *isp, XS_T *xs, u_int16_t *handlep)
 	}
 	isp->isp_xflist[j] = xs;
 	*handlep = j+1;
-	if (++j == isp->isp_maxcmds)
+	if (++j == isp->isp_maxcmds) {
 		j = 0;
-	isp->isp_lasthdls = (u_int16_t)j;
+	}
+	isp->isp_lasthdls = (u_int32_t)j;
 	return (0);
 }
 
 XS_T *
-isp_find_xs(struct ispsoftc *isp, u_int16_t handle)
+isp_find_xs(struct ispsoftc *isp, u_int32_t handle)
 {
-	if (handle < 1 || handle > (u_int16_t) isp->isp_maxcmds) {
+	if (handle < 1 || handle > (u_int32_t) isp->isp_maxcmds) {
 		return (NULL);
 	} else {
 		return (isp->isp_xflist[handle - 1]);
 	}
 }
 
-u_int16_t
+u_int32_t
 isp_find_handle(struct ispsoftc *isp, XS_T *xs)
 {
-	int i;
+	u_int16_t i;
 	if (xs != NULL) {
 		for (i = 0; i < isp->isp_maxcmds; i++) {
 			if (isp->isp_xflist[i] == xs) {
-				return ((u_int16_t) i+1);
+				return ((u_int32_t) (i+1));
 			}
 		}
 	}
 	return (0);
 }
 
-int
-isp_handle_index(u_int16_t handle)
+u_int32_t
+isp_handle_index(u_int32_t handle)
 {
-	return (handle-1);
+	return (handle - 1);
 }
 
 void
-isp_destroy_handle(struct ispsoftc *isp, u_int16_t handle)
+isp_destroy_handle(struct ispsoftc *isp, u_int32_t handle)
 {
-	if (handle > 0 && handle <= (u_int16_t) isp->isp_maxcmds) {
-		isp->isp_xflist[isp_handle_index(handle)] = NULL;
+	if (handle > 0 && handle <= (u_int32_t) isp->isp_maxcmds) {
+		isp->isp_xflist[handle - 1] = NULL;
 	}
 }
 
-void
-isp_remove_handle(struct ispsoftc *isp, XS_T *xs)
-{
-	isp_destroy_handle(isp, isp_find_handle(isp, xs));
-}
-
-int
-isp_getrqentry(struct ispsoftc *, u_int16_t *, u_int16_t *, void **);
-
 int
-isp_getrqentry(struct ispsoftc *isp, u_int16_t *iptrp,
-    u_int16_t *optrp, void **resultp)
+isp_getrqentry(struct ispsoftc *isp, u_int32_t *iptrp,
+    u_int32_t *optrp, void **resultp)
 {
-	volatile u_int16_t iptr, optr;
+	volatile u_int32_t iptr, optr;
 
-	optr = isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
+	optr = isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
 	iptr = isp->isp_reqidx;
 	*resultp = ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
 	iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN(isp));
@@ -122,6 +131,7 @@ isp_getrqentry(struct ispsoftc *isp, u_int16_t *iptrp,
 	return (0);
 }
 
+#define	TBA	(4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
 void
 isp_print_qentry(struct ispsoftc *isp, char *msg, int idx, void *arg)
 {
@@ -141,7 +151,7 @@ isp_print_qentry(struct ispsoftc *isp, char *msg, int idx, void *arg)
 }
 
 void
-isp_print_bytes(struct ispsoftc *isp, char *msg, int amt, void *arg)
+isp_print_bytes(struct ispsoftc *isp, const char *msg, int amt, void *arg)
 {
 	char buf[128];
 	u_int8_t *ptr = arg;
@@ -173,10 +183,6 @@ isp_print_bytes(struct ispsoftc *isp, char *msg, int amt, void *arg)
  * action because things may have changed while we were doing this.
  * Any failure or change of state causes us to return a nonzero value.
  *
- * We honor HBA roles in that if we're not in Initiator mode, we don't
- * attempt to sync up the database (that's for somebody else to do,
- * if ever).
- *
  * We assume we enter here with any locks held.
  */
 
@@ -186,35 +192,120 @@ isp_fc_runstate(struct ispsoftc *isp, int tval)
 	fcparam *fcp;
 	int *tptr;
 
-	if (IS_SCSI(isp))
+        if (isp->isp_role == ISP_ROLE_NONE) {
 		return (0);
-
-	tptr = tval? &tval : NULL;
-	if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) {
-		return (-1);
 	}
 	fcp = FCPARAM(isp);
-	if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_PDB_RCVD)
-		return (-1);
-	if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) {
-		return (-1);
-	}
-	if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) {
-		return (-1);
+	tptr = &tval;
+	if (fcp->isp_fwstate < FW_READY ||
+	    fcp->isp_loopstate < LOOP_PDB_RCVD) {
+		if (isp_control(isp, ISPCTL_FCLINK_TEST, tptr) != 0) {
+			isp_prt(isp, ISP_LOGSANCFG,
+			    "isp_fc_runstate: linktest failed");
+			return (-1);
+		}
+		if (fcp->isp_fwstate != FW_READY ||
+		    fcp->isp_loopstate < LOOP_PDB_RCVD) {
+			isp_prt(isp, ISP_LOGSANCFG,
+				"isp_fc_runstate: f/w not ready");
+			return (-1);
+		}
 	}
 	if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
 		return (0);
 	}
+	if (isp_control(isp, ISPCTL_SCAN_LOOP, NULL) != 0) {
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "isp_fc_runstate: scan loop fails");
+		return (LOOP_PDB_RCVD);
+	}
+	if (isp_control(isp, ISPCTL_SCAN_FABRIC, NULL) != 0) {
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "isp_fc_runstate: scan fabric fails");
+		return (LOOP_LSCAN_DONE);
+	}
 	if (isp_control(isp, ISPCTL_PDB_SYNC, NULL) != 0) {
-		return (-1);
+		isp_prt(isp, ISP_LOGSANCFG, "isp_fc_runstate: pdb_sync fails");
+		return (LOOP_FSCAN_DONE);
 	}
 	if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
+		isp_prt(isp, ISP_LOGSANCFG,
+		    "isp_fc_runstate: f/w not ready again");
 		return (-1);
 	}
 	return (0);
 }
 
 /*
+ * Fibre Channel Support- get the port database for the id.
+ */
+void
+isp_dump_portdb(struct ispsoftc *isp)
+{
+	fcparam *fcp = (fcparam *) isp->isp_param;
+	int i;
+
+	for (i = 0; i < MAX_FC_TARG; i++) {
+		char mb[4];
+		const char *dbs[8] = {
+			"NIL ",
+			"PROB",
+			"DEAD",
+			"CHGD",
+			"NEW ",
+			"PVLD",
+			"ZOMB",
+			"VLD "
+		};
+		const char *roles[4] = {
+			" UNK", " TGT", " INI", "TINI"
+		};
+		fcportdb_t *lp = &fcp->portdb[i];
+
+		if (lp->state == FC_PORTDB_STATE_NIL) {
+			continue;
+		}
+		if (lp->ini_map_idx) {
+			SNPRINTF(mb, sizeof (mb), "%3d",
+			    ((int) lp->ini_map_idx) - 1);
+		} else {
+			SNPRINTF(mb, sizeof (mb), "---");
+		}
+		isp_prt(isp, ISP_LOGALL, "%d: hdl 0x%x %s al%d tgt %s %s "
+		    "0x%06x =>%s 0x%06x; WWNN 0x%08x%08x WWPN 0x%08x%08x", i,
+		    lp->handle, dbs[lp->state], lp->autologin, mb,
+		    roles[lp->roles], lp->portid,
+		    roles[lp->new_roles], lp->new_portid,
+		    (u_int32_t) (lp->node_wwn >> 32),
+		    (u_int32_t) (lp->node_wwn),
+		    (u_int32_t) (lp->port_wwn >> 32),
+		    (u_int32_t) (lp->port_wwn));
+	}
+}
+
+void
+isp_shutdown(struct ispsoftc *isp)
+{
+	if (IS_FC(isp)) {
+		if (IS_24XX(isp)) {
+			ISP_WRITE(isp, BIU2400_ICR, 0);
+			ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
+		} else {
+			ISP_WRITE(isp, BIU_ICR, 0);
+			ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
+			ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
+			ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
+			ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
+		}
+	} else {
+		ISP_WRITE(isp, BIU_ICR, 0);
+		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
+	}
+}
+
+/*
  * Functions to move stuff to a form that the QLogic RISC engine understands
  * and functions to move stuff back to a form the processor understands.
  *
@@ -225,12 +316,15 @@ isp_fc_runstate(struct ispsoftc *isp, int tval)
  * (with a few exceptions for efficiency).
  */
 
+#define	ISP_IS_SBUS(isp)	\
+	(ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
+
+#define	ASIZE(x)	(sizeof (x) / sizeof (x[0]))
 /*
  * Swizzle/Copy Functions
  */
-
 void
-isp_copy_out_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
+isp_put_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
 {
 	if (ISP_IS_SBUS(isp)) {
 		ISP_IOXPUT_8(isp, hpsrc->rqs_entry_type,
@@ -254,7 +348,7 @@ isp_copy_out_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
 }
 
 void
-isp_copy_in_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
+isp_get_hdr(struct ispsoftc *isp, isphdr_t *hpsrc, isphdr_t *hpdst)
 {
 	if (ISP_IS_SBUS(isp)) {
 		ISP_IOXGET_8(isp, &hpsrc->rqs_entry_type,
@@ -293,7 +387,7 @@ void
 isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
+	isp_put_hdr(isp, &rqsrc->req_header, &rqdst->req_header);
 	ISP_IOXPUT_32(isp, rqsrc->req_handle, &rqdst->req_handle);
 	if (ISP_IS_SBUS(isp)) {
 		ISP_IOXPUT_8(isp, rqsrc->req_lun_trn, &rqdst->req_target);
@@ -306,7 +400,7 @@ isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
 	ISP_IOXPUT_16(isp, rqsrc->req_flags, &rqdst->req_flags);
 	ISP_IOXPUT_16(isp, rqsrc->req_time, &rqdst->req_time);
 	ISP_IOXPUT_16(isp, rqsrc->req_seg_count, &rqdst->req_seg_count);
-	for (i = 0; i < 12; i++) {
+	for (i = 0; i < ASIZE(rqsrc->req_cdb); i++) {
 		ISP_IOXPUT_8(isp, rqsrc->req_cdb[i], &rqdst->req_cdb[i]);
 	}
 	for (i = 0; i < ISP_RQDSEG; i++) {
@@ -318,153 +412,343 @@ isp_put_request(struct ispsoftc *isp, ispreq_t *rqsrc, ispreq_t *rqdst)
 }
 
 void
-isp_put_request_t2(struct ispsoftc *isp, ispreqt2_t *tqsrc, ispreqt2_t *tqdst)
+isp_put_marker(struct ispsoftc *isp, isp_marker_t *src, isp_marker_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
-	ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
-	ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
-	ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
-	ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
-	ISP_IOXPUT_16(isp, tqsrc->req_flags,  &tqdst->req_flags);
-	ISP_IOXPUT_16(isp, tqsrc->req_reserved, &tqdst->req_reserved);
-	ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
-	ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
-	for (i = 0; i < 16; i++) {
-		ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
+	isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
+	ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_target);
+		ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_reserved0);
+	} else {
+		ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
+		ISP_IOXPUT_8(isp, src->mrk_target, &dst->mrk_target);
+	}
+	ISP_IOXPUT_16(isp, src->mrk_modifier, &dst->mrk_modifier);
+	ISP_IOXPUT_16(isp, src->mrk_flags, &dst->mrk_flags);
+	ISP_IOXPUT_16(isp, src->mrk_lun, &dst->mrk_lun);
+	for (i = 0; i < ASIZE(src->mrk_reserved1); i++) {
+		ISP_IOXPUT_8(isp, src->mrk_reserved1[i],
+		    &dst->mrk_reserved1[i]);
 	}
-	ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
+}
+
+void
+isp_put_marker_24xx(struct ispsoftc *isp,
+    isp_marker_24xx_t *src, isp_marker_24xx_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->mrk_header, &dst->mrk_header);
+	ISP_IOXPUT_32(isp, src->mrk_handle, &dst->mrk_handle);
+	ISP_IOXPUT_16(isp, src->mrk_nphdl, &dst->mrk_nphdl);
+	ISP_IOXPUT_8(isp, src->mrk_modifier, &dst->mrk_modifier);
+	ISP_IOXPUT_8(isp, src->mrk_reserved0, &dst->mrk_reserved0);
+	ISP_IOXPUT_8(isp, src->mrk_reserved1, &dst->mrk_reserved1);
+	ISP_IOXPUT_8(isp, src->mrk_vphdl, &dst->mrk_vphdl);
+	ISP_IOXPUT_8(isp, src->mrk_reserved2, &dst->mrk_reserved2);
+	for (i = 0; i < ASIZE(src->mrk_lun); i++) {
+		ISP_IOXPUT_8(isp, src->mrk_lun[i], &dst->mrk_lun[i]);
+	}
+	for (i = 0; i < ASIZE(src->mrk_reserved3); i++) {
+		ISP_IOXPUT_8(isp, src->mrk_reserved3[i],
+		    &dst->mrk_reserved3[i]);
+	}
+}
+
+void
+isp_put_request_t2(struct ispsoftc *isp, ispreqt2_t *src, ispreqt2_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
+	ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
+	ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
+	ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
+	ISP_IOXPUT_16(isp, src->req_flags,  &dst->req_flags);
+	ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	for (i = 0; i < ASIZE(src->req_cdb); i++) {
+		ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
+	}
+	ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
 	for (i = 0; i < ISP_RQDSEG_T2; i++) {
-		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
-		    &tqdst->req_dataseg[i].ds_base);
-		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
-		    &tqdst->req_dataseg[i].ds_count);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
 	}
 }
 
 void
-isp_put_request_t3(struct ispsoftc *isp, ispreqt3_t *tqsrc, ispreqt3_t *tqdst)
+isp_put_request_t2e(struct ispsoftc *isp, ispreqt2e_t *src, ispreqt2e_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &tqsrc->req_header, &tqdst->req_header);
-	ISP_IOXPUT_32(isp, tqsrc->req_handle, &tqdst->req_handle);
-	ISP_IOXPUT_8(isp, tqsrc->req_lun_trn, &tqdst->req_lun_trn);
-	ISP_IOXPUT_8(isp, tqsrc->req_target, &tqdst->req_target);
-	ISP_IOXPUT_16(isp, tqsrc->req_scclun, &tqdst->req_scclun);
-	ISP_IOXPUT_16(isp, tqsrc->req_flags,  &tqdst->req_flags);
-	ISP_IOXPUT_16(isp, tqsrc->req_reserved, &tqdst->req_reserved);
-	ISP_IOXPUT_16(isp, tqsrc->req_time, &tqdst->req_time);
-	ISP_IOXPUT_16(isp, tqsrc->req_seg_count, &tqdst->req_seg_count);
-	for (i = 0; i < 16; i++) {
-		ISP_IOXPUT_8(isp, tqsrc->req_cdb[i], &tqdst->req_cdb[i]);
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
+	ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
+	ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
+	ISP_IOXPUT_16(isp, src->req_flags,  &dst->req_flags);
+	ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	for (i = 0; i < ASIZE(src->req_cdb); i++) {
+		ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
+	}
+	ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
+	for (i = 0; i < ISP_RQDSEG_T2; i++) {
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
 	}
-	ISP_IOXPUT_32(isp, tqsrc->req_totalcnt, &tqdst->req_totalcnt);
+}
+
+void
+isp_put_request_t3(struct ispsoftc *isp, ispreqt3_t *src, ispreqt3_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
+	ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
+	ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
+	ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
+	ISP_IOXPUT_16(isp, src->req_flags,  &dst->req_flags);
+	ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	for (i = 0; i < ASIZE(src->req_cdb); i++) {
+		ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
+	}
+	ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
+	for (i = 0; i < ISP_RQDSEG_T3; i++) {
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
+		    &dst->req_dataseg[i].ds_basehi);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
+	}
+}
+
+void
+isp_put_request_t3e(struct ispsoftc *isp, ispreqt3e_t *src, ispreqt3e_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
+	ISP_IOXPUT_16(isp, src->req_target, &dst->req_target);
+	ISP_IOXPUT_16(isp, src->req_scclun, &dst->req_scclun);
+	ISP_IOXPUT_16(isp, src->req_flags,  &dst->req_flags);
+	ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	for (i = 0; i < ASIZE(src->req_cdb); i++) {
+		ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
+	}
+	ISP_IOXPUT_32(isp, src->req_totalcnt, &dst->req_totalcnt);
 	for (i = 0; i < ISP_RQDSEG_T3; i++) {
-		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_base,
-		    &tqdst->req_dataseg[i].ds_base);
-		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_basehi,
-		    &tqdst->req_dataseg[i].ds_basehi);
-		ISP_IOXPUT_32(isp, tqsrc->req_dataseg[i].ds_count,
-		    &tqdst->req_dataseg[i].ds_count);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
+		    &dst->req_dataseg[i].ds_basehi);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
 	}
 }
 
 void
-isp_put_extended_request(struct ispsoftc *isp, ispextreq_t *xqsrc,
-    ispextreq_t *xqdst)
+isp_put_extended_request(struct ispsoftc *isp, ispextreq_t *src, ispextreq_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &xqsrc->req_header, &xqdst->req_header);
-	ISP_IOXPUT_32(isp, xqsrc->req_handle, &xqdst->req_handle);
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_target);
-		ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_lun_trn);
+		ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_target);
+		ISP_IOXPUT_8(isp, src->req_target, &dst->req_lun_trn);
 	} else {
-		ISP_IOXPUT_8(isp, xqsrc->req_lun_trn, &xqdst->req_lun_trn);
-		ISP_IOXPUT_8(isp, xqsrc->req_target, &xqdst->req_target);
+		ISP_IOXPUT_8(isp, src->req_lun_trn, &dst->req_lun_trn);
+		ISP_IOXPUT_8(isp, src->req_target, &dst->req_target);
 	}
-	ISP_IOXPUT_16(isp, xqsrc->req_cdblen, &xqdst->req_cdblen);
-	ISP_IOXPUT_16(isp, xqsrc->req_flags, &xqdst->req_flags);
-	ISP_IOXPUT_16(isp, xqsrc->req_time, &xqdst->req_time);
-	ISP_IOXPUT_16(isp, xqsrc->req_seg_count, &xqdst->req_seg_count);
-	for (i = 0; i < 44; i++) {
-		ISP_IOXPUT_8(isp, xqsrc->req_cdb[i], &xqdst->req_cdb[i]);
+	ISP_IOXPUT_16(isp, src->req_cdblen, &dst->req_cdblen);
+	ISP_IOXPUT_16(isp, src->req_flags, &dst->req_flags);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	for (i = 0; i < ASIZE(src->req_cdb); i++) {
+		ISP_IOXPUT_8(isp, src->req_cdb[i], &dst->req_cdb[i]);
 	}
 }
 
 void
-isp_put_cont_req(struct ispsoftc *isp, ispcontreq_t *cqsrc, ispcontreq_t *cqdst)
+isp_put_request_t7(struct ispsoftc *isp, ispreqt7_t *src, ispreqt7_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
+	u_int32_t *a, *b;
+
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXPUT_32(isp, src->req_handle, &dst->req_handle);
+	ISP_IOXPUT_16(isp, src->req_nphdl, &dst->req_nphdl);
+	ISP_IOXPUT_16(isp, src->req_time, &dst->req_time);
+	ISP_IOXPUT_16(isp, src->req_seg_count, &dst->req_seg_count);
+	ISP_IOXPUT_16(isp, src->req_reserved, &dst->req_reserved);
+	a = (u_int32_t *) src->req_lun;
+	b = (u_int32_t *) dst->req_lun;
+	for (i = 0; i < (ASIZE(src->req_lun) >> 2); i++ ) {
+		*b++ = ISP_SWAP32(isp, *a++);
+	}
+	ISP_IOXPUT_8(isp, src->req_alen_datadir, &dst->req_alen_datadir);
+	ISP_IOXPUT_8(isp, src->req_task_management, &dst->req_task_management);
+	ISP_IOXPUT_8(isp, src->req_task_attribute, &dst->req_task_attribute);
+	ISP_IOXPUT_8(isp, src->req_crn, &dst->req_crn);
+	a = (u_int32_t *) src->req_cdb;
+	b = (u_int32_t *) dst->req_cdb;
+	for (i = 0; i < (ASIZE(src->req_cdb) >> 2); i++) {
+		*b++ = ISP_SWAP32(isp, *a++);
+	}
+	ISP_IOXPUT_32(isp, src->req_dl, &dst->req_dl);
+	ISP_IOXPUT_16(isp, src->req_tidlo, &dst->req_tidlo);
+	ISP_IOXPUT_8(isp, src->req_tidhi, &dst->req_tidhi);
+	ISP_IOXPUT_8(isp, src->req_vpidx, &dst->req_vpidx);
+	ISP_IOXPUT_32(isp, src->req_dataseg.ds_base,
+	    &dst->req_dataseg.ds_base);
+	ISP_IOXPUT_32(isp, src->req_dataseg.ds_basehi,
+	    &dst->req_dataseg.ds_basehi);
+	ISP_IOXPUT_32(isp, src->req_dataseg.ds_count,
+	    &dst->req_dataseg.ds_count);
+}
+
+void
+isp_put_24xx_abrt(struct ispsoftc *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->abrt_header, &dst->abrt_header);
+	ISP_IOXPUT_32(isp, src->abrt_handle, &dst->abrt_handle);
+	ISP_IOXPUT_16(isp, src->abrt_nphdl, &dst->abrt_nphdl);
+	ISP_IOXPUT_16(isp, src->abrt_options, &dst->abrt_options);
+	ISP_IOXPUT_32(isp, src->abrt_cmd_handle, &dst->abrt_cmd_handle);
+	for (i = 0; i < ASIZE(src->abrt_reserved); i++) {
+		ISP_IOXPUT_8(isp, src->abrt_reserved[i],
+		    &dst->abrt_reserved[i]);
+	}
+	ISP_IOXPUT_16(isp, src->abrt_tidlo, &dst->abrt_tidlo);
+	ISP_IOXPUT_8(isp, src->abrt_tidhi, &dst->abrt_tidhi);
+	ISP_IOXPUT_8(isp, src->abrt_vpidx, &dst->abrt_vpidx);
+	for (i = 0; i < ASIZE(src->abrt_reserved1); i++) {
+		ISP_IOXPUT_8(isp, src->abrt_reserved1[i],
+		    &dst->abrt_reserved1[i]);
+	}
+}
+
+void
+isp_put_cont_req(struct ispsoftc *isp, ispcontreq_t *src, ispcontreq_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
 	for (i = 0; i < ISP_CDSEG; i++) {
-		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
-		    &cqdst->req_dataseg[i].ds_base);
-		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
-		    &cqdst->req_dataseg[i].ds_count);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
 	}
 }
 
 void
-isp_put_cont64_req(struct ispsoftc *isp, ispcontreq64_t *cqsrc,
-    ispcontreq64_t *cqdst)
+isp_put_cont64_req(struct ispsoftc *isp, ispcontreq64_t *src, ispcontreq64_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &cqsrc->req_header, &cqdst->req_header);
+	isp_put_hdr(isp, &src->req_header, &dst->req_header);
 	for (i = 0; i < ISP_CDSEG64; i++) {
-		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_base,
-		    &cqdst->req_dataseg[i].ds_base);
-		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_basehi,
-		    &cqdst->req_dataseg[i].ds_basehi);
-		ISP_IOXPUT_32(isp, cqsrc->req_dataseg[i].ds_count,
-		    &cqdst->req_dataseg[i].ds_count);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_base,
+		    &dst->req_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_basehi,
+		    &dst->req_dataseg[i].ds_basehi);
+		ISP_IOXPUT_32(isp, src->req_dataseg[i].ds_count,
+		    &dst->req_dataseg[i].ds_count);
 	}
 }
 
 void
-isp_get_response(struct ispsoftc *isp, ispstatusreq_t *spsrc,
-    ispstatusreq_t *spdst)
+isp_get_response(struct ispsoftc *isp, ispstatusreq_t *src, ispstatusreq_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &spsrc->req_header, &spdst->req_header);
-	ISP_IOXGET_32(isp, &spsrc->req_handle, spdst->req_handle);
-	ISP_IOXGET_16(isp, &spsrc->req_scsi_status, spdst->req_scsi_status);
-	ISP_IOXGET_16(isp, &spsrc->req_completion_status,
-	    spdst->req_completion_status);
-	ISP_IOXGET_16(isp, &spsrc->req_state_flags, spdst->req_state_flags);
-	ISP_IOXGET_16(isp, &spsrc->req_status_flags, spdst->req_status_flags);
-	ISP_IOXGET_16(isp, &spsrc->req_time, spdst->req_time);
-	ISP_IOXGET_16(isp, &spsrc->req_sense_len, spdst->req_sense_len);
-	ISP_IOXGET_32(isp, &spsrc->req_resid, spdst->req_resid);
+	isp_get_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
+	ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
+	ISP_IOXGET_16(isp, &src->req_completion_status,
+	    dst->req_completion_status);
+	ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
+	ISP_IOXGET_16(isp, &src->req_status_flags, dst->req_status_flags);
+	ISP_IOXGET_16(isp, &src->req_time, dst->req_time);
+	ISP_IOXGET_16(isp, &src->req_sense_len, dst->req_sense_len);
+	ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
 	for (i = 0; i < 8; i++) {
-		ISP_IOXGET_8(isp, &spsrc->req_response[i],
-		    spdst->req_response[i]);
+		ISP_IOXGET_8(isp, &src->req_response[i],
+		    dst->req_response[i]);
 	}
 	for (i = 0; i < 32; i++) {
-		ISP_IOXGET_8(isp, &spsrc->req_sense_data[i],
-		    spdst->req_sense_data[i]);
+		ISP_IOXGET_8(isp, &src->req_sense_data[i],
+		    dst->req_sense_data[i]);
+	}
+}
+
+void
+isp_get_24xx_response(struct ispsoftc *isp, isp24xx_statusreq_t *src,
+    isp24xx_statusreq_t *dst)
+{
+	int i;
+	u_int32_t *s, *d;
+
+	isp_get_hdr(isp, &src->req_header, &dst->req_header);
+	ISP_IOXGET_32(isp, &src->req_handle, dst->req_handle);
+	ISP_IOXGET_16(isp, &src->req_completion_status,
+	    dst->req_completion_status);
+	ISP_IOXGET_16(isp, &src->req_oxid, dst->req_oxid);
+	ISP_IOXGET_32(isp, &src->req_resid, dst->req_resid);
+	ISP_IOXGET_16(isp, &src->req_reserved0, dst->req_reserved0);
+	ISP_IOXGET_16(isp, &src->req_state_flags, dst->req_state_flags);
+	ISP_IOXGET_16(isp, &src->req_reserved1, dst->req_reserved1);
+	ISP_IOXGET_16(isp, &src->req_scsi_status, dst->req_scsi_status);
+	ISP_IOXGET_32(isp, &src->req_fcp_residual, dst->req_fcp_residual);
+	ISP_IOXGET_32(isp, &src->req_sense_len, dst->req_sense_len);
+	ISP_IOXGET_32(isp, &src->req_response_len, dst->req_response_len);
+	s = (u_int32_t *)src->req_rsp_sense;
+	d = (u_int32_t *)dst->req_rsp_sense;
+	for (i = 0; i < (ASIZE(src->req_rsp_sense) >> 2); i++) {
+		d[i] = ISP_SWAP32(isp, s[i]);
 	}
 }
 
 void
-isp_get_response_x(struct ispsoftc *isp, ispstatus_cont_t *cpsrc,
-    ispstatus_cont_t *cpdst)
+isp_get_24xx_abrt(struct ispsoftc *isp, isp24xx_abrt_t *src, isp24xx_abrt_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &cpsrc->req_header, &cpdst->req_header);
-	for (i = 0; i < 60; i++) {
-		ISP_IOXGET_8(isp, &cpsrc->req_sense_data[i],
-		    cpdst->req_sense_data[i]);
+	isp_get_hdr(isp, &src->abrt_header, &dst->abrt_header);
+	ISP_IOXGET_32(isp, &src->abrt_handle, dst->abrt_handle);
+	ISP_IOXGET_16(isp, &src->abrt_nphdl, dst->abrt_nphdl);
+	ISP_IOXGET_16(isp, &src->abrt_options, dst->abrt_options);
+	ISP_IOXGET_32(isp, &src->abrt_cmd_handle, dst->abrt_cmd_handle);
+	for (i = 0; i < ASIZE(src->abrt_reserved); i++) {
+		ISP_IOXGET_8(isp, &src->abrt_reserved[i],
+		    dst->abrt_reserved[i]);
+	}
+	ISP_IOXGET_16(isp, &src->abrt_tidlo, dst->abrt_tidlo);
+	ISP_IOXGET_8(isp, &src->abrt_tidhi, dst->abrt_tidhi);
+	ISP_IOXGET_8(isp, &src->abrt_vpidx, dst->abrt_vpidx);
+	for (i = 0; i < ASIZE(src->abrt_reserved1); i++) {
+		ISP_IOXGET_8(isp, &src->abrt_reserved1[i],
+		    dst->abrt_reserved1[i]);
 	}
 }
 
+
 void
 isp_get_rio2(struct ispsoftc *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &r2src->req_header, &r2dst->req_header);
-	if (r2dst->req_header.rqs_seqno > 30)
+	isp_get_hdr(isp, &r2src->req_header, &r2dst->req_header);
+	if (r2dst->req_header.rqs_seqno > 30) {
 		r2dst->req_header.rqs_seqno = 30;
+	}
 	for (i = 0; i < r2dst->req_header.rqs_seqno; i++) {
 		ISP_IOXGET_16(isp, &r2src->req_handles[i],
 		    r2dst->req_handles[i]);
@@ -475,53 +759,128 @@ isp_get_rio2(struct ispsoftc *isp, isp_rio2_t *r2src, isp_rio2_t *r2dst)
 }
 
 void
-isp_put_icb(struct ispsoftc *isp, isp_icb_t *Is, isp_icb_t *Id)
+isp_put_icb(struct ispsoftc *isp, isp_icb_t *src, isp_icb_t *dst)
+{
+	int i;
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_reserved0);
+		ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_version);
+	} else {
+		ISP_IOXPUT_8(isp, src->icb_version, &dst->icb_version);
+		ISP_IOXPUT_8(isp, src->icb_reserved0, &dst->icb_reserved0);
+	}
+	ISP_IOXPUT_16(isp, src->icb_fwoptions, &dst->icb_fwoptions);
+	ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
+	ISP_IOXPUT_16(isp, src->icb_maxalloc, &dst->icb_maxalloc);
+	ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_delay);
+		ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_count);
+	} else {
+		ISP_IOXPUT_8(isp, src->icb_retry_count, &dst->icb_retry_count);
+		ISP_IOXPUT_8(isp, src->icb_retry_delay, &dst->icb_retry_delay);
+	}
+	for (i = 0; i < 8; i++) {
+		ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_logintime);
+		ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_iqdevtype);
+	} else {
+		ISP_IOXPUT_8(isp, src->icb_iqdevtype, &dst->icb_iqdevtype);
+		ISP_IOXPUT_8(isp, src->icb_logintime, &dst->icb_logintime);
+	}
+	for (i = 0; i < 8; i++) {
+		ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
+	ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
+	ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
+	ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
+	}
+	for (i = 0; i < 4; i++) {
+		ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_lunenables, &dst->icb_lunenables);
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_icnt);
+		ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_ccnt);
+	} else {
+		ISP_IOXPUT_8(isp, src->icb_ccnt, &dst->icb_ccnt);
+		ISP_IOXPUT_8(isp, src->icb_icnt, &dst->icb_icnt);
+	}
+	ISP_IOXPUT_16(isp, src->icb_lunetimeout, &dst->icb_lunetimeout);
+	ISP_IOXPUT_16(isp, src->icb_reserved1, &dst->icb_reserved1);
+	ISP_IOXPUT_16(isp, src->icb_xfwoptions, &dst->icb_xfwoptions);
+	if (ISP_IS_SBUS(isp)) {
+		ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_idelaytimer);
+		ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_racctimer);
+	} else {
+		ISP_IOXPUT_8(isp, src->icb_racctimer, &dst->icb_racctimer);
+		ISP_IOXPUT_8(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
+	}
+	ISP_IOXPUT_16(isp, src->icb_zfwoptions, &dst->icb_zfwoptions);
+}
+
+void
+isp_put_icb_2400(struct ispsoftc *isp, isp_icb_2400_t *src, isp_icb_2400_t *dst)
 {
 	int i;
-	ISP_SWAP8(Is->icb_version, Is->icb_reserved0);
-	ISP_IOXPUT_8(isp, Is->icb_version, &Id->icb_version);
-	ISP_IOXPUT_8(isp, Is->icb_reserved0, &Id->icb_reserved0);
-	ISP_IOXPUT_16(isp, Is->icb_fwoptions, &Id->icb_fwoptions);
-	ISP_IOXPUT_16(isp, Is->icb_maxfrmlen, &Id->icb_maxfrmlen);
-	ISP_IOXPUT_16(isp, Is->icb_maxalloc, &Id->icb_maxalloc);
-	ISP_IOXPUT_16(isp, Is->icb_execthrottle, &Id->icb_execthrottle);
-	ISP_SWAP8(Is->icb_retry_count, Is->icb_retry_delay);
-	ISP_IOXPUT_8(isp, Is->icb_retry_count, &Id->icb_retry_count);
-	ISP_IOXPUT_8(isp, Is->icb_retry_delay, &Id->icb_retry_delay);
+	ISP_IOXPUT_16(isp, src->icb_version, &dst->icb_version);
+	ISP_IOXPUT_16(isp, src->icb_reserved0, &dst->icb_reserved0);
+	ISP_IOXPUT_16(isp, src->icb_maxfrmlen, &dst->icb_maxfrmlen);
+	ISP_IOXPUT_16(isp, src->icb_execthrottle, &dst->icb_execthrottle);
+	ISP_IOXPUT_16(isp, src->icb_xchgcnt, &dst->icb_xchgcnt);
+	ISP_IOXPUT_16(isp, src->icb_hardaddr, &dst->icb_hardaddr);
 	for (i = 0; i < 8; i++) {
-		ISP_IOXPUT_8(isp, Is->icb_portname[i], &Id->icb_portname[i]);
+		ISP_IOXPUT_8(isp, src->icb_portname[i], &dst->icb_portname[i]);
 	}
-	ISP_IOXPUT_16(isp, Is->icb_hardaddr, &Id->icb_hardaddr);
-	ISP_SWAP8(Is->icb_iqdevtype, Is->icb_logintime);
-	ISP_IOXPUT_8(isp, Is->icb_iqdevtype, &Id->icb_iqdevtype);
-	ISP_IOXPUT_8(isp, Is->icb_logintime, &Id->icb_logintime);
 	for (i = 0; i < 8; i++) {
-		ISP_IOXPUT_8(isp, Is->icb_nodename[i], &Id->icb_nodename[i]);
+		ISP_IOXPUT_8(isp, src->icb_nodename[i], &dst->icb_nodename[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_rspnsin, &dst->icb_rspnsin);
+	ISP_IOXPUT_16(isp, src->icb_rqstout, &dst->icb_rqstout);
+	ISP_IOXPUT_16(isp, src->icb_retry_count, &dst->icb_retry_count);
+	ISP_IOXPUT_16(isp, src->icb_priout, &dst->icb_priout);
+	ISP_IOXPUT_16(isp, src->icb_rsltqlen, &dst->icb_rsltqlen);
+	ISP_IOXPUT_16(isp, src->icb_rqstqlen, &dst->icb_rqstqlen);
+	ISP_IOXPUT_16(isp, src->icb_ldn_nols, &dst->icb_ldn_nols);
+	ISP_IOXPUT_16(isp, src->icb_prqstqlen, &dst->icb_prqstqlen);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXPUT_16(isp, src->icb_rqstaddr[i], &dst->icb_rqstaddr[i]);
+	}
+	for (i = 0; i < 4; i++) {
+		ISP_IOXPUT_16(isp, src->icb_respaddr[i], &dst->icb_respaddr[i]);
 	}
-	ISP_IOXPUT_16(isp, Is->icb_rqstout, &Id->icb_rqstout);
-	ISP_IOXPUT_16(isp, Is->icb_rspnsin, &Id->icb_rspnsin);
-	ISP_IOXPUT_16(isp, Is->icb_rqstqlen, &Id->icb_rqstqlen);
-	ISP_IOXPUT_16(isp, Is->icb_rsltqlen, &Id->icb_rsltqlen);
 	for (i = 0; i < 4; i++) {
-		ISP_IOXPUT_16(isp, Is->icb_rqstaddr[i], &Id->icb_rqstaddr[i]);
+		ISP_IOXPUT_16(isp, src->icb_priaddr[i], &dst->icb_priaddr[i]);
 	}
 	for (i = 0; i < 4; i++) {
-		ISP_IOXPUT_16(isp, Is->icb_respaddr[i], &Id->icb_respaddr[i]);
+		ISP_IOXPUT_16(isp, src->icb_reserved1[i],
+		    &dst->icb_reserved1[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_atio_in, &dst->icb_atio_in);
+	ISP_IOXPUT_16(isp, src->icb_atioqlen, &dst->icb_atioqlen);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXPUT_16(isp, src->icb_atioqaddr[i],
+		    &dst->icb_atioqaddr[i]);
+	}
+	ISP_IOXPUT_16(isp, src->icb_idelaytimer, &dst->icb_idelaytimer);
+	ISP_IOXPUT_16(isp, src->icb_logintime, &dst->icb_logintime);
+	ISP_IOXPUT_32(isp, src->icb_fwoptions1, &dst->icb_fwoptions1);
+	ISP_IOXPUT_32(isp, src->icb_fwoptions2, &dst->icb_fwoptions2);
+	ISP_IOXPUT_32(isp, src->icb_fwoptions3, &dst->icb_fwoptions3);
+	for (i = 0; i < 12; i++) {
+		ISP_IOXPUT_16(isp, src->icb_reserved2[i],
+		    &dst->icb_reserved2[i]);
 	}
-	ISP_IOXPUT_16(isp, Is->icb_lunenables, &Id->icb_lunenables);
-	ISP_SWAP8(Is->icb_ccnt, Is->icb_icnt);
-	ISP_IOXPUT_8(isp, Is->icb_ccnt, &Id->icb_ccnt);
-	ISP_IOXPUT_8(isp, Is->icb_icnt, &Id->icb_icnt);
-	ISP_IOXPUT_16(isp, Is->icb_lunetimeout, &Id->icb_lunetimeout);
-	ISP_IOXPUT_16(isp, Is->icb_xfwoptions, &Id->icb_xfwoptions);
-	ISP_SWAP8(Is->icb_racctimer, Is->icb_idelaytimer);
-	ISP_IOXPUT_8(isp, Is->icb_racctimer, &Id->icb_racctimer);
-	ISP_IOXPUT_8(isp, Is->icb_idelaytimer, &Id->icb_idelaytimer);
-	ISP_IOXPUT_16(isp, Is->icb_zfwoptions, &Id->icb_zfwoptions);
 }
 
 void
-isp_get_pdb(struct ispsoftc *isp, isp_pdb_t *src, isp_pdb_t *dst)
+isp_get_pdb_21xx(struct ispsoftc *isp, isp_pdb_21xx_t *src, isp_pdb_21xx_t *dst)
 {
 	int i;
 	ISP_IOXGET_16(isp, &src->pdb_options, dst->pdb_options);
@@ -574,29 +933,204 @@ isp_get_pdb(struct ispsoftc *isp, isp_pdb_t *src, isp_pdb_t *dst)
 	ISP_IOXGET_16(isp, &src->pdb_sl_ptr, dst->pdb_sl_ptr);
 }
 
+void
+isp_get_pdb_24xx(struct ispsoftc *isp, isp_pdb_24xx_t *src, isp_pdb_24xx_t *dst)
+{
+	int i;
+	ISP_IOXGET_16(isp, &src->pdb_flags, dst->pdb_flags);
+        ISP_IOXGET_8(isp, &src->pdb_curstate, dst->pdb_curstate);
+        ISP_IOXGET_8(isp, &src->pdb_laststate, dst->pdb_laststate);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXGET_8(isp, &src->pdb_hardaddr_bits[i],
+		    dst->pdb_hardaddr_bits[i]);
+	}
+	for (i = 0; i < 4; i++) {
+		ISP_IOXGET_8(isp, &src->pdb_portid_bits[i],
+		    dst->pdb_portid_bits[i]);
+	}
+	ISP_IOXGET_16(isp, &src->pdb_retry_timer, dst->pdb_retry_timer);
+	ISP_IOXGET_16(isp, &src->pdb_handle, dst->pdb_handle);
+	ISP_IOXGET_16(isp, &src->pdb_rcv_dsize, dst->pdb_rcv_dsize);
+	ISP_IOXGET_16(isp, &src->pdb_reserved0, dst->pdb_reserved0);
+	ISP_IOXGET_16(isp, &src->pdb_prli_svc0, dst->pdb_prli_svc0);
+	ISP_IOXGET_16(isp, &src->pdb_prli_svc3, dst->pdb_prli_svc3);
+	for (i = 0; i < 8; i++) {
+		ISP_IOXGET_8(isp, &src->pdb_nodename[i], dst->pdb_nodename[i]);
+	}
+	for (i = 0; i < 8; i++) {
+		ISP_IOXGET_8(isp, &src->pdb_portname[i], dst->pdb_portname[i]);
+	}
+	for (i = 0; i < 24; i++) {
+		ISP_IOXGET_8(isp, &src->pdb_reserved1[i],
+		    dst->pdb_reserved1[i]);
+	}
+}
 
 /*
- * CT_HDR canonicalization- only needed for SNS responses
+ * PLOGI/LOGO IOCB canonicalization
  */
+
 void
-isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
+isp_get_plogx(struct ispsoftc *isp, isp_plogx_t *src, isp_plogx_t *dst)
+{
+	int i;
+	isp_get_hdr(isp, &src->plogx_header, &dst->plogx_header);
+	ISP_IOXGET_32(isp, &src->plogx_handle, dst->plogx_handle);
+	ISP_IOXGET_16(isp, &src->plogx_status, dst->plogx_status);
+	ISP_IOXGET_16(isp, &src->plogx_nphdl, dst->plogx_nphdl);
+	ISP_IOXGET_16(isp, &src->plogx_flags, dst->plogx_flags);
+	ISP_IOXGET_16(isp, &src->plogx_vphdl, dst->plogx_vphdl);
+	ISP_IOXGET_16(isp, &src->plogx_portlo, dst->plogx_portlo);
+	ISP_IOXGET_16(isp, &src->plogx_rspsz_porthi, dst->plogx_rspsz_porthi);
+	for (i = 0; i < 11; i++) {
+		ISP_IOXGET_16(isp, &src->plogx_ioparm[i].lo16,
+		    dst->plogx_ioparm[i].lo16);
+		ISP_IOXGET_16(isp, &src->plogx_ioparm[i].hi16,
+		    dst->plogx_ioparm[i].hi16);
+	}
+}
+
+void
+isp_put_plogx(struct ispsoftc *isp, isp_plogx_t *src, isp_plogx_t *dst)
 {
-	ISP_IOXGET_8(isp, &src->ct_revision, dst->ct_revision);
-	ISP_IOXGET_8(isp, &src->ct_portid[0], dst->ct_portid[0]);
-	ISP_IOXGET_8(isp, &src->ct_portid[1], dst->ct_portid[1]);
-	ISP_IOXGET_8(isp, &src->ct_portid[2], dst->ct_portid[2]);
-	ISP_IOXGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
-	ISP_IOXGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
-	ISP_IOXGET_8(isp, &src->ct_options, dst->ct_options);
-	ISP_IOXGET_8(isp, &src->ct_res0, dst->ct_res0);
-	ISP_IOXGET_16(isp, &src->ct_response, dst->ct_response);
-	dst->ct_response = (dst->ct_response << 8) | (dst->ct_response >> 8);
-	ISP_IOXGET_16(isp, &src->ct_resid, dst->ct_resid);
-	dst->ct_resid = (dst->ct_resid << 8) | (dst->ct_resid >> 8);
-	ISP_IOXGET_8(isp, &src->ct_res1, dst->ct_res1);
-	ISP_IOXGET_8(isp, &src->ct_reason, dst->ct_reason);
-	ISP_IOXGET_8(isp, &src->ct_explanation, dst->ct_explanation);
-	ISP_IOXGET_8(isp, &src->ct_vunique, dst->ct_vunique);
+	int i;
+	isp_put_hdr(isp, &src->plogx_header, &dst->plogx_header);
+	ISP_IOXPUT_32(isp, src->plogx_handle, &dst->plogx_handle);
+	ISP_IOXPUT_16(isp, src->plogx_status, &dst->plogx_status);
+	ISP_IOXPUT_16(isp, src->plogx_nphdl, &dst->plogx_nphdl);
+	ISP_IOXPUT_16(isp, src->plogx_flags, &dst->plogx_flags);
+	ISP_IOXPUT_16(isp, src->plogx_vphdl, &dst->plogx_vphdl);
+	ISP_IOXPUT_16(isp, src->plogx_portlo, &dst->plogx_portlo);
+	ISP_IOXPUT_16(isp, src->plogx_rspsz_porthi, &dst->plogx_rspsz_porthi);
+	for (i = 0; i < 11; i++) {
+		ISP_IOXPUT_16(isp, src->plogx_ioparm[i].lo16,
+		    &dst->plogx_ioparm[i].lo16);
+		ISP_IOXPUT_16(isp, src->plogx_ioparm[i].hi16,
+		    &dst->plogx_ioparm[i].hi16);
+	}
+}
+
+/*
+ * CT Passthru canonicalization
+ */
+void
+isp_get_ct_pt(struct ispsoftc *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->ctp_header, &dst->ctp_header);
+	ISP_IOXGET_32(isp, &src->ctp_handle, dst->ctp_handle);
+	ISP_IOXGET_16(isp, &src->ctp_status, dst->ctp_status);
+	ISP_IOXGET_16(isp, &src->ctp_nphdl, dst->ctp_nphdl);
+	ISP_IOXGET_16(isp, &src->ctp_cmd_cnt, dst->ctp_cmd_cnt);
+	ISP_IOXGET_16(isp, &src->ctp_vpidx, dst->ctp_vpidx);
+	ISP_IOXGET_16(isp, &src->ctp_time, dst->ctp_time);
+	ISP_IOXGET_16(isp, &src->ctp_reserved0, dst->ctp_reserved0);
+	ISP_IOXGET_16(isp, &src->ctp_rsp_cnt, dst->ctp_rsp_cnt);
+	for (i = 0; i < 5; i++) {
+		ISP_IOXGET_16(isp, &src->ctp_reserved1[i],
+		    dst->ctp_reserved1[i]);
+	}
+	ISP_IOXGET_32(isp, &src->ctp_rsp_bcnt, dst->ctp_rsp_bcnt);
+	ISP_IOXGET_32(isp, &src->ctp_cmd_bcnt, dst->ctp_cmd_bcnt);
+	for (i = 0; i < 2; i++) {
+		ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_base,
+		    dst->ctp_dataseg[i].ds_base);
+		ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_basehi,
+		    dst->ctp_dataseg[i].ds_basehi);
+		ISP_IOXGET_32(isp, &src->ctp_dataseg[i].ds_count,
+		    dst->ctp_dataseg[i].ds_count);
+	}
+}
+
+void
+isp_get_ms(struct ispsoftc *isp, isp_ms_t *src, isp_ms_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->ms_header, &dst->ms_header);
+	ISP_IOXGET_32(isp, &src->ms_handle, dst->ms_handle);
+	ISP_IOXGET_16(isp, &src->ms_nphdl, dst->ms_nphdl);
+	ISP_IOXGET_16(isp, &src->ms_status, dst->ms_status);
+	ISP_IOXGET_16(isp, &src->ms_flags, dst->ms_flags);
+	ISP_IOXGET_16(isp, &src->ms_reserved1, dst->ms_reserved1);
+	ISP_IOXGET_16(isp, &src->ms_time, dst->ms_time);
+	ISP_IOXGET_16(isp, &src->ms_cmd_cnt, dst->ms_cmd_cnt);
+	ISP_IOXGET_16(isp, &src->ms_tot_cnt, dst->ms_tot_cnt);
+	ISP_IOXGET_8(isp, &src->ms_type, dst->ms_type);
+	ISP_IOXGET_8(isp, &src->ms_r_ctl, dst->ms_r_ctl);
+	ISP_IOXGET_16(isp, &src->ms_rxid, dst->ms_rxid);
+	ISP_IOXGET_16(isp, &src->ms_reserved2, dst->ms_reserved2);
+	ISP_IOXGET_32(isp, &src->ms_rsp_bcnt, dst->ms_rsp_bcnt);
+	ISP_IOXGET_32(isp, &src->ms_cmd_bcnt, dst->ms_cmd_bcnt);
+	for (i = 0; i < 2; i++) {
+		ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_base,
+		    dst->ms_dataseg[i].ds_base);
+		ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_basehi,
+		    dst->ms_dataseg[i].ds_basehi);
+		ISP_IOXGET_32(isp, &src->ms_dataseg[i].ds_count,
+		    dst->ms_dataseg[i].ds_count);
+	}
+}
+
+void
+isp_put_ct_pt(struct ispsoftc *isp, isp_ct_pt_t *src, isp_ct_pt_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->ctp_header, &dst->ctp_header);
+	ISP_IOXPUT_32(isp, src->ctp_handle, &dst->ctp_handle);
+	ISP_IOXPUT_16(isp, src->ctp_status, &dst->ctp_status);
+	ISP_IOXPUT_16(isp, src->ctp_nphdl, &dst->ctp_nphdl);
+	ISP_IOXPUT_16(isp, src->ctp_cmd_cnt, &dst->ctp_cmd_cnt);
+	ISP_IOXPUT_16(isp, src->ctp_vpidx, &dst->ctp_vpidx);
+	ISP_IOXPUT_16(isp, src->ctp_time, &dst->ctp_time);
+	ISP_IOXPUT_16(isp, src->ctp_reserved0, &dst->ctp_reserved0);
+	ISP_IOXPUT_16(isp, src->ctp_rsp_cnt, &dst->ctp_rsp_cnt);
+	for (i = 0; i < 5; i++) {
+		ISP_IOXPUT_16(isp, src->ctp_reserved1[i],
+		    &dst->ctp_reserved1[i]);
+	}
+	ISP_IOXPUT_32(isp, src->ctp_rsp_bcnt, &dst->ctp_rsp_bcnt);
+	ISP_IOXPUT_32(isp, src->ctp_cmd_bcnt, &dst->ctp_cmd_bcnt);
+	for (i = 0; i < 2; i++) {
+		ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_base,
+		    &dst->ctp_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_basehi,
+		    &dst->ctp_dataseg[i].ds_basehi);
+		ISP_IOXPUT_32(isp, src->ctp_dataseg[i].ds_count,
+		    &dst->ctp_dataseg[i].ds_count);
+	}
+}
+
+void
+isp_put_ms(struct ispsoftc *isp, isp_ms_t *src, isp_ms_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->ms_header, &dst->ms_header);
+	ISP_IOXPUT_32(isp, src->ms_handle, &dst->ms_handle);
+	ISP_IOXPUT_16(isp, src->ms_nphdl, &dst->ms_nphdl);
+	ISP_IOXPUT_16(isp, src->ms_status, &dst->ms_status);
+	ISP_IOXPUT_16(isp, src->ms_flags, &dst->ms_flags);
+	ISP_IOXPUT_16(isp, src->ms_reserved1, &dst->ms_reserved1);
+	ISP_IOXPUT_16(isp, src->ms_time, &dst->ms_time);
+	ISP_IOXPUT_16(isp, src->ms_cmd_cnt, &dst->ms_cmd_cnt);
+	ISP_IOXPUT_16(isp, src->ms_tot_cnt, &dst->ms_tot_cnt);
+	ISP_IOXPUT_8(isp, src->ms_type, &dst->ms_type);
+	ISP_IOXPUT_8(isp, src->ms_r_ctl, &dst->ms_r_ctl);
+	ISP_IOXPUT_16(isp, src->ms_rxid, &dst->ms_rxid);
+	ISP_IOXPUT_16(isp, src->ms_reserved2, &dst->ms_reserved2);
+	ISP_IOXPUT_32(isp, src->ms_rsp_bcnt, &dst->ms_rsp_bcnt);
+	ISP_IOXPUT_32(isp, src->ms_cmd_bcnt, &dst->ms_cmd_bcnt);
+	for (i = 0; i < 2; i++) {
+		ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_base,
+		    &dst->ms_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_basehi,
+		    &dst->ms_dataseg[i].ds_basehi);
+		ISP_IOXPUT_32(isp, src->ms_dataseg[i].ds_count,
+		    &dst->ms_dataseg[i].ds_count);
+	}
 }
 
 /*
@@ -774,330 +1308,969 @@ isp_get_ga_nxt_response(struct ispsoftc *isp, sns_ga_nxt_rsp_t *src,
 	}
 }
 
+void
+isp_get_els(struct ispsoftc *isp, els_t *src, els_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->els_hdr, &dst->els_hdr);
+	ISP_IOXGET_32(isp, &src->els_handle, dst->els_handle);
+	ISP_IOXGET_16(isp, &src->els_status, dst->els_status);
+	ISP_IOXGET_16(isp, &src->els_nphdl, dst->els_nphdl);
+	ISP_IOXGET_16(isp, &src->els_xmit_dsd_count, dst->els_xmit_dsd_count);
+	ISP_IOXGET_8(isp, &src->els_vphdl, dst->els_vphdl);
+	ISP_IOXGET_8(isp, &src->els_sof, dst->els_sof);
+	ISP_IOXGET_32(isp, &src->els_rxid, dst->els_rxid);
+	ISP_IOXGET_16(isp, &src->els_recv_dsd_count, dst->els_recv_dsd_count);
+	ISP_IOXGET_8(isp, &src->els_opcode, dst->els_opcode);
+	ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved1);
+	ISP_IOXGET_8(isp, &src->els_did_lo, dst->els_did_lo);
+	ISP_IOXGET_8(isp, &src->els_did_mid, dst->els_did_mid);
+	ISP_IOXGET_8(isp, &src->els_did_hi, dst->els_did_hi);
+	ISP_IOXGET_8(isp, &src->els_reserved2, dst->els_reserved2);
+	ISP_IOXGET_16(isp, &src->els_reserved3, dst->els_reserved3);
+	ISP_IOXGET_16(isp, &src->els_ctl_flags, dst->els_ctl_flags);
+	ISP_IOXGET_32(isp, &src->els_bytecnt, dst->els_bytecnt);
+	ISP_IOXGET_32(isp, &src->els_subcode1, dst->els_subcode1);
+	ISP_IOXGET_32(isp, &src->els_subcode2, dst->els_subcode2);
+	for (i = 0; i < 20; i++) {
+		ISP_IOXGET_8(isp, &src->els_reserved4[i],
+		    dst->els_reserved4[i]);
+	}
+}
+
+void
+isp_put_els(struct ispsoftc *isp, els_t *src, els_t *dst)
+{
+	isp_put_hdr(isp, &src->els_hdr, &dst->els_hdr);
+	ISP_IOXPUT_32(isp, src->els_handle, &dst->els_handle);
+	ISP_IOXPUT_16(isp, src->els_status, &dst->els_status);
+	ISP_IOXPUT_16(isp, src->els_nphdl, &dst->els_nphdl);
+	ISP_IOXPUT_16(isp, src->els_xmit_dsd_count, &dst->els_xmit_dsd_count);
+	ISP_IOXPUT_8(isp, src->els_vphdl, &dst->els_vphdl);
+	ISP_IOXPUT_8(isp, src->els_sof, &dst->els_sof);
+	ISP_IOXPUT_32(isp, src->els_rxid, &dst->els_rxid);
+	ISP_IOXPUT_16(isp, src->els_recv_dsd_count, &dst->els_recv_dsd_count);
+	ISP_IOXPUT_8(isp, src->els_opcode, &dst->els_opcode);
+	ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved1);
+	ISP_IOXPUT_8(isp, src->els_did_lo, &dst->els_did_lo);
+	ISP_IOXPUT_8(isp, src->els_did_mid, &dst->els_did_mid);
+	ISP_IOXPUT_8(isp, src->els_did_hi, &dst->els_did_hi);
+	ISP_IOXPUT_8(isp, src->els_reserved2, &dst->els_reserved2);
+	ISP_IOXPUT_16(isp, src->els_reserved3, &dst->els_reserved3);
+	ISP_IOXPUT_16(isp, src->els_ctl_flags, &dst->els_ctl_flags);
+	ISP_IOXPUT_32(isp, src->els_recv_bytecnt, &dst->els_recv_bytecnt);
+	ISP_IOXPUT_32(isp, src->els_xmit_bytecnt, &dst->els_xmit_bytecnt);
+	ISP_IOXPUT_32(isp, src->els_xmit_dsd_length, &dst->els_xmit_dsd_length);
+	ISP_IOXPUT_16(isp, src->els_xmit_dsd_a1500, &dst->els_xmit_dsd_a1500);
+	ISP_IOXPUT_16(isp, src->els_xmit_dsd_a3116, &dst->els_xmit_dsd_a3116);
+	ISP_IOXPUT_16(isp, src->els_xmit_dsd_a4732, &dst->els_xmit_dsd_a4732);
+	ISP_IOXPUT_16(isp, src->els_xmit_dsd_a6348, &dst->els_xmit_dsd_a6348);
+	ISP_IOXPUT_32(isp, src->els_recv_dsd_length, &dst->els_recv_dsd_length);
+	ISP_IOXPUT_16(isp, src->els_recv_dsd_a1500, &dst->els_recv_dsd_a1500);
+	ISP_IOXPUT_16(isp, src->els_recv_dsd_a3116, &dst->els_recv_dsd_a3116);
+	ISP_IOXPUT_16(isp, src->els_recv_dsd_a4732, &dst->els_recv_dsd_a4732);
+	ISP_IOXPUT_16(isp, src->els_recv_dsd_a6348, &dst->els_recv_dsd_a6348);
+}
+
+/*
+ * FC Structure Canonicalization
+ */
+
+void
+isp_get_fc_hdr(struct ispsoftc *isp, fc_hdr_t *src, fc_hdr_t *dst)
+{
+        ISP_IOZGET_8(isp, &src->r_ctl, dst->r_ctl);
+        ISP_IOZGET_8(isp, &src->d_id[0], dst->d_id[0]);
+        ISP_IOZGET_8(isp, &src->d_id[1], dst->d_id[1]);
+        ISP_IOZGET_8(isp, &src->d_id[2], dst->d_id[2]);
+        ISP_IOZGET_8(isp, &src->cs_ctl, dst->cs_ctl);
+        ISP_IOZGET_8(isp, &src->s_id[0], dst->s_id[0]);
+        ISP_IOZGET_8(isp, &src->s_id[1], dst->s_id[1]);
+        ISP_IOZGET_8(isp, &src->s_id[2], dst->s_id[2]);
+        ISP_IOZGET_8(isp, &src->type, dst->type);
+        ISP_IOZGET_8(isp, &src->f_ctl, dst->f_ctl);
+        ISP_IOZGET_8(isp, &src->seq_id, dst->seq_id);
+        ISP_IOZGET_8(isp, &src->df_ctl, dst->df_ctl);
+        ISP_IOZGET_16(isp, &src->seq_cnt, dst->seq_cnt);
+	/* XXX SOMETHING WAS AND STILL CONTINUES WRONG HERE XXX */
+#if	0
+        ISP_IOZGET_16(isp, &src->ox_id, dst->ox_id);
+        ISP_IOZGET_16(isp, &src->rx_id, dst->rx_id);
+#else
+        ISP_IOZGET_32(isp, &src->ox_id, dst->parameter);
+        dst->ox_id = dst->parameter;
+        dst->rx_id = dst->parameter >> 16;
+#endif
+        ISP_IOZGET_32(isp, &src->parameter, dst->parameter);
+}
+
+void
+isp_get_fcp_cmnd_iu(struct ispsoftc *isp, fcp_cmnd_iu_t *src, fcp_cmnd_iu_t *dst)
+{
+	int i;
+
+	for (i = 0; i < 8; i++) {
+		ISP_IOZGET_8(isp, &src->fcp_cmnd_lun[i], dst->fcp_cmnd_lun[i]);
+	}
+        ISP_IOZGET_8(isp, &src->fcp_cmnd_crn, dst->fcp_cmnd_crn);
+        ISP_IOZGET_8(isp, &src->fcp_cmnd_task_attribute,
+	    dst->fcp_cmnd_task_attribute);
+        ISP_IOZGET_8(isp, &src->fcp_cmnd_task_management,
+	    dst->fcp_cmnd_task_management);
+        ISP_IOZGET_8(isp, &src->fcp_cmnd_alen_datadir,
+	    dst->fcp_cmnd_alen_datadir);
+	for (i = 0; i < 16; i++) {
+		ISP_IOZGET_8(isp, &src->cdb_dl.sf.fcp_cmnd_cdb[i],
+		    dst->cdb_dl.sf.fcp_cmnd_cdb[i]);
+	}
+	ISP_IOZGET_32(isp, &src->cdb_dl.sf.fcp_cmnd_dl,
+	    dst->cdb_dl.sf.fcp_cmnd_dl);
+}
+
+void
+isp_put_rft_id(struct ispsoftc *isp, rft_id_t *src, rft_id_t *dst)
+{
+	int i;
+	isp_put_ct_hdr(isp, &src->rftid_hdr, &dst->rftid_hdr);
+	ISP_IOZPUT_8(isp, src->rftid_reserved, &dst->rftid_reserved);
+	for (i = 0; i < 3; i++) {
+		ISP_IOZPUT_8(isp, src->rftid_portid[i], &dst->rftid_portid[i]);
+	}
+	for (i = 0; i < 8; i++) {
+		ISP_IOZPUT_32(isp, src->rftid_fc4types[i],
+		    &dst->rftid_fc4types[i]);
+	}
+}
+
+void
+isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
+{
+	ISP_IOZGET_8(isp, &src->ct_revision, dst->ct_revision);
+	ISP_IOZGET_8(isp, &src->ct_in_id[0], dst->ct_in_id[0]);
+	ISP_IOZGET_8(isp, &src->ct_in_id[1], dst->ct_in_id[1]);
+	ISP_IOZGET_8(isp, &src->ct_in_id[2], dst->ct_in_id[2]);
+	ISP_IOZGET_8(isp, &src->ct_fcs_type, dst->ct_fcs_type);
+	ISP_IOZGET_8(isp, &src->ct_fcs_subtype, dst->ct_fcs_subtype);
+	ISP_IOZGET_8(isp, &src->ct_options, dst->ct_options);
+	ISP_IOZGET_8(isp, &src->ct_reserved0, dst->ct_reserved0);
+	ISP_IOZGET_16(isp, &src->ct_cmd_resp, dst->ct_cmd_resp);
+	ISP_IOZGET_16(isp, &src->ct_bcnt_resid, dst->ct_bcnt_resid);
+	ISP_IOZGET_8(isp, &src->ct_reserved1, dst->ct_reserved1);
+	ISP_IOZGET_8(isp, &src->ct_reason, dst->ct_reason);
+	ISP_IOZGET_8(isp, &src->ct_explanation, dst->ct_explanation);
+	ISP_IOZGET_8(isp, &src->ct_vunique, dst->ct_vunique);
+}
+
+void
+isp_put_ct_hdr(struct ispsoftc *isp, ct_hdr_t *src, ct_hdr_t *dst)
+{
+	ISP_IOZPUT_8(isp, src->ct_revision, &dst->ct_revision);
+	ISP_IOZPUT_8(isp, src->ct_in_id[0], &dst->ct_in_id[0]);
+	ISP_IOZPUT_8(isp, src->ct_in_id[1], &dst->ct_in_id[1]);
+	ISP_IOZPUT_8(isp, src->ct_in_id[2], &dst->ct_in_id[2]);
+	ISP_IOZPUT_8(isp, src->ct_fcs_type, &dst->ct_fcs_type);
+	ISP_IOZPUT_8(isp, src->ct_fcs_subtype, &dst->ct_fcs_subtype);
+	ISP_IOZPUT_8(isp, src->ct_options, &dst->ct_options);
+	ISP_IOZPUT_8(isp, src->ct_reserved0, &dst->ct_reserved0);
+	ISP_IOZPUT_16(isp, src->ct_cmd_resp, &dst->ct_cmd_resp);
+	ISP_IOZPUT_16(isp, src->ct_bcnt_resid, &dst->ct_bcnt_resid);
+	ISP_IOZPUT_8(isp, src->ct_reserved1, &dst->ct_reserved1);
+	ISP_IOZPUT_8(isp, src->ct_reason, &dst->ct_reason);
+	ISP_IOZPUT_8(isp, src->ct_explanation, &dst->ct_explanation);
+	ISP_IOZPUT_8(isp, src->ct_vunique, &dst->ct_vunique);
+}
+
 #ifdef	ISP_TARGET_MODE
+int
+isp_save_xs_tgt(struct ispsoftc *isp, void *xs, u_int32_t *handlep)
+{
+	int i;
+
+	for (i = 0; i < (int) isp->isp_maxcmds; i++) {
+		if (isp->isp_tgtlist[i] == NULL) {
+			break;
+		}
+	}
+	if (i == isp->isp_maxcmds) {
+		return (-1);
+	}
+	isp->isp_tgtlist[i] = xs;
+	*handlep = (i+1) | 0x8000;
+	return (0);
+}
+
+void *
+isp_find_xs_tgt(struct ispsoftc *isp, u_int32_t handle)
+{
+	if (handle == 0 || IS_TARGET_HANDLE(handle) == 0 ||
+	    (handle & ISP_HANDLE_MASK) > isp->isp_maxcmds) {
+		isp_prt(isp, ISP_LOGERR, "bad handle in isp_find_xs_tgt");
+		return (NULL);
+	} else {
+		return (isp->isp_tgtlist[(handle & ISP_HANDLE_MASK) - 1]);
+	}
+}
+
+u_int32_t
+isp_find_tgt_handle(struct ispsoftc *isp, void *xs)
+{
+	int i;
+	if (xs != NULL) {
+		for (i = 0; i < isp->isp_maxcmds; i++) {
+			if (isp->isp_tgtlist[i] == xs) {
+				return ((i+1) & ISP_HANDLE_MASK);
+			}
+		}
+	}
+	return (0);
+}
+
 void
-isp_put_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
+isp_destroy_tgt_handle(struct ispsoftc *isp, u_int32_t handle)
+{
+	if (handle == 0 || IS_TARGET_HANDLE(handle) == 0 ||
+	    (handle & ISP_HANDLE_MASK) > isp->isp_maxcmds) {
+		isp_prt(isp, ISP_LOGERR,
+		    "bad handle in isp_destroy_tgt_handle");
+	} else {
+		isp->isp_tgtlist[(handle & ISP_HANDLE_MASK) - 1] = NULL;
+	}
+}
+
+void
+isp_put_atio(struct ispsoftc *isp, at_entry_t *src, at_entry_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
-	ISP_IOXPUT_16(isp, atsrc->at_reserved, &atdst->at_reserved);
-	ISP_IOXPUT_16(isp, atsrc->at_handle, &atdst->at_handle);
+	isp_put_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXPUT_16(isp, src->at_reserved, &dst->at_reserved);
+	ISP_IOXPUT_16(isp, src->at_handle, &dst->at_handle);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_iid);
-		ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_lun);
-		ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_tgt);
-		ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_cdblen);
-		ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_scsi_status);
-		ISP_IOXPUT_8(isp, atsrc->at_scsi_status, &atdst->at_status);
-		ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_type);
-		ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_val);
+		ISP_IOXPUT_8(isp, src->at_lun, &dst->at_iid);
+		ISP_IOXPUT_8(isp, src->at_iid, &dst->at_lun);
+		ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_tgt);
+		ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_cdblen);
+		ISP_IOXPUT_8(isp, src->at_status, &dst->at_scsi_status);
+		ISP_IOXPUT_8(isp, src->at_scsi_status, &dst->at_status);
+		ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_type);
+		ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_val);
 	} else {
-		ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
-		ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
-		ISP_IOXPUT_8(isp, atsrc->at_cdblen, &atdst->at_cdblen);
-		ISP_IOXPUT_8(isp, atsrc->at_tgt, &atdst->at_tgt);
-		ISP_IOXPUT_8(isp, atsrc->at_status, &atdst->at_status);
-		ISP_IOXPUT_8(isp, atsrc->at_scsi_status,
-		    &atdst->at_scsi_status);
-		ISP_IOXPUT_8(isp, atsrc->at_tag_val, &atdst->at_tag_val);
-		ISP_IOXPUT_8(isp, atsrc->at_tag_type, &atdst->at_tag_type);
-	}
-	ISP_IOXPUT_32(isp, atsrc->at_flags, &atdst->at_flags);
+		ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
+		ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
+		ISP_IOXPUT_8(isp, src->at_cdblen, &dst->at_cdblen);
+		ISP_IOXPUT_8(isp, src->at_tgt, &dst->at_tgt);
+		ISP_IOXPUT_8(isp, src->at_status, &dst->at_status);
+		ISP_IOXPUT_8(isp, src->at_scsi_status,
+		    &dst->at_scsi_status);
+		ISP_IOXPUT_8(isp, src->at_tag_val, &dst->at_tag_val);
+		ISP_IOXPUT_8(isp, src->at_tag_type, &dst->at_tag_type);
+	}
+	ISP_IOXPUT_32(isp, src->at_flags, &dst->at_flags);
 	for (i = 0; i < ATIO_CDBLEN; i++) {
-		ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
+		ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
 	}
 	for (i = 0; i < QLTM_SENSELEN; i++) {
-		ISP_IOXPUT_8(isp, atsrc->at_sense[i], &atdst->at_sense[i]);
+		ISP_IOXPUT_8(isp, src->at_sense[i], &dst->at_sense[i]);
 	}
 }
 
 void
-isp_get_atio(struct ispsoftc *isp, at_entry_t *atsrc, at_entry_t *atdst)
+isp_get_atio(struct ispsoftc *isp, at_entry_t *src, at_entry_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
-	ISP_IOXGET_16(isp, &atsrc->at_reserved, atdst->at_reserved);
-	ISP_IOXGET_16(isp, &atsrc->at_handle, atdst->at_handle);
+	isp_get_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXGET_16(isp, &src->at_reserved, dst->at_reserved);
+	ISP_IOXGET_16(isp, &src->at_handle, dst->at_handle);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_iid);
-		ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_lun);
-		ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_tgt);
-		ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_cdblen);
-		ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_scsi_status);
-		ISP_IOXGET_8(isp, &atsrc->at_scsi_status, atdst->at_status);
-		ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_type);
-		ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_val);
+		ISP_IOXGET_8(isp, &src->at_lun, dst->at_iid);
+		ISP_IOXGET_8(isp, &src->at_iid, dst->at_lun);
+		ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_tgt);
+		ISP_IOXGET_8(isp, &src->at_tgt, dst->at_cdblen);
+		ISP_IOXGET_8(isp, &src->at_status, dst->at_scsi_status);
+		ISP_IOXGET_8(isp, &src->at_scsi_status, dst->at_status);
+		ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_type);
+		ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_val);
 	} else {
-		ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
-		ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
-		ISP_IOXGET_8(isp, &atsrc->at_cdblen, atdst->at_cdblen);
-		ISP_IOXGET_8(isp, &atsrc->at_tgt, atdst->at_tgt);
-		ISP_IOXGET_8(isp, &atsrc->at_status, atdst->at_status);
-		ISP_IOXGET_8(isp, &atsrc->at_scsi_status,
-		    atdst->at_scsi_status);
-		ISP_IOXGET_8(isp, &atsrc->at_tag_val, atdst->at_tag_val);
-		ISP_IOXGET_8(isp, &atsrc->at_tag_type, atdst->at_tag_type);
-	}
-	ISP_IOXGET_32(isp, &atsrc->at_flags, atdst->at_flags);
+		ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
+		ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
+		ISP_IOXGET_8(isp, &src->at_cdblen, dst->at_cdblen);
+		ISP_IOXGET_8(isp, &src->at_tgt, dst->at_tgt);
+		ISP_IOXGET_8(isp, &src->at_status, dst->at_status);
+		ISP_IOXGET_8(isp, &src->at_scsi_status,
+		    dst->at_scsi_status);
+		ISP_IOXGET_8(isp, &src->at_tag_val, dst->at_tag_val);
+		ISP_IOXGET_8(isp, &src->at_tag_type, dst->at_tag_type);
+	}
+	ISP_IOXGET_32(isp, &src->at_flags, dst->at_flags);
 	for (i = 0; i < ATIO_CDBLEN; i++) {
-		ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
+		ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
 	}
 	for (i = 0; i < QLTM_SENSELEN; i++) {
-		ISP_IOXGET_8(isp, &atsrc->at_sense[i], atdst->at_sense[i]);
+		ISP_IOXGET_8(isp, &src->at_sense[i], dst->at_sense[i]);
 	}
 }
 
 void
-isp_put_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
+isp_put_atio2(struct ispsoftc *isp, at2_entry_t *src, at2_entry_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &atsrc->at_header, &atdst->at_header);
-	ISP_IOXPUT_32(isp, atsrc->at_reserved, &atdst->at_reserved);
-	ISP_IOXPUT_8(isp, atsrc->at_lun, &atdst->at_lun);
-	ISP_IOXPUT_8(isp, atsrc->at_iid, &atdst->at_iid);
-	ISP_IOXPUT_16(isp, atsrc->at_rxid, &atdst->at_rxid);
-	ISP_IOXPUT_16(isp, atsrc->at_flags, &atdst->at_flags);
-	ISP_IOXPUT_16(isp, atsrc->at_status, &atdst->at_status);
-	ISP_IOXPUT_8(isp, atsrc->at_reserved1, &atdst->at_reserved1);
-	ISP_IOXPUT_8(isp, atsrc->at_taskcodes, &atdst->at_taskcodes);
-	ISP_IOXPUT_8(isp, atsrc->at_taskflags, &atdst->at_taskflags);
-	ISP_IOXPUT_8(isp, atsrc->at_execodes, &atdst->at_execodes);
+	isp_put_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
+	ISP_IOXPUT_8(isp, src->at_lun, &dst->at_lun);
+	ISP_IOXPUT_8(isp, src->at_iid, &dst->at_iid);
+	ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
+	ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
+	ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
+	ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
+	ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
+	ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
+	ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
 	for (i = 0; i < ATIO2_CDBLEN; i++) {
-		ISP_IOXPUT_8(isp, atsrc->at_cdb[i], &atdst->at_cdb[i]);
+		ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
 	}
-	ISP_IOXPUT_32(isp, atsrc->at_datalen, &atdst->at_datalen);
-	ISP_IOXPUT_16(isp, atsrc->at_scclun, &atdst->at_scclun);
+	ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
+	ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
 	for (i = 0; i < 4; i++) {
-		ISP_IOXPUT_16(isp, atsrc->at_wwpn[i], &atdst->at_wwpn[i]);
+		ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
 	}
 	for (i = 0; i < 6; i++) {
-		ISP_IOXPUT_16(isp, atsrc->at_reserved2[i],
-		    &atdst->at_reserved2[i]);
+		ISP_IOXPUT_16(isp, src->at_reserved2[i],
+		    &dst->at_reserved2[i]);
 	}
-	ISP_IOXPUT_16(isp, atsrc->at_oxid, &atdst->at_oxid);
+	ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
 }
 
 void
-isp_get_atio2(struct ispsoftc *isp, at2_entry_t *atsrc, at2_entry_t *atdst)
+isp_put_atio2e(struct ispsoftc *isp, at2e_entry_t *src, at2e_entry_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &atsrc->at_header, &atdst->at_header);
-	ISP_IOXGET_32(isp, &atsrc->at_reserved, atdst->at_reserved);
-	ISP_IOXGET_8(isp, &atsrc->at_lun, atdst->at_lun);
-	ISP_IOXGET_8(isp, &atsrc->at_iid, atdst->at_iid);
-	ISP_IOXGET_16(isp, &atsrc->at_rxid, atdst->at_rxid);
-	ISP_IOXGET_16(isp, &atsrc->at_flags, atdst->at_flags);
-	ISP_IOXGET_16(isp, &atsrc->at_status, atdst->at_status);
-	ISP_IOXGET_8(isp, &atsrc->at_reserved1, atdst->at_reserved1);
-	ISP_IOXGET_8(isp, &atsrc->at_taskcodes, atdst->at_taskcodes);
-	ISP_IOXGET_8(isp, &atsrc->at_taskflags, atdst->at_taskflags);
-	ISP_IOXGET_8(isp, &atsrc->at_execodes, atdst->at_execodes);
+	isp_put_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXPUT_32(isp, src->at_reserved, &dst->at_reserved);
+	ISP_IOXPUT_16(isp, src->at_iid, &dst->at_iid);
+	ISP_IOXPUT_16(isp, src->at_rxid, &dst->at_rxid);
+	ISP_IOXPUT_16(isp, src->at_flags, &dst->at_flags);
+	ISP_IOXPUT_16(isp, src->at_status, &dst->at_status);
+	ISP_IOXPUT_8(isp, src->at_crn, &dst->at_crn);
+	ISP_IOXPUT_8(isp, src->at_taskcodes, &dst->at_taskcodes);
+	ISP_IOXPUT_8(isp, src->at_taskflags, &dst->at_taskflags);
+	ISP_IOXPUT_8(isp, src->at_execodes, &dst->at_execodes);
 	for (i = 0; i < ATIO2_CDBLEN; i++) {
-		ISP_IOXGET_8(isp, &atsrc->at_cdb[i], atdst->at_cdb[i]);
+		ISP_IOXPUT_8(isp, src->at_cdb[i], &dst->at_cdb[i]);
 	}
-	ISP_IOXGET_32(isp, &atsrc->at_datalen, atdst->at_datalen);
-	ISP_IOXGET_16(isp, &atsrc->at_scclun, atdst->at_scclun);
+	ISP_IOXPUT_32(isp, src->at_datalen, &dst->at_datalen);
+	ISP_IOXPUT_16(isp, src->at_scclun, &dst->at_scclun);
 	for (i = 0; i < 4; i++) {
-		ISP_IOXGET_16(isp, &atsrc->at_wwpn[i], atdst->at_wwpn[i]);
+		ISP_IOXPUT_16(isp, src->at_wwpn[i], &dst->at_wwpn[i]);
 	}
 	for (i = 0; i < 6; i++) {
-		ISP_IOXGET_16(isp, &atsrc->at_reserved2[i],
-		    atdst->at_reserved2[i]);
+		ISP_IOXPUT_16(isp, src->at_reserved2[i],
+		    &dst->at_reserved2[i]);
 	}
-	ISP_IOXGET_16(isp, &atsrc->at_oxid, atdst->at_oxid);
+	ISP_IOXPUT_16(isp, src->at_oxid, &dst->at_oxid);
 }
 
 void
-isp_put_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
+isp_get_atio2(struct ispsoftc *isp, at2_entry_t *src, at2_entry_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
-	ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
-	ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
+	isp_get_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
+	ISP_IOXGET_8(isp, &src->at_lun, dst->at_lun);
+	ISP_IOXGET_8(isp, &src->at_iid, dst->at_iid);
+	ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
+	ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
+	ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
+	ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
+	ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
+	ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
+	ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
+	for (i = 0; i < ATIO2_CDBLEN; i++) {
+		ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
+	}
+	ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
+	ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
+	}
+	for (i = 0; i < 6; i++) {
+		ISP_IOXGET_16(isp, &src->at_reserved2[i],
+		    dst->at_reserved2[i]);
+	}
+	ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
+}
+
+void
+isp_get_atio2e(struct ispsoftc *isp, at2e_entry_t *src, at2e_entry_t *dst)
+{
+	int i;
+	isp_get_hdr(isp, &src->at_header, &dst->at_header);
+	ISP_IOXGET_32(isp, &src->at_reserved, dst->at_reserved);
+	ISP_IOXGET_16(isp, &src->at_iid, dst->at_iid);
+	ISP_IOXGET_16(isp, &src->at_rxid, dst->at_rxid);
+	ISP_IOXGET_16(isp, &src->at_flags, dst->at_flags);
+	ISP_IOXGET_16(isp, &src->at_status, dst->at_status);
+	ISP_IOXGET_8(isp, &src->at_crn, dst->at_crn);
+	ISP_IOXGET_8(isp, &src->at_taskcodes, dst->at_taskcodes);
+	ISP_IOXGET_8(isp, &src->at_taskflags, dst->at_taskflags);
+	ISP_IOXGET_8(isp, &src->at_execodes, dst->at_execodes);
+	for (i = 0; i < ATIO2_CDBLEN; i++) {
+		ISP_IOXGET_8(isp, &src->at_cdb[i], dst->at_cdb[i]);
+	}
+	ISP_IOXGET_32(isp, &src->at_datalen, dst->at_datalen);
+	ISP_IOXGET_16(isp, &src->at_scclun, dst->at_scclun);
+	for (i = 0; i < 4; i++) {
+		ISP_IOXGET_16(isp, &src->at_wwpn[i], dst->at_wwpn[i]);
+	}
+	for (i = 0; i < 6; i++) {
+		ISP_IOXGET_16(isp, &src->at_reserved2[i],
+		    dst->at_reserved2[i]);
+	}
+	ISP_IOXGET_16(isp, &src->at_oxid, dst->at_oxid);
+}
+
+void
+isp_get_atio7(struct ispsoftc *isp, at7_entry_t *src, at7_entry_t *dst)
+{
+	ISP_IOXGET_8(isp, &src->at_type, dst->at_type);
+	ISP_IOXGET_8(isp, &src->at_count, dst->at_count);
+	ISP_IOXGET_16(isp, &src->at_ta_len, dst->at_ta_len);
+	ISP_IOXGET_32(isp, &src->at_rxid, dst->at_rxid);
+	isp_get_fc_hdr(isp, &src->at_hdr, &dst->at_hdr);
+	isp_get_fcp_cmnd_iu(isp, &src->at_cmnd, &dst->at_cmnd);
+}
+
+void
+isp_put_ctio(struct ispsoftc *isp, ct_entry_t *src, ct_entry_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXPUT_16(isp, src->ct_syshandle, &dst->ct_syshandle);
+	ISP_IOXPUT_16(isp, src->ct_fwhandle, &dst->ct_fwhandle);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_lun);
-		ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_iid);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_reserved2);
-		ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_tgt);
-		ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_scsi_status);
-		ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status, &ctdst->ct_status);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_val);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_type);
+		ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_lun);
+		ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_iid);
+		ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_reserved2);
+		ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_tgt);
+		ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_scsi_status);
+		ISP_IOXPUT_8(isp, src->ct_scsi_status, &dst->ct_status);
+		ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_val);
+		ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_type);
 	} else {
-		ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
-		ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tgt, &ctdst->ct_tgt);
-		ISP_IOXPUT_8(isp, ctsrc->ct_reserved2, &ctdst->ct_reserved2);
-		ISP_IOXPUT_8(isp, ctsrc->ct_scsi_status,
-		    &ctdst->ct_scsi_status);
-		ISP_IOXPUT_8(isp, ctsrc->ct_status, &ctdst->ct_status);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tag_type, &ctdst->ct_tag_type);
-		ISP_IOXPUT_8(isp, ctsrc->ct_tag_val, &ctdst->ct_tag_val);
-	}
-	ISP_IOXPUT_32(isp, ctsrc->ct_flags, &ctdst->ct_flags);
-	ISP_IOXPUT_32(isp, ctsrc->ct_xfrlen, &ctdst->ct_xfrlen);
-	ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
-	ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
-	ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
+		ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
+		ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
+		ISP_IOXPUT_8(isp, src->ct_tgt, &dst->ct_tgt);
+		ISP_IOXPUT_8(isp, src->ct_reserved2, &dst->ct_reserved2);
+		ISP_IOXPUT_8(isp, src->ct_scsi_status,
+		    &dst->ct_scsi_status);
+		ISP_IOXPUT_8(isp, src->ct_status, &dst->ct_status);
+		ISP_IOXPUT_8(isp, src->ct_tag_type, &dst->ct_tag_type);
+		ISP_IOXPUT_8(isp, src->ct_tag_val, &dst->ct_tag_val);
+	}
+	ISP_IOXPUT_32(isp, src->ct_flags, &dst->ct_flags);
+	ISP_IOXPUT_32(isp, src->ct_xfrlen, &dst->ct_xfrlen);
+	ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
+	ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
+	ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
 	for (i = 0; i < ISP_RQDSEG; i++) {
-		ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_base,
-		    &ctdst->ct_dataseg[i].ds_base);
-		ISP_IOXPUT_32(isp, ctsrc->ct_dataseg[i].ds_count,
-		    &ctdst->ct_dataseg[i].ds_count);
+		ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_base,
+		    &dst->ct_dataseg[i].ds_base);
+		ISP_IOXPUT_32(isp, src->ct_dataseg[i].ds_count,
+		    &dst->ct_dataseg[i].ds_count);
 	}
 }
 
 void
-isp_get_ctio(struct ispsoftc *isp, ct_entry_t *ctsrc, ct_entry_t *ctdst)
+isp_get_ctio(struct ispsoftc *isp, ct_entry_t *src, ct_entry_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
-	ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
-	ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
+	isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXGET_16(isp, &src->ct_syshandle, dst->ct_syshandle);
+	ISP_IOXGET_16(isp, &src->ct_fwhandle, dst->ct_fwhandle);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_iid);
-		ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_lun);
-		ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_tgt);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_reserved2);
-		ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_scsi_status);
-		ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status, ctdst->ct_status);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_type);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_val);
+		ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_iid);
+		ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_lun);
+		ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_tgt);
+		ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_reserved2);
+		ISP_IOXGET_8(isp, &src->ct_status, dst->ct_scsi_status);
+		ISP_IOXGET_8(isp, &src->ct_scsi_status, dst->ct_status);
+		ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_type);
+		ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_val);
 	} else {
-		ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
-		ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
-		ISP_IOXGET_8(isp, &ctsrc->ct_reserved2, ctdst->ct_reserved2);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tgt, ctdst->ct_tgt);
-		ISP_IOXGET_8(isp, &ctsrc->ct_status, ctdst->ct_status);
-		ISP_IOXGET_8(isp, &ctsrc->ct_scsi_status,
-		    ctdst->ct_scsi_status);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tag_val, ctdst->ct_tag_val);
-		ISP_IOXGET_8(isp, &ctsrc->ct_tag_type, ctdst->ct_tag_type);
-	}
-	ISP_IOXGET_32(isp, &ctsrc->ct_flags, ctdst->ct_flags);
-	ISP_IOXGET_32(isp, &ctsrc->ct_xfrlen, ctdst->ct_xfrlen);
-	ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
-	ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
-	ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
+		ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
+		ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
+		ISP_IOXGET_8(isp, &src->ct_reserved2, dst->ct_reserved2);
+		ISP_IOXGET_8(isp, &src->ct_tgt, dst->ct_tgt);
+		ISP_IOXGET_8(isp, &src->ct_status, dst->ct_status);
+		ISP_IOXGET_8(isp, &src->ct_scsi_status,
+		    dst->ct_scsi_status);
+		ISP_IOXGET_8(isp, &src->ct_tag_val, dst->ct_tag_val);
+		ISP_IOXGET_8(isp, &src->ct_tag_type, dst->ct_tag_type);
+	}
+	ISP_IOXGET_32(isp, &src->ct_flags, dst->ct_flags);
+	ISP_IOXGET_32(isp, &src->ct_xfrlen, dst->ct_xfrlen);
+	ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
+	ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
+	ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
 	for (i = 0; i < ISP_RQDSEG; i++) {
 		ISP_IOXGET_32(isp,
-		    &ctsrc->ct_dataseg[i].ds_base,
-		    ctdst->ct_dataseg[i].ds_base);
+		    &src->ct_dataseg[i].ds_base,
+		    dst->ct_dataseg[i].ds_base);
 		ISP_IOXGET_32(isp,
-		    &ctsrc->ct_dataseg[i].ds_count,
-		    ctdst->ct_dataseg[i].ds_count);
-	}
-}
-
-void
-isp_put_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
-{
-	int i;
-	isp_copy_out_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
-	ISP_IOXPUT_16(isp, ctsrc->ct_reserved, &ctdst->ct_reserved);
-	ISP_IOXPUT_16(isp, ctsrc->ct_fwhandle, &ctdst->ct_fwhandle);
-	ISP_IOXPUT_8(isp, ctsrc->ct_lun, &ctdst->ct_lun);
-	ISP_IOXPUT_8(isp, ctsrc->ct_iid, &ctdst->ct_iid);
-	ISP_IOXPUT_16(isp, ctsrc->ct_rxid, &ctdst->ct_rxid);
-	ISP_IOXPUT_16(isp, ctsrc->ct_flags, &ctdst->ct_flags);
-	ISP_IOXPUT_16(isp, ctsrc->ct_timeout, &ctdst->ct_timeout);
-	ISP_IOXPUT_16(isp, ctsrc->ct_seg_count, &ctdst->ct_seg_count);
-	ISP_IOXPUT_32(isp, ctsrc->ct_resid, &ctdst->ct_resid);
-	ISP_IOXPUT_32(isp, ctsrc->ct_reloff, &ctdst->ct_reloff);
-	if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m0._reserved,
-		    &ctdst->rsp.m0._reserved);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m0._reserved2,
-		    &ctdst->rsp.m0._reserved2);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_scsi_status,
-		    &ctdst->rsp.m0.ct_scsi_status);
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_xfrlen,
-		    &ctdst->rsp.m0.ct_xfrlen);
-		if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
+		    &src->ct_dataseg[i].ds_count,
+		    dst->ct_dataseg[i].ds_count);
+	}
+}
+
+void
+isp_put_ctio2(struct ispsoftc *isp, ct2_entry_t *src, ct2_entry_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
+	ISP_IOXPUT_8(isp, src->ct_lun, &dst->ct_lun);
+	ISP_IOXPUT_8(isp, src->ct_iid, &dst->ct_iid);
+	ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
+	ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
+	ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
+	ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
+	ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
+	ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
+	if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
+		ISP_IOXPUT_32(isp, src->rsp.m0._reserved,
+		    &dst->rsp.m0._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m0._reserved2,
+		    &dst->rsp.m0._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status,
+		    &dst->rsp.m0.ct_scsi_status);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
+		    &dst->rsp.m0.ct_xfrlen);
+		if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
 			for (i = 0; i < ISP_RQDSEG_T2; i++) {
 				ISP_IOXPUT_32(isp,
-				    ctsrc->rsp.m0.ct_dataseg[i].ds_base,
-				    &ctdst->rsp.m0.ct_dataseg[i].ds_base);
+				    src->rsp.m0.u.ct_dataseg[i].ds_base,
+				    &dst->rsp.m0.u.ct_dataseg[i].ds_base);
 				ISP_IOXPUT_32(isp,
-				    ctsrc->rsp.m0.ct_dataseg[i].ds_count,
-				    &ctdst->rsp.m0.ct_dataseg[i].ds_count);
+				    src->rsp.m0.u.ct_dataseg[i].ds_count,
+				    &dst->rsp.m0.u.ct_dataseg[i].ds_count);
 			}
-		} else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
+		} else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
 			for (i = 0; i < ISP_RQDSEG_T3; i++) {
 				ISP_IOXPUT_32(isp,
-				    ctsrc->rsp.m0.ct_dataseg64[i].ds_base,
-				    &ctdst->rsp.m0.ct_dataseg64[i].ds_base);
+				    src->rsp.m0.u.ct_dataseg64[i].ds_base,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
 				ISP_IOXPUT_32(isp,
-				    ctsrc->rsp.m0.ct_dataseg64[i].ds_basehi,
-				    &ctdst->rsp.m0.ct_dataseg64[i].ds_basehi);
+				    src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
 				ISP_IOXPUT_32(isp,
-				    ctsrc->rsp.m0.ct_dataseg64[i].ds_count,
-				    &ctdst->rsp.m0.ct_dataseg64[i].ds_count);
+				    src->rsp.m0.u.ct_dataseg64[i].ds_count,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
 			}
-		} else if (ctsrc->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
-			ISP_IOXPUT_16(isp, ctsrc->rsp.m0.ct_dslist.ds_type,
-			    &ctdst->rsp.m0.ct_dslist.ds_type);
-			ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_segment,
-			    &ctdst->rsp.m0.ct_dslist.ds_segment);
-			ISP_IOXPUT_32(isp, ctsrc->rsp.m0.ct_dslist.ds_base,
-			    &ctdst->rsp.m0.ct_dslist.ds_base);
+		} else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
+			ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type,
+			    &dst->rsp.m0.u.ct_dslist.ds_type);
+			ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment,
+			    &dst->rsp.m0.u.ct_dslist.ds_segment);
+			ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base,
+			    &dst->rsp.m0.u.ct_dslist.ds_base);
 		}
-	} else if ((ctsrc->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved,
-		    &ctdst->rsp.m1._reserved);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m1._reserved2,
-		    &ctdst->rsp.m1._reserved2);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_senselen,
-		    &ctdst->rsp.m1.ct_senselen);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_scsi_status,
-		    &ctdst->rsp.m1.ct_scsi_status);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m1.ct_resplen,
-		    &ctdst->rsp.m1.ct_resplen);
+	} else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
+		ISP_IOXPUT_16(isp, src->rsp.m1._reserved,
+		    &dst->rsp.m1._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m1._reserved2,
+		    &dst->rsp.m1._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen,
+		    &dst->rsp.m1.ct_senselen);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status,
+		    &dst->rsp.m1.ct_scsi_status);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
+		    &dst->rsp.m1.ct_resplen);
 		for (i = 0; i < MAXRESPLEN; i++) {
-			ISP_IOXPUT_8(isp, ctsrc->rsp.m1.ct_resp[i],
-			    &ctdst->rsp.m1.ct_resp[i]);
+			ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
+			    &dst->rsp.m1.ct_resp[i]);
 		}
 	} else {
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m2._reserved,
-		    &ctdst->rsp.m2._reserved);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved2,
-		    &ctdst->rsp.m2._reserved2);
-		ISP_IOXPUT_16(isp, ctsrc->rsp.m2._reserved3,
-		    &ctdst->rsp.m2._reserved3);
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_datalen,
-		    &ctdst->rsp.m2.ct_datalen);
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_base,
-		    &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
-		ISP_IOXPUT_32(isp, ctsrc->rsp.m2.ct_fcp_rsp_iudata.ds_count,
-		    &ctdst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
-	}
-}
-
-void
-isp_get_ctio2(struct ispsoftc *isp, ct2_entry_t *ctsrc, ct2_entry_t *ctdst)
-{
-	int i;
-	isp_copy_in_hdr(isp, &ctsrc->ct_header, &ctdst->ct_header);
-	ISP_IOXGET_16(isp, &ctsrc->ct_reserved, ctdst->ct_reserved);
-	ISP_IOXGET_16(isp, &ctsrc->ct_fwhandle, ctdst->ct_fwhandle);
-	ISP_IOXGET_8(isp, &ctsrc->ct_lun, ctdst->ct_lun);
-	ISP_IOXGET_8(isp, &ctsrc->ct_iid, ctdst->ct_iid);
-	ISP_IOXGET_16(isp, &ctsrc->ct_rxid, ctdst->ct_rxid);
-	ISP_IOXGET_16(isp, &ctsrc->ct_flags, ctdst->ct_flags);
-	ISP_IOXGET_16(isp, &ctsrc->ct_status, ctdst->ct_status);
-	ISP_IOXGET_16(isp, &ctsrc->ct_timeout, ctdst->ct_timeout);
-	ISP_IOXGET_16(isp, &ctsrc->ct_seg_count, ctdst->ct_seg_count);
-	ISP_IOXGET_32(isp, &ctsrc->ct_reloff, ctdst->ct_reloff);
-	ISP_IOXGET_32(isp, &ctsrc->ct_resid, ctdst->ct_resid);
-	for (i = 0; i < 4; i++) {
-		ISP_IOXGET_32(isp, &ctsrc->rsp.fw._reserved[i],
-		    ctdst->rsp.fw._reserved[i]);
+		ISP_IOXPUT_32(isp, src->rsp.m2._reserved,
+		    &dst->rsp.m2._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m2._reserved2,
+		    &dst->rsp.m2._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m2._reserved3,
+		    &dst->rsp.m2._reserved3);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
+		    &dst->rsp.m2.ct_datalen);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
 	}
-	ISP_IOXGET_16(isp, &ctsrc->rsp.fw.ct_scsi_status,
-	    ctdst->rsp.fw.ct_scsi_status);
-	for (i = 0; i < QLTM_SENSELEN; i++) {
-		ISP_IOXGET_8(isp, &ctsrc->rsp.fw.ct_sense[i],
-		    ctdst->rsp.fw.ct_sense[i]);
+}
+
+void
+isp_put_ctio2e(struct ispsoftc *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
+	ISP_IOXPUT_16(isp, src->ct_iid, &dst->ct_iid);
+	ISP_IOXPUT_16(isp, src->ct_rxid, &dst->ct_rxid);
+	ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
+	ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
+	ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
+	ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
+	ISP_IOXPUT_32(isp, src->ct_reloff, &dst->ct_reloff);
+	if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
+		ISP_IOXPUT_32(isp, src->rsp.m0._reserved,
+		    &dst->rsp.m0._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m0._reserved2,
+		    &dst->rsp.m0._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m0.ct_scsi_status,
+		    &dst->rsp.m0.ct_scsi_status);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
+		    &dst->rsp.m0.ct_xfrlen);
+		if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
+			for (i = 0; i < ISP_RQDSEG_T2; i++) {
+				ISP_IOXPUT_32(isp,
+				    src->rsp.m0.u.ct_dataseg[i].ds_base,
+				    &dst->rsp.m0.u.ct_dataseg[i].ds_base);
+				ISP_IOXPUT_32(isp,
+				    src->rsp.m0.u.ct_dataseg[i].ds_count,
+				    &dst->rsp.m0.u.ct_dataseg[i].ds_count);
+			}
+		} else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
+			for (i = 0; i < ISP_RQDSEG_T3; i++) {
+				ISP_IOXPUT_32(isp,
+				    src->rsp.m0.u.ct_dataseg64[i].ds_base,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_base);
+				ISP_IOXPUT_32(isp,
+				    src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
+				ISP_IOXPUT_32(isp,
+				    src->rsp.m0.u.ct_dataseg64[i].ds_count,
+				    &dst->rsp.m0.u.ct_dataseg64[i].ds_count);
+			}
+		} else if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
+			ISP_IOXPUT_16(isp, src->rsp.m0.u.ct_dslist.ds_type,
+			    &dst->rsp.m0.u.ct_dslist.ds_type);
+			ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_segment,
+			    &dst->rsp.m0.u.ct_dslist.ds_segment);
+			ISP_IOXPUT_32(isp, src->rsp.m0.u.ct_dslist.ds_base,
+			    &dst->rsp.m0.u.ct_dslist.ds_base);
+		}
+	} else if ((src->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
+		ISP_IOXPUT_16(isp, src->rsp.m1._reserved,
+		    &dst->rsp.m1._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m1._reserved2,
+		    &dst->rsp.m1._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_senselen,
+		    &dst->rsp.m1.ct_senselen);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_scsi_status,
+		    &dst->rsp.m1.ct_scsi_status);
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
+		    &dst->rsp.m1.ct_resplen);
+		for (i = 0; i < MAXRESPLEN; i++) {
+			ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
+			    &dst->rsp.m1.ct_resp[i]);
+		}
+	} else {
+		ISP_IOXPUT_32(isp, src->rsp.m2._reserved,
+		    &dst->rsp.m2._reserved);
+		ISP_IOXPUT_16(isp, src->rsp.m2._reserved2,
+		    &dst->rsp.m2._reserved2);
+		ISP_IOXPUT_16(isp, src->rsp.m2._reserved3,
+		    &dst->rsp.m2._reserved3);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
+		    &dst->rsp.m2.ct_datalen);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
+	}
+}
+
+void
+isp_put_ctio7(struct ispsoftc *isp, ct7_entry_t *src, ct7_entry_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXPUT_32(isp, src->ct_syshandle, &dst->ct_syshandle);
+	ISP_IOXPUT_16(isp, src->ct_nphdl, &dst->ct_nphdl);
+	ISP_IOXPUT_16(isp, src->ct_timeout, &dst->ct_timeout);
+	ISP_IOXPUT_16(isp, src->ct_seg_count, &dst->ct_seg_count);
+	ISP_IOXPUT_8(isp, src->ct_vpindex, &dst->ct_vpindex);
+	ISP_IOXPUT_8(isp, src->ct_xflags, &dst->ct_xflags);
+	ISP_IOXPUT_16(isp, src->ct_iid_lo, &dst->ct_iid_lo);
+	ISP_IOXPUT_8(isp, src->ct_iid_hi, &dst->ct_iid_hi);
+	ISP_IOXPUT_8(isp, src->ct_reserved, &dst->ct_reserved);
+	ISP_IOXPUT_32(isp, src->ct_rxid, &dst->ct_rxid);
+	ISP_IOXPUT_16(isp, src->ct_senselen, &dst->ct_senselen);
+	ISP_IOXPUT_16(isp, src->ct_flags, &dst->ct_flags);
+	ISP_IOXPUT_32(isp, src->ct_resid, &dst->ct_resid);
+	ISP_IOXPUT_16(isp, src->ct_oxid, &dst->ct_oxid);
+	ISP_IOXPUT_16(isp, src->ct_scsi_status, &dst->ct_scsi_status);
+	if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
+		ISP_IOXPUT_32(isp, src->rsp.m0.reloff, &dst->rsp.m0.reloff);
+		ISP_IOXPUT_32(isp, src->rsp.m0.reserved0,
+		    &dst->rsp.m0.reserved0);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ct_xfrlen,
+		    &dst->rsp.m0.ct_xfrlen);
+		ISP_IOXPUT_32(isp, src->rsp.m0.reserved1,
+		    &dst->rsp.m0.reserved1);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_base,
+		    &dst->rsp.m0.ds.ds_base);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_basehi,
+		    &dst->rsp.m0.ds.ds_basehi);
+		ISP_IOXPUT_32(isp, src->rsp.m0.ds.ds_count,
+		    &dst->rsp.m0.ds.ds_count);
+	} else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
+		ISP_IOXPUT_16(isp, src->rsp.m1.ct_resplen,
+		    &dst->rsp.m1.ct_resplen);
+		ISP_IOXPUT_16(isp, src->rsp.m1.reserved, &dst->rsp.m1.reserved);
+		for (i = 0; i < MAXRESPLEN_24XX; i++) {
+			ISP_IOXPUT_8(isp, src->rsp.m1.ct_resp[i],
+			    &dst->rsp.m1.ct_resp[i]);
+		}
+	} else {
+		ISP_IOXPUT_32(isp, src->rsp.m2.reserved0,
+		    &dst->rsp.m2.reserved0);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_datalen,
+		    &dst->rsp.m2.ct_datalen);
+		ISP_IOXPUT_32(isp, src->rsp.m2.reserved1,
+		    &dst->rsp.m2.reserved1);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
+		ISP_IOXPUT_32(isp, src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    &dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
+	}
+}
+
+
+void
+isp_get_ctio2(struct ispsoftc *isp, ct2_entry_t *src, ct2_entry_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
+	ISP_IOXGET_8(isp, &src->ct_lun, dst->ct_lun);
+	ISP_IOXGET_8(isp, &src->ct_iid, dst->ct_iid);
+	ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
+	ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
+	ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
+	ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
+	ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
+	ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
+	ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
+	if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
+		ISP_IOXGET_32(isp, &src->rsp.m0._reserved,
+		    dst->rsp.m0._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m0._reserved2,
+		    dst->rsp.m0._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status,
+		    dst->rsp.m0.ct_scsi_status);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
+		    dst->rsp.m0.ct_xfrlen);
+		if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
+			for (i = 0; i < ISP_RQDSEG_T2; i++) {
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg[i].ds_base,
+				    dst->rsp.m0.u.ct_dataseg[i].ds_base);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg[i].ds_count,
+				    dst->rsp.m0.u.ct_dataseg[i].ds_count);
+			}
+		} else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
+			for (i = 0; i < ISP_RQDSEG_T3; i++) {
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_base,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_base);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_count,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_count);
+			}
+		} else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
+			ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type,
+			    dst->rsp.m0.u.ct_dslist.ds_type);
+			ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment,
+			    dst->rsp.m0.u.ct_dslist.ds_segment);
+			ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base,
+			    dst->rsp.m0.u.ct_dslist.ds_base);
+		}
+	} else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
+		ISP_IOXGET_16(isp, &src->rsp.m1._reserved,
+		    dst->rsp.m1._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m1._reserved2,
+		    dst->rsp.m1._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen,
+		    dst->rsp.m1.ct_senselen);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status,
+		    dst->rsp.m1.ct_scsi_status);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
+		    dst->rsp.m1.ct_resplen);
+		for (i = 0; i < MAXRESPLEN; i++) {
+			ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
+			    dst->rsp.m1.ct_resp[i]);
+		}
+	} else {
+		ISP_IOXGET_32(isp, &src->rsp.m2._reserved,
+		    dst->rsp.m2._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m2._reserved2,
+		    dst->rsp.m2._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m2._reserved3,
+		    dst->rsp.m2._reserved3);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
+		    dst->rsp.m2.ct_datalen);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
+	}
+}
+
+void
+isp_get_ctio2e(struct ispsoftc *isp, ct2e_entry_t *src, ct2e_entry_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
+	ISP_IOXGET_16(isp, &src->ct_iid, dst->ct_iid);
+	ISP_IOXGET_16(isp, &src->ct_rxid, dst->ct_rxid);
+	ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
+	ISP_IOXGET_16(isp, &src->ct_status, dst->ct_status);
+	ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
+	ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
+	ISP_IOXGET_32(isp, &src->ct_reloff, dst->ct_reloff);
+	ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
+	if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE0) {
+		ISP_IOXGET_32(isp, &src->rsp.m0._reserved,
+		    dst->rsp.m0._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m0._reserved2,
+		    dst->rsp.m0._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m0.ct_scsi_status,
+		    dst->rsp.m0.ct_scsi_status);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
+		    dst->rsp.m0.ct_xfrlen);
+		if (src->ct_header.rqs_entry_type == RQSTYPE_CTIO2) {
+			for (i = 0; i < ISP_RQDSEG_T2; i++) {
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg[i].ds_base,
+				    dst->rsp.m0.u.ct_dataseg[i].ds_base);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg[i].ds_count,
+				    dst->rsp.m0.u.ct_dataseg[i].ds_count);
+			}
+		} else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO3) {
+			for (i = 0; i < ISP_RQDSEG_T3; i++) {
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_base,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_base);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_basehi,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_basehi);
+				ISP_IOXGET_32(isp,
+				    &src->rsp.m0.u.ct_dataseg64[i].ds_count,
+				    dst->rsp.m0.u.ct_dataseg64[i].ds_count);
+			}
+		} else if (dst->ct_header.rqs_entry_type == RQSTYPE_CTIO4) {
+			ISP_IOXGET_16(isp, &src->rsp.m0.u.ct_dslist.ds_type,
+			    dst->rsp.m0.u.ct_dslist.ds_type);
+			ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_segment,
+			    dst->rsp.m0.u.ct_dslist.ds_segment);
+			ISP_IOXGET_32(isp, &src->rsp.m0.u.ct_dslist.ds_base,
+			    dst->rsp.m0.u.ct_dslist.ds_base);
+		}
+	} else if ((dst->ct_flags & CT2_FLAG_MMASK) == CT2_FLAG_MODE1) {
+		ISP_IOXGET_16(isp, &src->rsp.m1._reserved,
+		    dst->rsp.m1._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m1._reserved2,
+		    dst->rsp.m1._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_senselen,
+		    dst->rsp.m1.ct_senselen);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_scsi_status,
+		    dst->rsp.m1.ct_scsi_status);
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
+		    dst->rsp.m1.ct_resplen);
+		for (i = 0; i < MAXRESPLEN; i++) {
+			ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
+			    dst->rsp.m1.ct_resp[i]);
+		}
+	} else {
+		ISP_IOXGET_32(isp, &src->rsp.m2._reserved,
+		    dst->rsp.m2._reserved);
+		ISP_IOXGET_16(isp, &src->rsp.m2._reserved2,
+		    dst->rsp.m2._reserved2);
+		ISP_IOXGET_16(isp, &src->rsp.m2._reserved3,
+		    dst->rsp.m2._reserved3);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
+		    dst->rsp.m2.ct_datalen);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
+	}
+}
+
+void
+isp_get_ctio7(struct ispsoftc *isp, ct7_entry_t *src, ct7_entry_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->ct_header, &dst->ct_header);
+	ISP_IOXGET_32(isp, &src->ct_syshandle, dst->ct_syshandle);
+	ISP_IOXGET_16(isp, &src->ct_nphdl, dst->ct_nphdl);
+	ISP_IOXGET_16(isp, &src->ct_timeout, dst->ct_timeout);
+	ISP_IOXGET_16(isp, &src->ct_seg_count, dst->ct_seg_count);
+	ISP_IOXGET_8(isp, &src->ct_vpindex, dst->ct_vpindex);
+	ISP_IOXGET_8(isp, &src->ct_xflags, dst->ct_xflags);
+	ISP_IOXGET_16(isp, &src->ct_iid_lo, dst->ct_iid_lo);
+	ISP_IOXGET_8(isp, &src->ct_iid_hi, dst->ct_iid_hi);
+	ISP_IOXGET_8(isp, &src->ct_reserved, dst->ct_reserved);
+	ISP_IOXGET_32(isp, &src->ct_rxid, dst->ct_rxid);
+	ISP_IOXGET_16(isp, &src->ct_senselen, dst->ct_senselen);
+	ISP_IOXGET_16(isp, &src->ct_flags, dst->ct_flags);
+	ISP_IOXGET_32(isp, &src->ct_resid, dst->ct_resid);
+	ISP_IOXGET_16(isp, &src->ct_oxid, dst->ct_oxid);
+	ISP_IOXGET_16(isp, &src->ct_scsi_status, dst->ct_scsi_status);
+	if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE0) {
+		ISP_IOXGET_32(isp, &src->rsp.m0.reloff, dst->rsp.m0.reloff);
+		ISP_IOXGET_32(isp, &src->rsp.m0.reserved0,
+		    dst->rsp.m0.reserved0);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ct_xfrlen,
+		    dst->rsp.m0.ct_xfrlen);
+		ISP_IOXGET_32(isp, &src->rsp.m0.reserved1,
+		    dst->rsp.m0.reserved1);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_base,
+		    dst->rsp.m0.ds.ds_base);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_basehi,
+		    dst->rsp.m0.ds.ds_basehi);
+		ISP_IOXGET_32(isp, &src->rsp.m0.ds.ds_count,
+		    dst->rsp.m0.ds.ds_count);
+	} else if ((dst->ct_flags & CT7_FLAG_MMASK) == CT7_FLAG_MODE1) {
+		ISP_IOXGET_16(isp, &src->rsp.m1.ct_resplen,
+		    dst->rsp.m1.ct_resplen);
+		ISP_IOXGET_16(isp, &src->rsp.m1.reserved, dst->rsp.m1.reserved);
+		for (i = 0; i < MAXRESPLEN_24XX; i++) {
+			ISP_IOXGET_8(isp, &src->rsp.m1.ct_resp[i],
+			    dst->rsp.m1.ct_resp[i]);
+		}
+	} else {
+		ISP_IOXGET_32(isp, &src->rsp.m2.reserved0,
+		    dst->rsp.m2.reserved0);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_datalen,
+		    dst->rsp.m2.ct_datalen);
+		ISP_IOXGET_32(isp, &src->rsp.m2.reserved1,
+		    dst->rsp.m2.reserved1);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_base,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_base);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_basehi,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_basehi);
+		ISP_IOXGET_32(isp, &src->rsp.m2.ct_fcp_rsp_iudata.ds_count,
+		    dst->rsp.m2.ct_fcp_rsp_iudata.ds_count);
 	}
 }
 
@@ -1105,7 +2278,7 @@ void
 isp_put_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &lesrc->le_header, &ledst->le_header);
+	isp_put_hdr(isp, &lesrc->le_header, &ledst->le_header);
 	ISP_IOXPUT_32(isp, lesrc->le_reserved, &ledst->le_reserved);
 	if (ISP_IS_SBUS(isp)) {
 		ISP_IOXPUT_8(isp, lesrc->le_lun, &ledst->le_rsvd);
@@ -1142,7 +2315,7 @@ void
 isp_get_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &lesrc->le_header, &ledst->le_header);
+	isp_get_hdr(isp, &lesrc->le_header, &ledst->le_header);
 	ISP_IOXGET_32(isp, &lesrc->le_reserved, ledst->le_reserved);
 	if (ISP_IS_SBUS(isp)) {
 		ISP_IOXGET_8(isp, &lesrc->le_lun, ledst->le_rsvd);
@@ -1176,202 +2349,554 @@ isp_get_enable_lun(struct ispsoftc *isp, lun_entry_t *lesrc, lun_entry_t *ledst)
 }
 
 void
-isp_put_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
+isp_put_notify(struct ispsoftc *isp, in_entry_t *src, in_entry_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
-	ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
+	isp_put_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_iid);
-		ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_lun);
-		ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_tgt);
-		ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_reserved2);
-		ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_rsvd2);
-		ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_status);
-		ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_type);
-		ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_val);
+		ISP_IOXPUT_8(isp, src->in_lun, &dst->in_iid);
+		ISP_IOXPUT_8(isp, src->in_iid, &dst->in_lun);
+		ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_tgt);
+		ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_reserved2);
+		ISP_IOXPUT_8(isp, src->in_status, &dst->in_rsvd2);
+		ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_status);
+		ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_type);
+		ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_val);
 	} else {
-		ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
-		ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
-		ISP_IOXPUT_8(isp, insrc->in_reserved2, &indst->in_reserved2);
-		ISP_IOXPUT_8(isp, insrc->in_tgt, &indst->in_tgt);
-		ISP_IOXPUT_8(isp, insrc->in_status, &indst->in_status);
-		ISP_IOXPUT_8(isp, insrc->in_rsvd2, &indst->in_rsvd2);
-		ISP_IOXPUT_8(isp, insrc->in_tag_val, &indst->in_tag_val);
-		ISP_IOXPUT_8(isp, insrc->in_tag_type, &indst->in_tag_type);
-	}
-	ISP_IOXPUT_32(isp, insrc->in_flags, &indst->in_flags);
-	ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
+		ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
+		ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
+		ISP_IOXPUT_8(isp, src->in_reserved2, &dst->in_reserved2);
+		ISP_IOXPUT_8(isp, src->in_tgt, &dst->in_tgt);
+		ISP_IOXPUT_8(isp, src->in_status, &dst->in_status);
+		ISP_IOXPUT_8(isp, src->in_rsvd2, &dst->in_rsvd2);
+		ISP_IOXPUT_8(isp, src->in_tag_val, &dst->in_tag_val);
+		ISP_IOXPUT_8(isp, src->in_tag_type, &dst->in_tag_type);
+	}
+	ISP_IOXPUT_32(isp, src->in_flags, &dst->in_flags);
+	ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
 	for (i = 0; i < IN_MSGLEN; i++) {
-		ISP_IOXPUT_8(isp, insrc->in_msg[i], &indst->in_msg[i]);
+		ISP_IOXPUT_8(isp, src->in_msg[i], &dst->in_msg[i]);
 	}
 	for (i = 0; i < IN_RSVDLEN; i++) {
-		ISP_IOXPUT_8(isp, insrc->in_reserved3[i],
-		    &indst->in_reserved3[i]);
+		ISP_IOXPUT_8(isp, src->in_reserved3[i],
+		    &dst->in_reserved3[i]);
 	}
 	for (i = 0; i < QLTM_SENSELEN; i++) {
-		ISP_IOXPUT_8(isp, insrc->in_sense[i],
-		    &indst->in_sense[i]);
+		ISP_IOXPUT_8(isp, src->in_sense[i],
+		    &dst->in_sense[i]);
 	}
 }
 
 void
-isp_get_notify(struct ispsoftc *isp, in_entry_t *insrc, in_entry_t *indst)
+isp_get_notify(struct ispsoftc *isp, in_entry_t *src, in_entry_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
-	ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
+	isp_get_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_iid);
-		ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_lun);
-		ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_tgt);
-		ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_reserved2);
-		ISP_IOXGET_8(isp, &insrc->in_status, indst->in_rsvd2);
-		ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_status);
-		ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_type);
-		ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_val);
+		ISP_IOXGET_8(isp, &src->in_lun, dst->in_iid);
+		ISP_IOXGET_8(isp, &src->in_iid, dst->in_lun);
+		ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_tgt);
+		ISP_IOXGET_8(isp, &src->in_tgt, dst->in_reserved2);
+		ISP_IOXGET_8(isp, &src->in_status, dst->in_rsvd2);
+		ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_status);
+		ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_type);
+		ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_val);
 	} else {
-		ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
-		ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
-		ISP_IOXGET_8(isp, &insrc->in_reserved2, indst->in_reserved2);
-		ISP_IOXGET_8(isp, &insrc->in_tgt, indst->in_tgt);
-		ISP_IOXGET_8(isp, &insrc->in_status, indst->in_status);
-		ISP_IOXGET_8(isp, &insrc->in_rsvd2, indst->in_rsvd2);
-		ISP_IOXGET_8(isp, &insrc->in_tag_val, indst->in_tag_val);
-		ISP_IOXGET_8(isp, &insrc->in_tag_type, indst->in_tag_type);
-	}
-	ISP_IOXGET_32(isp, &insrc->in_flags, indst->in_flags);
-	ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
+		ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
+		ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
+		ISP_IOXGET_8(isp, &src->in_reserved2, dst->in_reserved2);
+		ISP_IOXGET_8(isp, &src->in_tgt, dst->in_tgt);
+		ISP_IOXGET_8(isp, &src->in_status, dst->in_status);
+		ISP_IOXGET_8(isp, &src->in_rsvd2, dst->in_rsvd2);
+		ISP_IOXGET_8(isp, &src->in_tag_val, dst->in_tag_val);
+		ISP_IOXGET_8(isp, &src->in_tag_type, dst->in_tag_type);
+	}
+	ISP_IOXGET_32(isp, &src->in_flags, dst->in_flags);
+	ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
 	for (i = 0; i < IN_MSGLEN; i++) {
-		ISP_IOXGET_8(isp, &insrc->in_msg[i], indst->in_msg[i]);
+		ISP_IOXGET_8(isp, &src->in_msg[i], dst->in_msg[i]);
 	}
 	for (i = 0; i < IN_RSVDLEN; i++) {
-		ISP_IOXGET_8(isp, &insrc->in_reserved3[i],
-		    indst->in_reserved3[i]);
+		ISP_IOXGET_8(isp, &src->in_reserved3[i],
+		    dst->in_reserved3[i]);
 	}
 	for (i = 0; i < QLTM_SENSELEN; i++) {
-		ISP_IOXGET_8(isp, &insrc->in_sense[i],
-		    indst->in_sense[i]);
+		ISP_IOXGET_8(isp, &src->in_sense[i],
+		    dst->in_sense[i]);
 	}
 }
 
 void
-isp_put_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
-    in_fcentry_t *indst)
+isp_put_notify_fc(struct ispsoftc *isp, in_fcentry_t *src,
+    in_fcentry_t *dst)
+{
+	isp_put_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
+	ISP_IOXPUT_8(isp, src->in_lun, &dst->in_lun);
+	ISP_IOXPUT_8(isp, src->in_iid, &dst->in_iid);
+	ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
+	ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
+	ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
+	ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
+	ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
+}
+
+void
+isp_put_notify_fc_e(struct ispsoftc *isp, in_fcentry_e_t *src,
+    in_fcentry_e_t *dst)
+{
+	isp_put_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
+	ISP_IOXPUT_16(isp, src->in_iid, &dst->in_iid);
+	ISP_IOXPUT_16(isp, src->in_scclun, &dst->in_scclun);
+	ISP_IOXPUT_32(isp, src->in_reserved2, &dst->in_reserved2);
+	ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
+	ISP_IOXPUT_16(isp, src->in_task_flags, &dst->in_task_flags);
+	ISP_IOXPUT_16(isp, src->in_seqid, &dst->in_seqid);
+}
+
+void
+isp_put_notify_24xx(struct ispsoftc *isp, in_fcentry_24xx_t *src,
+    in_fcentry_24xx_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXPUT_32(isp, src->in_reserved, &dst->in_reserved);
+	ISP_IOXPUT_16(isp, src->in_nphdl, &dst->in_nphdl);
+	ISP_IOXPUT_16(isp, src->in_reserved1, &dst->in_reserved1);
+	ISP_IOXPUT_16(isp, src->in_flags, &dst->in_flags);
+	ISP_IOXPUT_16(isp, src->in_srr_rxid, &dst->in_srr_rxid);
+	ISP_IOXPUT_16(isp, src->in_status, &dst->in_status);
+	ISP_IOXPUT_8(isp, src->in_status_subcode, &dst->in_status_subcode);
+	ISP_IOXPUT_16(isp, src->in_reserved2, &dst->in_reserved2);
+	ISP_IOXPUT_32(isp, src->in_rxid, &dst->in_rxid);
+	ISP_IOXPUT_16(isp, src->in_srr_reloff_hi, &dst->in_srr_reloff_hi);
+	ISP_IOXPUT_16(isp, src->in_srr_reloff_lo, &dst->in_srr_reloff_lo);
+	ISP_IOXPUT_16(isp, src->in_srr_iu, &dst->in_srr_iu);
+	ISP_IOXPUT_16(isp, src->in_srr_oxid, &dst->in_srr_oxid);
+	for (i = 0; i < 18; i++) {
+		ISP_IOXPUT_8(isp, src->in_reserved3[i], &dst->in_reserved3[i]);
+	}
+	ISP_IOXPUT_8(isp, src->in_reserved4, &dst->in_reserved4);
+	ISP_IOXPUT_8(isp, src->in_vpindex, &dst->in_vpindex);
+	ISP_IOXPUT_32(isp, src->in_reserved5, &dst->in_reserved5);
+	ISP_IOXPUT_16(isp, src->in_portid_lo, &dst->in_portid_lo);
+	ISP_IOXPUT_8(isp, src->in_portid_hi, &dst->in_portid_hi);
+	ISP_IOXPUT_8(isp, src->in_reserved6, &dst->in_reserved6);
+	ISP_IOXPUT_16(isp, src->in_reserved7, &dst->in_reserved7);
+	ISP_IOXPUT_16(isp, src->in_oxid, &dst->in_oxid);
+}
+
+void
+isp_get_notify_fc(struct ispsoftc *isp, in_fcentry_t *src,
+    in_fcentry_t *dst)
 {
-	isp_copy_out_hdr(isp, &insrc->in_header, &indst->in_header);
-	ISP_IOXPUT_32(isp, insrc->in_reserved, &indst->in_reserved);
-	ISP_IOXPUT_8(isp, insrc->in_lun, &indst->in_lun);
-	ISP_IOXPUT_8(isp, insrc->in_iid, &indst->in_iid);
-	ISP_IOXPUT_16(isp, insrc->in_scclun, &indst->in_scclun);
-	ISP_IOXPUT_32(isp, insrc->in_reserved2, &indst->in_reserved2);
-	ISP_IOXPUT_16(isp, insrc->in_status, &indst->in_status);
-	ISP_IOXPUT_16(isp, insrc->in_task_flags, &indst->in_task_flags);
-	ISP_IOXPUT_16(isp, insrc->in_seqid, &indst->in_seqid);
+	isp_get_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
+	ISP_IOXGET_8(isp, &src->in_lun, dst->in_lun);
+	ISP_IOXGET_8(isp, &src->in_iid, dst->in_iid);
+	ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
+	ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
+	ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
+	ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
+	ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
 }
 
 void
-isp_get_notify_fc(struct ispsoftc *isp, in_fcentry_t *insrc,
-    in_fcentry_t *indst)
+isp_get_notify_fc_e(struct ispsoftc *isp, in_fcentry_e_t *src,
+    in_fcentry_e_t *dst)
 {
-	isp_copy_in_hdr(isp, &insrc->in_header, &indst->in_header);
-	ISP_IOXGET_32(isp, &insrc->in_reserved, indst->in_reserved);
-	ISP_IOXGET_8(isp, &insrc->in_lun, indst->in_lun);
-	ISP_IOXGET_8(isp, &insrc->in_iid, indst->in_iid);
-	ISP_IOXGET_16(isp, &insrc->in_scclun, indst->in_scclun);
-	ISP_IOXGET_32(isp, &insrc->in_reserved2, indst->in_reserved2);
-	ISP_IOXGET_16(isp, &insrc->in_status, indst->in_status);
-	ISP_IOXGET_16(isp, &insrc->in_task_flags, indst->in_task_flags);
-	ISP_IOXGET_16(isp, &insrc->in_seqid, indst->in_seqid);
+	isp_get_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
+	ISP_IOXGET_16(isp, &src->in_iid, dst->in_iid);
+	ISP_IOXGET_16(isp, &src->in_scclun, dst->in_scclun);
+	ISP_IOXGET_32(isp, &src->in_reserved2, dst->in_reserved2);
+	ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
+	ISP_IOXGET_16(isp, &src->in_task_flags, dst->in_task_flags);
+	ISP_IOXGET_16(isp, &src->in_seqid, dst->in_seqid);
 }
 
 void
-isp_put_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc,  na_entry_t *nadst)
+isp_get_notify_24xx(struct ispsoftc *isp, in_fcentry_24xx_t *src,
+    in_fcentry_24xx_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
-	ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
+
+	isp_get_hdr(isp, &src->in_header, &dst->in_header);
+	ISP_IOXGET_32(isp, &src->in_reserved, dst->in_reserved);
+	ISP_IOXGET_16(isp, &src->in_nphdl, dst->in_nphdl);
+	ISP_IOXGET_16(isp, &src->in_reserved1, dst->in_reserved1);
+	ISP_IOXGET_16(isp, &src->in_flags, dst->in_flags);
+	ISP_IOXGET_16(isp, &src->in_srr_rxid, dst->in_srr_rxid);
+	ISP_IOXGET_16(isp, &src->in_status, dst->in_status);
+	ISP_IOXGET_8(isp, &src->in_status_subcode, dst->in_status_subcode);
+	ISP_IOXGET_16(isp, &src->in_reserved2, dst->in_reserved2);
+	ISP_IOXGET_32(isp, &src->in_rxid, dst->in_rxid);
+	ISP_IOXGET_16(isp, &src->in_srr_reloff_hi, dst->in_srr_reloff_hi);
+	ISP_IOXGET_16(isp, &src->in_srr_reloff_lo, dst->in_srr_reloff_lo);
+	ISP_IOXGET_16(isp, &src->in_srr_iu, dst->in_srr_iu);
+	ISP_IOXGET_16(isp, &src->in_srr_oxid, dst->in_srr_oxid);
+	for (i = 0; i < 18; i++) {
+		ISP_IOXGET_8(isp, &src->in_reserved3[i], dst->in_reserved3[i]);
+	}
+	ISP_IOXGET_8(isp, &src->in_reserved4, dst->in_reserved4);
+	ISP_IOXGET_8(isp, &src->in_vpindex, dst->in_vpindex);
+	ISP_IOXGET_32(isp, &src->in_reserved5, dst->in_reserved5);
+	ISP_IOXGET_16(isp, &src->in_portid_lo, dst->in_portid_lo);
+	ISP_IOXGET_8(isp, &src->in_portid_hi, dst->in_portid_hi);
+	ISP_IOXGET_8(isp, &src->in_reserved6, dst->in_reserved6);
+	ISP_IOXGET_16(isp, &src->in_reserved7, dst->in_reserved7);
+	ISP_IOXGET_16(isp, &src->in_oxid, dst->in_oxid);
+}
+
+void
+isp_put_notify_ack(struct ispsoftc *isp, na_entry_t *src,  na_entry_t *dst)
+{
+	int i;
+	isp_put_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_iid);
-		ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_lun);
-		ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_event);
-		ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_status);
+		ISP_IOXPUT_8(isp, src->na_lun, &dst->na_iid);
+		ISP_IOXPUT_8(isp, src->na_iid, &dst->na_lun);
+		ISP_IOXPUT_8(isp, src->na_status, &dst->na_event);
+		ISP_IOXPUT_8(isp, src->na_event, &dst->na_status);
 	} else {
-		ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
-		ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
-		ISP_IOXPUT_8(isp, nasrc->na_status, &nadst->na_status);
-		ISP_IOXPUT_8(isp, nasrc->na_event, &nadst->na_event);
+		ISP_IOXPUT_8(isp, src->na_lun, &dst->na_lun);
+		ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
+		ISP_IOXPUT_8(isp, src->na_status, &dst->na_status);
+		ISP_IOXPUT_8(isp, src->na_event, &dst->na_event);
 	}
-	ISP_IOXPUT_32(isp, nasrc->na_flags, &nadst->na_flags);
+	ISP_IOXPUT_32(isp, src->na_flags, &dst->na_flags);
 	for (i = 0; i < NA_RSVDLEN; i++) {
-		ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
-		    &nadst->na_reserved3[i]);
+		ISP_IOXPUT_16(isp, src->na_reserved3[i],
+		    &dst->na_reserved3[i]);
 	}
 }
 
 void
-isp_get_notify_ack(struct ispsoftc *isp, na_entry_t *nasrc, na_entry_t *nadst)
+isp_get_notify_ack(struct ispsoftc *isp, na_entry_t *src, na_entry_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
-	ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
+	isp_get_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
 	if (ISP_IS_SBUS(isp)) {
-		ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_iid);
-		ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_lun);
-		ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_event);
-		ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_status);
+		ISP_IOXGET_8(isp, &src->na_lun, dst->na_iid);
+		ISP_IOXGET_8(isp, &src->na_iid, dst->na_lun);
+		ISP_IOXGET_8(isp, &src->na_status, dst->na_event);
+		ISP_IOXGET_8(isp, &src->na_event, dst->na_status);
 	} else {
-		ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
-		ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
-		ISP_IOXGET_8(isp, &nasrc->na_status, nadst->na_status);
-		ISP_IOXGET_8(isp, &nasrc->na_event, nadst->na_event);
+		ISP_IOXGET_8(isp, &src->na_lun, dst->na_lun);
+		ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
+		ISP_IOXGET_8(isp, &src->na_status, dst->na_status);
+		ISP_IOXGET_8(isp, &src->na_event, dst->na_event);
 	}
-	ISP_IOXGET_32(isp, &nasrc->na_flags, nadst->na_flags);
+	ISP_IOXGET_32(isp, &src->na_flags, dst->na_flags);
 	for (i = 0; i < NA_RSVDLEN; i++) {
-		ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
-		    nadst->na_reserved3[i]);
+		ISP_IOXGET_16(isp, &src->na_reserved3[i],
+		    dst->na_reserved3[i]);
 	}
 }
 
 void
-isp_put_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
-    na_fcentry_t *nadst)
+isp_put_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *src,
+    na_fcentry_t *dst)
 {
 	int i;
-	isp_copy_out_hdr(isp, &nasrc->na_header, &nadst->na_header);
-	ISP_IOXPUT_32(isp, nasrc->na_reserved, &nadst->na_reserved);
-	ISP_IOXPUT_8(isp, nasrc->na_lun, &nadst->na_lun);
-	ISP_IOXPUT_8(isp, nasrc->na_iid, &nadst->na_iid);
-	ISP_IOXPUT_16(isp, nasrc->na_scclun, &nadst->na_scclun);
-	ISP_IOXPUT_16(isp, nasrc->na_flags, &nadst->na_flags);
-	ISP_IOXPUT_16(isp, nasrc->na_reserved2, &nadst->na_reserved2);
-	ISP_IOXPUT_16(isp, nasrc->na_status, &nadst->na_status);
-	ISP_IOXPUT_16(isp, nasrc->na_task_flags, &nadst->na_task_flags);
-	ISP_IOXPUT_16(isp, nasrc->na_seqid, &nadst->na_seqid);
+	isp_put_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
+	ISP_IOXPUT_8(isp, src->na_reserved1, &dst->na_reserved1);
+	ISP_IOXPUT_8(isp, src->na_iid, &dst->na_iid);
+	ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
+	ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
+	ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
+	ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
+	ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
+	ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
 	for (i = 0; i < NA2_RSVDLEN; i++) {
-		ISP_IOXPUT_16(isp, nasrc->na_reserved3[i],
-		    &nadst->na_reserved3[i]);
+		ISP_IOXPUT_16(isp, src->na_reserved3[i],
+		    &dst->na_reserved3[i]);
 	}
 }
 
 void
-isp_get_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *nasrc,
-    na_fcentry_t *nadst)
+isp_put_notify_ack_fc_e(struct ispsoftc *isp, na_fcentry_e_t *src,
+    na_fcentry_e_t *dst)
 {
 	int i;
-	isp_copy_in_hdr(isp, &nasrc->na_header, &nadst->na_header);
-	ISP_IOXGET_32(isp, &nasrc->na_reserved, nadst->na_reserved);
-	ISP_IOXGET_8(isp, &nasrc->na_lun, nadst->na_lun);
-	ISP_IOXGET_8(isp, &nasrc->na_iid, nadst->na_iid);
-	ISP_IOXGET_16(isp, &nasrc->na_scclun, nadst->na_scclun);
-	ISP_IOXGET_16(isp, &nasrc->na_flags, nadst->na_flags);
-	ISP_IOXGET_16(isp, &nasrc->na_reserved2, nadst->na_reserved2);
-	ISP_IOXGET_16(isp, &nasrc->na_status, nadst->na_status);
-	ISP_IOXGET_16(isp, &nasrc->na_task_flags, nadst->na_task_flags);
-	ISP_IOXGET_16(isp, &nasrc->na_seqid, nadst->na_seqid);
+	isp_put_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXPUT_32(isp, src->na_reserved, &dst->na_reserved);
+	ISP_IOXPUT_16(isp, src->na_iid, &dst->na_iid);
+	ISP_IOXPUT_16(isp, src->na_response, &dst->na_response);
+	ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
+	ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
+	ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
+	ISP_IOXPUT_16(isp, src->na_task_flags, &dst->na_task_flags);
+	ISP_IOXPUT_16(isp, src->na_seqid, &dst->na_seqid);
 	for (i = 0; i < NA2_RSVDLEN; i++) {
-		ISP_IOXGET_16(isp, &nasrc->na_reserved3[i],
-		    nadst->na_reserved3[i]);
+		ISP_IOXPUT_16(isp, src->na_reserved3[i],
+		    &dst->na_reserved3[i]);
 	}
 }
-#endif
+
+void
+isp_put_notify_24xx_ack(struct ispsoftc *isp, na_fcentry_24xx_t *src,
+    na_fcentry_24xx_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXPUT_32(isp, src->na_handle, &dst->na_handle);
+	ISP_IOXPUT_16(isp, src->na_nphdl, &dst->na_nphdl);
+	ISP_IOXPUT_16(isp, src->na_reserved1, &dst->na_reserved1);
+	ISP_IOXPUT_16(isp, src->na_flags, &dst->na_flags);
+	ISP_IOXPUT_16(isp, src->na_srr_rxid, &dst->na_srr_rxid);
+	ISP_IOXPUT_16(isp, src->na_status, &dst->na_status);
+	ISP_IOXPUT_8(isp, src->na_status_subcode, &dst->na_status_subcode);
+	ISP_IOXPUT_16(isp, src->na_reserved2, &dst->na_reserved2);
+	ISP_IOXPUT_32(isp, src->na_rxid, &dst->na_rxid);
+	ISP_IOXPUT_16(isp, src->na_srr_reloff_hi, &dst->na_srr_reloff_hi);
+	ISP_IOXPUT_16(isp, src->na_srr_reloff_lo, &dst->na_srr_reloff_lo);
+	ISP_IOXPUT_16(isp, src->na_srr_iu, &dst->na_srr_iu);
+	ISP_IOXPUT_16(isp, src->na_srr_flags, &dst->na_srr_flags);
+	for (i = 0; i < 18; i++) {
+		ISP_IOXPUT_8(isp, src->na_reserved3[i], &dst->na_reserved3[i]);
+	}
+	ISP_IOXPUT_8(isp, src->na_reserved4, &dst->na_reserved4);
+	ISP_IOXPUT_8(isp, src->na_vpindex, &dst->na_vpindex);
+	ISP_IOXPUT_8(isp, src->na_srr_reject_vunique,
+	    &dst->na_srr_reject_vunique);
+	ISP_IOXPUT_8(isp, src->na_srr_reject_explanation,
+	    &dst->na_srr_reject_explanation);
+	ISP_IOXPUT_8(isp, src->na_srr_reject_code, &dst->na_srr_reject_code);
+	ISP_IOXPUT_8(isp, src->na_reserved5, &dst->na_reserved5);
+	for (i = 0; i < 6; i++) {
+		ISP_IOXPUT_8(isp, src->na_reserved6[i], &dst->na_reserved6[i]);
+	}
+	ISP_IOXPUT_16(isp, src->na_oxid, &dst->na_oxid);
+}
+
+void
+isp_get_notify_ack_fc(struct ispsoftc *isp, na_fcentry_t *src,
+    na_fcentry_t *dst)
+{
+	int i;
+	isp_get_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
+	ISP_IOXGET_8(isp, &src->na_reserved1, dst->na_reserved1);
+	ISP_IOXGET_8(isp, &src->na_iid, dst->na_iid);
+	ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
+	ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
+	ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
+	ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
+	ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
+	ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
+	for (i = 0; i < NA2_RSVDLEN; i++) {
+		ISP_IOXGET_16(isp, &src->na_reserved3[i],
+		    dst->na_reserved3[i]);
+	}
+}
+
+void
+isp_get_notify_ack_fc_e(struct ispsoftc *isp, na_fcentry_e_t *src,
+    na_fcentry_e_t *dst)
+{
+	int i;
+	isp_get_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXGET_32(isp, &src->na_reserved, dst->na_reserved);
+	ISP_IOXGET_16(isp, &src->na_iid, dst->na_iid);
+	ISP_IOXGET_16(isp, &src->na_response, dst->na_response);
+	ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
+	ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
+	ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
+	ISP_IOXGET_16(isp, &src->na_task_flags, dst->na_task_flags);
+	ISP_IOXGET_16(isp, &src->na_seqid, dst->na_seqid);
+	for (i = 0; i < NA2_RSVDLEN; i++) {
+		ISP_IOXGET_16(isp, &src->na_reserved3[i],
+		    dst->na_reserved3[i]);
+	}
+}
+
+void
+isp_get_notify_ack_24xx(struct ispsoftc *isp, na_fcentry_24xx_t *src,
+    na_fcentry_24xx_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->na_header, &dst->na_header);
+	ISP_IOXGET_32(isp, &src->na_handle, dst->na_handle);
+	ISP_IOXGET_16(isp, &src->na_nphdl, dst->na_nphdl);
+	ISP_IOXGET_16(isp, &src->na_reserved1, dst->na_reserved1);
+	ISP_IOXGET_16(isp, &src->na_flags, dst->na_flags);
+	ISP_IOXGET_16(isp, &src->na_srr_rxid, dst->na_srr_rxid);
+	ISP_IOXGET_16(isp, &src->na_status, dst->na_status);
+	ISP_IOXGET_8(isp, &src->na_status_subcode, dst->na_status_subcode);
+	ISP_IOXGET_16(isp, &src->na_reserved2, dst->na_reserved2);
+	ISP_IOXGET_32(isp, &src->na_rxid, dst->na_rxid);
+	ISP_IOXGET_16(isp, &src->na_srr_reloff_hi, dst->na_srr_reloff_hi);
+	ISP_IOXGET_16(isp, &src->na_srr_reloff_lo, dst->na_srr_reloff_lo);
+	ISP_IOXGET_16(isp, &src->na_srr_iu, dst->na_srr_iu);
+	ISP_IOXGET_16(isp, &src->na_srr_flags, dst->na_srr_flags);
+	for (i = 0; i < 18; i++) {
+		ISP_IOXGET_8(isp, &src->na_reserved3[i], dst->na_reserved3[i]);
+	}
+	ISP_IOXGET_8(isp, &src->na_reserved4, dst->na_reserved4);
+	ISP_IOXGET_8(isp, &src->na_vpindex, dst->na_vpindex);
+	ISP_IOXGET_8(isp, &src->na_srr_reject_vunique,
+	    dst->na_srr_reject_vunique);
+	ISP_IOXGET_8(isp, &src->na_srr_reject_explanation,
+	    dst->na_srr_reject_explanation);
+	ISP_IOXGET_8(isp, &src->na_srr_reject_code, dst->na_srr_reject_code);
+	ISP_IOXGET_8(isp, &src->na_reserved5, dst->na_reserved5);
+	for (i = 0; i < 6; i++) {
+		ISP_IOXGET_8(isp, &src->na_reserved6[i], dst->na_reserved6[i]);
+	}
+	ISP_IOXGET_16(isp, &src->na_oxid, dst->na_oxid);
+}
+
+void
+isp_get_abts(struct ispsoftc *isp, abts_t *src, abts_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->abts_header, &dst->abts_header);
+	for (i = 0; i < 6; i++) {
+		ISP_IOXGET_8(isp, &src->abts_reserved0[i],
+		    dst->abts_reserved0[i]);
+	}
+	ISP_IOXGET_16(isp, &src->abts_nphdl, dst->abts_nphdl);
+	ISP_IOXGET_16(isp, &src->abts_reserved1, dst->abts_reserved1);
+	ISP_IOXGET_16(isp, &src->abts_sof, dst->abts_sof);
+	ISP_IOXGET_32(isp, &src->abts_rxid_abts, dst->abts_rxid_abts);
+	ISP_IOXGET_16(isp, &src->abts_did_lo, dst->abts_did_lo);
+	ISP_IOXGET_8(isp, &src->abts_did_hi, dst->abts_did_hi);
+	ISP_IOXGET_8(isp, &src->abts_r_ctl, dst->abts_r_ctl);
+	ISP_IOXGET_16(isp, &src->abts_sid_lo, dst->abts_sid_lo);
+	ISP_IOXGET_8(isp, &src->abts_sid_hi, dst->abts_sid_hi);
+	ISP_IOXGET_8(isp, &src->abts_cs_ctl, dst->abts_cs_ctl);
+	ISP_IOXGET_16(isp, &src->abts_fs_ctl, dst->abts_fs_ctl);
+	ISP_IOXGET_8(isp, &src->abts_f_ctl, dst->abts_f_ctl);
+	ISP_IOXGET_8(isp, &src->abts_type, dst->abts_type);
+	ISP_IOXGET_16(isp, &src->abts_seq_cnt, dst->abts_seq_cnt);
+	ISP_IOXGET_8(isp, &src->abts_df_ctl, dst->abts_df_ctl);
+	ISP_IOXGET_8(isp, &src->abts_seq_id, dst->abts_seq_id);
+	ISP_IOXGET_16(isp, &src->abts_rx_id, dst->abts_rx_id);
+	ISP_IOXGET_16(isp, &src->abts_ox_id, dst->abts_ox_id);
+	ISP_IOXGET_32(isp, &src->abts_param, dst->abts_param);
+	for (i = 0; i < 16; i++) {
+	ISP_IOXGET_8(isp, &src->abts_reserved2[i],
+		    dst->abts_reserved2[i]);
+	}
+	ISP_IOXGET_32(isp, &src->abts_rxid_task, dst->abts_rxid_task);
+}
+
+void
+isp_put_abts_rsp(struct ispsoftc *isp, abts_rsp_t *src, abts_rsp_t *dst)
+{
+	int i;
+
+	isp_put_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
+	ISP_IOXPUT_32(isp, src->abts_rsp_handle, &dst->abts_rsp_handle);
+	ISP_IOXPUT_16(isp, src->abts_rsp_status, &dst->abts_rsp_status);
+	ISP_IOXPUT_16(isp, src->abts_rsp_nphdl, &dst->abts_rsp_nphdl);
+	ISP_IOXPUT_16(isp, src->abts_rsp_ctl_flags, &dst->abts_rsp_ctl_flags);
+	ISP_IOXPUT_16(isp, src->abts_rsp_sof, &dst->abts_rsp_sof);
+	ISP_IOXPUT_32(isp, src->abts_rsp_rxid_abts, &dst->abts_rsp_rxid_abts);
+	ISP_IOXPUT_16(isp, src->abts_rsp_did_lo, &dst->abts_rsp_did_lo);
+	ISP_IOXPUT_8(isp, src->abts_rsp_did_hi, &dst->abts_rsp_did_hi);
+	ISP_IOXPUT_8(isp, src->abts_rsp_r_ctl, &dst->abts_rsp_r_ctl);
+	ISP_IOXPUT_16(isp, src->abts_rsp_sid_lo, &dst->abts_rsp_sid_lo);
+	ISP_IOXPUT_8(isp, src->abts_rsp_sid_hi, &dst->abts_rsp_sid_hi);
+	ISP_IOXPUT_8(isp, src->abts_rsp_cs_ctl, &dst->abts_rsp_cs_ctl);
+	ISP_IOXPUT_16(isp, src->abts_rsp_f_ctl_lo, &dst->abts_rsp_f_ctl_lo);
+	ISP_IOXPUT_8(isp, src->abts_rsp_f_ctl_hi, &dst->abts_rsp_f_ctl_hi);
+	ISP_IOXPUT_8(isp, src->abts_rsp_type, &dst->abts_rsp_type);
+	ISP_IOXPUT_16(isp, src->abts_rsp_seq_cnt, &dst->abts_rsp_seq_cnt);
+	ISP_IOXPUT_8(isp, src->abts_rsp_df_ctl, &dst->abts_rsp_df_ctl);
+	ISP_IOXPUT_8(isp, src->abts_rsp_seq_id, &dst->abts_rsp_seq_id);
+	ISP_IOXPUT_16(isp, src->abts_rsp_rx_id, &dst->abts_rsp_rx_id);
+	ISP_IOXPUT_16(isp, src->abts_rsp_ox_id, &dst->abts_rsp_ox_id);
+	ISP_IOXPUT_32(isp, src->abts_rsp_param, &dst->abts_rsp_param);
+	if (src->abts_rsp_r_ctl == BA_ACC) {
+		ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.reserved,
+		    &dst->abts_rsp_payload.ba_acc.reserved);
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.last_seq_id,
+		    &dst->abts_rsp_payload.ba_acc.last_seq_id);
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_acc.seq_id_valid,
+		    &dst->abts_rsp_payload.ba_acc.seq_id_valid);
+		ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_rx_id,
+		    &dst->abts_rsp_payload.ba_acc.aborted_rx_id);
+		ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.aborted_ox_id,
+		    &dst->abts_rsp_payload.ba_acc.aborted_ox_id);
+		ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.high_seq_cnt,
+		    &dst->abts_rsp_payload.ba_acc.high_seq_cnt);
+		ISP_IOXPUT_16(isp, src->abts_rsp_payload.ba_acc.low_seq_cnt,
+		    &dst->abts_rsp_payload.ba_acc.low_seq_cnt);
+		for (i = 0; i < 4; i++) {
+			ISP_IOXPUT_16(isp,
+			    src->abts_rsp_payload.ba_acc.reserved2[i],
+			    &dst->abts_rsp_payload.ba_acc.reserved2[i]);
+		}
+	} else if (src->abts_rsp_r_ctl == BA_RJT) {
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.vendor_unique,
+		    &dst->abts_rsp_payload.ba_rjt.vendor_unique);
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.explanation,
+		    &dst->abts_rsp_payload.ba_rjt.explanation);
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reason,
+		    &dst->abts_rsp_payload.ba_rjt.reason);
+		ISP_IOXPUT_8(isp, src->abts_rsp_payload.ba_rjt.reserved,
+		    &dst->abts_rsp_payload.ba_rjt.reserved);
+		for (i = 0; i < 12; i++) {
+			ISP_IOXPUT_16(isp,
+			    src->abts_rsp_payload.ba_rjt.reserved2[i],
+			    &dst->abts_rsp_payload.ba_rjt.reserved2[i]);
+		}
+	} else {
+		for (i = 0; i < 16; i++) {
+			ISP_IOXPUT_8(isp, src->abts_rsp_payload.reserved[i],
+			    &dst->abts_rsp_payload.reserved[i]);
+		}
+	}
+	ISP_IOXPUT_32(isp, src->abts_rsp_rxid_task, &dst->abts_rsp_rxid_task);
+}
+
+void
+isp_get_abts_rsp(struct ispsoftc *isp, abts_rsp_t *src, abts_rsp_t *dst)
+{
+	int i;
+
+	isp_get_hdr(isp, &src->abts_rsp_header, &dst->abts_rsp_header);
+	ISP_IOXGET_32(isp, &src->abts_rsp_handle, dst->abts_rsp_handle);
+	ISP_IOXGET_16(isp, &src->abts_rsp_status, dst->abts_rsp_status);
+	ISP_IOXGET_16(isp, &src->abts_rsp_nphdl, dst->abts_rsp_nphdl);
+	ISP_IOXGET_16(isp, &src->abts_rsp_ctl_flags, dst->abts_rsp_ctl_flags);
+	ISP_IOXGET_16(isp, &src->abts_rsp_sof, dst->abts_rsp_sof);
+	ISP_IOXGET_32(isp, &src->abts_rsp_rxid_abts, dst->abts_rsp_rxid_abts);
+	ISP_IOXGET_16(isp, &src->abts_rsp_did_lo, dst->abts_rsp_did_lo);
+	ISP_IOXGET_8(isp, &src->abts_rsp_did_hi, dst->abts_rsp_did_hi);
+	ISP_IOXGET_8(isp, &src->abts_rsp_r_ctl, dst->abts_rsp_r_ctl);
+	ISP_IOXGET_16(isp, &src->abts_rsp_sid_lo, dst->abts_rsp_sid_lo);
+	ISP_IOXGET_8(isp, &src->abts_rsp_sid_hi, dst->abts_rsp_sid_hi);
+	ISP_IOXGET_8(isp, &src->abts_rsp_cs_ctl, dst->abts_rsp_cs_ctl);
+	ISP_IOXGET_16(isp, &src->abts_rsp_f_ctl_lo, dst->abts_rsp_f_ctl_lo);
+	ISP_IOXGET_8(isp, &src->abts_rsp_f_ctl_hi, dst->abts_rsp_f_ctl_hi);
+	ISP_IOXGET_8(isp, &src->abts_rsp_type, dst->abts_rsp_type);
+	ISP_IOXGET_16(isp, &src->abts_rsp_seq_cnt, dst->abts_rsp_seq_cnt);
+	ISP_IOXGET_8(isp, &src->abts_rsp_df_ctl, dst->abts_rsp_df_ctl);
+	ISP_IOXGET_8(isp, &src->abts_rsp_seq_id, dst->abts_rsp_seq_id);
+	ISP_IOXGET_16(isp, &src->abts_rsp_rx_id, dst->abts_rsp_rx_id);
+	ISP_IOXGET_16(isp, &src->abts_rsp_ox_id, dst->abts_rsp_ox_id);
+	ISP_IOXGET_32(isp, &src->abts_rsp_param, dst->abts_rsp_param);
+	for (i = 0; i < 8; i++) {
+		ISP_IOXGET_8(isp, &src->abts_rsp_payload.rsp.reserved[i],
+		    dst->abts_rsp_payload.rsp.reserved[i]);
+	}
+	ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode1,
+	    dst->abts_rsp_payload.rsp.subcode1);
+	ISP_IOXGET_32(isp, &src->abts_rsp_payload.rsp.subcode2,
+	    dst->abts_rsp_payload.rsp.subcode2);
+	ISP_IOXGET_32(isp, &src->abts_rsp_rxid_task, dst->abts_rsp_rxid_task);
+}
+#endif	/* ISP_TARGET_MODE */
diff --git a/sys/dev/ic/isp_library.h b/sys/dev/ic/isp_library.h
index 3b9ec400c87..a42dcd322ec 100644
--- a/sys/dev/ic/isp_library.h
+++ b/sys/dev/ic/isp_library.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: isp_library.h,v 1.1 2008/11/16 00:00:13 krw Exp $ */
+/*	$OpenBSD: isp_library.h,v 1.2 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/isp_library.h,v 1.8 2007/04/02 01:04:20 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -29,122 +29,197 @@
 #ifndef	_ISP_LIBRARY_H
 #define	_ISP_LIBRARY_H
 
-#include <dev/ic/isp_openbsd.h>
-
-extern int isp_save_xs(struct ispsoftc *, XS_T *, u_int16_t *);
-extern XS_T *isp_find_xs(struct ispsoftc *, u_int16_t);
-extern u_int16_t isp_find_handle(struct ispsoftc *, XS_T *);
-extern int isp_handle_index(u_int16_t);
-extern void isp_destroy_handle(struct ispsoftc *, u_int16_t);
-extern void isp_remove_handle(struct ispsoftc *, XS_T *);
-
-extern int
-isp_getrqentry(struct ispsoftc *, u_int16_t *, u_int16_t *, void **);
-
+extern int isp_save_xs(ispsoftc_t *, XS_T *, u_int32_t *);
+extern XS_T *isp_find_xs(ispsoftc_t *, u_int32_t);
+extern u_int32_t isp_find_handle(ispsoftc_t *, XS_T *);
+extern u_int32_t isp_handle_index(u_int32_t);
+extern void isp_destroy_handle(ispsoftc_t *, u_int32_t);
+extern int isp_getrqentry(ispsoftc_t *, u_int32_t *, u_int32_t *, void **);
+extern void isp_print_qentry (ispsoftc_t *, char *, int, void *);
+extern void isp_print_bytes(ispsoftc_t *, const char *, int, void *);
+extern int isp_fc_runstate(ispsoftc_t *, int);
+extern void isp_dump_portdb(ispsoftc_t *);
+extern void isp_shutdown(ispsoftc_t *);
+extern void isp_put_hdr(ispsoftc_t *, isphdr_t *, isphdr_t *);
+extern void isp_get_hdr(ispsoftc_t *, isphdr_t *, isphdr_t *);
+extern int isp_get_response_type(ispsoftc_t *, isphdr_t *);
 extern void
-isp_print_qentry (struct ispsoftc *, char *, int, void *);
-
-
-#define	TBA	(4 * (((QENTRY_LEN >> 2) * 3) + 1) + 1)
-
+isp_put_request(ispsoftc_t *, ispreq_t *, ispreq_t *);
 extern void
-isp_print_bytes(struct ispsoftc *, char *, int, void *);
-
-extern int isp_fc_runstate(struct ispsoftc *, int);
-
-extern void isp_copy_out_hdr(struct ispsoftc *, isphdr_t *, isphdr_t *);
-extern void isp_copy_in_hdr(struct ispsoftc *, isphdr_t *, isphdr_t *);
-extern int isp_get_response_type(struct ispsoftc *, isphdr_t *);
-
+isp_put_marker(ispsoftc_t *, isp_marker_t *, isp_marker_t *);
+extern void
+isp_put_marker_24xx(ispsoftc_t *, isp_marker_24xx_t *, isp_marker_24xx_t *);
+extern void
+isp_put_request_t2(ispsoftc_t *, ispreqt2_t *, ispreqt2_t *);
+extern void
+isp_put_request_t2e(ispsoftc_t *, ispreqt2e_t *, ispreqt2e_t *);
 extern void
-isp_put_request(struct ispsoftc *, ispreq_t *, ispreq_t *);
+isp_put_request_t3(ispsoftc_t *, ispreqt3_t *, ispreqt3_t *);
 extern void
-isp_put_request_t2(struct ispsoftc *, ispreqt2_t *, ispreqt2_t *);
+isp_put_request_t3e(ispsoftc_t *, ispreqt3e_t *, ispreqt3e_t *);
 extern void
-isp_put_request_t3(struct ispsoftc *, ispreqt3_t *, ispreqt3_t *);
+isp_put_extended_request(ispsoftc_t *, ispextreq_t *, ispextreq_t *);
 extern void
-isp_put_extended_request(struct ispsoftc *, ispextreq_t *, ispextreq_t *);
+isp_put_request_t7(ispsoftc_t *, ispreqt7_t *, ispreqt7_t *);
 extern void
-isp_put_cont_req(struct ispsoftc *, ispcontreq_t *, ispcontreq_t *);
+isp_put_24xx_abrt(ispsoftc_t *, isp24xx_abrt_t *, isp24xx_abrt_t *);
 extern void
-isp_put_cont64_req(struct ispsoftc *, ispcontreq64_t *, ispcontreq64_t *);
+isp_put_cont_req(ispsoftc_t *, ispcontreq_t *, ispcontreq_t *);
 extern void
-isp_get_response(struct ispsoftc *, ispstatusreq_t *, ispstatusreq_t *);
+isp_put_cont64_req(ispsoftc_t *, ispcontreq64_t *, ispcontreq64_t *);
 extern void
-isp_get_response_x(struct ispsoftc *, ispstatus_cont_t *, ispstatus_cont_t *);
+isp_get_response(ispsoftc_t *, ispstatusreq_t *, ispstatusreq_t *);
+extern void isp_get_24xx_response(ispsoftc_t *, isp24xx_statusreq_t *,
+    isp24xx_statusreq_t *);
+void
+isp_get_24xx_abrt(ispsoftc_t *, isp24xx_abrt_t *, isp24xx_abrt_t *);
 extern void
-isp_get_rio2(struct ispsoftc *, isp_rio2_t *, isp_rio2_t *);
+isp_get_rio2(ispsoftc_t *, isp_rio2_t *, isp_rio2_t *);
 extern void
-isp_put_icb(struct ispsoftc *, isp_icb_t *, isp_icb_t *);
+isp_put_icb(ispsoftc_t *, isp_icb_t *, isp_icb_t *);
 extern void
-isp_get_pdb(struct ispsoftc *, isp_pdb_t *, isp_pdb_t *);
+isp_put_icb_2400(ispsoftc_t *, isp_icb_2400_t *, isp_icb_2400_t *);
 extern void
-isp_get_ct_hdr(struct ispsoftc *isp, ct_hdr_t *, ct_hdr_t *);
+isp_get_pdb_21xx(ispsoftc_t *, isp_pdb_21xx_t *, isp_pdb_21xx_t *);
 extern void
-isp_put_sns_request(struct ispsoftc *, sns_screq_t *, sns_screq_t *);
+isp_get_pdb_24xx(ispsoftc_t *, isp_pdb_24xx_t *, isp_pdb_24xx_t *);
 extern void
-isp_put_gid_ft_request(struct ispsoftc *, sns_gid_ft_req_t *,
+isp_get_plogx(ispsoftc_t *, isp_plogx_t *, isp_plogx_t *);
+extern void
+isp_put_plogx(ispsoftc_t *, isp_plogx_t *, isp_plogx_t *);
+extern void
+isp_get_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *, isp_ct_pt_t *);
+extern void
+isp_get_ms(ispsoftc_t *isp, isp_ms_t *, isp_ms_t *);
+extern void
+isp_put_ct_pt(ispsoftc_t *isp, isp_ct_pt_t *, isp_ct_pt_t *);
+extern void
+isp_put_ms(ispsoftc_t *isp, isp_ms_t *, isp_ms_t *);
+extern void
+isp_put_sns_request(ispsoftc_t *, sns_screq_t *, sns_screq_t *);
+extern void
+isp_put_gid_ft_request(ispsoftc_t *, sns_gid_ft_req_t *,
     sns_gid_ft_req_t *);
 extern void
-isp_put_gxn_id_request(struct ispsoftc *, sns_gxn_id_req_t *,
+isp_put_gxn_id_request(ispsoftc_t *, sns_gxn_id_req_t *,
     sns_gxn_id_req_t *);
 extern void
-isp_get_sns_response(struct ispsoftc *, sns_scrsp_t *, sns_scrsp_t *, int);
+isp_get_sns_response(ispsoftc_t *, sns_scrsp_t *, sns_scrsp_t *, int);
 extern void
-isp_get_gid_ft_response(struct ispsoftc *, sns_gid_ft_rsp_t *,
+isp_get_gid_ft_response(ispsoftc_t *, sns_gid_ft_rsp_t *,
     sns_gid_ft_rsp_t *, int);
 extern void
-isp_get_gxn_id_response(struct ispsoftc *, sns_gxn_id_rsp_t *,
+isp_get_gxn_id_response(ispsoftc_t *, sns_gxn_id_rsp_t *,
     sns_gxn_id_rsp_t *);
 extern void
-isp_get_gff_id_response(struct ispsoftc *, sns_gff_id_rsp_t *,
+isp_get_gff_id_response(ispsoftc_t *, sns_gff_id_rsp_t *,
     sns_gff_id_rsp_t *);
 extern void
-isp_get_ga_nxt_response(struct ispsoftc *, sns_ga_nxt_rsp_t *,
+isp_get_ga_nxt_response(ispsoftc_t *, sns_ga_nxt_rsp_t *,
     sns_ga_nxt_rsp_t *);
+extern void
+isp_get_els(ispsoftc_t *, els_t *, els_t *);
+extern void
+isp_put_els(ispsoftc_t *, els_t *, els_t *);
+extern void
+isp_get_fc_hdr(ispsoftc_t *, fc_hdr_t *, fc_hdr_t *);
+extern void
+isp_get_fcp_cmnd_iu(ispsoftc_t *, fcp_cmnd_iu_t *, fcp_cmnd_iu_t *);
+extern void isp_put_rft_id(ispsoftc_t *, rft_id_t *, rft_id_t *);
+extern void isp_get_ct_hdr(ispsoftc_t *isp, ct_hdr_t *, ct_hdr_t *);
+extern void isp_put_ct_hdr(ispsoftc_t *isp, ct_hdr_t *, ct_hdr_t *);
+
+#define	ISP_HANDLE_MASK		0x7fff
+
 #ifdef	ISP_TARGET_MODE
-#ifndef	_ISP_TARGET_H
+#if	defined(__NetBSD__) || defined(__OpenBSD__)
+#include <dev/ic/isp_target.h>
+#elif 	defined(__FreeBSD__)
+#include <dev/isp/isp_target.h>
+#else
 #include "isp_target.h"
 #endif
+
+#define	IS_TARGET_HANDLE(x)     ((x) & 0x8000)
+
+extern int isp_save_xs_tgt(ispsoftc_t *, void *, u_int32_t *);
+extern void *isp_find_xs_tgt(ispsoftc_t *, u_int32_t);
+extern u_int32_t isp_find_tgt_handle(ispsoftc_t *, void *);
+extern void isp_destroy_tgt_handle(ispsoftc_t *, u_int32_t);
+
 extern void
-isp_put_atio(struct ispsoftc *, at_entry_t *, at_entry_t *);
+isp_put_atio(ispsoftc_t *, at_entry_t *, at_entry_t *);
 extern void
-isp_get_atio(struct ispsoftc *, at_entry_t *, at_entry_t *);
+isp_get_atio(ispsoftc_t *, at_entry_t *, at_entry_t *);
 extern void
-isp_put_atio2(struct ispsoftc *, at2_entry_t *, at2_entry_t *);
+isp_put_atio2(ispsoftc_t *, at2_entry_t *, at2_entry_t *);
 extern void
-isp_get_atio2(struct ispsoftc *, at2_entry_t *, at2_entry_t *);
+isp_put_atio2e(ispsoftc_t *, at2e_entry_t *, at2e_entry_t *);
 extern void
-isp_put_ctio(struct ispsoftc *, ct_entry_t *, ct_entry_t *);
+isp_get_atio2(ispsoftc_t *, at2_entry_t *, at2_entry_t *);
 extern void
-isp_get_ctio(struct ispsoftc *, ct_entry_t *, ct_entry_t *);
+isp_get_atio2e(ispsoftc_t *, at2e_entry_t *, at2e_entry_t *);
 extern void
-isp_put_ctio2(struct ispsoftc *, ct2_entry_t *, ct2_entry_t *);
+isp_get_atio7(ispsoftc_t *isp, at7_entry_t *, at7_entry_t *);
 extern void
-isp_get_ctio2(struct ispsoftc *, ct2_entry_t *, ct2_entry_t *);
+isp_put_ctio(ispsoftc_t *, ct_entry_t *, ct_entry_t *);
 extern void
-isp_put_enable_lun(struct ispsoftc *, lun_entry_t *, lun_entry_t *);
+isp_get_ctio(ispsoftc_t *, ct_entry_t *, ct_entry_t *);
 extern void
-isp_get_enable_lun(struct ispsoftc *, lun_entry_t *, lun_entry_t *);
+isp_put_ctio2(ispsoftc_t *, ct2_entry_t *, ct2_entry_t *);
 extern void
-isp_put_notify(struct ispsoftc *, in_entry_t *, in_entry_t *);
+isp_put_ctio2e(ispsoftc_t *, ct2e_entry_t *, ct2e_entry_t *);
 extern void
-isp_get_notify(struct ispsoftc *, in_entry_t *, in_entry_t *);
+isp_put_ctio7(ispsoftc_t *, ct7_entry_t *, ct7_entry_t *);
 extern void
-isp_put_notify_fc(struct ispsoftc *, in_fcentry_t *, in_fcentry_t *);
+isp_get_ctio2(ispsoftc_t *, ct2_entry_t *, ct2_entry_t *);
 extern void
-isp_get_notify_fc(struct ispsoftc *, in_fcentry_t *, in_fcentry_t *);
+isp_get_ctio2e(ispsoftc_t *, ct2e_entry_t *, ct2e_entry_t *);
 extern void
-isp_put_notify_ack(struct ispsoftc *, na_entry_t *, na_entry_t *);
+isp_get_ctio7(ispsoftc_t *, ct7_entry_t *, ct7_entry_t *);
 extern void
-isp_get_notify_ack(struct ispsoftc *, na_entry_t *, na_entry_t *);
+isp_put_enable_lun(ispsoftc_t *, lun_entry_t *, lun_entry_t *);
 extern void
-isp_put_notify_ack_fc(struct ispsoftc *, na_fcentry_t *, na_fcentry_t *);
+isp_get_enable_lun(ispsoftc_t *, lun_entry_t *, lun_entry_t *);
 extern void
-isp_get_notify_ack_fc(struct ispsoftc *, na_fcentry_t *, na_fcentry_t *);
-#endif
-
-#define	ISP_IS_SBUS(isp)	\
-	(ISP_SBUS_SUPPORTED && (isp)->isp_bustype == ISP_BT_SBUS)
-
+isp_put_notify(ispsoftc_t *, in_entry_t *, in_entry_t *);
+extern void
+isp_get_notify(ispsoftc_t *, in_entry_t *, in_entry_t *);
+extern void
+isp_put_notify_fc(ispsoftc_t *, in_fcentry_t *, in_fcentry_t *);
+extern void
+isp_put_notify_fc_e(ispsoftc_t *, in_fcentry_e_t *, in_fcentry_e_t *);
+extern void
+isp_put_notify_24xx(ispsoftc_t *, in_fcentry_24xx_t *, in_fcentry_24xx_t *);
+extern void
+isp_get_notify_fc(ispsoftc_t *, in_fcentry_t *, in_fcentry_t *);
+extern void
+isp_get_notify_fc_e(ispsoftc_t *, in_fcentry_e_t *, in_fcentry_e_t *);
+extern void
+isp_get_notify_24xx(ispsoftc_t *, in_fcentry_24xx_t *, in_fcentry_24xx_t *);
+extern void
+isp_put_notify_ack(ispsoftc_t *, na_entry_t *, na_entry_t *);
+extern void
+isp_get_notify_ack(ispsoftc_t *, na_entry_t *, na_entry_t *);
+extern void
+isp_put_notify_24xx_ack(ispsoftc_t *, na_fcentry_24xx_t *, na_fcentry_24xx_t *);
+extern void
+isp_put_notify_ack_fc(ispsoftc_t *, na_fcentry_t *, na_fcentry_t *);
+extern void
+isp_put_notify_ack_fc_e(ispsoftc_t *, na_fcentry_e_t *, na_fcentry_e_t *);
+extern void isp_put_notify_ack_24xx(ispsoftc_t *, na_fcentry_24xx_t *,
+    na_fcentry_24xx_t *);
+extern void
+isp_get_notify_ack_fc(ispsoftc_t *, na_fcentry_t *, na_fcentry_t *);
+extern void
+isp_get_notify_ack_fc_e(ispsoftc_t *, na_fcentry_e_t *, na_fcentry_e_t *);
+extern void isp_get_notify_ack_24xx(ispsoftc_t *, na_fcentry_24xx_t *,
+    na_fcentry_24xx_t *);
+extern void
+isp_get_abts(ispsoftc_t *, abts_t *, abts_t *);
+extern void
+isp_put_abts_rsp(ispsoftc_t *, abts_rsp_t *, abts_rsp_t *);
+extern void
+isp_get_abts_rsp(ispsoftc_t *, abts_rsp_t *, abts_rsp_t *);
+#endif	/* ISP_TARGET_MODE */
 #endif	/* _ISP_LIBRARY_H */
diff --git a/sys/dev/ic/isp_openbsd.c b/sys/dev/ic/isp_openbsd.c
index ef65d585b58..1f979ebba07 100644
--- a/sys/dev/ic/isp_openbsd.c
+++ b/sys/dev/ic/isp_openbsd.c
@@ -1,4 +1,4 @@
-/* 	$OpenBSD: isp_openbsd.c,v 1.35 2009/02/16 21:19:06 miod Exp $ */
+/* 	$OpenBSD: isp_openbsd.c,v 1.36 2009/06/24 11:00:53 krw Exp $ */
 /*
  * Platform (OpenBSD) dependent common attachment code for QLogic adapters.
  *
@@ -40,8 +40,6 @@
  *  San Francisco, CA, 94131
  */
 
-/* expand expensive inline functions here. */
-#define EXPENSIVE_INLINE
 #include <dev/ic/isp_openbsd.h>
 
 /*
@@ -66,18 +64,28 @@ static void ispminphys(struct buf *, struct scsi_link *);
 static int32_t ispcmd_slow(XS_T *);
 static int32_t ispcmd(XS_T *);
 
-static struct scsi_device isp_dev = { NULL, NULL, NULL, NULL };
+struct scsi_device isp_dev = { NULL, NULL, NULL, NULL };
 
-static int isp_polled_cmd (struct ispsoftc *, XS_T *);
-static void isp_wdog (void *);
-static void isp_requeue(void *);
-static void isp_trestart(void *);
-static void isp_restart(struct ispsoftc *);
+int isp_polled_cmd (struct ispsoftc *, XS_T *);
+void isp_wdog (void *);
+void isp_make_here(ispsoftc_t *, int);
+void isp_make_gone(ispsoftc_t *, int);
+void isp_requeue(void *);
+void isp_trestart(void *);
+void isp_restart(struct ispsoftc *);
+void isp_add2_blocked_queue(struct ispsoftc *isp, XS_T *xs);
+int isp_mstohz(int ms);
 
 struct cfdriver isp_cd = {
 	NULL, "isp", DV_DULL
 };
 
+static const char *roles[4] = {
+    "(none)", "Target", "Initiator", "Target/Initiator"
+};
+static const char prom3[] =
+    "PortID 0x%06x Departed from Target %u because of %s";
+#define	isp_change_is_bad	0
 
 /*
  * Complete attachment of hardware, include subdevices.
@@ -104,8 +112,7 @@ isp_attach(struct ispsoftc *isp)
 	isp->isp_osinfo._adapter.scsi_cmd = ispcmd_slow;
 	if (IS_FC(isp)) {
 		lptr->adapter_buswidth = MAX_FC_TARG;
-		/* We can set max lun width here */
-		/* loopid set below */
+		lptr->adapter_target = MAX_FC_TARG; /* i.e. ignore. */
 	} else {
 		sdparam *sdp = isp->isp_param;
 		lptr->adapter_buswidth = MAX_TARGETS;
@@ -147,17 +154,10 @@ isp_attach(struct ispsoftc *isp)
 		 */
 		delay(4 * 1000000);
 	} else {
-		fcparam *fcp = isp->isp_param;
-		int defid = MAX_FC_TARG;
 		delay(2 * 1000000);
 		ISP_LOCK(isp);
 		isp_fc_runstate(isp, 10 * 1000000);
-		if (fcp->isp_fwstate == FW_READY &&
-		    fcp->isp_loopstate >= LOOP_PDB_RCVD) {
-			defid = fcp->isp_loopid;
-		}
 		ISP_UNLOCK(isp);
-		lptr->adapter_target = defid;
 	}
 
 	bzero(&saa, sizeof(saa));
@@ -195,7 +195,7 @@ ispminphys(struct buf *bp, struct scsi_link *sl)
 	minphys(bp);
 }
 
-static int32_t
+int32_t
 ispcmd_slow(XS_T *xs)
 {
 	sdparam *sdp;
@@ -273,9 +273,7 @@ ispcmd_slow(XS_T *xs)
 	return (ispcmd(xs));
 }
 
-static INLINE void isp_add2_blocked_queue(struct ispsoftc *, XS_T *);
-
-static INLINE void
+void
 isp_add2_blocked_queue(struct ispsoftc *isp, XS_T *xs)
 {
 	if (isp->isp_osinfo.wqf != NULL) {
@@ -287,7 +285,7 @@ isp_add2_blocked_queue(struct ispsoftc *isp, XS_T *xs)
 	xs->free_list.le_next = NULL;
 }
 
-static int32_t
+int32_t
 ispcmd(XS_T *xs)
 {
 	struct ispsoftc *isp;
@@ -308,16 +306,16 @@ ispcmd(XS_T *xs)
 
 	ISP_LOCK(isp);
 	if (isp->isp_state < ISP_RUNSTATE) {
-		DISABLE_INTS(isp);
+		ISP_DISABLE_INTS(isp);
 		isp_init(isp);
 		if (isp->isp_state != ISP_INITSTATE) {
-			ENABLE_INTS(isp);
+			ISP_ENABLE_INTS(isp);
 			ISP_UNLOCK(isp);
 			XS_SETERR(xs, HBA_BOTCH);
 			return (CMD_COMPLETE);
 		}
 		isp->isp_state = ISP_RUNSTATE;
-		ENABLE_INTS(isp);
+		ISP_ENABLE_INTS(isp);
 	}
 
 	/*
@@ -385,7 +383,7 @@ ispcmd(XS_T *xs)
 	return (result);
 }
 
-static int
+int
 isp_polled_cmd(struct ispsoftc *isp, XS_T *xs)
 {
 	int result;
@@ -418,7 +416,8 @@ isp_polled_cmd(struct ispsoftc *isp, XS_T *xs)
 		infinite = 1;
 
 	while (mswait || infinite) {
-		u_int16_t isr, sema, mbox;
+		u_int32_t isr;
+		u_int16_t sema, mbox;
 		if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
 			isp_intr(isp, isr, sema, mbox);
 			if (XS_CMD_DONE_P(xs)) {
@@ -470,7 +469,7 @@ isp_done(XS_T *xs)
 	}
 }
 
-static void
+void
 isp_wdog(void *arg)
 {
 	XS_T *xs = arg;
@@ -485,7 +484,8 @@ isp_wdog(void *arg)
 	ISP_LOCK(isp);
 	handle = isp_find_handle(isp, xs);
 	if (handle) {
-		u_int16_t isr, sema, mbox;
+		u_int32_t isr;
+		u_int16_t sema, mbox;
 
 		if (XS_CMD_DONE_P(xs)) {
 			isp_prt(isp, ISP_LOGDEBUG1,
@@ -534,7 +534,7 @@ isp_wdog(void *arg)
 			XS_CMD_S_CLEAR(xs);
 			isp_done(xs);
 		} else {
-			u_int16_t nxti, optr;
+			u_int32_t optr, nxti;
 			ispreq_t local, *mp = &local, *qe;
 
 			isp_prt(isp, ISP_LOGWARN,
@@ -551,7 +551,7 @@ isp_wdog(void *arg)
 			MEMZERO((void *) mp, sizeof (*mp));
 			mp->req_header.rqs_entry_count = 1;
 			mp->req_header.rqs_entry_type = RQSTYPE_MARKER;
-			mp->req_modifier = SYNC_ALL;
+			mp->req_cdblen = SYNC_ALL;
 			mp->req_target = XS_CHANNEL(xs) << 7;
 			isp_put_request(isp, mp, qe);
 			ISP_ADD_REQUEST(isp, nxti);
@@ -562,6 +562,18 @@ isp_wdog(void *arg)
 	ISP_UNLOCK(isp);
 }
 
+void
+isp_make_here(ispsoftc_t *isp, int tgt)
+{
+	isp_prt(isp, ISP_LOGINFO, "target %d has arrived", tgt);
+}
+
+void
+isp_make_gone(ispsoftc_t *isp, int tgt)
+{
+	isp_prt(isp, ISP_LOGINFO, "target %d has departed", tgt);
+}
+
 /*
  * Free any associated resources prior to decommissioning and
  * set the card to a known state (so it doesn't wake up and kick
@@ -576,7 +588,7 @@ isp_uninit(struct ispsoftc *isp)
 	/*
 	 * Leave with interrupts disabled.
 	 */
-	DISABLE_INTS(isp);
+	ISP_DISABLE_INTS(isp);
 
 	ISP_UNLOCK(isp);
 }
@@ -584,7 +596,7 @@ isp_uninit(struct ispsoftc *isp)
 /*
  * Restart function for a command to be requeued later.
  */
-static void
+void
 isp_requeue(void *arg)
 {
 	int r;
@@ -629,7 +641,7 @@ isp_requeue(void *arg)
  * Restart function after a LOOP UP event or a command completing,
  * sometimes done as a timeout for some hysteresis.
  */
-static void
+void
 isp_trestart(void *arg)
 {
 	struct ispsoftc *isp = arg;
@@ -657,7 +669,7 @@ isp_trestart(void *arg)
 	}
 }
 
-static void
+void
 isp_restart(struct ispsoftc *isp)
 {
 	struct scsi_xfer *list;
@@ -683,6 +695,14 @@ int
 isp_async(struct ispsoftc *isp, ispasync_t cmd, void *arg)
 {
 	int bus, tgt;
+	char *msg = NULL;
+	static const char prom[] =
+	    "PortID 0x%06x handle 0x%x role %s %s\n"
+	    "      WWNN 0x%08x%08x WWPN 0x%08x%08x";
+	static const char prom2[] =
+	    "PortID 0x%06x handle 0x%x role %s %s tgt %u\n"
+	    "      WWNN 0x%08x%08x WWPN 0x%08x%08x";
+	fcportdb_t *lp;
 
 	switch (cmd) {
 	case ISPASYNC_NEW_TGT_PARAMS:
@@ -779,147 +799,157 @@ isp_async(struct ispsoftc *isp, ispasync_t cmd, void *arg)
 		timeout_add(&isp->isp_osinfo.rqt, 1);
 		isp_prt(isp, ISP_LOGINFO, "Loop UP");
 		break;
-	case ISPASYNC_PROMENADE:
-	if (IS_FC(isp) && isp->isp_dblev) {
-		const char *fmt = "Target %d (Loop 0x%x) Port ID 0x%x "
-		    "role %s %s\n Port WWN 0x%08x%08x\n Node WWN 0x%08x%08x";
-		const static char *roles[4] = {
-		    "No", "Target", "Initiator", "Target/Initiator"
-		};
-		fcparam *fcp = isp->isp_param;
-		int tgt = *((int *) arg);
-		struct lportdb *lp = &fcp->portdb[tgt]; 
-
-		isp_prt(isp, ISP_LOGINFO, fmt, tgt, lp->loopid, lp->portid,
-		    roles[lp->roles & 0x3],
-		    (lp->valid)? "Arrived" : "Departed",
-		    (u_int32_t) (lp->port_wwn >> 32),
-		    (u_int32_t) (lp->port_wwn & 0xffffffffLL),
-		    (u_int32_t) (lp->node_wwn >> 32),
-		    (u_int32_t) (lp->node_wwn & 0xffffffffLL));
-		break;
-	}
-	case ISPASYNC_CHANGE_NOTIFY:
-		if (arg == (void *) 1) {
-			isp_prt(isp, ISP_LOGINFO,
-			    "Name Server Database Changed");
+	case ISPASYNC_DEV_ARRIVED:
+		lp = arg;
+		lp->reserved = 0;
+		if ((isp->isp_role & ISP_ROLE_INITIATOR) &&
+		    (lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT))) {
+			int dbidx = lp - FCPARAM(isp)->portdb;
+			int i;
+
+			for (i = 0; i < MAX_FC_TARG; i++) {
+				if (i >= FL_ID && i <= SNS_ID) {
+					continue;
+				}
+				if (FCPARAM(isp)->isp_ini_map[i] == 0) {
+					break;
+				}
+			}
+			if (i < MAX_FC_TARG) {
+				FCPARAM(isp)->isp_ini_map[i] = dbidx + 1;
+				lp->ini_map_idx = i + 1;
+				printf("ISPASYNC_DEV_ARRIVED: %d/%d\n",
+				    i, FCPARAM(isp)->isp_ini_map[i]);
+			} else {
+				isp_prt(isp, ISP_LOGWARN, "out of target ids");
+				isp_dump_portdb(isp);
+			}
+		}
+		if (lp->ini_map_idx) {
+			tgt = lp->ini_map_idx - 1;
+			isp_prt(isp, ISP_LOGCONFIG, prom2,
+			    lp->portid, lp->handle,
+		            roles[lp->roles], "arrived at", tgt,
+		    	    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+		    	    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
+			isp_make_here(isp, tgt);
 		} else {
-			isp_prt(isp, ISP_LOGINFO,
-			    "Name Server Database Changed");
+			isp_prt(isp, ISP_LOGCONFIG, prom,
+			    lp->portid, lp->handle,
+		            roles[lp->roles], "arrived",
+		    	    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+		    	    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
 		}
 		break;
-	case ISPASYNC_FABRIC_DEV:
-	{
-		int target, base, lim;
-		fcparam *fcp = isp->isp_param;
-		struct lportdb *lp = NULL;
-		struct lportdb *clp = (struct lportdb *) arg;
-		char *pt;
-
-		switch (clp->port_type) {
-		case 1:
-			pt = "   N_Port";
-			break;
-		case 2:
-			pt = "  NL_Port";
-			break;
-		case 3:
-			pt = "F/NL_Port";
-			break;
-		case 0x7f:
-			pt = "  Nx_Port";
-			break;
-		case 0x81:
-			pt = "  F_port";
-			break;
-		case 0x82:
-			pt = "  FL_Port";
-			break;
-		case 0x84:
-			pt = "   E_port";
-			break;
-		default:
-			pt = " ";
-			break;
-		}
-
-		isp_prt(isp, ISP_LOGINFO,
-		    "%s Fabric Device @ PortID 0x%x", pt, clp->portid);
-
-		/*
-		 * If we don't have an initiator role we bail.
-		 *
-		 * We just use ISPASYNC_FABRIC_DEV for announcement purposes.
-		 */
-
-		if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
-			break;
-		}
-
-		/*
-		 * Is this entry for us? If so, we bail.
-		 */
-
-		if (fcp->isp_portid == clp->portid) {
-			break;
-		}
-
-		/*
-		 * Else, the default policy is to find room for it in
-		 * our local port database. Later, when we execute
-		 * the call to isp_pdb_sync either this newly arrived
-		 * or already logged in device will be (re)announced.
-		 */
-
-		if (fcp->isp_topo == TOPO_FL_PORT)
-			base = FC_SNS_ID+1;
-		else
-			base = 0;
-
-		if (fcp->isp_topo == TOPO_N_PORT)
-			lim = 1;
-		else
-			lim = MAX_FC_TARG;
-
-		/*
-		 * Is it already in our list?
-		 */
-		for (target = base; target < lim; target++) {
-			if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
-				continue;
+	case ISPASYNC_DEV_CHANGED:
+		lp = arg;
+		if (isp_change_is_bad) {
+			lp->state = FC_PORTDB_STATE_NIL;
+			if (lp->ini_map_idx) {
+				tgt = lp->ini_map_idx - 1;
+				FCPARAM(isp)->isp_ini_map[tgt] = 0;
+				printf("ISPASYNC_DEV_CHANGED: %d/%d\n",
+				    tgt, FCPARAM(isp)->isp_ini_map[tgt]);
+				lp->ini_map_idx = 0;
+				isp_prt(isp, ISP_LOGCONFIG, prom3,
+				    lp->portid, tgt, "change is bad");
+				isp_make_gone(isp, tgt);
+			} else {
+				isp_prt(isp, ISP_LOGCONFIG, prom,
+				    lp->portid, lp->handle,
+				    roles[lp->roles],
+				    "changed and departed",
+				    (uint32_t) (lp->node_wwn >> 32),
+				    (uint32_t) lp->node_wwn,
+				    (uint32_t) (lp->port_wwn >> 32),
+				    (uint32_t) lp->port_wwn);
 			}
-			lp = &fcp->portdb[target];
-			if (lp->port_wwn == clp->port_wwn &&
-			    lp->node_wwn == clp->node_wwn) {
-				lp->fabric_dev = 1;
-				break;
+		} else {
+			lp->portid = lp->new_portid;
+			lp->roles = lp->new_roles;
+			if (lp->ini_map_idx) {
+				int t = lp->ini_map_idx - 1;
+				FCPARAM(isp)->isp_ini_map[t] =
+				    (lp - FCPARAM(isp)->portdb) + 1;
+				printf("ISPASYNC_DEV_CHANGED(2): %d/%d\n",
+				    t, FCPARAM(isp)->isp_ini_map[t]);
+				tgt = lp->ini_map_idx - 1;
+				isp_prt(isp, ISP_LOGCONFIG, prom2,
+				    lp->portid, lp->handle,
+				    roles[lp->roles], "changed at", tgt,
+				    (uint32_t) (lp->node_wwn >> 32),
+				    (uint32_t) lp->node_wwn,
+				    (uint32_t) (lp->port_wwn >> 32),
+				    (uint32_t) lp->port_wwn);
+			} else {
+				isp_prt(isp, ISP_LOGCONFIG, prom,
+				    lp->portid, lp->handle,
+				    roles[lp->roles], "changed",
+				    (uint32_t) (lp->node_wwn >> 32),
+				    (uint32_t) lp->node_wwn,
+				    (uint32_t) (lp->port_wwn >> 32),
+				    (uint32_t) lp->port_wwn);
 			}
 		}
-		if (target < lim) {
-			break;
+		break;
+	case ISPASYNC_DEV_STAYED:
+		lp = arg;
+		if (lp->ini_map_idx) {
+			tgt = lp->ini_map_idx - 1;
+			isp_prt(isp, ISP_LOGCONFIG, prom2,
+			    lp->portid, lp->handle,
+		    	    roles[lp->roles], "stayed at", tgt,
+			    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+		    	    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
+		} else {
+			isp_prt(isp, ISP_LOGCONFIG, prom,
+			    lp->portid, lp->handle,
+		    	    roles[lp->roles], "stayed",
+			    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+		    	    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
 		}
-		for (target = base; target < lim; target++) {
-			if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
-				continue;
-			}
-			lp = &fcp->portdb[target];
-			if (lp->port_wwn == 0) {
-				break;
-			}
+		break;
+	case ISPASYNC_DEV_GONE:
+		lp = arg;
+		if (lp->ini_map_idx && lp->reserved == 0) {
+			lp->reserved = 1;
+			lp->state = FC_PORTDB_STATE_ZOMBIE;
+			tgt = lp->ini_map_idx - 1;
+			isp_prt(isp, ISP_LOGCONFIG, prom2,
+			    lp->portid, lp->handle,
+		            roles[lp->roles], "gone zombie at", tgt,
+		    	    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+		    	    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
+		} else if (lp->reserved == 0) {
+			isp_prt(isp, ISP_LOGCONFIG, prom,
+			    lp->portid, lp->handle,
+			    roles[lp->roles], "departed",
+			    (uint32_t) (lp->node_wwn >> 32),
+			    (uint32_t) lp->node_wwn,
+			    (uint32_t) (lp->port_wwn >> 32),
+			    (uint32_t) lp->port_wwn);
 		}
-		if (target == lim) {
-			isp_prt(isp, ISP_LOGWARN,
-			    "out of space for fabric devices");
-			break;
+		break;
+	case ISPASYNC_CHANGE_NOTIFY:
+		if (arg == ISPASYNC_CHANGE_PDB) {
+			msg = "Port Database Changed";
+		} else if (arg == ISPASYNC_CHANGE_SNS) {
+			msg = "Name Server Database Changed";
+		} else {
+			msg = "Other Change Notify";
 		}
-		lp->port_type = clp->port_type;
-		lp->fc4_type = clp->fc4_type;
-		lp->node_wwn = clp->node_wwn;
-		lp->port_wwn = clp->port_wwn;
-		lp->portid = clp->portid;
-		lp->fabric_dev = 1;
+		isp_prt(isp, ISP_LOGINFO, msg);
 		break;
-	}
 	case ISPASYNC_FW_CRASH:
 	{
 		u_int16_t mbox1, mbox6;
@@ -961,3 +991,135 @@ isp_prt(struct ispsoftc *isp, int level, const char *fmt, ...)
 	va_end(ap);
 	printf("\n");
 }
+
+int
+isp_mbox_acquire(ispsoftc_t *isp)
+{
+	if (isp->isp_osinfo.mboxbsy) {
+		return (1);
+	} else {
+		isp->isp_osinfo.mboxcmd_done = 0;
+		isp->isp_osinfo.mboxbsy = 1;
+		return (0);
+	}
+}
+
+void
+isp_lock(struct ispsoftc *isp)
+{
+	int s = splbio();
+	if (isp->isp_osinfo.islocked++ == 0) {
+		isp->isp_osinfo.splsaved = s;
+	} else {
+		splx(s);
+	}
+}
+
+void
+isp_unlock(struct ispsoftc *isp)
+{
+	if (isp->isp_osinfo.islocked-- <= 1) {
+		isp->isp_osinfo.islocked = 0;
+		splx(isp->isp_osinfo.splsaved);
+	}
+}
+
+u_int64_t
+isp_nanotime_sub(struct timespec *b, struct timespec *a)
+{
+	struct timespec x;
+	u_int64_t elapsed;
+	timespecsub(b, a, &x);
+	elapsed = GET_NANOSEC(&x);
+	if (elapsed == 0)
+		elapsed++;
+	return (elapsed);
+}
+
+void
+isp_mbox_wait_complete(ispsoftc_t *isp, mbreg_t *mbp)
+{
+	unsigned int usecs = mbp->timeout;
+	unsigned int max, olim, ilim;
+
+	if (usecs == 0) {
+		usecs = MBCMD_DEFAULT_TIMEOUT;
+	}
+	max = isp->isp_mbxwrk0 + 1;
+
+	if (isp->isp_osinfo.mbox_sleep_ok) {
+		unsigned int ms = (usecs + 999) / 1000;
+
+		isp->isp_osinfo.mbox_sleep_ok = 0;
+		isp->isp_osinfo.mbox_sleeping = 1;
+		for (olim = 0; olim < max; olim++) {
+			tsleep(&isp->isp_mbxworkp, PRIBIO, "ispmbx_sleep",
+			    isp_mstohz(ms));
+			if (isp->isp_osinfo.mboxcmd_done) {
+				break;
+			}
+		}
+		isp->isp_osinfo.mbox_sleep_ok = 1;
+		isp->isp_osinfo.mbox_sleeping = 0;
+	} else {
+		for (olim = 0; olim < max; olim++) {
+			for (ilim = 0; ilim < usecs; ilim += 100) {
+				uint32_t isr;
+				uint16_t sema, mbox;
+				if (isp->isp_osinfo.mboxcmd_done) {
+					break;
+				}
+				if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
+					isp_intr(isp, isr, sema, mbox);
+					if (isp->isp_osinfo.mboxcmd_done) {
+						break;
+					}
+				}
+				USEC_DELAY(100);
+			}
+			if (isp->isp_osinfo.mboxcmd_done) {
+				break;
+			}
+		}
+	}
+	if (isp->isp_osinfo.mboxcmd_done == 0) {
+		isp_prt(isp, ISP_LOGWARN,
+		    "%s Mailbox Command (0x%x) Timeout (%uus)",
+		    isp->isp_osinfo.mbox_sleep_ok? "Interrupting" : "Polled",
+		    isp->isp_lastmbxcmd, usecs);
+		mbp->param[0] = MBOX_TIMEOUT;
+		isp->isp_osinfo.mboxcmd_done = 1;
+	}
+}
+
+void
+isp_mbox_notify_done(ispsoftc_t *isp)
+{
+	if (isp->isp_osinfo.mbox_sleeping) {
+		wakeup(&isp->isp_mbxworkp);
+	}
+	isp->isp_osinfo.mboxcmd_done = 1;
+}
+
+void
+isp_mbox_release(ispsoftc_t *isp)
+{
+	isp->isp_osinfo.mboxbsy = 0;
+}
+
+int
+isp_mstohz(int ms)
+{
+	int hz;
+	struct timeval t;
+	t.tv_sec = ms / 1000;
+	t.tv_usec = (ms % 1000) * 1000;
+	hz = tvtohz(&t);
+	if (hz < 0) {
+		hz = 0x7fffffff;
+	}
+	if (hz == 0) {
+		hz = 1;
+	}
+	return (hz);
+}
diff --git a/sys/dev/ic/isp_openbsd.h b/sys/dev/ic/isp_openbsd.h
index 19531cffcd2..01d3d6eccb7 100644
--- a/sys/dev/ic/isp_openbsd.h
+++ b/sys/dev/ic/isp_openbsd.h
@@ -1,4 +1,4 @@
-/*      $OpenBSD: isp_openbsd.h,v 1.30 2008/11/17 00:22:13 krw Exp $ */
+/*      $OpenBSD: isp_openbsd.h,v 1.31 2009/06/24 11:00:53 krw Exp $ */
 /*
  * OpenBSD Specific definitions for the QLogic ISP Host Adapter
  */
@@ -62,8 +62,8 @@
 #define	ISP_SBUS_SUPPORTED	0
 #endif
 
-#define	ISP_PLATFORM_VERSION_MAJOR	2
-#define	ISP_PLATFORM_VERSION_MINOR	1
+#define	ISP_PLATFORM_VERSION_MAJOR	5
+#define	ISP_PLATFORM_VERSION_MINOR	9
 
 struct isposinfo {
 	struct device		_dev;
@@ -75,20 +75,29 @@ struct isposinfo {
 	u_int32_t		islocked;
 	u_int32_t		onintstack;
 #if	!(defined(__sparc__) && !defined(__sparcv9__))
+	bus_space_tag_t		bus_tag;
+	bus_space_handle_t	bus_handle;
 	bus_dma_tag_t		dmatag;
-	bus_dmamap_t		rqdmap;
-	bus_dmamap_t		rsdmap;
-	bus_dmamap_t		scdmap;	/* FC only */
+	bus_dmamap_t		cdmap;
 #define	isp_dmatag		isp_osinfo.dmatag
-#define	isp_rqdmap		isp_osinfo.rqdmap
-#define	isp_rsdmap		isp_osinfo.rsdmap
-#define	isp_scdmap		isp_osinfo.scdmap
+#define	isp_cdmap		isp_osinfo.cdmap
+#define	isp_bus_tag		isp_osinfo.bus_tag
+#define	isp_bus_handle		isp_osinfo.bus_handle
 #endif
-	unsigned int		: 28,
-		
-		rtpend		: 1,
+	uint32_t		: 5,
+		simqfrozen	: 3,
+		hysteresis	: 8,
+		gdt_running	: 1,
+		ldt_running	: 1,
+		disabled	: 1,
+		fcbsy		: 1,
+		mbox_sleeping	: 1,
+		mbox_sleep_ok	: 1,
+		mboxcmd_done	: 1,
+		mboxbsy		: 1,
 		no_mbox_ints	: 1,
-		blocked		: 2;
+		blocked		: 2,
+		rtpend		: 1;
 	int			_iid;
 	union {
 		u_int64_t 	_wwn;
@@ -111,30 +120,20 @@ struct isposinfo {
  * Required Macros/Defines
  */
 
-#define	INLINE			__inline
-
-/* We don't want expensive inline functions. */
-#define EXP_INLINE
-
-#define	ISP2100_SCRLEN		0x800
+#define	ISP2100_SCRLEN		0x1000
 
 #define	MEMZERO			bzero
 #define	MEMCPY(dst, src, amt)	bcopy((src), (dst), (amt))
 #define	SNPRINTF		snprintf
-#define	USEC_DELAY(x)		delay(x)
-#define	USEC_SLEEP(isp, x)		\
-	if (!MUST_POLL(isp))		\
-		ISP_UNLOCK(isp);	\
-	delay(x);			\
-	if (!MUST_POLL(isp))		\
-		ISP_LOCK(isp)
+#define	USEC_DELAY		delay
+#define	USEC_SLEEP(isp, x)	delay(x)
 
 #define	NANOTIME_T		struct timespec
 #define	GET_NANOTIME		nanotime
 #define	GET_NANOSEC(x)		(((x)->tv_sec * 1000000000 + (x)->tv_nsec))
 #define	NANOTIME_SUB		isp_nanotime_sub
 
-#define	MAXISPREQUEST(isp)	256
+#define MAXISPREQUEST(isp)      ((IS_FC(isp) || IS_ULTRA2(isp))? 1024 : 256)
 
 #if	!(defined(__sparc__) && !defined(__sparcv9__))
 #define	MEMORYBARRIER(isp, type, offset, size)			\
@@ -142,32 +141,37 @@ switch (type) {							\
 case SYNC_REQUEST:						\
 {								\
 	off_t off = (off_t) offset * QENTRY_LEN;		\
-	bus_dmamap_sync(isp->isp_dmatag, isp->isp_rqdmap,	\
+	bus_dmamap_sync(isp->isp_dmatag, isp->isp_cdmap,	\
 	    off, size, BUS_DMASYNC_PREWRITE);			\
 	break;							\
 }								\
 case SYNC_RESULT:						\
 {								\
-	off_t off = (off_t) offset * QENTRY_LEN;		\
-	bus_dmamap_sync(isp->isp_dmatag, isp->isp_rsdmap,	\
+	off_t off = (off_t) offset * QENTRY_LEN  +		\
+	    ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));		\
+	bus_dmamap_sync(isp->isp_dmatag, isp->isp_cdmap,	\
 	    off, size, BUS_DMASYNC_POSTREAD);			\
 	break;							\
 }								\
 case SYNC_SFORDEV:						\
 {								\
 	off_t off = (off_t) offset;				\
-	bus_dmamap_sync(isp->isp_dmatag, isp->isp_scdmap,	\
+	bus_dmamap_sync(isp->isp_dmatag, isp->isp_cdmap,	\
 	    off, size, BUS_DMASYNC_PREWRITE);			\
 	break;							\
 }								\
 case SYNC_SFORCPU:						\
 {								\
 	off_t off = (off_t) offset;				\
-	bus_dmamap_sync(isp->isp_dmatag, isp->isp_scdmap,	\
+	bus_dmamap_sync(isp->isp_dmatag, isp->isp_cdmap,	\
 	    off, size, BUS_DMASYNC_POSTREAD);			\
 	break;							\
 }								\
 case SYNC_REG:							\
+	bus_space_barrier(isp->isp_bus_tag,			\
+	    isp->isp_bus_handle, offset, size, 			\
+	    BUS_SPACE_BARRIER_READ);				\
+	break;							\
 default:							\
 	break;							\
 }
@@ -175,20 +179,18 @@ default:							\
 #define	MEMORYBARRIER(isp, type, offset, size)
 #endif
 
-#define	MBOX_ACQUIRE(isp)
-#define	MBOX_WAIT_COMPLETE		isp_wait_complete
+#define	MBOX_ACQUIRE			isp_mbox_acquire
+#define MBOX_WAIT_COMPLETE		isp_mbox_wait_complete
+#define	MBOX_NOTIFY_COMPLETE		isp_mbox_notify_done
+#define	MBOX_RELEASE			isp_mbox_release
 
-#define	MBOX_NOTIFY_COMPLETE(isp)					\
-	if (isp->isp_osinfo.mboxwaiting) {				\
-                isp->isp_osinfo.mboxwaiting = 0;			\
-                wakeup(&isp->isp_osinfo.mboxwaiting);			\
-        }								\
-	isp->isp_mboxbsy = 0
-
-#define	MBOX_RELEASE(isp)
-
-#define	FC_SCRATCH_ACQUIRE(isp)
-#define	FC_SCRATCH_RELEASE(isp)
+#define	FC_SCRATCH_ACQUIRE(isp)						\
+	if (isp->isp_osinfo.fcbsy) {					\
+		isp_prt(isp, ISP_LOGWARN,				\
+		    "FC scratch area busy (line %d)!", __LINE__);	\
+	} else								\
+		isp->isp_osinfo.fcbsy = 1
+#define	FC_SCRATCH_RELEASE(isp)		 isp->isp_osinfo.fcbsy = 0
 
 #ifndef	SCSI_GOOD
 #define	SCSI_GOOD	0x0
@@ -204,6 +206,11 @@ default:							\
 #endif
 
 #define	XS_T			struct scsi_xfer
+#if	!(defined(__sparc__) && !defined(__sparcv9__))
+#define	XS_DMA_ADDR_T		bus_addr_t
+#else
+#define	XS_DMA_ADDR_T		u_int32_t
+#endif
 #define	XS_CHANNEL(xs)		(((xs)->sc_link->flags & SDEV_2NDBUS)? 1 : 0)
 #define	XS_ISP(xs)		(xs)->sc_link->adapter_softc
 #define	XS_LUN(xs)		((int) (xs)->sc_link->lun)
@@ -238,12 +245,11 @@ default:							\
 
 #define	XS_INITERR(xs)		(xs)->error = 0, XS_CMD_S_CLEAR(xs)
 
-#define	XS_SAVE_SENSE(xs, sp)				\
+#define	XS_SAVE_SENSE(xs, sp, len)				\
 	if (xs->error == XS_NOERROR) {			\
 		xs->error = XS_SENSE;			\
 	}						\
-	bcopy(sp->req_sense_data, &(xs)->sense,		\
-	    imin(XS_SNSLEN(xs), sp->req_sense_len))
+	bcopy(sp, &(xs)->sense, imin(XS_SNSLEN(xs), len))
 
 #define	XS_SET_STATE_STAT(a, b, c)
 
@@ -251,8 +257,8 @@ default:							\
 #define	DEFAULT_LOOPID(x)	107
 #define	DEFAULT_NODEWWN(isp)	(isp)->isp_osinfo.un._wwn
 #define	DEFAULT_PORTWWN(isp)	(isp)->isp_osinfo.un._wwn
-#define	ISP_NODEWWN(isp)	FCPARAM(isp)->isp_nodewwn
-#define	ISP_PORTWWN(isp)	FCPARAM(isp)->isp_portwwn
+#define	ISP_NODEWWN(isp)	FCPARAM(isp)->isp_wwnn_nvram
+#define	ISP_PORTWWN(isp)	FCPARAM(isp)->isp_wwpn_nvram
 
 #if	BYTE_ORDER == BIG_ENDIAN
 #ifdef	ISP_SBUS_SUPPORTED
@@ -278,6 +284,16 @@ default:							\
 #define	ISP_IOXGET_32(isp, s, d)	d = swap32(*((u_int32_t *)s))
 #endif
 #define	ISP_SWIZZLE_NVRAM_WORD(isp, rp)	*rp = swap16(*rp)
+#define	ISP_SWIZZLE_NVRAM_LONG(isp, rp)	*rp = swap32(*rp)
+
+#define	ISP_IOZGET_8(isp, s, d)		d = (*((u_int8_t *)s))
+#define	ISP_IOZGET_16(isp, s, d)	d = (*((u_int16_t *)s))
+#define	ISP_IOZGET_32(isp, s, d)	d = (*((u_int32_t *)s))
+#define	ISP_IOZPUT_8(isp, s, d)		*(d) = s
+#define	ISP_IOZPUT_16(isp, s, d)	*(d) = s
+#define	ISP_IOZPUT_32(isp, s, d)	*(d) = s
+
+
 #else
 #define	ISP_IOXPUT_8(isp, s, d)		*(d) = s
 #define	ISP_IOXPUT_16(isp, s, d)	*(d) = s
@@ -286,8 +302,20 @@ default:							\
 #define	ISP_IOXGET_16(isp, s, d)	d = *(s)
 #define	ISP_IOXGET_32(isp, s, d)	d = *(s)
 #define	ISP_SWIZZLE_NVRAM_WORD(isp, rp)
+#define	ISP_SWIZZLE_NVRAM_LONG(isp, rp)
+
+#define	ISP_IOZPUT_8(isp, s, d)		*(d) = s
+#define	ISP_IOZPUT_16(isp, s, d)	*(d) = swap16(s)
+#define	ISP_IOZPUT_32(isp, s, d)	*(d) = swap32(s)
+
+#define	ISP_IOZGET_8(isp, s, d)		d = (*((u_int8_t *)(s)))
+#define	ISP_IOZGET_16(isp, s, d)	d = swap16(*((u_int16_t *)(s)))
+#define	ISP_IOZGET_32(isp, s, d)	d = swap32(*((u_int32_t *)(s)))
 #endif
 
+#define	ISP_SWAP16(isp, s)	swap16(s)
+#define	ISP_SWAP32(isp, s)	swap32(s)
+
 /*
  * Includes of common header files
  */
@@ -308,11 +336,14 @@ default:							\
 void isp_attach(struct ispsoftc *);
 void isp_uninit(struct ispsoftc *);
 
-static INLINE void isp_lock(struct ispsoftc *);
-static INLINE void isp_unlock(struct ispsoftc *);
-static INLINE u_int64_t
-isp_nanotime_sub(struct timespec *, struct timespec *);
-static void isp_wait_complete(struct ispsoftc *);
+void isp_lock(struct ispsoftc *);
+void isp_unlock(struct ispsoftc *);
+void isp_prt(struct ispsoftc *, int level, const char *, ...);
+u_int64_t isp_nanotime_sub(struct timespec *, struct timespec *);
+int isp_mbox_acquire(ispsoftc_t *);
+void isp_mbox_wait_complete(ispsoftc_t *, mbreg_t *);
+void isp_mbox_notify_done(ispsoftc_t *);
+void isp_mbox_release(ispsoftc_t *);
 
 /*
  * Driver wide data...
@@ -345,88 +376,6 @@ static void isp_wait_complete(struct ispsoftc *);
 
 #define	XS_CMD_S_CLEAR(xs)	(xs)->flags &= ~XS_PSTS_ALL
 
-/*
- * Platform specific 'INLINE' or support functions
- */
-static INLINE void
-isp_lock(struct ispsoftc *isp)
-{
-	int s = splbio();
-	if (isp->isp_osinfo.islocked++ == 0) {
-		isp->isp_osinfo.splsaved = s;
-	} else {
-		splx(s);
-	}
-}
-
-static INLINE void
-isp_unlock(struct ispsoftc *isp)
-{
-	if (isp->isp_osinfo.islocked-- <= 1) {
-		isp->isp_osinfo.islocked = 0;
-		splx(isp->isp_osinfo.splsaved);
-	}
-}
-
-static INLINE u_int64_t
-isp_nanotime_sub(struct timespec *b, struct timespec *a)
-{
-	struct timespec x;
-	u_int64_t elapsed;
-	timespecsub(b, a, &x);
-	elapsed = GET_NANOSEC(&x);
-	if (elapsed == 0)
-		elapsed++;
-	return (elapsed);
-}
-
-static INLINE void
-isp_wait_complete(struct ispsoftc *isp)
-{
-	int delaytime;
-	if (isp->isp_mbxwrk0)
-		delaytime = 60;
-	else
-		delaytime = 5;
-	if (MUST_POLL(isp)) {
-		int usecs = 0;
-		delaytime *= 1000000;	/* convert to usecs */
-		while (usecs < delaytime) {
-			u_int16_t isr, sema, mbox;
-			if (isp->isp_mboxbsy == 0) {
-				break;
-			}
-			if (ISP_READ_ISR(isp, &isr, &sema, &mbox)) {
-				isp_intr(isp, isr, sema, mbox);
-				if (isp->isp_mboxbsy == 0) {
-					break;
-				}
-			}
-			USEC_DELAY(500);
-			usecs += 500;
-		}
-		if (isp->isp_mboxbsy != 0) {
-			isp_prt(isp, ISP_LOGWARN,
-			    "Polled Mailbox Command (0x%x) Timeout",
-			    isp->isp_lastmbxcmd);
-		}
-	} else {
-		int rv = 0;
-                isp->isp_osinfo.mboxwaiting = 1;
-                while (isp->isp_osinfo.mboxwaiting && rv == 0) {
-			rv = tsleep(&isp->isp_osinfo.mboxwaiting,
-			    PRIBIO, "isp_mboxcmd", delaytime * hz);
-		}
-		if (rv == EWOULDBLOCK) {
-			isp->isp_mboxbsy = 0;
-			isp->isp_osinfo.mboxwaiting = 0;
-			isp_prt(isp, ISP_LOGWARN,
-			    "Interrupting Mailbox Command (0x%x) Timeout",
-			    isp->isp_lastmbxcmd);
-		}
-	}
-}
-
 #include <dev/ic/isp_library.h>
 
 #endif	/* _ISP_OPENBSD_H */
diff --git a/sys/dev/ic/isp_stds.h b/sys/dev/ic/isp_stds.h
index be87fc89159..174731ebc45 100644
--- a/sys/dev/ic/isp_stds.h
+++ b/sys/dev/ic/isp_stds.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: isp_stds.h,v 1.1 2008/11/02 03:06:26 krw Exp $ */
+/* $OpenBSD: isp_stds.h,v 1.2 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/isp_stds.h,v 1.4 2007/03/10 02:39:54 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -109,14 +109,14 @@ typedef struct {
 
 typedef struct {
 	uint8_t		ct_revision;
-	uint8_t		ct_portid[3];
+	uint8_t		ct_in_id[3];
 	uint8_t		ct_fcs_type;
 	uint8_t		ct_fcs_subtype;
 	uint8_t		ct_options;
-	uint8_t		ct_res0;
-	uint16_t	ct_response;
-	uint16_t	ct_resid;
-	uint8_t		ct_res1;
+	uint8_t		ct_reserved0;
+	uint16_t	ct_cmd_resp;
+	uint16_t	ct_bcnt_resid;
+	uint8_t		ct_reserved1;
 	uint8_t		ct_reason;
 	uint8_t		ct_explanation;
 	uint8_t		ct_vunique;
diff --git a/sys/dev/ic/isp_target.c b/sys/dev/ic/isp_target.c
index d04983a9188..597b4b1ff96 100644
--- a/sys/dev/ic/isp_target.c
+++ b/sys/dev/ic/isp_target.c
@@ -1,33 +1,33 @@
-/* $OpenBSD: isp_target.c,v 1.15 2008/01/21 20:00:33 sobrado Exp $ */
+/* $OpenBSD: isp_target.c,v 1.16 2009/06/24 11:00:53 krw Exp $ */
+/*-
+ *  Copyright (c) 1997-2007 by Matthew Jacob
+ *  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.
+ * 
+ *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ *  SUCH DAMAGE.
+ */
 /*
- * Machine and OS Independent Target Mode Code for the QLogic SCSI/FC adapters.
- *
- * Copyright (c) 1999, 2000, 2001 by Matthew Jacob
- * All rights reserved.
- * mjacob@feral.com
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice immediately at the beginning of the file, without modification,
- *    this list of conditions, and the following disclaimer.
- * 2. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
+ * Machine and OS Independent Target Mode Code for the Qlogic SCSI/FC adapters.
  */
-
 /*
  * Bug fixes gratefully acknowledged from:
  *	Oded Kedem <oded@kashya.com>
@@ -40,6 +40,8 @@
 #include <dev/ic/isp_netbsd.h>
 #endif
 #ifdef	__FreeBSD__
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD: src/sys/dev/isp/isp_target.c,v 1.45 2007/10/12 06:03:43 kevlo Exp $");
 #include <dev/isp/isp_freebsd.h>
 #endif
 #ifdef	__OpenBSD__
@@ -54,19 +56,20 @@ static const char atiocope[] =
     "ATIO returned for lun %d because it was in the middle of Bus Device Reset "
     "on bus %d";
 static const char atior[] =
-    "ATIO returned on for lun %d on from IID %d because a Bus Reset occurred "
-    "on bus %d";
-
-static void isp_got_msg(struct ispsoftc *, int, in_entry_t *);
-static void isp_got_msg_fc(struct ispsoftc *, int, in_fcentry_t *);
-static void isp_notify_ack(struct ispsoftc *, void *);
-static void isp_handle_atio(struct ispsoftc *, at_entry_t *);
-static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *);
-static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *);
-static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
+    "ATIO returned on for lun %d on from loopid %d because a Bus Reset "
+    "occurred on bus %d";
+
+static void isp_got_msg(ispsoftc_t *, in_entry_t *);
+static void isp_got_msg_fc(ispsoftc_t *, in_fcentry_t *);
+static void isp_got_tmf_24xx(ispsoftc_t *, at7_entry_t *);
+static void isp_handle_atio(ispsoftc_t *, at_entry_t *);
+static void isp_handle_atio2(ispsoftc_t *, at2_entry_t *);
+static void isp_handle_ctio(ispsoftc_t *, ct_entry_t *);
+static void isp_handle_ctio2(ispsoftc_t *, ct2_entry_t *);
+static void isp_handle_ctio7(ispsoftc_t *, ct7_entry_t *);
 
 /*
- * The QLogic driver gets an interrupt to look at response queue entries.
+ * The Qlogic driver gets an interrupt to look at response queue entries.
  * Some of these are status completions for initiatior mode commands, but
  * if target mode is enabled, we get a whole wad of response queue entries
  * to be handled here.
@@ -86,7 +89,7 @@ static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
  * be moved and/or status to be sent) and finally finishing with sending
  * to the f/w's response queue an ATIO which then completes the handshake
  * with the f/w for that command. There's a lot of variations on this theme,
- * including flags you can set in the CTIO for the QLogic 2X00 fibre channel
+ * including flags you can set in the CTIO for the Qlogic 2X00 fibre channel
  * cards that 'auto-replenish' the f/w's ATIO count, but this is the basic
  * gist of it.
  *
@@ -107,39 +110,62 @@ static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
  * has already swizzled it into the platform dependent from canonical form.
  *
  * Because of the way this driver is designed, unfortunately most of the
- * actual synchronization work has to be done in the platform-specific
- * code - we have no synchronization primitives in the common code.
+ * actual synchronization work has to be done in the platform specific
+ * code- we have no synchroniation primitives in the common code.
  */
 
 int
-isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
+isp_target_notify(ispsoftc_t *isp, void *vptr, uint32_t *optrp)
 {
-	u_int16_t status, seqid;
+	uint16_t status;
+	uint32_t seqid;
 	union {
 		at_entry_t	*atiop;
 		at2_entry_t	*at2iop;
+		at2e_entry_t	*at2eiop;
+		at7_entry_t	*at7iop;
 		ct_entry_t	*ctiop;
 		ct2_entry_t	*ct2iop;
+		ct2e_entry_t	*ct2eiop;
+		ct7_entry_t	*ct7iop;
 		lun_entry_t	*lunenp;
 		in_entry_t	*inotp;
 		in_fcentry_t	*inot_fcp;
+		in_fcentry_e_t	*inote_fcp;
+		in_fcentry_24xx_t *inot_24xx;
 		na_entry_t	*nackp;
 		na_fcentry_t	*nack_fcp;
+		na_fcentry_e_t	*nacke_fcp;
+		na_fcentry_24xx_t *nack_24xx;
 		isphdr_t	*hp;
+		abts_t		*abts;
+		abts_rsp_t	*abts_rsp;
+		els_t		*els;
 		void *		*vp;
 #define	atiop		unp.atiop
 #define	at2iop		unp.at2iop
+#define	at2eiop		unp.at2eiop
+#define	at7iop		unp.at7iop
 #define	ctiop		unp.ctiop
 #define	ct2iop		unp.ct2iop
+#define	ct2eiop		unp.ct2eiop
+#define	ct7iop		unp.ct7iop
 #define	lunenp		unp.lunenp
 #define	inotp		unp.inotp
 #define	inot_fcp	unp.inot_fcp
+#define	inote_fcp	unp.inote_fcp
+#define	inot_24xx	unp.inot_24xx
 #define	nackp		unp.nackp
 #define	nack_fcp	unp.nack_fcp
+#define	nacke_fcp	unp.nacke_fcp
+#define	nack_24xx	unp.nack_24xx
+#define	abts		unp.abts
+#define	abts_rsp	unp.abts_rsp
+#define els		unp.els
 #define	hdrp		unp.hp
 	} unp;
-	u_int8_t local[QENTRY_LEN];
-	int bus, type, rval = 1;
+	uint8_t local[QENTRY_LEN];
+	int bus, type, level, rval = 1;
 
 	type = isp_get_response_type(isp, (isphdr_t *)vptr);
 	unp.vp = vptr;
@@ -148,21 +174,72 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 
 	switch(type) {
 	case RQSTYPE_ATIO:
-		isp_get_atio(isp, atiop, (at_entry_t *) local);
-		isp_handle_atio(isp, (at_entry_t *) local);
+		if (IS_24XX(isp)) {
+			int len;
+
+			isp_get_atio7(isp, at7iop, (at7_entry_t *) local);
+			at7iop = (at7_entry_t *) local;
+			/*
+			 * Check for and do something with commands whose IULEN
+			 * extends past a singel queue entry.
+			 */
+			len = at7iop->at_ta_len & 0xfffff;
+			if (len > (QENTRY_LEN - 8)) {
+				len -= (QENTRY_LEN - 8);
+				isp_prt(isp, ISP_LOGINFO,
+				    "long IU length (%d) ignored", len);
+				while (len > 0) {
+					*optrp =  ISP_NXT_QENTRY(*optrp,
+					    RESULT_QUEUE_LEN(isp));
+					len -= QENTRY_LEN;
+				}
+			}
+			/*
+			 * Check for a task management function
+			 */
+			if (at7iop->at_cmnd.fcp_cmnd_task_management) {
+				isp_got_tmf_24xx(isp, at7iop);
+				break;
+			}
+			/*
+			 * Just go straight to outer layer for this one.
+			 */
+			(void) isp_async(isp, ISPASYNC_TARGET_ACTION, local);
+		} else {
+			isp_get_atio(isp, atiop, (at_entry_t *) local);
+			isp_handle_atio(isp, (at_entry_t *) local);
+		}
 		break;
+
 	case RQSTYPE_CTIO:
 		isp_get_ctio(isp, ctiop, (ct_entry_t *) local);
 		isp_handle_ctio(isp, (ct_entry_t *) local);
 		break;
+
 	case RQSTYPE_ATIO2:
-		isp_get_atio2(isp, at2iop, (at2_entry_t *) local);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_get_atio2e(isp, at2eiop, (at2e_entry_t *) local);
+		} else {
+			isp_get_atio2(isp, at2iop, (at2_entry_t *) local);
+		}
 		isp_handle_atio2(isp, (at2_entry_t *) local);
 		break;
+
+	case RQSTYPE_CTIO3:
 	case RQSTYPE_CTIO2:
-		isp_get_ctio2(isp, ct2iop, (ct2_entry_t *) local);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_get_ctio2e(isp, ct2eiop, (ct2e_entry_t *) local);
+		} else {
+			isp_get_ctio2(isp, ct2iop, (ct2_entry_t *) local);
+		}
 		isp_handle_ctio2(isp, (ct2_entry_t *) local);
 		break;
+
+	case RQSTYPE_CTIO7:
+		isp_get_ctio7(isp, ct7iop, (ct7_entry_t *) local);
+		isp_handle_ctio7(isp, (ct7_entry_t *) local);
+		break;
+
 	case RQSTYPE_ENABLE_LUN:
 	case RQSTYPE_MODIFY_LUN:
 		isp_get_enable_lun(isp, lunenp, (lun_entry_t *) local);
@@ -178,8 +255,42 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 		 * (we set this initially in the Enable Lun entry).
 		 */
 		bus = 0;
-		if (IS_FC(isp)) {
-			isp_get_notify_fc(isp, inot_fcp, (in_fcentry_t *)local);
+		if (IS_24XX(isp)) {
+			isp_get_notify_24xx(isp, inot_24xx,
+			    (in_fcentry_24xx_t *)local);
+			inot_24xx = (in_fcentry_24xx_t *) local;
+			status = inot_24xx->in_status;
+			seqid = inot_24xx->in_rxid;
+			isp_prt(isp, ISP_LOGTDEBUG0,
+			    "Immediate Notify status=0x%x seqid=0x%x",
+			    status, seqid);
+			switch (status) {
+			case IN24XX_LIP_RESET:
+			case IN24XX_LINK_RESET:
+			case IN24XX_PORT_LOGOUT:
+			case IN24XX_PORT_CHANGED:
+			case IN24XX_LINK_FAILED:
+			case IN24XX_SRR_RCVD:
+			case IN24XX_ELS_RCVD:
+				(void) isp_async(isp, ISPASYNC_TARGET_ACTION,
+				    &local);
+				break;
+			default:
+				isp_prt(isp, ISP_LOGINFO,
+				    "isp_target_notify: unknown status (0x%x)",
+				    status);
+				isp_notify_ack(isp, local);
+				break;
+			}
+			break;
+		} else if (IS_FC(isp)) {
+			if (FCPARAM(isp)->isp_2klogin) {
+				isp_get_notify_fc_e(isp, inote_fcp,
+				    (in_fcentry_e_t *)local);
+			} else {
+				isp_get_notify_fc(isp, inot_fcp,
+				    (in_fcentry_t *)local);
+			}
 			inot_fcp = (in_fcentry_t *) local;
 			status = inot_fcp->in_status;
 			seqid = inot_fcp->in_seqid;
@@ -193,29 +304,43 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 				SET_BUS_VAL(inotp->in_iid, 0);
 			}
 		}
+
 		isp_prt(isp, ISP_LOGTDEBUG0,
 		    "Immediate Notify On Bus %d, status=0x%x seqid=0x%x",
 		    bus, status, seqid);
 
-		/*
-		 * ACK it right away.
-		 */
-		isp_notify_ack(isp, (status == IN_RESET)? NULL : local);
 		switch (status) {
-		case IN_RESET:
-			(void) isp_async(isp, ISPASYNC_BUS_RESET, &bus);
-			break;
 		case IN_MSG_RECEIVED:
 		case IN_IDE_RECEIVED:
 			if (IS_FC(isp)) {
-				isp_got_msg_fc(isp, bus, (in_fcentry_t *)local);
+				isp_got_msg_fc(isp, (in_fcentry_t *)local);
 			} else {
-				isp_got_msg(isp, bus, (in_entry_t *)local);
+				isp_got_msg(isp, (in_entry_t *)local);
 			}
 			break;
 		case IN_RSRC_UNAVAIL:
-			isp_prt(isp, ISP_LOGWARN, "Firmware out of ATIOs");
+			isp_prt(isp, ISP_LOGINFO, "Firmware out of ATIOs");
+			isp_notify_ack(isp, local);
+			break;
+		case IN_RESET:
+		{
+			/*
+			 * We form the notify structure here because we need
+			 * to mark it as needing a NOTIFY ACK on return.
+			 */
+			tmd_notify_t notify;
+
+			MEMZERO(&notify, sizeof (tmd_notify_t));
+			notify.nt_hba = isp;
+			notify.nt_iid = INI_ANY;
+			/* nt_tgt set in outer layers */
+			notify.nt_lun = LUN_ANY;
+			notify.nt_tagval = TAG_ANY;
+			notify.nt_ncode = NT_BUS_RESET;
+			notify.nt_need_ack = 1;
+			(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 			break;
+		}
 		case IN_PORT_LOGOUT:
 		case IN_ABORT_TASK:
 		case IN_PORT_CHANGED:
@@ -223,8 +348,10 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 			(void) isp_async(isp, ISPASYNC_TARGET_ACTION, &local);
 			break;
 		default:
-			isp_prt(isp, ISP_LOGERR,
-			    "bad status (0x%x) in isp_target_notify", status);
+			isp_prt(isp, ISP_LOGINFO,
+			    "isp_target_notify: unknown status (0x%x)",
+			    status);
+			isp_notify_ack(isp, local);
 			break;
 		}
 		break;
@@ -234,21 +361,68 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 		 * The ISP is acknowledging our acknowledgement of an
 		 * Immediate Notify entry for some asynchronous event.
 		 */
-		if (IS_FC(isp)) {
-			isp_get_notify_ack_fc(isp, nack_fcp,
-			    (na_fcentry_t *)local);
+		if (IS_24XX(isp)) {
+			isp_get_notify_ack_24xx(isp, nack_24xx,
+			    (na_fcentry_24xx_t *) local);
+			nack_24xx = (na_fcentry_24xx_t *) local;
+			if (nack_24xx->na_status != NA_OK) {
+				level = ISP_LOGINFO;
+			} else {
+				level = ISP_LOGTDEBUG1;
+			}
+			isp_prt(isp, level,
+			    "Notify Ack Status=0x%x; Subcode 0x%x seqid=0x%x",
+			    nack_24xx->na_status, nack_24xx->na_status_subcode,
+			    nack_24xx->na_rxid);
+		} else if (IS_FC(isp)) {
+			if (FCPARAM(isp)->isp_2klogin) {
+				isp_get_notify_ack_fc_e(isp, nacke_fcp,
+				    (na_fcentry_e_t *)local);
+			} else {
+				isp_get_notify_ack_fc(isp, nack_fcp,
+				    (na_fcentry_t *)local);
+			}
 			nack_fcp = (na_fcentry_t *)local;
-			isp_prt(isp, ISP_LOGTDEBUG1,
-			    "Notify Ack status=0x%x seqid 0x%x",
+			if (nack_fcp->na_status != NA_OK) {
+				level = ISP_LOGINFO;
+			} else {
+				level = ISP_LOGTDEBUG1;
+			}
+			isp_prt(isp, level,
+			    "Notify Ack Status=0x%x seqid 0x%x",
 			    nack_fcp->na_status, nack_fcp->na_seqid);
 		} else {
 			isp_get_notify_ack(isp, nackp, (na_entry_t *)local);
 			nackp = (na_entry_t *)local;
-			isp_prt(isp, ISP_LOGTDEBUG1,
+			if (nackp->na_status != NA_OK) {
+				level = ISP_LOGINFO;
+			} else {
+				level = ISP_LOGTDEBUG1;
+			}
+			isp_prt(isp, level,
 			    "Notify Ack event 0x%x status=0x%x seqid 0x%x",
 			    nackp->na_event, nackp->na_status, nackp->na_seqid);
 		}
 		break;
+
+	case RQSTYPE_ABTS_RCVD:
+		isp_get_abts(isp, abts, (abts_t *)local);
+		(void) isp_async(isp, ISPASYNC_TARGET_ACTION, &local);
+		break;
+	case RQSTYPE_ABTS_RSP:
+		isp_get_abts_rsp(isp, abts_rsp, (abts_rsp_t *)local);
+		abts_rsp = (abts_rsp_t *) local;
+		if (abts_rsp->abts_rsp_status) {
+			level = ISP_LOGINFO;
+		} else {
+			level = ISP_LOGTDEBUG0;
+		}
+		isp_prt(isp, level,
+		    "ABTS RSP response[0x%x]: status=0x%x sub=(0x%x 0x%x)",
+		    abts_rsp->abts_rsp_rxid_task, abts_rsp->abts_rsp_status,
+		    abts_rsp->abts_rsp_payload.rsp.subcode1,
+		    abts_rsp->abts_rsp_payload.rsp.subcode2);
+		break;
 	default:
 		isp_prt(isp, ISP_LOGERR,
 		    "Unknown entry type 0x%x in isp_target_notify", type);
@@ -257,13 +431,24 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
 	}
 #undef	atiop
 #undef	at2iop
+#undef	at2eiop
+#undef	at7iop
 #undef	ctiop
 #undef	ct2iop
+#undef	ct2eiop
+#undef	ct7iop
 #undef	lunenp
 #undef	inotp
 #undef	inot_fcp
+#undef	inote_fcp
+#undef	inot_24xx
 #undef	nackp
 #undef	nack_fcp
+#undef	nacke_fcp
+#undef	hack_24xx
+#undef	abts
+#undef	abts_rsp
+#undef	els
 #undef	hdrp
 	return (rval);
 }
@@ -279,11 +464,11 @@ isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
  * response entry. The caller is responsible for synchronizing this.
  */
 int
-isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
-    int cmd_cnt, int inot_cnt, u_int32_t opaque)
+isp_lun_cmd(ispsoftc_t *isp, int cmd, int bus, int tgt, int lun,
+    int cmd_cnt, int inot_cnt, uint32_t opaque)
 {
 	lun_entry_t el;
-	u_int16_t nxti, optr;
+	uint32_t nxti, optr;
 	void *outp;
 
 
@@ -315,10 +500,10 @@ isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
 	if (IS_SCSI(isp)) {
 		el.le_tgt = tgt;
 		el.le_lun = lun;
-	} else if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
+	} else if (FCPARAM(isp)->isp_sccfw == 0) {
 		el.le_lun = lun;
 	}
-	el.le_timeout = 2;
+	el.le_timeout = 30;
 
 	if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
 		isp_prt(isp, ISP_LOGERR,
@@ -333,11 +518,11 @@ isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
 
 
 int
-isp_target_put_entry(struct ispsoftc *isp, void *ap)
+isp_target_put_entry(ispsoftc_t *isp, void *ap)
 {
 	void *outp;
-	u_int16_t nxti, optr;
-	u_int8_t etype = ((isphdr_t *) ap)->rqs_entry_type;
+	uint32_t nxti, optr;
+	uint8_t etype = ((isphdr_t *) ap)->rqs_entry_type;
 
 	if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
 		isp_prt(isp, ISP_LOGWARN,
@@ -349,31 +534,46 @@ isp_target_put_entry(struct ispsoftc *isp, void *ap)
 		isp_put_atio(isp, (at_entry_t *) ap, (at_entry_t *) outp);
 		break;
 	case RQSTYPE_ATIO2:
-		isp_put_atio2(isp, (at2_entry_t *) ap, (at2_entry_t *) outp);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_put_atio2e(isp, (at2e_entry_t *) ap,
+			    (at2e_entry_t *) outp);
+		} else {
+			isp_put_atio2(isp, (at2_entry_t *) ap,
+			    (at2_entry_t *) outp);
+		}
 		break;
 	case RQSTYPE_CTIO:
 		isp_put_ctio(isp, (ct_entry_t *) ap, (ct_entry_t *) outp);
 		break;
 	case RQSTYPE_CTIO2:
-		isp_put_ctio2(isp, (ct2_entry_t *) ap, (ct2_entry_t *) outp);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_put_ctio2e(isp, (ct2e_entry_t *) ap,
+			    (ct2e_entry_t *) outp);
+		} else {
+			isp_put_ctio2(isp, (ct2_entry_t *) ap,
+			    (ct2_entry_t *) outp);
+		}
+		break;
+	case RQSTYPE_CTIO7:
+		isp_put_ctio7(isp, (ct7_entry_t *) ap, (ct7_entry_t *) outp);
 		break;
 	default:
 		isp_prt(isp, ISP_LOGERR,
 		    "Unknown type 0x%x in isp_put_entry", etype);
 		return (-1);
 	}
-
 	ISP_TDQE(isp, "isp_target_put_entry", (int) optr, ap);
 	ISP_ADD_REQUEST(isp, nxti);
 	return (0);
 }
 
 int
-isp_target_put_atio(struct ispsoftc *isp, void *arg)
+isp_target_put_atio(ispsoftc_t *isp, void *arg)
 {
 	union {
 		at_entry_t _atio;
 		at2_entry_t _atio2;
+		at2e_entry_t _atio2e;
 	} atun;
 
 	MEMZERO(&atun, sizeof atun);
@@ -381,12 +581,16 @@ isp_target_put_atio(struct ispsoftc *isp, void *arg)
 		at2_entry_t *aep = arg;
 		atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2;
 		atun._atio2.at_header.rqs_entry_count = 1;
-		if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
-			atun._atio2.at_scclun = (u_int16_t) aep->at_scclun;
+		if (FCPARAM(isp)->isp_sccfw) {
+			atun._atio2.at_scclun = aep->at_scclun;
+		} else {
+			atun._atio2.at_lun = (uint8_t) aep->at_lun;
+		}
+		if (FCPARAM(isp)->isp_2klogin) {
+			atun._atio2e.at_iid = ((at2e_entry_t *)aep)->at_iid;
 		} else {
-			atun._atio2.at_lun = (u_int8_t) aep->at_lun;
+			atun._atio2.at_iid = aep->at_iid;
 		}
-		atun._atio2.at_iid = aep->at_iid;
 		atun._atio2.at_rxid = aep->at_rxid;
 		atun._atio2.at_status = CT_OK;
 	} else {
@@ -424,29 +628,62 @@ isp_target_put_atio(struct ispsoftc *isp, void *arg)
  */
 
 int
-isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
+isp_endcmd(ispsoftc_t *isp, void *arg, uint32_t code, uint32_t hdl)
 {
 	int sts;
 	union {
 		ct_entry_t _ctio;
 		ct2_entry_t _ctio2;
+		ct2e_entry_t _ctio2e;
+		ct7_entry_t _ctio7;
 	} un;
 
 	MEMZERO(&un, sizeof un);
 	sts = code & 0xff;
 
-	if (IS_FC(isp)) {
+	if (IS_24XX(isp)) {
+		at7_entry_t *aep = arg;
+		ct7_entry_t *cto = &un._ctio7;
+
+		cto->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
+		cto->ct_header.rqs_entry_count = 1;
+/* XXXX */	cto->ct_nphdl = aep->at_hdr.seq_id;
+		cto->ct_rxid = aep->at_rxid;
+		cto->ct_iid_lo = (aep->at_hdr.s_id[1] << 8) |
+		    aep->at_hdr.s_id[2];
+		cto->ct_iid_hi = aep->at_hdr.s_id[0];
+		cto->ct_oxid = aep->at_hdr.ox_id;
+		cto->ct_scsi_status = sts;
+		cto->ct_flags = CT7_FLAG_MODE1 | CT7_NO_DATA | CT7_SENDSTATUS;
+		if (sts == SCSI_CHECK && (code & ECMD_SVALID)) {
+			cto->rsp.m1.ct_resplen = 16;
+			cto->rsp.m1.ct_resp[0] = 0xf0;
+			cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
+			cto->rsp.m1.ct_resp[7] = 8;
+			cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
+			cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
+		}
+		if (aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl) {
+			cto->ct_resid = aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl;
+			cto->ct_scsi_status |= CT2_DATA_UNDER;
+		}
+		cto->ct_syshandle = hdl;
+	} else if (IS_FC(isp)) {
 		at2_entry_t *aep = arg;
 		ct2_entry_t *cto = &un._ctio2;
 
 		cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
 		cto->ct_header.rqs_entry_count = 1;
-		cto->ct_iid = aep->at_iid;
-		if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
+		if (FCPARAM(isp)->isp_sccfw == 0) {
 			cto->ct_lun = aep->at_lun;
 		}
+		if (FCPARAM(isp)->isp_2klogin) {
+			un._ctio2e.ct_iid = ((at2e_entry_t *)aep)->at_iid;
+		} else {
+			cto->ct_iid = aep->at_iid;
+		}
 		cto->ct_rxid = aep->at_rxid;
-		cto->rsp.m1.ct_scsi_status = sts & 0xff;
+		cto->rsp.m1.ct_scsi_status = sts;
 		cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
 		if (hdl == 0) {
 			cto->ct_flags |= CT2_CCINCR;
@@ -455,7 +692,7 @@ isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
 			cto->ct_resid = aep->at_datalen;
 			cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
 		}
-		if ((sts & 0xff) == SCSI_CHECK && (sts & ECMD_SVALID)) {
+		if (sts == SCSI_CHECK && (code & ECMD_SVALID)) {
 			cto->rsp.m1.ct_resp[0] = 0xf0;
 			cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
 			cto->rsp.m1.ct_resp[7] = 8;
@@ -490,63 +727,87 @@ isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
 	return (isp_target_put_entry(isp, &un));
 }
 
+/*
+ * These are either broadcast events or specifically CTIO fast completion
+ */
 int
-isp_target_async(struct ispsoftc *isp, int bus, int event)
+isp_target_async(ispsoftc_t *isp, int bus, int event)
 {
-	tmd_event_t evt;
-	tmd_msg_t msg;
+	tmd_notify_t notify;
+
+	MEMZERO(&notify, sizeof (tmd_notify_t));
+	notify.nt_hba = isp;
+	notify.nt_iid = INI_ANY;
+	/* nt_tgt set in outer layers */
+	notify.nt_lun = LUN_ANY;
+	notify.nt_tagval = TAG_ANY;
+
+	if (IS_SCSI(isp)) {
+		TAG_INSERT_BUS(notify.nt_tagval, bus);
+	}
 
 	switch (event) {
-	/*
-	 * These three we handle here to propagate an effective bus reset
-	 * upstream, but these do not require any immediate notify actions
-	 * so we return when done.
-	 */
-	case ASYNC_LIP_F8:
-	case ASYNC_LIP_OCCURRED:
 	case ASYNC_LOOP_UP:
+	case ASYNC_PTPMODE:
+		notify.nt_ncode = NT_LINK_UP;
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
+		break;
 	case ASYNC_LOOP_DOWN:
+		notify.nt_ncode = NT_LINK_DOWN;
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
+		break;
+	case ASYNC_LIP_ERROR:
+	case ASYNC_LIP_F8:
+	case ASYNC_LIP_OCCURRED:
 	case ASYNC_LOOP_RESET:
-	case ASYNC_PTPMODE:
-		/*
-		 * These don't require any immediate notify actions. We used
-		 * treat them like SCSI Bus Resets, but that was just plain
-		 * wrong. Let the normal CTIO completion report what occurred.
-		 */
-                return (0);
-
+		notify.nt_ncode = NT_LIP_RESET;
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
+		break;
 	case ASYNC_BUS_RESET:
-	case ASYNC_TIMEOUT_RESET:
-		if (IS_FC(isp)) {
-			return (0); /* we'll be getting an inotify instead */
-		}
-		evt.ev_bus = bus;
-		evt.ev_event = event;
-		(void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt);
+	case ASYNC_TIMEOUT_RESET:	/* XXX: where does this come from ? */
+		notify.nt_ncode = NT_BUS_RESET;
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 		break;
 	case ASYNC_DEVICE_RESET:
-		/*
-		 * Bus Device Reset resets a specific target, so
-		 * we pass this as a synthesized message.
-		 */
-		MEMZERO(&msg, sizeof msg);
-		if (IS_FC(isp)) {
-			msg.nt_iid = FCPARAM(isp)->isp_loopid;
+		notify.nt_ncode = NT_TARGET_RESET;
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
+		break;
+	case ASYNC_CTIO_DONE:
+	{
+		uint8_t storage[QENTRY_LEN];
+		memset(storage, 0, QENTRY_LEN);
+		if (IS_24XX(isp)) {
+			ct7_entry_t *ct = (ct7_entry_t *) storage;
+			ct->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
+			ct->ct_nphdl = CT7_OK;
+			ct->ct_syshandle = bus;
+			ct->ct_flags = CT7_SENDSTATUS|CT7_FASTPOST;
+		} else if (IS_FC(isp)) {
+            		/* This should also suffice for 2K login code */
+			ct2_entry_t *ct = (ct2_entry_t *) storage;
+			ct->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
+			ct->ct_status = CT_OK;
+			ct->ct_syshandle = bus;
+			ct->ct_flags = CT2_SENDSTATUS|CT2_FASTPOST;
 		} else {
-			msg.nt_iid = SDPARAM(isp)->isp_initiator_id;
+			ct_entry_t *ct = (ct_entry_t *) storage;
+			ct->ct_header.rqs_entry_type = RQSTYPE_CTIO;
+			ct->ct_status = CT_OK;
+			ct->ct_fwhandle = bus;
+			ct->ct_flags = CT_SENDSTATUS;
 		}
-		msg.nt_bus = bus;
-		msg.nt_msg[0] = MSG_BUS_DEV_RESET;
-		(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
+		(void) isp_async(isp, ISPASYNC_TARGET_ACTION, storage);
 		break;
+	}
 	default:
 		isp_prt(isp, ISP_LOGERR,
 		    "isp_target_async: unknown event 0x%x", event);
+		if (isp->isp_state == ISP_RUNSTATE) {
+			isp_notify_ack(isp, NULL);
+		}
 		break;
 	}
-	if (isp->isp_state == ISP_RUNSTATE)
-		isp_notify_ack(isp, NULL);
-	return(0);
+	return (0);
 }
 
 
@@ -559,25 +820,53 @@ isp_target_async(struct ispsoftc *isp, int bus, int event)
  */
 
 static void
-isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
+isp_got_msg(ispsoftc_t *isp, in_entry_t *inp)
 {
-	u_int8_t status = inp->in_status & ~QLTM_SVALID;
+	tmd_notify_t nt;
+	uint8_t status = inp->in_status & ~QLTM_SVALID;
+
+	MEMZERO(&nt, sizeof (nt));
+	nt.nt_hba = isp;
+	nt.nt_iid = GET_IID_VAL(inp->in_iid);
+	nt.nt_tgt = inp->in_tgt;
+	nt.nt_lun = inp->in_lun;
+	IN_MAKE_TAGID(nt.nt_tagval, GET_BUS_VAL(inp->in_iid), 0, inp);
+	nt.nt_lreserved = inp;
 
 	if (status == IN_IDE_RECEIVED || status == IN_MSG_RECEIVED) {
-		tmd_msg_t msg;
-
-		MEMZERO(&msg, sizeof (msg));
-		msg.nt_bus = bus;
-		msg.nt_iid = inp->in_iid;
-		msg.nt_tgt = inp->in_tgt;
-		msg.nt_lun = inp->in_lun;
-		msg.nt_tagtype = inp->in_tag_type;
-		msg.nt_tagval = inp->in_tag_val;
-		MEMCPY(msg.nt_msg, inp->in_msg, IN_MSGLEN);
-		(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
+		switch (inp->in_msg[0]) {
+		case MSG_ABORT:
+			nt.nt_ncode = NT_ABORT_TASK_SET;
+			break;
+		case MSG_BUS_DEV_RESET:
+			nt.nt_ncode = NT_TARGET_RESET;
+			break;
+		case MSG_ABORT_TAG:
+			nt.nt_ncode = NT_ABORT_TASK;
+			break;
+		case MSG_CLEAR_QUEUE:
+			nt.nt_ncode = NT_CLEAR_TASK_SET;
+			break;
+		case MSG_REL_RECOVERY:
+			nt.nt_ncode = NT_CLEAR_ACA;
+			break;
+		case MSG_TERM_IO_PROC:
+			nt.nt_ncode = NT_ABORT_TASK;
+			break;
+		case MSG_LUN_RESET:
+			nt.nt_ncode = NT_LUN_RESET;
+			break;
+		default:
+			isp_prt(isp, ISP_LOGERR,
+			    "unhandled message 0x%x", inp->in_msg[0]);
+			isp_notify_ack(isp, inp);
+			return;
+		}
+		(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &nt);
 	} else {
 		isp_prt(isp, ISP_LOGERR,
 		    "unknown immediate notify status 0x%x", inp->in_status);
+		isp_notify_ack(isp, inp);
 	}
 }
 
@@ -585,69 +874,140 @@ isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
  * Synthesize a message from the task management flags in a FCP_CMND_IU.
  */
 static void
-isp_got_msg_fc(struct ispsoftc *isp, int bus, in_fcentry_t *inp)
+isp_got_msg_fc(ispsoftc_t *isp, in_fcentry_t *inp)
 {
-	int lun;
-	static const char f1[] = "%s from iid %d lun %d seq 0x%x";
-	static const char f2[] = 
-	    "unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n";
-
-	if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
-		lun = inp->in_scclun;
+	tmd_notify_t nt;
+	static const char f1[] = "%s from N-port handle 0x%x lun %d seq 0x%x";
+	static const char f2[] = "unknown %s 0x%x lun %d N-Port handle 0x%x "
+	    "task flags 0x%x seq 0x%x\n";
+	uint16_t seqid, loopid;
+
+	MEMZERO(&nt, sizeof (tmd_notify_t));
+	nt.nt_hba = isp;
+	if (FCPARAM(isp)->isp_2klogin) {
+		nt.nt_iid = ((in_fcentry_e_t *)inp)->in_iid;
+		loopid = ((in_fcentry_e_t *)inp)->in_iid;
+		seqid = ((in_fcentry_e_t *)inp)->in_seqid;
 	} else {
-		lun = inp->in_lun;
+		nt.nt_iid = inp->in_iid;
+		loopid = inp->in_iid;
+		seqid = inp->in_seqid;
 	}
+	/* nt_tgt set in outer layers */
+	if (FCPARAM(isp)->isp_sccfw) {
+		nt.nt_lun = inp->in_scclun;
+	} else {
+		nt.nt_lun = inp->in_lun;
+	}
+	IN_FC_MAKE_TAGID(nt.nt_tagval, 0, 0, seqid);
+	nt.nt_need_ack = 1;
+	nt.nt_lreserved = inp;
 
 	if (inp->in_status != IN_MSG_RECEIVED) {
 		isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status",
-		    inp->in_status, lun, inp->in_iid,
-		    inp->in_task_flags,  inp->in_seqid);
+		    inp->in_status, nt.nt_lun, loopid, inp->in_task_flags,
+		    inp->in_seqid);
+		isp_notify_ack(isp, inp);
+		return;
+	}
+
+	if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK_SET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET",
+		    loopid, nt.nt_lun, inp->in_seqid);
+		nt.nt_ncode = NT_ABORT_TASK_SET;
+	} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
+		    loopid, nt.nt_lun, inp->in_seqid);
+		nt.nt_ncode = NT_CLEAR_TASK_SET;
+	} else if (inp->in_task_flags & TASK_FLAGS_LUN_RESET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET",
+		    loopid, nt.nt_lun, inp->in_seqid);
+		nt.nt_ncode = NT_LUN_RESET;
+	} else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
+		    loopid, nt.nt_lun, inp->in_seqid);
+		nt.nt_ncode = NT_TARGET_RESET;
+	} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
+		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
+		    loopid, nt.nt_lun, inp->in_seqid);
+		nt.nt_ncode = NT_CLEAR_ACA;
 	} else {
-		tmd_msg_t msg;
-
-		MEMZERO(&msg, sizeof (msg));
-		msg.nt_bus = bus;
-		msg.nt_iid = inp->in_iid;
-		msg.nt_tagval = inp->in_seqid;
-		msg.nt_lun = lun;
-
-		if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK) {
-			isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK",
-			    inp->in_iid, lun, inp->in_seqid);
-			msg.nt_msg[0] = MSG_ABORT_TAG;
-		} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
-			isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
-			    inp->in_iid, lun, inp->in_seqid);
-			msg.nt_msg[0] = MSG_CLEAR_QUEUE;
-		} else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
-			isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
-			    inp->in_iid, lun, inp->in_seqid);
-			msg.nt_msg[0] = MSG_BUS_DEV_RESET;
-		} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
-			isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
-			    inp->in_iid, lun, inp->in_seqid);
-			/* ???? */
-			msg.nt_msg[0] = MSG_REL_RECOVERY;
-		} else if (inp->in_task_flags & TASK_FLAGS_TERMINATE_TASK) {
-			isp_prt(isp, ISP_LOGINFO, f1, "TERMINATE TASK",
-			    inp->in_iid, lun, inp->in_seqid);
-			msg.nt_msg[0] = MSG_TERM_IO_PROC;
-		} else {
-			isp_prt(isp, ISP_LOGWARN, f2, "task flag",
-			    inp->in_status, lun, inp->in_iid,
-			    inp->in_task_flags,  inp->in_seqid);
-		}
-		if (msg.nt_msg[0]) {
-			(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
-		}
+		isp_prt(isp, ISP_LOGWARN, f2, "task flag", inp->in_status,
+		    nt.nt_lun, loopid, inp->in_task_flags,  inp->in_seqid);
+		isp_notify_ack(isp, inp);
+		return;
 	}
+	(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &nt);
 }
 
+#define	HILO(x)	(uint32_t) (x >> 32),  (uint32_t) x
 static void
-isp_notify_ack(struct ispsoftc *isp, void *arg)
+isp_got_tmf_24xx(ispsoftc_t *isp, at7_entry_t *aep)
+{
+	tmd_notify_t nt;
+	static const char f1[] =
+	    "%s from PortID 0x%06x lun %d seq 0x%08x%08x";
+	static const char f2[] = 
+	    "unknown Task Flag 0x%x lun %d PortID 0x%x tag 0x%08x%08x";
+	uint32_t sid;
+
+	MEMZERO(&nt, sizeof (tmd_notify_t));
+	nt.nt_hba = isp;
+	nt.nt_iid = INI_ANY;
+	nt.nt_lun =
+	    (aep->at_cmnd.fcp_cmnd_lun[0] << 8) |
+	    (aep->at_cmnd.fcp_cmnd_lun[1]);
+	/*
+	 * XXX: VPIDX HAS TO BE DERIVED FROM DESTINATION PORT
+	 */
+	nt.nt_tagval = aep->at_rxid;
+	nt.nt_lreserved = aep;
+	sid =
+	    (aep->at_hdr.s_id[0] << 16) |
+	    (aep->at_hdr.s_id[1] <<  8) |
+	    (aep->at_hdr.s_id[2]);
+
+	if (aep->at_cmnd.fcp_cmnd_task_management &
+	    FCP_CMND_TMF_ABORT_TASK_SET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET",
+		    sid, nt.nt_lun, HILO(nt.nt_tagval));
+		nt.nt_ncode = NT_ABORT_TASK_SET;
+	} else if (aep->at_cmnd.fcp_cmnd_task_management &
+	    FCP_CMND_TMF_CLEAR_TASK_SET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
+		    sid, nt.nt_lun, HILO(nt.nt_tagval));
+		nt.nt_ncode = NT_CLEAR_TASK_SET;
+	} else if (aep->at_cmnd.fcp_cmnd_task_management &
+	    FCP_CMND_TMF_LUN_RESET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET",
+		    sid, nt.nt_lun, HILO(nt.nt_tagval));
+		nt.nt_ncode = NT_LUN_RESET;
+	} else if (aep->at_cmnd.fcp_cmnd_task_management &
+	    FCP_CMND_TMF_TGT_RESET) {
+		isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
+		    sid, nt.nt_lun, HILO(nt.nt_tagval));
+		nt.nt_ncode = NT_TARGET_RESET;
+		nt.nt_lun = LUN_ANY;
+	} else if (aep->at_cmnd.fcp_cmnd_task_management &
+	    FCP_CMND_TMF_CLEAR_ACA) {
+		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
+		    sid, nt.nt_lun, HILO(nt.nt_tagval));
+		nt.nt_ncode = NT_CLEAR_ACA;
+	} else {
+		isp_prt(isp, ISP_LOGWARN, f2,
+		    aep->at_cmnd.fcp_cmnd_task_management,
+		    nt.nt_lun, sid, HILO(nt.nt_tagval));
+		isp_endcmd(isp, aep, 0, 0);
+		return;
+	}
+	(void) isp_async(isp, ISPASYNC_TARGET_NOTIFY, &nt);
+}
+
+void
+isp_notify_ack(ispsoftc_t *isp, void *arg)
 {
 	char storage[QENTRY_LEN];
-	u_int16_t nxti, optr;
+	uint32_t nxti, optr;
 	void *outp;
 
 	if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
@@ -658,30 +1018,82 @@ isp_notify_ack(struct ispsoftc *isp, void *arg)
 
 	MEMZERO(storage, QENTRY_LEN);
 
-	if (IS_FC(isp)) {
+	if (IS_24XX(isp) && arg != NULL && (((isphdr_t *)arg)->rqs_entry_type == RQSTYPE_ATIO)) {
+		at7_entry_t *aep = arg;
+		isp_endcmd(isp, aep, 0, 0);
+		return;
+	} else if (IS_24XX(isp) && arg != NULL && (((isphdr_t *)arg)->rqs_entry_type == RQSTYPE_ABTS_RSP)) {
+		abts_rsp_t *abts_rsp = (abts_rsp_t *) storage;
+		/*
+		 * The caller will have set response values as appropriate
+		 * in the ABTS structure just before calling us.
+		 */
+		MEMCPY(abts_rsp, arg, QENTRY_LEN);
+		isp_put_abts_rsp(isp, abts_rsp, (abts_rsp_t *)outp);
+	} else if (IS_24XX(isp)) {
+		na_fcentry_24xx_t *na = (na_fcentry_24xx_t *) storage;
+		if (arg) {
+			in_fcentry_24xx_t *in = arg;
+			na->na_nphdl = in->in_nphdl;
+			na->na_status = in->in_status;
+			na->na_status_subcode = in->in_status_subcode;
+			na->na_rxid = in->in_rxid;
+			na->na_oxid = in->in_oxid;
+			if (in->in_status == IN24XX_SRR_RCVD) {
+				na->na_srr_rxid = in->in_srr_rxid;
+				na->na_srr_reloff_hi = in->in_srr_reloff_hi;
+				na->na_srr_reloff_lo = in->in_srr_reloff_lo;
+				na->na_srr_iu = in->in_srr_iu;
+				na->na_srr_flags = 1;
+				na->na_srr_reject_vunique = 0;
+				na->na_srr_reject_explanation = 1;
+				na->na_srr_reject_code = 1;
+			}
+		}
+		na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
+		na->na_header.rqs_entry_count = 1;
+		isp_put_notify_24xx_ack(isp, na, (na_fcentry_24xx_t *)outp);
+	} else if (IS_FC(isp)) {
 		na_fcentry_t *na = (na_fcentry_t *) storage;
+		int iid = 0;
+
 		if (arg) {
 			in_fcentry_t *inp = arg;
 			MEMCPY(storage, arg, sizeof (isphdr_t));
-			na->na_iid = inp->in_iid;
-			if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
-				na->na_lun = inp->in_scclun;
+			if (FCPARAM(isp)->isp_2klogin) {
+				((na_fcentry_e_t *)na)->na_iid =
+				    ((in_fcentry_e_t *)inp)->in_iid;
+				iid = ((na_fcentry_e_t *)na)->na_iid;
 			} else {
-				na->na_lun = inp->in_lun;
+				na->na_iid = inp->in_iid;
+				iid = na->na_iid;
 			}
-			na->na_task_flags = inp->in_task_flags;
+			na->na_task_flags =
+			    inp->in_task_flags & TASK_FLAGS_RESERVED_MASK;
 			na->na_seqid = inp->in_seqid;
 			na->na_flags = NAFC_RCOUNT;
 			na->na_status = inp->in_status;
 			if (inp->in_status == IN_RESET) {
 				na->na_flags |= NAFC_RST_CLRD;
 			}
+			if (inp->in_status == IN_MSG_RECEIVED) {
+				na->na_flags |= NAFC_TVALID;
+				na->na_response = 0;	/* XXX SUCCEEDED XXX */
+			}
 		} else {
 			na->na_flags = NAFC_RST_CLRD;
 		}
 		na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 		na->na_header.rqs_entry_count = 1;
-		isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_put_notify_ack_fc_e(isp, (na_fcentry_e_t *) na,
+			    (na_fcentry_e_t *)outp);
+		} else {
+			isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
+		}
+		isp_prt(isp, ISP_LOGTDEBUG0, "notify ack loopid %u seqid %x "
+		    "flags %x tflags %x response %x", iid, na->na_seqid,
+		    na->na_flags, na->na_task_flags, na->na_response);
 	} else {
 		na_entry_t *na = (na_entry_t *) storage;
 		if (arg) {
@@ -700,13 +1112,16 @@ isp_notify_ack(struct ispsoftc *isp, void *arg)
 		na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 		na->na_header.rqs_entry_count = 1;
 		isp_put_notify_ack(isp, na, (na_entry_t *)outp);
+		isp_prt(isp, ISP_LOGTDEBUG0, "notify ack loopid %u lun %u tgt "
+		    "%u seqid %x event %x", na->na_iid, na->na_lun, na->na_tgt,
+		    na->na_seqid, na->na_event);
 	}
 	ISP_TDQE(isp, "isp_notify_ack", (int) optr, storage);
 	ISP_ADD_REQUEST(isp, nxti);
 }
 
 static void
-isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
+isp_handle_atio(ispsoftc_t *isp, at_entry_t *aep)
 {
 	int lun;
 	lun = aep->at_lun;
@@ -714,7 +1129,7 @@ isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
 	 * The firmware status (except for the QLTM_SVALID bit) indicates
 	 * why this ATIO was sent to us.
 	 *
-	 * If QLTM_SVALID is set, the firmware has recommended Sense Data.
+	 * If QLTM_SVALID is set, the firware has recommended Sense Data.
 	 *
 	 * If the DISCONNECTS DISABLED bit is set in the flags field,
 	 * we're still connected on the SCSI bus - i.e. the initiator
@@ -779,7 +1194,7 @@ isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
 
 	default:
 		isp_prt(isp, ISP_LOGERR,
-		    "Unknown ATIO status 0x%x from initiator %d for lun %d",
+		    "Unknown ATIO status 0x%x from loopid %d for lun %d",
 		    aep->at_status, aep->at_iid, lun);
 		(void) isp_target_put_atio(isp, aep);
 		break;
@@ -787,21 +1202,27 @@ isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
 }
 
 static void
-isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
+isp_handle_atio2(ispsoftc_t *isp, at2_entry_t *aep)
 {
-	int lun;
+	int lun, iid;
 
-	if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
+	if (FCPARAM(isp)->isp_sccfw) {
 		lun = aep->at_scclun;
 	} else {
 		lun = aep->at_lun;
 	}
 
+	if (FCPARAM(isp)->isp_2klogin) {
+		iid = ((at2e_entry_t *)aep)->at_iid;
+	} else {
+		iid = aep->at_iid;
+	}
+
 	/*
 	 * The firmware status (except for the QLTM_SVALID bit) indicates
 	 * why this ATIO was sent to us.
 	 *
-	 * If QLTM_SVALID is set, the firmware has recommended Sense Data.
+	 * If QLTM_SVALID is set, the firware has recommended Sense Data.
 	 *
 	 * If the DISCONNECTS DISABLED bit is set in the flags field,
 	 * we're still connected on the SCSI bus - i.e. the initiator
@@ -856,30 +1277,31 @@ isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
 		 * Ignore it because the async event will clear things
 		 * up for us.
 		 */
-		isp_prt(isp, ISP_LOGERR, atior, lun, aep->at_iid, 0);
+		isp_prt(isp, ISP_LOGERR, atior, lun, iid, 0);
 		break;
 
 
 	default:
 		isp_prt(isp, ISP_LOGERR,
-		    "Unknown ATIO2 status 0x%x from initiator %d for lun %d",
-		    aep->at_status, aep->at_iid, lun);
+		    "Unknown ATIO2 status 0x%x from loopid %d for lun %d",
+		    aep->at_status, iid, lun);
 		(void) isp_target_put_atio(isp, aep);
 		break;
 	}
 }
 
 static void
-isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
+isp_handle_ctio(ispsoftc_t *isp, ct_entry_t *ct)
 {
 	void *xs;
 	int pl = ISP_LOGTDEBUG2;
 	char *fmsg = NULL;
 
 	if (ct->ct_syshandle) {
-		xs = isp_find_xs(isp, ct->ct_syshandle);
-		if (xs == NULL)
+		xs = isp_find_xs_tgt(isp, ct->ct_syshandle);
+		if (xs == NULL) {
 			pl = ISP_LOGALL;
+		}
 	} else {
 		xs = NULL;
 	}
@@ -931,7 +1353,7 @@ isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
 		if (fmsg == NULL)
 			fmsg = "ABORT TAG message sent by Initiator";
 
-		isp_prt(isp, ISP_LOGWARN, "CTIO destroyed by %s", fmsg);
+		isp_prt(isp, ISP_LOGTDEBUG0, "CTIO destroyed by %s", fmsg);
 		break;
 
 	case CT_INVAL:
@@ -1030,16 +1452,17 @@ isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
 }
 
 static void
-isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
+isp_handle_ctio2(ispsoftc_t *isp, ct2_entry_t *ct)
 {
-	XS_T *xs;
+	void *xs;
 	int pl = ISP_LOGTDEBUG2;
 	char *fmsg = NULL;
 
 	if (ct->ct_syshandle) {
-		xs = isp_find_xs(isp, ct->ct_syshandle);
-		if (xs == NULL)
+		xs = isp_find_xs_tgt(isp, ct->ct_syshandle);
+		if (xs == NULL) {
 			pl = ISP_LOGALL;
+		}
 	} else {
 		xs = NULL;
 	}
@@ -1069,7 +1492,7 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		 * status. These CTIOs are handled in that same way as
 		 * CT_ABORTED ones, so just fall through here.
 		 */
-		fmsg = "TARGET RESET Task Management Function Received";
+		fmsg = "TARGET RESET";
 		/*FALLTHROUGH*/
 	case CT_RESET:
 		if (fmsg == NULL)
@@ -1081,10 +1504,12 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		 * Bus Free and returns all outstanding CTIOs with the status
 		 * set, then sends us an Immediate Notify entry.
 		 */
-		if (fmsg == NULL)
-			fmsg = "ABORT Task Management Function Received";
+		if (fmsg == NULL) {
+			fmsg = "ABORT";
+		}
 
-		isp_prt(isp, ISP_LOGERR, "CTIO2 destroyed by %s", fmsg);
+		isp_prt(isp, ISP_LOGTDEBUG0,
+		    "CTIO2 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
 		break;
 
 	case CT_INVAL:
@@ -1110,16 +1535,18 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		if (fmsg == NULL)
 			fmsg = "Port Logout";
 		/*FALLTHROUGH*/
-	case CT_PORTNOTAVAIL:
+	case CT_PORTUNAVAIL:
 		if (fmsg == NULL)
 			fmsg = "Port not available";
+		/*FALLTHROUGH*/
 	case CT_PORTCHANGED:
 		if (fmsg == NULL)
 			fmsg = "Port Changed";
+		/*FALLTHROUGH*/
 	case CT_NOACK:
 		if (fmsg == NULL)
 			fmsg = "unacknowledged Immediate Notify pending";
-		isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
+		isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
 		break;
 
 	case CT_INVRXID:
@@ -1127,7 +1554,7 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		 * CTIO rejected by the firmware because an invalid RX_ID.
 		 * Just print a message.
 		 */
-		isp_prt(isp, ISP_LOGERR,
+		isp_prt(isp, ISP_LOGWARN,
 		    "CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
 		break;
 
@@ -1146,7 +1573,7 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		 * order we got them.
 		 */
 		if (ct->ct_syshandle == 0) {
-			if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
+			if ((ct->ct_flags & CT2_SENDSTATUS) == 0) {
 				isp_prt(isp, pl,
 				    "intermediate CTIO completed ok");
 			} else {
@@ -1162,7 +1589,160 @@ isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
 		if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
 			ISP_DMAFREE(isp, xs, ct->ct_syshandle);
 		}
-		if (ct->ct_flags & CT_SENDSTATUS) {
+		if (ct->ct_flags & CT2_SENDSTATUS) {
+			/*
+			 * Sent status and command complete.
+			 *
+			 * We're now really done with this command, so we
+			 * punt to the platform dependent layers because
+			 * only there can we do the appropriate command
+			 * complete thread synchronization.
+			 */
+			isp_prt(isp, pl, "status CTIO complete");
+		} else {
+			/*
+			 * Final CTIO completed. Release DMA resources and
+			 * notify platform dependent layers.
+			 */
+			isp_prt(isp, pl, "data CTIO complete");
+		}
+		(void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
+		/*
+		 * The platform layer will destroy the handle if appropriate.
+		 */
+	}
+}
+
+static void
+isp_handle_ctio7(ispsoftc_t *isp, ct7_entry_t *ct)
+{
+	void *xs;
+	int pl = ISP_LOGTDEBUG2;
+	char *fmsg = NULL;
+
+	if (ct->ct_syshandle) {
+		xs = isp_find_xs_tgt(isp, ct->ct_syshandle);
+		if (xs == NULL) {
+			pl = ISP_LOGALL;
+		}
+	} else {
+		xs = NULL;
+	}
+
+	switch(ct->ct_nphdl) {
+	case CT7_BUS_ERROR:
+		isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
+		/* FALL Through */
+	case CT7_DATA_OVER:
+	case CT7_DATA_UNDER:
+	case CT7_OK:
+		/*
+		 * There are generally 2 possibilities as to why we'd get
+		 * this condition:
+		 * 	We sent or received data.
+		 * 	We sent status & command complete.
+		 */
+
+		break;
+
+	case CT7_RESET:
+		if (fmsg == NULL) {
+			fmsg = "LIP Reset";
+		}
+		/*FALLTHROUGH*/
+	case CT7_ABORTED:
+		/*
+		 * When an Abort message is received the firmware goes to
+		 * Bus Free and returns all outstanding CTIOs with the status
+		 * set, then sends us an Immediate Notify entry.
+		 */
+		if (fmsg == NULL) {
+			fmsg = "ABORT";
+		}
+		isp_prt(isp, ISP_LOGTDEBUG0,
+		    "CTIO7 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
+		break;
+
+	case CT7_TIMEOUT:
+		if (fmsg == NULL) {
+			fmsg = "command";
+		}
+		isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
+		break;
+
+	case CT7_ERR:
+		fmsg = "Completed with Error";
+		/*FALLTHROUGH*/
+	case CT7_LOGOUT:
+		if (fmsg == NULL) {
+			fmsg = "Port Logout";
+		}
+		/*FALLTHROUGH*/
+	case CT7_PORTUNAVAIL:
+		if (fmsg == NULL) {
+			fmsg = "Port not available";
+		}
+		/*FALLTHROUGH*/
+	case CT7_PORTCHANGED:
+		if (fmsg == NULL) {
+			fmsg = "Port Changed";
+		}
+		isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
+		break;
+
+	case CT7_INVRXID:
+		/*
+		 * CTIO rejected by the firmware because an invalid RX_ID.
+		 * Just print a message.
+		 */
+		isp_prt(isp, ISP_LOGWARN,
+		    "CTIO7 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
+		break;
+
+	case CT7_REASSY_ERR:
+		isp_prt(isp, ISP_LOGWARN, "reassembly error");
+		break;
+
+	case CT7_SRR:
+		isp_prt(isp, ISP_LOGWARN, "SRR received");
+		break;
+
+	default:
+		isp_prt(isp, ISP_LOGERR, "Unknown CTIO7 status 0x%x",
+		    ct->ct_nphdl);
+		break;
+	}
+
+	if (xs == NULL) {
+		/*
+		 * There may be more than one CTIO for a data transfer,
+		 * or this may be a status CTIO we're not monitoring.
+		 *
+		 * The assumption is that they'll all be returned in the
+		 * order we got them.
+		 */
+		if (ct->ct_syshandle == 0) {
+			if (ct->ct_flags & CT7_TERMINATE) {
+				isp_prt(isp, ISP_LOGINFO,
+				    "termination of 0x%x complete",
+				    ct->ct_rxid);
+			} else if ((ct->ct_flags & CT7_SENDSTATUS) == 0) {
+				isp_prt(isp, pl,
+				    "intermediate CTIO completed ok");
+			} else {
+				isp_prt(isp, pl,
+				    "unmonitored CTIO completed ok");
+			}
+		} else {
+			isp_prt(isp, pl,
+			    "NO xs for CTIO (handle 0x%x) status 0x%x",
+			    ct->ct_syshandle, ct->ct_nphdl);
+		}
+	} else {
+		if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
+			ISP_DMAFREE(isp, xs, ct->ct_syshandle);
+		}
+		if (ct->ct_flags & CT2_SENDSTATUS) {
 			/*
 			 * Sent status and command complete.
 			 *
diff --git a/sys/dev/ic/isp_target.h b/sys/dev/ic/isp_target.h
index 93dcd1602fe..d40a068807e 100644
--- a/sys/dev/ic/isp_target.h
+++ b/sys/dev/ic/isp_target.h
@@ -1,30 +1,5 @@
-/*	$OpenBSD: isp_target.h,v 1.13 2008/11/02 02:01:47 krw Exp $	*/
+/*	$OpenBSD: isp_target.h,v 1.14 2009/06/24 11:00:53 krw Exp $	*/
 /* $FreeBSD: src/sys/dev/isp/isp_target.h,v 1.30 2007/03/10 02:39:54 mjacob Exp $ */
-/*
- * Copyright (c) 1997, 1998
- * Patrick Stirling
- * pms@psconsult.com
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice immediately at the beginning of the file, without modification,
- *    this list of conditions, and the following disclaimer.
- * 2. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
  *  All rights reserved.
@@ -170,33 +145,13 @@ typedef struct {
 /*
  * Values for the in_task_flags field- should only get one at a time!
  */
-#define	TASK_FLAGS_ABORT_TASK		(1<<9)
-#define	TASK_FLAGS_CLEAR_TASK_SET	(1<<10)
-#define	TASK_FLAGS_TARGET_RESET		(1<<13)
 #define	TASK_FLAGS_RESERVED_MASK	(0xe700)
 #define	TASK_FLAGS_CLEAR_ACA		(1<<14)
-#define	TASK_FLAGS_TERMINATE_TASK	(1<<15)
 #define	TASK_FLAGS_TARGET_RESET		(1<<13)
 #define	TASK_FLAGS_LUN_RESET		(1<<12)
 #define	TASK_FLAGS_CLEAR_TASK_SET	(1<<10)
 #define	TASK_FLAGS_ABORT_TASK_SET	(1<<9)
 
-#ifndef	MSG_ABORT_TAG
-#define	MSG_ABORT_TAG		0x06
-#endif
-#ifndef	MSG_CLEAR_QUEUE
-#define	MSG_CLEAR_QUEUE		0x0e
-#endif
-#ifndef	MSG_BUS_DEV_RESET
-#define	MSG_BUS_DEV_RESET	0x0b
-#endif
-#ifndef	MSG_REL_RECOVERY
-#define	MSG_REL_RECOVERY	0x10
-#endif
-#ifndef	MSG_TERM_IO_PROC
-#define	MSG_TERM_IO_PROC	0x11
-#endif
-
 /*
  * ISP24XX Immediate Notify
  */
@@ -268,9 +223,9 @@ typedef struct {
 typedef struct {
 	isphdr_t	na_header;
 	u_int32_t	na_reserved;
-	u_int8_t	na_lun;		/* lun */
-	u_int8_t	na_iid;		/* initiator */
-	u_int16_t	na_scclun;
+	u_int8_t	na_reserved1;
+	u_int8_t	na_iid;		/* initiator loop id */
+	u_int16_t	na_response;
 	u_int16_t	na_flags;
 	u_int16_t	na_reserved2;
 	u_int16_t	na_status;
@@ -367,21 +322,29 @@ typedef struct {
  * Macros to create and fetch and test concatenated handle and tag value macros
  */
 
-#define	AT_MAKE_TAGID(tid, aep)						\
-	tid = ((aep)->at_handle << 16);					\
-	if ((aep)->at_flags & AT_TQAE)					\
-		(tid) |= ((aep)->at_tag_val + 1)
+#define	AT_MAKE_TAGID(tid, bus, inst, aep)				\
+	tid = aep->at_handle;						\
+	if (aep->at_flags & AT_TQAE) {					\
+		tid |= (aep->at_tag_val << 16);				\
+		tid |= (1 << 24);					\
+	}								\
+	tid |= (bus << 25);						\
+	tid |= (inst << 26)
 
-#define	CT_MAKE_TAGID(tid, ct)						\
-	tid = ((ct)->ct_fwhandle << 16);				\
-	if ((ct)->ct_flags & CT_TQAE)					\
-		(tid) |= ((ct)->ct_tag_val + 1)
+#define	CT_MAKE_TAGID(tid, bus, inst, ct)				\
+	tid = ct->ct_fwhandle;						\
+	if (ct->ct_flags & CT_TQAE) {					\
+		tid |= (ct->ct_tag_val << 16);				\
+		tid |= (1 << 24);					\
+	}								\
+	tid |= ((bus & 0x1) << 25);					\
+	tid |= (inst << 26)
 
-#define	AT_HAS_TAG(val)		((val) & 0xffff)
-#define	AT_GET_TAG(val)		AT_HAS_TAG(val) - 1
+#define	AT_HAS_TAG(val)		((val) & (1 << 24))
+#define	AT_GET_TAG(val)		(((val) >> 16) & 0xff)
 #define	AT_GET_INST(val)	(((val) >> 26) & 0x3f)
 #define	AT_GET_BUS(val)		(((val) >> 25) & 0x1)
-#define	AT_GET_HANDLE(val)	((val) >> 16)
+#define	AT_GET_HANDLE(val)	((val) & 0xffff)
 
 #define	IN_MAKE_TAGID(tid, bus, inst, inp)				\
 	tid = inp->in_seqid;						\
@@ -411,7 +374,7 @@ typedef struct {
 	u_int16_t	at_rxid; 	/* response ID */
 	u_int16_t	at_flags;
 	u_int16_t	at_status;	/* firmware status */
-	u_int8_t	at_reserved1;
+	u_int8_t	at_crn;		/* command reference number */
 	u_int8_t	at_taskcodes;
 	u_int8_t	at_taskflags;
 	u_int8_t	at_execodes;
@@ -523,8 +486,7 @@ typedef struct {
  */
 typedef struct {
 	isphdr_t	ct_header;
-	u_int16_t	ct_reserved;
-#define	ct_syshandle	ct_reserved	/* we use this */
+	u_int16_t	ct_syshandle;
 	u_int16_t	ct_fwhandle;	/* required by f/w */
 	u_int8_t	ct_lun;	/* lun */
 	u_int8_t	ct_iid;	/* initiator id */
@@ -539,14 +501,7 @@ typedef struct {
 	u_int32_t	ct_resid;	/* residual length */
 	u_int16_t	ct_timeout;
 	u_int16_t	ct_seg_count;
-	/*
-	 * This is so we can share tag name space with
-	 * CTIO{2,3,4} with the minimum of pain.
-	 */
-	union {
-		ispds_t		ct_a[ISP_RQDSEG];
-	} _u;
-#define	ct_dataseg	_u.ct_a
+	ispds_t		ct_dataseg[ISP_RQDSEG];
 } ct_entry_t;
 
 /*
@@ -598,7 +553,7 @@ typedef struct {
 #define	CT_DATA_UNDER	0x15	/* (FC only) Data Underrun */
 #define CT_BDR_MSG	0x17	/* Bus Device Reset msg received */
 #define CT_TERMINATED	0x19	/* due to Terminate Transfer mbox cmd */
-#define	CT_PORTNOTAVAIL	0x28	/* port not available */
+#define	CT_PORTUNAVAIL	0x28	/* port not available */
 #define	CT_LOGOUT	0x29	/* port logout */
 #define	CT_PORTCHANGED	0x2A	/* port changed */
 #define	CT_IDE		0x33	/* Initiator Detected Error */
@@ -627,8 +582,7 @@ typedef struct {
 #define	MAXRESPLEN	26
 typedef struct {
 	isphdr_t	ct_header;
-	u_int16_t	ct_reserved;
-	u_int16_t	ct_fwhandle;	/* just to match CTIO */
+	u_int32_t	ct_syshandle;
 	u_int8_t	ct_lun;		/* lun */
 	u_int8_t	ct_iid;		/* initiator id */
 	u_int16_t	ct_rxid;	/* response ID */
@@ -658,13 +612,10 @@ typedef struct {
 			u_int16_t ct_scsi_status;
 			u_int32_t ct_xfrlen;
 			union {
-				ispds_t ct_a[ISP_RQDSEG_T2];	/* CTIO2 */
-				ispds64_t ct_b[ISP_RQDSEG_T3];	/* CTIO3 */
-				ispdslist_t ct_c;		/* CTIO4 */
-			} _u;
-#define	ct_dataseg	_u.ct_a
-#define	ct_dataseg64	_u.ct_b
-#define	ct_dslist	_u.ct_c
+				ispds_t ct_dataseg[ISP_RQDSEG_T2];
+				ispds64_t ct_dataseg64[ISP_RQDSEG_T3];
+				ispdslist_t ct_dslist;
+			} u;
 		} m0;
 		struct {
 			u_int16_t _reserved;
@@ -681,14 +632,6 @@ typedef struct {
 			u_int32_t ct_datalen;
 			ispds_t ct_fcp_rsp_iudata;
 		} m2;
-		/*
-		 * CTIO2 returned from F/W...
-		 */
-		struct {
-			u_int32_t _reserved[4];
-			u_int16_t ct_scsi_status;
-			u_int8_t  ct_sense[QLTM_SENSELEN];
-		} fw;
 	} rsp;
 } ct2_entry_t;
 
@@ -740,10 +683,10 @@ typedef struct {
 #define	CT2_FLAG_MODE1	0x0001
 #define	CT2_FLAG_MODE2	0x0002
 #define		CT2_FLAG_MMASK	0x0003
-#define CT2_DATA_IN	CT_DATA_IN
-#define CT2_DATA_OUT	CT_DATA_OUT
-#define CT2_NO_DATA	CT_NO_DATA
-#define CT2_DATAMASK	CT_DATAMASK
+#define CT2_DATA_IN	0x0040
+#define CT2_DATA_OUT	0x0080
+#define CT2_NO_DATA	0x00C0
+#define 	CT2_DATAMASK	0x00C0
 #define	CT2_CCINCR	0x0100
 #define	CT2_FASTPOST	0x0200
 #define	CT2_CONFIRM	0x2000
@@ -948,7 +891,7 @@ typedef struct {
 #define	ISP_TDQE(isp, msg, idx, arg)	\
     if (isp->isp_dblev & ISP_LOGTDEBUG2) isp_print_qentry(isp, msg, idx, arg)
 
-#ifdef	ISP_TARGET_FUNCTIONS
+#ifndef	ISP_TOOLS
 /*
  * The functions below are for the publicly available
  * target mode functions that are internal to the QLogic driver.
@@ -957,7 +900,7 @@ typedef struct {
 /*
  * This function handles new response queue entry appropriate for target mode.
  */
-int isp_target_notify(struct ispsoftc *, void *, u_int16_t *);
+int isp_target_notify(ispsoftc_t *, void *, u_int32_t *);
 
 /*
  * This function externalizes the ability to acknowledge an Immediate Notify
@@ -970,13 +913,13 @@ void isp_notify_ack(ispsoftc_t *, void *);
  * (softc, cmd, bus, tgt, lun, cmd_cnt, inotify_cnt, opaque)
  */
 #define	DFLT_CMND_CNT	0xfe	/* unmonitored */
-#define	DFLT_INOT_CNT	16
-int isp_lun_cmd(struct ispsoftc *, int, int, int, int, int, int, u_int32_t);
+#define	DFLT_INOT_CNT	0xfe	/* unmonitored */
+int isp_lun_cmd(ispsoftc_t *, int, int, int, int, int, int, u_int32_t);
 
 /*
  * General request queue 'put' routine for target mode entries.
  */
-int isp_target_put_entry(struct ispsoftc *isp, void *);
+int isp_target_put_entry(ispsoftc_t *isp, void *);
 
 /*
  * General routine to put back an ATIO entry-
@@ -984,13 +927,13 @@ int isp_target_put_entry(struct ispsoftc *isp, void *);
  * The argument is a pointer to a source ATIO
  * or ATIO2.
  */
-int isp_target_put_atio(struct ispsoftc *, void *);
+int isp_target_put_atio(ispsoftc_t *, void *);
 
 /*
  * General routine to send a final CTIO for a command- used mostly for
  * local responses.
  */
-int isp_endcmd(struct ispsoftc *, void *, u_int32_t, u_int16_t);
+int isp_endcmd(ispsoftc_t *, void *, u_int32_t, u_int32_t);
 #define	ECMD_SVALID	0x100
 
 /*
@@ -998,7 +941,6 @@ int isp_endcmd(struct ispsoftc *, void *, u_int32_t, u_int16_t);
  *
  * Return nonzero if the interrupt that generated this event has been dismissed.
  */
-
-int isp_target_async(struct ispsoftc *, int, int);
+int isp_target_async(ispsoftc_t *, int, int);
 #endif
 #endif	/* _ISP_TARGET_H */
diff --git a/sys/dev/ic/isp_tpublic.h b/sys/dev/ic/isp_tpublic.h
index 5c27602ba67..c6ff0aa6798 100644
--- a/sys/dev/ic/isp_tpublic.h
+++ b/sys/dev/ic/isp_tpublic.h
@@ -1,4 +1,4 @@
-/* $OpenBSD: isp_tpublic.h,v 1.11 2008/11/01 18:54:27 krw Exp $ */
+/* $OpenBSD: isp_tpublic.h,v 1.12 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/isp_tpublic.h,v 1.19 2007/05/05 20:17:23 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -39,10 +39,11 @@
  */
 typedef enum {
  	QOUT_HBA_REG=0,	/* the argument is a pointer to a hba_register_t */
-	QOUT_TMD_START,	/* the argument is a pointer to a tmd_cmd_t */
-	QOUT_TMD_DONE,	/* the argument is a pointer to a tmd_cmd_t */
-	QOUT_TEVENT,	/* the argument is a pointer to a tmd_event_t */
-	QOUT_TMSG,	/* the argument is a pointer to a tmd_msg_t */
+ 	QOUT_ENABLE,	/* the argument is a pointer to a enadis_t */
+ 	QOUT_DISABLE,	/* the argument is a pointer to a enadis_t */
+ 	QOUT_TMD_START,	/* the argument is a pointer to a tmd_cmd_t */
+ 	QOUT_TMD_DONE,	/* the argument is a pointer to a tmd_cmd_t */
+ 	QOUT_NOTIFY,	/* the argument is a pointer to a tmd_notify_t */
  	QOUT_HBA_UNREG	/* the argument is a pointer to a hba_register_t */
 } tact_e;
 
@@ -51,28 +52,18 @@ typedef enum {
  * MD driver to figure out what to do with.
  */
 typedef enum {
-	QIN_HBA_REG=6,	/* the argument is a pointer to a hba_register_t */
-	QIN_ENABLE,	/* the argument is a pointer to a tmd_cmd_t */
-	QIN_DISABLE,	/* the argument is a pointer to a tmd_cmd_t */
+	QIN_HBA_REG=99,	/* the argument is a pointer to a hba_register_t */
+	QIN_GETINFO,	/* the argument is a pointer to a info_t */
+	QIN_SETINFO,	/* the argument is a pointer to a info_t */
+	QIN_GETDLIST,	/* the argument is a pointer to a fc_dlist_t */
+	QIN_ENABLE,	/* the argument is a pointer to a enadis_t */
+	QIN_DISABLE,	/* the argument is a pointer to a enadis_t */
 	QIN_TMD_CONT,	/* the argument is a pointer to a tmd_cmd_t */
 	QIN_TMD_FIN,	/* the argument is a pointer to a tmd_cmd_t */
+	QIN_NOTIFY_ACK,	/* the argument is a pointer to a tmd_notify_t */
 	QIN_HBA_UNREG	/* the argument is a pointer to a hba_register_t */
 } qact_e;
 
-#ifndef	IN_MSGLEN
-#define	IN_MSGLEN	8
-#endif
-typedef struct {
-	void *		nt_hba;			/* HBA tag */
-	u_int64_t	nt_iid;			/* initiator id */
-	u_int64_t	nt_tgt;			/* target id */
-	u_int64_t	nt_lun;			/* logical unit */
-	u_int8_t	nt_bus;			/* bus */
-	u_int8_t	nt_tagtype;		/* tag type */
-	u_int16_t	nt_tagval;		/* tag value */
-	u_int8_t	nt_msg[IN_MSGLEN];	/* message content */
-} tmd_msg_t;
-
 /*
  * This structure is used to register to other software modules the
  * binding of an HBA identifier, driver name and instance and the
@@ -85,20 +76,18 @@ typedef struct {
  */
 #define    QR_VERSION    16
 typedef struct {
-	void *	r_identity;
-	char	r_name[8];
-	int	r_inst;
-	int	r_lunwidth;
-	int	r_buswidth;
-	void   (*r_action)(int, void *);
+    /* NB: tags from here to r_version must never change */
+    void *                  r_identity;
+    void                    (*r_action)(qact_e, void *);
+    char                    r_name[8];
+    int                     r_inst;
+    int                     r_version;
+    u_int32_t               r_locator;
+    u_int32_t               r_nchannels;
+    enum { R_FC, R_SPI }    r_type;
+    void *                  r_private;
 } hba_register_t;
 
-typedef struct {
-	void *		ev_hba;			/* HBA tag */
-	u_int16_t	ev_bus;			/* bus */
-	u_int16_t	ev_event;		/* type of async event */
-} tmd_event_t;
-
 /*
  * An information structure that is used to get or set per-channel transport layer parameters.
  */
@@ -295,26 +284,6 @@ typedef struct {
  * 
  */
 
-#ifndef	_LP64
-#if	defined(__alpha__) || defined(__sparcv9cpu) || defined(__sparc_v9__) ||\
-    defined(__ia64__)
-#define	_LP64
-#endif
-#endif
-
-#ifndef	_TMD_PAD_LEN
-#ifdef	_LP64
-#define	_TMD_PAD_LEN	12
-#else
-#define	_TMD_PAD_LEN	24
-#endif
-#endif
-#ifndef	ATIO_CDBLEN
-#define	ATIO_CDBLEN	26
-#endif
-#ifndef	QLTM_SENSELEN
-#define	QLTM_SENSELEN	18
-#endif
 #ifndef    TMD_CDBLEN
 #define    TMD_CDBLEN       16
 #endif
@@ -331,20 +300,26 @@ typedef struct tmd_cmd {
 	void *			cd_data;	/* 'pointer' to data */
 	u_int64_t		cd_iid;		/* initiator ID */
 	u_int64_t		cd_tgt;		/* target id */
-	u_int64_t		cd_lun;		/* logical unit */
-	u_int8_t		cd_bus;		/* bus */
-	u_int8_t		cd_tagtype;	/* tag type */
-	u_int32_t		cd_tagval;	/* tag value */
-	u_int8_t		cd_cdb[ATIO_CDBLEN];	/* Command */
-	u_int8_t		cd_lflags;	/* flags lower level sets */
-	u_int8_t		cd_hflags;	/* flags higher level sets */
-	u_int32_t		cd_totlen;	/* total data requirement */
+	u_int8_t		cd_lun[8];	/* logical unit */
+	u_int64_t		cd_tagval;	/* tag value */
+	u_int32_t		cd_channel;	/* channel index */
+	u_int32_t		cd_lflags;	/* flags lower level sets */
+	u_int32_t		cd_hflags;	/* flags higher level sets */
+	u_int32_t		cd_totlen;	/* total data load */
 	u_int32_t		cd_resid;	/* total data residual */
 	u_int32_t		cd_xfrlen;	/* current data load */
 	int32_t			cd_error;	/* current error */
-	u_int8_t		cd_sense[QLTM_SENSELEN];
-	u_int16_t		cd_scsi_status;	/* closing SCSI status */
-	u_int8_t		cd_reserved[_TMD_PAD_LEN];
+	u_int8_t		cd_tagtype;	/* tag type */
+	u_int8_t		cd_scsi_status;
+	u_int8_t		cd_sense[TMD_SENSELEN];
+	u_int8_t		cd_cdb[TMD_CDBLEN];
+	union {
+		void *		ptrs[QCDS / sizeof (void *)];
+		u_int64_t	llongs[QCDS / sizeof (u_int64_t)];
+		u_int32_t	longs[QCDS / sizeof (u_int32_t)];
+		u_int16_t	shorts[QCDS / sizeof (u_int16_t)];
+		u_int8_t	bytes[QCDS];
+	} cd_lreserved[4], cd_hreserved[4];
 } tmd_cmd_t;
 
 /* defined tags */
@@ -389,22 +364,21 @@ typedef struct tmd_cmd {
  * flags CDFH_DATA_IN and CDFH_DATA_OUT define which direction.
  */
 #define	CDFL_SNSVALID	0x01	/* sense data (from f/w) good */
-#define	CDFL_NODISC	0x02	/* disconnects disabled */
-#define	CDFL_SENTSENSE	0x04	/* last action sent sense data */
-#define	CDFL_SENTSTATUS	0x08	/* last action sent status */
-#define	CDFL_BIDIR      0x0C	/* bidirectional data */
-#define	CDFL_ERROR	0x10	/* last action ended in error */
-#define	CDFL_BUSY	0x40	/* this command is not on a free list */
-#define	CDFL_PRIVATE_0	0x80	/* private layer flags */
-	
+#define	CDFL_SENTSTATUS	0x02	/* last action sent status */
+#define	CDFL_DATA_IN	0x04	/* target (us) -> initiator (them) */
+#define CDFL_DATA_OUT	0x08	/* initiator (them) -> target (us) */
+#define    CDFL_BIDIR           0x0C            /* bidirectional data */
+#define    CDFL_ERROR           0x10            /* last action ended in error */
+#define    CDFL_NODISC          0x20            /* disconnects disabled */
+#define    CDFL_SENTSENSE       0x40            /* last action sent sense data */
+#define    CDFL_BUSY            0x80            /* this command is not on a free list */
+#define    CDFL_PRIVATE         0xFF000000      /* private layer flags */
 
-#define    CDFH_NODATA          0x00		/* no data transfer expected */
 #define    CDFH_SNSVALID        0x01            /* sense data (from outer layer) good */
 #define    CDFH_STSVALID        0x02            /* status valid */
 #define    CDFH_DATA_IN         0x04            /* target (us) -> initiator (them) */
 #define    CDFH_DATA_OUT        0x08            /* initiator (them) -> target (us) */
 #define    CDFH_DATA_MASK       0x0C            /* mask to cover data direction */
-#define    CDFH_PRIVATE_0       0x80            /* private layer flags */
 #define    CDFH_PRIVATE         0xFF000000      /* private layer flags */
 
 
diff --git a/sys/dev/ic/ispmbox.h b/sys/dev/ic/ispmbox.h
index b2ec96b60b6..b805c082923 100644
--- a/sys/dev/ic/ispmbox.h
+++ b/sys/dev/ic/ispmbox.h
@@ -1,4 +1,4 @@
-/*     $OpenBSD: ispmbox.h,v 1.22 2008/11/02 03:17:22 krw Exp $ */
+/*     $OpenBSD: ispmbox.h,v 1.23 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/ispmbox.h,v 1.59 2007/03/10 02:39:54 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -165,10 +165,6 @@
 
 #define	MBOX_BUSY			0x04
 
-typedef struct {
-	u_int16_t param[8];
-} mbreg_t;
-
 /*
  * Mailbox Command Complete Status Codes
  */
@@ -254,18 +250,6 @@ typedef struct {
  */
 #define	QENTRY_LEN			64
 
-#define	WRITE_REQUEST_QUEUE_IN_POINTER(isp, value)	\
-	ISP_WRITE(isp, isp->isp_rqstinrp, value)
-
-#define	READ_REQUEST_QUEUE_OUT_POINTER(isp)		\
-	ISP_READ(isp, isp->isp_rqstoutrp)
-
-#define	READ_RESPONSE_QUEUE_IN_POINTER(isp)		\
-	ISP_READ(isp, isp->isp_respinrp)
-
-#define	WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, value)	\
-	ISP_WRITE(isp, isp->isp_respoutrp, value)
-
 /*
  * Command Structure Definitions
  */
@@ -337,7 +321,7 @@ typedef struct {
 #define	RQSTYPE_T4RQS		0x15
 #define	RQSTYPE_ATIO2		0x16	/* Target Mode */
 #define	RQSTYPE_CTIO2		0x17	/* Target Mode */
-#define	RQSTYPE_CSET0		0x18
+#define	RQSTYPE_T7RQS		0x18
 #define	RQSTYPE_T3RQS		0x19
 #define	RQSTYPE_IP_XMIT_64	0x1b
 #define	RQSTYPE_CTIO4		0x1e	/* Target Mode */
@@ -362,7 +346,6 @@ typedef struct {
 	u_int8_t	req_lun_trn;
 	u_int8_t	req_target;
 	u_int16_t	req_cdblen;
-#define	req_modifier	req_cdblen	/* marker packet */
 	u_int16_t	req_flags;
 	u_int16_t	req_reserved;
 	u_int16_t	req_time;
@@ -826,7 +809,7 @@ typedef struct {
  *
  * Version One (prime) format.
  */
-typedef struct isp_icb {
+typedef struct {
 	u_int8_t	icb_version;
 	u_int8_t	icb_reserved0;
 	u_int16_t	icb_fwoptions;
@@ -898,16 +881,15 @@ typedef struct isp_icb {
 #define	ICBXOPT_RIO_32BIT	2
 #define	ICBXOPT_RIO_16BIT_IOCB	3
 #define	ICBXOPT_RIO_32BIT_IOCB	4
-#define	ICBXOPT_ZIO		(1 << 5)
+#define	ICBXOPT_ZIO		5	
 #define	ICBXOPT_TIMER_MASK	0x7
 
+#define	ICBZOPT_RATE_MASK	0xC000
+#define	ICBZOPT_RATE_ONEGB	0x0000
+#define	ICBZOPT_RATE_AUTO	0x8000
+#define	ICBZOPT_RATE_TWOGB	0x4000
 #define	ICBZOPT_50_OHM		0x2000
 #define	ICBZOPT_ENA_OOF		0x0040	/* out of order frame handling */
-/* These 3 only apply to the 2300 */
-#define	ICBZOPT_RATE_ONEGB	(MBGSD_ONEGB << 14)
-#define	ICBZOPT_RATE_TWOGB	(MBGSD_TWOGB << 14)
-#define	ICBZOPT_RATE_AUTO	(MBGSD_AUTO << 14)
-
 #define	ICBZOPT_RSPSZ_MASK	0x0030
 #define	ICBZOPT_RSPSZ_24	0x0000
 #define	ICBZOPT_RSPSZ_12	0x0010
@@ -1030,22 +1012,6 @@ typedef struct {
 	array[ICB_NNM6] = (u_int8_t) ((wwn >> 48) & 0xff), \
 	array[ICB_NNM7] = (u_int8_t) ((wwn >> 56) & 0xff)
 
-/*
- * FC-AL Position Map
- *
- * This is an at most 128 byte map that returns either
- * the LILP or Firmware generated list of ports.
- *
- * We deviate a bit from the returned QLogic format to
- * use an extra bit to say whether this was a LILP or
- * f/w generated map.
- */
-typedef struct {
-	u_int8_t	fwmap	: 1,
-			count	: 7;
-	u_int8_t	map[127];
-} fcpos_map_t;
-
 #define	MAKE_WWN_FROM_NODE_NAME(wwn, array)	\
 	wwn =	((u_int64_t) array[ICB_NNM0]) | \
 		((u_int64_t) array[ICB_NNM1] <<  8) | \
@@ -1099,7 +1065,7 @@ typedef struct {
 	u_int16_t	pdb_loopid;
 	u_int16_t	pdb_il_ptr;
 	u_int16_t	pdb_sl_ptr;
-} isp_pdb_t;
+} isp_pdb_21xx_t;
 
 #define	PDB_OPTIONS_XMITTING	(1<<11)
 #define	PDB_OPTIONS_LNKXMIT	(1<<10)
@@ -1158,13 +1124,14 @@ typedef struct {
 /*
  * Common elements from the above two structures that are actually useful to us.
  */
-
-#define	FS_ACC	0x8002
-#define	FS_RJT	0x8001
-
-#define	FC4_IP		5 /* ISO/EEC 8802-2 LLC/SNAP "Out of Order Delivery" */
-#define	FC4_SCSI	8 /* SCSI-3 via Fivre Channel Protocol (FCP) */
-#define	FC4_FC_SVC	0x20	/* Fibre Channel Services */
+typedef struct {
+	u_int16_t	handle;
+	u_int16_t	reserved;
+	u_int32_t	s3_role	: 8,
+			portid	: 24;
+	u_int8_t	portname[8];
+	u_int8_t	nodename[8];
+} isp_pdb_t;
 
 /*
  * Genericized Port Login/Logout software structure
diff --git a/sys/dev/ic/ispreg.h b/sys/dev/ic/ispreg.h
index 2989672e587..5429c47d9dd 100644
--- a/sys/dev/ic/ispreg.h
+++ b/sys/dev/ic/ispreg.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ispreg.h,v 1.15 2008/10/25 22:53:30 krw Exp $ */
+/*	$OpenBSD: ispreg.h,v 1.16 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/ispreg.h,v 1.29 2007/03/10 02:39:54 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -203,7 +203,6 @@
 #define		BIU2100_FB_REGS		(1 << 4)	/* FrameBuffer Regs */
 #define		BIU2100_FPM0_REGS	(2 << 4)	/* FPM 0 Regs */
 #define		BIU2100_FPM1_REGS	(3 << 4)	/* FPM 1 Regs */
-#define	BIU2100_PCI64			0x04	/*  R: 64 Bit PCI slot */
 #define	BIU2100_NVRAM_OFFSET		(1 << 14)
 #define	BIU2100_FLASH_UPPER_64K		0x04	/* RW: Upper 64K Bank Select */
 #define	BIU2100_FLASH_ENABLE		0x02	/* RW: Enable Flash RAM */
@@ -230,16 +229,7 @@
 #define	BIU2100_ICR_ENABLE_TXDMA_INT	0x0001
 #define	BIU2100_ICR_DISABLE_ALL_INTS	0x0000
 
-#define	ENABLE_INTS(isp)	(IS_SCSI(isp))?  \
- ISP_WRITE(isp, BIU_ICR, BIU_ICR_ENABLE_RISC_INT | BIU_ICR_ENABLE_ALL_INTS) : \
- ISP_WRITE(isp, BIU_ICR, BIU2100_ICR_ENA_RISC_INT | BIU2100_ICR_ENABLE_ALL_INTS)
-
-#define	INTS_ENABLED(isp)	((IS_SCSI(isp))?  \
- (ISP_READ(isp, BIU_ICR) & (BIU_ICR_ENABLE_RISC_INT|BIU_ICR_ENABLE_ALL_INTS)) :\
- (ISP_READ(isp, BIU_ICR) & \
-	(BIU2100_ICR_ENA_RISC_INT|BIU2100_ICR_ENABLE_ALL_INTS)))
-
-#define	DISABLE_INTS(isp)	ISP_WRITE(isp, BIU_ICR, 0)
+#define	BIU2100_IMASK	(BIU2100_ICR_ENA_RISC_INT|BIU2100_ICR_ENABLE_ALL_INTS)
 
 /* BUS STATUS REGISTER */
 #define	BIU_ISR_DMA_INT			0x0020	/* DMA interrupt pending */
@@ -256,11 +246,14 @@
 #define	BIU2100_ISR_RXDMA_INT_PENDING	0x0002	/* Global interrupt pending */
 #define	BIU2100_ISR_TXDMA_INT_PENDING	0x0001	/* Global interrupt pending */
 
-#define	INT_PENDING(isp, isr)	(IS_FC(isp)? \
-	((isr & BIU2100_ISR_RISC_INT) != 0) : ((isr & BIU_ISR_RISC_INT) != 0))
+#define	INT_PENDING(isp, isr)						\
+ IS_FC(isp)?								\
+  (IS_24XX(isp)? (isr & BIU2400_ISR_RISC_INT) : (isr & BIU2100_ISR_RISC_INT)) :\
+  (isr & BIU_ISR_RISC_INT)
 
 #define	INT_PENDING_MASK(isp)	\
-	(IS_FC(isp)? BIU2100_ISR_RISC_INT: BIU_ISR_RISC_INT)
+ (IS_FC(isp)? (IS_24XX(isp)? BIU2400_ISR_RISC_INT : BIU2100_ISR_RISC_INT) : \
+ (BIU_ISR_RISC_INT))
 
 /* BUS SEMAPHORE REGISTER */
 #define	BIU_SEMA_STATUS		0x0002	/* Semaphore Status Bit */
@@ -464,12 +457,23 @@
 #define	MBOX_OFF(n)	(MBOX_BLOCK + ((n) << 1))
 #define	NMBOX(isp)	\
 	(((((isp)->isp_type & ISP_HA_SCSI) >= ISP_HA_SCSI_1040A) || \
-	 ((isp)->isp_type & ISP_HA_FC))? 8 : 6)
+	 ((isp)->isp_type & ISP_HA_FC))? 12 : 6)
 #define	NMBOX_BMASK(isp)	\
 	(((((isp)->isp_type & ISP_HA_SCSI) >= ISP_HA_SCSI_1040A) || \
-	 ((isp)->isp_type & ISP_HA_FC))? 0xff : 0x3f)
-
-#define	MAX_MAILBOX	8
+	 ((isp)->isp_type & ISP_HA_FC))? 0xfff : 0x3f)
+
+#define	MAX_MAILBOX(isp)	((IS_FC(isp))? 12 : 8)
+#define	MAILBOX_STORAGE		12
+/* if timeout == 0, then default timeout is picked */
+#define	MBCMD_DEFAULT_TIMEOUT	100000	/* 100 ms */
+typedef struct {
+	u_int16_t param[MAILBOX_STORAGE];
+	u_int16_t ibits;
+	u_int16_t obits;
+	u_int32_t	: 28,
+		logval	: 4;
+	u_int32_t timeout;
+} mbreg_t;
 
 /*
  * Fibre Protocol Module and Frame Buffer Register Offsets/Definitions (2X00).
@@ -1046,7 +1050,7 @@
 #define	ISP2100_NVRAM_SIZE	256
 /* ISP_NVRAM_VERSION is in same overall place */
 #define	ISP2100_NVRAM_RISCVER(c)		(c)[6]
-#define	ISP2100_NVRAM_OPTIONS(c)		(c)[8]
+#define	ISP2100_NVRAM_OPTIONS(c)		((c)[8] | ((c)[9] << 8))
 #define	ISP2100_NVRAM_MAXFRAMELENGTH(c)		(((c)[10]) | ((c)[11] << 8))
 #define	ISP2100_NVRAM_MAXIOCBALLOCATION(c)	(((c)[12]) | ((c)[13] << 8))
 #define	ISP2100_NVRAM_EXECUTION_THROTTLE(c)	(((c)[14]) | ((c)[15] << 8))
@@ -1063,10 +1067,10 @@
 		(((u_int64_t)(c)[24]) <<  8) | \
 		(((u_int64_t)(c)[25]) <<  0))
 
-#define	ISP2100_NVRAM_HARDLOOPID(c)		(c)[26]
+#define	ISP2100_NVRAM_HARDLOOPID(c)		((c)[26] | ((c)[27] << 8))
 #define	ISP2100_NVRAM_TOV(c)			((c)[29])
 
-#define	ISP2200_NVRAM_NODE_NAME(c)	(\
+#define	ISP2100_NVRAM_NODE_NAME(c)	(\
 		(((u_int64_t)(c)[30]) << 56) | \
 		(((u_int64_t)(c)[31]) << 48) | \
 		(((u_int64_t)(c)[32]) << 40) | \
@@ -1076,7 +1080,6 @@
 		(((u_int64_t)(c)[36]) <<  8) | \
 		(((u_int64_t)(c)[37]) <<  0))
 
-#define	ISP2100_NVRAM_HBA_OPTIONS(c)		(c)[70]
 #define	ISP2100_XFW_OPTIONS(c)			((c)[38] | ((c)[39] << 8))
 
 #define	ISP2100_RACC_TIMER(c)			(c)[40]
@@ -1086,6 +1089,7 @@
 
 #define	ISP2100_SERIAL_LINK(c)			((c)[68] | ((c)[69] << 8))
 
+#define	ISP2100_NVRAM_HBA_OPTIONS(c)		((c)[70] | ((c)[71] << 8))
 #define	ISP2100_NVRAM_HBA_DISABLE(c)		ISPBSMX(c, 70, 0, 0x01)
 #define	ISP2100_NVRAM_BIOS_DISABLE(c)		ISPBSMX(c, 70, 1, 0x01)
 #define	ISP2100_NVRAM_LUN_DISABLE(c)		ISPBSMX(c, 70, 2, 0x01)
@@ -1106,7 +1110,7 @@
 #define	ISP2100_NVRAM_BOOT_LUN(c)		(c)[80]
 #define	ISP2100_RESET_DELAY(c)			(c)[81]
 
-#define	ISP2200_HBA_FEATURES(c)			(c)[232] | ((c)[233] << 8)
+#define	ISP2100_HBA_FEATURES(c)			((c)[232] | ((c)[233] << 8))
 
 /*
  * Qlogic 2400 NVRAM is an array of 512 bytes with a 32 bit checksum.
diff --git a/sys/dev/ic/ispvar.h b/sys/dev/ic/ispvar.h
index fe90c295954..d0da6b35931 100644
--- a/sys/dev/ic/ispvar.h
+++ b/sys/dev/ic/ispvar.h
@@ -1,4 +1,4 @@
-/*     $OpenBSD: ispvar.h,v 1.26 2008/11/02 03:17:22 krw Exp $ */
+/*     $OpenBSD: ispvar.h,v 1.27 2009/06/24 11:00:53 krw Exp $ */
 /* $FreeBSD: src/sys/dev/isp/ispvar.h,v 1.85 2007/07/02 20:08:20 mjacob Exp $ */
 /*-
  *  Copyright (c) 1997-2007 by Matthew Jacob
@@ -36,49 +36,40 @@
 #if defined(__NetBSD__) || defined(__OpenBSD__)
 #include <dev/ic/isp_stds.h>
 #include <dev/ic/ispmbox.h>
-#ifdef	ISP_TARGET_MODE
-#include <dev/ic/isp_target.h>
-#include <dev/ic/isp_tpublic.h>
-#endif
 #endif
 #ifdef	__FreeBSD__
 #include <dev/isp/isp_stds.h>
 #include <dev/isp/ispmbox.h>
-#ifdef	ISP_TARGET_MODE
-#include <dev/isp/isp_target.h>
-#include <dev/isp/isp_tpublic.h>
-#endif
 #endif
 #ifdef	__linux__
 #include "isp_stds.h"
 #include "ispmbox.h"
-#ifdef	ISP_TARGET_MODE
-#include "isp_target.h"
-#include "isp_tpublic.h"
 #endif
+#ifdef	__svr4__
+#include "isp_stds.h"
+#include "ispmbox.h"
 #endif
 
-#define	ISP_CORE_VERSION_MAJOR	2
-#define	ISP_CORE_VERSION_MINOR	7
+#define	ISP_CORE_VERSION_MAJOR	3
+#define	ISP_CORE_VERSION_MINOR	0
 
 /*
  * Vector for bus specific code to provide specific services.
  */
-struct ispsoftc;
+typedef struct ispsoftc ispsoftc_t;
 struct ispmdvec {
 	int		(*dv_rd_isr)
-	    (struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
-	u_int16_t	(*dv_rd_reg) (struct ispsoftc *, int);
-	void		(*dv_wr_reg) (struct ispsoftc *, int, u_int16_t);
+	    (struct ispsoftc *, u_int32_t *, u_int16_t *, u_int16_t *);
+	u_int32_t	(*dv_rd_reg) (struct ispsoftc *, int);
+	void		(*dv_wr_reg) (struct ispsoftc *, int, u_int32_t);
 	int		(*dv_mbxdma) (struct ispsoftc *);
-	int		(*dv_dmaset) (struct ispsoftc *,
-	    XS_T *, ispreq_t *, u_int16_t *, u_int16_t);
-	void		(*dv_dmaclr)
-	    (struct ispsoftc *, XS_T *, u_int16_t);
+	int		(*dv_dmaset)
+	    (struct ispsoftc *, XS_T *, ispreq_t *, u_int32_t *, u_int32_t);
+	void		(*dv_dmaclr) (struct ispsoftc *, XS_T *, u_int32_t);
 	void		(*dv_reset0) (struct ispsoftc *);
 	void		(*dv_reset1) (struct ispsoftc *);
 	void		(*dv_dregs) (struct ispsoftc *, const char *);
-	u_int16_t	*dv_ispfw;	/* ptr to f/w */
+	const void *	dv_ispfw;	/* ptr to f/w */
 	u_int16_t	dv_conf1;
 	u_int16_t	dv_clock;	/* clock frequency */
 };
@@ -87,20 +78,11 @@ struct ispmdvec {
  * Overall parameters
  */
 #define	MAX_TARGETS		16
-#define	MAX_FC_TARG		256
+#define	MAX_FC_TARG		512
 #define	ISP_MAX_TARGETS(isp)	(IS_FC(isp)? MAX_FC_TARG : MAX_TARGETS)
 #define	ISP_MAX_LUNS(isp)	(isp)->isp_maxluns
 
 /*
- * 'Types'
- */
-#ifdef	ISP_DAC_SUPPORTED
-typedef	u_int64_t	isp_dma_addr_t;
-#else
-typedef	u_int32_t	isp_dma_addr_t;
-#endif
-
-/*
  * Macros to access ISP registers through bus specific layers-
  * mostly wrappers to vector through the mdvec structure.
  */
@@ -163,7 +145,7 @@ typedef	u_int32_t	isp_dma_addr_t;
 #define	RESULT_QUEUE_LEN(x)		\
 	(((MAXISPREQUEST(x) >> 2) < 64)? 64 : MAXISPREQUEST(x) >> 2)
 #endif
-#define	ISP_QUEUE_ENTRY(q, idx)		((q) + ((idx) * QENTRY_LEN))
+#define	ISP_QUEUE_ENTRY(q, idx)		(((u_int8_t *)q) + ((idx) * QENTRY_LEN))
 #define	ISP_QUEUE_SIZE(n)		((n) * QENTRY_LEN)
 #define	ISP_NXT_QENTRY(idx, qlen)	(((idx) + 1) & ((qlen)-1))
 #define	ISP_QFREE(in, out, qlen)	\
@@ -174,20 +156,22 @@ typedef	u_int32_t	isp_dma_addr_t;
 
 #define	ISP_ADD_REQUEST(isp, nxti)					\
 	MEMORYBARRIER(isp, SYNC_REQUEST, isp->isp_reqidx, QENTRY_LEN);	\
-	WRITE_REQUEST_QUEUE_IN_POINTER(isp, nxti);			\
+	ISP_WRITE(isp, isp->isp_rqstinrp, nxti);			\
 	isp->isp_reqidx = nxti
 
 /*
  * SCSI Specific Host Adapter Parameters- per bus, per target
  */
-
 typedef struct {
-	u_int		isp_gotdparms		: 1,
+	u_int32_t 				: 10,
+			isp_bad_nvram		: 1,
+			isp_gotdparms		: 1,
 			isp_req_ack_active_neg	: 1,
 			isp_data_line_active_neg: 1,
 			isp_cmd_dma_burst_enable: 1,
 			isp_data_dma_burst_enabl: 1,
 			isp_fifo_threshold	: 3,
+			isp_ptisp		: 1,
 			isp_ultramode		: 1,
 			isp_diffmode		: 1,
 			isp_lvdmode		: 1,
@@ -249,14 +233,10 @@ typedef struct {
 /*
  * Fibre Channel Specifics
  */
-#define	FL_PORT_ID		0x7e	/* FL_Port Special ID */
-#define	FC_PORT_ID		0x7f	/* Fabric Controller Special ID */
-#define	FC_SNS_ID		0x80	/* SNS Server Special ID */
-
-/* #define	ISP_USE_GA_NXT	1 */	/* Use GA_NXT with switches */
-#ifndef	GA_NXT_MAX
-#define	GA_NXT_MAX	256
-#endif
+/* These are for non-2K Login Firmware cards */
+#define	FL_ID			0x7e	/* FL_Port Special ID */
+#define	SNS_ID			0x80	/* SNS Server Special ID */
+#define	NPH_MAX			0xfe
 
 /* These are for 2K Login Firmware cards */
 #define	NPH_RESERVED		0x7F0	/* begin of reserved N-port handles */
@@ -333,64 +313,102 @@ typedef struct {
  *    value.
  */
 typedef struct {
-	u_int32_t		isp_fwoptions	: 16,
-				isp_gbspeed	: 2,
-				isp_iid_set	: 1,
-				loop_seen_once	: 1,
-				isp_loopstate	: 4,	/* Current Loop State */
-				isp_fwstate	: 3,	/* ISP F/W state */
+	/*
+	 * This is the handle that the firmware needs in order for us to
+	 * send commands to the device. For pre-24XX cards, this would be
+	 * the 'loopid'.
+	 */
+	u_int16_t	handle;
+	/*
+	 * The ini_map_idx, if nonzero, is the system virtual target ID (+1)
+	 * as a cross-reference with the isp_ini_map.
+	 *
+	 * A device is 'autologin' if the firmware automatically logs into
+	 * it (re-logins as needed). Basically, local private loop devices.
+	 *
+	 * The state is the current state of thsi entry.
+	 *
+	 * Role is Initiator, Target, Both
+	 *
+	 * Portid is obvious, as or node && port WWNs. The new_role and
+	 * new_portid is for when we are pending a change.
+	 */
+	u_int16_t	ini_map_idx	: 12,
+			autologin	: 1,	/* F/W does PLOGI/PLOGO */
+			state		: 3;
+	u_int32_t	reserved	: 6,
+			roles		: 2,
+			portid		: 24;
+	u_int32_t	new_reserved	: 6,
+			new_roles	: 2,
+			new_portid	: 24;
+	u_int64_t	node_wwn;
+	u_int64_t	port_wwn;
+} fcportdb_t;
+
+#define	FC_PORTDB_STATE_NIL		0
+#define	FC_PORTDB_STATE_PROBATIONAL	1
+#define	FC_PORTDB_STATE_DEAD		2
+#define	FC_PORTDB_STATE_CHANGED		3
+#define	FC_PORTDB_STATE_NEW		4
+#define	FC_PORTDB_STATE_PENDING_VALID	5
+#define	FC_PORTDB_STATE_ZOMBIE		6
+#define	FC_PORTDB_STATE_VALID		7
+
+/*
+ * FC card specific information
+ */
+typedef struct {
+	u_int32_t				: 10,
+				isp_tmode	: 1,
+				isp_2klogin	: 1,
+				isp_sccfw	: 1,
+				isp_gbspeed	: 3,
+						: 1,
+						: 1,
 				isp_gotdparms	: 1,
+				isp_bad_nvram	: 1,
+				isp_loopstate	: 4,	/* Current Loop State */
+				isp_fwstate	: 4,	/* ISP F/W state */
 				isp_topo	: 3,
-				isp_onfabric	: 1;
-	u_int8_t		isp_iid;	/* 'initiator' id */
-	u_int8_t		isp_loopid;	/* hard loop id */
-	u_int8_t		isp_alpa;	/* ALPA */
-	u_int32_t		isp_portid;
-	volatile u_int16_t	isp_lipseq;	/* LIP sequence # */
+				loop_seen_once	: 1;
+	u_int32_t				: 8,
+				isp_portid	: 24;	/* S_ID */
+	u_int16_t		isp_fwoptions;
+	u_int16_t		isp_xfwoptions;
+	u_int16_t		isp_zfwoptions;
+	u_int16_t		isp_loopid;	/* hard loop id */
 	u_int16_t		isp_fwattr;	/* firmware attributes */
-	u_int8_t		isp_execthrottle;
+	u_int16_t		isp_execthrottle;
 	u_int8_t		isp_retry_delay;
 	u_int8_t		isp_retry_count;
 	u_int8_t		isp_reserved;
 	u_int16_t		isp_maxalloc;
 	u_int16_t		isp_maxfrmlen;
-	u_int64_t		isp_nodewwn;
-	u_int64_t		isp_portwwn;
+	u_int64_t		isp_wwnn_nvram;
+	u_int64_t		isp_wwpn_nvram;
+
 	/*
-	 * Port Data Base. This is indexed by 'target', which is invariate.
-	 * However, elements within can move around due to loop changes,
-	 * so the actual loop ID passed to the F/W is in this structure.
-	 * The first time the loop is seen up, loopid will match the index
-	 * (except for fabric nodes which are above mapped above FC_SNS_ID
-	 * and are completely virtual), but subsequent LIPs can cause things
-	 * to move around.
+	 * Our Port Data Base
 	 */
-	struct lportdb {
-		u_int32_t
-					port_type	: 8,
-					loopid		: 8,
-					fc4_type	: 4,
-					last_fabric_dev	: 1,
-							: 2,
-					relogin		: 1,
-					force_logout	: 1,
-					was_fabric_dev	: 1,
-					fabric_dev	: 1,
-					loggedin	: 1,
-					roles		: 2,
-					valid		: 1;
-		u_int32_t		portid;
-		u_int64_t		node_wwn;
-		u_int64_t		port_wwn;
-	} portdb[MAX_FC_TARG], tport[FC_PORT_ID];
+	fcportdb_t		portdb[MAX_FC_TARG];
+
+	/*
+	 * This maps system virtual 'target' id to a portdb entry.
+	 *
+	 * The mapping function is to take any non-zero entry and
+	 * subtract one to get the portdb index. This means that
+	 * entries which are zero are unmapped (i.e., don't exist).
+	 */
+	u_int16_t		isp_ini_map[MAX_FC_TARG];
 
 	/*
 	 * Scratch DMA mapped in area to fetch Port Database stuff, etc.
 	 */
-	caddr_t			isp_scratch;
-	isp_dma_addr_t		isp_scdma;
+	void *			isp_scratch;
+	XS_DMA_ADDR_T		isp_scdma;
 #ifdef	ISP_FW_CRASH_DUMP
-	u_int16_t		*isp_dump_data;
+	u_int16_t *		isp_dump_data;
 #endif
 } fcparam;
 
@@ -406,10 +424,10 @@ typedef struct {
 #define	LOOP_NIL		0
 #define	LOOP_LIP_RCVD		1
 #define	LOOP_PDB_RCVD		2
-#define	LOOP_SCANNING_FABRIC	3
-#define	LOOP_FSCAN_DONE		4
-#define	LOOP_SCANNING_LOOP	5
-#define	LOOP_LSCAN_DONE		6
+#define	LOOP_SCANNING_LOOP	3
+#define	LOOP_LSCAN_DONE		4
+#define	LOOP_SCANNING_FABRIC	5
+#define	LOOP_FSCAN_DONE		6
 #define	LOOP_SYNCING_PDB	7
 #define	LOOP_READY		8
 
@@ -422,7 +440,7 @@ typedef struct {
 /*
  * Soft Structure per host adapter
  */
-typedef struct ispsoftc {
+struct ispsoftc {
 	/*
 	 * Platform (OS) specific data
 	 */
@@ -459,10 +477,12 @@ typedef struct ispsoftc {
 
 	u_int32_t		isp_confopts;		/* config options */
 
-	u_int16_t		isp_rqstinrp;	/* register for REQINP */
-	u_int16_t		isp_rqstoutrp;	/* register for REQOUTP */
-	u_int16_t		isp_respinrp;	/* register for RESINP */
-	u_int16_t		isp_respoutrp;	/* register for RESOUTP */
+	u_int32_t		isp_rqstinrp;	/* register for REQINP */
+	u_int32_t		isp_rqstoutrp;	/* register for REQOUTP */
+	u_int32_t		isp_respinrp;	/* register for RESINP */
+	u_int32_t		isp_respoutrp;	/* register for RESOUTP */
+	u_int32_t		isp_atioinrp;	/* register for ATIOINP */
+	u_int32_t		isp_atiooutrp;	/* register for ATIOOUTP */
 
 	/*
 	 * Instrumentation
@@ -480,24 +500,25 @@ typedef struct ispsoftc {
 	 * Volatile state
 	 */
 
-	volatile u_int32_t
-		isp_obits	:	8,	/* mailbox command output */
+	volatile u_int32_t	:	8,
 		isp_mboxbsy	:	1,	/* mailbox command active */
 		isp_state	:	3,
 		isp_sendmarker	:	2,	/* send a marker entry */
 		isp_update	:	2,	/* update parameters */
 		isp_nactive	:	16;	/* how many commands active */
-	volatile u_int16_t	isp_reqodx;	/* index of last ISP pickup */
-	volatile u_int16_t	isp_reqidx;	/* index of next request */
-	volatile u_int16_t	isp_residx;	/* index of next result */
-	volatile u_int16_t	isp_resodx;	/* index of next result */
-	volatile u_int16_t	isp_rspbsy;
-	volatile u_int16_t	isp_lasthdls;	/* last handle seed */
-	volatile u_int16_t	isp_mboxtmp[MAX_MAILBOX];
+	volatile u_int32_t	isp_reqodx;	/* index of last ISP pickup */
+	volatile u_int32_t	isp_reqidx;	/* index of next request */
+	volatile u_int32_t	isp_residx;	/* index of next result */
+	volatile u_int32_t	isp_resodx;	/* index of next result */
+	volatile u_int32_t	isp_rspbsy;
+	volatile u_int32_t	isp_lasthdls;	/* last handle seed */
+	volatile u_int32_t	isp_obits;	/* mailbox command output */
+	volatile u_int16_t	isp_mboxtmp[MAILBOX_STORAGE];
 	volatile u_int16_t	isp_lastmbxcmd;	/* last mbox command sent */
 	volatile u_int16_t	isp_mbxwrk0;
 	volatile u_int16_t	isp_mbxwrk1;
 	volatile u_int16_t	isp_mbxwrk2;
+	volatile u_int16_t	isp_mbxwrk8;
 	void *			isp_mbxworkp;
 
 	/*
@@ -505,14 +526,26 @@ typedef struct ispsoftc {
 	 */
 	XS_T **isp_xflist;
 
+#ifdef	ISP_TARGET_MODE
+	/*
+	 * Active target commands are stored here, indexed by handle function.
+	 */
+	void **isp_tgtlist;
+#endif
+
 	/*
-	 * request/result queue pointers and dma handles for them.
+	 * request/result queue pointers and DMA handles for them.
 	 */
-	caddr_t			isp_rquest;
-	caddr_t			isp_result;
-	isp_dma_addr_t		isp_rquest_dma;
-	isp_dma_addr_t		isp_result_dma;
-} ispsoftc_t;
+	void *			isp_rquest;
+	void *			isp_result;
+	XS_DMA_ADDR_T		isp_rquest_dma;
+	XS_DMA_ADDR_T		isp_result_dma;
+#ifdef	ISP_TARGET_MODE
+	/* for 24XX only */
+	void *			isp_atioq;
+	XS_DMA_ADDR_T		isp_atioq_dma;
+#endif
+};
 
 #define	SDPARAM(isp)	((sdparam *) (isp)->isp_param)
 #define	FCPARAM(isp)	((fcparam *) (isp)->isp_param)
@@ -521,9 +554,10 @@ typedef struct ispsoftc {
  * ISP Driver Run States
  */
 #define	ISP_NILSTATE	0
-#define	ISP_RESETSTATE	1
-#define	ISP_INITSTATE	2
-#define	ISP_RUNSTATE	3
+#define	ISP_CRASHED	1
+#define	ISP_RESETSTATE	2
+#define	ISP_INITSTATE	3
+#define	ISP_RUNSTATE	4
 
 /*
  * ISP Configuration Options
@@ -567,8 +601,8 @@ typedef struct ispsoftc {
  *
  */
 #define	ISP_ROLE_NONE		0x0
-#define	ISP_ROLE_INITIATOR	0x1
-#define	ISP_ROLE_TARGET		0x2
+#define	ISP_ROLE_TARGET		0x1
+#define	ISP_ROLE_INITIATOR	0x2
 #define	ISP_ROLE_BOTH		(ISP_ROLE_TARGET|ISP_ROLE_INITIATOR)
 #define	ISP_ROLE_EITHER		ISP_ROLE_BOTH
 #ifndef	ISP_DEFAULT_ROLES
@@ -649,7 +683,8 @@ typedef struct ispsoftc {
 #define	IS_FC(isp)	((isp)->isp_type & ISP_HA_FC)
 #define	IS_2100(isp)	((isp)->isp_type == ISP_HA_FC_2100)
 #define	IS_2200(isp)	((isp)->isp_type == ISP_HA_FC_2200)
-#define	IS_23XX(isp)	((isp)->isp_type >= ISP_HA_FC_2300)
+#define	IS_23XX(isp)	((isp)->isp_type >= ISP_HA_FC_2300 && \
+				(isp)->isp_type < ISP_HA_FC_2400)
 #define	IS_2300(isp)	((isp)->isp_type == ISP_HA_FC_2300)
 #define	IS_2312(isp)	((isp)->isp_type == ISP_HA_FC_2312)
 #define	IS_2322(isp)	((isp)->isp_type == ISP_HA_FC_2322)
@@ -658,15 +693,10 @@ typedef struct ispsoftc {
 /*
  * DMA related macros
  */
-#ifdef	ISP_DAC_SUPPORTRED
-#define	DMA_WD3(x)	(((x) >> 48) & 0xffff)
-#define	DMA_WD2(x)	(((x) >> 32) & 0xffff)
-#else
-#define	DMA_WD3(x)	0
-#define	DMA_WD2(x)	0
-#endif
-#define	DMA_WD1(x)	(((x) >> 16) & 0xffff)
-#define	DMA_WD0(x)	(((x) & 0xffff))
+#define	DMA_WD3(x)	(((u_int16_t)(((u_int64_t)x) >> 48)) & 0xffff)
+#define	DMA_WD2(x)	(((u_int16_t)(((u_int64_t)x) >> 32)) & 0xffff)
+#define	DMA_WD1(x)	((u_int16_t)((x) >> 16) & 0xffff)
+#define	DMA_WD0(x)	((u_int16_t)((x) & 0xffff))
 
 #define	DMA_LO32(x)	((u_int32_t) (x))
 #define	DMA_HI32(x)	((u_int32_t)(((u_int64_t)x) >> 32))
@@ -705,7 +735,7 @@ void isp_fw_dump(struct ispsoftc *isp);
  * semaphore register and first mailbox register (if appropriate). This also
  * means that most spurious/bogus interrupts not for us can be filtered first.
  */
-void isp_intr(struct ispsoftc *, u_int16_t, u_int16_t, u_int16_t);
+void isp_intr(struct ispsoftc *, u_int32_t, u_int16_t, u_int16_t);
 
 
 /*
@@ -768,9 +798,11 @@ typedef enum {
 	ISPCTL_SCAN_LOOP,		/* (Re)scan Local Loop */
 	ISPCTL_PDB_SYNC,		/* Synchronize Port Database */
 	ISPCTL_SEND_LIP,		/* Send a LIP */
-	ISPCTL_GET_POSMAP,		/* Get FC-AL position map */
+	ISPCTL_GET_PORTNAME,		/* get portname from an N-port handle */
 	ISPCTL_RUN_MBOXCMD,		/* run a mailbox command */
-	ISPCTL_TOGGLE_TMODE		/* toggle target mode */
+	ISPCTL_TOGGLE_TMODE,		/* toggle target mode */
+	ISPCTL_GET_PDB,			/* get a single port database entry */
+	ISPCTL_PLOGX			/* do a port login/logout */
 } ispctl_t;
 int isp_control(struct ispsoftc *, ispctl_t, void *);
 
@@ -823,11 +855,12 @@ typedef enum {
 	ISPASYNC_LIP,			/* LIP Received */
 	ISPASYNC_LOOP_RESET,		/* Loop Reset Received */
 	ISPASYNC_CHANGE_NOTIFY,		/* FC Change Notification */
-	ISPASYNC_FABRIC_DEV,		/* FC Fabric Device Arrival */
-	ISPASYNC_PROMENADE,		/* FC Objects coming && going */
-	ISPASYNC_TARGET_MESSAGE,	/* target message */
-	ISPASYNC_TARGET_EVENT,		/* target asynchronous event */
-	ISPASYNC_TARGET_ACTION,		/* other target command action */
+	ISPASYNC_DEV_ARRIVED,		/* FC Device Arrival */
+	ISPASYNC_DEV_CHANGED,		/* FC Device Change */
+	ISPASYNC_DEV_STAYED,		/* FC Device Stayed the Same */
+	ISPASYNC_DEV_GONE,		/* FC Device Depart */
+	ISPASYNC_TARGET_NOTIFY,		/* target asynchronous notification event */
+	ISPASYNC_TARGET_ACTION,		/* target action requested */
 	ISPASYNC_CONF_CHANGE,		/* Platform Configuration Change */
 	ISPASYNC_UNHANDLED_RESPONSE,	/* Unhandled Response Entry */
 	ISPASYNC_FW_CRASH,		/* Firmware has crashed */
@@ -850,12 +883,6 @@ int isp_async(struct ispsoftc *, ispasync_t, void *);
  * but due to compiler differences on different platforms this won't be
  * formally done here. Instead, it goes in each platform definition file.
  */
-#ifdef	__GNUC__
-void isp_prt(struct ispsoftc *, int level, const char *, ...)
-	__attribute__((__format__(__printf__,3,4)));
-#else
-void isp_prt(struct ispsoftc *, int level, const char *, ...);
-#endif
 
 #define	ISP_LOGALL	0x0	/* log always */
 #define	ISP_LOGCONFIG	0x1	/* log configuration messages */
@@ -866,7 +893,7 @@ void isp_prt(struct ispsoftc *, int level, const char *, ...);
 #define	ISP_LOGDEBUG1	0x20	/* log intermediate debug messages */
 #define	ISP_LOGDEBUG2	0x40	/* log most debug messages */
 #define	ISP_LOGDEBUG3	0x80	/* log high frequency debug messages */
-#define	ISP_LOGDEBUG4	0x100	/* log high frequency debug messages */
+#define	ISP_LOGSANCFG	0x100	/* log SAN configuration */
 #define	ISP_LOGTDEBUG0	0x200	/* log simple debug messages (target mode) */
 #define	ISP_LOGTDEBUG1	0x400	/* log intermediate debug messages (target) */
 #define	ISP_LOGTDEBUG2	0x800	/* log all debug messages (target) */
@@ -906,7 +933,7 @@ void isp_prt(struct ispsoftc *, int level, const char *, ...);
  *		of the same object is consistent.
  *
  *	MBOX_ACQUIRE(struct ispsoftc *)		acquire lock on mailbox regs
- *	MBOX_WAIT_COMPLETE(struct ispsoftc *)	wait for mailbox cmd to be done
+ *	MBOX_WAIT_COMPLETE(struct ispsoftc *, mbreg_t *) wait for cmd to be done
  *	MBOX_NOTIFY_COMPLETE(struct ispsoftc *)	notification of mbox cmd donee
  *	MBOX_RELEASE(struct ispsoftc *)		release lock on mailbox regs
  *
@@ -919,6 +946,7 @@ void isp_prt(struct ispsoftc *, int level, const char *, ...);
  *	SCSI_QFULL	SCSI 'Queue Full' Status
  *
  *	XS_T		Platform SCSI transaction type (i.e., command for HBA)
+ *	XS_DMA_ADDR_T	Platform PCI DMA Address Type
  *	XS_ISP(xs)	gets an instance out of an XS_T
  *	XS_CHANNEL(xs)	gets the channel (bus # for DUALBUS cards) ""
  *	XS_TGT(xs)	gets the target ""
@@ -950,17 +978,17 @@ void isp_prt(struct ispsoftc *, int level, const char *, ...);
  *	XS_NOERR(xs)	there is no error currently set
  *	XS_INITERR(xs)	initialize error state
  *
- *	XS_SAVE_SENSE(xs, sp)		save sense data
+ *	XS_SAVE_SENSE(xs, sp, len)	save sense data
  *
  *	XS_SET_STATE_STAT(isp, sp, xs)	platform dependent interpreter of
  *					response queue entry status bits
  *
  *
  *	DEFAULT_IID(struct ispsoftc *)		Default SCSI initiator ID
- *	DEFAULT_LOOPID(struct ispsoftc *)	Default FC Loop ID
- *	DEFAULT_NODEWWN(struct ispsoftc *)	Default Node WWN
- *	DEFAULT_PORTWWN(struct ispsoftc *)	Default Port WWN
- *	DEFAULT_FRAMESIZE(struct ispsoftc *)	Default Frame Size
+ *	DEFAULT_LOOPID(struct ispsoftc *)		Default FC Loop ID
+ *	DEFAULT_NODEWWN(struct ispsoftc *)		Default Node WWN
+ *	DEFAULT_PORTWWN(struct ispsoftc *)		Default Port WWN
+ *	DEFAULT_FRAMESIZE(struct ispsoftc *)		Default Frame Size
  *	DEFAULT_EXEC_THROTTLE(struct ispsoftc *) Default Execution Throttle
  *		These establish reasonable defaults for each platform.
  * 		These must be available independent of card NVRAM and are
@@ -970,7 +998,7 @@ void isp_prt(struct ispsoftc *, int level, const char *, ...);
  *	ISP_PORTWWN(struct ispsoftc *)		FC Port WWN to use
  *
  *		These are to be used after NVRAM is read. The tags
- *		in fcparam.isp_{node,port}wwn reflect the values
+ *		in fcparam.isp_ww{n,p}n_nvram reflect the values
  *		read from NVRAM (possibly corrected for card botches).
  *		Each platform can take that information and override
  *		it or ignore and return the Node and Port WWNs to be
diff --git a/sys/dev/pci/isp_pci.c b/sys/dev/pci/isp_pci.c
index 3f12d0a40cd..a0caffdc95c 100644
--- a/sys/dev/pci/isp_pci.c
+++ b/sys/dev/pci/isp_pci.c
@@ -1,12 +1,8 @@
-/*	$OpenBSD: isp_pci.c,v 1.46 2009/05/31 17:42:13 miod Exp $	*/
-/*
- * PCI specific probe and attach routines for QLogic ISP SCSI adapters.
- *
- *---------------------------------------
- * Copyright (c) 1997, 1998, 1999 by Matthew Jacob
- * NASA/Ames Research Center
+/*	$OpenBSD: isp_pci.c,v 1.47 2009/06/24 11:00:53 krw Exp $	*/
+/* $FreeBSD: src/sys/dev/isp/isp_pci.c,v 1.148 2007/06/26 23:08:57 mjacob Exp $*/
+/*-
+ * Copyright (c) 1997-2006 by Matthew Jacob
  * All rights reserved.
- *---------------------------------------
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -14,10 +10,7 @@
  * 1. Redistributions of source code must retain the above copyright
  *    notice immediately at the beginning of the file, without modification,
  *    this list of conditions, and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. The name of the author may not be used to endorse or promote products
+ * 2. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
@@ -31,7 +24,10 @@
  * 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.
- *
+ */
+/*
+ * PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
+ * FreeBSD Version.
  */
 
 #include <dev/ic/isp_openbsd.h>
@@ -48,79 +44,36 @@
 #include <mips64/archtype.h>
 #endif
 
-static u_int16_t isp_pci_rd_reg(struct ispsoftc *, int);
-static void isp_pci_wr_reg(struct ispsoftc *, int, u_int16_t);
-#if !(defined(ISP_DISABLE_1080_SUPPORT) && defined(ISP_DISABLE_12160_SUPPORT))
-static u_int16_t isp_pci_rd_reg_1080(struct ispsoftc *, int);
-static void isp_pci_wr_reg_1080(struct ispsoftc *, int, u_int16_t);
-#endif
-static int
-isp_pci_rd_isr(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
-#ifndef	ISP_DISABLE_2300_SUPPORT
-static int
-isp_pci_rd_isr_2300(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
-#endif
-static int isp_pci_mbxdma(struct ispsoftc *);
-static int isp_pci_dmasetup(struct ispsoftc *, struct scsi_xfer *,
-	ispreq_t *, u_int16_t *, u_int16_t);
-static void
-isp_pci_dmateardown (struct ispsoftc *, struct scsi_xfer *, u_int16_t);
-static void isp_pci_reset1 (struct ispsoftc *);
-static void isp_pci_dumpregs (struct ispsoftc *, const char *);
-static int isp_pci_intr (void *);
-
-#ifdef	ISP_COMPILE_FW
-#define	ISP_COMPILE_1040_FW	1
-#define	ISP_COMPILE_1080_FW	1
-#define	ISP_COMPILE_12160_FW	1
-#define	ISP_COMPILE_2100_FW	1
-#define	ISP_COMPILE_2200_FW	1
-#define	ISP_COMPILE_2300_FW	1
-#endif
-
-#if	defined(ISP_DISABLE_1040_SUPPORT) || !defined(ISP_COMPILE_1040_FW)
-#define	ISP_1040_RISC_CODE	NULL
-#else
-#define	ISP_1040_RISC_CODE	(u_int16_t *) isp_1040_risc_code
 #include <dev/microcode/isp/asm_1040.h>
-#endif
-
-#if	defined(ISP_DISABLE_1080_SUPPORT) || !defined(ISP_COMPILE_1080_FW)
-#define	ISP_1080_RISC_CODE	NULL
-#else
-#define	ISP_1080_RISC_CODE	(u_int16_t *) isp_1080_risc_code
 #include <dev/microcode/isp/asm_1080.h>
-#endif
-
-#if	defined(ISP_DISABLE_12160_SUPPORT) || !defined(ISP_COMPILE_12160_FW)
-#define	ISP_12160_RISC_CODE	(u_int16_t *) NULL
-#else
-#define	ISP_12160_RISC_CODE	(u_int16_t *) isp_12160_risc_code
 #include <dev/microcode/isp/asm_12160.h>
-#endif
-
-#if	defined(ISP_DISABLE_2100_SUPPORT) || !defined(ISP_COMPILE_2100_FW)
-#define	ISP_2100_RISC_CODE	NULL
-#else
-#define	ISP_2100_RISC_CODE	(u_int16_t *) isp_2100_risc_code
 #include <dev/microcode/isp/asm_2100.h>
-#endif
-
-#if	defined(ISP_DISABLE_2200_SUPPORT) || !defined(ISP_COMPILE_2200_FW)
-#define	ISP_2200_RISC_CODE	NULL
-#else
-#define	ISP_2200_RISC_CODE	(u_int16_t *) isp_2200_risc_code
 #include <dev/microcode/isp/asm_2200.h>
-#endif
-
-#if	defined(ISP_DISABLE_2300_SUPPORT) || !defined(ISP_COMPILE_2300_FW)
-#define	ISP_2300_RISC_CODE	NULL
-#else
-#define	ISP_2300_RISC_CODE	(u_int16_t *) isp_2300_risc_code
 #include <dev/microcode/isp/asm_2300.h>
-#endif
+#include <dev/microcode/isp/asm_2400.h>
+
+#define	BUS_PROBE_DEFAULT	0
+
+uint32_t isp_pci_rd_reg(ispsoftc_t *, int);
+void isp_pci_wr_reg(ispsoftc_t *, int, uint32_t);
+uint32_t isp_pci_rd_reg_1080(ispsoftc_t *, int);
+void isp_pci_wr_reg_1080(ispsoftc_t *, int, uint32_t);
+uint32_t isp_pci_rd_reg_2400(ispsoftc_t *, int);
+void isp_pci_wr_reg_2400(ispsoftc_t *, int, uint32_t);
+int isp_pci_rd_isr(ispsoftc_t *, uint32_t *, uint16_t *, uint16_t *);
+int isp_pci_rd_isr_2300(ispsoftc_t *, uint32_t *, uint16_t *, uint16_t *);
+int isp_pci_rd_isr_2400(ispsoftc_t *, uint32_t *, uint16_t *, uint16_t *);
+int isp_pci_mbxdma(ispsoftc_t *);
+int isp_pci_dmasetup(ispsoftc_t *, XS_T *, ispreq_t *, uint32_t *, uint32_t);
+void isp_pci_reset0(ispsoftc_t *);
+void isp_pci_reset1(ispsoftc_t *);
+void isp_pci_dumpregs(ispsoftc_t *, const char *);
+ 
+
+int isp_pci_rd_debounced(struct ispsoftc *, int, u_int16_t *);
+int isp_pci_intr (void *);
+void isp_pci_dmateardown(struct ispsoftc *, XS_T *, u_int32_t);
 
-#ifndef	ISP_DISABLE_1020_SUPPORT
 static struct ispmdvec mdvec = {
 	isp_pci_rd_isr,
 	isp_pci_rd_reg,
@@ -128,15 +81,13 @@ static struct ispmdvec mdvec = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_1040_RISC_CODE,
+	NULL,
 	BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
 };
-#endif
 
-#ifndef	ISP_DISABLE_1080_SUPPORT
 static struct ispmdvec mdvec_1080 = {
 	isp_pci_rd_isr,
 	isp_pci_rd_reg_1080,
@@ -144,15 +95,13 @@ static struct ispmdvec mdvec_1080 = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_1080_RISC_CODE,
+	isp_1080_risc_code,
 	BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
 };
-#endif
 
-#ifndef	ISP_DISABLE_12160_SUPPORT
 static struct ispmdvec mdvec_12160 = {
 	isp_pci_rd_isr,
 	isp_pci_rd_reg_1080,
@@ -160,15 +109,13 @@ static struct ispmdvec mdvec_12160 = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_12160_RISC_CODE,
+	isp_12160_risc_code,
 	BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
 };
-#endif
 
-#ifndef	ISP_DISABLE_2100_SUPPORT
 static struct ispmdvec mdvec_2100 = {
 	isp_pci_rd_isr,
 	isp_pci_rd_reg,
@@ -176,14 +123,12 @@ static struct ispmdvec mdvec_2100 = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_2100_RISC_CODE
+	isp_2100_risc_code
 };
-#endif
 
-#ifndef	ISP_DISABLE_2200_SUPPORT
 static struct ispmdvec mdvec_2200 = {
 	isp_pci_rd_isr,
 	isp_pci_rd_reg,
@@ -191,14 +136,12 @@ static struct ispmdvec mdvec_2200 = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_2200_RISC_CODE
+	isp_2200_risc_code
 };
-#endif
 
-#ifndef	ISP_DISABLE_2300_SUPPORT
 static struct ispmdvec mdvec_2300 = {
 	isp_pci_rd_isr_2300,
 	isp_pci_rd_reg,
@@ -206,15 +149,58 @@ static struct ispmdvec mdvec_2300 = {
 	isp_pci_mbxdma,
 	isp_pci_dmasetup,
 	isp_pci_dmateardown,
-	NULL,
+	isp_pci_reset0,
 	isp_pci_reset1,
 	isp_pci_dumpregs,
-	ISP_2300_RISC_CODE
+	isp_2300_risc_code
+};
+
+static struct ispmdvec mdvec_2400 = {
+	isp_pci_rd_isr_2400,
+	isp_pci_rd_reg_2400,
+	isp_pci_wr_reg_2400,
+	isp_pci_mbxdma,
+	isp_pci_dmasetup,
+	isp_pci_dmateardown,
+	isp_pci_reset0,
+	isp_pci_reset1,
+	NULL
 };
+
+#ifndef	PCIM_CMD_INVEN
+#define	PCIM_CMD_INVEN			0x10
+#endif
+#ifndef	PCIM_CMD_BUSMASTEREN
+#define	PCIM_CMD_BUSMASTEREN		0x0004
+#endif
+#ifndef	PCIM_CMD_PERRESPEN
+#define	PCIM_CMD_PERRESPEN		0x0040
+#endif
+#ifndef	PCIM_CMD_SEREN
+#define	PCIM_CMD_SEREN			0x0100
+#endif
+#ifndef	PCIM_CMD_INTX_DISABLE
+#define	PCIM_CMD_INTX_DISABLE		0x0400
+#endif
+
+#ifndef	PCIR_COMMAND
+#define	PCIR_COMMAND			0x04
+#endif
+
+#ifndef	PCIR_CACHELNSZ
+#define	PCIR_CACHELNSZ			0x0c
+#endif
+
+#ifndef	PCIR_LATTIMER
+#define	PCIR_LATTIMER			0x0d
+#endif
+
+#ifndef	PCIR_ROMADDR
+#define	PCIR_ROMADDR			0x30
 #endif
 
 #ifndef	PCI_VENDOR_QLOGIC
-#define	PCI_VENDOR_QLOGIC	0x1077
+#define	PCI_VENDOR_QLOGIC		0x1077
 #endif
 
 #ifndef	PCI_PRODUCT_QLOGIC_ISP1020
@@ -225,14 +211,6 @@ static struct ispmdvec mdvec_2300 = {
 #define	PCI_PRODUCT_QLOGIC_ISP1080	0x1080
 #endif
 
-#ifndef	PCI_PRODUCT_QLOGIC_ISP1240
-#define	PCI_PRODUCT_QLOGIC_ISP1240	0x1240
-#endif
-
-#ifndef	PCI_PRODUCT_QLOGIC_ISP1280
-#define	PCI_PRODUCT_QLOGIC_ISP1280	0x1280
-#endif
-
 #ifndef	PCI_PRODUCT_QLOGIC_ISP10160
 #define	PCI_PRODUCT_QLOGIC_ISP10160	0x1016
 #endif
@@ -241,6 +219,14 @@ static struct ispmdvec mdvec_2300 = {
 #define	PCI_PRODUCT_QLOGIC_ISP12160	0x1216
 #endif
 
+#ifndef	PCI_PRODUCT_QLOGIC_ISP1240
+#define	PCI_PRODUCT_QLOGIC_ISP1240	0x1240
+#endif
+
+#ifndef	PCI_PRODUCT_QLOGIC_ISP1280
+#define	PCI_PRODUCT_QLOGIC_ISP1280	0x1280
+#endif
+
 #ifndef	PCI_PRODUCT_QLOGIC_ISP2100
 #define	PCI_PRODUCT_QLOGIC_ISP2100	0x2100
 #endif
@@ -257,20 +243,32 @@ static struct ispmdvec mdvec_2300 = {
 #define	PCI_PRODUCT_QLOGIC_ISP2312	0x2312
 #endif
 
+#ifndef	PCI_PRODUCT_QLOGIC_ISP2322
+#define	PCI_PRODUCT_QLOGIC_ISP2322	0x2322
+#endif
+
+#ifndef	PCI_PRODUCT_QLOGIC_ISP2422
+#define	PCI_PRODUCT_QLOGIC_ISP2422	0x2422
+#endif
+
+#ifndef	PCI_PRODUCT_QLOGIC_ISP2432
+#define	PCI_PRODUCT_QLOGIC_ISP2432	0x2432
+#endif
+
 #ifndef	PCI_PRODUCT_QLOGIC_ISP6312
 #define	PCI_PRODUCT_QLOGIC_ISP6312	0x6312
 #endif
 
-#define	PCI_QLOGIC_ISP	((PCI_PRODUCT_QLOGIC_ISP1020 << 16) | PCI_VENDOR_QLOGIC)
+#ifndef	PCI_PRODUCT_QLOGIC_ISP6322
+#define	PCI_PRODUCT_QLOGIC_ISP6322	0x6322
+#endif
 
-#define	PCI_QLOGIC_ISP1080	\
-	((PCI_PRODUCT_QLOGIC_ISP1080 << 16) | PCI_VENDOR_QLOGIC)
 
-#define	PCI_QLOGIC_ISP1240	\
-	((PCI_PRODUCT_QLOGIC_ISP1240 << 16) | PCI_VENDOR_QLOGIC)
+#define	PCI_QLOGIC_ISP1020	\
+	((PCI_PRODUCT_QLOGIC_ISP1020 << 16) | PCI_VENDOR_QLOGIC)
 
-#define	PCI_QLOGIC_ISP1280	\
-	((PCI_PRODUCT_QLOGIC_ISP1280 << 16) | PCI_VENDOR_QLOGIC)
+#define	PCI_QLOGIC_ISP1080	\
+	((PCI_PRODUCT_QLOGIC_ISP1080 << 16) | PCI_VENDOR_QLOGIC)
 
 #define	PCI_QLOGIC_ISP10160	\
 	((PCI_PRODUCT_QLOGIC_ISP10160 << 16) | PCI_VENDOR_QLOGIC)
@@ -278,6 +276,12 @@ static struct ispmdvec mdvec_2300 = {
 #define	PCI_QLOGIC_ISP12160	\
 	((PCI_PRODUCT_QLOGIC_ISP12160 << 16) | PCI_VENDOR_QLOGIC)
 
+#define	PCI_QLOGIC_ISP1240	\
+	((PCI_PRODUCT_QLOGIC_ISP1240 << 16) | PCI_VENDOR_QLOGIC)
+
+#define	PCI_QLOGIC_ISP1280	\
+	((PCI_PRODUCT_QLOGIC_ISP1280 << 16) | PCI_VENDOR_QLOGIC)
+
 #define	PCI_QLOGIC_ISP2100	\
 	((PCI_PRODUCT_QLOGIC_ISP2100 << 16) | PCI_VENDOR_QLOGIC)
 
@@ -290,18 +294,28 @@ static struct ispmdvec mdvec_2300 = {
 #define	PCI_QLOGIC_ISP2312	\
 	((PCI_PRODUCT_QLOGIC_ISP2312 << 16) | PCI_VENDOR_QLOGIC)
 
+#define	PCI_QLOGIC_ISP2322	\
+	((PCI_PRODUCT_QLOGIC_ISP2322 << 16) | PCI_VENDOR_QLOGIC)
+
+#define	PCI_QLOGIC_ISP2422	\
+	((PCI_PRODUCT_QLOGIC_ISP2422 << 16) | PCI_VENDOR_QLOGIC)
+
+#define	PCI_QLOGIC_ISP2432	\
+	((PCI_PRODUCT_QLOGIC_ISP2432 << 16) | PCI_VENDOR_QLOGIC)
+
 #define	PCI_QLOGIC_ISP6312	\
 	((PCI_PRODUCT_QLOGIC_ISP6312 << 16) | PCI_VENDOR_QLOGIC)
 
+#define	PCI_QLOGIC_ISP6322	\
+	((PCI_PRODUCT_QLOGIC_ISP6322 << 16) | PCI_VENDOR_QLOGIC)
+
 /*
  * Odd case for some AMI raid cards... We need to *not* attach to this.
  */
 #define	AMI_RAID_SUBVENDOR_ID	0x101e
 
-
-#define IO_MAP_REG	0x10
-#define MEM_MAP_REG	0x14
-#define	PCIR_ROMADDR	0x30
+#define	IO_MAP_REG	0x10
+#define	MEM_MAP_REG	0x14
 
 #define	PCI_DFLT_LTNCY	0x40
 #define	PCI_DFLT_LNSZ	0x10
@@ -314,9 +328,29 @@ static struct ispmdvec mdvec_2300 = {
 #endif
 #endif
 
-static int isp_pci_probe (struct device *, void *, void *);
-static void isp_pci_attach (struct device *, struct device *, void *);
+const struct pci_matchid ispdev[] = {
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1020 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1080 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1240 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1280 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP10160 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP12160 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2100 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2200 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2300 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2312 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2322 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2422 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2432 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP6312 },
+	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP6322 },
+	{ 0, 0 }
+};
+ 
+int isp_pci_probe (struct device *, void *, void *);
+void isp_pci_attach (struct device *, struct device *, void *);
 
+#define	ISP_PCD(isp)	((struct isp_pcisoftc *)isp)->pci_dev
 struct isp_pcisoftc {
 	struct ispsoftc		pci_isp;
 	pci_chipset_tag_t	pci_pc;
@@ -332,39 +366,7 @@ struct cfattach isp_pci_ca = {
 	sizeof (struct isp_pcisoftc), isp_pci_probe, isp_pci_attach
 };
 
-#ifdef  DEBUG
-const char vstring[] =
-    "QLogic ISP Driver, NetBSD (pci) Platform Version %d.%d Core Version %d.%d";
-#endif
-
-const struct pci_matchid ispdev[] = {
-#ifndef	ISP_DISABLE_1020_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1020 },
-#endif
-#ifndef	ISP_DISABLE_1080_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1080 },
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1240 },
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP1280 },
-#endif
-#ifndef	ISP_DISABLE_12160_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP10160 },
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP12160 },
-#endif
-#ifndef	ISP_DISABLE_2100_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2100 },
-#endif
-#ifndef	ISP_DISABLE_2200_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2200 },
-#endif
-#ifndef	ISP_DISABLE_2300_SUPPORT
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2300 },
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP2312 },
-	{ PCI_VENDOR_QLOGIC, PCI_PRODUCT_QLOGIC_ISP6312 },
-#endif
-	{ 0, 0 }
-};
-
-static int
+int
 isp_pci_probe(struct device *parent, void *match, void *aux)
 {
         struct pci_attach_args *pa = aux;
@@ -386,7 +388,7 @@ isp_pci_probe(struct device *parent, void *match, void *aux)
 }
 
 
-static void    
+void    
 isp_pci_attach(struct device *parent, struct device *self, void *aux)
 {
 #ifdef	DEBUG
@@ -395,7 +397,7 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 	static const char nomem[] = ": no mem for sdparam table\n";
 	u_int32_t data, rev, linesz = PCI_DFLT_LNSZ;
 	struct pci_attach_args *pa = aux;
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) self;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)self;
 	struct ispsoftc *isp = &pcs->pci_isp;
 	bus_space_tag_t st, iot, memt;
 	bus_space_handle_t sh, ioh, memh;
@@ -487,8 +489,8 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 	printf("\n");
 #endif
 
-	pcs->pci_st = st;
-	pcs->pci_sh = sh;
+	pcs->pci_st = isp->isp_bus_tag = st;
+	pcs->pci_sh = isp->isp_bus_handle = sh;
 	pcs->pci_pc = pa->pa_pc;
 	pcs->pci_tag = pa->pa_tag;
 	pcs->pci_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF;
@@ -497,8 +499,7 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 	pcs->pci_poff[RISC_BLOCK >> _BLK_REG_SHFT] = PCI_RISC_REGS_OFF;
 	pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF;
 	rev = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG) & 0xff;
-#ifndef	ISP_DISABLE_1020_SUPPORT
-	if (pa->pa_id == PCI_QLOGIC_ISP) {
+	if (pa->pa_id == PCI_QLOGIC_ISP1020) {
 		isp->isp_mdvec = &mdvec;
 		isp->isp_type = ISP_HA_SCSI_UNKNOWN;
 		isp->isp_param = malloc(sizeof(sdparam), M_DEVBUF,
@@ -508,8 +509,6 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 			return;
 		}
 	}
-#endif
-#ifndef	ISP_DISABLE_1080_SUPPORT
 	if (pa->pa_id == PCI_QLOGIC_ISP1080) {
 		isp->isp_mdvec = &mdvec_1080;
 		isp->isp_type = ISP_HA_SCSI_1080;
@@ -546,8 +545,6 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 		pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 		    ISP1080_DMA_REGS_OFF;
 	}
-#endif
-#ifndef	ISP_DISABLE_12160_SUPPORT
 	if (pa->pa_id == PCI_QLOGIC_ISP10160) {
 		isp->isp_mdvec = &mdvec_12160;
 		isp->isp_type = ISP_HA_SCSI_10160;
@@ -572,8 +569,6 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 		pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 		    ISP1080_DMA_REGS_OFF;
 	}
-#endif
-#ifndef	ISP_DISABLE_2100_SUPPORT
 	if (pa->pa_id == PCI_QLOGIC_ISP2100) {
 		isp->isp_mdvec = &mdvec_2100;
 		isp->isp_type = ISP_HA_FC_2100;
@@ -595,8 +590,6 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 			linesz = 1;
 		}
 	}
-#endif
-#ifndef	ISP_DISABLE_2200_SUPPORT
 	if (pa->pa_id == PCI_QLOGIC_ISP2200) {
 		isp->isp_mdvec = &mdvec_2200;
 		isp->isp_type = ISP_HA_FC_2200;
@@ -621,18 +614,38 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 		}
 #endif
 	}
-#endif
-#ifndef	ISP_DISABLE_2300_SUPPORT
-	if (pa->pa_id == PCI_QLOGIC_ISP2300 ||
-	    pa->pa_id == PCI_QLOGIC_ISP2312 ||
+	if (pa->pa_id == PCI_QLOGIC_ISP2300) {
+		isp->isp_mdvec = &mdvec_2300;
+		isp->isp_type = ISP_HA_FC_2300;
+		isp->isp_param = malloc(sizeof(fcparam), M_DEVBUF,
+		    M_NOWAIT | M_ZERO);
+		if (isp->isp_param == NULL) {
+			printf(nomem);
+			return;
+		}
+		pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
+		    PCI_MBOX_REGS2300_OFF;
+	}
+	if (pa->pa_id == PCI_QLOGIC_ISP2312 ||
 	    pa->pa_id == PCI_QLOGIC_ISP6312) {
 		isp->isp_mdvec = &mdvec_2300;
-		if (pa->pa_id  == PCI_QLOGIC_ISP2300) {
-			isp->isp_type = ISP_HA_FC_2300;
-		} else {
-			isp->isp_type = ISP_HA_FC_2312;
-			isp->isp_port = pa->pa_function;
+		isp->isp_type = ISP_HA_FC_2312;
+		isp->isp_port = pa->pa_function;
+		isp->isp_param = malloc(sizeof(fcparam), M_DEVBUF,
+		    M_NOWAIT | M_ZERO);
+		if (isp->isp_param == NULL) {
+			printf(nomem);
+			return;
 		}
+		pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
+		    PCI_MBOX_REGS2300_OFF;
+		data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG);
+	}
+	if (pa->pa_id == PCI_QLOGIC_ISP2322 ||
+	    pa->pa_id == PCI_QLOGIC_ISP6322) {
+		isp->isp_mdvec = &mdvec_2300;
+		isp->isp_type = ISP_HA_FC_2322;
+		isp->isp_port = pa->pa_function;
 		isp->isp_param = malloc(sizeof(fcparam), M_DEVBUF,
 		    M_NOWAIT | M_ZERO);
 		if (isp->isp_param == NULL) {
@@ -643,7 +656,20 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 		    PCI_MBOX_REGS2300_OFF;
 		data = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_CLASS_REG);
 	}
-#endif
+	if (pa->pa_id == PCI_QLOGIC_ISP2422 ||
+	    pa->pa_id == PCI_QLOGIC_ISP2432) {
+		isp->isp_mdvec = &mdvec_2400;
+		isp->isp_type = ISP_HA_FC_2400;
+		isp->isp_port = pa->pa_function;
+		isp->isp_param = malloc(sizeof(fcparam), M_DEVBUF,
+		    M_NOWAIT | M_ZERO);
+		if (isp->isp_param == NULL) {
+			printf(nomem);
+			return;
+		}
+		pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
+		    PCI_MBOX_REGS2400_OFF;
+	}
 	/*
 	 * Set up logging levels.
 	 */
@@ -739,7 +765,7 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 		free(isp->isp_param, M_DEVBUF);
 		return;
 	}
-	ENABLE_INTS(isp);
+	ISP_ENABLE_INTS(isp);
 	isp_init(isp);
 	if (isp->isp_state != ISP_INITSTATE) {
 		isp_uninit(isp);
@@ -762,19 +788,22 @@ isp_pci_attach(struct device *parent, struct device *self, void *aux)
 
 #define	IspVirt2Off(a, x)	\
 	(((struct isp_pcisoftc *)a)->pci_poff[((x) & _BLK_REG_MASK) >> \
-	_BLK_REG_SHFT] + ((x) & 0xff))
+	_BLK_REG_SHFT] + ((x) & 0xfff))
 
 #define	BXR2(pcs, off)		\
 	bus_space_read_2(pcs->pci_st, pcs->pci_sh, off)
 #define	BXW2(pcs, off, v)	\
 	bus_space_write_2(pcs->pci_st, pcs->pci_sh, off, v)
+#define	BXR4(pcs, off)		\
+	bus_space_read_4(pcs->pci_st, pcs->pci_sh, off)
+#define	BXW4(pcs, off, v)	\
+	bus_space_write_4(pcs->pci_st, pcs->pci_sh, off, v)
 
-
-static INLINE int
+int
 isp_pci_rd_debounced(struct ispsoftc *isp, int off, u_int16_t *rp)
 {
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
-	u_int16_t val0, val1;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	u_int32_t val0, val1;
 	int i = 0;
 
 	do {
@@ -788,11 +817,11 @@ isp_pci_rd_debounced(struct ispsoftc *isp, int off, u_int16_t *rp)
 	return (0);
 }
 
-static int
-isp_pci_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
+int
+isp_pci_rd_isr(struct ispsoftc *isp, u_int32_t *isrp,
     u_int16_t *semap, u_int16_t *mbp)
 {
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	u_int16_t isr, sema;
 
 	if (IS_2100(isp)) {
@@ -825,20 +854,19 @@ isp_pci_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
 	return (1);
 }
 
-#ifndef	ISP_DISABLE_2300_SUPPORT
-static int
-isp_pci_rd_isr_2300(struct ispsoftc *isp, u_int16_t *isrp,
+int
+isp_pci_rd_isr_2300(struct ispsoftc *isp, u_int32_t *isrp,
     u_int16_t *semap, u_int16_t *mbox0p)
 {
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	u_int32_t hccr;
 	u_int32_t r2hisr;
 
 	if (!(BXR2(pcs, IspVirt2Off(isp, BIU_ISR)) & BIU2100_ISR_RISC_INT)) {
 		*isrp = 0;
 		return (0);
 	}
-	r2hisr = bus_space_read_4(pcs->pci_st, pcs->pci_sh,
-	    IspVirt2Off(pcs, BIU_R2HSTSLO));
+	r2hisr = BXR4(pcs, IspVirt2Off(isp, BIU_R2HSTSLO));
 	isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
 	if ((r2hisr & BIU_R2HST_INTR) == 0) {
 		*isrp = 0;
@@ -875,16 +903,26 @@ isp_pci_rd_isr_2300(struct ispsoftc *isp, u_int16_t *isrp,
 		*semap = 0;
 		return (1);
 	default:
+		hccr = ISP_READ(isp, HCCR);
+		if (hccr & HCCR_PAUSE) {
+			ISP_WRITE(isp, HCCR, HCCR_RESET);
+			isp_prt(isp, ISP_LOGERR,
+			    "RISC paused at interrupt (%x->%x)", hccr,
+			    ISP_READ(isp, HCCR));
+			ISP_WRITE(isp, BIU_ICR, 0);
+		} else {
+			isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n",
+			    r2hisr);
+		}
 		return (0);
 	}
 }
-#endif
 
-static u_int16_t
+u_int32_t
 isp_pci_rd_reg(struct ispsoftc *isp, int regoff)
 {
 	u_int16_t rv;
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	int oldconf = 0;
 
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
@@ -894,18 +932,57 @@ isp_pci_rd_reg(struct ispsoftc *isp, int regoff)
 		oldconf = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 		    oldconf | BIU_PCI_CONF1_SXP);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 	rv = BXR2(pcs, IspVirt2Off(isp, regoff));
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oldconf);
 	}
+	MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	return (rv);
 }
 
-static void
-isp_pci_wr_reg(struct ispsoftc *isp, int regoff, u_int16_t val)
+int
+isp_pci_rd_isr_2400(ispsoftc_t *isp, uint32_t *isrp,
+    uint16_t *semap, uint16_t *mbox0p)
 {
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	uint32_t r2hisr;
+
+	r2hisr = BXR4(pcs, IspVirt2Off(isp, BIU2400_R2HSTSLO));
+	isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
+	if ((r2hisr & BIU2400_R2HST_INTR) == 0) {
+		*isrp = 0;
+		return (0);
+	}
+	switch (r2hisr & BIU2400_R2HST_ISTAT_MASK) {
+	case ISP2400R2HST_ROM_MBX_OK:
+	case ISP2400R2HST_ROM_MBX_FAIL:
+	case ISP2400R2HST_MBX_OK:
+	case ISP2400R2HST_MBX_FAIL:
+	case ISP2400R2HST_ASYNC_EVENT:
+		*isrp = r2hisr & 0xffff;
+		*mbox0p = (r2hisr >> 16);
+		*semap = 1;
+		return (1);
+	case ISP2400R2HST_RSPQ_UPDATE:
+	case ISP2400R2HST_ATIO_RSPQ_UPDATE:
+	case ISP2400R2HST_ATIO_RQST_UPDATE:
+		*isrp = r2hisr & 0xffff;
+		*mbox0p = 0;
+		*semap = 0;
+		return (1);
+	default:
+		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
+		isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
+		return (0);
+	}
+}
+
+void
+isp_pci_wr_reg(struct ispsoftc *isp, int regoff, u_int32_t val)
+{
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	int oldconf = 0;
 
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
@@ -915,23 +992,26 @@ isp_pci_wr_reg(struct ispsoftc *isp, int regoff, u_int16_t val)
 		oldconf = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 		    oldconf | BIU_PCI_CONF1_SXP);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 	BXW2(pcs, IspVirt2Off(isp, regoff), val);
+	MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2);
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oldconf);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
+
 }
 
-#if !(defined(ISP_DISABLE_1080_SUPPORT) && defined(ISP_DISABLE_12160_SUPPORT))
-static u_int16_t
+u_int32_t
 isp_pci_rd_reg_1080(struct ispsoftc *isp, int regoff)
 {
-	u_int16_t rv, oc = 0;
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	u_int32_t rv, oc = 0;
 
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK ||
 	    (regoff & _BLK_REG_MASK) == (SXP_BLOCK|SXP_BANK1_SELECT)) {
-		u_int16_t tc;
+		u_int32_t tc;
 		/*
 		 * We will assume that someone has paused the RISC processor.
 		 */
@@ -942,27 +1022,30 @@ isp_pci_rd_reg_1080(struct ispsoftc *isp, int regoff)
 		else
 			tc |= BIU_PCI1080_CONF1_SXP0;
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), tc);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	} else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
 		oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), 
 		    oc | BIU_PCI1080_CONF1_DMA);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 	rv = BXR2(pcs, IspVirt2Off(isp, regoff));
 	if (oc) {
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oc);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 	return (rv);
 }
 
-static void
-isp_pci_wr_reg_1080(struct ispsoftc *isp, int regoff, u_int16_t val)
+void
+isp_pci_wr_reg_1080(struct ispsoftc *isp, int regoff, u_int32_t val)
 {
-	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	int oc = 0;
 
 	if ((regoff & _BLK_REG_MASK) == SXP_BLOCK ||
 	    (regoff & _BLK_REG_MASK) == (SXP_BLOCK|SXP_BANK1_SELECT)) {
-		u_int16_t tc;
+		u_int32_t tc;
 		/*
 		 * We will assume that someone has paused the RISC processor.
 		 */
@@ -973,26 +1056,155 @@ isp_pci_wr_reg_1080(struct ispsoftc *isp, int regoff, u_int16_t val)
 		else
 			tc |= BIU_PCI1080_CONF1_SXP0;
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), tc);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	} else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
 		oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), 
 		    oc | BIU_PCI1080_CONF1_DMA);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 	BXW2(pcs, IspVirt2Off(isp, regoff), val);
+	MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2);
 	if (oc) {
 		BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oc);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2);
 	}
 }
-#endif
 
-static int
+uint32_t
+isp_pci_rd_reg_2400(ispsoftc_t *isp, int regoff)
+{
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	uint32_t rv;
+	int block = regoff & _BLK_REG_MASK;
+
+	switch (block) {
+	case BIU_BLOCK:
+		break;
+	case MBOX_BLOCK:
+		return (BXR2(pcs, IspVirt2Off(isp, regoff)));
+	case SXP_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "SXP_BLOCK read at 0x%x", regoff);
+		return (0xffffffff);
+	case RISC_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "RISC_BLOCK read at 0x%x", regoff);
+		return (0xffffffff);
+	case DMA_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "DMA_BLOCK read at 0x%x", regoff);
+		return (0xffffffff);
+	default:
+		isp_prt(isp, ISP_LOGWARN, "unknown block read at 0x%x", regoff);
+		return (0xffffffff);
+	}
+
+
+	switch (regoff) {
+	case BIU2400_FLASH_ADDR:
+	case BIU2400_FLASH_DATA:
+	case BIU2400_ICR:
+	case BIU2400_ISR:
+	case BIU2400_CSR:
+	case BIU2400_REQINP:
+	case BIU2400_REQOUTP:
+	case BIU2400_RSPINP:
+	case BIU2400_RSPOUTP:
+	case BIU2400_PRI_RQINP:
+	case BIU2400_PRI_RSPINP:
+	case BIU2400_ATIO_RSPINP:
+	case BIU2400_ATIO_REQINP:
+	case BIU2400_HCCR:
+	case BIU2400_GPIOD:
+	case BIU2400_GPIOE:
+	case BIU2400_HSEMA:
+		rv = BXR4(pcs, IspVirt2Off(isp, regoff));
+		break;
+	case BIU2400_R2HSTSLO:
+		rv = BXR4(pcs, IspVirt2Off(isp, regoff));
+		break;
+	case BIU2400_R2HSTSHI:
+		rv = BXR4(pcs, IspVirt2Off(isp, regoff)) >> 16;
+		break;
+	default:
+		isp_prt(isp, ISP_LOGERR,
+		    "isp_pci_rd_reg_2400: unknown offset %x", regoff);
+		rv = 0xffffffff;
+		break;
+	}
+	return (rv);
+}
+
+void
+isp_pci_wr_reg_2400(ispsoftc_t *isp, int regoff, uint32_t val)
+{
+	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
+	int block = regoff & _BLK_REG_MASK;
+
+	switch (block) {
+	case BIU_BLOCK:
+		break;
+	case MBOX_BLOCK:
+		BXW2(pcs, IspVirt2Off(isp, regoff), val);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2);
+		return;
+	case SXP_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "SXP_BLOCK write at 0x%x", regoff);
+		return;
+	case RISC_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "RISC_BLOCK write at 0x%x", regoff);
+		return;
+	case DMA_BLOCK:
+		isp_prt(isp, ISP_LOGWARN, "DMA_BLOCK write at 0x%x", regoff);
+		return;
+	default:
+		isp_prt(isp, ISP_LOGWARN, "unknown block write at 0x%x",
+		    regoff);
+		break;
+	}
+
+	switch (regoff) {
+	case BIU2400_FLASH_ADDR:
+	case BIU2400_FLASH_DATA:
+	case BIU2400_ICR:
+	case BIU2400_ISR:
+	case BIU2400_CSR:
+	case BIU2400_REQINP:
+	case BIU2400_REQOUTP:
+	case BIU2400_RSPINP:
+	case BIU2400_RSPOUTP:
+	case BIU2400_PRI_RQINP:
+	case BIU2400_PRI_RSPINP:
+	case BIU2400_ATIO_RSPINP:
+	case BIU2400_ATIO_REQINP:
+	case BIU2400_HCCR:
+	case BIU2400_GPIOD:
+	case BIU2400_GPIOE:
+	case BIU2400_HSEMA:
+		BXW4(pcs, IspVirt2Off(isp, regoff), val);
+		MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 4);
+		break;
+	default:
+		isp_prt(isp, ISP_LOGERR,
+		    "isp_pci_wr_reg_2400: bad offset 0x%x", regoff);
+		break;
+	}
+}
+
+
+struct imush {
+	ispsoftc_t *isp;
+	int error;
+};
+
+
+int
 isp_pci_mbxdma(struct ispsoftc *isp)
 {
 	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	bus_dma_tag_t dmat = isp->isp_dmatag;
 	bus_dma_segment_t sg;
+	bus_addr_t addr;
 	bus_size_t len;
-	fcparam *fcp;
+	caddr_t base;
 	int rs, i;
 
 	if (isp->isp_rquest_dma)	/* been here before? */
@@ -1033,62 +1245,48 @@ isp_pci_mbxdma(struct ispsoftc *isp)
 	}
 
 	/*
-	 * Allocate and map the request queue.
+	 * Allocate and map the request, result queues, plus FC scratch area.
 	 */
 	len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
+	len += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
+	if (IS_FC(isp)) {
+		len += ISP2100_SCRLEN;
+	}
+
 	if (bus_dmamem_alloc(dmat, len, PAGE_SIZE, 0, &sg, 1, &rs,
 			     BUS_DMA_NOWAIT) ||
 	    bus_dmamem_map(isp->isp_dmatag, &sg, rs, len,
-	    (caddr_t *)&isp->isp_rquest, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
+	    &base, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
 		goto dmafail;
 	}
 
 	if (bus_dmamap_create(dmat, len, 1, len, 0, BUS_DMA_NOWAIT,
-	    &isp->isp_rqdmap) || bus_dmamap_load(dmat, isp->isp_rqdmap,
-	    (caddr_t)isp->isp_rquest, len, NULL,
+	    &isp->isp_cdmap) || bus_dmamap_load(dmat, isp->isp_cdmap,
+	    base, len, NULL,
 	    BUS_DMA_NOWAIT)) {
 		goto dmafail;
 	}
-	isp->isp_rquest_dma = isp->isp_rqdmap->dm_segs[0].ds_addr;
 
-	/*
-	 * Allocate and map the result queue.
-	 */
-	len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
-	if (bus_dmamem_alloc(dmat, len, PAGE_SIZE, 0, &sg, 1, &rs,
-			     BUS_DMA_NOWAIT) ||
-	    bus_dmamem_map(dmat, &sg, rs, len, (caddr_t *)&isp->isp_result,
-	    BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
-		goto dmafail;
-	}
-	if (bus_dmamap_create(dmat, len, 1, len, 0, BUS_DMA_NOWAIT,
-	    &isp->isp_rsdmap) || bus_dmamap_load(isp->isp_dmatag,
-	    isp->isp_rsdmap, (caddr_t)isp->isp_result, len, NULL,
-	    BUS_DMA_NOWAIT)) {
-		goto dmafail;
-	}
-	isp->isp_result_dma = isp->isp_rsdmap->dm_segs[0].ds_addr;
+	addr = isp->isp_cdmap->dm_segs[0].ds_addr;
+	isp->isp_rquest_dma = addr;
+	addr += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
+	isp->isp_result_dma = addr;
 
-	if (IS_SCSI(isp)) {
-		return (0);
-	}
+	if (IS_FC(isp)) {
+		addr += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
+		FCPARAM(isp)->isp_scdma = addr;
 
-	fcp = isp->isp_param;
-	len = ISP2100_SCRLEN;
-	if (bus_dmamem_alloc(dmat, len, PAGE_SIZE, 0, &sg, 1, &rs,
-			     BUS_DMA_NOWAIT) ||
-	    bus_dmamem_map(dmat, &sg, rs, len, (caddr_t *)&fcp->isp_scratch,
-	    BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
-		goto dmafail;
 	}
-	if (bus_dmamap_create(dmat, len, 1, len, 0, BUS_DMA_NOWAIT,
-	    &isp->isp_scdmap) || bus_dmamap_load(dmat,
-	    isp->isp_scdmap, (caddr_t)fcp->isp_scratch, len, NULL,
-	    BUS_DMA_NOWAIT)) {
-		goto dmafail;
+
+	isp->isp_rquest = base;
+	base += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
+	isp->isp_result = base;
+	if (IS_FC(isp)) {
+		base += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
+		FCPARAM(isp)->isp_scratch = base;
 	}
-	fcp->isp_scdma = isp->isp_scdmap->dm_segs[0].ds_addr;
 	return (0);
+
 dmafail:
 	isp_prt(isp, ISP_LOGERR, "mailbox dma setup failure");
 	for (i = 0; i < isp->isp_maxcmds; i++) {
@@ -1101,17 +1299,17 @@ dmafail:
 	return (1);
 }
 
-static int
+int
 isp_pci_dmasetup(struct ispsoftc *isp, XS_T *xs, ispreq_t *rq,
-    u_int16_t *nxtip, u_int16_t optr)
+    u_int32_t *nxtip, u_int32_t optr)
 {
 	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	bus_dmamap_t dmap;
-	u_int16_t starti = isp->isp_reqidx, nxti = *nxtip;
+	u_int16_t nxti = *nxtip;
 	ispreq_t *qep;
 	int segcnt, seg, error, ovseg, seglim, drq;
 
-	qep = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, starti);
+	qep = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, isp->isp_reqidx);
 	dmap = pcs->pci_xfer_dmap[isp_handle_index(rq->req_handle)];
 	if (xs->datalen == 0) {
 		rq->req_seg_count = 1;
@@ -1222,17 +1420,37 @@ mbxsync:
 		    (ispextreq_t *)qep);
 		break;
 	case RQSTYPE_T2RQS:
-		isp_put_request_t2(isp, (ispreqt2_t *) rq, (ispreqt2_t *) qep);
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_put_request_t2e(isp,
+			    (ispreqt2e_t *) rq, (ispreqt2e_t *) qep);
+		} else {
+			isp_put_request_t2(isp,
+			    (ispreqt2_t *) rq, (ispreqt2_t *) qep);
+		}
+		break;
+	case RQSTYPE_T3RQS:
+		if (FCPARAM(isp)->isp_2klogin) {
+			isp_put_request_t3e(isp,
+			    (ispreqt3e_t *) rq, (ispreqt3e_t *) qep);
+			break;
+		}
+		/* FALLTHROUGH */
+	case RQSTYPE_A64:
+		isp_put_request_t3(isp, (ispreqt3_t *) rq, (ispreqt3_t *) qep);
+		break;
+	case RQSTYPE_T7RQS:
+		isp_put_request_t7(isp, (ispreqt7_t *) rq, (ispreqt7_t *) qep);
 		break;
 	}
 	*nxtip = nxti;
 	return (CMD_QUEUED);
 }
 
-static int
+int
 isp_pci_intr(void *arg)
 {
-	u_int16_t isr, sema, mbox;
+	u_int32_t isr;
+	u_int16_t sema, mbox;
 	struct ispsoftc *isp = (struct ispsoftc *)arg;
 
 	isp->isp_intcnt++;
@@ -1247,8 +1465,8 @@ isp_pci_intr(void *arg)
 	}
 }
 
-static void
-isp_pci_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
+void
+isp_pci_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int32_t handle)
 {
 	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	bus_dmamap_t dmap = pcs->pci_xfer_dmap[isp_handle_index(handle)];
@@ -1258,22 +1476,39 @@ isp_pci_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
 	bus_dmamap_unload(isp->isp_dmatag, dmap);
 }
 
-static void
+void
+isp_pci_reset0(ispsoftc_t *isp)
+{
+	ISP_DISABLE_INTS(isp);
+}
+
+void
 isp_pci_reset1(struct ispsoftc *isp)
 {
-	/* Make sure the BIOS is disabled */
-	isp_pci_wr_reg(isp, HCCR, PCI_HCCR_CMD_BIOS);
-	if (isp->isp_osinfo.no_mbox_ints == 0) {
-		ENABLE_INTS(isp);
+	if (!IS_24XX(isp)) {
+		/* Make sure the BIOS is disabled */
+		isp_pci_wr_reg(isp, HCCR, PCI_HCCR_CMD_BIOS);
 	}
+	/* and enable interrupts */
+	ISP_ENABLE_INTS(isp);
 }
 
-static void
+void
 isp_pci_dumpregs(struct ispsoftc *isp, const char *msg)
 {
 	struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
 	if (msg)
                 isp_prt(isp, ISP_LOGERR, "%s", msg);
+	if (IS_SCSI(isp))
+		isp_prt(isp, ISP_LOGERR, "    biu_conf1=%x",
+		    ISP_READ(isp, BIU_CONF1));
+	else
+		isp_prt(isp, ISP_LOGERR, "    biu_csr=%x",
+		    ISP_READ(isp, BIU2100_CSR));
+	isp_prt(isp, ISP_LOGERR, " biu_icr=%x biu_isr=%x biu_sema=%x ",
+	    ISP_READ(isp, BIU_ICR), ISP_READ(isp, BIU_ISR),
+	    ISP_READ(isp, BIU_SEMA));
+	isp_prt(isp, ISP_LOGERR, "risc_hccr=%x\n", ISP_READ(isp, HCCR));
 	isp_prt(isp, ISP_LOGERR, "PCI Status Command/Status=%x\n",
 	    pci_conf_read(pcs->pci_pc, pcs->pci_tag, PCI_COMMAND_STATUS_REG));
 }
diff --git a/sys/dev/sbus/isp_sbus.c b/sys/dev/sbus/isp_sbus.c
index 1d5007770cd..a92dfaebc20 100644
--- a/sys/dev/sbus/isp_sbus.c
+++ b/sys/dev/sbus/isp_sbus.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: isp_sbus.c,v 1.12 2008/06/01 15:49:25 kettenis Exp $	*/
+/*	$OpenBSD: isp_sbus.c,v 1.13 2009/06/24 11:00:53 krw Exp $	*/
 /* $NetBSD: isp_sbus.c,v 1.46 2001/09/26 20:53:14 eeh Exp $ */
 
 /*
@@ -79,13 +79,13 @@
 
 static int isp_sbus_intr(void *);
 static int
-isp_sbus_rd_isr(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
-static u_int16_t isp_sbus_rd_reg(struct ispsoftc *, int);
-static void isp_sbus_wr_reg (struct ispsoftc *, int, u_int16_t);
+isp_sbus_rd_isr(struct ispsoftc *, u_int32_t *, u_int16_t *, u_int16_t *);
+static u_int32_t isp_sbus_rd_reg(struct ispsoftc *, int);
+static void isp_sbus_wr_reg (struct ispsoftc *, int, u_int32_t);
 static int isp_sbus_mbxdma(struct ispsoftc *);
-static int isp_sbus_dmasetup(struct ispsoftc *, XS_T *, ispreq_t *, u_int16_t *,
-    u_int16_t);
-static void isp_sbus_dmateardown(struct ispsoftc *, XS_T *, u_int16_t);
+static int isp_sbus_dmasetup(struct ispsoftc *, XS_T *, ispreq_t *, u_int32_t *,
+    u_int32_t);
+static void isp_sbus_dmateardown(struct ispsoftc *, XS_T *, u_int32_t);
 
 #ifndef	ISP_1000_RISC_CODE
 #define	ISP_1000_RISC_CODE	NULL
@@ -283,7 +283,7 @@ isp_sbus_attach(struct device *parent, struct device *self, void *aux)
 		ISP_UNLOCK(isp);
 		return;
 	}
-	ENABLE_INTS(isp);
+	ISP_ENABLE_INTS(isp);
 	isp_init(isp);
 	if (isp->isp_state != ISP_INITSTATE) {
 		isp_uninit(isp);
@@ -306,7 +306,8 @@ isp_sbus_attach(struct device *parent, struct device *self, void *aux)
 static int
 isp_sbus_intr(void *arg)
 {
-	u_int16_t isr, sema, mbox;
+	u_int32_t isr;
+	u_int16_t sema, mbox;
 	struct ispsoftc *isp = arg;
 
 	isp->isp_intcnt++;
@@ -329,7 +330,7 @@ isp_sbus_intr(void *arg)
 	bus_space_read_2(sbc->sbus_bustag, sbc->sbus_reg, off)
 
 static int
-isp_sbus_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
+isp_sbus_rd_isr(struct ispsoftc *isp, u_int32_t *isrp,
     u_int16_t *semap, u_int16_t *mbp)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
@@ -350,7 +351,7 @@ isp_sbus_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
 	return (1);
 }
 
-static u_int16_t
+static u_int32_t
 isp_sbus_rd_reg(struct ispsoftc *isp, int regoff)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
@@ -360,7 +361,7 @@ isp_sbus_rd_reg(struct ispsoftc *isp, int regoff)
 }
 
 static void
-isp_sbus_wr_reg(struct ispsoftc *isp, int regoff, u_int16_t val)
+isp_sbus_wr_reg(struct ispsoftc *isp, int regoff, u_int32_t val)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
 	int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT];
@@ -372,10 +373,12 @@ static int
 isp_sbus_mbxdma(struct ispsoftc *isp)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
-	bus_dma_segment_t reqseg, rspseg;
-	int reqrs, rsprs, i, progress;
-	size_t n;
+	bus_dma_segment_t seg;
+	bus_addr_t addr;
 	bus_size_t len;
+	caddr_t base;
+	size_t n;
+	int rs, i, progress;
 
 	if (isp->isp_rquest_dma)
 		return (0);
@@ -420,81 +423,51 @@ isp_sbus_mbxdma(struct ispsoftc *isp)
 	 */
 	progress = 0;
 	len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
-	if (bus_dmamem_alloc(isp->isp_dmatag, len, 0, 0, &reqseg, 1, &reqrs,
+	len += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
+	if (bus_dmamem_alloc(isp->isp_dmatag, len, 0, 0, &seg, 1, &rs,
 	    BUS_DMA_NOWAIT)) {
 		goto dmafail;
 	}
 	progress++;
-	if (bus_dmamem_map(isp->isp_dmatag, &reqseg, reqrs, len,
-	    (caddr_t *)&isp->isp_rquest, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
+	if (bus_dmamem_map(isp->isp_dmatag, &seg, rs, len,
+	    &base, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
 		goto dmafail;
 	}
 	progress++;
 	if (bus_dmamap_create(isp->isp_dmatag, len, 1, len, 0, BUS_DMA_NOWAIT,
-	    &isp->isp_rqdmap) != 0) {
-		goto dmafail;
-	}
-	progress++;
-	if (bus_dmamap_load(isp->isp_dmatag, isp->isp_rqdmap,
-	    isp->isp_rquest, len, NULL, BUS_DMA_NOWAIT) != 0) {
-		goto dmafail;
-	}
-	progress++;
-	isp->isp_rquest_dma = isp->isp_rqdmap->dm_segs[0].ds_addr;
-
-	len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
-	if (bus_dmamem_alloc(isp->isp_dmatag, len, 0, 0, &rspseg, 1, &rsprs,
-	    BUS_DMA_NOWAIT)) {
-		goto dmafail;
-	}
-	progress++;
-	if (bus_dmamem_map(isp->isp_dmatag, &rspseg, rsprs, len,
-	    (caddr_t *)&isp->isp_result, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
+	    &isp->isp_cdmap) != 0) {
 		goto dmafail;
 	}
 	progress++;
-	if (bus_dmamap_create(isp->isp_dmatag, len, 1, len, 0, BUS_DMA_NOWAIT,
-	    &isp->isp_rsdmap) != 0) {
+	if (bus_dmamap_load(isp->isp_dmatag, isp->isp_cdmap,
+	    base, len, NULL, BUS_DMA_NOWAIT) != 0) {
 		goto dmafail;
 	}
 	progress++;
-	if (bus_dmamap_load(isp->isp_dmatag, isp->isp_rsdmap,
-	    isp->isp_result, len, NULL, BUS_DMA_NOWAIT) != 0) {
-		goto dmafail;
-	}
-	isp->isp_result_dma = isp->isp_rsdmap->dm_segs[0].ds_addr;
-
+	addr = isp->isp_cdmap->dm_segs[0].ds_addr;
+	isp->isp_rquest_dma = addr;
+	addr += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
+	isp->isp_result_dma = addr;
+
+	isp->isp_rquest = base;
+	base += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
+	isp->isp_result = base;
 	return (0);
 
 dmafail:
 	isp_prt(isp, ISP_LOGERR, "Mailbox DMA Setup Failure");
 
-	if (progress >= 8) {
-		bus_dmamap_unload(isp->isp_dmatag, isp->isp_rsdmap);
-	}
-	if (progress >= 7) {
-		bus_dmamap_destroy(isp->isp_dmatag, isp->isp_rsdmap);
-	}
-	if (progress >= 6) {
-		bus_dmamem_unmap(isp->isp_dmatag,
-		    isp->isp_result, ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp)));
-	}
-	if (progress >= 5) {
-		bus_dmamem_free(isp->isp_dmatag, &rspseg, rsprs);
-	}
-
 	if (progress >= 4) {
-		bus_dmamap_unload(isp->isp_dmatag, isp->isp_rqdmap);
+		bus_dmamap_unload(isp->isp_dmatag, isp->isp_cdmap);
 	}
 	if (progress >= 3) {
-		bus_dmamap_destroy(isp->isp_dmatag, isp->isp_rqdmap);
+		bus_dmamap_destroy(isp->isp_dmatag, isp->isp_cdmap);
 	}
 	if (progress >= 2) {
-		bus_dmamem_unmap(isp->isp_dmatag,
-		    isp->isp_rquest, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
+		bus_dmamem_unmap(isp->isp_dmatag, isp->isp_rquest, len);
 	}
 	if (progress >= 1) {
-		bus_dmamem_free(isp->isp_dmatag, &reqseg, reqrs);
+		bus_dmamem_free(isp->isp_dmatag, &seg, rs);
 	}
 
 	for (i = 0; i < isp->isp_maxcmds; i++) {
@@ -514,7 +487,7 @@ dmafail:
 
 static int
 isp_sbus_dmasetup(struct ispsoftc *isp, XS_T *xs, ispreq_t *rq,
-    u_int16_t *nxtip, u_int16_t optr)
+    u_int32_t *nxtip, u_int32_t optr)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
 	bus_dmamap_t dmap;
@@ -587,7 +560,7 @@ mbxsync:
 }
 
 static void
-isp_sbus_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
+isp_sbus_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int32_t handle)
 {
 	struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
 	bus_dmamap_t dmap;