sys/dev/isp/isp_target.c

   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