![[BACK]](/icons/back.gif){kind=icon}
Return to isp_target.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / ic|
Return to isp_target.c CVS log | Up to [local] / sys / dev / ic |
1.1 nbrk 1: /* $OpenBSD: isp_target.c,v 1.14 2007/02/14 00:53:48 jsg Exp $ */
2: /*
3: * Machine and OS Independent Target Mode Code for the Qlogic SCSI/FC adapters.
4: *
5: * Copyright (c) 1999, 2000, 2001 by Matthew Jacob
6: * All rights reserved.
7: * mjacob@feral.com
8: *
9: * Redistribution and use in source and binary forms, with or without
10: * modification, are permitted provided that the following conditions
11: * are met:
12: * 1. Redistributions of source code must retain the above copyright
13: * notice immediately at the beginning of the file, without modification,
14: * this list of conditions, and the following disclaimer.
15: * 2. The name of the author may not be used to endorse or promote products
16: * derived from this software without specific prior written permission.
17: *
18: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
22: * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28: * SUCH DAMAGE.
29: */
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 <dev/isp/isp_freebsd.h>
44: #endif
45: #ifdef __OpenBSD__
46: #include <dev/ic/isp_openbsd.h>
47: #endif
48: #ifdef __linux__
49: #include "isp_linux.h"
50: #endif
51:
52: #ifdef ISP_TARGET_MODE
53: static const char atiocope[] =
54: "ATIO returned for lun %d because it was in the middle of Bus Device Reset "
55: "on bus %d";
56: static const char atior[] =
57: "ATIO returned on for lun %d on from IID %d because a Bus Reset occurred "
58: "on bus %d";
59:
60: static void isp_got_msg(struct ispsoftc *, int, in_entry_t *);
61: static void isp_got_msg_fc(struct ispsoftc *, int, in_fcentry_t *);
62: static void isp_notify_ack(struct ispsoftc *, void *);
63: static void isp_handle_atio(struct ispsoftc *, at_entry_t *);
64: static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *);
65: static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *);
66: static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
67:
68: /*
69: * The Qlogic driver gets an interrupt to look at response queue entries.
70: * Some of these are status completions for initiatior mode commands, but
71: * if target mode is enabled, we get a whole wad of response queue entries
72: * to be handled here.
73: *
74: * Basically the split into 3 main groups: Lun Enable/Modification responses,
75: * SCSI Command processing, and Immediate Notification events.
76: *
77: * You start by writing a request queue entry to enable target mode (and
78: * establish some resource limitations which you can modify later).
79: * The f/w responds with a LUN ENABLE or LUN MODIFY response with
80: * the status of this action. If the enable was successful, you can expect...
81: *
82: * Response queue entries with SCSI commands encapsulate show up in an ATIO
83: * (Accept Target IO) type- sometimes with enough info to stop the command at
84: * this level. Ultimately the driver has to feed back to the f/w's request
85: * queue a sequence of CTIOs (continue target I/O) that describe data to
86: * be moved and/or status to be sent) and finally finishing with sending
87: * to the f/w's response queue an ATIO which then completes the handshake
88: * with the f/w for that command. There's a lot of variations on this theme,
89: * including flags you can set in the CTIO for the Qlogic 2X00 fibre channel
90: * cards that 'auto-replenish' the f/w's ATIO count, but this is the basic
91: * gist of it.
92: *
93: * The third group that can show up in the response queue are Immediate
94: * Notification events. These include things like notifications of SCSI bus
95: * resets, or Bus Device Reset messages or other messages received. This
96: * a classic oddbins area. It can get a little weird because you then turn
97: * around and acknowledge the Immediate Notify by writing an entry onto the
98: * request queue and then the f/w turns around and gives you an acknowledgement
99: * to *your* acknowledgement on the response queue (the idea being to let
100: * the f/w tell you when the event is *really* over I guess).
101: *
102: */
103:
104:
105: /*
106: * A new response queue entry has arrived. The interrupt service code
107: * has already swizzled it into the platform dependent from canonical form.
108: *
109: * Because of the way this driver is designed, unfortunately most of the
110: * actual synchronization work has to be done in the platform-specific
111: * code - we have no synchronization primitives in the common code.
112: */
113:
114: int
115: isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
116: {
117: u_int16_t status, seqid;
118: union {
119: at_entry_t *atiop;
120: at2_entry_t *at2iop;
121: ct_entry_t *ctiop;
122: ct2_entry_t *ct2iop;
123: lun_entry_t *lunenp;
124: in_entry_t *inotp;
125: in_fcentry_t *inot_fcp;
126: na_entry_t *nackp;
127: na_fcentry_t *nack_fcp;
128: isphdr_t *hp;
129: void * *vp;
130: #define atiop unp.atiop
131: #define at2iop unp.at2iop
132: #define ctiop unp.ctiop
133: #define ct2iop unp.ct2iop
134: #define lunenp unp.lunenp
135: #define inotp unp.inotp
136: #define inot_fcp unp.inot_fcp
137: #define nackp unp.nackp
138: #define nack_fcp unp.nack_fcp
139: #define hdrp unp.hp
140: } unp;
141: u_int8_t local[QENTRY_LEN];
142: int bus, type, rval = 1;
143:
144: type = isp_get_response_type(isp, (isphdr_t *)vptr);
145: unp.vp = vptr;
146:
147: ISP_TDQE(isp, "isp_target_notify", (int) *optrp, vptr);
148:
149: switch(type) {
150: case RQSTYPE_ATIO:
151: isp_get_atio(isp, atiop, (at_entry_t *) local);
152: isp_handle_atio(isp, (at_entry_t *) local);
153: break;
154: case RQSTYPE_CTIO:
155: isp_get_ctio(isp, ctiop, (ct_entry_t *) local);
156: isp_handle_ctio(isp, (ct_entry_t *) local);
157: break;
158: case RQSTYPE_ATIO2:
159: isp_get_atio2(isp, at2iop, (at2_entry_t *) local);
160: isp_handle_atio2(isp, (at2_entry_t *) local);
161: break;
162: case RQSTYPE_CTIO2:
163: isp_get_ctio2(isp, ct2iop, (ct2_entry_t *) local);
164: isp_handle_ctio2(isp, (ct2_entry_t *) local);
165: break;
166: case RQSTYPE_ENABLE_LUN:
167: case RQSTYPE_MODIFY_LUN:
168: isp_get_enable_lun(isp, lunenp, (lun_entry_t *) local);
169: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, local);
170: break;
171:
172: case RQSTYPE_NOTIFY:
173: /*
174: * Either the ISP received a SCSI message it can't
175: * handle, or it's returning an Immed. Notify entry
176: * we sent. We can send Immed. Notify entries to
177: * increment the firmware's resource count for them
178: * (we set this initially in the Enable Lun entry).
179: */
180: bus = 0;
181: if (IS_FC(isp)) {
182: isp_get_notify_fc(isp, inot_fcp, (in_fcentry_t *)local);
183: inot_fcp = (in_fcentry_t *) local;
184: status = inot_fcp->in_status;
185: seqid = inot_fcp->in_seqid;
186: } else {
187: isp_get_notify(isp, inotp, (in_entry_t *)local);
188: inotp = (in_entry_t *) local;
189: status = inotp->in_status & 0xff;
190: seqid = inotp->in_seqid;
191: if (IS_DUALBUS(isp)) {
192: bus = GET_BUS_VAL(inotp->in_iid);
193: SET_BUS_VAL(inotp->in_iid, 0);
194: }
195: }
196: isp_prt(isp, ISP_LOGTDEBUG0,
197: "Immediate Notify On Bus %d, status=0x%x seqid=0x%x",
198: bus, status, seqid);
199:
200: /*
201: * ACK it right away.
202: */
203: isp_notify_ack(isp, (status == IN_RESET)? NULL : local);
204: switch (status) {
205: case IN_RESET:
206: (void) isp_async(isp, ISPASYNC_BUS_RESET, &bus);
207: break;
208: case IN_MSG_RECEIVED:
209: case IN_IDE_RECEIVED:
210: if (IS_FC(isp)) {
211: isp_got_msg_fc(isp, bus, (in_fcentry_t *)local);
212: } else {
213: isp_got_msg(isp, bus, (in_entry_t *)local);
214: }
215: break;
216: case IN_RSRC_UNAVAIL:
217: isp_prt(isp, ISP_LOGWARN, "Firmware out of ATIOs");
218: break;
219: case IN_PORT_LOGOUT:
220: case IN_ABORT_TASK:
221: case IN_PORT_CHANGED:
222: case IN_GLOBAL_LOGO:
223: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, &local);
224: break;
225: default:
226: isp_prt(isp, ISP_LOGERR,
227: "bad status (0x%x) in isp_target_notify", status);
228: break;
229: }
230: break;
231:
232: case RQSTYPE_NOTIFY_ACK:
233: /*
234: * The ISP is acknowledging our acknowledgement of an
235: * Immediate Notify entry for some asynchronous event.
236: */
237: if (IS_FC(isp)) {
238: isp_get_notify_ack_fc(isp, nack_fcp,
239: (na_fcentry_t *)local);
240: nack_fcp = (na_fcentry_t *)local;
241: isp_prt(isp, ISP_LOGTDEBUG1,
242: "Notify Ack status=0x%x seqid 0x%x",
243: nack_fcp->na_status, nack_fcp->na_seqid);
244: } else {
245: isp_get_notify_ack(isp, nackp, (na_entry_t *)local);
246: nackp = (na_entry_t *)local;
247: isp_prt(isp, ISP_LOGTDEBUG1,
248: "Notify Ack event 0x%x status=0x%x seqid 0x%x",
249: nackp->na_event, nackp->na_status, nackp->na_seqid);
250: }
251: break;
252: default:
253: isp_prt(isp, ISP_LOGERR,
254: "Unknown entry type 0x%x in isp_target_notify", type);
255: rval = 0;
256: break;
257: }
258: #undef atiop
259: #undef at2iop
260: #undef ctiop
261: #undef ct2iop
262: #undef lunenp
263: #undef inotp
264: #undef inot_fcp
265: #undef nackp
266: #undef nack_fcp
267: #undef hdrp
268: return (rval);
269: }
270:
271:
272: /*
273: * Toggle (on/off) target mode for bus/target/lun
274: *
275: * The caller has checked for overlap and legality.
276: *
277: * Note that not all of bus, target or lun can be paid attention to.
278: * Note also that this action will not be complete until the f/w writes
279: * response entry. The caller is responsible for synchronizing this.
280: */
281: int
282: isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
283: int cmd_cnt, int inot_cnt, u_int32_t opaque)
284: {
285: lun_entry_t el;
286: u_int16_t nxti, optr;
287: void *outp;
288:
289:
290: MEMZERO(&el, sizeof (el));
291: if (IS_DUALBUS(isp)) {
292: el.le_rsvd = (bus & 0x1) << 7;
293: }
294: el.le_cmd_count = cmd_cnt;
295: el.le_in_count = inot_cnt;
296: if (cmd == RQSTYPE_ENABLE_LUN) {
297: if (IS_SCSI(isp)) {
298: el.le_flags = LUN_TQAE|LUN_DISAD;
299: el.le_cdb6len = 12;
300: el.le_cdb7len = 12;
301: }
302: } else if (cmd == -RQSTYPE_ENABLE_LUN) {
303: cmd = RQSTYPE_ENABLE_LUN;
304: el.le_cmd_count = 0;
305: el.le_in_count = 0;
306: } else if (cmd == -RQSTYPE_MODIFY_LUN) {
307: cmd = RQSTYPE_MODIFY_LUN;
308: el.le_ops = LUN_CCDECR | LUN_INDECR;
309: } else {
310: el.le_ops = LUN_CCINCR | LUN_ININCR;
311: }
312: el.le_header.rqs_entry_type = cmd;
313: el.le_header.rqs_entry_count = 1;
314: el.le_reserved = opaque;
315: if (IS_SCSI(isp)) {
316: el.le_tgt = tgt;
317: el.le_lun = lun;
318: } else if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
319: el.le_lun = lun;
320: }
321: el.le_timeout = 2;
322:
323: if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
324: isp_prt(isp, ISP_LOGERR,
325: "Request Queue Overflow in isp_lun_cmd");
326: return (-1);
327: }
328: ISP_TDQE(isp, "isp_lun_cmd", (int) optr, &el);
329: isp_put_enable_lun(isp, &el, outp);
330: ISP_ADD_REQUEST(isp, nxti);
331: return (0);
332: }
333:
334:
335: int
336: isp_target_put_entry(struct ispsoftc *isp, void *ap)
337: {
338: void *outp;
339: u_int16_t nxti, optr;
340: u_int8_t etype = ((isphdr_t *) ap)->rqs_entry_type;
341:
342: if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
343: isp_prt(isp, ISP_LOGWARN,
344: "Request Queue Overflow in isp_target_put_entry");
345: return (-1);
346: }
347: switch (etype) {
348: case RQSTYPE_ATIO:
349: isp_put_atio(isp, (at_entry_t *) ap, (at_entry_t *) outp);
350: break;
351: case RQSTYPE_ATIO2:
352: isp_put_atio2(isp, (at2_entry_t *) ap, (at2_entry_t *) outp);
353: break;
354: case RQSTYPE_CTIO:
355: isp_put_ctio(isp, (ct_entry_t *) ap, (ct_entry_t *) outp);
356: break;
357: case RQSTYPE_CTIO2:
358: isp_put_ctio2(isp, (ct2_entry_t *) ap, (ct2_entry_t *) outp);
359: break;
360: default:
361: isp_prt(isp, ISP_LOGERR,
362: "Unknown type 0x%x in isp_put_entry", etype);
363: return (-1);
364: }
365:
366: ISP_TDQE(isp, "isp_target_put_entry", (int) optr, ap);
367: ISP_ADD_REQUEST(isp, nxti);
368: return (0);
369: }
370:
371: int
372: isp_target_put_atio(struct ispsoftc *isp, void *arg)
373: {
374: union {
375: at_entry_t _atio;
376: at2_entry_t _atio2;
377: } atun;
378:
379: MEMZERO(&atun, sizeof atun);
380: if (IS_FC(isp)) {
381: at2_entry_t *aep = arg;
382: atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2;
383: atun._atio2.at_header.rqs_entry_count = 1;
384: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
385: atun._atio2.at_scclun = (u_int16_t) aep->at_scclun;
386: } else {
387: atun._atio2.at_lun = (u_int8_t) aep->at_lun;
388: }
389: atun._atio2.at_iid = aep->at_iid;
390: atun._atio2.at_rxid = aep->at_rxid;
391: atun._atio2.at_status = CT_OK;
392: } else {
393: at_entry_t *aep = arg;
394: atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO;
395: atun._atio.at_header.rqs_entry_count = 1;
396: atun._atio.at_handle = aep->at_handle;
397: atun._atio.at_iid = aep->at_iid;
398: atun._atio.at_tgt = aep->at_tgt;
399: atun._atio.at_lun = aep->at_lun;
400: atun._atio.at_tag_type = aep->at_tag_type;
401: atun._atio.at_tag_val = aep->at_tag_val;
402: atun._atio.at_status = (aep->at_flags & AT_TQAE);
403: atun._atio.at_status |= CT_OK;
404: }
405: return (isp_target_put_entry(isp, &atun));
406: }
407:
408: /*
409: * Command completion- both for handling cases of no resources or
410: * no blackhole driver, or other cases where we have to, inline,
411: * finish the command sanely, or for normal command completion.
412: *
413: * The 'completion' code value has the scsi status byte in the low 8 bits.
414: * If status is a CHECK CONDITION and bit 8 is nonzero, then bits 12..15 have
415: * the sense key and bits 16..23 have the ASCQ and bits 24..31 have the ASC
416: * values.
417: *
418: * NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't
419: * NB: inline SCSI sense reporting. As such, we lose this information. XXX.
420: *
421: * For both parallel && fibre channel, we use the feature that does
422: * an automatic resource autoreplenish so we don't have then later do
423: * put of an atio to replenish the f/w's resource count.
424: */
425:
426: int
427: isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
428: {
429: int sts;
430: union {
431: ct_entry_t _ctio;
432: ct2_entry_t _ctio2;
433: } un;
434:
435: MEMZERO(&un, sizeof un);
436: sts = code & 0xff;
437:
438: if (IS_FC(isp)) {
439: at2_entry_t *aep = arg;
440: ct2_entry_t *cto = &un._ctio2;
441:
442: cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
443: cto->ct_header.rqs_entry_count = 1;
444: cto->ct_iid = aep->at_iid;
445: if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
446: cto->ct_lun = aep->at_lun;
447: }
448: cto->ct_rxid = aep->at_rxid;
449: cto->rsp.m1.ct_scsi_status = sts & 0xff;
450: cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
451: if (hdl == 0) {
452: cto->ct_flags |= CT2_CCINCR;
453: }
454: if (aep->at_datalen) {
455: cto->ct_resid = aep->at_datalen;
456: cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
457: }
458: if ((sts & 0xff) == SCSI_CHECK && (sts & ECMD_SVALID)) {
459: cto->rsp.m1.ct_resp[0] = 0xf0;
460: cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
461: cto->rsp.m1.ct_resp[7] = 8;
462: cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
463: cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
464: cto->rsp.m1.ct_senselen = 16;
465: cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
466: }
467: cto->ct_syshandle = hdl;
468: } else {
469: at_entry_t *aep = arg;
470: ct_entry_t *cto = &un._ctio;
471:
472: cto->ct_header.rqs_entry_type = RQSTYPE_CTIO;
473: cto->ct_header.rqs_entry_count = 1;
474: cto->ct_fwhandle = aep->at_handle;
475: cto->ct_iid = aep->at_iid;
476: cto->ct_tgt = aep->at_tgt;
477: cto->ct_lun = aep->at_lun;
478: cto->ct_tag_type = aep->at_tag_type;
479: cto->ct_tag_val = aep->at_tag_val;
480: if (aep->at_flags & AT_TQAE) {
481: cto->ct_flags |= CT_TQAE;
482: }
483: cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA;
484: if (hdl == 0) {
485: cto->ct_flags |= CT_CCINCR;
486: }
487: cto->ct_scsi_status = sts;
488: cto->ct_syshandle = hdl;
489: }
490: return (isp_target_put_entry(isp, &un));
491: }
492:
493: int
494: isp_target_async(struct ispsoftc *isp, int bus, int event)
495: {
496: tmd_event_t evt;
497: tmd_msg_t msg;
498:
499: switch (event) {
500: /*
501: * These three we handle here to propagate an effective bus reset
502: * upstream, but these do not require any immediate notify actions
503: * so we return when done.
504: */
505: case ASYNC_LIP_F8:
506: case ASYNC_LIP_OCCURRED:
507: case ASYNC_LOOP_UP:
508: case ASYNC_LOOP_DOWN:
509: case ASYNC_LOOP_RESET:
510: case ASYNC_PTPMODE:
511: /*
512: * These don't require any immediate notify actions. We used
513: * treat them like SCSI Bus Resets, but that was just plain
514: * wrong. Let the normal CTIO completion report what occurred.
515: */
516: return (0);
517:
518: case ASYNC_BUS_RESET:
519: case ASYNC_TIMEOUT_RESET:
520: if (IS_FC(isp)) {
521: return (0); /* we'll be getting an inotify instead */
522: }
523: evt.ev_bus = bus;
524: evt.ev_event = event;
525: (void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt);
526: break;
527: case ASYNC_DEVICE_RESET:
528: /*
529: * Bus Device Reset resets a specific target, so
530: * we pass this as a synthesized message.
531: */
532: MEMZERO(&msg, sizeof msg);
533: if (IS_FC(isp)) {
534: msg.nt_iid = FCPARAM(isp)->isp_loopid;
535: } else {
536: msg.nt_iid = SDPARAM(isp)->isp_initiator_id;
537: }
538: msg.nt_bus = bus;
539: msg.nt_msg[0] = MSG_BUS_DEV_RESET;
540: (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
541: break;
542: default:
543: isp_prt(isp, ISP_LOGERR,
544: "isp_target_async: unknown event 0x%x", event);
545: break;
546: }
547: if (isp->isp_state == ISP_RUNSTATE)
548: isp_notify_ack(isp, NULL);
549: return(0);
550: }
551:
552:
553: /*
554: * Process a received message.
555: * The ISP firmware can handle most messages, there are only
556: * a few that we need to deal with:
557: * - abort: clean up the current command
558: * - abort tag and clear queue
559: */
560:
561: static void
562: isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
563: {
564: u_int8_t status = inp->in_status & ~QLTM_SVALID;
565:
566: if (status == IN_IDE_RECEIVED || status == IN_MSG_RECEIVED) {
567: tmd_msg_t msg;
568:
569: MEMZERO(&msg, sizeof (msg));
570: msg.nt_bus = bus;
571: msg.nt_iid = inp->in_iid;
572: msg.nt_tgt = inp->in_tgt;
573: msg.nt_lun = inp->in_lun;
574: msg.nt_tagtype = inp->in_tag_type;
575: msg.nt_tagval = inp->in_tag_val;
576: MEMCPY(msg.nt_msg, inp->in_msg, IN_MSGLEN);
577: (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
578: } else {
579: isp_prt(isp, ISP_LOGERR,
580: "unknown immediate notify status 0x%x", inp->in_status);
581: }
582: }
583:
584: /*
585: * Synthesize a message from the task management flags in a FCP_CMND_IU.
586: */
587: static void
588: isp_got_msg_fc(struct ispsoftc *isp, int bus, in_fcentry_t *inp)
589: {
590: int lun;
591: static const char f1[] = "%s from iid %d lun %d seq 0x%x";
592: static const char f2[] =
593: "unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n";
594:
595: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
596: lun = inp->in_scclun;
597: } else {
598: lun = inp->in_lun;
599: }
600:
601: if (inp->in_status != IN_MSG_RECEIVED) {
602: isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status",
603: inp->in_status, lun, inp->in_iid,
604: inp->in_task_flags, inp->in_seqid);
605: } else {
606: tmd_msg_t msg;
607:
608: MEMZERO(&msg, sizeof (msg));
609: msg.nt_bus = bus;
610: msg.nt_iid = inp->in_iid;
611: msg.nt_tagval = inp->in_seqid;
612: msg.nt_lun = lun;
613:
614: if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK) {
615: isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK",
616: inp->in_iid, lun, inp->in_seqid);
617: msg.nt_msg[0] = MSG_ABORT_TAG;
618: } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
619: isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
620: inp->in_iid, lun, inp->in_seqid);
621: msg.nt_msg[0] = MSG_CLEAR_QUEUE;
622: } else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
623: isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
624: inp->in_iid, lun, inp->in_seqid);
625: msg.nt_msg[0] = MSG_BUS_DEV_RESET;
626: } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
627: isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
628: inp->in_iid, lun, inp->in_seqid);
629: /* ???? */
630: msg.nt_msg[0] = MSG_REL_RECOVERY;
631: } else if (inp->in_task_flags & TASK_FLAGS_TERMINATE_TASK) {
632: isp_prt(isp, ISP_LOGINFO, f1, "TERMINATE TASK",
633: inp->in_iid, lun, inp->in_seqid);
634: msg.nt_msg[0] = MSG_TERM_IO_PROC;
635: } else {
636: isp_prt(isp, ISP_LOGWARN, f2, "task flag",
637: inp->in_status, lun, inp->in_iid,
638: inp->in_task_flags, inp->in_seqid);
639: }
640: if (msg.nt_msg[0]) {
641: (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
642: }
643: }
644: }
645:
646: static void
647: isp_notify_ack(struct ispsoftc *isp, void *arg)
648: {
649: char storage[QENTRY_LEN];
650: u_int16_t nxti, optr;
651: void *outp;
652:
653: if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
654: isp_prt(isp, ISP_LOGWARN,
655: "Request Queue Overflow For isp_notify_ack");
656: return;
657: }
658:
659: MEMZERO(storage, QENTRY_LEN);
660:
661: if (IS_FC(isp)) {
662: na_fcentry_t *na = (na_fcentry_t *) storage;
663: if (arg) {
664: in_fcentry_t *inp = arg;
665: MEMCPY(storage, arg, sizeof (isphdr_t));
666: na->na_iid = inp->in_iid;
667: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
668: na->na_lun = inp->in_scclun;
669: } else {
670: na->na_lun = inp->in_lun;
671: }
672: na->na_task_flags = inp->in_task_flags;
673: na->na_seqid = inp->in_seqid;
674: na->na_flags = NAFC_RCOUNT;
675: na->na_status = inp->in_status;
676: if (inp->in_status == IN_RESET) {
677: na->na_flags |= NAFC_RST_CLRD;
678: }
679: } else {
680: na->na_flags = NAFC_RST_CLRD;
681: }
682: na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
683: na->na_header.rqs_entry_count = 1;
684: isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
685: } else {
686: na_entry_t *na = (na_entry_t *) storage;
687: if (arg) {
688: in_entry_t *inp = arg;
689: MEMCPY(storage, arg, sizeof (isphdr_t));
690: na->na_iid = inp->in_iid;
691: na->na_lun = inp->in_lun;
692: na->na_tgt = inp->in_tgt;
693: na->na_seqid = inp->in_seqid;
694: if (inp->in_status == IN_RESET) {
695: na->na_event = NA_RST_CLRD;
696: }
697: } else {
698: na->na_event = NA_RST_CLRD;
699: }
700: na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
701: na->na_header.rqs_entry_count = 1;
702: isp_put_notify_ack(isp, na, (na_entry_t *)outp);
703: }
704: ISP_TDQE(isp, "isp_notify_ack", (int) optr, storage);
705: ISP_ADD_REQUEST(isp, nxti);
706: }
707:
708: static void
709: isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
710: {
711: int lun;
712: lun = aep->at_lun;
713: /*
714: * The firmware status (except for the QLTM_SVALID bit) indicates
715: * why this ATIO was sent to us.
716: *
717: * If QLTM_SVALID is set, the firmware has recommended Sense Data.
718: *
719: * If the DISCONNECTS DISABLED bit is set in the flags field,
720: * we're still connected on the SCSI bus - i.e. the initiator
721: * did not set DiscPriv in the identify message. We don't care
722: * about this so it's ignored.
723: */
724:
725: switch(aep->at_status & ~QLTM_SVALID) {
726: case AT_PATH_INVALID:
727: /*
728: * ATIO rejected by the firmware due to disabled lun.
729: */
730: isp_prt(isp, ISP_LOGERR,
731: "rejected ATIO for disabled lun %d", lun);
732: break;
733: case AT_NOCAP:
734: /*
735: * Requested Capability not available
736: * We sent an ATIO that overflowed the firmware's
737: * command resource count.
738: */
739: isp_prt(isp, ISP_LOGERR,
740: "rejected ATIO for lun %d because of command count"
741: " overflow", lun);
742: break;
743:
744: case AT_BDR_MSG:
745: /*
746: * If we send an ATIO to the firmware to increment
747: * its command resource count, and the firmware is
748: * recovering from a Bus Device Reset, it returns
749: * the ATIO with this status. We set the command
750: * resource count in the Enable Lun entry and do
751: * not increment it. Therefore we should never get
752: * this status here.
753: */
754: isp_prt(isp, ISP_LOGERR, atiocope, lun,
755: GET_BUS_VAL(aep->at_iid));
756: break;
757:
758: case AT_CDB: /* Got a CDB */
759: case AT_PHASE_ERROR: /* Bus Phase Sequence Error */
760: /*
761: * Punt to platform specific layer.
762: */
763: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
764: break;
765:
766: case AT_RESET:
767: /*
768: * A bus reset came along and blew away this command. Why
769: * they do this in addition the async event code stuff,
770: * I dunno.
771: *
772: * Ignore it because the async event will clear things
773: * up for us.
774: */
775: isp_prt(isp, ISP_LOGWARN, atior, lun,
776: GET_IID_VAL(aep->at_iid), GET_BUS_VAL(aep->at_iid));
777: break;
778:
779:
780: default:
781: isp_prt(isp, ISP_LOGERR,
782: "Unknown ATIO status 0x%x from initiator %d for lun %d",
783: aep->at_status, aep->at_iid, lun);
784: (void) isp_target_put_atio(isp, aep);
785: break;
786: }
787: }
788:
789: static void
790: isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
791: {
792: int lun;
793:
794: if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
795: lun = aep->at_scclun;
796: } else {
797: lun = aep->at_lun;
798: }
799:
800: /*
801: * The firmware status (except for the QLTM_SVALID bit) indicates
802: * why this ATIO was sent to us.
803: *
804: * If QLTM_SVALID is set, the firmware has recommended Sense Data.
805: *
806: * If the DISCONNECTS DISABLED bit is set in the flags field,
807: * we're still connected on the SCSI bus - i.e. the initiator
808: * did not set DiscPriv in the identify message. We don't care
809: * about this so it's ignored.
810: */
811:
812: switch(aep->at_status & ~QLTM_SVALID) {
813: case AT_PATH_INVALID:
814: /*
815: * ATIO rejected by the firmware due to disabled lun.
816: */
817: isp_prt(isp, ISP_LOGERR,
818: "rejected ATIO2 for disabled lun %d", lun);
819: break;
820: case AT_NOCAP:
821: /*
822: * Requested Capability not available
823: * We sent an ATIO that overflowed the firmware's
824: * command resource count.
825: */
826: isp_prt(isp, ISP_LOGERR,
827: "rejected ATIO2 for lun %d- command count overflow", lun);
828: break;
829:
830: case AT_BDR_MSG:
831: /*
832: * If we send an ATIO to the firmware to increment
833: * its command resource count, and the firmware is
834: * recovering from a Bus Device Reset, it returns
835: * the ATIO with this status. We set the command
836: * resource count in the Enable Lun entry and no
837: * not increment it. Therefore we should never get
838: * this status here.
839: */
840: isp_prt(isp, ISP_LOGERR, atiocope, lun, 0);
841: break;
842:
843: case AT_CDB: /* Got a CDB */
844: /*
845: * Punt to platform specific layer.
846: */
847: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
848: break;
849:
850: case AT_RESET:
851: /*
852: * A bus reset came along an blew away this command. Why
853: * they do this in addition the async event code stuff,
854: * I dunno.
855: *
856: * Ignore it because the async event will clear things
857: * up for us.
858: */
859: isp_prt(isp, ISP_LOGERR, atior, lun, aep->at_iid, 0);
860: break;
861:
862:
863: default:
864: isp_prt(isp, ISP_LOGERR,
865: "Unknown ATIO2 status 0x%x from initiator %d for lun %d",
866: aep->at_status, aep->at_iid, lun);
867: (void) isp_target_put_atio(isp, aep);
868: break;
869: }
870: }
871:
872: static void
873: isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
874: {
875: void *xs;
876: int pl = ISP_LOGTDEBUG2;
877: char *fmsg = NULL;
878:
879: if (ct->ct_syshandle) {
880: xs = isp_find_xs(isp, ct->ct_syshandle);
881: if (xs == NULL)
882: pl = ISP_LOGALL;
883: } else {
884: xs = NULL;
885: }
886:
887: switch(ct->ct_status & ~QLTM_SVALID) {
888: case CT_OK:
889: /*
890: * There are generally 3 possibilities as to why we'd get
891: * this condition:
892: * We disconnected after receiving a CDB.
893: * We sent or received data.
894: * We sent status & command complete.
895: */
896:
897: if (ct->ct_flags & CT_SENDSTATUS) {
898: break;
899: } else if ((ct->ct_flags & CT_DATAMASK) == CT_NO_DATA) {
900: /*
901: * Nothing to do in this case.
902: */
903: isp_prt(isp, pl, "CTIO- iid %d disconnected OK",
904: ct->ct_iid);
905: return;
906: }
907: break;
908:
909: case CT_BDR_MSG:
910: /*
911: * Bus Device Reset message received or the SCSI Bus has
912: * been Reset; the firmware has gone to Bus Free.
913: *
914: * The firmware generates an async mailbox interrupt to
915: * notify us of this and returns outstanding CTIOs with this
916: * status. These CTIOs are handled in that same way as
917: * CT_ABORTED ones, so just fall through here.
918: */
919: fmsg = "Bus Device Reset";
920: /*FALLTHROUGH*/
921: case CT_RESET:
922: if (fmsg == NULL)
923: fmsg = "Bus Reset";
924: /*FALLTHROUGH*/
925: case CT_ABORTED:
926: /*
927: * When an Abort message is received the firmware goes to
928: * Bus Free and returns all outstanding CTIOs with the status
929: * set, then sends us an Immediate Notify entry.
930: */
931: if (fmsg == NULL)
932: fmsg = "ABORT TAG message sent by Initiator";
933:
934: isp_prt(isp, ISP_LOGWARN, "CTIO destroyed by %s", fmsg);
935: break;
936:
937: case CT_INVAL:
938: /*
939: * CTIO rejected by the firmware due to disabled lun.
940: * "Cannot Happen".
941: */
942: isp_prt(isp, ISP_LOGERR,
943: "Firmware rejected CTIO for disabled lun %d",
944: ct->ct_lun);
945: break;
946:
947: case CT_NOPATH:
948: /*
949: * CTIO rejected by the firmware due "no path for the
950: * nondisconnecting nexus specified". This means that
951: * we tried to access the bus while a non-disconnecting
952: * command is in process.
953: */
954: isp_prt(isp, ISP_LOGERR,
955: "Firmware rejected CTIO for bad nexus %d/%d/%d",
956: ct->ct_iid, ct->ct_tgt, ct->ct_lun);
957: break;
958:
959: case CT_RSELTMO:
960: fmsg = "Reselection";
961: /*FALLTHROUGH*/
962: case CT_TIMEOUT:
963: if (fmsg == NULL)
964: fmsg = "Command";
965: isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
966: break;
967:
968: case CT_PANIC:
969: if (fmsg == NULL)
970: fmsg = "Unrecoverable Error";
971: /*FALLTHROUGH*/
972: case CT_ERR:
973: if (fmsg == NULL)
974: fmsg = "Completed with Error";
975: /*FALLTHROUGH*/
976: case CT_PHASE_ERROR:
977: if (fmsg == NULL)
978: fmsg = "Phase Sequence Error";
979: /*FALLTHROUGH*/
980: case CT_TERMINATED:
981: if (fmsg == NULL)
982: fmsg = "terminated by TERMINATE TRANSFER";
983: /*FALLTHROUGH*/
984: case CT_NOACK:
985: if (fmsg == NULL)
986: fmsg = "unacknowledged Immediate Notify pending";
987: isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
988: break;
989: default:
990: isp_prt(isp, ISP_LOGERR, "Unknown CTIO status 0x%x",
991: ct->ct_status & ~QLTM_SVALID);
992: break;
993: }
994:
995: if (xs == NULL) {
996: /*
997: * There may be more than one CTIO for a data transfer,
998: * or this may be a status CTIO we're not monitoring.
999: *
1000: * The assumption is that they'll all be returned in the
1001: * order we got them.
1002: */
1003: if (ct->ct_syshandle == 0) {
1004: if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
1005: isp_prt(isp, pl,
1006: "intermediate CTIO completed ok");
1007: } else {
1008: isp_prt(isp, pl,
1009: "unmonitored CTIO completed ok");
1010: }
1011: } else {
1012: isp_prt(isp, pl,
1013: "NO xs for CTIO (handle 0x%x) status 0x%x",
1014: ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1015: }
1016: } else {
1017: /*
1018: * Final CTIO completed. Release DMA resources and
1019: * notify platform dependent layers.
1020: */
1021: if ((ct->ct_flags & CT_DATAMASK) != CT_NO_DATA) {
1022: ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1023: }
1024: isp_prt(isp, pl, "final CTIO complete");
1025: /*
1026: * The platform layer will destroy the handle if appropriate.
1027: */
1028: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1029: }
1030: }
1031:
1032: static void
1033: isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
1034: {
1035: XS_T *xs;
1036: int pl = ISP_LOGTDEBUG2;
1037: char *fmsg = NULL;
1038:
1039: if (ct->ct_syshandle) {
1040: xs = isp_find_xs(isp, ct->ct_syshandle);
1041: if (xs == NULL)
1042: pl = ISP_LOGALL;
1043: } else {
1044: xs = NULL;
1045: }
1046:
1047: switch(ct->ct_status & ~QLTM_SVALID) {
1048: case CT_BUS_ERROR:
1049: isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1050: /* FALLTHROUGH */
1051: case CT_DATA_OVER:
1052: case CT_DATA_UNDER:
1053: case CT_OK:
1054: /*
1055: * There are generally 2 possibilities as to why we'd get
1056: * this condition:
1057: * We sent or received data.
1058: * We sent status & command complete.
1059: */
1060:
1061: break;
1062:
1063: case CT_BDR_MSG:
1064: /*
1065: * Target Reset function received.
1066: *
1067: * The firmware generates an async mailbox interrupt to
1068: * notify us of this and returns outstanding CTIOs with this
1069: * status. These CTIOs are handled in that same way as
1070: * CT_ABORTED ones, so just fall through here.
1071: */
1072: fmsg = "TARGET RESET Task Management Function Received";
1073: /*FALLTHROUGH*/
1074: case CT_RESET:
1075: if (fmsg == NULL)
1076: fmsg = "LIP Reset";
1077: /*FALLTHROUGH*/
1078: case CT_ABORTED:
1079: /*
1080: * When an Abort message is received the firmware goes to
1081: * Bus Free and returns all outstanding CTIOs with the status
1082: * set, then sends us an Immediate Notify entry.
1083: */
1084: if (fmsg == NULL)
1085: fmsg = "ABORT Task Management Function Received";
1086:
1087: isp_prt(isp, ISP_LOGERR, "CTIO2 destroyed by %s", fmsg);
1088: break;
1089:
1090: case CT_INVAL:
1091: /*
1092: * CTIO rejected by the firmware - invalid data direction.
1093: */
1094: isp_prt(isp, ISP_LOGERR, "CTIO2 had wrong data direction");
1095: break;
1096:
1097: case CT_RSELTMO:
1098: fmsg = "failure to reconnect to initiator";
1099: /*FALLTHROUGH*/
1100: case CT_TIMEOUT:
1101: if (fmsg == NULL)
1102: fmsg = "command";
1103: isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
1104: break;
1105:
1106: case CT_ERR:
1107: fmsg = "Completed with Error";
1108: /*FALLTHROUGH*/
1109: case CT_LOGOUT:
1110: if (fmsg == NULL)
1111: fmsg = "Port Logout";
1112: /*FALLTHROUGH*/
1113: case CT_PORTNOTAVAIL:
1114: if (fmsg == NULL)
1115: fmsg = "Port not available";
1116: case CT_PORTCHANGED:
1117: if (fmsg == NULL)
1118: fmsg = "Port Changed";
1119: case CT_NOACK:
1120: if (fmsg == NULL)
1121: fmsg = "unacknowledged Immediate Notify pending";
1122: isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
1123: break;
1124:
1125: case CT_INVRXID:
1126: /*
1127: * CTIO rejected by the firmware because an invalid RX_ID.
1128: * Just print a message.
1129: */
1130: isp_prt(isp, ISP_LOGERR,
1131: "CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1132: break;
1133:
1134: default:
1135: isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x",
1136: ct->ct_status & ~QLTM_SVALID);
1137: break;
1138: }
1139:
1140: if (xs == NULL) {
1141: /*
1142: * There may be more than one CTIO for a data transfer,
1143: * or this may be a status CTIO we're not monitoring.
1144: *
1145: * The assumption is that they'll all be returned in the
1146: * order we got them.
1147: */
1148: if (ct->ct_syshandle == 0) {
1149: if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
1150: isp_prt(isp, pl,
1151: "intermediate CTIO completed ok");
1152: } else {
1153: isp_prt(isp, pl,
1154: "unmonitored CTIO completed ok");
1155: }
1156: } else {
1157: isp_prt(isp, pl,
1158: "NO xs for CTIO (handle 0x%x) status 0x%x",
1159: ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1160: }
1161: } else {
1162: if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
1163: ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1164: }
1165: if (ct->ct_flags & CT_SENDSTATUS) {
1166: /*
1167: * Sent status and command complete.
1168: *
1169: * We're now really done with this command, so we
1170: * punt to the platform dependent layers because
1171: * only there can we do the appropriate command
1172: * complete thread synchronization.
1173: */
1174: isp_prt(isp, pl, "status CTIO complete");
1175: } else {
1176: /*
1177: * Final CTIO completed. Release DMA resources and
1178: * notify platform dependent layers.
1179: */
1180: isp_prt(isp, pl, "data CTIO complete");
1181: }
1182: (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1183: /*
1184: * The platform layer will destroy the handle if appropriate.
1185: */
1186: }
1187: }
1188: #endif