xref: /freebsd/sys/dev/isp/isp.c (revision f37852c17391fdf0e8309bcf684384dd0d854e43)
1 /*-
2  *  Copyright (c) 2009-2017 Alexander Motin <mav@FreeBSD.org>
3  *  Copyright (c) 1997-2009 by Matthew Jacob
4  *  All rights reserved.
5  *
6  *  Redistribution and use in source and binary forms, with or without
7  *  modification, are permitted provided that the following conditions
8  *  are met:
9  *
10  *  1. Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer.
12  *  2. Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution.
15  *
16  *  THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  *  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  *  ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
20  *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  *  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  *  OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  *  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  *  OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  *  SUCH DAMAGE.
27  *
28  */
29 
30 /*
31  * Machine and OS Independent (well, as best as possible)
32  * code for the Qlogic ISP SCSI and FC-SCSI adapters.
33  */
34 
35 /*
36  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
37  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
38  * ideas dredged from the Solaris driver.
39  */
40 
41 /*
42  * Include header file appropriate for platform we're building on.
43  */
44 #ifdef	__NetBSD__
45 #include <sys/cdefs.h>
46 __KERNEL_RCSID(0, "$NetBSD$");
47 #include <dev/ic/isp_netbsd.h>
48 #endif
49 #ifdef	__FreeBSD__
50 #include <sys/cdefs.h>
51 __FBSDID("$FreeBSD$");
52 #include <dev/isp/isp_freebsd.h>
53 #endif
54 #ifdef	__OpenBSD__
55 #include <dev/ic/isp_openbsd.h>
56 #endif
57 #ifdef	__linux__
58 #include "isp_linux.h"
59 #endif
60 #ifdef	__svr4__
61 #include "isp_solaris.h"
62 #endif
63 
64 /*
65  * General defines
66  */
67 #define	MBOX_DELAY_COUNT	1000000 / 100
68 
69 /*
70  * Local static data
71  */
72 static const char notresp[] = "Unknown IOCB in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
73 static const char bun[] = "bad underrun (count %d, resid %d, status %s)";
74 static const char lipd[] = "Chan %d LIP destroyed %d active commands";
75 static const char sacq[] = "unable to acquire scratch area";
76 
77 static const uint8_t alpa_map[] = {
78 	0xef, 0xe8, 0xe4, 0xe2, 0xe1, 0xe0, 0xdc, 0xda,
79 	0xd9, 0xd6, 0xd5, 0xd4, 0xd3, 0xd2, 0xd1, 0xce,
80 	0xcd, 0xcc, 0xcb, 0xca, 0xc9, 0xc7, 0xc6, 0xc5,
81 	0xc3, 0xbc, 0xba, 0xb9, 0xb6, 0xb5, 0xb4, 0xb3,
82 	0xb2, 0xb1, 0xae, 0xad, 0xac, 0xab, 0xaa, 0xa9,
83 	0xa7, 0xa6, 0xa5, 0xa3, 0x9f, 0x9e, 0x9d, 0x9b,
84 	0x98, 0x97, 0x90, 0x8f, 0x88, 0x84, 0x82, 0x81,
85 	0x80, 0x7c, 0x7a, 0x79, 0x76, 0x75, 0x74, 0x73,
86 	0x72, 0x71, 0x6e, 0x6d, 0x6c, 0x6b, 0x6a, 0x69,
87 	0x67, 0x66, 0x65, 0x63, 0x5c, 0x5a, 0x59, 0x56,
88 	0x55, 0x54, 0x53, 0x52, 0x51, 0x4e, 0x4d, 0x4c,
89 	0x4b, 0x4a, 0x49, 0x47, 0x46, 0x45, 0x43, 0x3c,
90 	0x3a, 0x39, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31,
91 	0x2e, 0x2d, 0x2c, 0x2b, 0x2a, 0x29, 0x27, 0x26,
92 	0x25, 0x23, 0x1f, 0x1e, 0x1d, 0x1b, 0x18, 0x17,
93 	0x10, 0x0f, 0x08, 0x04, 0x02, 0x01, 0x00
94 };
95 
96 /*
97  * Local function prototypes.
98  */
99 static void isp_parse_async(ispsoftc_t *, uint16_t);
100 static void isp_parse_async_fc(ispsoftc_t *, uint16_t);
101 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *, uint32_t *);
102 static void isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, uint32_t *);
103 static void isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, uint32_t *);
104 static void isp_fastpost_complete(ispsoftc_t *, uint32_t);
105 static void isp_scsi_init(ispsoftc_t *);
106 static void isp_scsi_channel_init(ispsoftc_t *, int);
107 static void isp_fibre_init(ispsoftc_t *);
108 static void isp_fibre_init_2400(ispsoftc_t *);
109 static void isp_clear_portdb(ispsoftc_t *, int);
110 static void isp_mark_portdb(ispsoftc_t *, int);
111 static int isp_plogx(ispsoftc_t *, int, uint16_t, uint32_t, int);
112 static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
113 static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
114 static int isp_getpdb(ispsoftc_t *, int, uint16_t, isp_pdb_t *);
115 static int isp_gethandles(ispsoftc_t *, int, uint16_t *, int *, int);
116 static void isp_dump_chip_portdb(ispsoftc_t *, int);
117 static uint64_t isp_get_wwn(ispsoftc_t *, int, int, int);
118 static int isp_fclink_test(ispsoftc_t *, int, int);
119 static int isp_pdb_sync(ispsoftc_t *, int);
120 static int isp_scan_loop(ispsoftc_t *, int);
121 static int isp_gid_pt(ispsoftc_t *, int);
122 static int isp_scan_fabric(ispsoftc_t *, int);
123 static int isp_login_device(ispsoftc_t *, int, uint32_t, isp_pdb_t *, uint16_t *);
124 static int isp_send_change_request(ispsoftc_t *, int);
125 static int isp_register_fc4_type(ispsoftc_t *, int);
126 static int isp_register_fc4_features_24xx(ispsoftc_t *, int);
127 static int isp_register_port_name_24xx(ispsoftc_t *, int);
128 static int isp_register_node_name_24xx(ispsoftc_t *, int);
129 static uint16_t isp_next_handle(ispsoftc_t *, uint16_t *);
130 static int isp_fw_state(ispsoftc_t *, int);
131 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
132 
133 static void isp_spi_update(ispsoftc_t *, int);
134 static void isp_setdfltsdparm(ispsoftc_t *);
135 static void isp_setdfltfcparm(ispsoftc_t *, int);
136 static int isp_read_nvram(ispsoftc_t *, int);
137 static int isp_read_nvram_2400(ispsoftc_t *, uint8_t *);
138 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
139 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
140 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
141 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
142 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
143 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
144 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
145 
146 static void
147 isp_change_fw_state(ispsoftc_t *isp, int chan, int state)
148 {
149 	fcparam *fcp = FCPARAM(isp, chan);
150 
151 	if (fcp->isp_fwstate == state)
152 		return;
153 	isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG,
154 	    "Chan %d Firmware state <%s->%s>", chan,
155 	    isp_fc_fw_statename(fcp->isp_fwstate), isp_fc_fw_statename(state));
156 	fcp->isp_fwstate = state;
157 }
158 
159 /*
160  * Reset Hardware.
161  *
162  * Hit the chip over the head, download new f/w if available and set it running.
163  *
164  * Locking done elsewhere.
165  */
166 
167 void
168 isp_reset(ispsoftc_t *isp, int do_load_defaults)
169 {
170 	mbreg_t mbs;
171 	char *buf;
172 	uint64_t fwt;
173 	uint32_t code_org, val;
174 	int loops, i, dodnld = 1;
175 	const char *btype = "????";
176 	static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
177 
178 	/*
179 	 * Basic types (SCSI, FibreChannel and PCI or SBus)
180 	 * have been set in the MD code. We figure out more
181 	 * here. Possibly more refined types based upon PCI
182 	 * identification. Chip revision has been gathered.
183 	 *
184 	 * After we've fired this chip up, zero out the conf1 register
185 	 * for SCSI adapters and do other settings for the 2100.
186 	 */
187 
188 	isp->isp_state = ISP_NILSTATE;
189 	ISP_DISABLE_INTS(isp);
190 
191 	/*
192 	 * Put the board into PAUSE mode (so we can read the SXP registers
193 	 * or write FPM/FBM registers).
194 	 */
195 	if (IS_24XX(isp)) {
196 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
197 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
198 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
199 	} else {
200 		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
201 	}
202 
203 	if (IS_FC(isp)) {
204 		switch (isp->isp_type) {
205 		case ISP_HA_FC_2100:
206 			btype = "2100";
207 			break;
208 		case ISP_HA_FC_2200:
209 			btype = "2200";
210 			break;
211 		case ISP_HA_FC_2300:
212 			btype = "2300";
213 			break;
214 		case ISP_HA_FC_2312:
215 			btype = "2312";
216 			break;
217 		case ISP_HA_FC_2322:
218 			btype = "2322";
219 			break;
220 		case ISP_HA_FC_2400:
221 			btype = "2422";
222 			break;
223 		case ISP_HA_FC_2500:
224 			btype = "2532";
225 			break;
226 		case ISP_HA_FC_2600:
227 			btype = "2031";
228 			break;
229 		default:
230 			break;
231 		}
232 
233 		if (!IS_24XX(isp)) {
234 			/*
235 			 * While we're paused, reset the FPM module and FBM
236 			 * fifos.
237 			 */
238 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
239 			ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
240 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
241 			ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
242 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
243 		}
244 	} else if (IS_1240(isp)) {
245 		sdparam *sdp;
246 
247 		btype = "1240";
248 		isp->isp_clock = 60;
249 		sdp = SDPARAM(isp, 0);
250 		sdp->isp_ultramode = 1;
251 		sdp = SDPARAM(isp, 1);
252 		sdp->isp_ultramode = 1;
253 		/*
254 		 * XXX: Should probably do some bus sensing.
255 		 */
256 	} else if (IS_ULTRA3(isp)) {
257 		sdparam *sdp = isp->isp_param;
258 
259 		isp->isp_clock = 100;
260 
261 		if (IS_10160(isp))
262 			btype = "10160";
263 		else if (IS_12160(isp))
264 			btype = "12160";
265 		else
266 			btype = "<UNKLVD>";
267 		sdp->isp_lvdmode = 1;
268 
269 		if (IS_DUALBUS(isp)) {
270 			sdp++;
271 			sdp->isp_lvdmode = 1;
272 		}
273 	} else if (IS_ULTRA2(isp)) {
274 		static const char m[] = "bus %d is in %s Mode";
275 		uint16_t l;
276 		sdparam *sdp = SDPARAM(isp, 0);
277 
278 		isp->isp_clock = 100;
279 
280 		if (IS_1280(isp))
281 			btype = "1280";
282 		else if (IS_1080(isp))
283 			btype = "1080";
284 		else
285 			btype = "<UNKLVD>";
286 
287 		l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
288 		switch (l) {
289 		case ISP1080_LVD_MODE:
290 			sdp->isp_lvdmode = 1;
291 			isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
292 			break;
293 		case ISP1080_HVD_MODE:
294 			sdp->isp_diffmode = 1;
295 			isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
296 			break;
297 		case ISP1080_SE_MODE:
298 			sdp->isp_ultramode = 1;
299 			isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
300 			break;
301 		default:
302 			isp_prt(isp, ISP_LOGERR,
303 			    "unknown mode on bus %d (0x%x)", 0, l);
304 			break;
305 		}
306 
307 		if (IS_DUALBUS(isp)) {
308 			sdp = SDPARAM(isp, 1);
309 			l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
310 			l &= ISP1080_MODE_MASK;
311 			switch (l) {
312 			case ISP1080_LVD_MODE:
313 				sdp->isp_lvdmode = 1;
314 				isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
315 				break;
316 			case ISP1080_HVD_MODE:
317 				sdp->isp_diffmode = 1;
318 				isp_prt(isp, ISP_LOGCONFIG,
319 				    m, 1, "Differential");
320 				break;
321 			case ISP1080_SE_MODE:
322 				sdp->isp_ultramode = 1;
323 				isp_prt(isp, ISP_LOGCONFIG,
324 				    m, 1, "Single-Ended");
325 				break;
326 			default:
327 				isp_prt(isp, ISP_LOGERR,
328 				    "unknown mode on bus %d (0x%x)", 1, l);
329 				break;
330 			}
331 		}
332 	} else {
333 		sdparam *sdp = SDPARAM(isp, 0);
334 		i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
335 		switch (i) {
336 		default:
337 			isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
338 			/* FALLTHROUGH */
339 		case 1:
340 			btype = "1020";
341 			isp->isp_type = ISP_HA_SCSI_1020;
342 			isp->isp_clock = 40;
343 			break;
344 		case 2:
345 			/*
346 			 * Some 1020A chips are Ultra Capable, but don't
347 			 * run the clock rate up for that unless told to
348 			 * do so by the Ultra Capable bits being set.
349 			 */
350 			btype = "1020A";
351 			isp->isp_type = ISP_HA_SCSI_1020A;
352 			isp->isp_clock = 40;
353 			break;
354 		case 3:
355 			btype = "1040";
356 			isp->isp_type = ISP_HA_SCSI_1040;
357 			isp->isp_clock = 60;
358 			break;
359 		case 4:
360 			btype = "1040A";
361 			isp->isp_type = ISP_HA_SCSI_1040A;
362 			isp->isp_clock = 60;
363 			break;
364 		case 5:
365 			btype = "1040B";
366 			isp->isp_type = ISP_HA_SCSI_1040B;
367 			isp->isp_clock = 60;
368 			break;
369 		case 6:
370 			btype = "1040C";
371 			isp->isp_type = ISP_HA_SCSI_1040C;
372 			isp->isp_clock = 60;
373                         break;
374 		}
375 		/*
376 		 * Now, while we're at it, gather info about ultra
377 		 * and/or differential mode.
378 		 */
379 		if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
380 			isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
381 			sdp->isp_diffmode = 1;
382 		} else {
383 			sdp->isp_diffmode = 0;
384 		}
385 		i = ISP_READ(isp, RISC_PSR);
386 		if (isp->isp_bustype == ISP_BT_SBUS) {
387 			i &= RISC_PSR_SBUS_ULTRA;
388 		} else {
389 			i &= RISC_PSR_PCI_ULTRA;
390 		}
391 		if (i != 0) {
392 			isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
393 			sdp->isp_ultramode = 1;
394 			/*
395 			 * If we're in Ultra Mode, we have to be 60MHz clock-
396 			 * even for the SBus version.
397 			 */
398 			isp->isp_clock = 60;
399 		} else {
400 			sdp->isp_ultramode = 0;
401 			/*
402 			 * Clock is known. Gronk.
403 			 */
404 		}
405 
406 		/*
407 		 * Machine dependent clock (if set) overrides
408 		 * our generic determinations.
409 		 */
410 		if (isp->isp_mdvec->dv_clock) {
411 			if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
412 				isp->isp_clock = isp->isp_mdvec->dv_clock;
413 			}
414 		}
415 	}
416 
417 	/*
418 	 * Hit the chip over the head with hammer,
419 	 * and give it a chance to recover.
420 	 */
421 
422 	if (IS_SCSI(isp)) {
423 		ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
424 		/*
425 		 * A slight delay...
426 		 */
427 		ISP_DELAY(100);
428 
429 		/*
430 		 * Clear data && control DMA engines.
431 		 */
432 		ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
433 		ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
434 
435 
436 	} else if (IS_24XX(isp)) {
437 		/*
438 		 * Stop DMA and wait for it to stop.
439 		 */
440 		ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
441 		for (val = loops = 0; loops < 30000; loops++) {
442 			ISP_DELAY(10);
443 			val = ISP_READ(isp, BIU2400_CSR);
444 			if ((val & BIU2400_DMA_ACTIVE) == 0) {
445 				break;
446 			}
447 		}
448 		if (val & BIU2400_DMA_ACTIVE) {
449 			isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
450 			return;
451 		}
452 		/*
453 		 * Hold it in SOFT_RESET and STOP state for 100us.
454 		 */
455 		ISP_WRITE(isp, BIU2400_CSR, BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
456 		ISP_DELAY(100);
457 		for (loops = 0; loops < 10000; loops++) {
458 			ISP_DELAY(5);
459 			val = ISP_READ(isp, OUTMAILBOX0);
460 		}
461 		for (val = loops = 0; loops < 500000; loops ++) {
462 			val = ISP_READ(isp, BIU2400_CSR);
463 			if ((val & BIU2400_SOFT_RESET) == 0) {
464 				break;
465 			}
466 		}
467 		if (val & BIU2400_SOFT_RESET) {
468 			isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
469 			return;
470 		}
471 	} else {
472 		ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
473 		/*
474 		 * A slight delay...
475 		 */
476 		ISP_DELAY(100);
477 
478 		/*
479 		 * Clear data && control DMA engines.
480 		 */
481 		ISP_WRITE(isp, CDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
482 		ISP_WRITE(isp, TDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
483 		ISP_WRITE(isp, RDMA2100_CONTROL, DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
484 	}
485 
486 	/*
487 	 * Wait for ISP to be ready to go...
488 	 */
489 	loops = MBOX_DELAY_COUNT;
490 	for (;;) {
491 		if (IS_SCSI(isp)) {
492 			if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
493 				break;
494 			}
495 		} else if (IS_24XX(isp)) {
496 			if (ISP_READ(isp, OUTMAILBOX0) == 0) {
497 				break;
498 			}
499 		} else {
500 			if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
501 				break;
502 		}
503 		ISP_DELAY(100);
504 		if (--loops < 0) {
505 			ISP_DUMPREGS(isp, "chip reset timed out");
506 			return;
507 		}
508 	}
509 
510 	/*
511 	 * After we've fired this chip up, zero out the conf1 register
512 	 * for SCSI adapters and other settings for the 2100.
513 	 */
514 
515 	if (IS_SCSI(isp)) {
516 		ISP_WRITE(isp, BIU_CONF1, 0);
517 	} else if (!IS_24XX(isp)) {
518 		ISP_WRITE(isp, BIU2100_CSR, 0);
519 	}
520 
521 	/*
522 	 * Reset RISC Processor
523 	 */
524 	if (IS_24XX(isp)) {
525 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
526 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
527 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
528 	} else {
529 		ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
530 		ISP_DELAY(100);
531 		ISP_WRITE(isp, BIU_SEMA, 0);
532 	}
533 
534 	/*
535 	 * Post-RISC Reset stuff.
536 	 */
537 	if (IS_24XX(isp)) {
538 		for (val = loops = 0; loops < 5000000; loops++) {
539 			ISP_DELAY(5);
540 			val = ISP_READ(isp, OUTMAILBOX0);
541 			if (val == 0) {
542 				break;
543 			}
544 		}
545 		if (val != 0) {
546 			isp_prt(isp, ISP_LOGERR, "reset didn't clear");
547 			return;
548 		}
549 	} else if (IS_SCSI(isp)) {
550 		uint16_t tmp = isp->isp_mdvec->dv_conf1;
551 		/*
552 		 * Busted FIFO. Turn off all but burst enables.
553 		 */
554 		if (isp->isp_type == ISP_HA_SCSI_1040A) {
555 			tmp &= BIU_BURST_ENABLE;
556 		}
557 		ISP_SETBITS(isp, BIU_CONF1, tmp);
558 		if (tmp & BIU_BURST_ENABLE) {
559 			ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
560 			ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
561 		}
562 		if (SDPARAM(isp, 0)->isp_ptisp) {
563 			if (SDPARAM(isp, 0)->isp_ultramode) {
564 				while (ISP_READ(isp, RISC_MTR) != 0x1313) {
565 					ISP_WRITE(isp, RISC_MTR, 0x1313);
566 					ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
567 				}
568 			} else {
569 				ISP_WRITE(isp, RISC_MTR, 0x1212);
570 			}
571 			/*
572 			 * PTI specific register
573 			 */
574 			ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
575 		} else {
576 			ISP_WRITE(isp, RISC_MTR, 0x1212);
577 		}
578 		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
579 	} else {
580 		ISP_WRITE(isp, RISC_MTR2100, 0x1212);
581 		if (IS_2200(isp) || IS_23XX(isp)) {
582 			ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
583 		}
584 		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
585 	}
586 
587 	/*
588 	 * Set up default request/response queue in-pointer/out-pointer
589 	 * register indices.
590 	 */
591 	if (IS_24XX(isp)) {
592 		isp->isp_rqstinrp = BIU2400_REQINP;
593 		isp->isp_rqstoutrp = BIU2400_REQOUTP;
594 		isp->isp_respinrp = BIU2400_RSPINP;
595 		isp->isp_respoutrp = BIU2400_RSPOUTP;
596 	} else if (IS_23XX(isp)) {
597 		isp->isp_rqstinrp = BIU_REQINP;
598 		isp->isp_rqstoutrp = BIU_REQOUTP;
599 		isp->isp_respinrp = BIU_RSPINP;
600 		isp->isp_respoutrp = BIU_RSPOUTP;
601 	} else {
602 		isp->isp_rqstinrp = INMAILBOX4;
603 		isp->isp_rqstoutrp = OUTMAILBOX4;
604 		isp->isp_respinrp = OUTMAILBOX5;
605 		isp->isp_respoutrp = INMAILBOX5;
606 	}
607 	ISP_WRITE(isp, isp->isp_rqstinrp, 0);
608 	ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
609 	ISP_WRITE(isp, isp->isp_respinrp, 0);
610 	ISP_WRITE(isp, isp->isp_respoutrp, 0);
611 	if (IS_24XX(isp)) {
612 		if (!IS_26XX(isp)) {
613 			ISP_WRITE(isp, BIU2400_PRI_REQINP, 0);
614 			ISP_WRITE(isp, BIU2400_PRI_REQOUTP, 0);
615 		}
616 		ISP_WRITE(isp, BIU2400_ATIO_RSPINP, 0);
617 		ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, 0);
618 	}
619 
620 	if (!IS_24XX(isp) && isp->isp_bustype == ISP_BT_PCI) {
621 		/* Make sure the BIOS is disabled */
622 		ISP_WRITE(isp, HCCR, PCI_HCCR_CMD_BIOS);
623 	}
624 
625 	/*
626 	 * Wait for everything to finish firing up.
627 	 *
628 	 * Avoid doing this on early 2312s because you can generate a PCI
629 	 * parity error (chip breakage).
630 	 */
631 	if (IS_2312(isp) && isp->isp_revision < 2) {
632 		ISP_DELAY(100);
633 	} else {
634 		loops = MBOX_DELAY_COUNT;
635 		while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
636 			ISP_DELAY(100);
637 			if (--loops < 0) {
638 				isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
639 				return;
640 			}
641 		}
642 	}
643 
644 	/*
645 	 * Up until this point we've done everything by just reading or
646 	 * setting registers. From this point on we rely on at least *some*
647 	 * kind of firmware running in the card.
648 	 */
649 
650 	/*
651 	 * Do some sanity checking by running a NOP command.
652 	 * If it succeeds, the ROM firmware is now running.
653 	 */
654 	MBSINIT(&mbs, MBOX_NO_OP, MBLOGALL, 0);
655 	isp_mboxcmd(isp, &mbs);
656 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
657 		isp_prt(isp, ISP_LOGERR, "NOP command failed (%x)", mbs.param[0]);
658 		return;
659 	}
660 
661 	/*
662 	 * Do some operational tests
663 	 */
664 	if (IS_SCSI(isp) || IS_24XX(isp)) {
665 		static const uint16_t patterns[MAX_MAILBOX] = {
666 			0x0000, 0xdead, 0xbeef, 0xffff,
667 			0xa5a5, 0x5a5a, 0x7f7f, 0x7ff7,
668 			0x3421, 0xabcd, 0xdcba, 0xfeef,
669 			0xbead, 0xdebe, 0x2222, 0x3333,
670 			0x5555, 0x6666, 0x7777, 0xaaaa,
671 			0xffff, 0xdddd, 0x9999, 0x1fbc,
672 			0x6666, 0x6677, 0x1122, 0x33ff,
673 			0x0000, 0x0001, 0x1000, 0x1010,
674 		};
675 		int nmbox = ISP_NMBOX(isp);
676 		if (IS_SCSI(isp))
677 			nmbox = 6;
678 		MBSINIT(&mbs, MBOX_MAILBOX_REG_TEST, MBLOGALL, 0);
679 		for (i = 1; i < nmbox; i++) {
680 			mbs.param[i] = patterns[i];
681 		}
682 		isp_mboxcmd(isp, &mbs);
683 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
684 			return;
685 		}
686 		for (i = 1; i < nmbox; i++) {
687 			if (mbs.param[i] != patterns[i]) {
688 				isp_prt(isp, ISP_LOGERR, "Register Test Failed at Register %d: should have 0x%04x but got 0x%04x", i, patterns[i], mbs.param[i]);
689 				return;
690 			}
691 		}
692 	}
693 
694 	/*
695 	 * Download new Firmware, unless requested not to do so.
696 	 * This is made slightly trickier in some cases where the
697 	 * firmware of the ROM revision is newer than the revision
698 	 * compiled into the driver. So, where we used to compare
699 	 * versions of our f/w and the ROM f/w, now we just see
700 	 * whether we have f/w at all and whether a config flag
701 	 * has disabled our download.
702 	 */
703 	if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) {
704 		dodnld = 0;
705 	} else {
706 
707 		/*
708 		 * Set up DMA for the request and response queues.
709 		 * We do this now so we can use the request queue
710 		 * for dma to load firmware from.
711 		 */
712 		if (ISP_MBOXDMASETUP(isp) != 0) {
713 			isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
714 			return;
715 		}
716 	}
717 
718 	if (IS_24XX(isp)) {
719 		code_org = ISP_CODE_ORG_2400;
720 	} else if (IS_23XX(isp)) {
721 		code_org = ISP_CODE_ORG_2300;
722 	} else {
723 		code_org = ISP_CODE_ORG;
724 	}
725 
726 	isp->isp_loaded_fw = 0;
727 	if (dodnld && IS_24XX(isp)) {
728 		const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
729 		uint32_t la, wi, wl;
730 
731 		/*
732 		 * Keep loading until we run out of f/w.
733 		 */
734 		code_org = ptr[2];	/* 1st load address is our start addr */
735 
736 		for (;;) {
737 
738 			isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], ptr[2]);
739 
740 			wi = 0;
741 			la = ptr[2];
742 			wl = ptr[3];
743 			while (wi < ptr[3]) {
744 				uint32_t *cp;
745 				uint32_t nw;
746 
747 				nw = min(wl, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 4);
748 				cp = isp->isp_rquest;
749 				for (i = 0; i < nw; i++)
750 					ISP_IOXPUT_32(isp, ptr[wi + i], &cp[i]);
751 				MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
752 				MBSINIT(&mbs, MBOX_LOAD_RISC_RAM, MBLOGALL, 0);
753 				mbs.param[1] = la;
754 				mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
755 				mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
756 				mbs.param[4] = nw >> 16;
757 				mbs.param[5] = nw;
758 				mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
759 				mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
760 				mbs.param[8] = la >> 16;
761 				isp_prt(isp, ISP_LOGDEBUG0, "LOAD RISC RAM %u words at load address 0x%x", nw, la);
762 				isp_mboxcmd(isp, &mbs);
763 				if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
764 					isp_prt(isp, ISP_LOGERR, "F/W download failed");
765 					return;
766 				}
767 				la += nw;
768 				wi += nw;
769 				wl -= nw;
770 			}
771 
772 			if (ptr[1] == 0) {
773 				break;
774 			}
775 			ptr += ptr[3];
776 		}
777 		isp->isp_loaded_fw = 1;
778 	} else if (dodnld && IS_23XX(isp)) {
779 		const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
780 		uint16_t wi, wl, segno;
781 		uint32_t la;
782 
783 		la = code_org;
784 		segno = 0;
785 
786 		for (;;) {
787 			uint32_t nxtaddr;
788 
789 			isp_prt(isp, ISP_LOGDEBUG0, "load 0x%x words of code at load address 0x%x", ptr[3], la);
790 
791 			wi = 0;
792 			wl = ptr[3];
793 
794 			while (wi < ptr[3]) {
795 				uint16_t *cp;
796 				uint16_t nw;
797 
798 				nw = min(wl, min((1 << 15), ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) / 2));
799 				cp = isp->isp_rquest;
800 				for (i = 0; i < nw; i++)
801 					ISP_IOXPUT_16(isp, ptr[wi + i], &cp[i]);
802 				MEMORYBARRIER(isp, SYNC_REQUEST, 0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)), -1);
803 				MBSINIT(&mbs, 0, MBLOGALL, 0);
804 				if (la < 0x10000) {
805 					mbs.param[0] = MBOX_LOAD_RISC_RAM_2100;
806 					mbs.param[1] = la;
807 					mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
808 					mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
809 					mbs.param[4] = nw;
810 					mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
811 					mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
812 					isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM 2100 %u words at load address 0x%x\n", nw, la);
813 				} else {
814 					mbs.param[0] = MBOX_LOAD_RISC_RAM;
815 					mbs.param[1] = la;
816 					mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
817 					mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
818 					mbs.param[4] = nw;
819 					mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
820 					mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
821 					mbs.param[8] = la >> 16;
822 					isp_prt(isp, ISP_LOGDEBUG1, "LOAD RISC RAM %u words at load address 0x%x\n", nw, la);
823 				}
824 				isp_mboxcmd(isp, &mbs);
825 				if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
826 					isp_prt(isp, ISP_LOGERR, "F/W download failed");
827 					return;
828 				}
829 				la += nw;
830 				wi += nw;
831 				wl -= nw;
832 			}
833 
834 			if (!IS_2322(isp)) {
835 				break;
836 			}
837 
838 			if (++segno == 3) {
839 				break;
840 			}
841 
842 			/*
843 			 * If we're a 2322, the firmware actually comes in
844 			 * three chunks. We loaded the first at the code_org
845 			 * address. The other two chunks, which follow right
846 			 * after each other in memory here, get loaded at
847 			 * addresses specfied at offset 0x9..0xB.
848 			 */
849 
850 			nxtaddr = ptr[3];
851 			ptr = &ptr[nxtaddr];
852 			la = ptr[5] | ((ptr[4] & 0x3f) << 16);
853 		}
854 		isp->isp_loaded_fw = 1;
855 	} else if (dodnld) {
856 		const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
857 		u_int i, wl;
858 
859 		wl = ptr[3];
860 		isp_prt(isp, ISP_LOGDEBUG1,
861 		    "WRITE RAM %u words at load address 0x%x", wl, code_org);
862 		for (i = 0; i < wl; i++) {
863 			MBSINIT(&mbs, MBOX_WRITE_RAM_WORD, MBLOGNONE, 0);
864 			mbs.param[1] = code_org + i;
865 			mbs.param[2] = ptr[i];
866 			isp_mboxcmd(isp, &mbs);
867 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
868 				isp_prt(isp, ISP_LOGERR,
869 				    "F/W download failed at word %d", i);
870 				return;
871 			}
872 		}
873 	} else if (IS_26XX(isp)) {
874 		MBSINIT(&mbs, MBOX_LOAD_FLASH_FIRMWARE, MBLOGALL, 5000000);
875 		mbs.ibitm = 0x01;
876 		mbs.obitm = 0x07;
877 		isp_mboxcmd(isp, &mbs);
878 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
879 			isp_prt(isp, ISP_LOGERR, "Flash F/W load failed");
880 			return;
881 		}
882 	} else {
883 		isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
884 	}
885 
886 	/*
887 	 * If we loaded firmware, verify its checksum
888 	 */
889 	if (isp->isp_loaded_fw) {
890 		MBSINIT(&mbs, MBOX_VERIFY_CHECKSUM, MBLOGNONE, 0);
891 		if (IS_24XX(isp)) {
892 			mbs.param[1] = code_org >> 16;
893 			mbs.param[2] = code_org;
894 		} else {
895 			mbs.param[1] = code_org;
896 		}
897 		isp_mboxcmd(isp, &mbs);
898 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
899 			isp_prt(isp, ISP_LOGERR, dcrc);
900 			return;
901 		}
902 	}
903 
904 	/*
905 	 * Now start it rolling.
906 	 *
907 	 * If we didn't actually download f/w,
908 	 * we still need to (re)start it.
909 	 */
910 	MBSINIT(&mbs, MBOX_EXEC_FIRMWARE, MBLOGALL, 5000000);
911 	if (IS_24XX(isp)) {
912 		mbs.param[1] = code_org >> 16;
913 		mbs.param[2] = code_org;
914 		if (isp->isp_loaded_fw) {
915 			mbs.param[3] = 0;
916 		} else {
917 			mbs.param[3] = 1;
918 		}
919 	} else if (IS_2322(isp)) {
920 		mbs.param[1] = code_org;
921 		if (isp->isp_loaded_fw) {
922 			mbs.param[2] = 0;
923 		} else {
924 			mbs.param[2] = 1;
925 		}
926 	} else {
927 		mbs.param[1] = code_org;
928 	}
929 	isp_mboxcmd(isp, &mbs);
930 	if (IS_2322(isp) || IS_24XX(isp)) {
931 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
932 			return;
933 		}
934 	}
935 
936 	if (IS_SCSI(isp)) {
937 		/*
938 		 * Set CLOCK RATE, but only if asked to.
939 		 */
940 		if (isp->isp_clock) {
941 			MBSINIT(&mbs, MBOX_SET_CLOCK_RATE, MBLOGALL, 0);
942 			mbs.param[1] = isp->isp_clock;
943 			isp_mboxcmd(isp, &mbs);
944 			/* we will try not to care if this fails */
945 		}
946 	}
947 
948 	/*
949 	 * Ask the chip for the current firmware version.
950 	 * This should prove that the new firmware is working.
951 	 */
952 	MBSINIT(&mbs, MBOX_ABOUT_FIRMWARE, MBLOGALL, 0);
953 	isp_mboxcmd(isp, &mbs);
954 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
955 		return;
956 	}
957 
958 	/*
959 	 * The SBus firmware that we are using apparently does not return
960 	 * major, minor, micro revisions in the mailbox registers, which
961 	 * is really, really, annoying.
962 	 */
963 	if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
964 		if (dodnld) {
965 #ifdef	ISP_TARGET_MODE
966 			isp->isp_fwrev[0] = 7;
967 			isp->isp_fwrev[1] = 55;
968 #else
969 			isp->isp_fwrev[0] = 1;
970 			isp->isp_fwrev[1] = 37;
971 #endif
972 			isp->isp_fwrev[2] = 0;
973 		}
974 	} else {
975 		isp->isp_fwrev[0] = mbs.param[1];
976 		isp->isp_fwrev[1] = mbs.param[2];
977 		isp->isp_fwrev[2] = mbs.param[3];
978 	}
979 
980 	if (IS_FC(isp)) {
981 		/*
982 		 * We do not believe firmware attributes for 2100 code less
983 		 * than 1.17.0, unless it's the firmware we specifically
984 		 * are loading.
985 		 *
986 		 * Note that all 22XX and later f/w is greater than 1.X.0.
987 		 */
988 		if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
989 #ifdef	USE_SMALLER_2100_FIRMWARE
990 			isp->isp_fwattr = ISP_FW_ATTR_SCCLUN;
991 #else
992 			isp->isp_fwattr = 0;
993 #endif
994 		} else {
995 			isp->isp_fwattr = mbs.param[6];
996 		}
997 		if (IS_24XX(isp)) {
998 			isp->isp_fwattr |= ((uint64_t) mbs.param[15]) << 16;
999 			if (isp->isp_fwattr & ISP2400_FW_ATTR_EXTNDED) {
1000 				isp->isp_fwattr |=
1001 				    (((uint64_t) mbs.param[16]) << 32) |
1002 				    (((uint64_t) mbs.param[17]) << 48);
1003 			}
1004 		}
1005 	} else {
1006 		isp->isp_fwattr = 0;
1007 	}
1008 
1009 	isp_prt(isp, ISP_LOGCONFIG, "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1010 	    btype, isp->isp_revision, dodnld? "loaded" : "resident", isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1011 
1012 	fwt = isp->isp_fwattr;
1013 	if (IS_24XX(isp)) {
1014 		buf = FCPARAM(isp, 0)->isp_scanscratch;
1015 		ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1016 		if (fwt & ISP2400_FW_ATTR_CLASS2) {
1017 			fwt ^=ISP2400_FW_ATTR_CLASS2;
1018 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1019 		}
1020 		if (fwt & ISP2400_FW_ATTR_IP) {
1021 			fwt ^=ISP2400_FW_ATTR_IP;
1022 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1023 		}
1024 		if (fwt & ISP2400_FW_ATTR_MULTIID) {
1025 			fwt ^=ISP2400_FW_ATTR_MULTIID;
1026 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MultiID", buf);
1027 		}
1028 		if (fwt & ISP2400_FW_ATTR_SB2) {
1029 			fwt ^=ISP2400_FW_ATTR_SB2;
1030 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SB2", buf);
1031 		}
1032 		if (fwt & ISP2400_FW_ATTR_T10CRC) {
1033 			fwt ^=ISP2400_FW_ATTR_T10CRC;
1034 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s T10CRC", buf);
1035 		}
1036 		if (fwt & ISP2400_FW_ATTR_VI) {
1037 			fwt ^=ISP2400_FW_ATTR_VI;
1038 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1039 		}
1040 		if (fwt & ISP2400_FW_ATTR_MQ) {
1041 			fwt ^=ISP2400_FW_ATTR_MQ;
1042 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MQ", buf);
1043 		}
1044 		if (fwt & ISP2400_FW_ATTR_MSIX) {
1045 			fwt ^=ISP2400_FW_ATTR_MSIX;
1046 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s MSIX", buf);
1047 		}
1048 		if (fwt & ISP2400_FW_ATTR_FCOE) {
1049 			fwt ^=ISP2400_FW_ATTR_FCOE;
1050 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FCOE", buf);
1051 		}
1052 		if (fwt & ISP2400_FW_ATTR_VP0) {
1053 			fwt ^= ISP2400_FW_ATTR_VP0;
1054 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VP0_Decoupling", buf);
1055 		}
1056 		if (fwt & ISP2400_FW_ATTR_EXPFW) {
1057 			fwt ^= ISP2400_FW_ATTR_EXPFW;
1058 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (Experimental)", buf);
1059 		}
1060 		if (fwt & ISP2400_FW_ATTR_HOTFW) {
1061 			fwt ^= ISP2400_FW_ATTR_HOTFW;
1062 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s HotFW", buf);
1063 		}
1064 		fwt &= ~ISP2400_FW_ATTR_EXTNDED;
1065 		if (fwt & ISP2400_FW_ATTR_EXTVP) {
1066 			fwt ^= ISP2400_FW_ATTR_EXTVP;
1067 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ExtVP", buf);
1068 		}
1069 		if (fwt & ISP2400_FW_ATTR_VN2VN) {
1070 			fwt ^= ISP2400_FW_ATTR_VN2VN;
1071 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VN2VN", buf);
1072 		}
1073 		if (fwt & ISP2400_FW_ATTR_EXMOFF) {
1074 			fwt ^= ISP2400_FW_ATTR_EXMOFF;
1075 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s EXMOFF", buf);
1076 		}
1077 		if (fwt & ISP2400_FW_ATTR_NPMOFF) {
1078 			fwt ^= ISP2400_FW_ATTR_NPMOFF;
1079 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s NPMOFF", buf);
1080 		}
1081 		if (fwt & ISP2400_FW_ATTR_DIFCHOP) {
1082 			fwt ^= ISP2400_FW_ATTR_DIFCHOP;
1083 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s DIFCHOP", buf);
1084 		}
1085 		if (fwt & ISP2400_FW_ATTR_SRIOV) {
1086 			fwt ^= ISP2400_FW_ATTR_SRIOV;
1087 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SRIOV", buf);
1088 		}
1089 		if (fwt & ISP2400_FW_ATTR_ASICTMP) {
1090 			fwt ^= ISP2400_FW_ATTR_ASICTMP;
1091 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ASICTMP", buf);
1092 		}
1093 		if (fwt & ISP2400_FW_ATTR_ATIOMQ) {
1094 			fwt ^= ISP2400_FW_ATTR_ATIOMQ;
1095 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s ATIOMQ", buf);
1096 		}
1097 		if (fwt) {
1098 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1099 			    (uint32_t) (fwt >> 32), (uint32_t) fwt);
1100 		}
1101 		isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1102 	} else if (IS_FC(isp)) {
1103 		buf = FCPARAM(isp, 0)->isp_scanscratch;
1104 		ISP_SNPRINTF(buf, ISP_FC_SCRLEN, "Attributes:");
1105 		if (fwt & ISP_FW_ATTR_TMODE) {
1106 			fwt ^=ISP_FW_ATTR_TMODE;
1107 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s TargetMode", buf);
1108 		}
1109 		if (fwt & ISP_FW_ATTR_SCCLUN) {
1110 			fwt ^=ISP_FW_ATTR_SCCLUN;
1111 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s SCC-Lun", buf);
1112 		}
1113 		if (fwt & ISP_FW_ATTR_FABRIC) {
1114 			fwt ^=ISP_FW_ATTR_FABRIC;
1115 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Fabric", buf);
1116 		}
1117 		if (fwt & ISP_FW_ATTR_CLASS2) {
1118 			fwt ^=ISP_FW_ATTR_CLASS2;
1119 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s Class2", buf);
1120 		}
1121 		if (fwt & ISP_FW_ATTR_FCTAPE) {
1122 			fwt ^=ISP_FW_ATTR_FCTAPE;
1123 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s FC-Tape", buf);
1124 		}
1125 		if (fwt & ISP_FW_ATTR_IP) {
1126 			fwt ^=ISP_FW_ATTR_IP;
1127 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s IP", buf);
1128 		}
1129 		if (fwt & ISP_FW_ATTR_VI) {
1130 			fwt ^=ISP_FW_ATTR_VI;
1131 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI", buf);
1132 		}
1133 		if (fwt & ISP_FW_ATTR_VI_SOLARIS) {
1134 			fwt ^=ISP_FW_ATTR_VI_SOLARIS;
1135 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s VI_SOLARIS", buf);
1136 		}
1137 		if (fwt & ISP_FW_ATTR_2KLOGINS) {
1138 			fwt ^=ISP_FW_ATTR_2KLOGINS;
1139 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s 2K-Login", buf);
1140 		}
1141 		if (fwt != 0) {
1142 			ISP_SNPRINTF(buf, ISP_FC_SCRLEN - strlen(buf), "%s (unknown 0x%08x%08x)", buf,
1143 			    (uint32_t) (fwt >> 32), (uint32_t) fwt);
1144 		}
1145 		isp_prt(isp, ISP_LOGCONFIG, "%s", buf);
1146 	}
1147 
1148 	if (IS_24XX(isp)) {
1149 		MBSINIT(&mbs, MBOX_GET_RESOURCE_COUNT, MBLOGALL, 0);
1150 		isp_mboxcmd(isp, &mbs);
1151 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1152 			return;
1153 		}
1154 		isp->isp_maxcmds = mbs.param[3];
1155 	} else {
1156 		MBSINIT(&mbs, MBOX_GET_FIRMWARE_STATUS, MBLOGALL, 0);
1157 		isp_mboxcmd(isp, &mbs);
1158 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1159 			return;
1160 		}
1161 		isp->isp_maxcmds = mbs.param[2];
1162 	}
1163 	isp_prt(isp, ISP_LOGCONFIG, "%d max I/O command limit set", isp->isp_maxcmds);
1164 
1165 	/*
1166 	 * If we don't have Multi-ID f/w loaded, we need to restrict channels to one.
1167 	 * Only make this check for non-SCSI cards (I'm not sure firmware attributes
1168 	 * work for them).
1169 	 */
1170 	if (IS_FC(isp) && isp->isp_nchan > 1) {
1171 		if (!ISP_CAP_MULTI_ID(isp)) {
1172 			isp_prt(isp, ISP_LOGWARN, "non-MULTIID f/w loaded, "
1173 			    "only can enable 1 of %d channels", isp->isp_nchan);
1174 			isp->isp_nchan = 1;
1175 		} else if (!ISP_CAP_VP0(isp)) {
1176 			isp_prt(isp, ISP_LOGWARN, "We can not use MULTIID "
1177 			    "feature properly without VP0_Decoupling");
1178 			isp->isp_nchan = 1;
1179 		}
1180 	}
1181 
1182 	/*
1183 	 * Final DMA setup after we got isp_maxcmds.
1184 	 */
1185 	if (ISP_MBOXDMASETUP(isp) != 0) {
1186 		isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
1187 		return;
1188 	}
1189 
1190 	/*
1191 	 * Setup interrupts.
1192 	 */
1193 	if (ISP_IRQSETUP(isp) != 0) {
1194 		isp_prt(isp, ISP_LOGERR, "Cannot setup IRQ");
1195 		return;
1196 	}
1197 	ISP_ENABLE_INTS(isp);
1198 
1199 	if (IS_FC(isp)) {
1200 		for (i = 0; i < isp->isp_nchan; i++)
1201 			isp_change_fw_state(isp, i, FW_CONFIG_WAIT);
1202 	}
1203 
1204 	isp->isp_state = ISP_RESETSTATE;
1205 
1206 	/*
1207 	 * Okay- now that we have new firmware running, we now (re)set our
1208 	 * notion of how many luns we support. This is somewhat tricky because
1209 	 * if we haven't loaded firmware, we sometimes do not have an easy way
1210 	 * of knowing how many luns we support.
1211 	 *
1212 	 * Expanded lun firmware gives you 32 luns for SCSI cards and
1213 	 * unlimited luns for Fibre Channel cards.
1214 	 *
1215 	 * It turns out that even for QLogic 2100s with ROM 1.10 and above
1216 	 * we do get a firmware attributes word returned in mailbox register 6.
1217 	 *
1218 	 * Because the lun is in a different position in the Request Queue
1219 	 * Entry structure for Fibre Channel with expanded lun firmware, we
1220 	 * can only support one lun (lun zero) when we don't know what kind
1221 	 * of firmware we're running.
1222 	 */
1223 	if (IS_SCSI(isp)) {
1224 		if (dodnld) {
1225 			if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1226 				isp->isp_maxluns = 32;
1227 			} else {
1228 				isp->isp_maxluns = 8;
1229 			}
1230 		} else {
1231 			isp->isp_maxluns = 8;
1232 		}
1233 	} else {
1234 		if (ISP_CAP_SCCFW(isp)) {
1235 			isp->isp_maxluns = 0;	/* No limit -- 2/8 bytes */
1236 		} else {
1237 			isp->isp_maxluns = 16;
1238 		}
1239 	}
1240 
1241 	/*
1242 	 * We get some default values established. As a side
1243 	 * effect, NVRAM is read here (unless overriden by
1244 	 * a configuration flag).
1245 	 */
1246 	if (do_load_defaults) {
1247 		if (IS_SCSI(isp)) {
1248 			isp_setdfltsdparm(isp);
1249 		} else {
1250 			for (i = 0; i < isp->isp_nchan; i++) {
1251 				isp_setdfltfcparm(isp, i);
1252 			}
1253 		}
1254 	}
1255 }
1256 
1257 /*
1258  * Clean firmware shutdown.
1259  */
1260 static int
1261 isp_stop(ispsoftc_t *isp)
1262 {
1263 	mbreg_t mbs;
1264 
1265 	isp->isp_state = ISP_NILSTATE;
1266 	MBSINIT(&mbs, MBOX_STOP_FIRMWARE, MBLOGALL, 500000);
1267 	mbs.param[1] = 0;
1268 	mbs.param[2] = 0;
1269 	mbs.param[3] = 0;
1270 	mbs.param[4] = 0;
1271 	mbs.param[5] = 0;
1272 	mbs.param[6] = 0;
1273 	mbs.param[7] = 0;
1274 	mbs.param[8] = 0;
1275 	isp_mboxcmd(isp, &mbs);
1276 	return (mbs.param[0] == MBOX_COMMAND_COMPLETE ? 0 : mbs.param[0]);
1277 }
1278 
1279 /*
1280  * Hardware shutdown.
1281  */
1282 void
1283 isp_shutdown(ispsoftc_t *isp)
1284 {
1285 
1286 	if (isp->isp_state >= ISP_RESETSTATE)
1287 		isp_stop(isp);
1288 	ISP_DISABLE_INTS(isp);
1289 	if (IS_FC(isp)) {
1290 		if (IS_24XX(isp)) {
1291 			ISP_WRITE(isp, BIU2400_ICR, 0);
1292 			ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
1293 		} else {
1294 			ISP_WRITE(isp, BIU_ICR, 0);
1295 			ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1296 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
1297 			ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
1298 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
1299 			ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
1300 			ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
1301 		}
1302 	} else {
1303 		ISP_WRITE(isp, BIU_ICR, 0);
1304 		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1305 	}
1306 }
1307 
1308 /*
1309  * Initialize Parameters of Hardware to a known state.
1310  *
1311  * Locks are held before coming here.
1312  */
1313 void
1314 isp_init(ispsoftc_t *isp)
1315 {
1316 	if (IS_FC(isp)) {
1317 		if (IS_24XX(isp)) {
1318 			isp_fibre_init_2400(isp);
1319 		} else {
1320 			isp_fibre_init(isp);
1321 		}
1322 	} else {
1323 		isp_scsi_init(isp);
1324 	}
1325 }
1326 
1327 static void
1328 isp_scsi_init(ispsoftc_t *isp)
1329 {
1330 	sdparam *sdp_chan0, *sdp_chan1;
1331 	mbreg_t mbs;
1332 
1333 	isp->isp_state = ISP_INITSTATE;
1334 
1335 	sdp_chan0 = SDPARAM(isp, 0);
1336 	sdp_chan1 = sdp_chan0;
1337 	if (IS_DUALBUS(isp)) {
1338 		sdp_chan1 = SDPARAM(isp, 1);
1339 	}
1340 
1341 	/* First do overall per-card settings. */
1342 
1343 	/*
1344 	 * If we have fast memory timing enabled, turn it on.
1345 	 */
1346 	if (sdp_chan0->isp_fast_mttr) {
1347 		ISP_WRITE(isp, RISC_MTR, 0x1313);
1348 	}
1349 
1350 	/*
1351 	 * Set Retry Delay and Count.
1352 	 * You set both channels at the same time.
1353 	 */
1354 	MBSINIT(&mbs, MBOX_SET_RETRY_COUNT, MBLOGALL, 0);
1355 	mbs.param[1] = sdp_chan0->isp_retry_count;
1356 	mbs.param[2] = sdp_chan0->isp_retry_delay;
1357 	mbs.param[6] = sdp_chan1->isp_retry_count;
1358 	mbs.param[7] = sdp_chan1->isp_retry_delay;
1359 	isp_mboxcmd(isp, &mbs);
1360 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1361 		return;
1362 	}
1363 
1364 	/*
1365 	 * Set ASYNC DATA SETUP time. This is very important.
1366 	 */
1367 	MBSINIT(&mbs, MBOX_SET_ASYNC_DATA_SETUP_TIME, MBLOGALL, 0);
1368 	mbs.param[1] = sdp_chan0->isp_async_data_setup;
1369 	mbs.param[2] = sdp_chan1->isp_async_data_setup;
1370 	isp_mboxcmd(isp, &mbs);
1371 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1372 		return;
1373 	}
1374 
1375 	/*
1376 	 * Set ACTIVE Negation State.
1377 	 */
1378 	MBSINIT(&mbs, MBOX_SET_ACT_NEG_STATE, MBLOGNONE, 0);
1379 	mbs.param[1] =
1380 	    (sdp_chan0->isp_req_ack_active_neg << 4) |
1381 	    (sdp_chan0->isp_data_line_active_neg << 5);
1382 	mbs.param[2] =
1383 	    (sdp_chan1->isp_req_ack_active_neg << 4) |
1384 	    (sdp_chan1->isp_data_line_active_neg << 5);
1385 	isp_mboxcmd(isp, &mbs);
1386 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1387 		isp_prt(isp, ISP_LOGERR,
1388 		    "failed to set active negation state (%d,%d), (%d,%d)",
1389 		    sdp_chan0->isp_req_ack_active_neg,
1390 		    sdp_chan0->isp_data_line_active_neg,
1391 		    sdp_chan1->isp_req_ack_active_neg,
1392 		    sdp_chan1->isp_data_line_active_neg);
1393 		/*
1394 		 * But don't return.
1395 		 */
1396 	}
1397 
1398 	/*
1399 	 * Set the Tag Aging limit
1400 	 */
1401 	MBSINIT(&mbs, MBOX_SET_TAG_AGE_LIMIT, MBLOGALL, 0);
1402 	mbs.param[1] = sdp_chan0->isp_tag_aging;
1403 	mbs.param[2] = sdp_chan1->isp_tag_aging;
1404 	isp_mboxcmd(isp, &mbs);
1405 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1406 		isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1407 		    sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1408 		return;
1409 	}
1410 
1411 	/*
1412 	 * Set selection timeout.
1413 	 */
1414 	MBSINIT(&mbs, MBOX_SET_SELECT_TIMEOUT, MBLOGALL, 0);
1415 	mbs.param[1] = sdp_chan0->isp_selection_timeout;
1416 	mbs.param[2] = sdp_chan1->isp_selection_timeout;
1417 	isp_mboxcmd(isp, &mbs);
1418 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1419 		return;
1420 	}
1421 
1422 	/* now do per-channel settings */
1423 	isp_scsi_channel_init(isp, 0);
1424 	if (IS_DUALBUS(isp))
1425 		isp_scsi_channel_init(isp, 1);
1426 
1427 	/*
1428 	 * Now enable request/response queues
1429 	 */
1430 
1431 	if (IS_ULTRA2(isp) || IS_1240(isp)) {
1432 		MBSINIT(&mbs, MBOX_INIT_RES_QUEUE_A64, MBLOGALL, 0);
1433 		mbs.param[1] = RESULT_QUEUE_LEN(isp);
1434 		mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1435 		mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1436 		mbs.param[4] = 0;
1437 		mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1438 		mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1439 		isp_mboxcmd(isp, &mbs);
1440 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1441 			return;
1442 		}
1443 		isp->isp_residx = isp->isp_resodx = mbs.param[5];
1444 
1445 		MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE_A64, MBLOGALL, 0);
1446 		mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1447 		mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1448 		mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1449 		mbs.param[5] = 0;
1450 		mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1451 		mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1452 		isp_mboxcmd(isp, &mbs);
1453 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1454 			return;
1455 		}
1456 		isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1457 	} else {
1458 		MBSINIT(&mbs, MBOX_INIT_RES_QUEUE, MBLOGALL, 0);
1459 		mbs.param[1] = RESULT_QUEUE_LEN(isp);
1460 		mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1461 		mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1462 		mbs.param[4] = 0;
1463 		isp_mboxcmd(isp, &mbs);
1464 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1465 			return;
1466 		}
1467 		isp->isp_residx = isp->isp_resodx = mbs.param[5];
1468 
1469 		MBSINIT(&mbs, MBOX_INIT_REQ_QUEUE, MBLOGALL, 0);
1470 		mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1471 		mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1472 		mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1473 		mbs.param[5] = 0;
1474 		isp_mboxcmd(isp, &mbs);
1475 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1476 			return;
1477 		}
1478 		isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1479 	}
1480 
1481 	/*
1482 	 * Turn on LVD transitions for ULTRA2 or better and other features
1483 	 *
1484 	 * Now that we have 32 bit handles, don't do any fast posting
1485 	 * any more. For Ultra2/Ultra3 cards, we can turn on 32 bit RIO
1486 	 * operation or use fast posting. To be conservative, we'll only
1487 	 * do this for Ultra3 cards now because the other cards are so
1488 	 * rare for this author to find and test with.
1489 	 */
1490 
1491 	MBSINIT(&mbs, MBOX_SET_FW_FEATURES, MBLOGALL, 0);
1492 	if (IS_ULTRA2(isp))
1493 		mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1494 #ifdef	ISP_NO_RIO
1495 	if (IS_ULTRA3(isp))
1496 		mbs.param[1] |= FW_FEATURE_FAST_POST;
1497 #else
1498 	if (IS_ULTRA3(isp))
1499 		mbs.param[1] |= FW_FEATURE_RIO_32BIT;
1500 #endif
1501 	if (mbs.param[1] != 0) {
1502 		uint16_t sfeat = mbs.param[1];
1503 		isp_mboxcmd(isp, &mbs);
1504 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1505 			isp_prt(isp, ISP_LOGINFO,
1506 			    "Enabled FW features (0x%x)", sfeat);
1507 		}
1508 	}
1509 
1510 	isp->isp_state = ISP_RUNSTATE;
1511 }
1512 
1513 static void
1514 isp_scsi_channel_init(ispsoftc_t *isp, int chan)
1515 {
1516 	sdparam *sdp;
1517 	mbreg_t mbs;
1518 	int tgt;
1519 
1520 	sdp = SDPARAM(isp, chan);
1521 
1522 	/*
1523 	 * Set (possibly new) Initiator ID.
1524 	 */
1525 	MBSINIT(&mbs, MBOX_SET_INIT_SCSI_ID, MBLOGALL, 0);
1526 	mbs.param[1] = (chan << 7) | sdp->isp_initiator_id;
1527 	isp_mboxcmd(isp, &mbs);
1528 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1529 		return;
1530 	}
1531 	isp_prt(isp, ISP_LOGINFO, "Chan %d Initiator ID is %d",
1532 	    chan, sdp->isp_initiator_id);
1533 
1534 
1535 	/*
1536 	 * Set current per-target parameters to an initial safe minimum.
1537 	 */
1538 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1539 		int lun;
1540 		uint16_t sdf;
1541 
1542 		if (sdp->isp_devparam[tgt].dev_enable == 0) {
1543 			continue;
1544 		}
1545 #ifndef	ISP_TARGET_MODE
1546 		sdf = sdp->isp_devparam[tgt].goal_flags;
1547 		sdf &= DPARM_SAFE_DFLT;
1548 		/*
1549 		 * It is not quite clear when this changed over so that
1550 		 * we could force narrow and async for 1000/1020 cards,
1551 		 * but assume that this is only the case for loaded
1552 		 * firmware.
1553 		 */
1554 		if (isp->isp_loaded_fw) {
1555 			sdf |= DPARM_NARROW | DPARM_ASYNC;
1556 		}
1557 #else
1558 		/*
1559 		 * The !$*!)$!$)* f/w uses the same index into some
1560 		 * internal table to decide how to respond to negotiations,
1561 		 * so if we've said "let's be safe" for ID X, and ID X
1562 		 * selects *us*, the negotiations will back to 'safe'
1563 		 * (as in narrow/async). What the f/w *should* do is
1564 		 * use the initiator id settings to decide how to respond.
1565 		 */
1566 		sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1567 #endif
1568 		MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGNONE, 0);
1569 		mbs.param[1] = (chan << 15) | (tgt << 8);
1570 		mbs.param[2] = sdf;
1571 		if ((sdf & DPARM_SYNC) == 0) {
1572 			mbs.param[3] = 0;
1573 		} else {
1574 			mbs.param[3] =
1575 			    (sdp->isp_devparam[tgt].goal_offset << 8) |
1576 			    (sdp->isp_devparam[tgt].goal_period);
1577 		}
1578 		isp_prt(isp, ISP_LOGDEBUG0, "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1579 		    chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
1580 		isp_mboxcmd(isp, &mbs);
1581 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1582 			sdf = DPARM_SAFE_DFLT;
1583 			MBSINIT(&mbs, MBOX_SET_TARGET_PARAMS, MBLOGALL, 0);
1584 			mbs.param[1] = (tgt << 8) | (chan << 15);
1585 			mbs.param[2] = sdf;
1586 			mbs.param[3] = 0;
1587 			isp_mboxcmd(isp, &mbs);
1588 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1589 				continue;
1590 			}
1591 		}
1592 
1593 		/*
1594 		 * We don't update any information directly from the f/w
1595 		 * because we need to run at least one command to cause a
1596 		 * new state to be latched up. So, we just assume that we
1597 		 * converge to the values we just had set.
1598 		 *
1599 		 * Ensure that we don't believe tagged queuing is enabled yet.
1600 		 * It turns out that sometimes the ISP just ignores our
1601 		 * attempts to set parameters for devices that it hasn't
1602 		 * seen yet.
1603 		 */
1604 		sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1605 		for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1606 			MBSINIT(&mbs, MBOX_SET_DEV_QUEUE_PARAMS, MBLOGALL, 0);
1607 			mbs.param[1] = (chan << 15) | (tgt << 8) | lun;
1608 			mbs.param[2] = sdp->isp_max_queue_depth;
1609 			mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1610 			isp_mboxcmd(isp, &mbs);
1611 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1612 				break;
1613 			}
1614 		}
1615 	}
1616 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1617 		if (sdp->isp_devparam[tgt].dev_refresh) {
1618 			sdp->sendmarker = 1;
1619 			sdp->update = 1;
1620 			break;
1621 		}
1622 	}
1623 }
1624 
1625 /*
1626  * Fibre Channel specific initialization.
1627  */
1628 static void
1629 isp_fibre_init(ispsoftc_t *isp)
1630 {
1631 	fcparam *fcp;
1632 	isp_icb_t local, *icbp = &local;
1633 	mbreg_t mbs;
1634 
1635 	/*
1636 	 * We only support one channel on non-24XX cards
1637 	 */
1638 	fcp = FCPARAM(isp, 0);
1639 	if (fcp->role == ISP_ROLE_NONE)
1640 		return;
1641 
1642 	isp->isp_state = ISP_INITSTATE;
1643 	ISP_MEMZERO(icbp, sizeof (*icbp));
1644 	icbp->icb_version = ICB_VERSION1;
1645 	icbp->icb_fwoptions = fcp->isp_fwoptions;
1646 
1647 	/*
1648 	 * Firmware Options are either retrieved from NVRAM or
1649 	 * are patched elsewhere. We check them for sanity here
1650 	 * and make changes based on board revision, but otherwise
1651 	 * let others decide policy.
1652 	 */
1653 
1654 	/*
1655 	 * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1656 	 */
1657 	if (IS_2100(isp) && isp->isp_revision < 5) {
1658 		icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1659 	}
1660 
1661 	/*
1662 	 * We have to use FULL LOGIN even though it resets the loop too much
1663 	 * because otherwise port database entries don't get updated after
1664 	 * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1665 	 */
1666 	if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1667 		icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1668 	}
1669 
1670 	/*
1671 	 * Insist on Port Database Update Async notifications
1672 	 */
1673 	icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1674 
1675 	/*
1676 	 * Make sure that target role reflects into fwoptions.
1677 	 */
1678 	if (fcp->role & ISP_ROLE_TARGET) {
1679 		icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1680 	} else {
1681 		icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1682 	}
1683 
1684 	/*
1685 	 * For some reason my 2200 does not generate ATIOs in target mode
1686 	 * if initiator is disabled.  Extra logins are better then target
1687 	 * not working at all.
1688 	 */
1689 	if ((fcp->role & ISP_ROLE_INITIATOR) || IS_2100(isp) || IS_2200(isp)) {
1690 		icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1691 	} else {
1692 		icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1693 	}
1694 
1695 	icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
1696 	if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1697 		isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
1698 		icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1699 	}
1700 	icbp->icb_maxalloc = fcp->isp_maxalloc;
1701 	if (icbp->icb_maxalloc < 1) {
1702 		isp_prt(isp, ISP_LOGERR, "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1703 		icbp->icb_maxalloc = 16;
1704 	}
1705 	icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
1706 	if (icbp->icb_execthrottle < 1) {
1707 		isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
1708 		icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1709 	}
1710 	icbp->icb_retry_delay = fcp->isp_retry_delay;
1711 	icbp->icb_retry_count = fcp->isp_retry_count;
1712 	if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
1713 		icbp->icb_hardaddr = fcp->isp_loopid;
1714 		if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
1715 			icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1716 		else
1717 			icbp->icb_fwoptions |= ICBOPT_PREV_ADDRESS;
1718 	}
1719 
1720 	/*
1721 	 * Right now we just set extended options to prefer point-to-point
1722 	 * over loop based upon some soft config options.
1723 	 *
1724 	 * NB: for the 2300, ICBOPT_EXTENDED is required.
1725 	 */
1726 	if (IS_2100(isp)) {
1727 		/*
1728 		 * We can't have Fast Posting any more- we now
1729 		 * have 32 bit handles.
1730 		 */
1731 		icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1732 	} else if (IS_2200(isp) || IS_23XX(isp)) {
1733 		icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1734 
1735 		icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1736 
1737 		if (ISP_CAP_FCTAPE(isp)) {
1738 			if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1739 				icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1740 
1741 			if (isp->isp_confopts & ISP_CFG_FCTAPE)
1742 				icbp->icb_xfwoptions |= ICBXOPT_FCTAPE;
1743 
1744 			if (icbp->icb_xfwoptions & ICBXOPT_FCTAPE) {
1745 				icbp->icb_fwoptions &= ~ICBOPT_FULL_LOGIN;	/* per documents */
1746 				icbp->icb_xfwoptions |= ICBXOPT_FCTAPE_CCQ|ICBXOPT_FCTAPE_CONFIRM;
1747 				FCPARAM(isp, 0)->fctape_enabled = 1;
1748 			} else {
1749 				FCPARAM(isp, 0)->fctape_enabled = 0;
1750 			}
1751 		} else {
1752 			icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1753 			FCPARAM(isp, 0)->fctape_enabled = 0;
1754 		}
1755 
1756 		/*
1757 		 * Prefer or force Point-To-Point instead Loop?
1758 		 */
1759 		switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1760 		case ISP_CFG_LPORT_ONLY:
1761 			icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1762 			icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1763 			break;
1764 		case ISP_CFG_NPORT_ONLY:
1765 			icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1766 			icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1767 			break;
1768 		case ISP_CFG_LPORT:
1769 			icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1770 			icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1771 			break;
1772 		case ISP_CFG_NPORT:
1773 			icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1774 			icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1775 			break;
1776 		default:
1777 			/* Let NVRAM settings define it if they are sane */
1778 			switch (icbp->icb_xfwoptions & ICBXOPT_TOPO_MASK) {
1779 			case ICBXOPT_PTP_2_LOOP:
1780 			case ICBXOPT_PTP_ONLY:
1781 			case ICBXOPT_LOOP_ONLY:
1782 			case ICBXOPT_LOOP_2_PTP:
1783 				break;
1784 			default:
1785 				icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1786 				icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1787 			}
1788 			break;
1789 		}
1790 		if (IS_2200(isp)) {
1791 			/*
1792 			 * We can't have Fast Posting any more- we now
1793 			 * have 32 bit handles.
1794 			 *
1795 			 * RIO seemed to have to much breakage.
1796 			 *
1797 			 * Just opt for safety.
1798 			 */
1799 			icbp->icb_xfwoptions &= ~ICBXOPT_RIO_16BIT;
1800 			icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1801 		} else {
1802 			/*
1803 			 * QLogic recommends that FAST Posting be turned
1804 			 * off for 23XX cards and instead allow the HBA
1805 			 * to write response queue entries and interrupt
1806 			 * after a delay (ZIO).
1807 			 */
1808 			icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1809 			if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) == ICBXOPT_ZIO) {
1810 				icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1811 				icbp->icb_idelaytimer = 10;
1812 			}
1813 			icbp->icb_zfwoptions = fcp->isp_zfwoptions;
1814 			if (isp->isp_confopts & ISP_CFG_1GB) {
1815 				icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1816 				icbp->icb_zfwoptions |= ICBZOPT_RATE_1GB;
1817 			} else if (isp->isp_confopts & ISP_CFG_2GB) {
1818 				icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1819 				icbp->icb_zfwoptions |= ICBZOPT_RATE_2GB;
1820 			} else {
1821 				switch (icbp->icb_zfwoptions & ICBZOPT_RATE_MASK) {
1822 				case ICBZOPT_RATE_1GB:
1823 				case ICBZOPT_RATE_2GB:
1824 				case ICBZOPT_RATE_AUTO:
1825 					break;
1826 				default:
1827 					icbp->icb_zfwoptions &= ~ICBZOPT_RATE_MASK;
1828 					icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1829 					break;
1830 				}
1831 			}
1832 		}
1833 	}
1834 
1835 
1836 	/*
1837 	 * For 22XX > 2.1.26 && 23XX, set some options.
1838 	 */
1839 	if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1840 		MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1841 		mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1842 		mbs.param[2] = 0;
1843 		mbs.param[3] = 0;
1844 		if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1845 			mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1846 			if (fcp->role & ISP_ROLE_TARGET) {
1847 				if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1848 					mbs.param[1] |= IFCOPT1_ENAPURE;
1849 				}
1850 				mbs.param[3] = IFCOPT3_NOPRLI;
1851 			}
1852 		}
1853 		isp_mboxcmd(isp, &mbs);
1854 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1855 			return;
1856 		}
1857 	}
1858 	icbp->icb_logintime = ICB_LOGIN_TOV;
1859 
1860 #ifdef	ISP_TARGET_MODE
1861 	if (icbp->icb_fwoptions & ICBOPT_TGT_ENABLE) {
1862 		icbp->icb_lunenables = 0xffff;
1863 		icbp->icb_ccnt = 0xff;
1864 		icbp->icb_icnt = 0xff;
1865 		icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1866 	}
1867 #endif
1868 	if (fcp->isp_wwnn && fcp->isp_wwpn) {
1869 		icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1870 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1871 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1872 		isp_prt(isp, ISP_LOGDEBUG1,
1873 		    "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1874 		    ((uint32_t) (fcp->isp_wwnn >> 32)),
1875 		    ((uint32_t) (fcp->isp_wwnn)),
1876 		    ((uint32_t) (fcp->isp_wwpn >> 32)),
1877 		    ((uint32_t) (fcp->isp_wwpn)));
1878 	} else if (fcp->isp_wwpn) {
1879 		icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1880 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1881 		isp_prt(isp, ISP_LOGDEBUG1,
1882 		    "Setting ICB Port 0x%08x%08x",
1883 		    ((uint32_t) (fcp->isp_wwpn >> 32)),
1884 		    ((uint32_t) (fcp->isp_wwpn)));
1885 	} else {
1886 		isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1887 		return;
1888 	}
1889 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1890 	if (icbp->icb_rqstqlen < 1) {
1891 		isp_prt(isp, ISP_LOGERR, "bad request queue length");
1892 	}
1893 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1894 	if (icbp->icb_rsltqlen < 1) {
1895 		isp_prt(isp, ISP_LOGERR, "bad result queue length");
1896 	}
1897 	icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1898 	icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1899 	icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1900 	icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1901 	icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1902 	icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1903 	icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1904 	icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1905 
1906 	if (FC_SCRATCH_ACQUIRE(isp, 0)) {
1907 		isp_prt(isp, ISP_LOGERR, sacq);
1908 		return;
1909 	}
1910 	isp_prt(isp, ISP_LOGDEBUG0, "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1911 	    icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1912 
1913 	isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1914 	if (isp->isp_dblev & ISP_LOGDEBUG1) {
1915 		isp_print_bytes(isp, "isp_fibre_init",
1916 		    sizeof(*icbp), fcp->isp_scratch);
1917 	}
1918 
1919 	/*
1920 	 * Init the firmware
1921 	 */
1922 	MBSINIT(&mbs, MBOX_INIT_FIRMWARE, MBLOGALL, 30000000);
1923 	mbs.param[1] = 0;
1924 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1925 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1926 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1927 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1928 	isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1929 	    fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1930 	    (uint32_t) fcp->isp_scdma);
1931 	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
1932 	isp_mboxcmd(isp, &mbs);
1933 	FC_SCRATCH_RELEASE(isp, 0);
1934 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
1935 		return;
1936 	isp->isp_reqidx = 0;
1937 	isp->isp_reqodx = 0;
1938 	isp->isp_residx = 0;
1939 	isp->isp_resodx = 0;
1940 
1941 	/*
1942 	 * Whatever happens, we're now committed to being here.
1943 	 */
1944 	isp->isp_state = ISP_RUNSTATE;
1945 }
1946 
1947 static void
1948 isp_fibre_init_2400(ispsoftc_t *isp)
1949 {
1950 	fcparam *fcp;
1951 	isp_icb_2400_t local, *icbp = &local;
1952 	mbreg_t mbs;
1953 	int chan;
1954 
1955 	/*
1956 	 * Check to see whether all channels have *some* kind of role
1957 	 */
1958 	for (chan = 0; chan < isp->isp_nchan; chan++) {
1959 		fcp = FCPARAM(isp, chan);
1960 		if (fcp->role != ISP_ROLE_NONE) {
1961 			break;
1962 		}
1963 	}
1964 	if (chan == isp->isp_nchan) {
1965 		isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1966 		return;
1967 	}
1968 
1969 	isp->isp_state = ISP_INITSTATE;
1970 
1971 	/*
1972 	 * Start with channel 0.
1973 	 */
1974 	fcp = FCPARAM(isp, 0);
1975 
1976 	/*
1977 	 * Turn on LIP F8 async event (1)
1978 	 */
1979 	MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1980 	mbs.param[1] = 1;
1981 	isp_mboxcmd(isp, &mbs);
1982 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1983 		return;
1984 	}
1985 
1986 	ISP_MEMZERO(icbp, sizeof (*icbp));
1987 	icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1988 	icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1989 	icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
1990 	if (isp->isp_nchan > 1 && ISP_CAP_VP0(isp)) {
1991 		icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
1992 		icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
1993 	} else {
1994 		if (fcp->role & ISP_ROLE_TARGET)
1995 			icbp->icb_fwoptions1 |= ICB2400_OPT1_TGT_ENABLE;
1996 		else
1997 			icbp->icb_fwoptions1 &= ~ICB2400_OPT1_TGT_ENABLE;
1998 		if (fcp->role & ISP_ROLE_INITIATOR)
1999 			icbp->icb_fwoptions1 &= ~ICB2400_OPT1_INI_DISABLE;
2000 		else
2001 			icbp->icb_fwoptions1 |= ICB2400_OPT1_INI_DISABLE;
2002 	}
2003 
2004 	icbp->icb_version = ICB_VERSION1;
2005 	icbp->icb_maxfrmlen = DEFAULT_FRAMESIZE(isp);
2006 	if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN || icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
2007 		isp_prt(isp, ISP_LOGERR, "bad frame length (%d) from NVRAM- using %d", DEFAULT_FRAMESIZE(isp), ICB_DFLT_FRMLEN);
2008 		icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
2009 	}
2010 
2011 	icbp->icb_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
2012 	if (icbp->icb_execthrottle < 1) {
2013 		isp_prt(isp, ISP_LOGERR, "bad execution throttle of %d- using %d", DEFAULT_EXEC_THROTTLE(isp), ICB_DFLT_THROTTLE);
2014 		icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
2015 	}
2016 
2017 	/*
2018 	 * Set target exchange count. Take half if we are supporting both roles.
2019 	 */
2020 	if (icbp->icb_fwoptions1 & ICB2400_OPT1_TGT_ENABLE) {
2021 		icbp->icb_xchgcnt = isp->isp_maxcmds;
2022 		if ((icbp->icb_fwoptions1 & ICB2400_OPT1_INI_DISABLE) == 0)
2023 			icbp->icb_xchgcnt >>= 1;
2024 	}
2025 
2026 	if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
2027 		icbp->icb_hardaddr = fcp->isp_loopid;
2028 		if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2029 			icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
2030 		else
2031 			icbp->icb_fwoptions1 |= ICB2400_OPT1_PREV_ADDRESS;
2032 	}
2033 
2034 	if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2035 		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
2036 	}
2037 	if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2038 		icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
2039 	}
2040 
2041 	for (chan = 0; chan < isp->isp_nchan; chan++) {
2042 		if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE)
2043 			FCPARAM(isp, chan)->fctape_enabled = 1;
2044 		else
2045 			FCPARAM(isp, chan)->fctape_enabled = 0;
2046 	}
2047 
2048 	switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2049 	case ISP_CFG_LPORT_ONLY:
2050 		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2051 		icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
2052 		break;
2053 	case ISP_CFG_NPORT_ONLY:
2054 		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2055 		icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
2056 		break;
2057 	case ISP_CFG_NPORT:
2058 		/* ISP_CFG_PTP_2_LOOP not available in 24XX/25XX */
2059 	case ISP_CFG_LPORT:
2060 		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2061 		icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2062 		break;
2063 	default:
2064 		/* Let NVRAM settings define it if they are sane */
2065 		switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TOPO_MASK) {
2066 		case ICB2400_OPT2_LOOP_ONLY:
2067 		case ICB2400_OPT2_PTP_ONLY:
2068 		case ICB2400_OPT2_LOOP_2_PTP:
2069 			break;
2070 		default:
2071 			icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2072 			icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
2073 		}
2074 		break;
2075 	}
2076 
2077 	switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
2078 	case ICB2400_OPT2_ZIO:
2079 	case ICB2400_OPT2_ZIO1:
2080 		icbp->icb_idelaytimer = 0;
2081 		break;
2082 	case 0:
2083 		break;
2084 	default:
2085 		isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field", icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
2086 		icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
2087 		break;
2088 	}
2089 
2090 	if (IS_26XX(isp)) {
2091 		/* Use handshake to reduce global lock congestion. */
2092 		icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHR;
2093 		icbp->icb_fwoptions2 |= ICB2400_OPT2_ENA_IHA;
2094 	}
2095 
2096 	if ((icbp->icb_fwoptions3 & ICB2400_OPT3_RSPSZ_MASK) == 0) {
2097 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RSPSZ_24;
2098 	}
2099 	if (isp->isp_confopts & ISP_CFG_1GB) {
2100 		icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2101 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_1GB;
2102 	} else if (isp->isp_confopts & ISP_CFG_2GB) {
2103 		icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2104 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_2GB;
2105 	} else if (isp->isp_confopts & ISP_CFG_4GB) {
2106 		icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2107 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_4GB;
2108 	} else if (isp->isp_confopts & ISP_CFG_8GB) {
2109 		icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2110 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_8GB;
2111 	} else if (isp->isp_confopts & ISP_CFG_16GB) {
2112 		icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2113 		icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_16GB;
2114 	} else {
2115 		switch (icbp->icb_fwoptions3 & ICB2400_OPT3_RATE_MASK) {
2116 		case ICB2400_OPT3_RATE_4GB:
2117 		case ICB2400_OPT3_RATE_8GB:
2118 		case ICB2400_OPT3_RATE_16GB:
2119 		case ICB2400_OPT3_RATE_AUTO:
2120 			break;
2121 		case ICB2400_OPT3_RATE_2GB:
2122 			if (isp->isp_type <= ISP_HA_FC_2500)
2123 				break;
2124 			/*FALLTHROUGH*/
2125 		case ICB2400_OPT3_RATE_1GB:
2126 			if (isp->isp_type <= ISP_HA_FC_2400)
2127 				break;
2128 			/*FALLTHROUGH*/
2129 		default:
2130 			icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_MASK;
2131 			icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
2132 			break;
2133 		}
2134 	}
2135 	icbp->icb_logintime = ICB_LOGIN_TOV;
2136 
2137 	if (fcp->isp_wwnn && fcp->isp_wwpn) {
2138 		icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
2139 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2140 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
2141 		isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node 0x%08x%08x Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwnn >> 32)), ((uint32_t) (fcp->isp_wwnn)),
2142 		    ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2143 	} else if (fcp->isp_wwpn) {
2144 		icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
2145 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
2146 		isp_prt(isp, ISP_LOGDEBUG1, "Setting ICB Node to be same as Port 0x%08x%08x", ((uint32_t) (fcp->isp_wwpn >> 32)), ((uint32_t) (fcp->isp_wwpn)));
2147 	} else {
2148 		isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
2149 		return;
2150 	}
2151 	icbp->icb_retry_count = fcp->isp_retry_count;
2152 
2153 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
2154 	if (icbp->icb_rqstqlen < 8) {
2155 		isp_prt(isp, ISP_LOGERR, "bad request queue length %d", icbp->icb_rqstqlen);
2156 		return;
2157 	}
2158 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
2159 	if (icbp->icb_rsltqlen < 8) {
2160 		isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
2161 		    icbp->icb_rsltqlen);
2162 		return;
2163 	}
2164 	icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
2165 	icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
2166 	icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
2167 	icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
2168 
2169 	icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
2170 	icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
2171 	icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
2172 	icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
2173 
2174 #ifdef	ISP_TARGET_MODE
2175 	/* unconditionally set up the ATIO queue if we support target mode */
2176 	icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2177 	if (icbp->icb_atioqlen < 8) {
2178 		isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d", icbp->icb_atioqlen);
2179 		return;
2180 	}
2181 	icbp->icb_atioqaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_atioq_dma);
2182 	icbp->icb_atioqaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_atioq_dma);
2183 	icbp->icb_atioqaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_atioq_dma);
2184 	icbp->icb_atioqaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_atioq_dma);
2185 	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),
2186 	    DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2187 #endif
2188 
2189 	if (ISP_CAP_MSIX(isp) && isp->isp_nirq >= 2) {
2190 		icbp->icb_msixresp = 1;
2191 		if (IS_26XX(isp) && isp->isp_nirq >= 3)
2192 			icbp->icb_msixatio = 2;
2193 	}
2194 
2195 	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);
2196 
2197 	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),
2198 	    DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma), DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2199 	    DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2200 
2201 	if (FC_SCRATCH_ACQUIRE(isp, 0)) {
2202 		isp_prt(isp, ISP_LOGERR, sacq);
2203 		return;
2204 	}
2205 	ISP_MEMZERO(fcp->isp_scratch, ISP_FC_SCRLEN);
2206 	isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2207 	if (isp->isp_dblev & ISP_LOGDEBUG1) {
2208 		isp_print_bytes(isp, "isp_fibre_init_2400",
2209 		    sizeof (*icbp), fcp->isp_scratch);
2210 	}
2211 
2212 	/*
2213 	 * Now fill in information about any additional channels
2214 	 */
2215 	if (isp->isp_nchan > 1) {
2216 		isp_icb_2400_vpinfo_t vpinfo, *vdst;
2217 		vp_port_info_t pi, *pdst;
2218 		size_t amt = 0;
2219 		uint8_t *off;
2220 
2221 		vpinfo.vp_global_options = ICB2400_VPGOPT_GEN_RIDA;
2222 		if (ISP_CAP_VP0(isp)) {
2223 			vpinfo.vp_global_options |= ICB2400_VPGOPT_VP0_DECOUPLE;
2224 			vpinfo.vp_count = isp->isp_nchan;
2225 			chan = 0;
2226 		} else {
2227 			vpinfo.vp_count = isp->isp_nchan - 1;
2228 			chan = 1;
2229 		}
2230 		off = fcp->isp_scratch;
2231 		off += ICB2400_VPINFO_OFF;
2232 		vdst = (isp_icb_2400_vpinfo_t *) off;
2233 		isp_put_icb_2400_vpinfo(isp, &vpinfo, vdst);
2234 		amt = ICB2400_VPINFO_OFF + sizeof (isp_icb_2400_vpinfo_t);
2235 		for (; chan < isp->isp_nchan; chan++) {
2236 			fcparam *fcp2;
2237 
2238 			ISP_MEMZERO(&pi, sizeof (pi));
2239 			fcp2 = FCPARAM(isp, chan);
2240 			if (fcp2->role != ISP_ROLE_NONE) {
2241 				pi.vp_port_options = ICB2400_VPOPT_ENABLED |
2242 				    ICB2400_VPOPT_ENA_SNSLOGIN;
2243 				if (fcp2->role & ISP_ROLE_INITIATOR)
2244 					pi.vp_port_options |= ICB2400_VPOPT_INI_ENABLE;
2245 				if ((fcp2->role & ISP_ROLE_TARGET) == 0)
2246 					pi.vp_port_options |= ICB2400_VPOPT_TGT_DISABLE;
2247 			}
2248 			if (fcp2->isp_loopid < LOCAL_LOOP_LIM) {
2249 				pi.vp_port_loopid = fcp2->isp_loopid;
2250 				if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2251 					pi.vp_port_options |= ICB2400_VPOPT_HARD_ADDRESS;
2252 				else
2253 					pi.vp_port_options |= ICB2400_VPOPT_PREV_ADDRESS;
2254 			}
2255 			MAKE_NODE_NAME_FROM_WWN(pi.vp_port_portname, fcp2->isp_wwpn);
2256 			MAKE_NODE_NAME_FROM_WWN(pi.vp_port_nodename, fcp2->isp_wwnn);
2257 			off = fcp->isp_scratch;
2258 			if (ISP_CAP_VP0(isp))
2259 				off += ICB2400_VPINFO_PORT_OFF(chan);
2260 			else
2261 				off += ICB2400_VPINFO_PORT_OFF(chan - 1);
2262 			pdst = (vp_port_info_t *) off;
2263 			isp_put_vp_port_info(isp, &pi, pdst);
2264 			amt += ICB2400_VPOPT_WRITE_SIZE;
2265 		}
2266 		if (isp->isp_dblev & ISP_LOGDEBUG1) {
2267 			isp_print_bytes(isp, "isp_fibre_init_2400",
2268 			    amt - ICB2400_VPINFO_OFF,
2269 			    (char *)fcp->isp_scratch + ICB2400_VPINFO_OFF);
2270 		}
2271 	}
2272 
2273 	/*
2274 	 * Init the firmware
2275 	 */
2276 	MBSINIT(&mbs, 0, MBLOGALL, 30000000);
2277 	if (isp->isp_nchan > 1) {
2278 		mbs.param[0] = MBOX_INIT_FIRMWARE_MULTI_ID;
2279 	} else {
2280 		mbs.param[0] = MBOX_INIT_FIRMWARE;
2281 	}
2282 	mbs.param[1] = 0;
2283 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2284 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2285 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2286 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2287 	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));
2288 	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp), 0);
2289 	isp_mboxcmd(isp, &mbs);
2290 	FC_SCRATCH_RELEASE(isp, 0);
2291 
2292 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2293 		return;
2294 	}
2295 	isp->isp_reqidx = 0;
2296 	isp->isp_reqodx = 0;
2297 	isp->isp_residx = 0;
2298 	isp->isp_resodx = 0;
2299 	isp->isp_atioodx = 0;
2300 
2301 	/*
2302 	 * Whatever happens, we're now committed to being here.
2303 	 */
2304 	isp->isp_state = ISP_RUNSTATE;
2305 }
2306 
2307 static int
2308 isp_fc_enable_vp(ispsoftc_t *isp, int chan)
2309 {
2310 	fcparam *fcp = FCPARAM(isp, chan);
2311 	vp_modify_t vp;
2312 	void *reqp;
2313 	uint8_t resp[QENTRY_LEN];
2314 
2315 	/* Build a VP MODIFY command in memory */
2316 	ISP_MEMZERO(&vp, sizeof(vp));
2317 	vp.vp_mod_hdr.rqs_entry_type = RQSTYPE_VP_MODIFY;
2318 	vp.vp_mod_hdr.rqs_entry_count = 1;
2319 	vp.vp_mod_cnt = 1;
2320 	vp.vp_mod_idx0 = chan;
2321 	vp.vp_mod_cmd = VP_MODIFY_ENA;
2322 	vp.vp_mod_ports[0].options = ICB2400_VPOPT_ENABLED |
2323 	    ICB2400_VPOPT_ENA_SNSLOGIN;
2324 	if (fcp->role & ISP_ROLE_INITIATOR)
2325 		vp.vp_mod_ports[0].options |= ICB2400_VPOPT_INI_ENABLE;
2326 	if ((fcp->role & ISP_ROLE_TARGET) == 0)
2327 		vp.vp_mod_ports[0].options |= ICB2400_VPOPT_TGT_DISABLE;
2328 	if (fcp->isp_loopid < LOCAL_LOOP_LIM) {
2329 		vp.vp_mod_ports[0].loopid = fcp->isp_loopid;
2330 		if (isp->isp_confopts & ISP_CFG_OWNLOOPID)
2331 			vp.vp_mod_ports[0].options |= ICB2400_VPOPT_HARD_ADDRESS;
2332 		else
2333 			vp.vp_mod_ports[0].options |= ICB2400_VPOPT_PREV_ADDRESS;
2334 	}
2335 	MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwpn, fcp->isp_wwpn);
2336 	MAKE_NODE_NAME_FROM_WWN(vp.vp_mod_ports[0].wwnn, fcp->isp_wwnn);
2337 
2338 	/* Prepare space for response in memory */
2339 	memset(resp, 0xff, sizeof(resp));
2340 	vp.vp_mod_hdl = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2341 	if (vp.vp_mod_hdl == 0) {
2342 		isp_prt(isp, ISP_LOGERR,
2343 		    "%s: VP_MODIFY of Chan %d out of handles", __func__, chan);
2344 		return (EIO);
2345 	}
2346 
2347 	/* Send request and wait for response. */
2348 	reqp = isp_getrqentry(isp);
2349 	if (reqp == NULL) {
2350 		isp_prt(isp, ISP_LOGERR,
2351 		    "%s: VP_MODIFY of Chan %d out of rqent", __func__, chan);
2352 		isp_destroy_handle(isp, vp.vp_mod_hdl);
2353 		return (EIO);
2354 	}
2355 	isp_put_vp_modify(isp, &vp, (vp_modify_t *)reqp);
2356 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2357 		isp_print_bytes(isp, "IOCB VP_MODIFY", QENTRY_LEN, reqp);
2358 	ISP_SYNC_REQUEST(isp);
2359 	if (msleep(resp, &isp->isp_lock, 0, "VP_MODIFY", 5*hz) == EWOULDBLOCK) {
2360 		isp_prt(isp, ISP_LOGERR,
2361 		    "%s: VP_MODIFY of Chan %d timed out", __func__, chan);
2362 		isp_destroy_handle(isp, vp.vp_mod_hdl);
2363 		return (EIO);
2364 	}
2365 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2366 		isp_print_bytes(isp, "IOCB VP_MODIFY response", QENTRY_LEN, resp);
2367 	isp_get_vp_modify(isp, (vp_modify_t *)resp, &vp);
2368 
2369 	if (vp.vp_mod_hdr.rqs_flags != 0 || vp.vp_mod_status != VP_STS_OK) {
2370 		isp_prt(isp, ISP_LOGERR,
2371 		    "%s: VP_MODIFY of Chan %d failed with flags %x status %d",
2372 		    __func__, chan, vp.vp_mod_hdr.rqs_flags, vp.vp_mod_status);
2373 		return (EIO);
2374 	}
2375 	return (0);
2376 }
2377 
2378 static int
2379 isp_fc_disable_vp(ispsoftc_t *isp, int chan)
2380 {
2381 	vp_ctrl_info_t vp;
2382 	void *reqp;
2383 	uint8_t resp[QENTRY_LEN];
2384 
2385 	/* Build a VP CTRL command in memory */
2386 	ISP_MEMZERO(&vp, sizeof(vp));
2387 	vp.vp_ctrl_hdr.rqs_entry_type = RQSTYPE_VP_CTRL;
2388 	vp.vp_ctrl_hdr.rqs_entry_count = 1;
2389 	if (ISP_CAP_VP0(isp)) {
2390 		vp.vp_ctrl_status = 1;
2391 	} else {
2392 		vp.vp_ctrl_status = 0;
2393 		chan--;	/* VP0 can not be controlled in this case. */
2394 	}
2395 	vp.vp_ctrl_command = VP_CTRL_CMD_DISABLE_VP_LOGO_ALL;
2396 	vp.vp_ctrl_vp_count = 1;
2397 	vp.vp_ctrl_idmap[chan / 16] |= (1 << chan % 16);
2398 
2399 	/* Prepare space for response in memory */
2400 	memset(resp, 0xff, sizeof(resp));
2401 	vp.vp_ctrl_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2402 	if (vp.vp_ctrl_handle == 0) {
2403 		isp_prt(isp, ISP_LOGERR,
2404 		    "%s: VP_CTRL of Chan %d out of handles", __func__, chan);
2405 		return (EIO);
2406 	}
2407 
2408 	/* Send request and wait for response. */
2409 	reqp = isp_getrqentry(isp);
2410 	if (reqp == NULL) {
2411 		isp_prt(isp, ISP_LOGERR,
2412 		    "%s: VP_CTRL of Chan %d out of rqent", __func__, chan);
2413 		isp_destroy_handle(isp, vp.vp_ctrl_handle);
2414 		return (EIO);
2415 	}
2416 	isp_put_vp_ctrl_info(isp, &vp, (vp_ctrl_info_t *)reqp);
2417 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2418 		isp_print_bytes(isp, "IOCB VP_CTRL", QENTRY_LEN, reqp);
2419 	ISP_SYNC_REQUEST(isp);
2420 	if (msleep(resp, &isp->isp_lock, 0, "VP_CTRL", 5*hz) == EWOULDBLOCK) {
2421 		isp_prt(isp, ISP_LOGERR,
2422 		    "%s: VP_CTRL of Chan %d timed out", __func__, chan);
2423 		isp_destroy_handle(isp, vp.vp_ctrl_handle);
2424 		return (EIO);
2425 	}
2426 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2427 		isp_print_bytes(isp, "IOCB VP_CTRL response", QENTRY_LEN, resp);
2428 	isp_get_vp_ctrl_info(isp, (vp_ctrl_info_t *)resp, &vp);
2429 
2430 	if (vp.vp_ctrl_hdr.rqs_flags != 0 || vp.vp_ctrl_status != 0) {
2431 		isp_prt(isp, ISP_LOGERR,
2432 		    "%s: VP_CTRL of Chan %d failed with flags %x status %d %d",
2433 		    __func__, chan, vp.vp_ctrl_hdr.rqs_flags,
2434 		    vp.vp_ctrl_status, vp.vp_ctrl_index_fail);
2435 		return (EIO);
2436 	}
2437 	return (0);
2438 }
2439 
2440 static int
2441 isp_fc_change_role(ispsoftc_t *isp, int chan, int new_role)
2442 {
2443 	fcparam *fcp = FCPARAM(isp, chan);
2444 	int i, was, res = 0;
2445 
2446 	if (chan >= isp->isp_nchan) {
2447 		isp_prt(isp, ISP_LOGWARN, "%s: bad channel %d", __func__, chan);
2448 		return (ENXIO);
2449 	}
2450 	if (fcp->role == new_role)
2451 		return (0);
2452 	for (was = 0, i = 0; i < isp->isp_nchan; i++) {
2453 		if (FCPARAM(isp, i)->role != ISP_ROLE_NONE)
2454 			was++;
2455 	}
2456 	if (was == 0 || (was == 1 && fcp->role != ISP_ROLE_NONE)) {
2457 		fcp->role = new_role;
2458 		return (isp_reinit(isp, 0));
2459 	}
2460 	if (fcp->role != ISP_ROLE_NONE) {
2461 		res = isp_fc_disable_vp(isp, chan);
2462 		isp_clear_portdb(isp, chan);
2463 	}
2464 	fcp->role = new_role;
2465 	if (fcp->role != ISP_ROLE_NONE)
2466 		res = isp_fc_enable_vp(isp, chan);
2467 	return (res);
2468 }
2469 
2470 static void
2471 isp_clear_portdb(ispsoftc_t *isp, int chan)
2472 {
2473 	fcparam *fcp = FCPARAM(isp, chan);
2474 	fcportdb_t *lp;
2475 	int i;
2476 
2477 	for (i = 0; i < MAX_FC_TARG; i++) {
2478 		lp = &fcp->portdb[i];
2479 		switch (lp->state) {
2480 		case FC_PORTDB_STATE_DEAD:
2481 		case FC_PORTDB_STATE_CHANGED:
2482 		case FC_PORTDB_STATE_VALID:
2483 			lp->state = FC_PORTDB_STATE_NIL;
2484 			isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
2485 			break;
2486 		case FC_PORTDB_STATE_NIL:
2487 		case FC_PORTDB_STATE_NEW:
2488 			lp->state = FC_PORTDB_STATE_NIL;
2489 			break;
2490 		case FC_PORTDB_STATE_ZOMBIE:
2491 			break;
2492 		default:
2493 			panic("Don't know how to clear state %d\n", lp->state);
2494 		}
2495 	}
2496 }
2497 
2498 static void
2499 isp_mark_portdb(ispsoftc_t *isp, int chan)
2500 {
2501 	fcparam *fcp = FCPARAM(isp, chan);
2502 	fcportdb_t *lp;
2503 	int i;
2504 
2505 	for (i = 0; i < MAX_FC_TARG; i++) {
2506 		lp = &fcp->portdb[i];
2507 		if (lp->state == FC_PORTDB_STATE_NIL)
2508 			continue;
2509 		if (lp->portid >= DOMAIN_CONTROLLER_BASE &&
2510 		    lp->portid <= DOMAIN_CONTROLLER_END)
2511 			continue;
2512 		fcp->portdb[i].probational = 1;
2513 	}
2514 }
2515 
2516 /*
2517  * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2518  * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2519  */
2520 static int
2521 isp_plogx(ispsoftc_t *isp, int chan, uint16_t handle, uint32_t portid, int flags)
2522 {
2523 	isp_plogx_t pl;
2524 	void *reqp;
2525 	uint8_t resp[QENTRY_LEN];
2526 	uint32_t sst, parm1;
2527 	int rval, lev;
2528 	const char *msg;
2529 	char buf[64];
2530 
2531 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d PLOGX %s PortID 0x%06x nphdl 0x%x",
2532 	    chan, (flags & PLOGX_FLG_CMD_MASK) == PLOGX_FLG_CMD_PLOGI ?
2533 	    "Login":"Logout", portid, handle);
2534 	if (!IS_24XX(isp)) {
2535 		int action = flags & PLOGX_FLG_CMD_MASK;
2536 		if (action == PLOGX_FLG_CMD_PLOGI) {
2537 			return (isp_port_login(isp, handle, portid));
2538 		} else if (action == PLOGX_FLG_CMD_LOGO) {
2539 			return (isp_port_logout(isp, handle, portid));
2540 		} else {
2541 			return (MBOX_INVALID_COMMAND);
2542 		}
2543 	}
2544 
2545 	ISP_MEMZERO(&pl, sizeof(pl));
2546 	pl.plogx_header.rqs_entry_count = 1;
2547 	pl.plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2548 	pl.plogx_nphdl = handle;
2549 	pl.plogx_vphdl = chan;
2550 	pl.plogx_portlo = portid;
2551 	pl.plogx_rspsz_porthi = (portid >> 16) & 0xff;
2552 	pl.plogx_flags = flags;
2553 
2554 	/* Prepare space for response in memory */
2555 	memset(resp, 0xff, sizeof(resp));
2556 	pl.plogx_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
2557 	if (pl.plogx_handle == 0) {
2558 		isp_prt(isp, ISP_LOGERR,
2559 		    "%s: PLOGX of Chan %d out of handles", __func__, chan);
2560 		return (-1);
2561 	}
2562 
2563 	/* Send request and wait for response. */
2564 	reqp = isp_getrqentry(isp);
2565 	if (reqp == NULL) {
2566 		isp_prt(isp, ISP_LOGERR,
2567 		    "%s: PLOGX of Chan %d out of rqent", __func__, chan);
2568 		isp_destroy_handle(isp, pl.plogx_handle);
2569 		return (-1);
2570 	}
2571 	isp_put_plogx(isp, &pl, (isp_plogx_t *)reqp);
2572 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2573 		isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, reqp);
2574 	FCPARAM(isp, chan)->isp_login_hdl = handle;
2575 	ISP_SYNC_REQUEST(isp);
2576 	if (msleep(resp, &isp->isp_lock, 0, "PLOGX", 3 * ICB_LOGIN_TOV * hz)
2577 	    == EWOULDBLOCK) {
2578 		isp_prt(isp, ISP_LOGERR,
2579 		    "%s: PLOGX of Chan %d timed out", __func__, chan);
2580 		isp_destroy_handle(isp, pl.plogx_handle);
2581 		return (-1);
2582 	}
2583 	FCPARAM(isp, chan)->isp_login_hdl = NIL_HANDLE;
2584 	if (isp->isp_dblev & ISP_LOGDEBUG1)
2585 		isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, resp);
2586 	isp_get_plogx(isp, (isp_plogx_t *)resp, &pl);
2587 
2588 	if (pl.plogx_status == PLOGX_STATUS_OK) {
2589 		return (0);
2590 	} else if (pl.plogx_status != PLOGX_STATUS_IOCBERR) {
2591 		isp_prt(isp, ISP_LOGWARN,
2592 		    "status 0x%x on port login IOCB channel %d",
2593 		    pl.plogx_status, chan);
2594 		return (-1);
2595 	}
2596 
2597 	sst = pl.plogx_ioparm[0].lo16 | (pl.plogx_ioparm[0].hi16 << 16);
2598 	parm1 = pl.plogx_ioparm[1].lo16 | (pl.plogx_ioparm[1].hi16 << 16);
2599 
2600 	rval = -1;
2601 	lev = ISP_LOGERR;
2602 	msg = NULL;
2603 
2604 	switch (sst) {
2605 	case PLOGX_IOCBERR_NOLINK:
2606 		msg = "no link";
2607 		break;
2608 	case PLOGX_IOCBERR_NOIOCB:
2609 		msg = "no IOCB buffer";
2610 		break;
2611 	case PLOGX_IOCBERR_NOXGHG:
2612 		msg = "no Exchange Control Block";
2613 		break;
2614 	case PLOGX_IOCBERR_FAILED:
2615 		ISP_SNPRINTF(buf, sizeof (buf), "reason 0x%x (last LOGIN state 0x%x)", parm1 & 0xff, (parm1 >> 8) & 0xff);
2616 		msg = buf;
2617 		break;
2618 	case PLOGX_IOCBERR_NOFABRIC:
2619 		msg = "no fabric";
2620 		break;
2621 	case PLOGX_IOCBERR_NOTREADY:
2622 		msg = "firmware not ready";
2623 		break;
2624 	case PLOGX_IOCBERR_NOLOGIN:
2625 		ISP_SNPRINTF(buf, sizeof (buf), "not logged in (last state 0x%x)", parm1);
2626 		msg = buf;
2627 		rval = MBOX_NOT_LOGGED_IN;
2628 		break;
2629 	case PLOGX_IOCBERR_REJECT:
2630 		ISP_SNPRINTF(buf, sizeof (buf), "LS_RJT = 0x%x", parm1);
2631 		msg = buf;
2632 		break;
2633 	case PLOGX_IOCBERR_NOPCB:
2634 		msg = "no PCB allocated";
2635 		break;
2636 	case PLOGX_IOCBERR_EINVAL:
2637 		ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2638 		msg = buf;
2639 		break;
2640 	case PLOGX_IOCBERR_PORTUSED:
2641 		lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2642 		ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2643 		msg = buf;
2644 		rval = MBOX_PORT_ID_USED | (parm1 << 16);
2645 		break;
2646 	case PLOGX_IOCBERR_HNDLUSED:
2647 		lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2648 		ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2649 		msg = buf;
2650 		rval = MBOX_LOOP_ID_USED;
2651 		break;
2652 	case PLOGX_IOCBERR_NOHANDLE:
2653 		msg = "no handle allocated";
2654 		break;
2655 	case PLOGX_IOCBERR_NOFLOGI:
2656 		msg = "no FLOGI_ACC";
2657 		break;
2658 	default:
2659 		ISP_SNPRINTF(buf, sizeof (buf), "status %x from %x", pl.plogx_status, flags);
2660 		msg = buf;
2661 		break;
2662 	}
2663 	if (msg) {
2664 		isp_prt(isp, lev, "Chan %d PLOGX PortID 0x%06x to N-Port handle 0x%x: %s",
2665 		    chan, portid, handle, msg);
2666 	}
2667 	return (rval);
2668 }
2669 
2670 static int
2671 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2672 {
2673 	mbreg_t mbs;
2674 
2675 	MBSINIT(&mbs, MBOX_FABRIC_LOGIN, MBLOGNONE, 500000);
2676 	if (ISP_CAP_2KLOGIN(isp)) {
2677 		mbs.param[1] = handle;
2678 		mbs.ibits = (1 << 10);
2679 	} else {
2680 		mbs.param[1] = handle << 8;
2681 	}
2682 	mbs.param[2] = portid >> 16;
2683 	mbs.param[3] = portid;
2684 	mbs.logval = MBLOGNONE;
2685 	mbs.timeout = 500000;
2686 	isp_mboxcmd(isp, &mbs);
2687 
2688 	switch (mbs.param[0]) {
2689 	case MBOX_PORT_ID_USED:
2690 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: portid 0x%06x already logged in as 0x%x", portid, mbs.param[1]);
2691 		return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2692 
2693 	case MBOX_LOOP_ID_USED:
2694 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: handle 0x%x in use for port id 0x%02xXXXX", handle, mbs.param[1] & 0xff);
2695 		return (MBOX_LOOP_ID_USED);
2696 
2697 	case MBOX_COMMAND_COMPLETE:
2698 		return (0);
2699 
2700 	case MBOX_COMMAND_ERROR:
2701 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: error 0x%x in PLOGI to port 0x%06x", mbs.param[1], portid);
2702 		return (MBOX_COMMAND_ERROR);
2703 
2704 	case MBOX_ALL_IDS_USED:
2705 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2706 		return (MBOX_ALL_IDS_USED);
2707 
2708 	default:
2709 		isp_prt(isp, ISP_LOG_SANCFG, "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x", mbs.param[0], portid, handle);
2710 		return (mbs.param[0]);
2711 	}
2712 }
2713 
2714 /*
2715  * Pre-24XX fabric port logout
2716  *
2717  * Note that portid is not used
2718  */
2719 static int
2720 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2721 {
2722 	mbreg_t mbs;
2723 
2724 	MBSINIT(&mbs, MBOX_FABRIC_LOGOUT, MBLOGNONE, 500000);
2725 	if (ISP_CAP_2KLOGIN(isp)) {
2726 		mbs.param[1] = handle;
2727 		mbs.ibits = (1 << 10);
2728 	} else {
2729 		mbs.param[1] = handle << 8;
2730 	}
2731 	isp_mboxcmd(isp, &mbs);
2732 	return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2733 }
2734 
2735 static int
2736 isp_getpdb(ispsoftc_t *isp, int chan, uint16_t id, isp_pdb_t *pdb)
2737 {
2738 	mbreg_t mbs;
2739 	union {
2740 		isp_pdb_21xx_t fred;
2741 		isp_pdb_24xx_t bill;
2742 	} un;
2743 
2744 	MBSINIT(&mbs, MBOX_GET_PORT_DB,
2745 	    MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 250000);
2746 	if (IS_24XX(isp)) {
2747 		mbs.ibits = (1 << 9)|(1 << 10);
2748 		mbs.param[1] = id;
2749 		mbs.param[9] = chan;
2750 	} else if (ISP_CAP_2KLOGIN(isp)) {
2751 		mbs.param[1] = id;
2752 	} else {
2753 		mbs.param[1] = id << 8;
2754 	}
2755 	mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
2756 	mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
2757 	mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
2758 	mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
2759 	MEMORYBARRIER(isp, SYNC_IFORDEV, 0, sizeof(un), chan);
2760 
2761 	isp_mboxcmd(isp, &mbs);
2762 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
2763 		return (mbs.param[0] | (mbs.param[1] << 16));
2764 
2765 	MEMORYBARRIER(isp, SYNC_IFORCPU, 0, sizeof(un), chan);
2766 	if (IS_24XX(isp)) {
2767 		isp_get_pdb_24xx(isp, isp->isp_iocb, &un.bill);
2768 		pdb->handle = un.bill.pdb_handle;
2769 		pdb->prli_word3 = un.bill.pdb_prli_svc3;
2770 		pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2771 		ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2772 		ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2773 		isp_prt(isp, ISP_LOGDEBUG0,
2774 		    "Chan %d handle 0x%x Port 0x%06x flags 0x%x curstate %x laststate %x",
2775 		    chan, id, pdb->portid, un.bill.pdb_flags,
2776 		    un.bill.pdb_curstate, un.bill.pdb_laststate);
2777 
2778 		if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2779 			mbs.param[0] = MBOX_NOT_LOGGED_IN;
2780 			return (mbs.param[0]);
2781 		}
2782 	} else {
2783 		isp_get_pdb_21xx(isp, isp->isp_iocb, &un.fred);
2784 		pdb->handle = un.fred.pdb_loopid;
2785 		pdb->prli_word3 = un.fred.pdb_prli_svc3;
2786 		pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2787 		ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2788 		ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2789 		isp_prt(isp, ISP_LOGDEBUG1,
2790 		    "Chan %d handle 0x%x Port 0x%06x", chan, id, pdb->portid);
2791 	}
2792 	return (0);
2793 }
2794 
2795 static int
2796 isp_gethandles(ispsoftc_t *isp, int chan, uint16_t *handles, int *num, int loop)
2797 {
2798 	fcparam *fcp = FCPARAM(isp, chan);
2799 	mbreg_t mbs;
2800 	isp_pnhle_21xx_t el1, *elp1;
2801 	isp_pnhle_23xx_t el3, *elp3;
2802 	isp_pnhle_24xx_t el4, *elp4;
2803 	int i, j;
2804 	uint32_t p;
2805 	uint16_t h;
2806 
2807 	MBSINIT(&mbs, MBOX_GET_ID_LIST, MBLOGALL, 250000);
2808 	if (IS_24XX(isp)) {
2809 		mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2810 		mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2811 		mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2812 		mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2813 		mbs.param[8] = ISP_FC_SCRLEN;
2814 		mbs.param[9] = chan;
2815 	} else {
2816 		mbs.ibits = (1 << 1)|(1 << 2)|(1 << 3)|(1 << 6);
2817 		mbs.param[1] = DMA_WD1(fcp->isp_scdma);
2818 		mbs.param[2] = DMA_WD0(fcp->isp_scdma);
2819 		mbs.param[3] = DMA_WD3(fcp->isp_scdma);
2820 		mbs.param[6] = DMA_WD2(fcp->isp_scdma);
2821 	}
2822 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
2823 		isp_prt(isp, ISP_LOGERR, sacq);
2824 		return (-1);
2825 	}
2826 	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, ISP_FC_SCRLEN, chan);
2827 	isp_mboxcmd(isp, &mbs);
2828 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2829 		FC_SCRATCH_RELEASE(isp, chan);
2830 		return (mbs.param[0] | (mbs.param[1] << 16));
2831 	}
2832 	MEMORYBARRIER(isp, SYNC_SFORCPU, 0, ISP_FC_SCRLEN, chan);
2833 	elp1 = fcp->isp_scratch;
2834 	elp3 = fcp->isp_scratch;
2835 	elp4 = fcp->isp_scratch;
2836 	for (i = 0, j = 0; i < mbs.param[1] && j < *num; i++) {
2837 		if (IS_24XX(isp)) {
2838 			isp_get_pnhle_24xx(isp, &elp4[i], &el4);
2839 			p = el4.pnhle_port_id_lo |
2840 			    (el4.pnhle_port_id_hi << 16);
2841 			h = el4.pnhle_handle;
2842 		} else if (IS_23XX(isp)) {
2843 			isp_get_pnhle_23xx(isp, &elp3[i], &el3);
2844 			p = el3.pnhle_port_id_lo |
2845 			    (el3.pnhle_port_id_hi << 16);
2846 			h = el3.pnhle_handle;
2847 		} else { /* 21xx */
2848 			isp_get_pnhle_21xx(isp, &elp1[i], &el1);
2849 			p = el1.pnhle_port_id_lo |
2850 			    ((el1.pnhle_port_id_hi_handle & 0xff) << 16);
2851 			h = el1.pnhle_port_id_hi_handle >> 8;
2852 		}
2853 		if (loop && (p >> 8) != (fcp->isp_portid >> 8))
2854 			continue;
2855 		handles[j++] = h;
2856 	}
2857 	*num = j;
2858 	FC_SCRATCH_RELEASE(isp, chan);
2859 	return (0);
2860 }
2861 
2862 static void
2863 isp_dump_chip_portdb(ispsoftc_t *isp, int chan)
2864 {
2865 	isp_pdb_t pdb;
2866 	uint16_t lim, nphdl;
2867 
2868 	isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d chip port dump", chan);
2869 	if (ISP_CAP_2KLOGIN(isp)) {
2870 		lim = NPH_MAX_2K;
2871 	} else {
2872 		lim = NPH_MAX;
2873 	}
2874 	for (nphdl = 0; nphdl != lim; nphdl++) {
2875 		if (isp_getpdb(isp, chan, nphdl, &pdb)) {
2876 			continue;
2877 		}
2878 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Handle 0x%04x "
2879 		    "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2880 		    chan, nphdl, pdb.portid, pdb.portname[0], pdb.portname[1],
2881 		    pdb.portname[2], pdb.portname[3], pdb.portname[4],
2882 		    pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2883 	}
2884 }
2885 
2886 static uint64_t
2887 isp_get_wwn(ispsoftc_t *isp, int chan, int nphdl, int nodename)
2888 {
2889 	uint64_t wwn = INI_NONE;
2890 	mbreg_t mbs;
2891 
2892 	MBSINIT(&mbs, MBOX_GET_PORT_NAME,
2893 	    MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_PARAM_ERROR), 500000);
2894 	if (ISP_CAP_2KLOGIN(isp)) {
2895 		mbs.param[1] = nphdl;
2896 		if (nodename) {
2897 			mbs.param[10] = 1;
2898 		}
2899 		mbs.param[9] = chan;
2900 	} else {
2901 		mbs.ibitm = 3;
2902 		mbs.param[1] = nphdl << 8;
2903 		if (nodename) {
2904 			mbs.param[1] |= 1;
2905 		}
2906 	}
2907 	isp_mboxcmd(isp, &mbs);
2908 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2909 		return (wwn);
2910 	}
2911 	if (IS_24XX(isp)) {
2912 		wwn =
2913 		    (((uint64_t)(mbs.param[2] >> 8))	<< 56) |
2914 		    (((uint64_t)(mbs.param[2] & 0xff))	<< 48) |
2915 		    (((uint64_t)(mbs.param[3] >> 8))	<< 40) |
2916 		    (((uint64_t)(mbs.param[3] & 0xff))	<< 32) |
2917 		    (((uint64_t)(mbs.param[6] >> 8))	<< 24) |
2918 		    (((uint64_t)(mbs.param[6] & 0xff))	<< 16) |
2919 		    (((uint64_t)(mbs.param[7] >> 8))	<<  8) |
2920 		    (((uint64_t)(mbs.param[7] & 0xff)));
2921 	} else {
2922 		wwn =
2923 		    (((uint64_t)(mbs.param[2] & 0xff))  << 56) |
2924 		    (((uint64_t)(mbs.param[2] >> 8))	<< 48) |
2925 		    (((uint64_t)(mbs.param[3] & 0xff))	<< 40) |
2926 		    (((uint64_t)(mbs.param[3] >> 8))	<< 32) |
2927 		    (((uint64_t)(mbs.param[6] & 0xff))	<< 24) |
2928 		    (((uint64_t)(mbs.param[6] >> 8))	<< 16) |
2929 		    (((uint64_t)(mbs.param[7] & 0xff))	<<  8) |
2930 		    (((uint64_t)(mbs.param[7] >> 8)));
2931 	}
2932 	return (wwn);
2933 }
2934 
2935 /*
2936  * Make sure we have good FC link.
2937  */
2938 
2939 static int
2940 isp_fclink_test(ispsoftc_t *isp, int chan, int usdelay)
2941 {
2942 	mbreg_t mbs;
2943 	int i, r;
2944 	uint16_t nphdl;
2945 	fcparam *fcp;
2946 	isp_pdb_t pdb;
2947 	NANOTIME_T hra, hrb;
2948 
2949 	fcp = FCPARAM(isp, chan);
2950 
2951 	if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2952 		return (-1);
2953 	if (fcp->isp_loopstate >= LOOP_LTEST_DONE)
2954 		return (0);
2955 
2956 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test", chan);
2957 
2958 	/*
2959 	 * Wait up to N microseconds for F/W to go to a ready state.
2960 	 */
2961 	GET_NANOTIME(&hra);
2962 	while (1) {
2963 		isp_change_fw_state(isp, chan, isp_fw_state(isp, chan));
2964 		if (fcp->isp_fwstate == FW_READY) {
2965 			break;
2966 		}
2967 		if (fcp->isp_loopstate < LOOP_HAVE_LINK)
2968 			goto abort;
2969 		GET_NANOTIME(&hrb);
2970 		if ((NANOTIME_SUB(&hrb, &hra) / 1000 + 1000 >= usdelay))
2971 			break;
2972 		ISP_SLEEP(isp, 1000);
2973 	}
2974 	if (fcp->isp_fwstate != FW_READY) {
2975 		isp_prt(isp, ISP_LOG_SANCFG,
2976 		    "Chan %d Firmware is not ready (%s)",
2977 		    chan, isp_fc_fw_statename(fcp->isp_fwstate));
2978 		return (-1);
2979 	}
2980 
2981 	/*
2982 	 * Get our Loop ID and Port ID.
2983 	 */
2984 	MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2985 	mbs.param[9] = chan;
2986 	isp_mboxcmd(isp, &mbs);
2987 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2988 		return (-1);
2989 	}
2990 
2991 	if (IS_2100(isp)) {
2992 		/*
2993 		 * Don't bother with fabric if we are using really old
2994 		 * 2100 firmware. It's just not worth it.
2995 		 */
2996 		if (ISP_FW_NEWER_THAN(isp, 1, 15, 37))
2997 			fcp->isp_topo = TOPO_FL_PORT;
2998 		else
2999 			fcp->isp_topo = TOPO_NL_PORT;
3000 	} else {
3001 		int topo = (int) mbs.param[6];
3002 		if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
3003 			topo = TOPO_PTP_STUB;
3004 		}
3005 		fcp->isp_topo = topo;
3006 	}
3007 	fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
3008 
3009 	if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3010 		fcp->isp_loopid = mbs.param[1] & 0xff;
3011 	} else if (fcp->isp_topo != TOPO_F_PORT) {
3012 		uint8_t alpa = fcp->isp_portid;
3013 
3014 		for (i = 0; alpa_map[i]; i++) {
3015 			if (alpa_map[i] == alpa)
3016 				break;
3017 		}
3018 		if (alpa_map[i])
3019 			fcp->isp_loopid = i;
3020 	}
3021 
3022 #if 0
3023 	fcp->isp_loopstate = LOOP_HAVE_ADDR;
3024 #endif
3025 	fcp->isp_loopstate = LOOP_TESTING_LINK;
3026 
3027 	if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
3028 		nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3029 		r = isp_getpdb(isp, chan, nphdl, &pdb);
3030 		if (r != 0 || pdb.portid == 0) {
3031 			if (IS_2100(isp)) {
3032 				fcp->isp_topo = TOPO_NL_PORT;
3033 			} else {
3034 				isp_prt(isp, ISP_LOGWARN,
3035 				    "fabric topology, but cannot get info about fabric controller (0x%x)", r);
3036 				fcp->isp_topo = TOPO_PTP_STUB;
3037 			}
3038 			goto not_on_fabric;
3039 		}
3040 
3041 		if (IS_24XX(isp)) {
3042 			fcp->isp_fabric_params = mbs.param[7];
3043 			fcp->isp_sns_hdl = NPH_SNS_ID;
3044 			r = isp_register_fc4_type(isp, chan);
3045 			if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3046 				goto abort;
3047 			if (r != 0)
3048 				goto not_on_fabric;
3049 			r = isp_register_fc4_features_24xx(isp, chan);
3050 			if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3051 				goto abort;
3052 			if (r != 0)
3053 				goto not_on_fabric;
3054 			r = isp_register_port_name_24xx(isp, chan);
3055 			if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3056 				goto abort;
3057 			if (r != 0)
3058 				goto not_on_fabric;
3059 			isp_register_node_name_24xx(isp, chan);
3060 			if (fcp->isp_loopstate < LOOP_TESTING_LINK)
3061 				goto abort;
3062 		} else {
3063 			fcp->isp_sns_hdl = SNS_ID;
3064 			r = isp_register_fc4_type(isp, chan);
3065 			if (r != 0)
3066 				goto not_on_fabric;
3067 			if (fcp->role == ISP_ROLE_TARGET)
3068 				isp_send_change_request(isp, chan);
3069 		}
3070 	}
3071 
3072 not_on_fabric:
3073 	/* Get link speed. */
3074 	fcp->isp_gbspeed = 1;
3075 	if (IS_23XX(isp) || IS_24XX(isp)) {
3076 		MBSINIT(&mbs, MBOX_GET_SET_DATA_RATE, MBLOGALL, 3000000);
3077 		mbs.param[1] = MBGSD_GET_RATE;
3078 		/* mbs.param[2] undefined if we're just getting rate */
3079 		isp_mboxcmd(isp, &mbs);
3080 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3081 			if (mbs.param[1] == MBGSD_10GB)
3082 				fcp->isp_gbspeed = 10;
3083 			else if (mbs.param[1] == MBGSD_16GB)
3084 				fcp->isp_gbspeed = 16;
3085 			else if (mbs.param[1] == MBGSD_8GB)
3086 				fcp->isp_gbspeed = 8;
3087 			else if (mbs.param[1] == MBGSD_4GB)
3088 				fcp->isp_gbspeed = 4;
3089 			else if (mbs.param[1] == MBGSD_2GB)
3090 				fcp->isp_gbspeed = 2;
3091 			else if (mbs.param[1] == MBGSD_1GB)
3092 				fcp->isp_gbspeed = 1;
3093 		}
3094 	}
3095 
3096 	if (fcp->isp_loopstate < LOOP_TESTING_LINK) {
3097 abort:
3098 		isp_prt(isp, ISP_LOG_SANCFG,
3099 		    "Chan %d FC link test aborted", chan);
3100 		return (1);
3101 	}
3102 	fcp->isp_loopstate = LOOP_LTEST_DONE;
3103 	isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3104 	    "Chan %d WWPN %016jx WWNN %016jx",
3105 	    chan, (uintmax_t)fcp->isp_wwpn, (uintmax_t)fcp->isp_wwnn);
3106 	isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG,
3107 	    "Chan %d %dGb %s PortID 0x%06x LoopID 0x%02x",
3108 	    chan, fcp->isp_gbspeed, isp_fc_toponame(fcp), fcp->isp_portid,
3109 	    fcp->isp_loopid);
3110 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC link test done", chan);
3111 	return (0);
3112 }
3113 
3114 /*
3115  * Complete the synchronization of our Port Database.
3116  *
3117  * At this point, we've scanned the local loop (if any) and the fabric
3118  * and performed fabric logins on all new devices.
3119  *
3120  * Our task here is to go through our port database removing any entities
3121  * that are still marked probational (issuing PLOGO for ones which we had
3122  * PLOGI'd into) or are dead, and notifying upper layers about new/changed
3123  * devices.
3124  */
3125 static int
3126 isp_pdb_sync(ispsoftc_t *isp, int chan)
3127 {
3128 	fcparam *fcp = FCPARAM(isp, chan);
3129 	fcportdb_t *lp;
3130 	uint16_t dbidx;
3131 
3132 	if (fcp->isp_loopstate < LOOP_FSCAN_DONE)
3133 		return (-1);
3134 	if (fcp->isp_loopstate >= LOOP_READY)
3135 		return (0);
3136 
3137 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync", chan);
3138 
3139 	fcp->isp_loopstate = LOOP_SYNCING_PDB;
3140 
3141 	for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3142 		lp = &fcp->portdb[dbidx];
3143 
3144 		if (lp->state == FC_PORTDB_STATE_NIL)
3145 			continue;
3146 		if (lp->probational && lp->state != FC_PORTDB_STATE_ZOMBIE)
3147 			lp->state = FC_PORTDB_STATE_DEAD;
3148 		switch (lp->state) {
3149 		case FC_PORTDB_STATE_DEAD:
3150 			lp->state = FC_PORTDB_STATE_NIL;
3151 			isp_async(isp, ISPASYNC_DEV_GONE, chan, lp);
3152 			if ((lp->portid & 0xffff00) != 0) {
3153 				(void) isp_plogx(isp, chan, lp->handle,
3154 				    lp->portid,
3155 				    PLOGX_FLG_CMD_LOGO |
3156 				    PLOGX_FLG_IMPLICIT |
3157 				    PLOGX_FLG_FREE_NPHDL);
3158 			}
3159 			/*
3160 			 * Note that we might come out of this with our state
3161 			 * set to FC_PORTDB_STATE_ZOMBIE.
3162 			 */
3163 			break;
3164 		case FC_PORTDB_STATE_NEW:
3165 			lp->state = FC_PORTDB_STATE_VALID;
3166 			isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
3167 			break;
3168 		case FC_PORTDB_STATE_CHANGED:
3169 			lp->state = FC_PORTDB_STATE_VALID;
3170 			isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3171 			lp->portid = lp->new_portid;
3172 			lp->prli_word3 = lp->new_prli_word3;
3173 			break;
3174 		case FC_PORTDB_STATE_VALID:
3175 			isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3176 			break;
3177 		case FC_PORTDB_STATE_ZOMBIE:
3178 			break;
3179 		default:
3180 			isp_prt(isp, ISP_LOGWARN,
3181 			    "isp_pdb_sync: state %d for idx %d",
3182 			    lp->state, dbidx);
3183 			isp_dump_portdb(isp, chan);
3184 		}
3185 	}
3186 
3187 	if (fcp->isp_loopstate < LOOP_SYNCING_PDB) {
3188 		isp_prt(isp, ISP_LOG_SANCFG,
3189 		    "Chan %d FC PDB sync aborted", chan);
3190 		return (1);
3191 	}
3192 
3193 	fcp->isp_loopstate = LOOP_READY;
3194 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC PDB sync done", chan);
3195 	return (0);
3196 }
3197 
3198 static void
3199 isp_pdb_add_update(ispsoftc_t *isp, int chan, isp_pdb_t *pdb)
3200 {
3201 	fcportdb_t *lp;
3202 	uint64_t wwnn, wwpn;
3203 
3204 	MAKE_WWN_FROM_NODE_NAME(wwnn, pdb->nodename);
3205 	MAKE_WWN_FROM_NODE_NAME(wwpn, pdb->portname);
3206 
3207 	/* Search port database for the same WWPN. */
3208 	if (isp_find_pdb_by_wwpn(isp, chan, wwpn, &lp)) {
3209 		if (!lp->probational) {
3210 			isp_prt(isp, ISP_LOGERR,
3211 			    "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3212 			    chan, lp->portid, lp->handle,
3213 			    FC_PORTDB_TGT(isp, chan, lp), lp->state);
3214 			isp_dump_portdb(isp, chan);
3215 			return;
3216 		}
3217 		lp->probational = 0;
3218 		lp->node_wwn = wwnn;
3219 
3220 		/* Old device, nothing new. */
3221 		if (lp->portid == pdb->portid &&
3222 		    lp->handle == pdb->handle &&
3223 		    lp->prli_word3 == pdb->prli_word3) {
3224 			if (lp->state != FC_PORTDB_STATE_NEW)
3225 				lp->state = FC_PORTDB_STATE_VALID;
3226 			isp_prt(isp, ISP_LOG_SANCFG,
3227 			    "Chan %d Port 0x%06x@0x%04x is valid",
3228 			    chan, pdb->portid, pdb->handle);
3229 			return;
3230 		}
3231 
3232 		/* Something has changed. */
3233 		lp->state = FC_PORTDB_STATE_CHANGED;
3234 		lp->handle = pdb->handle;
3235 		lp->new_portid = pdb->portid;
3236 		lp->new_prli_word3 = pdb->prli_word3;
3237 		isp_prt(isp, ISP_LOG_SANCFG,
3238 		    "Chan %d Port 0x%06x@0x%04x is changed",
3239 		    chan, pdb->portid, pdb->handle);
3240 		return;
3241 	}
3242 
3243 	/* It seems like a new port. Find an empty slot for it. */
3244 	if (!isp_find_pdb_empty(isp, chan, &lp)) {
3245 		isp_prt(isp, ISP_LOGERR, "Chan %d out of portdb entries", chan);
3246 		return;
3247 	}
3248 
3249 	ISP_MEMZERO(lp, sizeof (fcportdb_t));
3250 	lp->probational = 0;
3251 	lp->state = FC_PORTDB_STATE_NEW;
3252 	lp->portid = lp->new_portid = pdb->portid;
3253 	lp->prli_word3 = lp->new_prli_word3 = pdb->prli_word3;
3254 	lp->handle = pdb->handle;
3255 	lp->port_wwn = wwpn;
3256 	lp->node_wwn = wwnn;
3257 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x@0x%04x is new",
3258 	    chan, pdb->portid, pdb->handle);
3259 }
3260 
3261 /*
3262  * Fix port IDs for logged-in initiators on pre-2400 chips.
3263  * For those chips we are not receiving login events, adding initiators
3264  * based on ATIO requests, but there is no port ID in that structure.
3265  */
3266 static void
3267 isp_fix_portids(ispsoftc_t *isp, int chan)
3268 {
3269 	fcparam *fcp = FCPARAM(isp, chan);
3270 	isp_pdb_t pdb;
3271 	uint64_t wwpn;
3272 	int i, r;
3273 
3274 	for (i = 0; i < MAX_FC_TARG; i++) {
3275 		fcportdb_t *lp = &fcp->portdb[i];
3276 
3277 		if (lp->state == FC_PORTDB_STATE_NIL ||
3278 		    lp->state == FC_PORTDB_STATE_ZOMBIE)
3279 			continue;
3280 		if (VALID_PORT(lp->portid))
3281 			continue;
3282 
3283 		r = isp_getpdb(isp, chan, lp->handle, &pdb);
3284 		if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3285 			return;
3286 		if (r != 0) {
3287 			isp_prt(isp, ISP_LOGDEBUG1,
3288 			    "Chan %d FC Scan Loop handle %d returned %x",
3289 			    chan, lp->handle, r);
3290 			continue;
3291 		}
3292 
3293 		MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3294 		if (lp->port_wwn != wwpn)
3295 			continue;
3296 		lp->portid = lp->new_portid = pdb.portid;
3297 		isp_prt(isp, ISP_LOG_SANCFG,
3298 		    "Chan %d Port 0x%06x@0x%04x is fixed",
3299 		    chan, pdb.portid, pdb.handle);
3300 	}
3301 }
3302 
3303 /*
3304  * Scan local loop for devices.
3305  */
3306 static int
3307 isp_scan_loop(ispsoftc_t *isp, int chan)
3308 {
3309 	fcparam *fcp = FCPARAM(isp, chan);
3310 	int idx, lim, r;
3311 	isp_pdb_t pdb;
3312 	uint16_t *handles;
3313 	uint16_t handle;
3314 
3315 	if (fcp->isp_loopstate < LOOP_LTEST_DONE)
3316 		return (-1);
3317 	if (fcp->isp_loopstate >= LOOP_LSCAN_DONE)
3318 		return (0);
3319 
3320 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan", chan);
3321 	fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3322 	if (TOPO_IS_FABRIC(fcp->isp_topo)) {
3323 		if (!IS_24XX(isp)) {
3324 			isp_fix_portids(isp, chan);
3325 			if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3326 				goto abort;
3327 		}
3328 		isp_prt(isp, ISP_LOG_SANCFG,
3329 		    "Chan %d FC loop scan done (no loop)", chan);
3330 		fcp->isp_loopstate = LOOP_LSCAN_DONE;
3331 		return (0);
3332 	}
3333 
3334 	handles = (uint16_t *)fcp->isp_scanscratch;
3335 	lim = ISP_FC_SCRLEN / 2;
3336 	r = isp_gethandles(isp, chan, handles, &lim, 1);
3337 	if (r != 0) {
3338 		isp_prt(isp, ISP_LOG_SANCFG,
3339 		    "Chan %d Getting list of handles failed with %x", chan, r);
3340 		isp_prt(isp, ISP_LOG_SANCFG,
3341 		    "Chan %d FC loop scan done (bad)", chan);
3342 		return (-1);
3343 	}
3344 
3345 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Got %d handles",
3346 	    chan, lim);
3347 
3348 	/*
3349 	 * Run through the list and get the port database info for each one.
3350 	 */
3351 	isp_mark_portdb(isp, chan);
3352 	for (idx = 0; idx < lim; idx++) {
3353 		handle = handles[idx];
3354 
3355 		/*
3356 		 * Don't scan "special" ids.
3357 		 */
3358 		if (ISP_CAP_2KLOGIN(isp)) {
3359 			if (handle >= NPH_RESERVED)
3360 				continue;
3361 		} else {
3362 			if (handle >= FL_ID && handle <= SNS_ID)
3363 				continue;
3364 		}
3365 
3366 		/*
3367 		 * In older cards with older f/w GET_PORT_DATABASE has been
3368 		 * known to hang. This trick gets around that problem.
3369 		 */
3370 		if (IS_2100(isp) || IS_2200(isp)) {
3371 			uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3372 			if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3373 abort:
3374 				isp_prt(isp, ISP_LOG_SANCFG,
3375 				    "Chan %d FC loop scan aborted", chan);
3376 				return (1);
3377 			}
3378 			if (node_wwn == INI_NONE) {
3379 				continue;
3380 			}
3381 		}
3382 
3383 		/*
3384 		 * Get the port database entity for this index.
3385 		 */
3386 		r = isp_getpdb(isp, chan, handle, &pdb);
3387 		if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3388 			goto abort;
3389 		if (r != 0) {
3390 			isp_prt(isp, ISP_LOGDEBUG1,
3391 			    "Chan %d FC Scan Loop handle %d returned %x",
3392 			    chan, handle, r);
3393 			continue;
3394 		}
3395 
3396 		isp_pdb_add_update(isp, chan, &pdb);
3397 	}
3398 	if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
3399 		goto abort;
3400 	fcp->isp_loopstate = LOOP_LSCAN_DONE;
3401 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC loop scan done", chan);
3402 	return (0);
3403 }
3404 
3405 static int
3406 isp_ct_sns(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3407 {
3408 	fcparam *fcp = FCPARAM(isp, chan);
3409 	mbreg_t mbs;
3410 
3411 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3412 		isp_print_bytes(isp, "CT SNS request", cmd_bcnt, fcp->isp_scratch);
3413 	MEMORYBARRIER(isp, SYNC_SFORDEV, 0, cmd_bcnt, chan);
3414 
3415 	MBSINIT(&mbs, MBOX_SEND_SNS, MBLOGALL, 10000000);
3416 	mbs.param[1] = cmd_bcnt >> 1;
3417 	mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3418 	mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3419 	mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3420 	mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3421 	isp_mboxcmd(isp, &mbs);
3422 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3423 		if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3424 			return (1);
3425 		} else {
3426 			return (-1);
3427 		}
3428 	}
3429 
3430 	MEMORYBARRIER(isp, SYNC_SFORCPU, 0, rsp_bcnt, chan);
3431 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3432 		isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3433 	return (0);
3434 }
3435 
3436 static int
3437 isp_ct_passthru(ispsoftc_t *isp, int chan, uint32_t cmd_bcnt, uint32_t rsp_bcnt)
3438 {
3439 	fcparam *fcp = FCPARAM(isp, chan);
3440 	isp_ct_pt_t pt;
3441 	void *reqp;
3442 	uint8_t resp[QENTRY_LEN];
3443 
3444 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3445 		isp_print_bytes(isp, "CT request", cmd_bcnt, fcp->isp_scratch);
3446 
3447 	/*
3448 	 * Build a Passthrough IOCB in memory.
3449 	 */
3450 	ISP_MEMZERO(&pt, sizeof(pt));
3451 	pt.ctp_header.rqs_entry_count = 1;
3452 	pt.ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3453 	pt.ctp_nphdl = fcp->isp_sns_hdl;
3454 	pt.ctp_cmd_cnt = 1;
3455 	pt.ctp_vpidx = ISP_GET_VPIDX(isp, chan);
3456 	pt.ctp_time = 10;
3457 	pt.ctp_rsp_cnt = 1;
3458 	pt.ctp_rsp_bcnt = rsp_bcnt;
3459 	pt.ctp_cmd_bcnt = cmd_bcnt;
3460 	pt.ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma);
3461 	pt.ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma);
3462 	pt.ctp_dataseg[0].ds_count = cmd_bcnt;
3463 	pt.ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma);
3464 	pt.ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma);
3465 	pt.ctp_dataseg[1].ds_count = rsp_bcnt;
3466 
3467 	/* Prepare space for response in memory */
3468 	memset(resp, 0xff, sizeof(resp));
3469 	pt.ctp_handle = isp_allocate_handle(isp, resp, ISP_HANDLE_CTRL);
3470 	if (pt.ctp_handle == 0) {
3471 		isp_prt(isp, ISP_LOGERR,
3472 		    "%s: CTP of Chan %d out of handles", __func__, chan);
3473 		return (-1);
3474 	}
3475 
3476 	/* Send request and wait for response. */
3477 	reqp = isp_getrqentry(isp);
3478 	if (reqp == NULL) {
3479 		isp_prt(isp, ISP_LOGERR,
3480 		    "%s: CTP of Chan %d out of rqent", __func__, chan);
3481 		isp_destroy_handle(isp, pt.ctp_handle);
3482 		return (-1);
3483 	}
3484 	isp_put_ct_pt(isp, &pt, (isp_ct_pt_t *)reqp);
3485 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3486 		isp_print_bytes(isp, "CT IOCB request", QENTRY_LEN, reqp);
3487 	ISP_SYNC_REQUEST(isp);
3488 	if (msleep(resp, &isp->isp_lock, 0, "CTP", pt.ctp_time*hz) == EWOULDBLOCK) {
3489 		isp_prt(isp, ISP_LOGERR,
3490 		    "%s: CTP of Chan %d timed out", __func__, chan);
3491 		isp_destroy_handle(isp, pt.ctp_handle);
3492 		return (-1);
3493 	}
3494 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3495 		isp_print_bytes(isp, "CT IOCB response", QENTRY_LEN, resp);
3496 
3497 	isp_get_ct_pt(isp, (isp_ct_pt_t *)resp, &pt);
3498 	if (pt.ctp_status && pt.ctp_status != RQCS_DATA_UNDERRUN) {
3499 		isp_prt(isp, ISP_LOGWARN,
3500 		    "Chan %d CT pass-through returned 0x%x",
3501 		    chan, pt.ctp_status);
3502 		return (-1);
3503 	}
3504 
3505 	if (isp->isp_dblev & ISP_LOGDEBUG1)
3506 		isp_print_bytes(isp, "CT response", rsp_bcnt, fcp->isp_scratch);
3507 
3508 	return (0);
3509 }
3510 
3511 /*
3512  * Scan the fabric for devices and add them to our port database.
3513  *
3514  * Use the GID_PT command to get list of all Nx_Port IDs SNS knows.
3515  * Use GFF_ID and GFT_ID to check port type (FCP) and features (target).
3516  *
3517  * For 2100-23XX cards, we use the SNS mailbox command to pass simple name
3518  * server commands to the switch management server via the QLogic f/w.
3519  *
3520  * For the 24XX and above card, we use CT Pass-through IOCB.
3521  */
3522 #define	GIDLEN	ISP_FC_SCRLEN
3523 #define	NGENT	((GIDLEN - 16) >> 2)
3524 
3525 static int
3526 isp_gid_pt(ispsoftc_t *isp, int chan)
3527 {
3528 	fcparam *fcp = FCPARAM(isp, chan);
3529 	ct_hdr_t ct;
3530 	sns_gid_pt_req_t rq;
3531 	uint8_t *scp = fcp->isp_scratch;
3532 
3533 	isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GID_PT", chan);
3534 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3535 		isp_prt(isp, ISP_LOGERR, sacq);
3536 		return (-1);
3537 	}
3538 
3539 	if (IS_24XX(isp)) {
3540 		/* Build the CT command and execute via pass-through. */
3541 		ISP_MEMZERO(&ct, sizeof (ct));
3542 		ct.ct_revision = CT_REVISION;
3543 		ct.ct_fcs_type = CT_FC_TYPE_FC;
3544 		ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3545 		ct.ct_cmd_resp = SNS_GID_PT;
3546 		ct.ct_bcnt_resid = (GIDLEN - 16) >> 2;
3547 		isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3548 		scp[sizeof(ct)] = 0x7f;		/* Port Type = Nx_Port */
3549 		scp[sizeof(ct)+1] = 0;		/* Domain_ID = any */
3550 		scp[sizeof(ct)+2] = 0;		/* Area_ID = any */
3551 		scp[sizeof(ct)+3] = 0;		/* Flags = no Area_ID */
3552 
3553 		if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t), GIDLEN)) {
3554 			FC_SCRATCH_RELEASE(isp, chan);
3555 			return (-1);
3556 		}
3557 	} else {
3558 		/* Build the SNS request and execute via firmware. */
3559 		ISP_MEMZERO(&rq, SNS_GID_PT_REQ_SIZE);
3560 		rq.snscb_rblen = GIDLEN >> 1;
3561 		rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3562 		rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3563 		rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3564 		rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3565 		rq.snscb_sblen = 6;
3566 		rq.snscb_cmd = SNS_GID_PT;
3567 		rq.snscb_mword_div_2 = NGENT;
3568 		rq.snscb_port_type = 0x7f;	/* Port Type = Nx_Port */
3569 		rq.snscb_domain = 0;		/* Domain_ID = any */
3570 		rq.snscb_area = 0;		/* Area_ID = any */
3571 		rq.snscb_flags = 0;		/* Flags = no Area_ID */
3572 		isp_put_gid_pt_request(isp, &rq, (sns_gid_pt_req_t *)scp);
3573 
3574 		if (isp_ct_sns(isp, chan, sizeof(rq), NGENT)) {
3575 			FC_SCRATCH_RELEASE(isp, chan);
3576 			return (-1);
3577 		}
3578 	}
3579 
3580 	isp_get_gid_xx_response(isp, (sns_gid_xx_rsp_t *)scp,
3581 	    (sns_gid_xx_rsp_t *)fcp->isp_scanscratch, NGENT);
3582 	FC_SCRATCH_RELEASE(isp, chan);
3583 	return (0);
3584 }
3585 
3586 static int
3587 isp_gff_id(ispsoftc_t *isp, int chan, uint32_t portid)
3588 {
3589 	fcparam *fcp = FCPARAM(isp, chan);
3590 	ct_hdr_t ct;
3591 	uint32_t *rp;
3592 	uint8_t *scp = fcp->isp_scratch;
3593 	sns_gff_id_rsp_t rsp;
3594 	int i, res = -1;
3595 
3596 	if (!fcp->isp_use_gff_id)	/* User may block GFF_ID use. */
3597 		return (res);
3598 
3599 	if (!IS_24XX(isp))	/* Old chips can't request GFF_ID. */
3600 		return (res);
3601 
3602 	isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFF_ID", chan);
3603 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3604 		isp_prt(isp, ISP_LOGERR, sacq);
3605 		return (res);
3606 	}
3607 
3608 	/* Build the CT command and execute via pass-through. */
3609 	ISP_MEMZERO(&ct, sizeof (ct));
3610 	ct.ct_revision = CT_REVISION;
3611 	ct.ct_fcs_type = CT_FC_TYPE_FC;
3612 	ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3613 	ct.ct_cmd_resp = SNS_GFF_ID;
3614 	ct.ct_bcnt_resid = (SNS_GFF_ID_RESP_SIZE - sizeof(ct)) / 4;
3615 	isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3616 	rp = (uint32_t *) &scp[sizeof(ct)];
3617 	ISP_IOZPUT_32(isp, portid, rp);
3618 
3619 	if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3620 	    SNS_GFF_ID_RESP_SIZE)) {
3621 		FC_SCRATCH_RELEASE(isp, chan);
3622 		return (res);
3623 	}
3624 
3625 	isp_get_gff_id_response(isp, (sns_gff_id_rsp_t *)scp, &rsp);
3626 	if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3627 		for (i = 0; i < 32; i++) {
3628 			if (rsp.snscb_fc4_features[i] != 0) {
3629 				res = 0;
3630 				break;
3631 			}
3632 		}
3633 		if (((rsp.snscb_fc4_features[FC4_SCSI / 8] >>
3634 		    ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3635 			res = 1;
3636 		/* Workaround for broken Brocade firmware. */
3637 		if (((ISP_SWAP32(isp, rsp.snscb_fc4_features[FC4_SCSI / 8]) >>
3638 		    ((FC4_SCSI % 8) * 4)) & 0x01) != 0)
3639 			res = 1;
3640 	}
3641 	FC_SCRATCH_RELEASE(isp, chan);
3642 	isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFF_ID result is %d", chan, res);
3643 	return (res);
3644 }
3645 
3646 static int
3647 isp_gft_id(ispsoftc_t *isp, int chan, uint32_t portid)
3648 {
3649 	fcparam *fcp = FCPARAM(isp, chan);
3650 	ct_hdr_t ct;
3651 	sns_gxx_id_req_t rq;
3652 	uint32_t *rp;
3653 	uint8_t *scp = fcp->isp_scratch;
3654 	sns_gft_id_rsp_t rsp;
3655 	int i, res = -1;
3656 
3657 	if (!fcp->isp_use_gft_id)	/* User may block GFT_ID use. */
3658 		return (res);
3659 
3660 	isp_prt(isp, ISP_LOGDEBUG0, "Chan %d requesting GFT_ID", chan);
3661 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3662 		isp_prt(isp, ISP_LOGERR, sacq);
3663 		return (res);
3664 	}
3665 
3666 	if (IS_24XX(isp)) {
3667 		/* Build the CT command and execute via pass-through. */
3668 		ISP_MEMZERO(&ct, sizeof (ct));
3669 		ct.ct_revision = CT_REVISION;
3670 		ct.ct_fcs_type = CT_FC_TYPE_FC;
3671 		ct.ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3672 		ct.ct_cmd_resp = SNS_GFT_ID;
3673 		ct.ct_bcnt_resid = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3674 		isp_put_ct_hdr(isp, &ct, (ct_hdr_t *)scp);
3675 		rp = (uint32_t *) &scp[sizeof(ct)];
3676 		ISP_IOZPUT_32(isp, portid, rp);
3677 
3678 		if (isp_ct_passthru(isp, chan, sizeof(ct) + sizeof(uint32_t),
3679 		    SNS_GFT_ID_RESP_SIZE)) {
3680 			FC_SCRATCH_RELEASE(isp, chan);
3681 			return (res);
3682 		}
3683 	} else {
3684 		/* Build the SNS request and execute via firmware. */
3685 		ISP_MEMZERO(&rq, SNS_GXX_ID_REQ_SIZE);
3686 		rq.snscb_rblen = SNS_GFT_ID_RESP_SIZE >> 1;
3687 		rq.snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
3688 		rq.snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
3689 		rq.snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
3690 		rq.snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
3691 		rq.snscb_sblen = 6;
3692 		rq.snscb_cmd = SNS_GFT_ID;
3693 		rq.snscb_mword_div_2 = (SNS_GFT_ID_RESP_SIZE - sizeof(ct)) / 4;
3694 		rq.snscb_portid = portid;
3695 		isp_put_gxx_id_request(isp, &rq, (sns_gxx_id_req_t *)scp);
3696 
3697 		if (isp_ct_sns(isp, chan, sizeof(rq), SNS_GFT_ID_RESP_SIZE)) {
3698 			FC_SCRATCH_RELEASE(isp, chan);
3699 			return (res);
3700 		}
3701 	}
3702 
3703 	isp_get_gft_id_response(isp, (sns_gft_id_rsp_t *)scp, &rsp);
3704 	if (rsp.snscb_cthdr.ct_cmd_resp == LS_ACC) {
3705 		for (i = 0; i < 8; i++) {
3706 			if (rsp.snscb_fc4_types[i] != 0) {
3707 				res = 0;
3708 				break;
3709 			}
3710 		}
3711 		if (((rsp.snscb_fc4_types[FC4_SCSI / 32] >>
3712 		    (FC4_SCSI % 32)) & 0x01) != 0)
3713 			res = 1;
3714 	}
3715 	FC_SCRATCH_RELEASE(isp, chan);
3716 	isp_prt(isp, ISP_LOGDEBUG0, "Chan %d GFT_ID result is %d", chan, res);
3717 	return (res);
3718 }
3719 
3720 static int
3721 isp_scan_fabric(ispsoftc_t *isp, int chan)
3722 {
3723 	fcparam *fcp = FCPARAM(isp, chan);
3724 	fcportdb_t *lp;
3725 	uint32_t portid;
3726 	uint16_t nphdl;
3727 	isp_pdb_t pdb;
3728 	int portidx, portlim, r;
3729 	sns_gid_xx_rsp_t *rs;
3730 
3731 	if (fcp->isp_loopstate < LOOP_LSCAN_DONE)
3732 		return (-1);
3733 	if (fcp->isp_loopstate >= LOOP_FSCAN_DONE)
3734 		return (0);
3735 
3736 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan", chan);
3737 	fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3738 	if (!TOPO_IS_FABRIC(fcp->isp_topo)) {
3739 		fcp->isp_loopstate = LOOP_FSCAN_DONE;
3740 		isp_prt(isp, ISP_LOG_SANCFG,
3741 		    "Chan %d FC fabric scan done (no fabric)", chan);
3742 		return (0);
3743 	}
3744 
3745 	if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3746 abort:
3747 		FC_SCRATCH_RELEASE(isp, chan);
3748 		isp_prt(isp, ISP_LOG_SANCFG,
3749 		    "Chan %d FC fabric scan aborted", chan);
3750 		return (1);
3751 	}
3752 
3753 	/*
3754 	 * Make sure we still are logged into the fabric controller.
3755 	 */
3756 	nphdl = IS_24XX(isp) ? NPH_FL_ID : FL_ID;
3757 	r = isp_getpdb(isp, chan, nphdl, &pdb);
3758 	if ((r & 0xffff) == MBOX_NOT_LOGGED_IN) {
3759 		isp_dump_chip_portdb(isp, chan);
3760 	}
3761 	if (r) {
3762 		fcp->isp_loopstate = LOOP_LTEST_DONE;
3763 fail:
3764 		isp_prt(isp, ISP_LOG_SANCFG,
3765 		    "Chan %d FC fabric scan done (bad)", chan);
3766 		return (-1);
3767 	}
3768 
3769 	/* Get list of port IDs from SNS. */
3770 	r = isp_gid_pt(isp, chan);
3771 	if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3772 		goto abort;
3773 	if (r > 0) {
3774 		fcp->isp_loopstate = LOOP_FSCAN_DONE;
3775 		return (-1);
3776 	} else if (r < 0) {
3777 		fcp->isp_loopstate = LOOP_LTEST_DONE;	/* try again */
3778 		return (-1);
3779 	}
3780 
3781 	rs = (sns_gid_xx_rsp_t *) fcp->isp_scanscratch;
3782 	if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3783 		goto abort;
3784 	if (rs->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3785 		int level;
3786 		if (rs->snscb_cthdr.ct_reason == 9 && rs->snscb_cthdr.ct_explanation == 7) {
3787 			level = ISP_LOG_SANCFG;
3788 		} else {
3789 			level = ISP_LOGWARN;
3790 		}
3791 		isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_PT"
3792 		    " (Reason=0x%x Expl=0x%x)", chan,
3793 		    rs->snscb_cthdr.ct_reason,
3794 		    rs->snscb_cthdr.ct_explanation);
3795 		fcp->isp_loopstate = LOOP_FSCAN_DONE;
3796 		return (-1);
3797 	}
3798 
3799 	/* Check our buffer was big enough to get the full list. */
3800 	for (portidx = 0; portidx < NGENT-1; portidx++) {
3801 		if (rs->snscb_ports[portidx].control & 0x80)
3802 			break;
3803 	}
3804 	if ((rs->snscb_ports[portidx].control & 0x80) == 0) {
3805 		isp_prt(isp, ISP_LOGWARN,
3806 		    "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3807 	}
3808 	portlim = portidx + 1;
3809 	isp_prt(isp, ISP_LOG_SANCFG,
3810 	    "Chan %d Got %d ports back from name server", chan, portlim);
3811 
3812 	/* Go through the list and remove duplicate port ids. */
3813 	for (portidx = 0; portidx < portlim; portidx++) {
3814 		int npidx;
3815 
3816 		portid =
3817 		    ((rs->snscb_ports[portidx].portid[0]) << 16) |
3818 		    ((rs->snscb_ports[portidx].portid[1]) << 8) |
3819 		    ((rs->snscb_ports[portidx].portid[2]));
3820 
3821 		for (npidx = portidx + 1; npidx < portlim; npidx++) {
3822 			uint32_t new_portid =
3823 			    ((rs->snscb_ports[npidx].portid[0]) << 16) |
3824 			    ((rs->snscb_ports[npidx].portid[1]) << 8) |
3825 			    ((rs->snscb_ports[npidx].portid[2]));
3826 			if (new_portid == portid) {
3827 				break;
3828 			}
3829 		}
3830 
3831 		if (npidx < portlim) {
3832 			rs->snscb_ports[npidx].portid[0] = 0;
3833 			rs->snscb_ports[npidx].portid[1] = 0;
3834 			rs->snscb_ports[npidx].portid[2] = 0;
3835 			isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3836 		}
3837 	}
3838 
3839 	/*
3840 	 * We now have a list of Port IDs for all FC4 SCSI devices
3841 	 * that the Fabric Name server knows about.
3842 	 *
3843 	 * For each entry on this list go through our port database looking
3844 	 * for probational entries- if we find one, then an old entry is
3845 	 * maybe still this one. We get some information to find out.
3846 	 *
3847 	 * Otherwise, it's a new fabric device, and we log into it
3848 	 * (unconditionally). After searching the entire database
3849 	 * again to make sure that we never ever ever ever have more
3850 	 * than one entry that has the same PortID or the same
3851 	 * WWNN/WWPN duple, we enter the device into our database.
3852 	 */
3853 	isp_mark_portdb(isp, chan);
3854 	for (portidx = 0; portidx < portlim; portidx++) {
3855 		portid = ((rs->snscb_ports[portidx].portid[0]) << 16) |
3856 			 ((rs->snscb_ports[portidx].portid[1]) << 8) |
3857 			 ((rs->snscb_ports[portidx].portid[2]));
3858 		isp_prt(isp, ISP_LOG_SANCFG,
3859 		    "Chan %d Checking fabric port 0x%06x", chan, portid);
3860 		if (portid == 0) {
3861 			isp_prt(isp, ISP_LOG_SANCFG,
3862 			    "Chan %d Port at idx %d is zero",
3863 			    chan, portidx);
3864 			continue;
3865 		}
3866 		if (portid == fcp->isp_portid) {
3867 			isp_prt(isp, ISP_LOG_SANCFG,
3868 			    "Chan %d Port 0x%06x is our", chan, portid);
3869 			continue;
3870 		}
3871 
3872 		/* Now search the entire port database for the same portid. */
3873 		if (isp_find_pdb_by_portid(isp, chan, portid, &lp)) {
3874 			if (!lp->probational) {
3875 				isp_prt(isp, ISP_LOGERR,
3876 				    "Chan %d Port 0x%06x@0x%04x [%d] is not probational (0x%x)",
3877 				    chan, lp->portid, lp->handle,
3878 				    FC_PORTDB_TGT(isp, chan, lp), lp->state);
3879 				isp_dump_portdb(isp, chan);
3880 				goto fail;
3881 			}
3882 
3883 			if (lp->state == FC_PORTDB_STATE_ZOMBIE)
3884 				goto relogin;
3885 
3886 			/*
3887 			 * See if we're still logged into it.
3888 			 *
3889 			 * If we aren't, mark it as a dead device and
3890 			 * leave the new portid in the database entry
3891 			 * for somebody further along to decide what to
3892 			 * do (policy choice).
3893 			 *
3894 			 * If we are, check to see if it's the same
3895 			 * device still (it should be). If for some
3896 			 * reason it isn't, mark it as a changed device
3897 			 * and leave the new portid and role in the
3898 			 * database entry for somebody further along to
3899 			 * decide what to do (policy choice).
3900 			 */
3901 			r = isp_getpdb(isp, chan, lp->handle, &pdb);
3902 			if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3903 				goto abort;
3904 			if (r != 0) {
3905 				lp->state = FC_PORTDB_STATE_DEAD;
3906 				isp_prt(isp, ISP_LOG_SANCFG,
3907 				    "Chan %d Port 0x%06x handle 0x%x is dead (%d)",
3908 				    chan, portid, lp->handle, r);
3909 				goto relogin;
3910 			}
3911 
3912 			isp_pdb_add_update(isp, chan, &pdb);
3913 			continue;
3914 		}
3915 
3916 relogin:
3917 		if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
3918 			isp_prt(isp, ISP_LOG_SANCFG,
3919 			    "Chan %d Port 0x%06x is not logged in", chan, portid);
3920 			continue;
3921 		}
3922 
3923 		r = isp_gff_id(isp, chan, portid);
3924 		if (r == 0) {
3925 			isp_prt(isp, ISP_LOG_SANCFG,
3926 			    "Chan %d Port 0x%06x is not an FCP target", chan, portid);
3927 			continue;
3928 		}
3929 		if (r < 0)
3930 			r = isp_gft_id(isp, chan, portid);
3931 		if (r == 0) {
3932 			isp_prt(isp, ISP_LOG_SANCFG,
3933 			    "Chan %d Port 0x%06x is not FCP", chan, portid);
3934 			continue;
3935 		}
3936 
3937 		if (isp_login_device(isp, chan, portid, &pdb,
3938 		    &FCPARAM(isp, 0)->isp_lasthdl)) {
3939 			if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3940 				goto abort;
3941 			continue;
3942 		}
3943 
3944 		isp_pdb_add_update(isp, chan, &pdb);
3945 	}
3946 
3947 	if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC)
3948 		goto abort;
3949 	fcp->isp_loopstate = LOOP_FSCAN_DONE;
3950 	isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC fabric scan done", chan);
3951 	return (0);
3952 }
3953 
3954 /*
3955  * Find an unused handle and try and use to login to a port.
3956  */
3957 static int
3958 isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3959 {
3960 	int lim, i, r;
3961 	uint16_t handle;
3962 
3963 	if (ISP_CAP_2KLOGIN(isp)) {
3964 		lim = NPH_MAX_2K;
3965 	} else {
3966 		lim = NPH_MAX;
3967 	}
3968 
3969 	handle = isp_next_handle(isp, ohp);
3970 	for (i = 0; i < lim; i++) {
3971 		if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
3972 			return (-1);
3973 
3974 		/* Check if this handle is free. */
3975 		r = isp_getpdb(isp, chan, handle, p);
3976 		if (r == 0) {
3977 			if (p->portid != portid) {
3978 				/* This handle is busy, try next one. */
3979 				handle = isp_next_handle(isp, ohp);
3980 				continue;
3981 			}
3982 			break;
3983 		}
3984 		if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
3985 			return (-1);
3986 
3987 		/*
3988 		 * Now try and log into the device
3989 		 */
3990 		r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
3991 		if (r == 0) {
3992 			break;
3993 		} else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
3994 			/*
3995 			 * If we get here, then the firmwware still thinks we're logged into this device, but with a different
3996 			 * handle. We need to break that association. We used to try and just substitute the handle, but then
3997 			 * failed to get any data via isp_getpdb (below).
3998 			 */
3999 			if (isp_plogx(isp, chan, r >> 16, portid, PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT | PLOGX_FLG_FREE_NPHDL)) {
4000 				isp_prt(isp, ISP_LOGERR, "baw... logout of %x failed", r >> 16);
4001 			}
4002 			if (FCPARAM(isp, chan)->isp_loopstate != LOOP_SCANNING_FABRIC)
4003 				return (-1);
4004 			r = isp_plogx(isp, chan, handle, portid, PLOGX_FLG_CMD_PLOGI);
4005 			if (r != 0)
4006 				i = lim;
4007 			break;
4008 		} else if ((r & 0xffff) == MBOX_LOOP_ID_USED) {
4009 			/* Try the next handle. */
4010 			handle = isp_next_handle(isp, ohp);
4011 		} else {
4012 			/* Give up. */
4013 			i = lim;
4014 			break;
4015 		}
4016 	}
4017 
4018 	if (i == lim) {
4019 		isp_prt(isp, ISP_LOGWARN, "Chan %d PLOGI 0x%06x failed", chan, portid);
4020 		return (-1);
4021 	}
4022 
4023 	/*
4024 	 * If we successfully logged into it, get the PDB for it
4025 	 * so we can crosscheck that it is still what we think it
4026 	 * is and that we also have the role it plays
4027 	 */
4028 	r = isp_getpdb(isp, chan, handle, p);
4029 	if (r != 0) {
4030 		isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x disappeared", chan, portid, handle);
4031 		return (-1);
4032 	}
4033 
4034 	if (p->handle != handle || p->portid != portid) {
4035 		isp_prt(isp, ISP_LOGERR, "Chan %d new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
4036 		    chan, portid, handle, p->portid, p->handle);
4037 		return (-1);
4038 	}
4039 	return (0);
4040 }
4041 
4042 static int
4043 isp_send_change_request(ispsoftc_t *isp, int chan)
4044 {
4045 	mbreg_t mbs;
4046 
4047 	MBSINIT(&mbs, MBOX_SEND_CHANGE_REQUEST, MBLOGALL, 500000);
4048 	mbs.param[1] = 0x03;
4049 	mbs.param[9] = chan;
4050 	isp_mboxcmd(isp, &mbs);
4051 	if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4052 		return (0);
4053 	} else {
4054 		isp_prt(isp, ISP_LOGWARN, "Chan %d Send Change Request: 0x%x",
4055 		    chan, mbs.param[0]);
4056 		return (-1);
4057 	}
4058 }
4059 
4060 static int
4061 isp_register_fc4_type(ispsoftc_t *isp, int chan)
4062 {
4063 	fcparam *fcp = FCPARAM(isp, chan);
4064 	rft_id_t rp;
4065 	ct_hdr_t *ct = &rp.rftid_hdr;
4066 	uint8_t local[SNS_RFT_ID_REQ_SIZE];
4067 	sns_screq_t *reqp = (sns_screq_t *) local;
4068 	uint8_t *scp = fcp->isp_scratch;
4069 
4070 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4071 		isp_prt(isp, ISP_LOGERR, sacq);
4072 		return (-1);
4073 	}
4074 
4075 	if (IS_24XX(isp)) {
4076 		/* Build the CT command and execute via pass-through. */
4077 		ISP_MEMZERO(&rp, sizeof(rp));
4078 		ct->ct_revision = CT_REVISION;
4079 		ct->ct_fcs_type = CT_FC_TYPE_FC;
4080 		ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4081 		ct->ct_cmd_resp = SNS_RFT_ID;
4082 		ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
4083 		rp.rftid_portid[0] = fcp->isp_portid >> 16;
4084 		rp.rftid_portid[1] = fcp->isp_portid >> 8;
4085 		rp.rftid_portid[2] = fcp->isp_portid;
4086 		rp.rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
4087 		isp_put_rft_id(isp, &rp, (rft_id_t *)scp);
4088 
4089 		if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4090 			FC_SCRATCH_RELEASE(isp, chan);
4091 			return (-1);
4092 		}
4093 	} else {
4094 		/* Build the SNS request and execute via firmware. */
4095 		ISP_MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
4096 		reqp->snscb_rblen = sizeof (ct_hdr_t) >> 1;
4097 		reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma);
4098 		reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma);
4099 		reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma);
4100 		reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma);
4101 		reqp->snscb_sblen = 22;
4102 		reqp->snscb_data[0] = SNS_RFT_ID;
4103 		reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
4104 		reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
4105 		reqp->snscb_data[6] = (1 << FC4_SCSI);
4106 		isp_put_sns_request(isp, reqp, (sns_screq_t *)scp);
4107 
4108 		if (isp_ct_sns(isp, chan, SNS_RFT_ID_REQ_SIZE, sizeof(ct_hdr_t))) {
4109 			FC_SCRATCH_RELEASE(isp, chan);
4110 			return (-1);
4111 		}
4112 	}
4113 
4114 	isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4115 	FC_SCRATCH_RELEASE(isp, chan);
4116 	if (ct->ct_cmd_resp == LS_RJT) {
4117 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4118 		return (-1);
4119 	} else if (ct->ct_cmd_resp == LS_ACC) {
4120 		isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4121 	} else {
4122 		isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4123 		return (-1);
4124 	}
4125 	return (0);
4126 }
4127 
4128 static int
4129 isp_register_fc4_features_24xx(ispsoftc_t *isp, int chan)
4130 {
4131 	fcparam *fcp = FCPARAM(isp, chan);
4132 	ct_hdr_t *ct;
4133 	rff_id_t rp;
4134 	uint8_t *scp = fcp->isp_scratch;
4135 
4136 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4137 		isp_prt(isp, ISP_LOGERR, sacq);
4138 		return (-1);
4139 	}
4140 
4141 	/*
4142 	 * Build the CT header and command in memory.
4143 	 */
4144 	ISP_MEMZERO(&rp, sizeof(rp));
4145 	ct = &rp.rffid_hdr;
4146 	ct->ct_revision = CT_REVISION;
4147 	ct->ct_fcs_type = CT_FC_TYPE_FC;
4148 	ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4149 	ct->ct_cmd_resp = SNS_RFF_ID;
4150 	ct->ct_bcnt_resid = (sizeof (rff_id_t) - sizeof (ct_hdr_t)) >> 2;
4151 	rp.rffid_portid[0] = fcp->isp_portid >> 16;
4152 	rp.rffid_portid[1] = fcp->isp_portid >> 8;
4153 	rp.rffid_portid[2] = fcp->isp_portid;
4154 	rp.rffid_fc4features = 0;
4155 	if (fcp->role & ISP_ROLE_TARGET)
4156 		rp.rffid_fc4features |= 1;
4157 	if (fcp->role & ISP_ROLE_INITIATOR)
4158 		rp.rffid_fc4features |= 2;
4159 	rp.rffid_fc4type = FC4_SCSI;
4160 	isp_put_rff_id(isp, &rp, (rff_id_t *)scp);
4161 	if (isp->isp_dblev & ISP_LOGDEBUG1)
4162 		isp_print_bytes(isp, "CT request", sizeof(rft_id_t), scp);
4163 
4164 	if (isp_ct_passthru(isp, chan, sizeof(rft_id_t), sizeof(ct_hdr_t))) {
4165 		FC_SCRATCH_RELEASE(isp, chan);
4166 		return (-1);
4167 	}
4168 
4169 	isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4170 	FC_SCRATCH_RELEASE(isp, chan);
4171 	if (ct->ct_cmd_resp == LS_RJT) {
4172 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4173 		    "Chan %d Register FC4 Features rejected", chan);
4174 		return (-1);
4175 	} else if (ct->ct_cmd_resp == LS_ACC) {
4176 		isp_prt(isp, ISP_LOG_SANCFG,
4177 		    "Chan %d Register FC4 Features accepted", chan);
4178 	} else {
4179 		isp_prt(isp, ISP_LOGWARN,
4180 		    "Chan %d Register FC4 Features: 0x%x", chan, ct->ct_cmd_resp);
4181 		return (-1);
4182 	}
4183 	return (0);
4184 }
4185 
4186 static int
4187 isp_register_port_name_24xx(ispsoftc_t *isp, int chan)
4188 {
4189 	fcparam *fcp = FCPARAM(isp, chan);
4190 	ct_hdr_t *ct;
4191 	rspn_id_t rp;
4192 	uint8_t *scp = fcp->isp_scratch;
4193 	int len;
4194 
4195 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4196 		isp_prt(isp, ISP_LOGERR, sacq);
4197 		return (-1);
4198 	}
4199 
4200 	/*
4201 	 * Build the CT header and command in memory.
4202 	 */
4203 	ISP_MEMZERO(&rp, sizeof(rp));
4204 	ct = &rp.rspnid_hdr;
4205 	ct->ct_revision = CT_REVISION;
4206 	ct->ct_fcs_type = CT_FC_TYPE_FC;
4207 	ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4208 	ct->ct_cmd_resp = SNS_RSPN_ID;
4209 	rp.rspnid_portid[0] = fcp->isp_portid >> 16;
4210 	rp.rspnid_portid[1] = fcp->isp_portid >> 8;
4211 	rp.rspnid_portid[2] = fcp->isp_portid;
4212 	rp.rspnid_length = 0;
4213 	len = offsetof(rspn_id_t, rspnid_name);
4214 	mtx_lock(&prison0.pr_mtx);
4215 	rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4216 	    "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4217 	mtx_unlock(&prison0.pr_mtx);
4218 	rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4219 	    ":%s", device_get_nameunit(isp->isp_dev));
4220 	if (chan != 0) {
4221 		rp.rspnid_length += sprintf(&scp[len + rp.rspnid_length],
4222 		    "/%d", chan);
4223 	}
4224 	len += rp.rspnid_length;
4225 	ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4226 	isp_put_rspn_id(isp, &rp, (rspn_id_t *)scp);
4227 
4228 	if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4229 		FC_SCRATCH_RELEASE(isp, chan);
4230 		return (-1);
4231 	}
4232 
4233 	isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4234 	FC_SCRATCH_RELEASE(isp, chan);
4235 	if (ct->ct_cmd_resp == LS_RJT) {
4236 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4237 		    "Chan %d Register Symbolic Port Name rejected", chan);
4238 		return (-1);
4239 	} else if (ct->ct_cmd_resp == LS_ACC) {
4240 		isp_prt(isp, ISP_LOG_SANCFG,
4241 		    "Chan %d Register Symbolic Port Name accepted", chan);
4242 	} else {
4243 		isp_prt(isp, ISP_LOGWARN,
4244 		    "Chan %d Register Symbolic Port Name: 0x%x", chan, ct->ct_cmd_resp);
4245 		return (-1);
4246 	}
4247 	return (0);
4248 }
4249 
4250 static int
4251 isp_register_node_name_24xx(ispsoftc_t *isp, int chan)
4252 {
4253 	fcparam *fcp = FCPARAM(isp, chan);
4254 	ct_hdr_t *ct;
4255 	rsnn_nn_t rp;
4256 	uint8_t *scp = fcp->isp_scratch;
4257 	int len;
4258 
4259 	if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4260 		isp_prt(isp, ISP_LOGERR, sacq);
4261 		return (-1);
4262 	}
4263 
4264 	/*
4265 	 * Build the CT header and command in memory.
4266 	 */
4267 	ISP_MEMZERO(&rp, sizeof(rp));
4268 	ct = &rp.rsnnnn_hdr;
4269 	ct->ct_revision = CT_REVISION;
4270 	ct->ct_fcs_type = CT_FC_TYPE_FC;
4271 	ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
4272 	ct->ct_cmd_resp = SNS_RSNN_NN;
4273 	MAKE_NODE_NAME_FROM_WWN(rp.rsnnnn_nodename, fcp->isp_wwnn);
4274 	rp.rsnnnn_length = 0;
4275 	len = offsetof(rsnn_nn_t, rsnnnn_name);
4276 	mtx_lock(&prison0.pr_mtx);
4277 	rp.rsnnnn_length += sprintf(&scp[len + rp.rsnnnn_length],
4278 	    "%s", prison0.pr_hostname[0] ? prison0.pr_hostname : "FreeBSD");
4279 	mtx_unlock(&prison0.pr_mtx);
4280 	len += rp.rsnnnn_length;
4281 	ct->ct_bcnt_resid = (len - sizeof(ct_hdr_t)) >> 2;
4282 	isp_put_rsnn_nn(isp, &rp, (rsnn_nn_t *)scp);
4283 
4284 	if (isp_ct_passthru(isp, chan, len, sizeof(ct_hdr_t))) {
4285 		FC_SCRATCH_RELEASE(isp, chan);
4286 		return (-1);
4287 	}
4288 
4289 	isp_get_ct_hdr(isp, (ct_hdr_t *) scp, ct);
4290 	FC_SCRATCH_RELEASE(isp, chan);
4291 	if (ct->ct_cmd_resp == LS_RJT) {
4292 		isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1,
4293 		    "Chan %d Register Symbolic Node Name rejected", chan);
4294 		return (-1);
4295 	} else if (ct->ct_cmd_resp == LS_ACC) {
4296 		isp_prt(isp, ISP_LOG_SANCFG,
4297 		    "Chan %d Register Symbolic Node Name accepted", chan);
4298 	} else {
4299 		isp_prt(isp, ISP_LOGWARN,
4300 		    "Chan %d Register Symbolic Node Name: 0x%x", chan, ct->ct_cmd_resp);
4301 		return (-1);
4302 	}
4303 	return (0);
4304 }
4305 
4306 static uint16_t
4307 isp_next_handle(ispsoftc_t *isp, uint16_t *ohp)
4308 {
4309 	fcparam *fcp;
4310 	int i, chan, wrap;
4311 	uint16_t handle, minh, maxh;
4312 
4313 	handle = *ohp;
4314 	if (ISP_CAP_2KLOGIN(isp)) {
4315 		minh = 0;
4316 		maxh = NPH_RESERVED - 1;
4317 	} else {
4318 		minh = SNS_ID + 1;
4319 		maxh = NPH_MAX - 1;
4320 	}
4321 	wrap = 0;
4322 
4323 next:
4324 	if (handle == NIL_HANDLE) {
4325 		handle = minh;
4326 	} else {
4327 		handle++;
4328 		if (handle > maxh) {
4329 			if (++wrap >= 2) {
4330 				isp_prt(isp, ISP_LOGERR, "Out of port handles!");
4331 				return (NIL_HANDLE);
4332 			}
4333 			handle = minh;
4334 		}
4335 	}
4336 	for (chan = 0; chan < isp->isp_nchan; chan++) {
4337 		fcp = FCPARAM(isp, chan);
4338 		if (fcp->role == ISP_ROLE_NONE)
4339 			continue;
4340 		for (i = 0; i < MAX_FC_TARG; i++) {
4341 			if (fcp->portdb[i].state != FC_PORTDB_STATE_NIL &&
4342 			    fcp->portdb[i].handle == handle)
4343 				goto next;
4344 		}
4345 	}
4346 	*ohp = handle;
4347 	return (handle);
4348 }
4349 
4350 /*
4351  * Start a command. Locking is assumed done in the caller.
4352  */
4353 
4354 int
4355 isp_start(XS_T *xs)
4356 {
4357 	ispsoftc_t *isp;
4358 	uint32_t cdblen;
4359 	uint8_t local[QENTRY_LEN];
4360 	ispreq_t *reqp;
4361 	void *cdbp, *qep;
4362 	uint16_t *tptr;
4363 	fcportdb_t *lp;
4364 	int target, dmaresult;
4365 
4366 	XS_INITERR(xs);
4367 	isp = XS_ISP(xs);
4368 
4369 	/*
4370 	 * Check command CDB length, etc.. We really are limited to 16 bytes
4371 	 * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4372 	 * but probably only if we're running fairly new firmware (we'll
4373 	 * let the old f/w choke on an extended command queue entry).
4374 	 */
4375 
4376 	if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4377 		isp_prt(isp, ISP_LOGERR, "unsupported cdb length (%d, CDB[0]=0x%x)", XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4378 		XS_SETERR(xs, HBA_REQINVAL);
4379 		return (CMD_COMPLETE);
4380 	}
4381 
4382 	/*
4383 	 * Translate the target to device handle as appropriate, checking
4384 	 * for correct device state as well.
4385 	 */
4386 	target = XS_TGT(xs);
4387 	if (IS_FC(isp)) {
4388 		fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4389 
4390 		if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4391 			isp_prt(isp, ISP_LOG_WARN1,
4392 			    "%d.%d.%jx I am not an initiator",
4393 			    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4394 			XS_SETERR(xs, HBA_SELTIMEOUT);
4395 			return (CMD_COMPLETE);
4396 		}
4397 
4398 		if (isp->isp_state != ISP_RUNSTATE) {
4399 			isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4400 			XS_SETERR(xs, HBA_BOTCH);
4401 			return (CMD_COMPLETE);
4402 		}
4403 
4404 		isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d", target);
4405 		lp = &fcp->portdb[target];
4406 		if (target < 0 || target >= MAX_FC_TARG ||
4407 		    lp->is_target == 0) {
4408 			XS_SETERR(xs, HBA_SELTIMEOUT);
4409 			return (CMD_COMPLETE);
4410 		}
4411 		if (fcp->isp_loopstate != LOOP_READY) {
4412 			isp_prt(isp, ISP_LOGDEBUG1,
4413 			    "%d.%d.%jx loop is not ready",
4414 			    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4415 			return (CMD_RQLATER);
4416 		}
4417 		if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
4418 			isp_prt(isp, ISP_LOGDEBUG1,
4419 			    "%d.%d.%jx target zombie",
4420 			    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4421 			return (CMD_RQLATER);
4422 		}
4423 		if (lp->state != FC_PORTDB_STATE_VALID) {
4424 			isp_prt(isp, ISP_LOGDEBUG1,
4425 			    "%d.%d.%jx bad db port state 0x%x",
4426 			    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs), lp->state);
4427 			XS_SETERR(xs, HBA_SELTIMEOUT);
4428 			return (CMD_COMPLETE);
4429 		}
4430 	} else {
4431 		sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4432 		if (isp->isp_state != ISP_RUNSTATE) {
4433 			isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4434 			XS_SETERR(xs, HBA_BOTCH);
4435 			return (CMD_COMPLETE);
4436 		}
4437 
4438 		if (sdp->update) {
4439 			isp_spi_update(isp, XS_CHANNEL(xs));
4440 		}
4441 		lp = NULL;
4442 	}
4443 
4444  start_again:
4445 
4446 	qep = isp_getrqentry(isp);
4447 	if (qep == NULL) {
4448 		isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4449 		XS_SETERR(xs, HBA_BOTCH);
4450 		return (CMD_EAGAIN);
4451 	}
4452 	XS_SETERR(xs, HBA_NOERROR);
4453 
4454 	/*
4455 	 * Now see if we need to synchronize the ISP with respect to anything.
4456 	 * We do dual duty here (cough) for synchronizing for buses other
4457 	 * than which we got here to send a command to.
4458 	 */
4459 	reqp = (ispreq_t *) local;
4460 	ISP_MEMZERO(local, QENTRY_LEN);
4461 	if (ISP_TST_SENDMARKER(isp, XS_CHANNEL(xs))) {
4462 		if (IS_24XX(isp)) {
4463 			isp_marker_24xx_t *m = (isp_marker_24xx_t *) reqp;
4464 			m->mrk_header.rqs_entry_count = 1;
4465 			m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4466 			m->mrk_modifier = SYNC_ALL;
4467 			m->mrk_vphdl = XS_CHANNEL(xs);
4468 			isp_put_marker_24xx(isp, m, qep);
4469 		} else {
4470 			isp_marker_t *m = (isp_marker_t *) reqp;
4471 			m->mrk_header.rqs_entry_count = 1;
4472 			m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4473 			m->mrk_target = (XS_CHANNEL(xs) << 7);	/* bus # */
4474 			m->mrk_modifier = SYNC_ALL;
4475 			isp_put_marker(isp, m, qep);
4476 		}
4477 		ISP_SYNC_REQUEST(isp);
4478 		ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4479 		goto start_again;
4480 	}
4481 
4482 	reqp->req_header.rqs_entry_count = 1;
4483 
4484 	/*
4485 	 * Select and install Header Code.
4486 	 * Note that it might be overridden before going out
4487 	 * if we're on a 64 bit platform. The lower level
4488 	 * code (isp_send_cmd) will select the appropriate
4489 	 * 64 bit variant if it needs to.
4490 	 */
4491 	if (IS_24XX(isp)) {
4492 		reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4493 	} else if (IS_FC(isp)) {
4494 		reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4495 	} else {
4496 		if (XS_CDBLEN(xs) > 12) {
4497 			reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4498 		} else {
4499 			reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4500 		}
4501 	}
4502 
4503 	/*
4504 	 * Set task attributes
4505 	 */
4506 	if (IS_24XX(isp)) {
4507 		int ttype;
4508 		if (XS_TAG_P(xs)) {
4509 			ttype = XS_TAG_TYPE(xs);
4510 		} else {
4511 			ttype = REQFLAG_STAG;
4512 		}
4513 		if (ttype == REQFLAG_OTAG) {
4514 			ttype = FCP_CMND_TASK_ATTR_ORDERED;
4515 		} else if (ttype == REQFLAG_HTAG) {
4516 			ttype = FCP_CMND_TASK_ATTR_HEAD;
4517 		} else {
4518 			ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4519 		}
4520 		((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4521 	} else if (IS_FC(isp)) {
4522 		/*
4523 		 * See comment in isp_intr_respq
4524 		 */
4525 		/* XS_SET_RESID(xs, 0); */
4526 
4527 		/*
4528 		 * Fibre Channel always requires some kind of tag.
4529 		 * The Qlogic drivers seem be happy not to use a tag,
4530 		 * but this breaks for some devices (IBM drives).
4531 		 */
4532 		if (XS_TAG_P(xs)) {
4533 			((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4534 		} else {
4535 			((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4536 		}
4537 	} else {
4538 		sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4539 		if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4540 			reqp->req_flags = XS_TAG_TYPE(xs);
4541 		}
4542 	}
4543 
4544 	/*
4545 	 * NB: we do not support long CDBs (yet)
4546 	 */
4547 	cdblen = XS_CDBLEN(xs);
4548 
4549 	if (IS_SCSI(isp)) {
4550 		if (cdblen > sizeof (reqp->req_cdb)) {
4551 			isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4552 			XS_SETERR(xs, HBA_REQINVAL);
4553 			return (CMD_COMPLETE);
4554 		}
4555 		reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4556 		reqp->req_lun_trn = XS_LUN(xs);
4557 		reqp->req_cdblen = cdblen;
4558 		tptr = &reqp->req_time;
4559 		cdbp = reqp->req_cdb;
4560 	} else if (IS_24XX(isp)) {
4561 		ispreqt7_t *t7 = (ispreqt7_t *)local;
4562 
4563 		if (cdblen > sizeof (t7->req_cdb)) {
4564 			isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4565 			XS_SETERR(xs, HBA_REQINVAL);
4566 			return (CMD_COMPLETE);
4567 		}
4568 
4569 		t7->req_nphdl = lp->handle;
4570 		t7->req_tidlo = lp->portid;
4571 		t7->req_tidhi = lp->portid >> 16;
4572 		t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4573 		be64enc(t7->req_lun, CAM_EXTLUN_BYTE_SWIZZLE(XS_LUN(xs)));
4574 		if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4575 			if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4576 				isp_prt(isp, ISP_LOG_WARN1,
4577 				    "%d.%d.%jx cannot generate next CRN",
4578 				    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4579 				XS_SETERR(xs, HBA_BOTCH);
4580 				return (CMD_EAGAIN);
4581 			}
4582 		}
4583 		tptr = &t7->req_time;
4584 		cdbp = t7->req_cdb;
4585 	} else {
4586 		ispreqt2_t *t2 = (ispreqt2_t *)local;
4587 
4588 		if (cdblen > sizeof t2->req_cdb) {
4589 			isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4590 			XS_SETERR(xs, HBA_REQINVAL);
4591 			return (CMD_COMPLETE);
4592 		}
4593 		if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4594 			if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4595 				isp_prt(isp, ISP_LOG_WARN1,
4596 				    "%d.%d.%jx cannot generate next CRN",
4597 				    XS_CHANNEL(xs), target, (uintmax_t)XS_LUN(xs));
4598 				XS_SETERR(xs, HBA_BOTCH);
4599 				return (CMD_EAGAIN);
4600 			}
4601 		}
4602 		if (ISP_CAP_2KLOGIN(isp)) {
4603 			ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4604 			t2e->req_target = lp->handle;
4605 			t2e->req_scclun = XS_LUN(xs);
4606 			tptr = &t2e->req_time;
4607 			cdbp = t2e->req_cdb;
4608 		} else if (ISP_CAP_SCCFW(isp)) {
4609 			t2->req_target = lp->handle;
4610 			t2->req_scclun = XS_LUN(xs);
4611 			tptr = &t2->req_time;
4612 			cdbp = t2->req_cdb;
4613 		} else {
4614 			t2->req_target = lp->handle;
4615 			t2->req_lun_trn = XS_LUN(xs);
4616 			tptr = &t2->req_time;
4617 			cdbp = t2->req_cdb;
4618 		}
4619 	}
4620 	*tptr = XS_TIME(xs);
4621 	ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4622 
4623 	/* Whew. Thankfully the same for type 7 requests */
4624 	reqp->req_handle = isp_allocate_handle(isp, xs, ISP_HANDLE_INITIATOR);
4625 	if (reqp->req_handle == 0) {
4626 		isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4627 		XS_SETERR(xs, HBA_BOTCH);
4628 		return (CMD_EAGAIN);
4629 	}
4630 
4631 	/*
4632 	 * Set up DMA and/or do any platform dependent swizzling of the request entry
4633 	 * so that the Qlogic F/W understands what is being asked of it.
4634 	 *
4635 	 * The callee is responsible for adding all requests at this point.
4636 	 */
4637 	dmaresult = ISP_DMASETUP(isp, xs, reqp);
4638 	if (dmaresult != CMD_QUEUED) {
4639 		isp_destroy_handle(isp, reqp->req_handle);
4640 		/*
4641 		 * dmasetup sets actual error in packet, and
4642 		 * return what we were given to return.
4643 		 */
4644 		return (dmaresult);
4645 	}
4646 	isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "START cmd cdb[0]=0x%x datalen %ld", XS_CDBP(xs)[0], (long) XS_XFRLEN(xs));
4647 	return (CMD_QUEUED);
4648 }
4649 
4650 /*
4651  * isp control
4652  * Locks (ints blocked) assumed held.
4653  */
4654 
4655 int
4656 isp_control(ispsoftc_t *isp, ispctl_t ctl, ...)
4657 {
4658 	XS_T *xs;
4659 	mbreg_t *mbr, mbs;
4660 	int chan, tgt;
4661 	uint32_t handle;
4662 	va_list ap;
4663 
4664 	switch (ctl) {
4665 	case ISPCTL_RESET_BUS:
4666 		/*
4667 		 * Issue a bus reset.
4668 		 */
4669 		if (IS_24XX(isp)) {
4670 			isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4671 			break;
4672 		} else if (IS_FC(isp)) {
4673 			mbs.param[1] = 10;
4674 			chan = 0;
4675 		} else {
4676 			va_start(ap, ctl);
4677 			chan = va_arg(ap, int);
4678 			va_end(ap);
4679 			mbs.param[1] = SDPARAM(isp, chan)->isp_bus_reset_delay;
4680 			if (mbs.param[1] < 2) {
4681 				mbs.param[1] = 2;
4682 			}
4683 			mbs.param[2] = chan;
4684 		}
4685 		MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4686 		ISP_SET_SENDMARKER(isp, chan, 1);
4687 		isp_mboxcmd(isp, &mbs);
4688 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4689 			break;
4690 		}
4691 		isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4692 		return (0);
4693 
4694 	case ISPCTL_RESET_DEV:
4695 		va_start(ap, ctl);
4696 		chan = va_arg(ap, int);
4697 		tgt = va_arg(ap, int);
4698 		va_end(ap);
4699 		if (IS_24XX(isp)) {
4700 			uint8_t local[QENTRY_LEN];
4701 			isp24xx_tmf_t *tmf;
4702 			isp24xx_statusreq_t *sp;
4703 			fcparam *fcp = FCPARAM(isp, chan);
4704 			fcportdb_t *lp;
4705 
4706 			if (tgt < 0 || tgt >= MAX_FC_TARG) {
4707 				isp_prt(isp, ISP_LOGWARN, "Chan %d trying to reset bad target %d", chan, tgt);
4708 				break;
4709 			}
4710 			lp = &fcp->portdb[tgt];
4711 			if (lp->is_target == 0 ||
4712 			    lp->state != FC_PORTDB_STATE_VALID) {
4713 				isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4714 				break;
4715 			}
4716 
4717 			tmf = (isp24xx_tmf_t *) local;
4718 			ISP_MEMZERO(tmf, QENTRY_LEN);
4719 			tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4720 			tmf->tmf_header.rqs_entry_count = 1;
4721 			tmf->tmf_nphdl = lp->handle;
4722 			tmf->tmf_delay = 2;
4723 			tmf->tmf_timeout = 4;
4724 			tmf->tmf_flags = ISP24XX_TMF_TARGET_RESET;
4725 			tmf->tmf_tidlo = lp->portid;
4726 			tmf->tmf_tidhi = lp->portid >> 16;
4727 			tmf->tmf_vpidx = ISP_GET_VPIDX(isp, chan);
4728 			isp_put_24xx_tmf(isp, tmf, isp->isp_iocb);
4729 			if (isp->isp_dblev & ISP_LOGDEBUG1)
4730 				isp_print_bytes(isp, "TMF IOCB request", QENTRY_LEN, isp->isp_iocb);
4731 			MEMORYBARRIER(isp, SYNC_IFORDEV, 0, QENTRY_LEN, chan);
4732 			fcp->sendmarker = 1;
4733 
4734 			isp_prt(isp, ISP_LOGALL, "Chan %d Reset N-Port Handle 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4735 			MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL,
4736 			    MBCMD_DEFAULT_TIMEOUT + tmf->tmf_timeout * 1000000);
4737 			mbs.param[1] = QENTRY_LEN;
4738 			mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4739 			mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4740 			mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4741 			mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4742 			isp_mboxcmd(isp, &mbs);
4743 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4744 				break;
4745 
4746 			MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4747 			if (isp->isp_dblev & ISP_LOGDEBUG1)
4748 				isp_print_bytes(isp, "TMF IOCB response", QENTRY_LEN, &((isp24xx_statusreq_t *)isp->isp_iocb)[1]);
4749 			sp = (isp24xx_statusreq_t *) local;
4750 			isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)isp->isp_iocb)[1], sp);
4751 			if (sp->req_completion_status == 0) {
4752 				return (0);
4753 			}
4754 			isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4755 			break;
4756 		} else if (IS_FC(isp)) {
4757 			if (ISP_CAP_2KLOGIN(isp)) {
4758 				mbs.param[1] = tgt;
4759 				mbs.ibits = (1 << 10);
4760 			} else {
4761 				mbs.param[1] = (tgt << 8);
4762 			}
4763 		} else {
4764 			mbs.param[1] = (chan << 15) | (tgt << 8);
4765 		}
4766 		MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4767 		mbs.param[2] = 3;	/* 'delay', in seconds */
4768 		isp_mboxcmd(isp, &mbs);
4769 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4770 			break;
4771 		}
4772 		isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4773 		ISP_SET_SENDMARKER(isp, chan, 1);
4774 		return (0);
4775 
4776 	case ISPCTL_ABORT_CMD:
4777 		va_start(ap, ctl);
4778 		xs = va_arg(ap, XS_T *);
4779 		va_end(ap);
4780 
4781 		tgt = XS_TGT(xs);
4782 		chan = XS_CHANNEL(xs);
4783 
4784 		handle = isp_find_handle(isp, xs);
4785 		if (handle == 0) {
4786 			isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4787 			break;
4788 		}
4789 		if (IS_24XX(isp)) {
4790 			isp24xx_abrt_t local, *ab = &local;
4791 			fcparam *fcp;
4792 			fcportdb_t *lp;
4793 
4794 			fcp = FCPARAM(isp, chan);
4795 			if (tgt < 0 || tgt >= MAX_FC_TARG) {
4796 				isp_prt(isp, ISP_LOGWARN, "Chan %d trying to abort bad target %d", chan, tgt);
4797 				break;
4798 			}
4799 			lp = &fcp->portdb[tgt];
4800 			if (lp->is_target == 0 ||
4801 			    lp->state != FC_PORTDB_STATE_VALID) {
4802 				isp_prt(isp, ISP_LOGWARN, "Chan %d abort of no longer valid target %d", chan, tgt);
4803 				break;
4804 			}
4805 			isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4806 			ISP_MEMZERO(ab, QENTRY_LEN);
4807 			ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4808 			ab->abrt_header.rqs_entry_count = 1;
4809 			ab->abrt_handle = lp->handle;
4810 			ab->abrt_cmd_handle = handle;
4811 			ab->abrt_tidlo = lp->portid;
4812 			ab->abrt_tidhi = lp->portid >> 16;
4813 			ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);
4814 			isp_put_24xx_abrt(isp, ab, isp->isp_iocb);
4815 			if (isp->isp_dblev & ISP_LOGDEBUG1)
4816 				isp_print_bytes(isp, "AB IOCB quest", QENTRY_LEN, isp->isp_iocb);
4817 			MEMORYBARRIER(isp, SYNC_IFORDEV, 0, 2 * QENTRY_LEN, chan);
4818 
4819 			ISP_MEMZERO(&mbs, sizeof (mbs));
4820 			MBSINIT(&mbs, MBOX_EXEC_COMMAND_IOCB_A64, MBLOGALL, 5000000);
4821 			mbs.param[1] = QENTRY_LEN;
4822 			mbs.param[2] = DMA_WD1(isp->isp_iocb_dma);
4823 			mbs.param[3] = DMA_WD0(isp->isp_iocb_dma);
4824 			mbs.param[6] = DMA_WD3(isp->isp_iocb_dma);
4825 			mbs.param[7] = DMA_WD2(isp->isp_iocb_dma);
4826 
4827 			isp_mboxcmd(isp, &mbs);
4828 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE)
4829 				break;
4830 
4831 			MEMORYBARRIER(isp, SYNC_IFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4832 			if (isp->isp_dblev & ISP_LOGDEBUG1)
4833 				isp_print_bytes(isp, "AB IOCB response", QENTRY_LEN, &((isp24xx_abrt_t *)isp->isp_iocb)[1]);
4834 			isp_get_24xx_abrt(isp, &((isp24xx_abrt_t *)isp->isp_iocb)[1], ab);
4835 			if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4836 				return (0);
4837 			}
4838 			isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, tgt, ab->abrt_nphdl);
4839 			break;
4840 		} else if (IS_FC(isp)) {
4841 			if (ISP_CAP_SCCFW(isp)) {
4842 				if (ISP_CAP_2KLOGIN(isp)) {
4843 					mbs.param[1] = tgt;
4844 				} else {
4845 					mbs.param[1] = tgt << 8;
4846 				}
4847 				mbs.param[6] = XS_LUN(xs);
4848 			} else {
4849 				mbs.param[1] = tgt << 8 | XS_LUN(xs);
4850 			}
4851 		} else {
4852 			mbs.param[1] = (chan << 15) | (tgt << 8) | XS_LUN(xs);
4853 		}
4854 		MBSINIT(&mbs, MBOX_ABORT,
4855 		    MBLOGALL & ~MBLOGMASK(MBOX_COMMAND_ERROR), 0);
4856 		mbs.param[2] = handle;
4857 		isp_mboxcmd(isp, &mbs);
4858 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4859 			break;
4860 		}
4861 		return (0);
4862 
4863 	case ISPCTL_UPDATE_PARAMS:
4864 
4865 		va_start(ap, ctl);
4866 		chan = va_arg(ap, int);
4867 		va_end(ap);
4868 		isp_spi_update(isp, chan);
4869 		return (0);
4870 
4871 	case ISPCTL_FCLINK_TEST:
4872 
4873 		if (IS_FC(isp)) {
4874 			int usdelay;
4875 			va_start(ap, ctl);
4876 			chan = va_arg(ap, int);
4877 			usdelay = va_arg(ap, int);
4878 			va_end(ap);
4879 			if (usdelay == 0) {
4880 				usdelay =  250000;
4881 			}
4882 			return (isp_fclink_test(isp, chan, usdelay));
4883 		}
4884 		break;
4885 
4886 	case ISPCTL_SCAN_FABRIC:
4887 
4888 		if (IS_FC(isp)) {
4889 			va_start(ap, ctl);
4890 			chan = va_arg(ap, int);
4891 			va_end(ap);
4892 			return (isp_scan_fabric(isp, chan));
4893 		}
4894 		break;
4895 
4896 	case ISPCTL_SCAN_LOOP:
4897 
4898 		if (IS_FC(isp)) {
4899 			va_start(ap, ctl);
4900 			chan = va_arg(ap, int);
4901 			va_end(ap);
4902 			return (isp_scan_loop(isp, chan));
4903 		}
4904 		break;
4905 
4906 	case ISPCTL_PDB_SYNC:
4907 
4908 		if (IS_FC(isp)) {
4909 			va_start(ap, ctl);
4910 			chan = va_arg(ap, int);
4911 			va_end(ap);
4912 			return (isp_pdb_sync(isp, chan));
4913 		}
4914 		break;
4915 
4916 	case ISPCTL_SEND_LIP:
4917 
4918 		if (IS_FC(isp) && !IS_24XX(isp)) {
4919 			MBSINIT(&mbs, MBOX_INIT_LIP, MBLOGALL, 0);
4920 			if (ISP_CAP_2KLOGIN(isp)) {
4921 				mbs.ibits = (1 << 10);
4922 			}
4923 			isp_mboxcmd(isp, &mbs);
4924 			if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4925 				return (0);
4926 			}
4927 		}
4928 		break;
4929 
4930 	case ISPCTL_GET_PDB:
4931 		if (IS_FC(isp)) {
4932 			isp_pdb_t *pdb;
4933 			va_start(ap, ctl);
4934 			chan = va_arg(ap, int);
4935 			tgt = va_arg(ap, int);
4936 			pdb = va_arg(ap, isp_pdb_t *);
4937 			va_end(ap);
4938 			return (isp_getpdb(isp, chan, tgt, pdb));
4939 		}
4940 		break;
4941 
4942 	case ISPCTL_GET_NAMES:
4943 	{
4944 		uint64_t *wwnn, *wwnp;
4945 		va_start(ap, ctl);
4946 		chan = va_arg(ap, int);
4947 		tgt = va_arg(ap, int);
4948 		wwnn = va_arg(ap, uint64_t *);
4949 		wwnp = va_arg(ap, uint64_t *);
4950 		va_end(ap);
4951 		if (wwnn == NULL && wwnp == NULL) {
4952 			break;
4953 		}
4954 		if (wwnn) {
4955 			*wwnn = isp_get_wwn(isp, chan, tgt, 1);
4956 			if (*wwnn == INI_NONE) {
4957 				break;
4958 			}
4959 		}
4960 		if (wwnp) {
4961 			*wwnp = isp_get_wwn(isp, chan, tgt, 0);
4962 			if (*wwnp == INI_NONE) {
4963 				break;
4964 			}
4965 		}
4966 		return (0);
4967 	}
4968 	case ISPCTL_RUN_MBOXCMD:
4969 	{
4970 		va_start(ap, ctl);
4971 		mbr = va_arg(ap, mbreg_t *);
4972 		va_end(ap);
4973 		isp_mboxcmd(isp, mbr);
4974 		return (0);
4975 	}
4976 	case ISPCTL_PLOGX:
4977 	{
4978 		isp_plcmd_t *p;
4979 		int r;
4980 
4981 		va_start(ap, ctl);
4982 		p = va_arg(ap, isp_plcmd_t *);
4983 		va_end(ap);
4984 
4985 		if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI || (p->handle != NIL_HANDLE)) {
4986 			return (isp_plogx(isp, p->channel, p->handle, p->portid, p->flags));
4987 		}
4988 		do {
4989 			isp_next_handle(isp, &p->handle);
4990 			r = isp_plogx(isp, p->channel, p->handle, p->portid, p->flags);
4991 			if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4992 				p->handle = r >> 16;
4993 				r = 0;
4994 				break;
4995 			}
4996 		} while ((r & 0xffff) == MBOX_LOOP_ID_USED);
4997 		return (r);
4998 	}
4999 	case ISPCTL_CHANGE_ROLE:
5000 		if (IS_FC(isp)) {
5001 			int role, r;
5002 
5003 			va_start(ap, ctl);
5004 			chan = va_arg(ap, int);
5005 			role = va_arg(ap, int);
5006 			va_end(ap);
5007 			r = isp_fc_change_role(isp, chan, role);
5008 			return (r);
5009 		}
5010 		break;
5011 	default:
5012 		isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
5013 		break;
5014 
5015 	}
5016 	return (-1);
5017 }
5018 
5019 /*
5020  * Interrupt Service Routine(s).
5021  *
5022  * External (OS) framework has done the appropriate locking,
5023  * and the locking will be held throughout this function.
5024  */
5025 
5026 #ifdef	ISP_TARGET_MODE
5027 void
5028 isp_intr_atioq(ispsoftc_t *isp)
5029 {
5030 	uint8_t qe[QENTRY_LEN];
5031 	isphdr_t *hp;
5032 	void *addr;
5033 	uint32_t iptr, optr, oop;
5034 
5035 	iptr = ISP_READ(isp, BIU2400_ATIO_RSPINP);
5036 	optr = isp->isp_atioodx;
5037 	while (optr != iptr) {
5038 		oop = optr;
5039 		MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN, -1);
5040 		addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
5041 		isp_get_hdr(isp, addr, (isphdr_t *)qe);
5042 		hp = (isphdr_t *)qe;
5043 		switch (hp->rqs_entry_type) {
5044 		case RQSTYPE_NOTIFY:
5045 		case RQSTYPE_ATIO:
5046 			(void) isp_target_notify(isp, addr, &oop);
5047 			break;
5048 		default:
5049 			isp_print_qentry(isp, "?ATIOQ entry?", oop, addr);
5050 			break;
5051 		}
5052 		optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
5053 	}
5054 	if (isp->isp_atioodx != optr) {
5055 		ISP_WRITE(isp, BIU2400_ATIO_RSPOUTP, optr);
5056 		isp->isp_atioodx = optr;
5057 	}
5058 }
5059 #endif
5060 
5061 void
5062 isp_intr_async(ispsoftc_t *isp, uint16_t event)
5063 {
5064 
5065 	if (IS_FC(isp))
5066 		isp_parse_async_fc(isp, event);
5067 	else
5068 		isp_parse_async(isp, event);
5069 }
5070 
5071 void
5072 isp_intr_mbox(ispsoftc_t *isp, uint16_t mbox0)
5073 {
5074 	int i, obits;
5075 
5076 	if (!isp->isp_mboxbsy) {
5077 		isp_prt(isp, ISP_LOGWARN, "mailbox 0x%x with no waiters", mbox0);
5078 		return;
5079 	}
5080 	obits = isp->isp_obits;
5081 	isp->isp_mboxtmp[0] = mbox0;
5082 	for (i = 1; i < ISP_NMBOX(isp); i++) {
5083 		if ((obits & (1 << i)) == 0)
5084 			continue;
5085 		isp->isp_mboxtmp[i] = ISP_READ(isp, MBOX_OFF(i));
5086 	}
5087 	MBOX_NOTIFY_COMPLETE(isp);
5088 }
5089 
5090 void
5091 isp_intr_respq(ispsoftc_t *isp)
5092 {
5093 	XS_T *xs, *cont_xs;
5094 	uint8_t qe[QENTRY_LEN];
5095 	ispstatusreq_t *sp = (ispstatusreq_t *)qe;
5096 	isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
5097 	isphdr_t *hp;
5098 	uint8_t *resp, *snsp;
5099 	int buddaboom, completion_status, cont = 0, etype, i;
5100 	int req_status_flags, req_state_flags, scsi_status;
5101 	uint32_t iptr, junk, cptr, optr, rlen, slen, sptr, totslen, resid;
5102 
5103 	/*
5104 	 * We can't be getting this now.
5105 	 */
5106 	if (isp->isp_state != ISP_RUNSTATE) {
5107 		isp_prt(isp, ISP_LOGINFO, "respq interrupt when not ready");
5108 		return;
5109 	}
5110 
5111 	iptr = ISP_READ(isp, isp->isp_respinrp);
5112 	/* Debounce the 2300 if revision less than 2. */
5113 	if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
5114 		do {
5115 			junk = iptr;
5116 			iptr = ISP_READ(isp, isp->isp_respinrp);
5117 		} while (junk != iptr);
5118 	}
5119 	isp->isp_residx = iptr;
5120 
5121 	optr = isp->isp_resodx;
5122 	while (optr != iptr) {
5123 		sptr = cptr = optr;
5124 		hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, cptr);
5125 		optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5126 
5127 		/*
5128 		 * Synchronize our view of this response queue entry.
5129 		 */
5130 		MEMORYBARRIER(isp, SYNC_RESULT, cptr, QENTRY_LEN, -1);
5131 		if (isp->isp_dblev & ISP_LOGDEBUG1)
5132 			isp_print_qentry(isp, "Response Queue Entry", cptr, hp);
5133 		isp_get_hdr(isp, hp, &sp->req_header);
5134 		etype = sp->req_header.rqs_entry_type;
5135 
5136 		/* We expected Status Continuation, but got different IOCB. */
5137 		if (cont > 0 && etype != RQSTYPE_STATUS_CONT) {
5138 			cont = 0;
5139 			isp_done(cont_xs);
5140 		}
5141 
5142 		if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
5143 			isp_get_24xx_response(isp, (isp24xx_statusreq_t *)hp, sp2);
5144 			scsi_status = sp2->req_scsi_status;
5145 			completion_status = sp2->req_completion_status;
5146 			req_status_flags = 0;
5147 			if ((scsi_status & 0xff) != 0)
5148 				req_state_flags = RQSF_GOT_STATUS;
5149 			else
5150 				req_state_flags = 0;
5151 			resid = sp2->req_resid;
5152 		} else if (etype == RQSTYPE_RESPONSE) {
5153 			isp_get_response(isp, (ispstatusreq_t *) hp, sp);
5154 			scsi_status = sp->req_scsi_status;
5155 			completion_status = sp->req_completion_status;
5156 			req_status_flags = sp->req_status_flags;
5157 			req_state_flags = sp->req_state_flags;
5158 			resid = sp->req_resid;
5159 		} else if (etype == RQSTYPE_RIO1) {
5160 			isp_rio1_t *rio = (isp_rio1_t *) qe;
5161 			isp_get_rio1(isp, (isp_rio1_t *) hp, rio);
5162 			for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5163 				isp_fastpost_complete(isp, rio->req_handles[i]);
5164 			}
5165 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5166 			continue;
5167 		} else if (etype == RQSTYPE_RIO2) {
5168 			isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5169 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5170 			continue;
5171 		} else if (etype == RQSTYPE_STATUS_CONT) {
5172 			ispstatus_cont_t *scp = (ispstatus_cont_t *)qe;
5173 			isp_get_cont_response(isp, (ispstatus_cont_t *)hp, scp);
5174 			if (cont > 0) {
5175 				i = min(cont, sizeof(scp->req_sense_data));
5176 				XS_SENSE_APPEND(cont_xs, scp->req_sense_data, i);
5177 				cont -= i;
5178 				if (cont == 0) {
5179 					isp_done(cont_xs);
5180 				} else {
5181 					isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5182 					    "Expecting Status Continuations for %u bytes",
5183 					    cont);
5184 				}
5185 			} else {
5186 				isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5187 			}
5188 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5189 			continue;
5190 		} else if (isp_handle_other_response(isp, etype, hp, &cptr)) {
5191 			/* More then one IOCB could be consumed. */
5192 			while (sptr != cptr) {
5193 				ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5194 				sptr = ISP_NXT_QENTRY(sptr, RESULT_QUEUE_LEN(isp));
5195 				hp = (isphdr_t *)ISP_QUEUE_ENTRY(isp->isp_result, sptr);
5196 			}
5197 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5198 			optr = ISP_NXT_QENTRY(cptr, RESULT_QUEUE_LEN(isp));
5199 			continue;
5200 		} else {
5201 			/* We don't know what was this -- log and skip. */
5202 			isp_prt(isp, ISP_LOGERR, notresp, etype, cptr, optr);
5203 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5204 			continue;
5205 		}
5206 
5207 		buddaboom = 0;
5208 		if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5209 			if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5210 				isp_print_qentry(isp, "unexpected continuation segment",
5211 				    cptr, hp);
5212 				continue;
5213 			}
5214 			if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5215 				isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5216 				/*
5217 				 * We'll synthesize a QUEUE FULL message below.
5218 				 */
5219 			}
5220 			if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5221 				isp_print_qentry(isp, "bad header flag",
5222 				    cptr, hp);
5223 				buddaboom++;
5224 			}
5225 			if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5226 				isp_print_qentry(isp, "bad request packet",
5227 				    cptr, hp);
5228 				buddaboom++;
5229 			}
5230 			if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5231 				isp_print_qentry(isp, "invalid entry count",
5232 				    cptr, hp);
5233 				buddaboom++;
5234 			}
5235 			if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5236 				isp_print_qentry(isp, "invalid IOCB ordering",
5237 				    cptr, hp);
5238 				continue;
5239 			}
5240 		}
5241 
5242 		xs = isp_find_xs(isp, sp->req_handle);
5243 		if (xs == NULL) {
5244 			uint8_t ts = completion_status & 0xff;
5245 			/*
5246 			 * Only whine if this isn't the expected fallout of
5247 			 * aborting the command or resetting the target.
5248 			 */
5249 			if (etype != RQSTYPE_RESPONSE) {
5250 				isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5251 			} else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5252 				isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5253 			}
5254 			ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5255 			continue;
5256 		}
5257 		if (req_status_flags & RQSTF_BUS_RESET) {
5258 			isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx bus was reset",
5259 			    XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5260 			XS_SETERR(xs, HBA_BUSRESET);
5261 			ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5262 		}
5263 		if (buddaboom) {
5264 			isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%jx buddaboom",
5265 			    XS_CHANNEL(xs), XS_TGT(xs), (uintmax_t)XS_LUN(xs));
5266 			XS_SETERR(xs, HBA_BOTCH);
5267 		}
5268 
5269 		resp = snsp = NULL;
5270 		rlen = slen = totslen = 0;
5271 		if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5272 			resp = sp2->req_rsp_sense;
5273 			rlen = sp2->req_response_len;
5274 		} else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5275 			resp = sp->req_response;
5276 			rlen = sp->req_response_len;
5277 		}
5278 		if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5279 			/*
5280 			 * Fibre Channel F/W doesn't say we got status
5281 			 * if there's Sense Data instead. I guess they
5282 			 * think it goes w/o saying.
5283 			 */
5284 			req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5285 			if (IS_24XX(isp)) {
5286 				snsp = sp2->req_rsp_sense;
5287 				snsp += rlen;
5288 				totslen = sp2->req_sense_len;
5289 				slen = sizeof(sp2->req_rsp_sense) - rlen;
5290 			} else {
5291 				snsp = sp->req_sense_data;
5292 				totslen = sp->req_sense_len;
5293 				slen = sizeof(sp->req_sense_data);
5294 			}
5295 		} else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5296 			snsp = sp->req_sense_data;
5297 			totslen = sp->req_sense_len;
5298 			slen = sizeof (sp->req_sense_data);
5299 		}
5300 		if (slen > totslen)
5301 			slen = totslen;
5302 		if (req_state_flags & RQSF_GOT_STATUS)
5303 			*XS_STSP(xs) = scsi_status & 0xff;
5304 
5305 		if (rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {
5306 			const char *ptr;
5307 			char lb[64];
5308 			const char *rnames[10] = {
5309 			    "Task Management function complete",
5310 			    "FCP_DATA length different than FCP_BURST_LEN",
5311 			    "FCP_CMND fields invalid",
5312 			    "FCP_DATA parameter mismatch with FCP_DATA_RO",
5313 			    "Task Management function rejected",
5314 			    "Task Management function failed",
5315 			    NULL,
5316 			    NULL,
5317 			    "Task Management function succeeded",
5318 			    "Task Management function incorrect logical unit number",
5319 			};
5320 			uint8_t code = resp[FCP_RSPNS_CODE_OFFSET];
5321 			if (code >= 10 || rnames[code] == NULL) {
5322 				ISP_SNPRINTF(lb, sizeof(lb),
5323 				    "Unknown FCP Response Code 0x%x", code);
5324 				ptr = lb;
5325 			} else {
5326 				ptr = rnames[code];
5327 			}
5328 			isp_xs_prt(isp, xs, ISP_LOGWARN,
5329 			    "FCP RESPONSE, LENGTH %u: %s CDB0=0x%02x",
5330 			    rlen, ptr, XS_CDBP(xs)[0] & 0xff);
5331 			if (code != 0 && code != 8)
5332 				XS_SETERR(xs, HBA_BOTCH);
5333 		}
5334 		if (IS_24XX(isp))
5335 			isp_parse_status_24xx(isp, sp2, xs, &resid);
5336 		else
5337 			isp_parse_status(isp, sp, xs, &resid);
5338 		if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
5339 		    (*XS_STSP(xs) == SCSI_BUSY))
5340 			XS_SETERR(xs, HBA_TGTBSY);
5341 		if (IS_SCSI(isp)) {
5342 			XS_SET_RESID(xs, resid);
5343 			/*
5344 			 * A new synchronous rate was negotiated for
5345 			 * this target. Mark state such that we'll go
5346 			 * look up that which has changed later.
5347 			 */
5348 			if (req_status_flags & RQSTF_NEGOTIATION) {
5349 				int t = XS_TGT(xs);
5350 				sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
5351 				sdp->isp_devparam[t].dev_refresh = 1;
5352 				sdp->update = 1;
5353 			}
5354 		} else {
5355 			if (req_status_flags & RQSF_XFER_COMPLETE) {
5356 				XS_SET_RESID(xs, 0);
5357 			} else if (scsi_status & RQCS_RESID) {
5358 				XS_SET_RESID(xs, resid);
5359 			} else {
5360 				XS_SET_RESID(xs, 0);
5361 			}
5362 		}
5363 		if (slen > 0) {
5364 			XS_SAVE_SENSE(xs, snsp, slen);
5365 			if (totslen > slen) {
5366 				cont = totslen - slen;
5367 				cont_xs = xs;
5368 				isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN,
5369 				    "Expecting Status Continuations for %u bytes",
5370 				    cont);
5371 			}
5372 		}
5373 		isp_prt(isp, ISP_LOGDEBUG2, "asked for %lu got raw resid %lu settled for %lu",
5374 		    (u_long)XS_XFRLEN(xs), (u_long)resid, (u_long)XS_GET_RESID(xs));
5375 
5376 		if (XS_XFRLEN(xs))
5377 			ISP_DMAFREE(isp, xs, sp->req_handle);
5378 		isp_destroy_handle(isp, sp->req_handle);
5379 
5380 		ISP_MEMZERO(hp, QENTRY_LEN);	/* PERF */
5381 
5382 		/* Complete command if we expect no Status Continuations. */
5383 		if (cont == 0)
5384 			isp_done(xs);
5385 	}
5386 
5387 	/* We haven't received all Status Continuations, but that is it. */
5388 	if (cont > 0)
5389 		isp_done(cont_xs);
5390 
5391 	/* If we processed any IOCBs, let ISP know about it. */
5392 	if (optr != isp->isp_resodx) {
5393 		ISP_WRITE(isp, isp->isp_respoutrp, optr);
5394 		isp->isp_resodx = optr;
5395 	}
5396 }
5397 
5398 /*
5399  * Parse an ASYNC mailbox complete
5400  */
5401 static void
5402 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5403 {
5404 	uint32_t h1 = 0, h2 = 0;
5405 	uint16_t chan = 0;
5406 
5407 	/*
5408 	 * Pick up the channel, but not if this is a ASYNC_RIO32_2,
5409 	 * where Mailboxes 6/7 have the second handle.
5410 	 */
5411 	if (mbox != ASYNC_RIO32_2) {
5412 		if (IS_DUALBUS(isp)) {
5413 			chan = ISP_READ(isp, OUTMAILBOX6);
5414 		}
5415 	}
5416 	isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5417 
5418 	switch (mbox) {
5419 	case ASYNC_BUS_RESET:
5420 		ISP_SET_SENDMARKER(isp, chan, 1);
5421 #ifdef	ISP_TARGET_MODE
5422 		isp_target_async(isp, chan, mbox);
5423 #endif
5424 		isp_async(isp, ISPASYNC_BUS_RESET, chan);
5425 		break;
5426 	case ASYNC_SYSTEM_ERROR:
5427 		isp->isp_state = ISP_CRASHED;
5428 		/*
5429 		 * Were we waiting for a mailbox command to complete?
5430 		 * If so, it's dead, so wake up the waiter.
5431 		 */
5432 		if (isp->isp_mboxbsy) {
5433 			isp->isp_obits = 1;
5434 			isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5435 			MBOX_NOTIFY_COMPLETE(isp);
5436 		}
5437 		/*
5438 		 * It's up to the handler for isp_async to reinit stuff and
5439 		 * restart the firmware
5440 		 */
5441 		isp_async(isp, ISPASYNC_FW_CRASH);
5442 		break;
5443 
5444 	case ASYNC_RQS_XFER_ERR:
5445 		isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5446 		break;
5447 
5448 	case ASYNC_RSP_XFER_ERR:
5449 		isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5450 		break;
5451 
5452 	case ASYNC_QWAKEUP:
5453 		/*
5454 		 * We've just been notified that the Queue has woken up.
5455 		 * We don't need to be chatty about this- just unlatch things
5456 		 * and move on.
5457 		 */
5458 		mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5459 		break;
5460 
5461 	case ASYNC_TIMEOUT_RESET:
5462 		isp_prt(isp, ISP_LOGWARN, "timeout initiated SCSI bus reset of chan %d", chan);
5463 		ISP_SET_SENDMARKER(isp, chan, 1);
5464 #ifdef	ISP_TARGET_MODE
5465 		isp_target_async(isp, chan, mbox);
5466 #endif
5467 		break;
5468 
5469 	case ASYNC_DEVICE_RESET:
5470 		isp_prt(isp, ISP_LOGINFO, "device reset on chan %d", chan);
5471 		ISP_SET_SENDMARKER(isp, chan, 1);
5472 #ifdef	ISP_TARGET_MODE
5473 		isp_target_async(isp, chan, mbox);
5474 #endif
5475 		break;
5476 
5477 	case ASYNC_EXTMSG_UNDERRUN:
5478 		isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5479 		break;
5480 
5481 	case ASYNC_SCAM_INT:
5482 		isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5483 		break;
5484 
5485 	case ASYNC_HUNG_SCSI:
5486 		isp_prt(isp, ISP_LOGERR, "stalled SCSI Bus after DATA Overrun");
5487 		/* XXX: Need to issue SCSI reset at this point */
5488 		break;
5489 
5490 	case ASYNC_KILLED_BUS:
5491 		isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5492 		break;
5493 
5494 	case ASYNC_BUS_TRANSIT:
5495 		mbox = ISP_READ(isp, OUTMAILBOX2);
5496 		switch (mbox & SXP_PINS_MODE_MASK) {
5497 		case SXP_PINS_LVD_MODE:
5498 			isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5499 			SDPARAM(isp, chan)->isp_diffmode = 0;
5500 			SDPARAM(isp, chan)->isp_ultramode = 0;
5501 			SDPARAM(isp, chan)->isp_lvdmode = 1;
5502 			break;
5503 		case SXP_PINS_HVD_MODE:
5504 			isp_prt(isp, ISP_LOGINFO,
5505 			    "Transition to Differential mode");
5506 			SDPARAM(isp, chan)->isp_diffmode = 1;
5507 			SDPARAM(isp, chan)->isp_ultramode = 0;
5508 			SDPARAM(isp, chan)->isp_lvdmode = 0;
5509 			break;
5510 		case SXP_PINS_SE_MODE:
5511 			isp_prt(isp, ISP_LOGINFO,
5512 			    "Transition to Single Ended mode");
5513 			SDPARAM(isp, chan)->isp_diffmode = 0;
5514 			SDPARAM(isp, chan)->isp_ultramode = 1;
5515 			SDPARAM(isp, chan)->isp_lvdmode = 0;
5516 			break;
5517 		default:
5518 			isp_prt(isp, ISP_LOGWARN,
5519 			    "Transition to Unknown Mode 0x%x", mbox);
5520 			break;
5521 		}
5522 		/*
5523 		 * XXX: Set up to renegotiate again!
5524 		 */
5525 		/* Can only be for a 1080... */
5526 		ISP_SET_SENDMARKER(isp, chan, 1);
5527 		break;
5528 
5529 	case ASYNC_CMD_CMPLT:
5530 	case ASYNC_RIO32_1:
5531 		if (!IS_ULTRA3(isp)) {
5532 			isp_prt(isp, ISP_LOGERR, "unexpected fast posting completion");
5533 			break;
5534 		}
5535 		/* FALLTHROUGH */
5536 		h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5537 		break;
5538 
5539 	case ASYNC_RIO32_2:
5540 		h1 = (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1);
5541 		h2 = (ISP_READ(isp, OUTMAILBOX7) << 16) | ISP_READ(isp, OUTMAILBOX6);
5542 		break;
5543 
5544 	case ASYNC_RIO16_5:
5545 	case ASYNC_RIO16_4:
5546 	case ASYNC_RIO16_3:
5547 	case ASYNC_RIO16_2:
5548 	case ASYNC_RIO16_1:
5549 		isp_prt(isp, ISP_LOGERR, "unexpected 16 bit RIO handle");
5550 		break;
5551 	default:
5552 		isp_prt(isp, ISP_LOGWARN, "%s: unhandled async code 0x%x", __func__, mbox);
5553 		break;
5554 	}
5555 
5556 	if (h1 || h2) {
5557 		isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h1);
5558 		isp_fastpost_complete(isp, h1);
5559 		if (h2) {
5560 			isp_prt(isp, ISP_LOGDEBUG3, "fast post/rio completion of 0x%08x", h2);
5561 			isp_fastpost_complete(isp, h2);
5562 		}
5563 	}
5564 }
5565 
5566 static void
5567 isp_parse_async_fc(ispsoftc_t *isp, uint16_t mbox)
5568 {
5569 	fcparam *fcp;
5570 	uint16_t chan;
5571 
5572 	if (IS_DUALBUS(isp)) {
5573 		chan = ISP_READ(isp, OUTMAILBOX6);
5574 	} else {
5575 		chan = 0;
5576 	}
5577 	isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5578 
5579 	switch (mbox) {
5580 	case ASYNC_SYSTEM_ERROR:
5581 		isp->isp_state = ISP_CRASHED;
5582 		FCPARAM(isp, chan)->isp_loopstate = LOOP_NIL;
5583 		isp_change_fw_state(isp, chan, FW_CONFIG_WAIT);
5584 		/*
5585 		 * Were we waiting for a mailbox command to complete?
5586 		 * If so, it's dead, so wake up the waiter.
5587 		 */
5588 		if (isp->isp_mboxbsy) {
5589 			isp->isp_obits = 1;
5590 			isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5591 			MBOX_NOTIFY_COMPLETE(isp);
5592 		}
5593 		/*
5594 		 * It's up to the handler for isp_async to reinit stuff and
5595 		 * restart the firmware
5596 		 */
5597 		isp_async(isp, ISPASYNC_FW_CRASH);
5598 		break;
5599 
5600 	case ASYNC_RQS_XFER_ERR:
5601 		isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5602 		break;
5603 
5604 	case ASYNC_RSP_XFER_ERR:
5605 		isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5606 		break;
5607 
5608 	case ASYNC_QWAKEUP:
5609 #ifdef	ISP_TARGET_MODE
5610 		if (IS_24XX(isp)) {
5611 			isp_prt(isp, ISP_LOGERR, "ATIO Queue Transfer Error");
5612 			break;
5613 		}
5614 #endif
5615 		isp_prt(isp, ISP_LOGERR, "%s: unexpected ASYNC_QWAKEUP code", __func__);
5616 		break;
5617 
5618 	case ASYNC_CMD_CMPLT:
5619 		isp_fastpost_complete(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) | ISP_READ(isp, OUTMAILBOX1));
5620 		break;
5621 
5622 	case ASYNC_RIOZIO_STALL:
5623 		isp_intr_respq(isp);
5624 		break;
5625 
5626 	case ASYNC_CTIO_DONE:
5627 #ifdef	ISP_TARGET_MODE
5628 		isp_target_async(isp, (ISP_READ(isp, OUTMAILBOX2) << 16) |
5629 		    ISP_READ(isp, OUTMAILBOX1), mbox);
5630 #else
5631 		isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC CTIO done");
5632 #endif
5633 		break;
5634 	case ASYNC_LIP_ERROR:
5635 	case ASYNC_LIP_NOS_OLS_RECV:
5636 	case ASYNC_LIP_OCCURRED:
5637 	case ASYNC_PTPMODE:
5638 		/*
5639 		 * These are broadcast events that have to be sent across
5640 		 * all active channels.
5641 		 */
5642 		for (chan = 0; chan < isp->isp_nchan; chan++) {
5643 			fcp = FCPARAM(isp, chan);
5644 			int topo = fcp->isp_topo;
5645 
5646 			if (fcp->role == ISP_ROLE_NONE)
5647 				continue;
5648 			if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5649 				fcp->isp_loopstate = LOOP_HAVE_LINK;
5650 			ISP_SET_SENDMARKER(isp, chan, 1);
5651 			isp_async(isp, ISPASYNC_LIP, chan);
5652 #ifdef	ISP_TARGET_MODE
5653 			isp_target_async(isp, chan, mbox);
5654 #endif
5655 			/*
5656 			 * We've had problems with data corruption occurring on
5657 			 * commands that complete (with no apparent error) after
5658 			 * we receive a LIP. This has been observed mostly on
5659 			 * Local Loop topologies. To be safe, let's just mark
5660 			 * all active initiator commands as dead.
5661 			 */
5662 			if (topo == TOPO_NL_PORT || topo == TOPO_FL_PORT) {
5663 				int i, j;
5664 				for (i = j = 0; i < isp->isp_maxcmds; i++) {
5665 					XS_T *xs;
5666 					isp_hdl_t *hdp;
5667 
5668 					hdp = &isp->isp_xflist[i];
5669 					if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5670 						continue;
5671 					}
5672 					xs = hdp->cmd;
5673 					if (XS_CHANNEL(xs) != chan) {
5674 						continue;
5675 					}
5676 					j++;
5677 					isp_prt(isp, ISP_LOG_WARN1,
5678 					    "%d.%d.%jx bus reset set at %s:%u",
5679 					    XS_CHANNEL(xs), XS_TGT(xs),
5680 					    (uintmax_t)XS_LUN(xs),
5681 					    __func__, __LINE__);
5682 					XS_SETERR(xs, HBA_BUSRESET);
5683 				}
5684 				if (j) {
5685 					isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5686 				}
5687 			}
5688 		}
5689 		break;
5690 
5691 	case ASYNC_LOOP_UP:
5692 		/*
5693 		 * This is a broadcast event that has to be sent across
5694 		 * all active channels.
5695 		 */
5696 		for (chan = 0; chan < isp->isp_nchan; chan++) {
5697 			fcp = FCPARAM(isp, chan);
5698 			if (fcp->role == ISP_ROLE_NONE)
5699 				continue;
5700 			fcp->isp_linkstate = 1;
5701 			if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5702 				fcp->isp_loopstate = LOOP_HAVE_LINK;
5703 			ISP_SET_SENDMARKER(isp, chan, 1);
5704 			isp_async(isp, ISPASYNC_LOOP_UP, chan);
5705 #ifdef	ISP_TARGET_MODE
5706 			isp_target_async(isp, chan, mbox);
5707 #endif
5708 		}
5709 		break;
5710 
5711 	case ASYNC_LOOP_DOWN:
5712 		/*
5713 		 * This is a broadcast event that has to be sent across
5714 		 * all active channels.
5715 		 */
5716 		for (chan = 0; chan < isp->isp_nchan; chan++) {
5717 			fcp = FCPARAM(isp, chan);
5718 			if (fcp->role == ISP_ROLE_NONE)
5719 				continue;
5720 			ISP_SET_SENDMARKER(isp, chan, 1);
5721 			fcp->isp_linkstate = 0;
5722 			fcp->isp_loopstate = LOOP_NIL;
5723 			isp_async(isp, ISPASYNC_LOOP_DOWN, chan);
5724 #ifdef	ISP_TARGET_MODE
5725 			isp_target_async(isp, chan, mbox);
5726 #endif
5727 		}
5728 		break;
5729 
5730 	case ASYNC_LOOP_RESET:
5731 		/*
5732 		 * This is a broadcast event that has to be sent across
5733 		 * all active channels.
5734 		 */
5735 		for (chan = 0; chan < isp->isp_nchan; chan++) {
5736 			fcp = FCPARAM(isp, chan);
5737 			if (fcp->role == ISP_ROLE_NONE)
5738 				continue;
5739 			ISP_SET_SENDMARKER(isp, chan, 1);
5740 			if (fcp->isp_loopstate > LOOP_HAVE_LINK)
5741 				fcp->isp_loopstate = LOOP_HAVE_LINK;
5742 			isp_async(isp, ISPASYNC_LOOP_RESET, chan);
5743 #ifdef	ISP_TARGET_MODE
5744 			isp_target_async(isp, chan, mbox);
5745 #endif
5746 		}
5747 		break;
5748 
5749 	case ASYNC_PDB_CHANGED:
5750 	{
5751 		int echan, nphdl, nlstate, reason;
5752 
5753 		if (IS_23XX(isp) || IS_24XX(isp)) {
5754 			nphdl = ISP_READ(isp, OUTMAILBOX1);
5755 			nlstate = ISP_READ(isp, OUTMAILBOX2);
5756 		} else {
5757 			nphdl = nlstate = 0xffff;
5758 		}
5759 		if (IS_24XX(isp))
5760 			reason = ISP_READ(isp, OUTMAILBOX3) >> 8;
5761 		else
5762 			reason = 0xff;
5763 		if (ISP_CAP_MULTI_ID(isp)) {
5764 			chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5765 			if (chan == 0xff || nphdl == NIL_HANDLE) {
5766 				chan = 0;
5767 				echan = isp->isp_nchan - 1;
5768 			} else if (chan >= isp->isp_nchan) {
5769 				break;
5770 			} else {
5771 				echan = chan;
5772 			}
5773 		} else {
5774 			chan = echan = 0;
5775 		}
5776 		for (; chan <= echan; chan++) {
5777 			fcp = FCPARAM(isp, chan);
5778 			if (fcp->role == ISP_ROLE_NONE)
5779 				continue;
5780 			if (fcp->isp_loopstate > LOOP_LTEST_DONE) {
5781 				if (nphdl != NIL_HANDLE &&
5782 				    nphdl == fcp->isp_login_hdl &&
5783 				    reason == PDB24XX_AE_OPN_2)
5784 					continue;
5785 				fcp->isp_loopstate = LOOP_LTEST_DONE;
5786 			} else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5787 				fcp->isp_loopstate = LOOP_HAVE_LINK;
5788 			isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5789 			    ISPASYNC_CHANGE_PDB, nphdl, nlstate, reason);
5790 		}
5791 		break;
5792 	}
5793 	case ASYNC_CHANGE_NOTIFY:
5794 	{
5795 		int portid;
5796 
5797 		portid = ((ISP_READ(isp, OUTMAILBOX1) & 0xff) << 16) |
5798 		    ISP_READ(isp, OUTMAILBOX2);
5799 		if (ISP_CAP_MULTI_ID(isp)) {
5800 			chan = ISP_READ(isp, OUTMAILBOX3) & 0xff;
5801 			if (chan >= isp->isp_nchan)
5802 				break;
5803 		} else {
5804 			chan = 0;
5805 		}
5806 		fcp = FCPARAM(isp, chan);
5807 		if (fcp->role == ISP_ROLE_NONE)
5808 			break;
5809 		if (fcp->isp_loopstate > LOOP_LTEST_DONE)
5810 			fcp->isp_loopstate = LOOP_LTEST_DONE;
5811 		else if (fcp->isp_loopstate < LOOP_HAVE_LINK)
5812 			fcp->isp_loopstate = LOOP_HAVE_LINK;
5813 		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan,
5814 		    ISPASYNC_CHANGE_SNS, portid);
5815 		break;
5816 	}
5817 	case ASYNC_ERR_LOGGING_DISABLED:
5818 		isp_prt(isp, ISP_LOGWARN, "Error logging disabled (reason 0x%x)",
5819 		    ISP_READ(isp, OUTMAILBOX1));
5820 		break;
5821 	case ASYNC_CONNMODE:
5822 		/*
5823 		 * This only applies to 2100 amd 2200 cards
5824 		 */
5825 		if (!IS_2200(isp) && !IS_2100(isp)) {
5826 			isp_prt(isp, ISP_LOGWARN, "bad card for ASYNC_CONNMODE event");
5827 			break;
5828 		}
5829 		chan = 0;
5830 		mbox = ISP_READ(isp, OUTMAILBOX1);
5831 		switch (mbox) {
5832 		case ISP_CONN_LOOP:
5833 			isp_prt(isp, ISP_LOGINFO,
5834 			    "Point-to-Point -> Loop mode");
5835 			break;
5836 		case ISP_CONN_PTP:
5837 			isp_prt(isp, ISP_LOGINFO,
5838 			    "Loop -> Point-to-Point mode");
5839 			break;
5840 		case ISP_CONN_BADLIP:
5841 			isp_prt(isp, ISP_LOGWARN,
5842 			    "Point-to-Point -> Loop mode (BAD LIP)");
5843 			break;
5844 		case ISP_CONN_FATAL:
5845 			isp->isp_state = ISP_CRASHED;
5846 			isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5847 			isp_async(isp, ISPASYNC_FW_CRASH);
5848 			return;
5849 		case ISP_CONN_LOOPBACK:
5850 			isp_prt(isp, ISP_LOGWARN,
5851 			    "Looped Back in Point-to-Point mode");
5852 			break;
5853 		default:
5854 			isp_prt(isp, ISP_LOGWARN,
5855 			    "Unknown connection mode (0x%x)", mbox);
5856 			break;
5857 		}
5858 		ISP_SET_SENDMARKER(isp, chan, 1);
5859 		FCPARAM(isp, chan)->isp_loopstate = LOOP_HAVE_LINK;
5860 		isp_async(isp, ISPASYNC_CHANGE_NOTIFY, chan, ISPASYNC_CHANGE_OTHER);
5861 		break;
5862 	case ASYNC_P2P_INIT_ERR:
5863 		isp_prt(isp, ISP_LOGWARN, "P2P init error (reason 0x%x)",
5864 		    ISP_READ(isp, OUTMAILBOX1));
5865 		break;
5866 	case ASYNC_RCV_ERR:
5867 		if (IS_24XX(isp)) {
5868 			isp_prt(isp, ISP_LOGWARN, "Receive Error");
5869 		} else {
5870 			isp_prt(isp, ISP_LOGWARN, "unexpected ASYNC_RCV_ERR");
5871 		}
5872 		break;
5873 	case ASYNC_RJT_SENT:	/* same as ASYNC_QFULL_SENT */
5874 		if (IS_24XX(isp)) {
5875 			isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5876 			break;
5877 		} else {
5878 			isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5879 			break;
5880 		}
5881 	case ASYNC_FW_RESTART_COMPLETE:
5882 		isp_prt(isp, ISP_LOGDEBUG0, "FW restart complete");
5883 		break;
5884 	case ASYNC_TEMPERATURE_ALERT:
5885 		isp_prt(isp, ISP_LOGERR, "Temperature alert (subcode 0x%x)",
5886 		    ISP_READ(isp, OUTMAILBOX1));
5887 		break;
5888 	case ASYNC_AUTOLOAD_FW_COMPLETE:
5889 		isp_prt(isp, ISP_LOGDEBUG0, "Autoload FW init complete");
5890 		break;
5891 	case ASYNC_AUTOLOAD_FW_FAILURE:
5892 		isp_prt(isp, ISP_LOGERR, "Autoload FW init failure");
5893 		break;
5894 	default:
5895 		isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5896 		break;
5897 	}
5898 }
5899 
5900 /*
5901  * Handle other response entries. A pointer to the request queue output
5902  * index is here in case we want to eat several entries at once, although
5903  * this is not used currently.
5904  */
5905 
5906 static int
5907 isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
5908 {
5909 	isp_ridacq_t rid;
5910 	int chan, c;
5911 	uint32_t hdl, portid;
5912 	void *ptr;
5913 
5914 	switch (type) {
5915 	case RQSTYPE_MARKER:
5916 		isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
5917 		return (1);
5918 	case RQSTYPE_RPT_ID_ACQ:
5919 		isp_get_ridacq(isp, (isp_ridacq_t *)hp, &rid);
5920 		portid = (uint32_t)rid.ridacq_vp_port_hi << 16 |
5921 		    rid.ridacq_vp_port_lo;
5922 		if (rid.ridacq_format == 0) {
5923 			for (chan = 0; chan < isp->isp_nchan; chan++) {
5924 				fcparam *fcp = FCPARAM(isp, chan);
5925 				if (fcp->role == ISP_ROLE_NONE)
5926 					continue;
5927 				c = (chan == 0) ? 127 : (chan - 1);
5928 				if (rid.ridacq_map[c / 16] & (1 << (c % 16)) ||
5929 				    chan == 0) {
5930 					fcp->isp_loopstate = LOOP_HAVE_LINK;
5931 					isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5932 					    chan, ISPASYNC_CHANGE_OTHER);
5933 				} else {
5934 					fcp->isp_loopstate = LOOP_NIL;
5935 					isp_async(isp, ISPASYNC_LOOP_DOWN,
5936 					    chan);
5937 				}
5938 			}
5939 		} else {
5940 			fcparam *fcp = FCPARAM(isp, rid.ridacq_vp_index);
5941 			if (rid.ridacq_vp_status == RIDACQ_STS_COMPLETE ||
5942 			    rid.ridacq_vp_status == RIDACQ_STS_CHANGED) {
5943 				fcp->isp_topo = (rid.ridacq_map[0] >> 9) & 0x7;
5944 				fcp->isp_portid = portid;
5945 				fcp->isp_loopstate = LOOP_HAVE_ADDR;
5946 				isp_async(isp, ISPASYNC_CHANGE_NOTIFY,
5947 				    rid.ridacq_vp_index, ISPASYNC_CHANGE_OTHER);
5948 			} else {
5949 				fcp->isp_loopstate = LOOP_NIL;
5950 				isp_async(isp, ISPASYNC_LOOP_DOWN,
5951 				    rid.ridacq_vp_index);
5952 			}
5953 		}
5954 		return (1);
5955 	case RQSTYPE_CT_PASSTHRU:
5956 	case RQSTYPE_VP_MODIFY:
5957 	case RQSTYPE_VP_CTRL:
5958 	case RQSTYPE_LOGIN:
5959 		ISP_IOXGET_32(isp, (uint32_t *)(hp + 1), hdl);
5960 		ptr = isp_find_xs(isp, hdl);
5961 		if (ptr != NULL) {
5962 			isp_destroy_handle(isp, hdl);
5963 			memcpy(ptr, hp, QENTRY_LEN);
5964 			wakeup(ptr);
5965 		}
5966 		return (1);
5967 	case RQSTYPE_ATIO:
5968 	case RQSTYPE_CTIO:
5969 	case RQSTYPE_NOTIFY:
5970 	case RQSTYPE_NOTIFY_ACK:
5971 	case RQSTYPE_CTIO1:
5972 	case RQSTYPE_ATIO2:
5973 	case RQSTYPE_CTIO2:
5974 	case RQSTYPE_CTIO3:
5975 	case RQSTYPE_CTIO7:
5976 	case RQSTYPE_ABTS_RCVD:
5977 	case RQSTYPE_ABTS_RSP:
5978 #ifdef	ISP_TARGET_MODE
5979 		return (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp));
5980 #endif
5981 		/* FALLTHROUGH */
5982 	case RQSTYPE_REQUEST:
5983 	default:
5984 		return (0);
5985 	}
5986 }
5987 
5988 static void
5989 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, uint32_t *rp)
5990 {
5991 	switch (sp->req_completion_status & 0xff) {
5992 	case RQCS_COMPLETE:
5993 		if (XS_NOERR(xs)) {
5994 			XS_SETERR(xs, HBA_NOERROR);
5995 		}
5996 		return;
5997 
5998 	case RQCS_INCOMPLETE:
5999 		if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6000 			isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6001 			if (XS_NOERR(xs)) {
6002 				XS_SETERR(xs, HBA_SELTIMEOUT);
6003 				*rp = XS_XFRLEN(xs);
6004 			}
6005 			return;
6006 		}
6007 		isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6008 		break;
6009 
6010 	case RQCS_DMA_ERROR:
6011 		isp_xs_prt(isp, xs, ISP_LOGERR, "DMA Error");
6012 		*rp = XS_XFRLEN(xs);
6013 		break;
6014 
6015 	case RQCS_TRANSPORT_ERROR:
6016 	{
6017 		char buf[172];
6018 		ISP_SNPRINTF(buf, sizeof (buf), "states=>");
6019 		if (sp->req_state_flags & RQSF_GOT_BUS) {
6020 			ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
6021 		}
6022 		if (sp->req_state_flags & RQSF_GOT_TARGET) {
6023 			ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
6024 		}
6025 		if (sp->req_state_flags & RQSF_SENT_CDB) {
6026 			ISP_SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
6027 		}
6028 		if (sp->req_state_flags & RQSF_XFRD_DATA) {
6029 			ISP_SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
6030 		}
6031 		if (sp->req_state_flags & RQSF_GOT_STATUS) {
6032 			ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
6033 		}
6034 		if (sp->req_state_flags & RQSF_GOT_SENSE) {
6035 			ISP_SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
6036 		}
6037 		if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
6038 			ISP_SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
6039 		}
6040 		ISP_SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
6041 		if (sp->req_status_flags & RQSTF_DISCONNECT) {
6042 			ISP_SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
6043 		}
6044 		if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
6045 			ISP_SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
6046 		}
6047 		if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
6048 			ISP_SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
6049 		}
6050 		if (sp->req_status_flags & RQSTF_BUS_RESET) {
6051 			ISP_SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
6052 		}
6053 		if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
6054 			ISP_SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
6055 		}
6056 		if (sp->req_status_flags & RQSTF_ABORTED) {
6057 			ISP_SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
6058 		}
6059 		if (sp->req_status_flags & RQSTF_TIMEOUT) {
6060 			ISP_SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
6061 		}
6062 		if (sp->req_status_flags & RQSTF_NEGOTIATION) {
6063 			ISP_SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
6064 		}
6065 		isp_xs_prt(isp, xs,  ISP_LOGERR, "Transport Error: %s", buf);
6066 		*rp = XS_XFRLEN(xs);
6067 		break;
6068 	}
6069 	case RQCS_RESET_OCCURRED:
6070 	{
6071 		int chan;
6072 		isp_xs_prt(isp, xs, ISP_LOGWARN, "Bus Reset destroyed command");
6073 		for (chan = 0; chan < isp->isp_nchan; chan++) {
6074 			FCPARAM(isp, chan)->sendmarker = 1;
6075 		}
6076 		if (XS_NOERR(xs)) {
6077 			XS_SETERR(xs, HBA_BUSRESET);
6078 		}
6079 		*rp = XS_XFRLEN(xs);
6080 		return;
6081 	}
6082 	case RQCS_ABORTED:
6083 		isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6084 		ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
6085 		if (XS_NOERR(xs)) {
6086 			XS_SETERR(xs, HBA_ABORTED);
6087 		}
6088 		return;
6089 
6090 	case RQCS_TIMEOUT:
6091 		isp_xs_prt(isp, xs, ISP_LOGWARN, "Command timed out");
6092 		/*
6093 	 	 * XXX: Check to see if we logged out of the device.
6094 		 */
6095 		if (XS_NOERR(xs)) {
6096 			XS_SETERR(xs, HBA_CMDTIMEOUT);
6097 		}
6098 		return;
6099 
6100 	case RQCS_DATA_OVERRUN:
6101 		XS_SET_RESID(xs, sp->req_resid);
6102 		isp_xs_prt(isp, xs, ISP_LOGERR, "data overrun (%ld)", (long) XS_GET_RESID(xs));
6103 		if (XS_NOERR(xs)) {
6104 			XS_SETERR(xs, HBA_DATAOVR);
6105 		}
6106 		return;
6107 
6108 	case RQCS_COMMAND_OVERRUN:
6109 		isp_xs_prt(isp, xs, ISP_LOGERR, "command overrun");
6110 		break;
6111 
6112 	case RQCS_STATUS_OVERRUN:
6113 		isp_xs_prt(isp, xs, ISP_LOGERR, "status overrun");
6114 		break;
6115 
6116 	case RQCS_BAD_MESSAGE:
6117 		isp_xs_prt(isp, xs, ISP_LOGERR, "msg not COMMAND COMPLETE after status");
6118 		break;
6119 
6120 	case RQCS_NO_MESSAGE_OUT:
6121 		isp_xs_prt(isp, xs, ISP_LOGERR, "No MESSAGE OUT phase after selection");
6122 		break;
6123 
6124 	case RQCS_EXT_ID_FAILED:
6125 		isp_xs_prt(isp, xs, ISP_LOGERR, "EXTENDED IDENTIFY failed");
6126 		break;
6127 
6128 	case RQCS_IDE_MSG_FAILED:
6129 		isp_xs_prt(isp, xs, ISP_LOGERR, "INITIATOR DETECTED ERROR rejected");
6130 		break;
6131 
6132 	case RQCS_ABORT_MSG_FAILED:
6133 		isp_xs_prt(isp, xs, ISP_LOGERR, "ABORT OPERATION rejected");
6134 		break;
6135 
6136 	case RQCS_REJECT_MSG_FAILED:
6137 		isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE REJECT rejected");
6138 		break;
6139 
6140 	case RQCS_NOP_MSG_FAILED:
6141 		isp_xs_prt(isp, xs, ISP_LOGERR, "NOP rejected");
6142 		break;
6143 
6144 	case RQCS_PARITY_ERROR_MSG_FAILED:
6145 		isp_xs_prt(isp, xs, ISP_LOGERR, "MESSAGE PARITY ERROR rejected");
6146 		break;
6147 
6148 	case RQCS_DEVICE_RESET_MSG_FAILED:
6149 		isp_xs_prt(isp, xs, ISP_LOGWARN, "BUS DEVICE RESET rejected");
6150 		break;
6151 
6152 	case RQCS_ID_MSG_FAILED:
6153 		isp_xs_prt(isp, xs, ISP_LOGERR, "IDENTIFY rejected");
6154 		break;
6155 
6156 	case RQCS_UNEXP_BUS_FREE:
6157 		isp_xs_prt(isp, xs, ISP_LOGERR, "Unexpected Bus Free");
6158 		break;
6159 
6160 	case RQCS_DATA_UNDERRUN:
6161 	{
6162 		if (IS_FC(isp)) {
6163 			int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6164 			if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
6165 				isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6166 				if (XS_NOERR(xs)) {
6167 					XS_SETERR(xs, HBA_BOTCH);
6168 				}
6169 				return;
6170 			}
6171 		}
6172 		XS_SET_RESID(xs, sp->req_resid);
6173 		if (XS_NOERR(xs)) {
6174 			XS_SETERR(xs, HBA_NOERROR);
6175 		}
6176 		return;
6177 	}
6178 
6179 	case RQCS_XACT_ERR1:
6180 		isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued transaction with disconnect not set");
6181 		break;
6182 
6183 	case RQCS_XACT_ERR2:
6184 		isp_xs_prt(isp, xs, ISP_LOGERR,
6185 		    "HBA attempted queued transaction to target routine %jx",
6186 		    (uintmax_t)XS_LUN(xs));
6187 		break;
6188 
6189 	case RQCS_XACT_ERR3:
6190 		isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6191 		break;
6192 
6193 	case RQCS_BAD_ENTRY:
6194 		isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6195 		break;
6196 
6197 	case RQCS_QUEUE_FULL:
6198 		isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6199 
6200 		/*
6201 		 * If QFULL or some other status byte is set, then this
6202 		 * isn't an error, per se.
6203 		 *
6204 		 * Unfortunately, some QLogic f/w writers have, in
6205 		 * some cases, omitted to *set* status to QFULL.
6206 		 */
6207 #if	0
6208 		if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6209 			XS_SETERR(xs, HBA_NOERROR);
6210 			return;
6211 		}
6212 
6213 #endif
6214 		*XS_STSP(xs) = SCSI_QFULL;
6215 		XS_SETERR(xs, HBA_NOERROR);
6216 		return;
6217 
6218 	case RQCS_PHASE_SKIPPED:
6219 		isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6220 		break;
6221 
6222 	case RQCS_ARQS_FAILED:
6223 		isp_xs_prt(isp, xs, ISP_LOGERR, "Auto Request Sense Failed");
6224 		if (XS_NOERR(xs)) {
6225 			XS_SETERR(xs, HBA_ARQFAIL);
6226 		}
6227 		return;
6228 
6229 	case RQCS_WIDE_FAILED:
6230 		isp_xs_prt(isp, xs, ISP_LOGERR, "Wide Negotiation Failed");
6231 		if (IS_SCSI(isp)) {
6232 			sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6233 			sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
6234 			sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6235 			sdp->update = 1;
6236 		}
6237 		if (XS_NOERR(xs)) {
6238 			XS_SETERR(xs, HBA_NOERROR);
6239 		}
6240 		return;
6241 
6242 	case RQCS_SYNCXFER_FAILED:
6243 		isp_xs_prt(isp, xs, ISP_LOGERR, "SDTR Message Failed");
6244 		if (IS_SCSI(isp)) {
6245 			sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
6246 			sdp += XS_CHANNEL(xs);
6247 			sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
6248 			sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
6249 			sdp->update = 1;
6250 		}
6251 		break;
6252 
6253 	case RQCS_LVD_BUSERR:
6254 		isp_xs_prt(isp, xs, ISP_LOGERR, "Bad LVD condition");
6255 		break;
6256 
6257 	case RQCS_PORT_UNAVAILABLE:
6258 		/*
6259 		 * No such port on the loop. Moral equivalent of SELTIMEO
6260 		 */
6261 	case RQCS_PORT_LOGGED_OUT:
6262 	{
6263 		const char *reason;
6264 		uint8_t sts = sp->req_completion_status & 0xff;
6265 		fcparam *fcp = FCPARAM(isp, 0);
6266 		fcportdb_t *lp;
6267 
6268 		/*
6269 		 * It was there (maybe)- treat as a selection timeout.
6270 		 */
6271 		if (sts == RQCS_PORT_UNAVAILABLE) {
6272 			reason = "unavailable";
6273 		} else {
6274 			reason = "logout";
6275 		}
6276 
6277 		isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6278 
6279 		/* XXX: Should we trigger rescan or FW announce change? */
6280 
6281 		if (XS_NOERR(xs)) {
6282 			lp = &fcp->portdb[XS_TGT(xs)];
6283 			if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6284 				*XS_STSP(xs) = SCSI_BUSY;
6285 				XS_SETERR(xs, HBA_TGTBSY);
6286 			} else
6287 				XS_SETERR(xs, HBA_SELTIMEOUT);
6288 		}
6289 		return;
6290 	}
6291 	case RQCS_PORT_CHANGED:
6292 		isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6293 		if (XS_NOERR(xs)) {
6294 			*XS_STSP(xs) = SCSI_BUSY;
6295 			XS_SETERR(xs, HBA_TGTBSY);
6296 		}
6297 		return;
6298 
6299 	case RQCS_PORT_BUSY:
6300 		isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6301 		if (XS_NOERR(xs)) {
6302 			*XS_STSP(xs) = SCSI_BUSY;
6303 			XS_SETERR(xs, HBA_TGTBSY);
6304 		}
6305 		return;
6306 
6307 	default:
6308 		isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6309 		break;
6310 	}
6311 	if (XS_NOERR(xs)) {
6312 		XS_SETERR(xs, HBA_BOTCH);
6313 	}
6314 }
6315 
6316 static void
6317 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp, XS_T *xs, uint32_t *rp)
6318 {
6319 	int ru_marked, sv_marked;
6320 	int chan = XS_CHANNEL(xs);
6321 
6322 	switch (sp->req_completion_status) {
6323 	case RQCS_COMPLETE:
6324 		if (XS_NOERR(xs)) {
6325 			XS_SETERR(xs, HBA_NOERROR);
6326 		}
6327 		return;
6328 
6329 	case RQCS_DMA_ERROR:
6330 		isp_xs_prt(isp, xs, ISP_LOGERR, "DMA error");
6331 		break;
6332 
6333 	case RQCS_TRANSPORT_ERROR:
6334 		isp_xs_prt(isp, xs,  ISP_LOGERR, "Transport Error");
6335 		break;
6336 
6337 	case RQCS_RESET_OCCURRED:
6338 		isp_xs_prt(isp, xs, ISP_LOGWARN, "reset destroyed command");
6339 		FCPARAM(isp, chan)->sendmarker = 1;
6340 		if (XS_NOERR(xs)) {
6341 			XS_SETERR(xs, HBA_BUSRESET);
6342 		}
6343 		return;
6344 
6345 	case RQCS_ABORTED:
6346 		isp_xs_prt(isp, xs, ISP_LOGERR, "Command Aborted");
6347 		FCPARAM(isp, chan)->sendmarker = 1;
6348 		if (XS_NOERR(xs)) {
6349 			XS_SETERR(xs, HBA_ABORTED);
6350 		}
6351 		return;
6352 
6353 	case RQCS_TIMEOUT:
6354 		isp_xs_prt(isp, xs, ISP_LOGWARN, "Command Timed Out");
6355 		if (XS_NOERR(xs)) {
6356 			XS_SETERR(xs, HBA_CMDTIMEOUT);
6357 		}
6358 		return;
6359 
6360 	case RQCS_DATA_OVERRUN:
6361 		XS_SET_RESID(xs, sp->req_resid);
6362 		isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6363 		if (XS_NOERR(xs)) {
6364 			XS_SETERR(xs, HBA_DATAOVR);
6365 		}
6366 		return;
6367 
6368 	case RQCS_24XX_DRE:	/* data reassembly error */
6369 		isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6370 		if (XS_NOERR(xs)) {
6371 			XS_SETERR(xs, HBA_ABORTED);
6372 		}
6373 		*rp = XS_XFRLEN(xs);
6374 		return;
6375 
6376 	case RQCS_24XX_TABORT:	/* aborted by target */
6377 		isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6378 		if (XS_NOERR(xs)) {
6379 			XS_SETERR(xs, HBA_ABORTED);
6380 		}
6381 		return;
6382 
6383 	case RQCS_DATA_UNDERRUN:
6384 		ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6385 		/*
6386 		 * We can get an underrun w/o things being marked
6387 		 * if we got a non-zero status.
6388 		 */
6389 		sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
6390 		if ((ru_marked == 0 && sv_marked == 0) ||
6391 		    (sp->req_resid > XS_XFRLEN(xs))) {
6392 			isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6393 			if (XS_NOERR(xs)) {
6394 				XS_SETERR(xs, HBA_BOTCH);
6395 			}
6396 			return;
6397 		}
6398 		XS_SET_RESID(xs, sp->req_resid);
6399 		isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6400 		if (XS_NOERR(xs)) {
6401 			XS_SETERR(xs, HBA_NOERROR);
6402 		}
6403 		return;
6404 
6405 	case RQCS_PORT_UNAVAILABLE:
6406 		/*
6407 		 * No such port on the loop. Moral equivalent of SELTIMEO
6408 		 */
6409 	case RQCS_PORT_LOGGED_OUT:
6410 	{
6411 		const char *reason;
6412 		uint8_t sts = sp->req_completion_status & 0xff;
6413 		fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
6414 		fcportdb_t *lp;
6415 
6416 		/*
6417 		 * It was there (maybe)- treat as a selection timeout.
6418 		 */
6419 		if (sts == RQCS_PORT_UNAVAILABLE) {
6420 			reason = "unavailable";
6421 		} else {
6422 			reason = "logout";
6423 		}
6424 
6425 		isp_prt(isp, ISP_LOGINFO, "Chan %d port %s for target %d",
6426 		    chan, reason, XS_TGT(xs));
6427 
6428 		/* XXX: Should we trigger rescan or FW announce change? */
6429 
6430 		if (XS_NOERR(xs)) {
6431 			lp = &fcp->portdb[XS_TGT(xs)];
6432 			if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
6433 				*XS_STSP(xs) = SCSI_BUSY;
6434 				XS_SETERR(xs, HBA_TGTBSY);
6435 			} else
6436 				XS_SETERR(xs, HBA_SELTIMEOUT);
6437 		}
6438 		return;
6439 	}
6440 	case RQCS_PORT_CHANGED:
6441 		isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6442 		if (XS_NOERR(xs)) {
6443 			*XS_STSP(xs) = SCSI_BUSY;
6444 			XS_SETERR(xs, HBA_TGTBSY);
6445 		}
6446 		return;
6447 
6448 	case RQCS_24XX_ENOMEM:	/* f/w resource unavailable */
6449 		isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6450 		if (XS_NOERR(xs)) {
6451 			*XS_STSP(xs) = SCSI_BUSY;
6452 			XS_SETERR(xs, HBA_TGTBSY);
6453 		}
6454 		return;
6455 
6456 	case RQCS_24XX_TMO:	/* task management overrun */
6457 		isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6458 		if (XS_NOERR(xs)) {
6459 			*XS_STSP(xs) = SCSI_BUSY;
6460 			XS_SETERR(xs, HBA_TGTBSY);
6461 		}
6462 		return;
6463 
6464 	default:
6465 		isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6466 		break;
6467 	}
6468 	if (XS_NOERR(xs)) {
6469 		XS_SETERR(xs, HBA_BOTCH);
6470 	}
6471 }
6472 
6473 static void
6474 isp_fastpost_complete(ispsoftc_t *isp, uint32_t fph)
6475 {
6476 	XS_T *xs;
6477 
6478 	if (fph == 0) {
6479 		return;
6480 	}
6481 	xs = isp_find_xs(isp, fph);
6482 	if (xs == NULL) {
6483 		isp_prt(isp, ISP_LOGWARN,
6484 		    "Command for fast post handle 0x%x not found", fph);
6485 		return;
6486 	}
6487 	isp_destroy_handle(isp, fph);
6488 
6489 	/*
6490 	 * Since we don't have a result queue entry item,
6491 	 * we must believe that SCSI status is zero and
6492 	 * that all data transferred.
6493 	 */
6494 	XS_SET_RESID(xs, 0);
6495 	*XS_STSP(xs) = SCSI_GOOD;
6496 	if (XS_XFRLEN(xs)) {
6497 		ISP_DMAFREE(isp, xs, fph);
6498 	}
6499 	isp_done(xs);
6500 }
6501 
6502 #define	ISP_SCSI_IBITS(op)		(mbpscsi[((op)<<1)])
6503 #define	ISP_SCSI_OBITS(op)		(mbpscsi[((op)<<1) + 1])
6504 #define	ISP_SCSI_OPMAP(in, out)		in, out
6505 static const uint8_t mbpscsi[] = {
6506 	ISP_SCSI_OPMAP(0x01, 0x01),	/* 0x00: MBOX_NO_OP */
6507 	ISP_SCSI_OPMAP(0x1f, 0x01),	/* 0x01: MBOX_LOAD_RAM */
6508 	ISP_SCSI_OPMAP(0x03, 0x01),	/* 0x02: MBOX_EXEC_FIRMWARE */
6509 	ISP_SCSI_OPMAP(0x1f, 0x01),	/* 0x03: MBOX_DUMP_RAM */
6510 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x04: MBOX_WRITE_RAM_WORD */
6511 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x05: MBOX_READ_RAM_WORD */
6512 	ISP_SCSI_OPMAP(0x3f, 0x3f),	/* 0x06: MBOX_MAILBOX_REG_TEST */
6513 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
6514 	ISP_SCSI_OPMAP(0x01, 0x0f),	/* 0x08: MBOX_ABOUT_FIRMWARE */
6515 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x09: */
6516 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x0a: */
6517 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x0b: */
6518 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x0c: */
6519 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x0d: */
6520 	ISP_SCSI_OPMAP(0x01, 0x05),	/* 0x0e: MBOX_CHECK_FIRMWARE */
6521 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x0f: */
6522 	ISP_SCSI_OPMAP(0x1f, 0x1f),	/* 0x10: MBOX_INIT_REQ_QUEUE */
6523 	ISP_SCSI_OPMAP(0x3f, 0x3f),	/* 0x11: MBOX_INIT_RES_QUEUE */
6524 	ISP_SCSI_OPMAP(0x0f, 0x0f),	/* 0x12: MBOX_EXECUTE_IOCB */
6525 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x13: MBOX_WAKE_UP	*/
6526 	ISP_SCSI_OPMAP(0x01, 0x3f),	/* 0x14: MBOX_STOP_FIRMWARE */
6527 	ISP_SCSI_OPMAP(0x0f, 0x0f),	/* 0x15: MBOX_ABORT */
6528 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x16: MBOX_ABORT_DEVICE */
6529 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x17: MBOX_ABORT_TARGET */
6530 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x18: MBOX_BUS_RESET */
6531 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x19: MBOX_STOP_QUEUE */
6532 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x1a: MBOX_START_QUEUE */
6533 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6534 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x1c: MBOX_ABORT_QUEUE */
6535 	ISP_SCSI_OPMAP(0x03, 0x4f),	/* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6536 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x1e: */
6537 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6538 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x20: MBOX_GET_INIT_SCSI_ID */
6539 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x21: MBOX_GET_SELECT_TIMEOUT */
6540 	ISP_SCSI_OPMAP(0x01, 0xc7),	/* 0x22: MBOX_GET_RETRY_COUNT	*/
6541 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6542 	ISP_SCSI_OPMAP(0x01, 0x03),	/* 0x24: MBOX_GET_CLOCK_RATE */
6543 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x25: MBOX_GET_ACT_NEG_STATE */
6544 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6545 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x27: MBOX_GET_PCI_PARAMS */
6546 	ISP_SCSI_OPMAP(0x03, 0x4f),	/* 0x28: MBOX_GET_TARGET_PARAMS */
6547 	ISP_SCSI_OPMAP(0x03, 0x0f),	/* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6548 	ISP_SCSI_OPMAP(0x01, 0x07),	/* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6549 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x2b: */
6550 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x2c: */
6551 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x2d: */
6552 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x2e: */
6553 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x2f: */
6554 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x30: MBOX_SET_INIT_SCSI_ID */
6555 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x31: MBOX_SET_SELECT_TIMEOUT */
6556 	ISP_SCSI_OPMAP(0xc7, 0xc7),	/* 0x32: MBOX_SET_RETRY_COUNT	*/
6557 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6558 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x34: MBOX_SET_CLOCK_RATE */
6559 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x35: MBOX_SET_ACT_NEG_STATE */
6560 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6561 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6562 	ISP_SCSI_OPMAP(0x4f, 0x4f),	/* 0x38: MBOX_SET_TARGET_PARAMS */
6563 	ISP_SCSI_OPMAP(0x0f, 0x0f),	/* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6564 	ISP_SCSI_OPMAP(0x07, 0x07),	/* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6565 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x3b: */
6566 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x3c: */
6567 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x3d: */
6568 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x3e: */
6569 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x3f: */
6570 	ISP_SCSI_OPMAP(0x01, 0x03),	/* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6571 	ISP_SCSI_OPMAP(0x3f, 0x01),	/* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6572 	ISP_SCSI_OPMAP(0x03, 0x07),	/* 0x42: MBOX_EXEC_BIOS_IOCB */
6573 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x43: */
6574 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x44: */
6575 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x45: SET SYSTEM PARAMETER */
6576 	ISP_SCSI_OPMAP(0x01, 0x03),	/* 0x46: GET SYSTEM PARAMETER */
6577 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x47: */
6578 	ISP_SCSI_OPMAP(0x01, 0xcf),	/* 0x48: GET SCAM CONFIGURATION */
6579 	ISP_SCSI_OPMAP(0xcf, 0xcf),	/* 0x49: SET SCAM CONFIGURATION */
6580 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6581 	ISP_SCSI_OPMAP(0x01, 0x03),	/* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6582 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x4c: */
6583 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x4d: */
6584 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x4e: */
6585 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x4f: */
6586 	ISP_SCSI_OPMAP(0xdf, 0xdf),	/* 0x50: LOAD RAM A64 */
6587 	ISP_SCSI_OPMAP(0xdf, 0xdf),	/* 0x51: DUMP RAM A64 */
6588 	ISP_SCSI_OPMAP(0xdf, 0xff),	/* 0x52: INITIALIZE REQUEST QUEUE A64 */
6589 	ISP_SCSI_OPMAP(0xef, 0xff),	/* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6590 	ISP_SCSI_OPMAP(0xcf, 0x01),	/* 0x54: EXECUCUTE COMMAND IOCB A64 */
6591 	ISP_SCSI_OPMAP(0x07, 0x01),	/* 0x55: ENABLE TARGET MODE */
6592 	ISP_SCSI_OPMAP(0x03, 0x0f),	/* 0x56: GET TARGET STATUS */
6593 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x57: */
6594 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x58: */
6595 	ISP_SCSI_OPMAP(0x00, 0x00),	/* 0x59: */
6596 	ISP_SCSI_OPMAP(0x03, 0x03),	/* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6597 	ISP_SCSI_OPMAP(0x01, 0x03),	/* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6598 	ISP_SCSI_OPMAP(0x0f, 0x0f),	/* 0x5c: SET HOST DATA */
6599 	ISP_SCSI_OPMAP(0x01, 0x01)	/* 0x5d: GET NOST DATA */
6600 };
6601 #define	MAX_SCSI_OPCODE	0x5d
6602 
6603 static const char *scsi_mbcmd_names[] = {
6604 	"NO-OP",
6605 	"LOAD RAM",
6606 	"EXEC FIRMWARE",
6607 	"DUMP RAM",
6608 	"WRITE RAM WORD",
6609 	"READ RAM WORD",
6610 	"MAILBOX REG TEST",
6611 	"VERIFY CHECKSUM",
6612 	"ABOUT FIRMWARE",
6613 	NULL,
6614 	NULL,
6615 	NULL,
6616 	NULL,
6617 	NULL,
6618 	"CHECK FIRMWARE",
6619 	NULL,
6620 	"INIT REQUEST QUEUE",
6621 	"INIT RESULT QUEUE",
6622 	"EXECUTE IOCB",
6623 	"WAKE UP",
6624 	"STOP FIRMWARE",
6625 	"ABORT",
6626 	"ABORT DEVICE",
6627 	"ABORT TARGET",
6628 	"BUS RESET",
6629 	"STOP QUEUE",
6630 	"START QUEUE",
6631 	"SINGLE STEP QUEUE",
6632 	"ABORT QUEUE",
6633 	"GET DEV QUEUE STATUS",
6634 	NULL,
6635 	"GET FIRMWARE STATUS",
6636 	"GET INIT SCSI ID",
6637 	"GET SELECT TIMEOUT",
6638 	"GET RETRY COUNT",
6639 	"GET TAG AGE LIMIT",
6640 	"GET CLOCK RATE",
6641 	"GET ACT NEG STATE",
6642 	"GET ASYNC DATA SETUP TIME",
6643 	"GET PCI PARAMS",
6644 	"GET TARGET PARAMS",
6645 	"GET DEV QUEUE PARAMS",
6646 	"GET RESET DELAY PARAMS",
6647 	NULL,
6648 	NULL,
6649 	NULL,
6650 	NULL,
6651 	NULL,
6652 	"SET INIT SCSI ID",
6653 	"SET SELECT TIMEOUT",
6654 	"SET RETRY COUNT",
6655 	"SET TAG AGE LIMIT",
6656 	"SET CLOCK RATE",
6657 	"SET ACT NEG STATE",
6658 	"SET ASYNC DATA SETUP TIME",
6659 	"SET PCI CONTROL PARAMS",
6660 	"SET TARGET PARAMS",
6661 	"SET DEV QUEUE PARAMS",
6662 	"SET RESET DELAY PARAMS",
6663 	NULL,
6664 	NULL,
6665 	NULL,
6666 	NULL,
6667 	NULL,
6668 	"RETURN BIOS BLOCK ADDR",
6669 	"WRITE FOUR RAM WORDS",
6670 	"EXEC BIOS IOCB",
6671 	NULL,
6672 	NULL,
6673 	"SET SYSTEM PARAMETER",
6674 	"GET SYSTEM PARAMETER",
6675 	NULL,
6676 	"GET SCAM CONFIGURATION",
6677 	"SET SCAM CONFIGURATION",
6678 	"SET FIRMWARE FEATURES",
6679 	"GET FIRMWARE FEATURES",
6680 	NULL,
6681 	NULL,
6682 	NULL,
6683 	NULL,
6684 	"LOAD RAM A64",
6685 	"DUMP RAM A64",
6686 	"INITIALIZE REQUEST QUEUE A64",
6687 	"INITIALIZE RESPONSE QUEUE A64",
6688 	"EXECUTE IOCB A64",
6689 	"ENABLE TARGET MODE",
6690 	"GET TARGET MODE STATE",
6691 	NULL,
6692 	NULL,
6693 	NULL,
6694 	"SET DATA OVERRUN RECOVERY MODE",
6695 	"GET DATA OVERRUN RECOVERY MODE",
6696 	"SET HOST DATA",
6697 	"GET NOST DATA",
6698 };
6699 
6700 #define	ISP_FC_IBITS(op)	((mbpfc[((op)<<3) + 0] << 24) | (mbpfc[((op)<<3) + 1] << 16) | (mbpfc[((op)<<3) + 2] << 8) | (mbpfc[((op)<<3) + 3]))
6701 #define	ISP_FC_OBITS(op)	((mbpfc[((op)<<3) + 4] << 24) | (mbpfc[((op)<<3) + 5] << 16) | (mbpfc[((op)<<3) + 6] << 8) | (mbpfc[((op)<<3) + 7]))
6702 
6703 #define	ISP_FC_OPMAP(in0, out0)							  0,   0,   0, in0,    0,    0,    0, out0
6704 #define	ISP_FC_OPMAP_HALF(in1, in0, out1, out0)					  0,   0, in1, in0,    0,    0, out1, out0
6705 #define	ISP_FC_OPMAP_FULL(in3, in2, in1, in0, out3, out2, out1, out0)		in3, in2, in1, in0, out3, out2, out1, out0
6706 static const uint32_t mbpfc[] = {
6707 	ISP_FC_OPMAP(0x01, 0x01),	/* 0x00: MBOX_NO_OP */
6708 	ISP_FC_OPMAP(0x1f, 0x01),	/* 0x01: MBOX_LOAD_RAM */
6709 	ISP_FC_OPMAP_HALF(0x07, 0xff, 0x00, 0x03),	/* 0x02: MBOX_EXEC_FIRMWARE */
6710 	ISP_FC_OPMAP(0xdf, 0x01),	/* 0x03: MBOX_DUMP_RAM */
6711 	ISP_FC_OPMAP(0x07, 0x07),	/* 0x04: MBOX_WRITE_RAM_WORD */
6712 	ISP_FC_OPMAP(0x03, 0x07),	/* 0x05: MBOX_READ_RAM_WORD */
6713 	ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff),	/* 0x06: MBOX_MAILBOX_REG_TEST */
6714 	ISP_FC_OPMAP(0x07, 0x07),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
6715 	ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f),	/* 0x08: MBOX_ABOUT_FIRMWARE */
6716 	ISP_FC_OPMAP(0xdf, 0x01),	/* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6717 	ISP_FC_OPMAP(0xdf, 0x01),	/* 0x0a: DUMP RAM */
6718 	ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01),	/* 0x0b: MBOX_LOAD_RISC_RAM */
6719 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x0c: */
6720 	ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01),	/* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6721 	ISP_FC_OPMAP(0x01, 0x05),	/* 0x0e: MBOX_CHECK_FIRMWARE */
6722 	ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d),	/* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6723 	ISP_FC_OPMAP(0x1f, 0x11),	/* 0x10: MBOX_INIT_REQ_QUEUE */
6724 	ISP_FC_OPMAP(0x2f, 0x21),	/* 0x11: MBOX_INIT_RES_QUEUE */
6725 	ISP_FC_OPMAP(0x0f, 0x01),	/* 0x12: MBOX_EXECUTE_IOCB */
6726 	ISP_FC_OPMAP(0x03, 0x03),	/* 0x13: MBOX_WAKE_UP	*/
6727 	ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x03),	/* 0x14: MBOX_STOP_FIRMWARE */
6728 	ISP_FC_OPMAP(0x4f, 0x01),	/* 0x15: MBOX_ABORT */
6729 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x16: MBOX_ABORT_DEVICE */
6730 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x17: MBOX_ABORT_TARGET */
6731 	ISP_FC_OPMAP(0x03, 0x03),	/* 0x18: MBOX_BUS_RESET */
6732 	ISP_FC_OPMAP(0x07, 0x05),	/* 0x19: MBOX_STOP_QUEUE */
6733 	ISP_FC_OPMAP(0x07, 0x05),	/* 0x1a: MBOX_START_QUEUE */
6734 	ISP_FC_OPMAP(0x07, 0x05),	/* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6735 	ISP_FC_OPMAP(0x07, 0x05),	/* 0x1c: MBOX_ABORT_QUEUE */
6736 	ISP_FC_OPMAP(0x07, 0x03),	/* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6737 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x1e: */
6738 	ISP_FC_OPMAP(0x01, 0x07),	/* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6739 	ISP_FC_OPMAP_HALF(0x2, 0x01, 0x7e, 0xcf),	/* 0x20: MBOX_GET_LOOP_ID */
6740 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x21: */
6741 	ISP_FC_OPMAP(0x03, 0x4b),	/* 0x22: MBOX_GET_TIMEOUT_PARAMS */
6742 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x23: */
6743 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x24: */
6744 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x25: */
6745 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x26: */
6746 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x27: */
6747 	ISP_FC_OPMAP(0x01, 0x03),	/* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6748 	ISP_FC_OPMAP(0x03, 0x07),	/* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6749 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2a: */
6750 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2b: */
6751 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2c: */
6752 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2d: */
6753 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2e: */
6754 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x2f: */
6755 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x30: */
6756 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x31: */
6757 	ISP_FC_OPMAP(0x4b, 0x4b),	/* 0x32: MBOX_SET_TIMEOUT_PARAMS */
6758 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x33: */
6759 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x34: */
6760 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x35: */
6761 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x36: */
6762 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x37: */
6763 	ISP_FC_OPMAP(0x0f, 0x01),	/* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6764 	ISP_FC_OPMAP(0x0f, 0x07),	/* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6765 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3a: */
6766 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3b: */
6767 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3c: */
6768 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3d: */
6769 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3e: */
6770 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x3f: */
6771 	ISP_FC_OPMAP(0x03, 0x01),	/* 0x40: MBOX_LOOP_PORT_BYPASS */
6772 	ISP_FC_OPMAP(0x03, 0x01),	/* 0x41: MBOX_LOOP_PORT_ENABLE */
6773 	ISP_FC_OPMAP_HALF(0x0, 0x01, 0x1f, 0xcf),	/* 0x42: MBOX_GET_RESOURCE_COUNT */
6774 	ISP_FC_OPMAP(0x01, 0x01),	/* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6775 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x44: */
6776 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x45: */
6777 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x46: */
6778 	ISP_FC_OPMAP(0xcf, 0x03),	/* 0x47: GET PORT_DATABASE ENHANCED */
6779 	ISP_FC_OPMAP(0xcf, 0x0f),	/* 0x48: MBOX_INIT_FIRMWARE_MULTI_ID */
6780 	ISP_FC_OPMAP(0xcd, 0x01),	/* 0x49: MBOX_GET_VP_DATABASE */
6781 	ISP_FC_OPMAP_HALF(0x2, 0xcd, 0x0, 0x01),	/* 0x4a: MBOX_GET_VP_DATABASE_ENTRY */
6782 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x4b: */
6783 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x4c: */
6784 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x4d: */
6785 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x4e: */
6786 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x4f: */
6787 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x50: */
6788 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x51: */
6789 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x52: */
6790 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x53: */
6791 	ISP_FC_OPMAP(0xcf, 0x01),	/* 0x54: EXECUTE IOCB A64 */
6792 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x55: */
6793 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x56: */
6794 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x57: */
6795 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x58: */
6796 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x59: */
6797 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x5a: */
6798 	ISP_FC_OPMAP(0x03, 0x01),	/* 0x5b: MBOX_DRIVER_HEARTBEAT */
6799 	ISP_FC_OPMAP(0xcf, 0x01),	/* 0x5c: MBOX_FW_HEARTBEAT */
6800 	ISP_FC_OPMAP(0x07, 0x1f),	/* 0x5d: MBOX_GET_SET_DATA_RATE */
6801 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x5e: */
6802 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x5f: */
6803 	ISP_FC_OPMAP(0xcf, 0x0f),	/* 0x60: MBOX_INIT_FIRMWARE */
6804 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x61: */
6805 	ISP_FC_OPMAP(0x01, 0x01),	/* 0x62: MBOX_INIT_LIP */
6806 	ISP_FC_OPMAP(0xcd, 0x03),	/* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6807 	ISP_FC_OPMAP(0xcf, 0x01),	/* 0x64: MBOX_GET_PORT_DB */
6808 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x65: MBOX_CLEAR_ACA */
6809 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x66: MBOX_TARGET_RESET */
6810 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x67: MBOX_CLEAR_TASK_SET */
6811 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x68: MBOX_ABORT_TASK_SET */
6812 	ISP_FC_OPMAP(0x01, 0x07),	/* 0x69: MBOX_GET_FW_STATE */
6813 	ISP_FC_OPMAP_HALF(0x6, 0x03, 0x0, 0xcf),	/* 0x6a: MBOX_GET_PORT_NAME */
6814 	ISP_FC_OPMAP(0xcf, 0x01),	/* 0x6b: MBOX_GET_LINK_STATUS */
6815 	ISP_FC_OPMAP(0x0f, 0x01),	/* 0x6c: MBOX_INIT_LIP_RESET */
6816 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x6d: */
6817 	ISP_FC_OPMAP(0xcf, 0x03),	/* 0x6e: MBOX_SEND_SNS */
6818 	ISP_FC_OPMAP(0x0f, 0x07),	/* 0x6f: MBOX_FABRIC_LOGIN */
6819 	ISP_FC_OPMAP_HALF(0x02, 0x03, 0x00, 0x03),	/* 0x70: MBOX_SEND_CHANGE_REQUEST */
6820 	ISP_FC_OPMAP(0x03, 0x03),	/* 0x71: MBOX_FABRIC_LOGOUT */
6821 	ISP_FC_OPMAP(0x0f, 0x0f),	/* 0x72: MBOX_INIT_LIP_LOGIN */
6822 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x73: */
6823 	ISP_FC_OPMAP(0x07, 0x01),	/* 0x74: LOGIN LOOP PORT */
6824 	ISP_FC_OPMAP_HALF(0x03, 0xcf, 0x00, 0x07),	/* 0x75: GET PORT/NODE NAME LIST */
6825 	ISP_FC_OPMAP(0x4f, 0x01),	/* 0x76: SET VENDOR ID */
6826 	ISP_FC_OPMAP(0xcd, 0x01),	/* 0x77: INITIALIZE IP MAILBOX */
6827 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x78: */
6828 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x79: */
6829 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x7a: */
6830 	ISP_FC_OPMAP(0x00, 0x00),	/* 0x7b: */
6831 	ISP_FC_OPMAP_HALF(0x03, 0x4f, 0x00, 0x07),	/* 0x7c: Get ID List */
6832 	ISP_FC_OPMAP(0xcf, 0x01),	/* 0x7d: SEND LFA */
6833 	ISP_FC_OPMAP(0x0f, 0x01)	/* 0x7e: LUN RESET */
6834 };
6835 #define	MAX_FC_OPCODE	0x7e
6836 /*
6837  * Footnotes
6838  *
6839  * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6840  *	do not access at this time in the core driver. The caller is
6841  *	responsible for setting this register first (Gross!). The assumption
6842  *	is that we won't overflow.
6843  */
6844 
6845 static const char *fc_mbcmd_names[] = {
6846 	"NO-OP",			/* 00h */
6847 	"LOAD RAM",
6848 	"EXEC FIRMWARE",
6849 	"DUMP RAM",
6850 	"WRITE RAM WORD",
6851 	"READ RAM WORD",
6852 	"MAILBOX REG TEST",
6853 	"VERIFY CHECKSUM",
6854 	"ABOUT FIRMWARE",
6855 	"LOAD RAM (2100)",
6856 	"DUMP RAM",
6857 	"LOAD RISC RAM",
6858 	"DUMP RISC RAM",
6859 	"WRITE RAM WORD EXTENDED",
6860 	"CHECK FIRMWARE",
6861 	"READ RAM WORD EXTENDED",
6862 	"INIT REQUEST QUEUE",		/* 10h */
6863 	"INIT RESULT QUEUE",
6864 	"EXECUTE IOCB",
6865 	"WAKE UP",
6866 	"STOP FIRMWARE",
6867 	"ABORT",
6868 	"ABORT DEVICE",
6869 	"ABORT TARGET",
6870 	"BUS RESET",
6871 	"STOP QUEUE",
6872 	"START QUEUE",
6873 	"SINGLE STEP QUEUE",
6874 	"ABORT QUEUE",
6875 	"GET DEV QUEUE STATUS",
6876 	NULL,
6877 	"GET FIRMWARE STATUS",
6878 	"GET LOOP ID",			/* 20h */
6879 	NULL,
6880 	"GET TIMEOUT PARAMS",
6881 	NULL,
6882 	NULL,
6883 	NULL,
6884 	NULL,
6885 	NULL,
6886 	"GET FIRMWARE OPTIONS",
6887 	"GET PORT QUEUE PARAMS",
6888 	"GENERATE SYSTEM ERROR",
6889 	NULL,
6890 	NULL,
6891 	NULL,
6892 	NULL,
6893 	NULL,
6894 	"WRITE SFP",			/* 30h */
6895 	"READ SFP",
6896 	"SET TIMEOUT PARAMS",
6897 	NULL,
6898 	NULL,
6899 	NULL,
6900 	NULL,
6901 	NULL,
6902 	"SET FIRMWARE OPTIONS",
6903 	"SET PORT QUEUE PARAMS",
6904 	NULL,
6905 	"SET FC LED CONF",
6906 	NULL,
6907 	"RESTART NIC FIRMWARE",
6908 	"ACCESS CONTROL",
6909 	NULL,
6910 	"LOOP PORT BYPASS",		/* 40h */
6911 	"LOOP PORT ENABLE",
6912 	"GET RESOURCE COUNT",
6913 	"REQUEST NON PARTICIPATING MODE",
6914 	"DIAGNOSTIC ECHO TEST",
6915 	"DIAGNOSTIC LOOPBACK",
6916 	NULL,
6917 	"GET PORT DATABASE ENHANCED",
6918 	"INIT FIRMWARE MULTI ID",
6919 	"GET VP DATABASE",
6920 	"GET VP DATABASE ENTRY",
6921 	NULL,
6922 	NULL,
6923 	NULL,
6924 	NULL,
6925 	NULL,
6926 	"GET FCF LIST",			/* 50h */
6927 	"GET DCBX PARAMETERS",
6928 	NULL,
6929 	"HOST MEMORY COPY",
6930 	"EXECUTE IOCB A64",
6931 	NULL,
6932 	NULL,
6933 	"SEND RNID",
6934 	NULL,
6935 	"SET PARAMETERS",
6936 	"GET PARAMETERS",
6937 	"DRIVER HEARTBEAT",
6938 	"FIRMWARE HEARTBEAT",
6939 	"GET/SET DATA RATE",
6940 	"SEND RNFT",
6941 	NULL,
6942 	"INIT FIRMWARE",		/* 60h */
6943 	"GET INIT CONTROL BLOCK",
6944 	"INIT LIP",
6945 	"GET FC-AL POSITION MAP",
6946 	"GET PORT DATABASE",
6947 	"CLEAR ACA",
6948 	"TARGET RESET",
6949 	"CLEAR TASK SET",
6950 	"ABORT TASK SET",
6951 	"GET FW STATE",
6952 	"GET PORT NAME",
6953 	"GET LINK STATUS",
6954 	"INIT LIP RESET",
6955 	"GET LINK STATS & PRIVATE DATA CNTS",
6956 	"SEND SNS",
6957 	"FABRIC LOGIN",
6958 	"SEND CHANGE REQUEST",		/* 70h */
6959 	"FABRIC LOGOUT",
6960 	"INIT LIP LOGIN",
6961 	NULL,
6962 	"LOGIN LOOP PORT",
6963 	"GET PORT/NODE NAME LIST",
6964 	"SET VENDOR ID",
6965 	"INITIALIZE IP MAILBOX",
6966 	NULL,
6967 	NULL,
6968 	"GET XGMAC STATS",
6969 	NULL,
6970 	"GET ID LIST",
6971 	"SEND LFA",
6972 	"LUN RESET"
6973 };
6974 
6975 static void
6976 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6977 {
6978 	const char *cname, *xname, *sname;
6979 	char tname[16], mname[16];
6980 	unsigned int ibits, obits, box, opcode;
6981 
6982 	opcode = mbp->param[0];
6983 	if (IS_FC(isp)) {
6984 		if (opcode > MAX_FC_OPCODE) {
6985 			mbp->param[0] = MBOX_INVALID_COMMAND;
6986 			isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
6987 			return;
6988 		}
6989 		cname = fc_mbcmd_names[opcode];
6990 		ibits = ISP_FC_IBITS(opcode);
6991 		obits = ISP_FC_OBITS(opcode);
6992 	} else {
6993 		if (opcode > MAX_SCSI_OPCODE) {
6994 			mbp->param[0] = MBOX_INVALID_COMMAND;
6995 			isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
6996 			return;
6997 		}
6998 		cname = scsi_mbcmd_names[opcode];
6999 		ibits = ISP_SCSI_IBITS(opcode);
7000 		obits = ISP_SCSI_OBITS(opcode);
7001 	}
7002 	if (cname == NULL) {
7003 		cname = tname;
7004 		ISP_SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
7005 	}
7006 	isp_prt(isp, ISP_LOGDEBUG3, "Mailbox Command '%s'", cname);
7007 
7008 	/*
7009 	 * Pick up any additional bits that the caller might have set.
7010 	 */
7011 	ibits |= mbp->ibits;
7012 	obits |= mbp->obits;
7013 
7014 	/*
7015 	 * Mask any bits that the caller wants us to mask
7016 	 */
7017 	ibits &= mbp->ibitm;
7018 	obits &= mbp->obitm;
7019 
7020 
7021 	if (ibits == 0 && obits == 0) {
7022 		mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
7023 		isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
7024 		return;
7025 	}
7026 
7027 	/*
7028 	 * Get exclusive usage of mailbox registers.
7029 	 */
7030 	if (MBOX_ACQUIRE(isp)) {
7031 		mbp->param[0] = MBOX_REGS_BUSY;
7032 		goto out;
7033 	}
7034 
7035 	for (box = 0; box < ISP_NMBOX(isp); box++) {
7036 		if (ibits & (1 << box)) {
7037 			isp_prt(isp, ISP_LOGDEBUG3, "IN mbox %d = 0x%04x", box,
7038 			    mbp->param[box]);
7039 			ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
7040 		}
7041 		isp->isp_mboxtmp[box] = mbp->param[box] = 0;
7042 	}
7043 
7044 	isp->isp_lastmbxcmd = opcode;
7045 
7046 	/*
7047 	 * We assume that we can't overwrite a previous command.
7048 	 */
7049 	isp->isp_obits = obits;
7050 	isp->isp_mboxbsy = 1;
7051 
7052 	/*
7053 	 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
7054 	 */
7055 	if (IS_24XX(isp)) {
7056 		ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
7057 	} else {
7058 		ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
7059 	}
7060 
7061 	/*
7062 	 * While we haven't finished the command, spin our wheels here.
7063 	 */
7064 	MBOX_WAIT_COMPLETE(isp, mbp);
7065 
7066 	/*
7067 	 * Did the command time out?
7068 	 */
7069 	if (mbp->param[0] == MBOX_TIMEOUT) {
7070 		isp->isp_mboxbsy = 0;
7071 		MBOX_RELEASE(isp);
7072 		goto out;
7073 	}
7074 
7075 	/*
7076 	 * Copy back output registers.
7077 	 */
7078 	for (box = 0; box < ISP_NMBOX(isp); box++) {
7079 		if (obits & (1 << box)) {
7080 			mbp->param[box] = isp->isp_mboxtmp[box];
7081 			isp_prt(isp, ISP_LOGDEBUG3, "OUT mbox %d = 0x%04x", box,
7082 			    mbp->param[box]);
7083 		}
7084 	}
7085 
7086 	isp->isp_mboxbsy = 0;
7087 	MBOX_RELEASE(isp);
7088 out:
7089 	if (mbp->logval == 0 || mbp->param[0] == MBOX_COMMAND_COMPLETE)
7090 		return;
7091 
7092 	if ((mbp->param[0] & 0xbfe0) == 0 &&
7093 	    (mbp->logval & MBLOGMASK(mbp->param[0])) == 0)
7094 		return;
7095 
7096 	xname = NULL;
7097 	sname = "";
7098 	switch (mbp->param[0]) {
7099 	case MBOX_INVALID_COMMAND:
7100 		xname = "INVALID COMMAND";
7101 		break;
7102 	case MBOX_HOST_INTERFACE_ERROR:
7103 		xname = "HOST INTERFACE ERROR";
7104 		break;
7105 	case MBOX_TEST_FAILED:
7106 		xname = "TEST FAILED";
7107 		break;
7108 	case MBOX_COMMAND_ERROR:
7109 		xname = "COMMAND ERROR";
7110 		ISP_SNPRINTF(mname, sizeof(mname), " subcode 0x%x",
7111 		    mbp->param[1]);
7112 		sname = mname;
7113 		break;
7114 	case MBOX_COMMAND_PARAM_ERROR:
7115 		xname = "COMMAND PARAMETER ERROR";
7116 		break;
7117 	case MBOX_PORT_ID_USED:
7118 		xname = "PORT ID ALREADY IN USE";
7119 		break;
7120 	case MBOX_LOOP_ID_USED:
7121 		xname = "LOOP ID ALREADY IN USE";
7122 		break;
7123 	case MBOX_ALL_IDS_USED:
7124 		xname = "ALL LOOP IDS IN USE";
7125 		break;
7126 	case MBOX_NOT_LOGGED_IN:
7127 		xname = "NOT LOGGED IN";
7128 		break;
7129 	case MBOX_LINK_DOWN_ERROR:
7130 		xname = "LINK DOWN ERROR";
7131 		break;
7132 	case MBOX_LOOPBACK_ERROR:
7133 		xname = "LOOPBACK ERROR";
7134 		break;
7135 	case MBOX_CHECKSUM_ERROR:
7136 		xname = "CHECKSUM ERROR";
7137 		break;
7138 	case MBOX_INVALID_PRODUCT_KEY:
7139 		xname = "INVALID PRODUCT KEY";
7140 		break;
7141 	case MBOX_REGS_BUSY:
7142 		xname = "REGISTERS BUSY";
7143 		break;
7144 	case MBOX_TIMEOUT:
7145 		xname = "TIMEOUT";
7146 		break;
7147 	default:
7148 		ISP_SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
7149 		xname = mname;
7150 		break;
7151 	}
7152 	if (xname) {
7153 		isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s%s)",
7154 		    cname, xname, sname);
7155 	}
7156 }
7157 
7158 static int
7159 isp_fw_state(ispsoftc_t *isp, int chan)
7160 {
7161 	if (IS_FC(isp)) {
7162 		mbreg_t mbs;
7163 
7164 		MBSINIT(&mbs, MBOX_GET_FW_STATE, MBLOGALL, 0);
7165 		isp_mboxcmd(isp, &mbs);
7166 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
7167 			return (mbs.param[1]);
7168 		}
7169 	}
7170 	return (FW_ERROR);
7171 }
7172 
7173 static void
7174 isp_spi_update(ispsoftc_t *isp, int chan)
7175 {
7176 	int tgt;
7177 	mbreg_t mbs;
7178 	sdparam *sdp;
7179 
7180 	if (IS_FC(isp)) {
7181 		/*
7182 		 * There are no 'per-bus' settings for Fibre Channel.
7183 		 */
7184 		return;
7185 	}
7186 	sdp = SDPARAM(isp, chan);
7187 	sdp->update = 0;
7188 
7189 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7190 		uint16_t flags, period, offset;
7191 		int get;
7192 
7193 		if (sdp->isp_devparam[tgt].dev_enable == 0) {
7194 			sdp->isp_devparam[tgt].dev_update = 0;
7195 			sdp->isp_devparam[tgt].dev_refresh = 0;
7196 			isp_prt(isp, ISP_LOGDEBUG0, "skipping target %d bus %d update", tgt, chan);
7197 			continue;
7198 		}
7199 		/*
7200 		 * If the goal is to update the status of the device,
7201 		 * take what's in goal_flags and try and set the device
7202 		 * toward that. Otherwise, if we're just refreshing the
7203 		 * current device state, get the current parameters.
7204 		 */
7205 
7206 		MBSINIT(&mbs, 0, MBLOGALL, 0);
7207 
7208 		/*
7209 		 * Refresh overrides set
7210 		 */
7211 		if (sdp->isp_devparam[tgt].dev_refresh) {
7212 			mbs.param[0] = MBOX_GET_TARGET_PARAMS;
7213 			get = 1;
7214 		} else if (sdp->isp_devparam[tgt].dev_update) {
7215 			mbs.param[0] = MBOX_SET_TARGET_PARAMS;
7216 
7217 			/*
7218 			 * Make sure goal_flags has "Renegotiate on Error"
7219 			 * on and "Freeze Queue on Error" off.
7220 			 */
7221 			sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
7222 			sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
7223 			mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
7224 
7225 			/*
7226 			 * Insist that PARITY must be enabled
7227 			 * if SYNC or WIDE is enabled.
7228 			 */
7229 			if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
7230 				mbs.param[2] |= DPARM_PARITY;
7231 			}
7232 
7233 			if (mbs.param[2] & DPARM_SYNC) {
7234 				mbs.param[3] =
7235 				    (sdp->isp_devparam[tgt].goal_offset << 8) |
7236 				    (sdp->isp_devparam[tgt].goal_period);
7237 			}
7238 			/*
7239 			 * A command completion later that has
7240 			 * RQSTF_NEGOTIATION set can cause
7241 			 * the dev_refresh/announce cycle also.
7242 			 *
7243 			 * Note: It is really important to update our current
7244 			 * flags with at least the state of TAG capabilities-
7245 			 * otherwise we might try and send a tagged command
7246 			 * when we have it all turned off. So change it here
7247 			 * to say that current already matches goal.
7248 			 */
7249 			sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
7250 			sdp->isp_devparam[tgt].actv_flags |=
7251 			    (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
7252 			isp_prt(isp, ISP_LOGDEBUG0, "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
7253 			    chan, tgt, mbs.param[2], mbs.param[3] >> 8, mbs.param[3] & 0xff);
7254 			get = 0;
7255 		} else {
7256 			continue;
7257 		}
7258 		mbs.param[1] = (chan << 15) | (tgt << 8);
7259 		isp_mboxcmd(isp, &mbs);
7260 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7261 			continue;
7262 		}
7263 		if (get == 0) {
7264 			sdp->sendmarker = 1;
7265 			sdp->isp_devparam[tgt].dev_update = 0;
7266 			sdp->isp_devparam[tgt].dev_refresh = 1;
7267 		} else {
7268 			sdp->isp_devparam[tgt].dev_refresh = 0;
7269 			flags = mbs.param[2];
7270 			period = mbs.param[3] & 0xff;
7271 			offset = mbs.param[3] >> 8;
7272 			sdp->isp_devparam[tgt].actv_flags = flags;
7273 			sdp->isp_devparam[tgt].actv_period = period;
7274 			sdp->isp_devparam[tgt].actv_offset = offset;
7275 			isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, chan, tgt);
7276 		}
7277 	}
7278 
7279 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7280 		if (sdp->isp_devparam[tgt].dev_update ||
7281 		    sdp->isp_devparam[tgt].dev_refresh) {
7282 			sdp->update = 1;
7283 			break;
7284 		}
7285 	}
7286 }
7287 
7288 static void
7289 isp_setdfltsdparm(ispsoftc_t *isp)
7290 {
7291 	int tgt;
7292 	sdparam *sdp, *sdp1;
7293 
7294 	sdp = SDPARAM(isp, 0);
7295 	if (IS_DUALBUS(isp))
7296 		sdp1 = sdp + 1;
7297 	else
7298 		sdp1 = NULL;
7299 
7300 	/*
7301 	 * Establish some default parameters.
7302 	 */
7303 	sdp->isp_cmd_dma_burst_enable = 0;
7304 	sdp->isp_data_dma_burst_enabl = 1;
7305 	sdp->isp_fifo_threshold = 0;
7306 	sdp->isp_initiator_id = DEFAULT_IID(isp, 0);
7307 	if (isp->isp_type >= ISP_HA_SCSI_1040) {
7308 		sdp->isp_async_data_setup = 9;
7309 	} else {
7310 		sdp->isp_async_data_setup = 6;
7311 	}
7312 	sdp->isp_selection_timeout = 250;
7313 	sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7314 	sdp->isp_tag_aging = 8;
7315 	sdp->isp_bus_reset_delay = 5;
7316 	/*
7317 	 * Don't retry selection, busy or queue full automatically- reflect
7318 	 * these back to us.
7319 	 */
7320 	sdp->isp_retry_count = 0;
7321 	sdp->isp_retry_delay = 0;
7322 
7323 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7324 		sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7325 		sdp->isp_devparam[tgt].dev_enable = 1;
7326 	}
7327 
7328 	/*
7329 	 * The trick here is to establish a default for the default (honk!)
7330 	 * state (goal_flags). Then try and get the current status from
7331 	 * the card to fill in the current state. We don't, in fact, set
7332 	 * the default to the SAFE default state- that's not the goal state.
7333 	 */
7334 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7335 		uint8_t off, per;
7336 		sdp->isp_devparam[tgt].actv_offset = 0;
7337 		sdp->isp_devparam[tgt].actv_period = 0;
7338 		sdp->isp_devparam[tgt].actv_flags = 0;
7339 
7340 		sdp->isp_devparam[tgt].goal_flags =
7341 		    sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7342 
7343 		/*
7344 		 * We default to Wide/Fast for versions less than a 1040
7345 		 * (unless it's SBus).
7346 		 */
7347 		if (IS_ULTRA3(isp)) {
7348 			off = ISP_80M_SYNCPARMS >> 8;
7349 			per = ISP_80M_SYNCPARMS & 0xff;
7350 		} else if (IS_ULTRA2(isp)) {
7351 			off = ISP_40M_SYNCPARMS >> 8;
7352 			per = ISP_40M_SYNCPARMS & 0xff;
7353 		} else if (IS_1240(isp)) {
7354 			off = ISP_20M_SYNCPARMS >> 8;
7355 			per = ISP_20M_SYNCPARMS & 0xff;
7356 		} else if ((isp->isp_bustype == ISP_BT_SBUS &&
7357 		    isp->isp_type < ISP_HA_SCSI_1020A) ||
7358 		    (isp->isp_bustype == ISP_BT_PCI &&
7359 		    isp->isp_type < ISP_HA_SCSI_1040) ||
7360 		    (isp->isp_clock && isp->isp_clock < 60) ||
7361 		    (sdp->isp_ultramode == 0)) {
7362 			off = ISP_10M_SYNCPARMS >> 8;
7363 			per = ISP_10M_SYNCPARMS & 0xff;
7364 		} else {
7365 			off = ISP_20M_SYNCPARMS_1040 >> 8;
7366 			per = ISP_20M_SYNCPARMS_1040 & 0xff;
7367 		}
7368 		sdp->isp_devparam[tgt].goal_offset =
7369 		    sdp->isp_devparam[tgt].nvrm_offset = off;
7370 		sdp->isp_devparam[tgt].goal_period =
7371 		    sdp->isp_devparam[tgt].nvrm_period = per;
7372 
7373 	}
7374 
7375 	/*
7376 	 * If we're a dual bus card, just copy the data over
7377 	 */
7378 	if (sdp1) {
7379 		*sdp1 = *sdp;
7380 		sdp1->isp_initiator_id = DEFAULT_IID(isp, 1);
7381 	}
7382 
7383 	/*
7384 	 * If we've not been told to avoid reading NVRAM, try and read it.
7385 	 * If we're successful reading it, we can then return because NVRAM
7386 	 * will tell us what the desired settings are. Otherwise, we establish
7387 	 * some reasonable 'fake' nvram and goal defaults.
7388 	 */
7389 	if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7390 		mbreg_t mbs;
7391 
7392 		if (isp_read_nvram(isp, 0) == 0) {
7393 			if (IS_DUALBUS(isp)) {
7394 				if (isp_read_nvram(isp, 1) == 0) {
7395 					return;
7396 				}
7397 			}
7398 		}
7399 		MBSINIT(&mbs, MBOX_GET_ACT_NEG_STATE, MBLOGNONE, 0);
7400 		isp_mboxcmd(isp, &mbs);
7401 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7402 			sdp->isp_req_ack_active_neg = 1;
7403 			sdp->isp_data_line_active_neg = 1;
7404 			if (sdp1) {
7405 				sdp1->isp_req_ack_active_neg = 1;
7406 				sdp1->isp_data_line_active_neg = 1;
7407 			}
7408 		} else {
7409 			sdp->isp_req_ack_active_neg =
7410 			    (mbs.param[1] >> 4) & 0x1;
7411 			sdp->isp_data_line_active_neg =
7412 			    (mbs.param[1] >> 5) & 0x1;
7413 			if (sdp1) {
7414 				sdp1->isp_req_ack_active_neg =
7415 				    (mbs.param[2] >> 4) & 0x1;
7416 				sdp1->isp_data_line_active_neg =
7417 				    (mbs.param[2] >> 5) & 0x1;
7418 			}
7419 		}
7420 	}
7421 
7422 }
7423 
7424 static void
7425 isp_setdfltfcparm(ispsoftc_t *isp, int chan)
7426 {
7427 	fcparam *fcp = FCPARAM(isp, chan);
7428 
7429 	/*
7430 	 * Establish some default parameters.
7431 	 */
7432 	fcp->role = DEFAULT_ROLE(isp, chan);
7433 	fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7434 	fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7435 	fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7436 	fcp->isp_loopid = DEFAULT_LOOPID(isp, chan);
7437 	fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp, chan);
7438 	fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp, chan);
7439 	fcp->isp_fwoptions = 0;
7440 	fcp->isp_xfwoptions = 0;
7441 	fcp->isp_zfwoptions = 0;
7442 	fcp->isp_lasthdl = NIL_HANDLE;
7443 	fcp->isp_login_hdl = NIL_HANDLE;
7444 
7445 	if (IS_24XX(isp)) {
7446 		fcp->isp_fwoptions |= ICB2400_OPT1_FAIRNESS;
7447 		fcp->isp_fwoptions |= ICB2400_OPT1_HARD_ADDRESS;
7448 		if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7449 			fcp->isp_fwoptions |= ICB2400_OPT1_FULL_DUPLEX;
7450 		fcp->isp_fwoptions |= ICB2400_OPT1_BOTH_WWNS;
7451 		fcp->isp_xfwoptions |= ICB2400_OPT2_LOOP_2_PTP;
7452 		fcp->isp_zfwoptions |= ICB2400_OPT3_RATE_AUTO;
7453 	} else {
7454 		fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7455 		fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7456 		fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7457 		if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
7458 			fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7459 		/*
7460 		 * Make sure this is turned off now until we get
7461 		 * extended options from NVRAM
7462 		 */
7463 		fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7464 		fcp->isp_xfwoptions |= ICBXOPT_LOOP_2_PTP;
7465 		fcp->isp_zfwoptions |= ICBZOPT_RATE_AUTO;
7466 	}
7467 
7468 
7469 	/*
7470 	 * Now try and read NVRAM unless told to not do so.
7471 	 * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7472 	 */
7473 	if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7474 		int i, j = 0;
7475 		/*
7476 		 * Give a couple of tries at reading NVRAM.
7477 		 */
7478 		for (i = 0; i < 2; i++) {
7479 			j = isp_read_nvram(isp, chan);
7480 			if (j == 0) {
7481 				break;
7482 			}
7483 		}
7484 		if (j) {
7485 			isp->isp_confopts |= ISP_CFG_NONVRAM;
7486 		}
7487 	}
7488 
7489 	fcp->isp_wwnn = ACTIVE_NODEWWN(isp, chan);
7490 	fcp->isp_wwpn = ACTIVE_PORTWWN(isp, chan);
7491 	isp_prt(isp, ISP_LOGCONFIG, "Chan %d 0x%08x%08x/0x%08x%08x Role %s",
7492 	    chan, (uint32_t) (fcp->isp_wwnn >> 32), (uint32_t) (fcp->isp_wwnn),
7493 	    (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) (fcp->isp_wwpn),
7494 	    isp_class3_roles[fcp->role]);
7495 }
7496 
7497 /*
7498  * Re-initialize the ISP and complete all orphaned commands
7499  * with a 'botched' notice. The reset/init routines should
7500  * not disturb an already active list of commands.
7501  */
7502 
7503 int
7504 isp_reinit(ispsoftc_t *isp, int do_load_defaults)
7505 {
7506 	int i, res = 0;
7507 
7508 	if (isp->isp_state > ISP_RESETSTATE)
7509 		isp_stop(isp);
7510 	if (isp->isp_state != ISP_RESETSTATE)
7511 		isp_reset(isp, do_load_defaults);
7512 	if (isp->isp_state != ISP_RESETSTATE) {
7513 		res = EIO;
7514 		isp_prt(isp, ISP_LOGERR, "%s: cannot reset card", __func__);
7515 		goto cleanup;
7516 	}
7517 
7518 	isp_init(isp);
7519 	if (isp->isp_state > ISP_RESETSTATE &&
7520 	    isp->isp_state != ISP_RUNSTATE) {
7521 		res = EIO;
7522 		isp_prt(isp, ISP_LOGERR, "%s: cannot init card", __func__);
7523 		ISP_DISABLE_INTS(isp);
7524 		if (IS_FC(isp)) {
7525 			/*
7526 			 * If we're in ISP_ROLE_NONE, turn off the lasers.
7527 			 */
7528 			if (!IS_24XX(isp)) {
7529 				ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7530 				ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7531 				ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7532 				ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7533 				ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7534 			}
7535 		}
7536 	}
7537 
7538 cleanup:
7539 	isp_clear_commands(isp);
7540 	if (IS_FC(isp)) {
7541 		for (i = 0; i < isp->isp_nchan; i++)
7542 			isp_clear_portdb(isp, i);
7543 	}
7544 	return (res);
7545 }
7546 
7547 /*
7548  * NVRAM Routines
7549  */
7550 static int
7551 isp_read_nvram(ispsoftc_t *isp, int bus)
7552 {
7553 	int i, amt, retval;
7554 	uint8_t csum, minversion;
7555 	union {
7556 		uint8_t _x[ISP2400_NVRAM_SIZE];
7557 		uint16_t _s[ISP2400_NVRAM_SIZE>>1];
7558 	} _n;
7559 #define	nvram_data	_n._x
7560 #define	nvram_words	_n._s
7561 
7562 	if (IS_24XX(isp)) {
7563 		return (isp_read_nvram_2400(isp, nvram_data));
7564 	} else if (IS_FC(isp)) {
7565 		amt = ISP2100_NVRAM_SIZE;
7566 		minversion = 1;
7567 	} else if (IS_ULTRA2(isp)) {
7568 		amt = ISP1080_NVRAM_SIZE;
7569 		minversion = 0;
7570 	} else {
7571 		amt = ISP_NVRAM_SIZE;
7572 		minversion = 2;
7573 	}
7574 
7575 	for (i = 0; i < amt>>1; i++) {
7576 		isp_rdnvram_word(isp, i, &nvram_words[i]);
7577 	}
7578 
7579 	if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7580 	    nvram_data[2] != 'P') {
7581 		if (isp->isp_bustype != ISP_BT_SBUS) {
7582 			isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7583 			isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x", nvram_data[0], nvram_data[1], nvram_data[2]);
7584 		}
7585 		retval = -1;
7586 		goto out;
7587 	}
7588 
7589 	for (csum = 0, i = 0; i < amt; i++) {
7590 		csum += nvram_data[i];
7591 	}
7592 	if (csum != 0) {
7593 		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7594 		retval = -1;
7595 		goto out;
7596 	}
7597 
7598 	if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7599 		isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7600 		    ISP_NVRAM_VERSION(nvram_data));
7601 		retval = -1;
7602 		goto out;
7603 	}
7604 
7605 	if (IS_ULTRA3(isp)) {
7606 		isp_parse_nvram_12160(isp, bus, nvram_data);
7607 	} else if (IS_1080(isp)) {
7608 		isp_parse_nvram_1080(isp, bus, nvram_data);
7609 	} else if (IS_1280(isp) || IS_1240(isp)) {
7610 		isp_parse_nvram_1080(isp, bus, nvram_data);
7611 	} else if (IS_SCSI(isp)) {
7612 		isp_parse_nvram_1020(isp, nvram_data);
7613 	} else {
7614 		isp_parse_nvram_2100(isp, nvram_data);
7615 	}
7616 	retval = 0;
7617 out:
7618 	return (retval);
7619 #undef	nvram_data
7620 #undef	nvram_words
7621 }
7622 
7623 static int
7624 isp_read_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7625 {
7626 	int retval = 0;
7627 	uint32_t addr, csum, lwrds, *dptr;
7628 
7629 	if (isp->isp_port) {
7630 		addr = ISP2400_NVRAM_PORT1_ADDR;
7631 	} else {
7632 		addr = ISP2400_NVRAM_PORT0_ADDR;
7633 	}
7634 
7635 	dptr = (uint32_t *) nvram_data;
7636 	for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7637 		isp_rd_2400_nvram(isp, addr++, dptr++);
7638 	}
7639 	if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7640 	    nvram_data[2] != 'P') {
7641 		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7642 		    nvram_data[0], nvram_data[1], nvram_data[2]);
7643 		retval = -1;
7644 		goto out;
7645 	}
7646 	dptr = (uint32_t *) nvram_data;
7647 	for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7648 		uint32_t tmp;
7649 		ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7650 		csum += tmp;
7651 	}
7652 	if (csum != 0) {
7653 		isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7654 		retval = -1;
7655 		goto out;
7656 	}
7657 	isp_parse_nvram_2400(isp, nvram_data);
7658 out:
7659 	return (retval);
7660 }
7661 
7662 static void
7663 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7664 {
7665 	int i, cbits;
7666 	uint16_t bit, rqst, junk;
7667 
7668 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7669 	ISP_DELAY(10);
7670 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7671 	ISP_DELAY(10);
7672 
7673 	if (IS_FC(isp)) {
7674 		wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7675 		if (IS_2312(isp) && isp->isp_port) {
7676 			wo += 128;
7677 		}
7678 		rqst = (ISP_NVRAM_READ << 8) | wo;
7679 		cbits = 10;
7680 	} else if (IS_ULTRA2(isp)) {
7681 		wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7682 		rqst = (ISP_NVRAM_READ << 8) | wo;
7683 		cbits = 10;
7684 	} else {
7685 		wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7686 		rqst = (ISP_NVRAM_READ << 6) | wo;
7687 		cbits = 8;
7688 	}
7689 
7690 	/*
7691 	 * Clock the word select request out...
7692 	 */
7693 	for (i = cbits; i >= 0; i--) {
7694 		if ((rqst >> i) & 1) {
7695 			bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7696 		} else {
7697 			bit = BIU_NVRAM_SELECT;
7698 		}
7699 		ISP_WRITE(isp, BIU_NVRAM, bit);
7700 		ISP_DELAY(10);
7701 		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
7702 		ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7703 		ISP_DELAY(10);
7704 		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
7705 		ISP_WRITE(isp, BIU_NVRAM, bit);
7706 		ISP_DELAY(10);
7707 		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
7708 	}
7709 	/*
7710 	 * Now read the result back in (bits come back in MSB format).
7711 	 */
7712 	*rp = 0;
7713 	for (i = 0; i < 16; i++) {
7714 		uint16_t rv;
7715 		*rp <<= 1;
7716 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7717 		ISP_DELAY(10);
7718 		rv = ISP_READ(isp, BIU_NVRAM);
7719 		if (rv & BIU_NVRAM_DATAIN) {
7720 			*rp |= 1;
7721 		}
7722 		ISP_DELAY(10);
7723 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7724 		ISP_DELAY(10);
7725 		junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
7726 	}
7727 	ISP_WRITE(isp, BIU_NVRAM, 0);
7728 	ISP_DELAY(10);
7729 	junk = ISP_READ(isp, BIU_NVRAM);	/* force PCI flush */
7730 	ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7731 }
7732 
7733 static void
7734 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7735 {
7736 	int loops = 0;
7737 	uint32_t base = 0x7ffe0000;
7738 	uint32_t tmp = 0;
7739 
7740 	if (IS_26XX(isp)) {
7741 		base = 0x7fe7c000;	/* XXX: Observation, may be wrong. */
7742 	} else if (IS_25XX(isp)) {
7743 		base = 0x7ff00000 | 0x48000;
7744 	}
7745 	ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7746 	for (loops = 0; loops < 5000; loops++) {
7747 		ISP_DELAY(10);
7748 		tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7749 		if ((tmp & (1U << 31)) != 0) {
7750 			break;
7751 		}
7752 	}
7753 	if (tmp & (1U << 31)) {
7754 		*rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7755 		ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7756 	} else {
7757 		*rp = 0xffffffff;
7758 	}
7759 }
7760 
7761 static void
7762 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7763 {
7764 	sdparam *sdp = SDPARAM(isp, 0);
7765 	int tgt;
7766 
7767 	sdp->isp_fifo_threshold =
7768 		ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7769 		(ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7770 
7771 	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7772 		sdp->isp_initiator_id = ISP_NVRAM_INITIATOR_ID(nvram_data);
7773 
7774 	sdp->isp_bus_reset_delay =
7775 		ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7776 
7777 	sdp->isp_retry_count =
7778 		ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7779 
7780 	sdp->isp_retry_delay =
7781 		ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7782 
7783 	sdp->isp_async_data_setup =
7784 		ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7785 
7786 	if (isp->isp_type >= ISP_HA_SCSI_1040) {
7787 		if (sdp->isp_async_data_setup < 9) {
7788 			sdp->isp_async_data_setup = 9;
7789 		}
7790 	} else {
7791 		if (sdp->isp_async_data_setup != 6) {
7792 			sdp->isp_async_data_setup = 6;
7793 		}
7794 	}
7795 
7796 	sdp->isp_req_ack_active_neg =
7797 		ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7798 
7799 	sdp->isp_data_line_active_neg =
7800 		ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7801 
7802 	sdp->isp_data_dma_burst_enabl =
7803 		ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7804 
7805 	sdp->isp_cmd_dma_burst_enable =
7806 		ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7807 
7808 	sdp->isp_tag_aging =
7809 		ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7810 
7811 	sdp->isp_selection_timeout =
7812 		ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7813 
7814 	sdp->isp_max_queue_depth =
7815 		ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7816 
7817 	sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7818 
7819 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7820 		sdp->isp_devparam[tgt].dev_enable =
7821 			ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7822 		sdp->isp_devparam[tgt].exc_throttle =
7823 			ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7824 		sdp->isp_devparam[tgt].nvrm_offset =
7825 			ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7826 		sdp->isp_devparam[tgt].nvrm_period =
7827 			ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7828 		/*
7829 		 * We probably shouldn't lie about this, but it
7830 		 * it makes it much safer if we limit NVRAM values
7831 		 * to sanity.
7832 		 */
7833 		if (isp->isp_type < ISP_HA_SCSI_1040) {
7834 			/*
7835 			 * If we're not ultra, we can't possibly
7836 			 * be a shorter period than this.
7837 			 */
7838 			if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7839 				sdp->isp_devparam[tgt].nvrm_period = 0x19;
7840 			}
7841 			if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7842 				sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7843 			}
7844 		} else {
7845 			if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7846 				sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7847 			}
7848 		}
7849 		sdp->isp_devparam[tgt].nvrm_flags = 0;
7850 		if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7851 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7852 		sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7853 		if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7854 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7855 		if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7856 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7857 		if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7858 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7859 		if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7860 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7861 		if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7862 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7863 		sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7864 		sdp->isp_devparam[tgt].goal_offset =
7865 		    sdp->isp_devparam[tgt].nvrm_offset;
7866 		sdp->isp_devparam[tgt].goal_period =
7867 		    sdp->isp_devparam[tgt].nvrm_period;
7868 		sdp->isp_devparam[tgt].goal_flags =
7869 		    sdp->isp_devparam[tgt].nvrm_flags;
7870 	}
7871 }
7872 
7873 static void
7874 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7875 {
7876 	sdparam *sdp = SDPARAM(isp, bus);
7877 	int tgt;
7878 
7879 	sdp->isp_fifo_threshold =
7880 	    ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7881 
7882 	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7883 		sdp->isp_initiator_id = ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7884 
7885 	sdp->isp_bus_reset_delay =
7886 	    ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7887 
7888 	sdp->isp_retry_count =
7889 	    ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7890 
7891 	sdp->isp_retry_delay =
7892 	    ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7893 
7894 	sdp->isp_async_data_setup =
7895 	    ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7896 
7897 	sdp->isp_req_ack_active_neg =
7898 	    ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7899 
7900 	sdp->isp_data_line_active_neg =
7901 	    ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7902 
7903 	sdp->isp_data_dma_burst_enabl =
7904 	    ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7905 
7906 	sdp->isp_cmd_dma_burst_enable =
7907 	    ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7908 
7909 	sdp->isp_selection_timeout =
7910 	    ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7911 
7912 	sdp->isp_max_queue_depth =
7913 	     ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7914 
7915 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7916 		sdp->isp_devparam[tgt].dev_enable =
7917 		    ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7918 		sdp->isp_devparam[tgt].exc_throttle =
7919 			ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7920 		sdp->isp_devparam[tgt].nvrm_offset =
7921 			ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7922 		sdp->isp_devparam[tgt].nvrm_period =
7923 			ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7924 		sdp->isp_devparam[tgt].nvrm_flags = 0;
7925 		if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7926 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7927 		sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7928 		if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7929 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7930 		if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7931 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7932 		if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7933 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7934 		if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7935 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7936 		if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7937 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7938 		sdp->isp_devparam[tgt].actv_flags = 0;
7939 		sdp->isp_devparam[tgt].goal_offset =
7940 		    sdp->isp_devparam[tgt].nvrm_offset;
7941 		sdp->isp_devparam[tgt].goal_period =
7942 		    sdp->isp_devparam[tgt].nvrm_period;
7943 		sdp->isp_devparam[tgt].goal_flags =
7944 		    sdp->isp_devparam[tgt].nvrm_flags;
7945 	}
7946 }
7947 
7948 static void
7949 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7950 {
7951 	sdparam *sdp = SDPARAM(isp, bus);
7952 	int tgt;
7953 
7954 	sdp->isp_fifo_threshold =
7955 	    ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7956 
7957 	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7958 		sdp->isp_initiator_id = ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7959 
7960 	sdp->isp_bus_reset_delay =
7961 	    ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7962 
7963 	sdp->isp_retry_count =
7964 	    ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7965 
7966 	sdp->isp_retry_delay =
7967 	    ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7968 
7969 	sdp->isp_async_data_setup =
7970 	    ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7971 
7972 	sdp->isp_req_ack_active_neg =
7973 	    ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7974 
7975 	sdp->isp_data_line_active_neg =
7976 	    ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7977 
7978 	sdp->isp_data_dma_burst_enabl =
7979 	    ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7980 
7981 	sdp->isp_cmd_dma_burst_enable =
7982 	    ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7983 
7984 	sdp->isp_selection_timeout =
7985 	    ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7986 
7987 	sdp->isp_max_queue_depth =
7988 	     ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7989 
7990 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7991 		sdp->isp_devparam[tgt].dev_enable =
7992 		    ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7993 		sdp->isp_devparam[tgt].exc_throttle =
7994 			ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7995 		sdp->isp_devparam[tgt].nvrm_offset =
7996 			ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7997 		sdp->isp_devparam[tgt].nvrm_period =
7998 			ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7999 		sdp->isp_devparam[tgt].nvrm_flags = 0;
8000 		if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
8001 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
8002 		sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
8003 		if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
8004 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
8005 		if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
8006 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
8007 		if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
8008 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
8009 		if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
8010 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
8011 		if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
8012 			sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
8013 		sdp->isp_devparam[tgt].actv_flags = 0;
8014 		sdp->isp_devparam[tgt].goal_offset =
8015 		    sdp->isp_devparam[tgt].nvrm_offset;
8016 		sdp->isp_devparam[tgt].goal_period =
8017 		    sdp->isp_devparam[tgt].nvrm_period;
8018 		sdp->isp_devparam[tgt].goal_flags =
8019 		    sdp->isp_devparam[tgt].nvrm_flags;
8020 	}
8021 }
8022 
8023 static void
8024 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
8025 {
8026 	fcparam *fcp = FCPARAM(isp, 0);
8027 	uint64_t wwn;
8028 
8029 	/*
8030 	 * There is NVRAM storage for both Port and Node entities-
8031 	 * but the Node entity appears to be unused on all the cards
8032 	 * I can find. However, we should account for this being set
8033 	 * at some point in the future.
8034 	 *
8035 	 * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
8036 	 * bits 48..60. In the case of the 2202, it appears that they do
8037 	 * use bit 48 to distinguish between the two instances on the card.
8038 	 * The 2204, which I've never seen, *probably* extends this method.
8039 	 */
8040 	wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
8041 	if (wwn) {
8042 		isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
8043 		    (uint32_t) (wwn >> 32), (uint32_t) (wwn));
8044 		if ((wwn >> 60) == 0) {
8045 			wwn |= (((uint64_t) 2)<< 60);
8046 		}
8047 	}
8048 	fcp->isp_wwpn_nvram = wwn;
8049 	if (IS_2200(isp) || IS_23XX(isp)) {
8050 		wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
8051 		if (wwn) {
8052 			isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
8053 			    (uint32_t) (wwn >> 32),
8054 			    (uint32_t) (wwn));
8055 			if ((wwn >> 60) == 0) {
8056 				wwn |= (((uint64_t) 2)<< 60);
8057 			}
8058 		} else {
8059 			wwn = fcp->isp_wwpn_nvram & ~((uint64_t) 0xfff << 48);
8060 		}
8061 	} else {
8062 		wwn &= ~((uint64_t) 0xfff << 48);
8063 	}
8064 	fcp->isp_wwnn_nvram = wwn;
8065 
8066 	fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
8067 	if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8068 		DEFAULT_FRAMESIZE(isp) =
8069 		    ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
8070 	}
8071 	fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
8072 	fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
8073 	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8074 		fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
8075 	}
8076 	if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8077 		DEFAULT_EXEC_THROTTLE(isp) =
8078 			ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
8079 	}
8080 	fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
8081 	isp_prt(isp, ISP_LOGDEBUG0,
8082 	    "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
8083 	    (uint32_t) (fcp->isp_wwnn_nvram >> 32),
8084 	    (uint32_t) fcp->isp_wwnn_nvram,
8085 	    (uint32_t) (fcp->isp_wwpn_nvram >> 32),
8086 	    (uint32_t) fcp->isp_wwpn_nvram,
8087 	    ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
8088 	    ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
8089 	isp_prt(isp, ISP_LOGDEBUG0,
8090 	    "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
8091 	    ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
8092 	    ISP2100_NVRAM_OPTIONS(nvram_data),
8093 	    ISP2100_NVRAM_HARDLOOPID(nvram_data),
8094 	    ISP2100_NVRAM_TOV(nvram_data));
8095 	fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
8096 	fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
8097 	isp_prt(isp, ISP_LOGDEBUG0, "xfwoptions 0x%x zfw options 0x%x",
8098 	    ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
8099 }
8100 
8101 static void
8102 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
8103 {
8104 	fcparam *fcp = FCPARAM(isp, 0);
8105 	uint64_t wwn;
8106 
8107 	isp_prt(isp, ISP_LOGDEBUG0,
8108 	    "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
8109 	    (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
8110 	    (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
8111 	    (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
8112 	    (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
8113 	    ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
8114 	    ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
8115 	isp_prt(isp, ISP_LOGDEBUG0,
8116 	    "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
8117 	    ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
8118 	    ISP2400_NVRAM_HARDLOOPID(nvram_data),
8119 	    ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
8120 	    ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
8121 	    ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
8122 
8123 	wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
8124 	fcp->isp_wwpn_nvram = wwn;
8125 
8126 	wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
8127 	if (wwn) {
8128 		if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
8129 			wwn = 0;
8130 		}
8131 	}
8132 	if (wwn == 0 && (fcp->isp_wwpn_nvram >> 60) == 2) {
8133 		wwn = fcp->isp_wwpn_nvram;
8134 		wwn &= ~((uint64_t) 0xfff << 48);
8135 	}
8136 	fcp->isp_wwnn_nvram = wwn;
8137 
8138 	if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
8139 		fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
8140 	}
8141 	if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8142 		DEFAULT_FRAMESIZE(isp) =
8143 		    ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8144 	}
8145 	if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8146 		fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8147 	}
8148 	if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8149 		DEFAULT_EXEC_THROTTLE(isp) =
8150 			ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8151 	}
8152 	fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8153 	fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8154 	fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
8155 }
8156