sys/dev/disk/isp/isp_target.c

   1 /* $FreeBSD: src/sys/dev/isp/isp_target.c,v 1.5.4.10 2002/07/29 04:25:59 mjacob 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 synchroniation 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_status = CT_OK;
 390         } else {
 391                 at_entry_t *aep = arg;
 392                 atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO;
 393                 atun._atio.at_header.rqs_entry_count = 1;
 394                 atun._atio.at_handle = aep->at_handle;
 395                 atun._atio.at_iid = aep->at_iid;
 396                 atun._atio.at_tgt = aep->at_tgt;
 397                 atun._atio.at_lun = aep->at_lun;
 398                 atun._atio.at_tag_type = aep->at_tag_type;
 399                 atun._atio.at_tag_val = aep->at_tag_val;
 400                 atun._atio.at_status = (aep->at_flags & AT_TQAE);
 401                 atun._atio.at_status |= CT_OK;
 402         }
 403         return (isp_target_put_entry(isp, &atun));
 404 }
 405
 406 /*
 407  * Command completion- both for handling cases of no resources or
 408  * no blackhole driver, or other cases where we have to, inline,
 409  * finish the command sanely, or for normal command completion.
 410  *
 411  * The 'completion' code value has the scsi status byte in the low 8 bits.
 412  * If status is a CHECK CONDITION and bit 8 is nonzero, then bits 12..15 have
 413  * the sense key and  bits 16..23 have the ASCQ and bits 24..31 have the ASC
 414  * values.
 415  *
 416  * NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't
 417  * NB: inline SCSI sense reporting. As such, we lose this information. XXX.
 418  *
 419  * For both parallel && fibre channel, we use the feature that does
 420  * an automatic resource autoreplenish so we don't have then later do
 421  * put of an atio to replenish the f/w's resource count.
 422  */
 423
 424 int
 425 isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
 426 {
 427         int sts;
 428         union {
 429                 ct_entry_t _ctio;
 430                 ct2_entry_t _ctio2;
 431         } un;
 432
 433         MEMZERO(&un, sizeof un);
 434         sts = code & 0xff;
 435
 436         if (IS_FC(isp)) {
 437                 at2_entry_t *aep = arg;
 438                 ct2_entry_t *cto = &un._ctio2;
 439
 440                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
 441                 cto->ct_header.rqs_entry_count = 1;
 442                 cto->ct_iid = aep->at_iid;
 443                 if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
 444                         cto->ct_lun = aep->at_lun;
 445                 }
 446                 cto->ct_rxid = aep->at_rxid;
 447                 cto->rsp.m1.ct_scsi_status = sts & 0xff;
 448                 cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
 449                 if (hdl == 0) {
 450                         cto->ct_flags |= CT2_CCINCR;
 451                 }
 452                 if (aep->at_datalen) {
 453                         cto->ct_resid = aep->at_datalen;
 454                         cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
 455                 }
 456                 if ((sts & 0xff) == SCSI_CHECK && (sts & ECMD_SVALID)) {
 457                         cto->rsp.m1.ct_resp[0] = 0xf0;
 458                         cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
 459                         cto->rsp.m1.ct_resp[7] = 8;
 460                         cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
 461                         cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
 462                         cto->rsp.m1.ct_senselen = 16;
 463                         cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
 464                 }
 465                 cto->ct_syshandle = hdl;
 466         } else {
 467                 at_entry_t *aep = arg;
 468                 ct_entry_t *cto = &un._ctio;
 469
 470                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO;
 471                 cto->ct_header.rqs_entry_count = 1;
 472                 cto->ct_fwhandle = aep->at_handle;
 473                 cto->ct_iid = aep->at_iid;
 474                 cto->ct_tgt = aep->at_tgt;
 475                 cto->ct_lun = aep->at_lun;
 476                 cto->ct_tag_type = aep->at_tag_type;
 477                 cto->ct_tag_val = aep->at_tag_val;
 478                 if (aep->at_flags & AT_TQAE) {
 479                         cto->ct_flags |= CT_TQAE;
 480                 }
 481                 cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA;
 482                 if (hdl == 0) {
 483                         cto->ct_flags |= CT_CCINCR;
 484                 }
 485                 cto->ct_scsi_status = sts;
 486                 cto->ct_syshandle = hdl;
 487         }
 488         return (isp_target_put_entry(isp, &un));
 489 }
 490
 491 int
 492 isp_target_async(struct ispsoftc *isp, int bus, int event)
 493 {
 494         tmd_event_t evt;
 495         tmd_msg_t msg;
 496
 497         switch (event) {
 498         /*
 499          * These three we handle here to propagate an effective bus reset
 500          * upstream, but these do not require any immediate notify actions
 501          * so we return when done.
 502          */
 503         case ASYNC_LIP_F8:
 504         case ASYNC_LIP_OCCURRED:
 505         case ASYNC_LOOP_UP:
 506         case ASYNC_LOOP_DOWN:
 507         case ASYNC_LOOP_RESET:
 508         case ASYNC_PTPMODE:
 509                 /*
 510                  * These don't require any immediate notify actions. We used
 511                  * treat them like SCSI Bus Resets, but that was just plain
 512                  * wrong. Let the normal CTIO completion report what occurred.
 513                  */
 514                 return (0);
 515
 516         case ASYNC_BUS_RESET:
 517         case ASYNC_TIMEOUT_RESET:
 518                 if (IS_FC(isp)) {
 519                         return (0); /* we'll be getting an inotify instead */
 520                 }
 521                 evt.ev_bus = bus;
 522                 evt.ev_event = event;
 523                 (void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt);
 524                 break;
 525         case ASYNC_DEVICE_RESET:
 526                 /*
 527                  * Bus Device Reset resets a specific target, so
 528                  * we pass this as a synthesized message.
 529                  */
 530                 MEMZERO(&msg, sizeof msg);
 531                 if (IS_FC(isp)) {
 532                         msg.nt_iid = FCPARAM(isp)->isp_loopid;
 533                 } else {
 534                         msg.nt_iid = SDPARAM(isp)->isp_initiator_id;
 535                 }
 536                 msg.nt_bus = bus;
 537                 msg.nt_msg[0] = MSG_BUS_DEV_RESET;
 538                 (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
 539                 break;
 540         default:
 541                 isp_prt(isp, ISP_LOGERR,
 542                     "isp_target_async: unknown event 0x%x", event);
 543                 break;
 544         }
 545         if (isp->isp_state == ISP_RUNSTATE)
 546                 isp_notify_ack(isp, NULL);
 547         return(0);
 548 }
 549
 550
 551 /*
 552  * Process a received message.
 553  * The ISP firmware can handle most messages, there are only
 554  * a few that we need to deal with:
 555  * - abort: clean up the current command
 556  * - abort tag and clear queue
 557  */
 558
 559 static void
 560 isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
 561 {
 562         u_int8_t status = inp->in_status & ~QLTM_SVALID;
 563
 564         if (status == IN_IDE_RECEIVED || status == IN_MSG_RECEIVED) {
 565                 tmd_msg_t msg;
 566
 567                 MEMZERO(&msg, sizeof (msg));
 568                 msg.nt_bus = bus;
 569                 msg.nt_iid = inp->in_iid;
 570                 msg.nt_tgt = inp->in_tgt;
 571                 msg.nt_lun = inp->in_lun;
 572                 msg.nt_tagtype = inp->in_tag_type;
 573                 msg.nt_tagval = inp->in_tag_val;
 574                 MEMCPY(msg.nt_msg, inp->in_msg, IN_MSGLEN);
 575                 (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
 576         } else {
 577                 isp_prt(isp, ISP_LOGERR,
 578                     "unknown immediate notify status 0x%x", inp->in_status);
 579         }
 580 }
 581
 582 /*
 583  * Synthesize a message from the task management flags in a FCP_CMND_IU.
 584  */
 585 static void
 586 isp_got_msg_fc(struct ispsoftc *isp, int bus, in_fcentry_t *inp)
 587 {
 588         int lun;
 589         static const char f1[] = "%s from iid %d lun %d seq 0x%x";
 590         static const char f2[] =
 591             "unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n";
 592
 593         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
 594                 lun = inp->in_scclun;
 595         } else {
 596                 lun = inp->in_lun;
 597         }
 598
 599         if (inp->in_status != IN_MSG_RECEIVED) {
 600                 isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status",
 601                     inp->in_status, lun, inp->in_iid,
 602                     inp->in_task_flags,  inp->in_seqid);
 603         } else {
 604                 tmd_msg_t msg;
 605
 606                 MEMZERO(&msg, sizeof (msg));
 607                 msg.nt_bus = bus;
 608                 msg.nt_iid = inp->in_iid;
 609                 msg.nt_tagval = inp->in_seqid;
 610                 msg.nt_lun = lun;
 611
 612                 if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK) {
 613                         isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK",
 614                             inp->in_iid, msg.nt_lun, inp->in_seqid);
 615                         msg.nt_msg[0] = MSG_ABORT_TAG;
 616                 } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
 617                         isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
 618                             inp->in_iid, msg.nt_lun, inp->in_seqid);
 619                         msg.nt_msg[0] = MSG_CLEAR_QUEUE;
 620                 } else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
 621                         isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
 622                             inp->in_iid, msg.nt_lun, inp->in_seqid);
 623                         msg.nt_msg[0] = MSG_BUS_DEV_RESET;
 624                 } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
 625                         isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
 626                             inp->in_iid, msg.nt_lun, inp->in_seqid);
 627                         /* ???? */
 628                         msg.nt_msg[0] = MSG_REL_RECOVERY;
 629                 } else if (inp->in_task_flags & TASK_FLAGS_TERMINATE_TASK) {
 630                         isp_prt(isp, ISP_LOGINFO, f1, "TERMINATE TASK",
 631                             inp->in_iid, msg.nt_lun, inp->in_seqid);
 632                         msg.nt_msg[0] = MSG_TERM_IO_PROC;
 633                 } else {
 634                         isp_prt(isp, ISP_LOGWARN, f2, "task flag",
 635                             inp->in_status, msg.nt_lun, inp->in_iid,
 636                             inp->in_task_flags,  inp->in_seqid);
 637                 }
 638                 if (msg.nt_msg[0]) {
 639                         (void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
 640                 }
 641         }
 642 }
 643
 644 static void
 645 isp_notify_ack(struct ispsoftc *isp, void *arg)
 646 {
 647         char storage[QENTRY_LEN];
 648         u_int16_t nxti, optr;
 649         void *outp;
 650
 651         if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
 652                 isp_prt(isp, ISP_LOGWARN,
 653                     "Request Queue Overflow For isp_notify_ack");
 654                 return;
 655         }
 656
 657         MEMZERO(storage, QENTRY_LEN);
 658
 659         if (IS_FC(isp)) {
 660                 na_fcentry_t *na = (na_fcentry_t *) storage;
 661                 if (arg) {
 662                         in_fcentry_t *inp = arg;
 663                         MEMCPY(storage, arg, sizeof (isphdr_t));
 664                         na->na_iid = inp->in_iid;
 665                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
 666                                 na->na_lun = inp->in_scclun;
 667                         } else {
 668                                 na->na_lun = inp->in_lun;
 669                         }
 670                         na->na_task_flags = inp->in_task_flags;
 671                         na->na_seqid = inp->in_seqid;
 672                         na->na_flags = NAFC_RCOUNT;
 673                         na->na_status = inp->in_status;
 674                         if (inp->in_status == IN_RESET) {
 675                                 na->na_flags |= NAFC_RST_CLRD;
 676                         }
 677                 } else {
 678                         na->na_flags = NAFC_RST_CLRD;
 679                 }
 680                 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 681                 na->na_header.rqs_entry_count = 1;
 682                 isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
 683         } else {
 684                 na_entry_t *na = (na_entry_t *) storage;
 685                 if (arg) {
 686                         in_entry_t *inp = arg;
 687                         MEMCPY(storage, arg, sizeof (isphdr_t));
 688                         na->na_iid = inp->in_iid;
 689                         na->na_lun = inp->in_lun;
 690                         na->na_tgt = inp->in_tgt;
 691                         na->na_seqid = inp->in_seqid;
 692                         if (inp->in_status == IN_RESET) {
 693                                 na->na_event = NA_RST_CLRD;
 694                         }
 695                 } else {
 696                         na->na_event = NA_RST_CLRD;
 697                 }
 698                 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 699                 na->na_header.rqs_entry_count = 1;
 700                 isp_put_notify_ack(isp, na, (na_entry_t *)outp);
 701         }
 702         ISP_TDQE(isp, "isp_notify_ack", (int) optr, storage);
 703         ISP_ADD_REQUEST(isp, nxti);
 704 }
 705
 706 static void
 707 isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
 708 {
 709         int lun;
 710         lun = aep->at_lun;
 711         /*
 712          * The firmware status (except for the QLTM_SVALID bit) indicates
 713          * why this ATIO was sent to us.
 714          *
 715          * If QLTM_SVALID is set, the firware has recommended Sense Data.
 716          *
 717          * If the DISCONNECTS DISABLED bit is set in the flags field,
 718          * we're still connected on the SCSI bus - i.e. the initiator
 719          * did not set DiscPriv in the identify message. We don't care
 720          * about this so it's ignored.
 721          */
 722
 723         switch(aep->at_status & ~QLTM_SVALID) {
 724         case AT_PATH_INVALID:
 725                 /*
 726                  * ATIO rejected by the firmware due to disabled lun.
 727                  */
 728                 isp_prt(isp, ISP_LOGERR,
 729                     "rejected ATIO for disabled lun %d", lun);
 730                 break;
 731         case AT_NOCAP:
 732                 /*
 733                  * Requested Capability not available
 734                  * We sent an ATIO that overflowed the firmware's
 735                  * command resource count.
 736                  */
 737                 isp_prt(isp, ISP_LOGERR,
 738                     "rejected ATIO for lun %d because of command count"
 739                     " overflow", lun);
 740                 break;
 741
 742         case AT_BDR_MSG:
 743                 /*
 744                  * If we send an ATIO to the firmware to increment
 745                  * its command resource count, and the firmware is
 746                  * recovering from a Bus Device Reset, it returns
 747                  * the ATIO with this status. We set the command
 748                  * resource count in the Enable Lun entry and do
 749                  * not increment it. Therefore we should never get
 750                  * this status here.
 751                  */
 752                 isp_prt(isp, ISP_LOGERR, atiocope, lun,
 753                     GET_BUS_VAL(aep->at_iid));
 754                 break;
 755
 756         case AT_CDB:            /* Got a CDB */
 757         case AT_PHASE_ERROR:    /* Bus Phase Sequence Error */
 758                 /*
 759                  * Punt to platform specific layer.
 760                  */
 761                 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
 762                 break;
 763
 764         case AT_RESET:
 765                 /*
 766                  * A bus reset came along an blew away this command. Why
 767                  * they do this in addition the async event code stuff,
 768                  * I dunno.
 769                  *
 770                  * Ignore it because the async event will clear things
 771                  * up for us.
 772                  */
 773                 isp_prt(isp, ISP_LOGWARN, atior, lun,
 774                     GET_IID_VAL(aep->at_iid), GET_BUS_VAL(aep->at_iid));
 775                 break;
 776
 777
 778         default:
 779                 isp_prt(isp, ISP_LOGERR,
 780                     "Unknown ATIO status 0x%x from initiator %d for lun %d",
 781                     aep->at_status, aep->at_iid, lun);
 782                 (void) isp_target_put_atio(isp, aep);
 783                 break;
 784         }
 785 }
 786
 787 static void
 788 isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
 789 {
 790         int lun;
 791
 792         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
 793                 lun = aep->at_scclun;
 794         } else {
 795                 lun = aep->at_lun;
 796         }
 797
 798         /*
 799          * The firmware status (except for the QLTM_SVALID bit) indicates
 800          * why this ATIO was sent to us.
 801          *
 802          * If QLTM_SVALID is set, the firware has recommended Sense Data.
 803          *
 804          * If the DISCONNECTS DISABLED bit is set in the flags field,
 805          * we're still connected on the SCSI bus - i.e. the initiator
 806          * did not set DiscPriv in the identify message. We don't care
 807          * about this so it's ignored.
 808          */
 809
 810         switch(aep->at_status & ~QLTM_SVALID) {
 811         case AT_PATH_INVALID:
 812                 /*
 813                  * ATIO rejected by the firmware due to disabled lun.
 814                  */
 815                 isp_prt(isp, ISP_LOGERR,
 816                     "rejected ATIO2 for disabled lun %d", lun);
 817                 break;
 818         case AT_NOCAP:
 819                 /*
 820                  * Requested Capability not available
 821                  * We sent an ATIO that overflowed the firmware's
 822                  * command resource count.
 823                  */
 824                 isp_prt(isp, ISP_LOGERR,
 825                     "rejected ATIO2 for lun %d- command count overflow", lun);
 826                 break;
 827
 828         case AT_BDR_MSG:
 829                 /*
 830                  * If we send an ATIO to the firmware to increment
 831                  * its command resource count, and the firmware is
 832                  * recovering from a Bus Device Reset, it returns
 833                  * the ATIO with this status. We set the command
 834                  * resource count in the Enable Lun entry and no
 835                  * not increment it. Therefore we should never get
 836                  * this status here.
 837                  */
 838                 isp_prt(isp, ISP_LOGERR, atiocope, lun, 0);
 839                 break;
 840
 841         case AT_CDB:            /* Got a CDB */
 842                 /*
 843                  * Punt to platform specific layer.
 844                  */
 845                 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
 846                 break;
 847
 848         case AT_RESET:
 849                 /*
 850                  * A bus reset came along an blew away this command. Why
 851                  * they do this in addition the async event code stuff,
 852                  * I dunno.
 853                  *
 854                  * Ignore it because the async event will clear things
 855                  * up for us.
 856                  */
 857                 isp_prt(isp, ISP_LOGERR, atior, lun, aep->at_iid, 0);
 858                 break;
 859
 860
 861         default:
 862                 isp_prt(isp, ISP_LOGERR,
 863                     "Unknown ATIO2 status 0x%x from initiator %d for lun %d",
 864                     aep->at_status, aep->at_iid, lun);
 865                 (void) isp_target_put_atio(isp, aep);
 866                 break;
 867         }
 868 }
 869
 870 static void
 871 isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
 872 {
 873         void *xs;
 874         int pl = ISP_LOGTDEBUG2;
 875         char *fmsg = NULL;
 876
 877         if (ct->ct_syshandle) {
 878                 xs = isp_find_xs(isp, ct->ct_syshandle);
 879                 if (xs == NULL)
 880                         pl = ISP_LOGALL;
 881         } else {
 882                 xs = NULL;
 883         }
 884
 885         switch(ct->ct_status & ~QLTM_SVALID) {
 886         case CT_OK:
 887                 /*
 888                  * There are generally 3 possibilities as to why we'd get
 889                  * this condition:
 890                  *      We disconnected after receiving a CDB.
 891                  *      We sent or received data.
 892                  *      We sent status & command complete.
 893                  */
 894
 895                 if (ct->ct_flags & CT_SENDSTATUS) {
 896                         break;
 897                 } else if ((ct->ct_flags & CT_DATAMASK) == CT_NO_DATA) {
 898                         /*
 899                          * Nothing to do in this case.
 900                          */
 901                         isp_prt(isp, pl, "CTIO- iid %d disconnected OK",
 902                             ct->ct_iid);
 903                         return;
 904                 }
 905                 break;
 906
 907         case CT_BDR_MSG:
 908                 /*
 909                  * Bus Device Reset message received or the SCSI Bus has
 910                  * been Reset; the firmware has gone to Bus Free.
 911                  *
 912                  * The firmware generates an async mailbox interupt to
 913                  * notify us of this and returns outstanding CTIOs with this
 914                  * status. These CTIOs are handled in that same way as
 915                  * CT_ABORTED ones, so just fall through here.
 916                  */
 917                 fmsg = "Bus Device Reset";
 918                 /*FALLTHROUGH*/
 919         case CT_RESET:
 920                 if (fmsg == NULL)
 921                         fmsg = "Bus Reset";
 922                 /*FALLTHROUGH*/
 923         case CT_ABORTED:
 924                 /*
 925                  * When an Abort message is received the firmware goes to
 926                  * Bus Free and returns all outstanding CTIOs with the status
 927                  * set, then sends us an Immediate Notify entry.
 928                  */
 929                 if (fmsg == NULL)
 930                         fmsg = "ABORT TAG message sent by Initiator";
 931
 932                 isp_prt(isp, ISP_LOGWARN, "CTIO destroyed by %s", fmsg);
 933                 break;
 934
 935         case CT_INVAL:
 936                 /*
 937                  * CTIO rejected by the firmware due to disabled lun.
 938                  * "Cannot Happen".
 939                  */
 940                 isp_prt(isp, ISP_LOGERR,
 941                     "Firmware rejected CTIO for disabled lun %d",
 942                     ct->ct_lun);
 943                 break;
 944
 945         case CT_NOPATH:
 946                 /*
 947                  * CTIO rejected by the firmware due "no path for the
 948                  * nondisconnecting nexus specified". This means that
 949                  * we tried to access the bus while a non-disconnecting
 950                  * command is in process.
 951                  */
 952                 isp_prt(isp, ISP_LOGERR,
 953                     "Firmware rejected CTIO for bad nexus %d/%d/%d",
 954                     ct->ct_iid, ct->ct_tgt, ct->ct_lun);
 955                 break;
 956
 957         case CT_RSELTMO:
 958                 fmsg = "Reselection";
 959                 /*FALLTHROUGH*/
 960         case CT_TIMEOUT:
 961                 if (fmsg == NULL)
 962                         fmsg = "Command";
 963                 isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
 964                 break;
 965
 966         case    CT_PANIC:
 967                 if (fmsg == NULL)
 968                         fmsg = "Unrecoverable Error";
 969                 /*FALLTHROUGH*/
 970         case CT_ERR:
 971                 if (fmsg == NULL)
 972                         fmsg = "Completed with Error";
 973                 /*FALLTHROUGH*/
 974         case CT_PHASE_ERROR:
 975                 if (fmsg == NULL)
 976                         fmsg = "Phase Sequence Error";
 977                 /*FALLTHROUGH*/
 978         case CT_TERMINATED:
 979                 if (fmsg == NULL)
 980                         fmsg = "terminated by TERMINATE TRANSFER";
 981                 /*FALLTHROUGH*/
 982         case CT_NOACK:
 983                 if (fmsg == NULL)
 984                         fmsg = "unacknowledged Immediate Notify pending";
 985                 isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
 986                 break;
 987         default:
 988                 isp_prt(isp, ISP_LOGERR, "Unknown CTIO status 0x%x",
 989                     ct->ct_status & ~QLTM_SVALID);
 990                 break;
 991         }
 992
 993         if (xs == NULL) {
 994                 /*
 995                  * There may be more than one CTIO for a data transfer,
 996                  * or this may be a status CTIO we're not monitoring.
 997                  *
 998                  * The assumption is that they'll all be returned in the
 999                  * order we got them.
1000                  */
1001                 if (ct->ct_syshandle == 0) {
1002                         if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
1003                                 isp_prt(isp, pl,
1004                                     "intermediate CTIO completed ok");
1005                         } else {
1006                                 isp_prt(isp, pl,
1007                                     "unmonitored CTIO completed ok");
1008                         }
1009                 } else {
1010                         isp_prt(isp, pl,
1011                             "NO xs for CTIO (handle 0x%x) status 0x%x",
1012                             ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1013                 }
1014         } else {
1015                 /*
1016                  * Final CTIO completed. Release DMA resources and
1017                  * notify platform dependent layers.
1018                  */
1019                 if ((ct->ct_flags & CT_DATAMASK) != CT_NO_DATA) {
1020                         ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1021                 }
1022                 isp_prt(isp, pl, "final CTIO complete");
1023                 /*
1024                  * The platform layer will destroy the handle if appropriate.
1025                  */
1026                 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1027         }
1028 }
1029
1030 static void
1031 isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
1032 {
1033         XS_T *xs;
1034         int pl = ISP_LOGTDEBUG2;
1035         char *fmsg = NULL;
1036
1037         if (ct->ct_syshandle) {
1038                 xs = isp_find_xs(isp, ct->ct_syshandle);
1039                 if (xs == NULL)
1040                         pl = ISP_LOGALL;
1041         } else {
1042                 xs = NULL;
1043         }
1044
1045         switch(ct->ct_status & ~QLTM_SVALID) {
1046         case CT_BUS_ERROR:
1047                 isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1048                 /* FALL Through */
1049         case CT_DATA_OVER:
1050         case CT_DATA_UNDER:
1051         case CT_OK:
1052                 /*
1053                  * There are generally 2 possibilities as to why we'd get
1054                  * this condition:
1055                  *      We sent or received data.
1056                  *      We sent status & command complete.
1057                  */
1058
1059                 break;
1060
1061         case CT_BDR_MSG:
1062                 /*
1063                  * Target Reset function received.
1064                  *
1065                  * The firmware generates an async mailbox interupt to
1066                  * notify us of this and returns outstanding CTIOs with this
1067                  * status. These CTIOs are handled in that same way as
1068                  * CT_ABORTED ones, so just fall through here.
1069                  */
1070                 fmsg = "TARGET RESET Task Management Function Received";
1071                 /*FALLTHROUGH*/
1072         case CT_RESET:
1073                 if (fmsg == NULL)
1074                         fmsg = "LIP Reset";
1075                 /*FALLTHROUGH*/
1076         case CT_ABORTED:
1077                 /*
1078                  * When an Abort message is received the firmware goes to
1079                  * Bus Free and returns all outstanding CTIOs with the status
1080                  * set, then sends us an Immediate Notify entry.
1081                  */
1082                 if (fmsg == NULL)
1083                         fmsg = "ABORT Task Management Function Received";
1084
1085                 isp_prt(isp, ISP_LOGERR, "CTIO2 destroyed by %s", fmsg);
1086                 break;
1087
1088         case CT_INVAL:
1089                 /*
1090                  * CTIO rejected by the firmware - invalid data direction.
1091                  */
1092                 isp_prt(isp, ISP_LOGERR, "CTIO2 had wrong data directiond");
1093                 break;
1094
1095         case CT_RSELTMO:
1096                 fmsg = "failure to reconnect to initiator";
1097                 /*FALLTHROUGH*/
1098         case CT_TIMEOUT:
1099                 if (fmsg == NULL)
1100                         fmsg = "command";
1101                 isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
1102                 break;
1103
1104         case CT_ERR:
1105                 fmsg = "Completed with Error";
1106                 /*FALLTHROUGH*/
1107         case CT_LOGOUT:
1108                 if (fmsg == NULL)
1109                         fmsg = "Port Logout";
1110                 /*FALLTHROUGH*/
1111         case CT_PORTNOTAVAIL:
1112                 if (fmsg == NULL)
1113                         fmsg = "Port not available";
1114         case CT_PORTCHANGED:
1115                 if (fmsg == NULL)
1116                         fmsg = "Port Changed";
1117         case CT_NOACK:
1118                 if (fmsg == NULL)
1119                         fmsg = "unacknowledged Immediate Notify pending";
1120                 isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
1121                 break;
1122
1123         case CT_INVRXID:
1124                 /*
1125                  * CTIO rejected by the firmware because an invalid RX_ID.
1126                  * Just print a message.
1127                  */
1128                 isp_prt(isp, ISP_LOGERR,
1129                     "CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1130                 break;
1131
1132         default:
1133                 isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x",
1134                     ct->ct_status & ~QLTM_SVALID);
1135                 break;
1136         }
1137
1138         if (xs == NULL) {
1139                 /*
1140                  * There may be more than one CTIO for a data transfer,
1141                  * or this may be a status CTIO we're not monitoring.
1142                  *
1143                  * The assumption is that they'll all be returned in the
1144                  * order we got them.
1145                  */
1146                 if (ct->ct_syshandle == 0) {
1147                         if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
1148                                 isp_prt(isp, pl,
1149                                     "intermediate CTIO completed ok");
1150                         } else {
1151                                 isp_prt(isp, pl,
1152                                     "unmonitored CTIO completed ok");
1153                         }
1154                 } else {
1155                         isp_prt(isp, pl,
1156                             "NO xs for CTIO (handle 0x%x) status 0x%x",
1157                             ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1158                 }
1159         } else {
1160                 if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
1161                         ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1162                 }
1163                 if (ct->ct_flags & CT_SENDSTATUS) {
1164                         /*
1165                          * Sent status and command complete.
1166                          *
1167                          * We're now really done with this command, so we
1168                          * punt to the platform dependent layers because
1169                          * only there can we do the appropriate command
1170                          * complete thread synchronization.
1171                          */
1172                         isp_prt(isp, pl, "status CTIO complete");
1173                 } else {
1174                         /*
1175                          * Final CTIO completed. Release DMA resources and
1176                          * notify platform dependent layers.
1177                          */
1178                         isp_prt(isp, pl, "data CTIO complete");
1179                 }
1180                 (void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1181                 /*
1182                  * The platform layer will destroy the handle if appropriate.
1183                  */
1184         }
1185 }
1186 #endif