xref: /freebsd/sys/dev/isp/isp_target.c (revision 6b7b2d80ed4d728d3ffd12c422e57798c1b63a84)
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  * Machine and OS Independent Target Mode Code for the Qlogic SCSI/FC adapters.
30  */
31 /*
32  * Bug fixes gratefully acknowledged from:
33  *	Oded Kedem <oded@kashya.com>
34  */
35 /*
36  * Include header file appropriate for platform we're building on.
37  */
38 
39 #ifdef	__NetBSD__
40 #include <dev/ic/isp_netbsd.h>
41 #endif
42 #ifdef	__FreeBSD__
43 #include <sys/cdefs.h>
44 __FBSDID("$FreeBSD$");
45 #include <dev/isp/isp_freebsd.h>
46 #endif
47 #ifdef	__OpenBSD__
48 #include <dev/ic/isp_openbsd.h>
49 #endif
50 #ifdef	__linux__
51 #include "isp_linux.h"
52 #endif
53 
54 #ifdef	ISP_TARGET_MODE
55 static const char atiocope[] = "ATIO returned for LUN %x because it was in the middle of Bus Device Reset on bus %d";
56 static const char atior[] = "ATIO returned for LUN %x from handle 0x%x because a Bus Reset occurred on bus %d";
57 static const char rqo[] = "%s: Request Queue Overflow";
58 
59 static void isp_got_msg_fc(ispsoftc_t *, in_fcentry_t *);
60 static void isp_got_tmf_24xx(ispsoftc_t *, at7_entry_t *);
61 static void isp_handle_atio2(ispsoftc_t *, at2_entry_t *);
62 static void isp_handle_ctio2(ispsoftc_t *, ct2_entry_t *);
63 static void isp_handle_ctio7(ispsoftc_t *, ct7_entry_t *);
64 static void isp_handle_24xx_inotify(ispsoftc_t *, in_fcentry_24xx_t *);
65 
66 /*
67  * The Qlogic driver gets an interrupt to look at response queue entries.
68  * Some of these are status completions for initiatior mode commands, but
69  * if target mode is enabled, we get a whole wad of response queue entries
70  * to be handled here.
71  *
72  * Basically the split into 3 main groups: Lun Enable/Modification responses,
73  * SCSI Command processing, and Immediate Notification events.
74  *
75  * You start by writing a request queue entry to enable target mode (and
76  * establish some resource limitations which you can modify later).
77  * The f/w responds with a LUN ENABLE or LUN MODIFY response with
78  * the status of this action. If the enable was successful, you can expect...
79  *
80  * Response queue entries with SCSI commands encapsulate show up in an ATIO
81  * (Accept Target IO) type- sometimes with enough info to stop the command at
82  * this level. Ultimately the driver has to feed back to the f/w's request
83  * queue a sequence of CTIOs (continue target I/O) that describe data to
84  * be moved and/or status to be sent) and finally finishing with sending
85  * to the f/w's response queue an ATIO which then completes the handshake
86  * with the f/w for that command. There's a lot of variations on this theme,
87  * including flags you can set in the CTIO for the Qlogic 2X00 fibre channel
88  * cards that 'auto-replenish' the f/w's ATIO count, but this is the basic
89  * gist of it.
90  *
91  * The third group that can show up in the response queue are Immediate
92  * Notification events. These include things like notifications of SCSI bus
93  * resets, or Bus Device Reset messages or other messages received. This
94  * a classic oddbins area. It can get  a little weird because you then turn
95  * around and acknowledge the Immediate Notify by writing an entry onto the
96  * request queue and then the f/w turns around and gives you an acknowledgement
97  * to *your* acknowledgement on the response queue (the idea being to let
98  * the f/w tell you when the event is *really* over I guess).
99  *
100  */
101 
102 
103 /*
104  * A new response queue entry has arrived. The interrupt service code
105  * has already swizzled it into the platform dependent from canonical form.
106  *
107  * Because of the way this driver is designed, unfortunately most of the
108  * actual synchronization work has to be done in the platform specific
109  * code- we have no synchroniation primitives in the common code.
110  */
111 
112 int
113 isp_target_notify(ispsoftc_t *isp, void *vptr, uint32_t *optrp)
114 {
115 	uint16_t status;
116 	uint32_t seqid;
117 	union {
118 		at2_entry_t	*at2iop;
119 		at2e_entry_t	*at2eiop;
120 		at7_entry_t	*at7iop;
121 		ct2_entry_t	*ct2iop;
122 		ct2e_entry_t	*ct2eiop;
123 		ct7_entry_t	*ct7iop;
124 		lun_entry_t	*lunenp;
125 		in_fcentry_t	*inot_fcp;
126 		in_fcentry_e_t	*inote_fcp;
127 		in_fcentry_24xx_t *inot_24xx;
128 		na_fcentry_t	*nack_fcp;
129 		na_fcentry_e_t	*nacke_fcp;
130 		na_fcentry_24xx_t *nack_24xx;
131 		isphdr_t	*hp;
132 		abts_t		*abts;
133 		abts_rsp_t	*abts_rsp;
134 		els_t		*els;
135 		void *		*vp;
136 #define	at2iop		unp.at2iop
137 #define	at2eiop		unp.at2eiop
138 #define	at7iop		unp.at7iop
139 #define	ct2iop		unp.ct2iop
140 #define	ct2eiop		unp.ct2eiop
141 #define	ct7iop		unp.ct7iop
142 #define	lunenp		unp.lunenp
143 #define	inot_fcp	unp.inot_fcp
144 #define	inote_fcp	unp.inote_fcp
145 #define	inot_24xx	unp.inot_24xx
146 #define	nack_fcp	unp.nack_fcp
147 #define	nacke_fcp	unp.nacke_fcp
148 #define	nack_24xx	unp.nack_24xx
149 #define	abts		unp.abts
150 #define	abts_rsp	unp.abts_rsp
151 #define els		unp.els
152 #define	hdrp		unp.hp
153 	} unp;
154 	uint8_t local[QENTRY_LEN];
155 	uint16_t iid;
156 	int bus, type, len, level, rval = 1;
157 	isp_notify_t notify;
158 
159 	type = isp_get_response_type(isp, (isphdr_t *)vptr);
160 	unp.vp = vptr;
161 
162 	ISP_TDQE(isp, "isp_target_notify", (int) *optrp, vptr);
163 
164 	switch (type) {
165 	case RQSTYPE_ATIO:
166 		isp_get_atio7(isp, at7iop, (at7_entry_t *) local);
167 		at7iop = (at7_entry_t *) local;
168 		/*
169 		 * Check for and do something with commands whose
170 		 * IULEN extends past a single queue entry.
171 		 */
172 		len = at7iop->at_ta_len & 0xfffff;
173 		if (len > (QENTRY_LEN - 8)) {
174 			len -= (QENTRY_LEN - 8);
175 			isp_prt(isp, ISP_LOGINFO, "long IU length (%d) ignored", len);
176 			while (len > 0) {
177 				*optrp =  ISP_NXT_QENTRY(*optrp, RESULT_QUEUE_LEN(isp));
178 				len -= QENTRY_LEN;
179 			}
180 		}
181 		/*
182 		 * Check for a task management function
183 		 */
184 		if (at7iop->at_cmnd.fcp_cmnd_task_management) {
185 			isp_got_tmf_24xx(isp, at7iop);
186 			break;
187 		}
188 		/*
189 		 * Just go straight to outer layer for this one.
190 		 */
191 		isp_async(isp, ISPASYNC_TARGET_ACTION, local);
192 		break;
193 
194 	case RQSTYPE_ATIO2:
195 		if (ISP_CAP_2KLOGIN(isp)) {
196 			isp_get_atio2e(isp, at2eiop, (at2e_entry_t *) local);
197 		} else {
198 			isp_get_atio2(isp, at2iop, (at2_entry_t *) local);
199 		}
200 		isp_handle_atio2(isp, (at2_entry_t *) local);
201 		break;
202 
203 	case RQSTYPE_CTIO3:
204 	case RQSTYPE_CTIO2:
205 		if (ISP_CAP_2KLOGIN(isp)) {
206 			isp_get_ctio2e(isp, ct2eiop, (ct2e_entry_t *) local);
207 		} else {
208 			isp_get_ctio2(isp, ct2iop, (ct2_entry_t *) local);
209 		}
210 		isp_handle_ctio2(isp, (ct2_entry_t *) local);
211 		break;
212 
213 	case RQSTYPE_CTIO7:
214 		isp_get_ctio7(isp, ct7iop, (ct7_entry_t *) local);
215 		isp_handle_ctio7(isp, (ct7_entry_t *) local);
216 		break;
217 
218 	case RQSTYPE_ENABLE_LUN:
219 	case RQSTYPE_MODIFY_LUN:
220 		isp_get_enable_lun(isp, lunenp, (lun_entry_t *) local);
221 		isp_async(isp, ISPASYNC_TARGET_ACTION, local);
222 		break;
223 
224 	case RQSTYPE_NOTIFY:
225 		bus = 0;
226 		if (IS_24XX(isp)) {
227 			isp_get_notify_24xx(isp, inot_24xx, (in_fcentry_24xx_t *)local);
228 			inot_24xx = (in_fcentry_24xx_t *) local;
229 			isp_handle_24xx_inotify(isp, inot_24xx);
230 			break;
231 		} else {
232 			if (ISP_CAP_2KLOGIN(isp)) {
233 				in_fcentry_e_t *ecp = (in_fcentry_e_t *)local;
234 				isp_get_notify_fc_e(isp, inote_fcp, ecp);
235 				iid = ecp->in_iid;
236 				status = ecp->in_status;
237 				seqid = ecp->in_seqid;
238 			} else {
239 				in_fcentry_t *fcp = (in_fcentry_t *)local;
240 				isp_get_notify_fc(isp, inot_fcp, fcp);
241 				iid = fcp->in_iid;
242 				status = fcp->in_status;
243 				seqid = fcp->in_seqid;
244 			}
245 		}
246 
247 		isp_prt(isp, ISP_LOGTDEBUG0, "Immediate Notify On Bus %d, status=0x%x seqid=0x%x", bus, status, seqid);
248 
249 		switch (status) {
250 		case IN_MSG_RECEIVED:
251 		case IN_IDE_RECEIVED:
252 			isp_got_msg_fc(isp, (in_fcentry_t *)local);
253 			break;
254 		case IN_RSRC_UNAVAIL:
255 			isp_prt(isp, ISP_LOGINFO, "Firmware out of ATIOs");
256 			isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, local);
257 			break;
258 
259 		case IN_RESET:
260 			ISP_MEMZERO(&notify, sizeof (isp_notify_t));
261 			notify.nt_hba = isp;
262 			notify.nt_wwn = INI_ANY;
263 			notify.nt_tgt = TGT_ANY;
264 			notify.nt_nphdl = iid;
265 			notify.nt_sid = PORT_ANY;
266 			notify.nt_did = PORT_ANY;
267 			notify.nt_lun = LUN_ANY;
268 			notify.nt_tagval = TAG_ANY;
269 			notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
270 			notify.nt_ncode = NT_BUS_RESET;
271 			notify.nt_need_ack = 1;
272 			notify.nt_lreserved = local;
273 			isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
274 			break;
275 
276 		case IN_PORT_LOGOUT:
277 			ISP_MEMZERO(&notify, sizeof (isp_notify_t));
278 			notify.nt_hba = isp;
279 			notify.nt_wwn = INI_ANY;
280 			notify.nt_nphdl = iid;
281 			notify.nt_sid = PORT_ANY;
282 			notify.nt_did = PORT_ANY;
283 			notify.nt_ncode = NT_LOGOUT;
284 			notify.nt_need_ack = 1;
285 			notify.nt_lreserved = local;
286 			isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
287 			break;
288 
289 		case IN_ABORT_TASK:
290 			ISP_MEMZERO(&notify, sizeof (isp_notify_t));
291 			notify.nt_hba = isp;
292 			notify.nt_wwn = INI_ANY;
293 			notify.nt_nphdl = iid;
294 			notify.nt_sid = PORT_ANY;
295 			notify.nt_did = PORT_ANY;
296 			notify.nt_ncode = NT_ABORT_TASK;
297 			notify.nt_need_ack = 1;
298 			notify.nt_lreserved = local;
299 			isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
300 			break;
301 
302 		case IN_GLOBAL_LOGO:
303 			isp_prt(isp, ISP_LOGTINFO, "%s: all ports logged out", __func__);
304 			ISP_MEMZERO(&notify, sizeof (isp_notify_t));
305 			notify.nt_hba = isp;
306 			notify.nt_wwn = INI_ANY;
307 			notify.nt_nphdl = NIL_HANDLE;
308 			notify.nt_sid = PORT_ANY;
309 			notify.nt_did = PORT_ANY;
310 			notify.nt_ncode = NT_GLOBAL_LOGOUT;
311 			notify.nt_need_ack = 1;
312 			notify.nt_lreserved = local;
313 			isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
314 			break;
315 
316 		case IN_PORT_CHANGED:
317 			isp_prt(isp, ISP_LOGTINFO, "%s: port changed", __func__);
318 			ISP_MEMZERO(&notify, sizeof (isp_notify_t));
319 			notify.nt_hba = isp;
320 			notify.nt_wwn = INI_ANY;
321 			notify.nt_nphdl = NIL_HANDLE;
322 			notify.nt_sid = PORT_ANY;
323 			notify.nt_did = PORT_ANY;
324 			notify.nt_ncode = NT_CHANGED;
325 			notify.nt_need_ack = 1;
326 			notify.nt_lreserved = local;
327 			isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
328 			break;
329 
330 		default:
331 			ISP_SNPRINTF(local, sizeof local, "%s: unknown status to RQSTYPE_NOTIFY (0x%x)", __func__, status);
332 			isp_print_bytes(isp, local, QENTRY_LEN, vptr);
333 			isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, local);
334 			break;
335 		}
336 		break;
337 
338 	case RQSTYPE_NOTIFY_ACK:
339 		/*
340 		 * The ISP is acknowledging our acknowledgement of an
341 		 * Immediate Notify entry for some asynchronous event.
342 		 */
343 		if (IS_24XX(isp)) {
344 			isp_get_notify_ack_24xx(isp, nack_24xx, (na_fcentry_24xx_t *) local);
345 			nack_24xx = (na_fcentry_24xx_t *) local;
346 			if (nack_24xx->na_status != NA_OK) {
347 				level = ISP_LOGINFO;
348 			} else {
349 				level = ISP_LOGTDEBUG1;
350 			}
351 			isp_prt(isp, level, "Notify Ack Status=0x%x; Subcode 0x%x seqid=0x%x", nack_24xx->na_status, nack_24xx->na_status_subcode, nack_24xx->na_rxid);
352 		} else {
353 			if (ISP_CAP_2KLOGIN(isp)) {
354 				isp_get_notify_ack_fc_e(isp, nacke_fcp, (na_fcentry_e_t *)local);
355 			} else {
356 				isp_get_notify_ack_fc(isp, nack_fcp, (na_fcentry_t *)local);
357 			}
358 			nack_fcp = (na_fcentry_t *)local;
359 			if (nack_fcp->na_status != NA_OK) {
360 				level = ISP_LOGINFO;
361 			} else {
362 				level = ISP_LOGTDEBUG1;
363 			}
364 			isp_prt(isp, level, "Notify Ack Status=0x%x seqid 0x%x", nack_fcp->na_status, nack_fcp->na_seqid);
365 		}
366 		break;
367 
368 	case RQSTYPE_ABTS_RCVD:
369 		isp_get_abts(isp, abts, (abts_t *)local);
370 		isp_async(isp, ISPASYNC_TARGET_ACTION, &local);
371 		break;
372 	case RQSTYPE_ABTS_RSP:
373 		isp_get_abts_rsp(isp, abts_rsp, (abts_rsp_t *)local);
374 		abts_rsp = (abts_rsp_t *) local;
375 		if (abts_rsp->abts_rsp_status) {
376 			level = ISP_LOGINFO;
377 		} else {
378 			level = ISP_LOGTDEBUG0;
379 		}
380 		isp_prt(isp, level, "ABTS RSP response[0x%x]: status=0x%x sub=(0x%x 0x%x)", abts_rsp->abts_rsp_rxid_task, abts_rsp->abts_rsp_status,
381 		    abts_rsp->abts_rsp_payload.rsp.subcode1, abts_rsp->abts_rsp_payload.rsp.subcode2);
382 		break;
383 	default:
384 		isp_prt(isp, ISP_LOGERR, "%s: unknown entry type 0x%x", __func__, type);
385 		rval = 0;
386 		break;
387 	}
388 #undef	atiop
389 #undef	at2iop
390 #undef	at2eiop
391 #undef	at7iop
392 #undef	ctiop
393 #undef	ct2iop
394 #undef	ct2eiop
395 #undef	ct7iop
396 #undef	lunenp
397 #undef	inotp
398 #undef	inot_fcp
399 #undef	inote_fcp
400 #undef	inot_24xx
401 #undef	nackp
402 #undef	nack_fcp
403 #undef	nacke_fcp
404 #undef	hack_24xx
405 #undef	abts
406 #undef	abts_rsp
407 #undef	els
408 #undef	hdrp
409 	return (rval);
410 }
411 
412 int
413 isp_target_put_entry(ispsoftc_t *isp, void *ap)
414 {
415 	void *outp;
416 	uint8_t etype = ((isphdr_t *) ap)->rqs_entry_type;
417 
418 	outp = isp_getrqentry(isp);
419 	if (outp == NULL) {
420 		isp_prt(isp, ISP_LOGWARN, rqo, __func__);
421 		return (-1);
422 	}
423 	switch (etype) {
424 	case RQSTYPE_ATIO2:
425 		if (ISP_CAP_2KLOGIN(isp)) {
426 			isp_put_atio2e(isp, (at2e_entry_t *) ap, (at2e_entry_t *) outp);
427 		} else {
428 			isp_put_atio2(isp, (at2_entry_t *) ap, (at2_entry_t *) outp);
429 		}
430 		break;
431 	case RQSTYPE_CTIO2:
432 		if (ISP_CAP_2KLOGIN(isp)) {
433 			isp_put_ctio2e(isp, (ct2e_entry_t *) ap, (ct2e_entry_t *) outp);
434 		} else {
435 			isp_put_ctio2(isp, (ct2_entry_t *) ap, (ct2_entry_t *) outp);
436 		}
437 		break;
438 	case RQSTYPE_CTIO7:
439 		isp_put_ctio7(isp, (ct7_entry_t *) ap, (ct7_entry_t *) outp);
440 		break;
441 	default:
442 		isp_prt(isp, ISP_LOGERR, "%s: Unknown type 0x%x", __func__, etype);
443 		return (-1);
444 	}
445 	ISP_TDQE(isp, __func__, isp->isp_reqidx, ap);
446 	ISP_SYNC_REQUEST(isp);
447 	return (0);
448 }
449 
450 int
451 isp_target_put_atio(ispsoftc_t *isp, void *arg)
452 {
453 	at2_entry_t *aep = arg;
454 	union {
455 		at2_entry_t _atio2;
456 		at2e_entry_t _atio2e;
457 	} atun;
458 
459 	ISP_MEMZERO(&atun, sizeof atun);
460 	atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2;
461 	atun._atio2.at_header.rqs_entry_count = 1;
462 	if (ISP_CAP_SCCFW(isp)) {
463 		atun._atio2.at_scclun = aep->at_scclun;
464 	} else {
465 		atun._atio2.at_lun = (uint8_t) aep->at_lun;
466 	}
467 	if (ISP_CAP_2KLOGIN(isp)) {
468 		atun._atio2e.at_iid = ((at2e_entry_t *)aep)->at_iid;
469 	} else {
470 		atun._atio2.at_iid = aep->at_iid;
471 	}
472 	atun._atio2.at_rxid = aep->at_rxid;
473 	atun._atio2.at_status = CT_OK;
474 	return (isp_target_put_entry(isp, &atun));
475 }
476 
477 /*
478  * Command completion- both for handling cases of no resources or
479  * no blackhole driver, or other cases where we have to, inline,
480  * finish the command sanely, or for normal command completion.
481  *
482  * The 'completion' code value has the scsi status byte in the low 8 bits.
483  * If status is a CHECK CONDITION and bit 8 is nonzero, then bits 12..15 have
484  * the sense key and  bits 16..23 have the ASCQ and bits 24..31 have the ASC
485  * values.
486  *
487  * NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't
488  * NB: inline SCSI sense reporting. As such, we lose this information. XXX.
489  *
490  * For both parallel && fibre channel, we use the feature that does
491  * an automatic resource autoreplenish so we don't have then later do
492  * put of an atio to replenish the f/w's resource count.
493  */
494 
495 int
496 isp_endcmd(ispsoftc_t *isp, ...)
497 {
498 	uint32_t code, hdl;
499 	uint8_t sts;
500 	union {
501 		ct2_entry_t _ctio2;
502 		ct2e_entry_t _ctio2e;
503 		ct7_entry_t _ctio7;
504 	} un;
505 	va_list ap;
506 
507 	ISP_MEMZERO(&un, sizeof un);
508 
509 	if (IS_24XX(isp)) {
510 		int vpidx, nphdl;
511 		at7_entry_t *aep;
512 		ct7_entry_t *cto = &un._ctio7;
513 
514 		va_start(ap, isp);
515 		aep = va_arg(ap, at7_entry_t *);
516 		nphdl = va_arg(ap, int);
517 		/*
518 		 * Note that vpidx may equal 0xff (unknown) here
519 		 */
520 		vpidx = va_arg(ap, int);
521 		code = va_arg(ap, uint32_t);
522 		hdl = va_arg(ap, uint32_t);
523 		va_end(ap);
524 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: [RX_ID 0x%x] chan %d code %x", __func__, aep->at_rxid, vpidx, code);
525 
526 		sts = code & 0xff;
527 		cto->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
528 		cto->ct_header.rqs_entry_count = 1;
529 		cto->ct_nphdl = nphdl;
530 		cto->ct_rxid = aep->at_rxid;
531 		cto->ct_iid_lo = (aep->at_hdr.s_id[1] << 8) | aep->at_hdr.s_id[2];
532 		cto->ct_iid_hi = aep->at_hdr.s_id[0];
533 		cto->ct_oxid = aep->at_hdr.ox_id;
534 		cto->ct_scsi_status = sts;
535 		cto->ct_vpidx = vpidx;
536 		cto->ct_flags = CT7_NOACK;
537 		if (code & ECMD_TERMINATE) {
538 			cto->ct_flags |= CT7_TERMINATE;
539 		} else if (code & ECMD_SVALID) {
540 			cto->ct_flags |= CT7_FLAG_MODE1 | CT7_SENDSTATUS;
541 			cto->ct_scsi_status |= (FCP_SNSLEN_VALID << 8);
542 			cto->rsp.m1.ct_resplen = cto->ct_senselen = min(16, MAXRESPLEN_24XX);
543 			ISP_MEMZERO(cto->rsp.m1.ct_resp, sizeof (cto->rsp.m1.ct_resp));
544 			cto->rsp.m1.ct_resp[0] = 0xf0;
545 			cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
546 			cto->rsp.m1.ct_resp[7] = 8;
547 			cto->rsp.m1.ct_resp[12] = (code >> 16) & 0xff;
548 			cto->rsp.m1.ct_resp[13] = (code >> 24) & 0xff;
549 		} else {
550 			cto->ct_flags |= CT7_FLAG_MODE1 | CT7_SENDSTATUS;
551 		}
552 		if (aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl) {
553 			cto->ct_resid = aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl;
554 			if (cto->ct_resid < 0) {
555 				 cto->ct_scsi_status |= (FCP_RESID_OVERFLOW << 8);
556 			} else if (cto->ct_resid > 0) {
557 				 cto->ct_scsi_status |= (FCP_RESID_UNDERFLOW << 8);
558 			}
559 		}
560 		cto->ct_syshandle = hdl;
561 	} else {
562 		at2_entry_t *aep;
563 		ct2_entry_t *cto = &un._ctio2;
564 
565 		va_start(ap, isp);
566 		aep = va_arg(ap, at2_entry_t *);
567 		code = va_arg(ap, uint32_t);
568 		hdl = va_arg(ap, uint32_t);
569 		va_end(ap);
570 
571 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: [RX_ID 0x%x] code %x", __func__, aep->at_rxid, code);
572 
573 		sts = code & 0xff;
574 		cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
575 		cto->ct_header.rqs_entry_count = 1;
576 		if (ISP_CAP_SCCFW(isp) == 0) {
577 			cto->ct_lun = aep->at_lun;
578 		}
579 		if (ISP_CAP_2KLOGIN(isp)) {
580 			un._ctio2e.ct_iid = ((at2e_entry_t *)aep)->at_iid;
581 		} else {
582 			cto->ct_iid = aep->at_iid;
583 		}
584 		cto->ct_rxid = aep->at_rxid;
585 		cto->rsp.m1.ct_scsi_status = sts;
586 		cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
587 		if (hdl == 0) {
588 			cto->ct_flags |= CT2_CCINCR;
589 		}
590 		if (aep->at_datalen) {
591 			cto->ct_resid = aep->at_datalen;
592 			cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
593 		}
594 		if (sts == SCSI_CHECK && (code & ECMD_SVALID)) {
595 			cto->rsp.m1.ct_resp[0] = 0xf0;
596 			cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
597 			cto->rsp.m1.ct_resp[7] = 8;
598 			cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
599 			cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
600 			cto->rsp.m1.ct_senselen = 16;
601 			cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
602 		}
603 		cto->ct_syshandle = hdl;
604 	}
605 	return (isp_target_put_entry(isp, &un));
606 }
607 
608 /*
609  * These are either broadcast events or specifically CTIO fast completion
610  */
611 
612 int
613 isp_target_async(ispsoftc_t *isp, int bus, int event)
614 {
615 	isp_notify_t notify;
616 
617 	ISP_MEMZERO(&notify, sizeof (isp_notify_t));
618 	notify.nt_hba = isp;
619 	notify.nt_wwn = INI_ANY;
620 	notify.nt_nphdl = NIL_HANDLE;
621 	notify.nt_sid = PORT_ANY;
622 	notify.nt_did = PORT_ANY;
623 	notify.nt_tgt = TGT_ANY;
624 	notify.nt_channel = bus;
625 	notify.nt_lun = LUN_ANY;
626 	notify.nt_tagval = TAG_ANY;
627 	notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
628 
629 	switch (event) {
630 	case ASYNC_LOOP_UP:
631 	case ASYNC_PTPMODE:
632 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: LOOP UP", __func__);
633 		notify.nt_ncode = NT_LINK_UP;
634 		isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
635 		break;
636 	case ASYNC_LOOP_DOWN:
637 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: LOOP DOWN", __func__);
638 		notify.nt_ncode = NT_LINK_DOWN;
639 		isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
640 		break;
641 	case ASYNC_LIP_ERROR:
642 	case ASYNC_LIP_NOS_OLS_RECV:
643 	case ASYNC_LIP_OCCURRED:
644 	case ASYNC_LOOP_RESET:
645 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: LIP RESET", __func__);
646 		notify.nt_ncode = NT_LIP_RESET;
647 		isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
648 		break;
649 	case ASYNC_BUS_RESET:
650 	case ASYNC_TIMEOUT_RESET:	/* XXX: where does this come from ? */
651 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: BUS RESET", __func__);
652 		notify.nt_ncode = NT_BUS_RESET;
653 		isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
654 		break;
655 	case ASYNC_DEVICE_RESET:
656 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: DEVICE RESET", __func__);
657 		notify.nt_ncode = NT_TARGET_RESET;
658 		isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
659 		break;
660 	case ASYNC_CTIO_DONE:
661 	{
662 		uint8_t storage[QENTRY_LEN];
663 		isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO DONE", __func__);
664 		memset(storage, 0, QENTRY_LEN);
665 		if (IS_24XX(isp)) {
666 			ct7_entry_t *ct = (ct7_entry_t *) storage;
667 			ct->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
668 			ct->ct_nphdl = CT7_OK;
669 			ct->ct_syshandle = bus;
670 			ct->ct_flags = CT7_SENDSTATUS;
671 		} else {
672             		/* This should also suffice for 2K login code */
673 			ct2_entry_t *ct = (ct2_entry_t *) storage;
674 			ct->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
675 			ct->ct_status = CT_OK;
676 			ct->ct_syshandle = bus;
677 			ct->ct_flags = CT2_SENDSTATUS|CT2_FASTPOST;
678 		}
679 		isp_async(isp, ISPASYNC_TARGET_ACTION, storage);
680 		break;
681 	}
682 	default:
683 		isp_prt(isp, ISP_LOGERR, "%s: unknown event 0x%x", __func__, event);
684 		if (isp->isp_state == ISP_RUNSTATE) {
685 			isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, NULL);
686 		}
687 		break;
688 	}
689 	return (0);
690 }
691 
692 /*
693  * Synthesize a message from the task management flags in a FCP_CMND_IU.
694  */
695 static void
696 isp_got_msg_fc(ispsoftc_t *isp, in_fcentry_t *inp)
697 {
698 	isp_notify_t notify;
699 	static const char f1[] = "%s from N-port handle 0x%x lun %x seq 0x%x";
700 	static const char f2[] = "unknown %s 0x%x lun %x N-Port handle 0x%x task flags 0x%x seq 0x%x\n";
701 	uint16_t seqid, nphdl;
702 
703 	ISP_MEMZERO(&notify, sizeof (isp_notify_t));
704 	notify.nt_hba = isp;
705 	notify.nt_wwn = INI_ANY;
706 	if (ISP_CAP_2KLOGIN(isp)) {
707 		notify.nt_nphdl = ((in_fcentry_e_t *)inp)->in_iid;
708 		nphdl = ((in_fcentry_e_t *)inp)->in_iid;
709 		seqid = ((in_fcentry_e_t *)inp)->in_seqid;
710 	} else {
711 		notify.nt_nphdl = inp->in_iid;
712 		nphdl = inp->in_iid;
713 		seqid = inp->in_seqid;
714 	}
715 	notify.nt_sid = PORT_ANY;
716 	notify.nt_did = PORT_ANY;
717 
718 	/* nt_tgt set in outer layers */
719 	if (ISP_CAP_SCCFW(isp)) {
720 		notify.nt_lun = inp->in_scclun;
721 #if __FreeBSD_version < 1000700
722 		notify.nt_lun &= 0x3fff;
723 #endif
724 	} else {
725 		notify.nt_lun = inp->in_lun;
726 	}
727 	notify.nt_tagval = seqid;
728 	notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
729 	notify.nt_need_ack = 1;
730 	notify.nt_lreserved = inp;
731 
732 	if (inp->in_status != IN_MSG_RECEIVED) {
733 		isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status", inp->in_status, notify.nt_lun, nphdl, inp->in_task_flags, inp->in_seqid);
734 		isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inp);
735 		return;
736 	}
737 
738 	if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK_SET) {
739 		isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET", nphdl, notify.nt_lun, inp->in_seqid);
740 		notify.nt_ncode = NT_ABORT_TASK_SET;
741 	} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
742 		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET", nphdl, notify.nt_lun, inp->in_seqid);
743 		notify.nt_ncode = NT_CLEAR_TASK_SET;
744 	} else if (inp->in_task_flags & TASK_FLAGS_LUN_RESET) {
745 		isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET", nphdl, notify.nt_lun, inp->in_seqid);
746 		notify.nt_ncode = NT_LUN_RESET;
747 	} else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
748 		isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET", nphdl, notify.nt_lun, inp->in_seqid);
749 		notify.nt_ncode = NT_TARGET_RESET;
750 	} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
751 		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA", nphdl, notify.nt_lun, inp->in_seqid);
752 		notify.nt_ncode = NT_CLEAR_ACA;
753 	} else {
754 		isp_prt(isp, ISP_LOGWARN, f2, "task flag", inp->in_status, notify.nt_lun, nphdl, inp->in_task_flags,  inp->in_seqid);
755 		isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inp);
756 		return;
757 	}
758 	isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
759 }
760 
761 static void
762 isp_got_tmf_24xx(ispsoftc_t *isp, at7_entry_t *aep)
763 {
764 	isp_notify_t notify;
765 	static const char f1[] = "%s from PortID 0x%06x lun %x seq 0x%08x";
766 	static const char f2[] = "unknown Task Flag 0x%x lun %x PortID 0x%x tag 0x%08x";
767 	uint16_t chan;
768 	uint32_t sid, did;
769 
770 	ISP_MEMZERO(&notify, sizeof (isp_notify_t));
771 	notify.nt_hba = isp;
772 	notify.nt_wwn = INI_ANY;
773 	notify.nt_lun = (aep->at_cmnd.fcp_cmnd_lun[0] << 8) | (aep->at_cmnd.fcp_cmnd_lun[1]);
774 	notify.nt_tagval = aep->at_rxid;
775 	notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
776 	notify.nt_lreserved = aep;
777 	sid = (aep->at_hdr.s_id[0] << 16) | (aep->at_hdr.s_id[1] <<  8) | (aep->at_hdr.s_id[2]);
778 
779 	/* Channel has to derived from D_ID */
780 	did = (aep->at_hdr.d_id[0] << 16) | (aep->at_hdr.d_id[1] << 8) | aep->at_hdr.d_id[2];
781 	for (chan = 0; chan < isp->isp_nchan; chan++) {
782 		if (FCPARAM(isp, chan)->isp_portid == did) {
783 			break;
784 		}
785 	}
786 	if (chan == isp->isp_nchan) {
787 		isp_prt(isp, ISP_LOGWARN, "%s: D_ID 0x%x not found on any channel", __func__, did);
788 		/* just drop on the floor */
789 		return;
790 	}
791 	notify.nt_nphdl = NIL_HANDLE; /* unknown here */
792 	notify.nt_sid = sid;
793 	notify.nt_did = did;
794 	notify.nt_channel = chan;
795 	if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_QUERY_TASK_SET) {
796 		isp_prt(isp, ISP_LOGINFO, f1, "QUERY TASK SET", sid, notify.nt_lun, aep->at_rxid);
797 		notify.nt_ncode = NT_QUERY_TASK_SET;
798 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_ABORT_TASK_SET) {
799 		isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET", sid, notify.nt_lun, aep->at_rxid);
800 		notify.nt_ncode = NT_ABORT_TASK_SET;
801 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_CLEAR_TASK_SET) {
802 		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET", sid, notify.nt_lun, aep->at_rxid);
803 		notify.nt_ncode = NT_CLEAR_TASK_SET;
804 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_QUERY_ASYNC_EVENT) {
805 		isp_prt(isp, ISP_LOGINFO, f1, "QUERY ASYNC EVENT", sid, notify.nt_lun, aep->at_rxid);
806 		notify.nt_ncode = NT_QUERY_ASYNC_EVENT;
807 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_LUN_RESET) {
808 		isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET", sid, notify.nt_lun, aep->at_rxid);
809 		notify.nt_ncode = NT_LUN_RESET;
810 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_TGT_RESET) {
811 		isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET", sid, notify.nt_lun, aep->at_rxid);
812 		notify.nt_ncode = NT_TARGET_RESET;
813 	} else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_CLEAR_ACA) {
814 		isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA", sid, notify.nt_lun, aep->at_rxid);
815 		notify.nt_ncode = NT_CLEAR_ACA;
816 	} else {
817 		isp_prt(isp, ISP_LOGWARN, f2, aep->at_cmnd.fcp_cmnd_task_management, notify.nt_lun, sid, aep->at_rxid);
818 		notify.nt_ncode = NT_UNKNOWN;
819 		return;
820 	}
821 	isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
822 }
823 
824 int
825 isp_notify_ack(ispsoftc_t *isp, void *arg)
826 {
827 	char storage[QENTRY_LEN];
828 	void *outp;
829 
830 	/*
831 	 * This is in case a Task Management Function ends up here.
832 	 */
833 	if (IS_24XX(isp) && arg != NULL && (((isphdr_t *)arg)->rqs_entry_type == RQSTYPE_ATIO)) {
834 		at7_entry_t *aep = arg;
835 		return (isp_endcmd(isp, aep, NIL_HANDLE, 0, 0, 0));
836 	}
837 
838 	outp = isp_getrqentry(isp);
839 	if (outp == NULL) {
840 		isp_prt(isp, ISP_LOGWARN, rqo, __func__);
841 		return (1);
842 	}
843 
844 	ISP_MEMZERO(storage, QENTRY_LEN);
845 
846 	if (IS_24XX(isp)) {
847 		na_fcentry_24xx_t *na = (na_fcentry_24xx_t *) storage;
848 		na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
849 		na->na_header.rqs_entry_count = 1;
850 		if (arg) {
851 			in_fcentry_24xx_t *in = arg;
852 			na->na_nphdl = in->in_nphdl;
853 			na->na_flags = in->in_flags;
854 			na->na_status = in->in_status;
855 			na->na_status_subcode = in->in_status_subcode;
856 			na->na_fwhandle = in->in_fwhandle;
857 			na->na_rxid = in->in_rxid;
858 			na->na_oxid = in->in_oxid;
859 			na->na_vpidx = in->in_vpidx;
860 			if (in->in_status == IN24XX_SRR_RCVD) {
861 				na->na_srr_rxid = in->in_srr_rxid;
862 				na->na_srr_reloff_hi = in->in_srr_reloff_hi;
863 				na->na_srr_reloff_lo = in->in_srr_reloff_lo;
864 				na->na_srr_iu = in->in_srr_iu;
865 				/*
866 				 * Whether we're accepting the SRR or rejecting
867 				 * it is determined by looking at the in_reserved
868 				 * field in the original notify structure.
869 				 */
870 				if (in->in_reserved) {
871 					na->na_srr_flags = 1;
872 					na->na_srr_reject_vunique = 0;
873 					na->na_srr_reject_code = 9;		/* unable to perform this command at this time */
874 					na->na_srr_reject_explanation = 0x2a;	/* unable to supply the requested data */
875 				}
876 			}
877 		}
878 		isp_put_notify_24xx_ack(isp, na, (na_fcentry_24xx_t *)outp);
879 	} else {
880 		na_fcentry_t *na = (na_fcentry_t *) storage;
881 		int iid = 0;
882 
883 		if (arg) {
884 			in_fcentry_t *inp = arg;
885 			ISP_MEMCPY(storage, arg, sizeof (isphdr_t));
886 			if (ISP_CAP_2KLOGIN(isp)) {
887 				((na_fcentry_e_t *)na)->na_iid = ((in_fcentry_e_t *)inp)->in_iid;
888 				iid = ((na_fcentry_e_t *)na)->na_iid;
889 			} else {
890 				na->na_iid = inp->in_iid;
891 				iid = na->na_iid;
892 			}
893 			na->na_task_flags = inp->in_task_flags & TASK_FLAGS_RESERVED_MASK;
894 			na->na_seqid = inp->in_seqid;
895 			na->na_status = inp->in_status;
896 			na->na_flags = NAFC_RCOUNT;
897 			if (inp->in_status == IN_RESET) {
898 				na->na_flags = NAFC_RST_CLRD;	/* We do not modify resource counts for LIP resets */
899 			}
900 			if (inp->in_status == IN_MSG_RECEIVED) {
901 				na->na_flags |= NAFC_TVALID;
902 				na->na_response = 0;	/* XXX SUCCEEDED XXX */
903 			}
904 		} else {
905 			na->na_flags = NAFC_RST_CLRD;
906 		}
907 		na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
908 		na->na_header.rqs_entry_count = 1;
909 		if (ISP_CAP_2KLOGIN(isp)) {
910 			isp_put_notify_ack_fc_e(isp, (na_fcentry_e_t *) na, (na_fcentry_e_t *)outp);
911 		} else {
912 			isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
913 		}
914 		isp_prt(isp, ISP_LOGTDEBUG0, "notify ack handle %x seqid %x flags %x tflags %x response %x", iid, na->na_seqid,
915 		    na->na_flags, na->na_task_flags, na->na_response);
916 	}
917 	ISP_TDQE(isp, "isp_notify_ack", isp->isp_reqidx, storage);
918 	ISP_SYNC_REQUEST(isp);
919 	return (0);
920 }
921 
922 int
923 isp_acknak_abts(ispsoftc_t *isp, void *arg, int errno)
924 {
925 	char storage[QENTRY_LEN];
926 	uint16_t tmpw;
927 	uint8_t tmpb;
928 	abts_t *abts = arg;
929 	abts_rsp_t *rsp = (abts_rsp_t *) storage;
930 	void *outp;
931 
932 	if (!IS_24XX(isp)) {
933 		isp_prt(isp, ISP_LOGERR, "%s: called for non-24XX card", __func__);
934 		return (0);
935 	}
936 
937 	if (abts->abts_header.rqs_entry_type != RQSTYPE_ABTS_RCVD) {
938 		isp_prt(isp, ISP_LOGERR, "%s: called for non-ABTS entry (0x%x)", __func__, abts->abts_header.rqs_entry_type);
939 		return (0);
940 	}
941 
942 	outp = isp_getrqentry(isp);
943 	if (outp == NULL) {
944 		isp_prt(isp, ISP_LOGWARN, rqo, __func__);
945 		return (1);
946 	}
947 
948 	ISP_MEMCPY(rsp, abts, QENTRY_LEN);
949 	rsp->abts_rsp_header.rqs_entry_type = RQSTYPE_ABTS_RSP;
950 
951 	/*
952 	 * Swap destination and source for response.
953 	 */
954 	rsp->abts_rsp_r_ctl = BA_ACC;
955 	tmpw = rsp->abts_rsp_did_lo;
956 	tmpb = rsp->abts_rsp_did_hi;
957 	rsp->abts_rsp_did_lo = rsp->abts_rsp_sid_lo;
958 	rsp->abts_rsp_did_hi = rsp->abts_rsp_sid_hi;
959 	rsp->abts_rsp_sid_lo = tmpw;
960 	rsp->abts_rsp_sid_hi = tmpb;
961 
962 	rsp->abts_rsp_f_ctl_hi ^= 0x80; 	/* invert Exchange Context */
963 	rsp->abts_rsp_f_ctl_hi &= ~0x7f;	/* clear Sequence Initiator and other bits */
964 	rsp->abts_rsp_f_ctl_hi |= 0x10;		/* abort the whole exchange */
965 	rsp->abts_rsp_f_ctl_hi |= 0x8;		/* last data frame of sequence */
966 	rsp->abts_rsp_f_ctl_hi |= 0x1;		/* transfer Sequence Initiative */
967 	rsp->abts_rsp_f_ctl_lo = 0;
968 
969 	if (errno == 0) {
970 		uint16_t rx_id, ox_id;
971 
972 		rx_id = rsp->abts_rsp_rx_id;
973 		ox_id = rsp->abts_rsp_ox_id;
974 		ISP_MEMZERO(&rsp->abts_rsp_payload.ba_acc, sizeof (rsp->abts_rsp_payload.ba_acc));
975                 isp_prt(isp, ISP_LOGTINFO, "[0x%x] ABTS of 0x%x being BA_ACC'd", rsp->abts_rsp_rxid_abts, rsp->abts_rsp_rxid_task);
976                 rsp->abts_rsp_payload.ba_acc.aborted_rx_id = rx_id;
977                 rsp->abts_rsp_payload.ba_acc.aborted_ox_id = ox_id;
978                 rsp->abts_rsp_payload.ba_acc.high_seq_cnt = 0xffff;
979 	} else {
980 		ISP_MEMZERO(&rsp->abts_rsp_payload.ba_rjt, sizeof (rsp->abts_rsp_payload.ba_acc));
981 		switch (errno) {
982 		case ENOMEM:
983 			rsp->abts_rsp_payload.ba_rjt.reason = 5;	/* Logical Unit Busy */
984 			break;
985 		default:
986 			rsp->abts_rsp_payload.ba_rjt.reason = 9;	/* Unable to perform command request */
987 			break;
988 		}
989 	}
990 
991 	/*
992 	 * The caller will have set response values as appropriate
993 	 * in the ABTS structure just before calling us.
994 	 */
995 	isp_put_abts_rsp(isp, rsp, (abts_rsp_t *)outp);
996 	ISP_TDQE(isp, "isp_acknak_abts", isp->isp_reqidx, storage);
997 	ISP_SYNC_REQUEST(isp);
998 	return (0);
999 }
1000 
1001 static void
1002 isp_handle_atio2(ispsoftc_t *isp, at2_entry_t *aep)
1003 {
1004 	int lun, iid;
1005 
1006 	if (ISP_CAP_SCCFW(isp)) {
1007 		lun = aep->at_scclun;
1008 #if __FreeBSD_version < 1000700
1009 		lun &= 0x3fff;
1010 #endif
1011 	} else {
1012 		lun = aep->at_lun;
1013 	}
1014 
1015 	if (ISP_CAP_2KLOGIN(isp)) {
1016 		iid = ((at2e_entry_t *)aep)->at_iid;
1017 	} else {
1018 		iid = aep->at_iid;
1019 	}
1020 
1021 	/*
1022 	 * The firmware status (except for the QLTM_SVALID bit) indicates
1023 	 * why this ATIO was sent to us.
1024 	 *
1025 	 * If QLTM_SVALID is set, the firware has recommended Sense Data.
1026 	 *
1027 	 * If the DISCONNECTS DISABLED bit is set in the flags field,
1028 	 * we're still connected on the SCSI bus - i.e. the initiator
1029 	 * did not set DiscPriv in the identify message. We don't care
1030 	 * about this so it's ignored.
1031 	 */
1032 
1033 	switch (aep->at_status & ~QLTM_SVALID) {
1034 	case AT_PATH_INVALID:
1035 		/*
1036 		 * ATIO rejected by the firmware due to disabled lun.
1037 		 */
1038 		isp_prt(isp, ISP_LOGERR, "rejected ATIO2 for disabled lun %x", lun);
1039 		break;
1040 	case AT_NOCAP:
1041 		/*
1042 		 * Requested Capability not available
1043 		 * We sent an ATIO that overflowed the firmware's
1044 		 * command resource count.
1045 		 */
1046 		isp_prt(isp, ISP_LOGERR, "rejected ATIO2 for lun %x- command count overflow", lun);
1047 		break;
1048 
1049 	case AT_BDR_MSG:
1050 		/*
1051 		 * If we send an ATIO to the firmware to increment
1052 		 * its command resource count, and the firmware is
1053 		 * recovering from a Bus Device Reset, it returns
1054 		 * the ATIO with this status. We set the command
1055 		 * resource count in the Enable Lun entry and no
1056 		 * not increment it. Therefore we should never get
1057 		 * this status here.
1058 		 */
1059 		isp_prt(isp, ISP_LOGERR, atiocope, lun, 0);
1060 		break;
1061 
1062 	case AT_CDB:		/* Got a CDB */
1063 		/*
1064 		 * Punt to platform specific layer.
1065 		 */
1066 		isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
1067 		break;
1068 
1069 	case AT_RESET:
1070 		/*
1071 		 * A bus reset came along an blew away this command. Why
1072 		 * they do this in addition the async event code stuff,
1073 		 * I dunno.
1074 		 *
1075 		 * Ignore it because the async event will clear things
1076 		 * up for us.
1077 		 */
1078 		isp_prt(isp, ISP_LOGERR, atior, lun, iid, 0);
1079 		break;
1080 
1081 
1082 	default:
1083 		isp_prt(isp, ISP_LOGERR, "Unknown ATIO2 status 0x%x from handle %d for lun %x", aep->at_status, iid, lun);
1084 		(void) isp_target_put_atio(isp, aep);
1085 		break;
1086 	}
1087 }
1088 
1089 static void
1090 isp_handle_ctio2(ispsoftc_t *isp, ct2_entry_t *ct)
1091 {
1092 	void *xs;
1093 	int pl = ISP_LOGTDEBUG2;
1094 	char *fmsg = NULL;
1095 
1096 	if (ct->ct_syshandle) {
1097 		xs = isp_find_xs(isp, ct->ct_syshandle);
1098 		if (xs == NULL) {
1099 			pl = ISP_LOGALL;
1100 		}
1101 	} else {
1102 		xs = NULL;
1103 	}
1104 
1105 	switch (ct->ct_status & ~QLTM_SVALID) {
1106 	case CT_BUS_ERROR:
1107 		isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1108 		/* FALL Through */
1109 	case CT_DATA_OVER:
1110 	case CT_DATA_UNDER:
1111 	case CT_OK:
1112 		/*
1113 		 * There are generally 2 possibilities as to why we'd get
1114 		 * this condition:
1115 		 * 	We sent or received data.
1116 		 * 	We sent status & command complete.
1117 		 */
1118 
1119 		break;
1120 
1121 	case CT_BDR_MSG:
1122 		/*
1123 		 * Target Reset function received.
1124 		 *
1125 		 * The firmware generates an async mailbox interrupt to
1126 		 * notify us of this and returns outstanding CTIOs with this
1127 		 * status. These CTIOs are handled in that same way as
1128 		 * CT_ABORTED ones, so just fall through here.
1129 		 */
1130 		fmsg = "TARGET RESET";
1131 		/*FALLTHROUGH*/
1132 	case CT_RESET:
1133 		if (fmsg == NULL)
1134 			fmsg = "LIP Reset";
1135 		/*FALLTHROUGH*/
1136 	case CT_ABORTED:
1137 		/*
1138 		 * When an Abort message is received the firmware goes to
1139 		 * Bus Free and returns all outstanding CTIOs with the status
1140 		 * set, then sends us an Immediate Notify entry.
1141 		 */
1142 		if (fmsg == NULL) {
1143 			fmsg = "ABORT";
1144 		}
1145 
1146 		isp_prt(isp, ISP_LOGTDEBUG0, "CTIO2 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
1147 		break;
1148 
1149 	case CT_INVAL:
1150 		/*
1151 		 * CTIO rejected by the firmware - invalid data direction.
1152 		 */
1153 		isp_prt(isp, ISP_LOGERR, "CTIO2 had wrong data direction");
1154 		break;
1155 
1156 	case CT_RSELTMO:
1157 		fmsg = "failure to reconnect to initiator";
1158 		/*FALLTHROUGH*/
1159 	case CT_TIMEOUT:
1160 		if (fmsg == NULL)
1161 			fmsg = "command";
1162 		isp_prt(isp, ISP_LOGWARN, "Firmware timed out on %s", fmsg);
1163 		break;
1164 
1165 	case CT_ERR:
1166 		fmsg = "Completed with Error";
1167 		/*FALLTHROUGH*/
1168 	case CT_LOGOUT:
1169 		if (fmsg == NULL)
1170 			fmsg = "Port Logout";
1171 		/*FALLTHROUGH*/
1172 	case CT_PORTUNAVAIL:
1173 		if (fmsg == NULL)
1174 			fmsg = "Port not available";
1175 		/*FALLTHROUGH*/
1176 	case CT_PORTCHANGED:
1177 		if (fmsg == NULL)
1178 			fmsg = "Port Changed";
1179 		/*FALLTHROUGH*/
1180 	case CT_NOACK:
1181 		if (fmsg == NULL)
1182 			fmsg = "unacknowledged Immediate Notify pending";
1183 		isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
1184 		break;
1185 
1186 	case CT_INVRXID:
1187 		/*
1188 		 * CTIO rejected by the firmware because an invalid RX_ID.
1189 		 * Just print a message.
1190 		 */
1191 		isp_prt(isp, ISP_LOGWARN, "CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1192 		break;
1193 
1194 	default:
1195 		isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x", ct->ct_status & ~QLTM_SVALID);
1196 		break;
1197 	}
1198 
1199 	if (xs == NULL) {
1200 		/*
1201 		 * There may be more than one CTIO for a data transfer,
1202 		 * or this may be a status CTIO we're not monitoring.
1203 		 *
1204 		 * The assumption is that they'll all be returned in the
1205 		 * order we got them.
1206 		 */
1207 		if (ct->ct_syshandle == 0) {
1208 			if ((ct->ct_flags & CT2_SENDSTATUS) == 0) {
1209 				isp_prt(isp, pl, "intermediate CTIO completed ok");
1210 			} else {
1211 				isp_prt(isp, pl, "unmonitored CTIO completed ok");
1212 			}
1213 		} else {
1214 			isp_prt(isp, pl, "NO xs for CTIO (handle 0x%x) status 0x%x", ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1215 		}
1216 	} else {
1217 		if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
1218 			ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1219 		}
1220 		if (ct->ct_flags & CT2_SENDSTATUS) {
1221 			/*
1222 			 * Sent status and command complete.
1223 			 *
1224 			 * We're now really done with this command, so we
1225 			 * punt to the platform dependent layers because
1226 			 * only there can we do the appropriate command
1227 			 * complete thread synchronization.
1228 			 */
1229 			isp_prt(isp, pl, "status CTIO complete");
1230 		} else {
1231 			/*
1232 			 * Final CTIO completed. Release DMA resources and
1233 			 * notify platform dependent layers.
1234 			 */
1235 			isp_prt(isp, pl, "data CTIO complete");
1236 		}
1237 		isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1238 		/*
1239 		 * The platform layer will destroy the handle if appropriate.
1240 		 */
1241 	}
1242 }
1243 
1244 static void
1245 isp_handle_ctio7(ispsoftc_t *isp, ct7_entry_t *ct)
1246 {
1247 	void *xs;
1248 	int pl = ISP_LOGTDEBUG2;
1249 	char *fmsg = NULL;
1250 
1251 	if (ct->ct_syshandle) {
1252 		xs = isp_find_xs(isp, ct->ct_syshandle);
1253 		if (xs == NULL) {
1254 			pl = ISP_LOGALL;
1255 		}
1256 	} else {
1257 		xs = NULL;
1258 	}
1259 
1260 	switch (ct->ct_nphdl) {
1261 	case CT7_BUS_ERROR:
1262 		isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1263 		/* FALL Through */
1264 	case CT7_DATA_OVER:
1265 	case CT7_DATA_UNDER:
1266 	case CT7_OK:
1267 		/*
1268 		 * There are generally 2 possibilities as to why we'd get
1269 		 * this condition:
1270 		 * 	We sent or received data.
1271 		 * 	We sent status & command complete.
1272 		 */
1273 
1274 		break;
1275 
1276 	case CT7_RESET:
1277 		if (fmsg == NULL) {
1278 			fmsg = "LIP Reset";
1279 		}
1280 		/*FALLTHROUGH*/
1281 	case CT7_ABORTED:
1282 		/*
1283 		 * When an Abort message is received the firmware goes to
1284 		 * Bus Free and returns all outstanding CTIOs with the status
1285 		 * set, then sends us an Immediate Notify entry.
1286 		 */
1287 		if (fmsg == NULL) {
1288 			fmsg = "ABORT";
1289 		}
1290 		isp_prt(isp, ISP_LOGTDEBUG0, "CTIO7 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
1291 		break;
1292 
1293 	case CT7_TIMEOUT:
1294 		if (fmsg == NULL) {
1295 			fmsg = "command";
1296 		}
1297 		isp_prt(isp, ISP_LOGWARN, "Firmware timed out on %s", fmsg);
1298 		break;
1299 
1300 	case CT7_ERR:
1301 		fmsg = "Completed with Error";
1302 		/*FALLTHROUGH*/
1303 	case CT7_LOGOUT:
1304 		if (fmsg == NULL) {
1305 			fmsg = "Port Logout";
1306 		}
1307 		/*FALLTHROUGH*/
1308 	case CT7_PORTUNAVAIL:
1309 		if (fmsg == NULL) {
1310 			fmsg = "Port not available";
1311 		}
1312 		/*FALLTHROUGH*/
1313 	case CT7_PORTCHANGED:
1314 		if (fmsg == NULL) {
1315 			fmsg = "Port Changed";
1316 		}
1317 		isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
1318 		break;
1319 
1320 	case CT7_INVRXID:
1321 		/*
1322 		 * CTIO rejected by the firmware because an invalid RX_ID.
1323 		 * Just print a message.
1324 		 */
1325 		isp_prt(isp, ISP_LOGWARN, "CTIO7 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1326 		break;
1327 
1328 	case CT7_REASSY_ERR:
1329 		isp_prt(isp, ISP_LOGWARN, "reassembly error");
1330 		break;
1331 
1332 	case CT7_SRR:
1333 		isp_prt(isp, ISP_LOGTDEBUG0, "SRR received");
1334 		break;
1335 
1336 	default:
1337 		isp_prt(isp, ISP_LOGERR, "Unknown CTIO7 status 0x%x", ct->ct_nphdl);
1338 		break;
1339 	}
1340 
1341 	if (xs == NULL) {
1342 		/*
1343 		 * There may be more than one CTIO for a data transfer,
1344 		 * or this may be a status CTIO we're not monitoring.
1345 		 *
1346 		 * The assumption is that they'll all be returned in the
1347 		 * order we got them.
1348 		 */
1349 		if (ct->ct_syshandle == 0) {
1350 			if (ct->ct_flags & CT7_TERMINATE) {
1351 				isp_prt(isp, ISP_LOGINFO, "termination of [RX_ID 0x%x] complete", ct->ct_rxid);
1352 			} else if ((ct->ct_flags & CT7_SENDSTATUS) == 0) {
1353 				isp_prt(isp, pl, "intermediate CTIO completed ok");
1354 			} else {
1355 				isp_prt(isp, pl, "unmonitored CTIO completed ok");
1356 			}
1357 		} else {
1358 			isp_prt(isp, pl, "NO xs for CTIO (handle 0x%x) status 0x%x", ct->ct_syshandle, ct->ct_nphdl);
1359 		}
1360 	} else {
1361 		if ((ct->ct_flags & CT7_DATAMASK) != CT7_NO_DATA) {
1362 			ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1363 		}
1364 		if (ct->ct_flags & CT7_SENDSTATUS) {
1365 			/*
1366 			 * Sent status and command complete.
1367 			 *
1368 			 * We're now really done with this command, so we
1369 			 * punt to the platform dependent layers because
1370 			 * only there can we do the appropriate command
1371 			 * complete thread synchronization.
1372 			 */
1373 			isp_prt(isp, pl, "status CTIO complete");
1374 		} else {
1375 			/*
1376 			 * Final CTIO completed. Release DMA resources and
1377 			 * notify platform dependent layers.
1378 			 */
1379 			isp_prt(isp, pl, "data CTIO complete");
1380 		}
1381 		isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1382 		/*
1383 		 * The platform layer will destroy the handle if appropriate.
1384 		 */
1385 	}
1386 }
1387 
1388 static void
1389 isp_handle_24xx_inotify(ispsoftc_t *isp, in_fcentry_24xx_t *inot_24xx)
1390 {
1391 	uint8_t ochan, chan, lochan, hichan;
1392 
1393 	/*
1394 	 * Check to see whether we got a wildcard channel.
1395 	 * If so, we have to iterate over all channels.
1396 	 */
1397 	ochan = chan = ISP_GET_VPIDX(isp, inot_24xx->in_vpidx);
1398 	if (chan == 0xff) {
1399 		lochan = 0;
1400 		hichan = isp->isp_nchan;
1401 	} else {
1402 		if (chan >= isp->isp_nchan) {
1403 			char buf[64];
1404 			ISP_SNPRINTF(buf, sizeof buf, "%s: bad channel %d for status 0x%x", __func__, chan, inot_24xx->in_status);
1405 			isp_print_bytes(isp, buf, QENTRY_LEN, inot_24xx);
1406 			isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot_24xx);
1407 			return;
1408 		}
1409 		lochan = chan;
1410 		hichan = chan + 1;
1411 	}
1412 	isp_prt(isp, ISP_LOGTDEBUG1, "%s: Immediate Notify Channels %d..%d status=0x%x seqid=0x%x", __func__, lochan, hichan-1, inot_24xx->in_status, inot_24xx->in_rxid);
1413 	for (chan = lochan; chan < hichan; chan++) {
1414 		if (FCPARAM(isp, chan)->role == ISP_ROLE_NONE)
1415 			continue;
1416 		switch (inot_24xx->in_status) {
1417 		case IN24XX_LIP_RESET:
1418 		case IN24XX_LINK_RESET:
1419 		case IN24XX_PORT_LOGOUT:
1420 		case IN24XX_PORT_CHANGED:
1421 		case IN24XX_LINK_FAILED:
1422 		case IN24XX_SRR_RCVD:
1423 		case IN24XX_ELS_RCVD:
1424 			inot_24xx->in_reserved = 0;	/* clear this for later usage */
1425 			inot_24xx->in_vpidx = chan;
1426 			isp_async(isp, ISPASYNC_TARGET_ACTION, inot_24xx);
1427 			break;
1428 		default:
1429 			isp_prt(isp, ISP_LOGINFO, "%s: unhandled status (0x%x) for chan %d", __func__, inot_24xx->in_status, chan);
1430 			isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot_24xx);
1431 			break;
1432 		}
1433 	}
1434 	inot_24xx->in_vpidx = ochan;
1435 }
1436 #endif
1437