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