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 & 0x0fff;
 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         int vpidx, nphdl;
 507
 508         ISP_MEMZERO(&un, sizeof un);
 509
 510         if (IS_24XX(isp)) {
 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->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 if (code & ECMD_RVALID) {
 550                         cto->ct_flags |= CT7_FLAG_MODE1 | CT7_SENDSTATUS;
 551                         cto->ct_scsi_status |= (FCP_RSPLEN_VALID << 8);
 552                         cto->rsp.m1.ct_resplen = 4;
 553                         ISP_MEMZERO(cto->rsp.m1.ct_resp, sizeof (cto->rsp.m1.ct_resp));
 554                         cto->rsp.m1.ct_resp[0] = (code >> 12) & 0xf;
 555                         cto->rsp.m1.ct_resp[1] = (code >> 16) & 0xff;
 556                         cto->rsp.m1.ct_resp[2] = (code >> 24) & 0xff;
 557                         cto->rsp.m1.ct_resp[3] = 0;
 558                 } else {
 559                         cto->ct_flags |= CT7_FLAG_MODE1 | CT7_SENDSTATUS;
 560                 }
 561                 if (aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl != 0) {
 562                         cto->ct_resid = aep->at_cmnd.cdb_dl.sf.fcp_cmnd_dl;
 563                         cto->ct_scsi_status |= (FCP_RESID_UNDERFLOW << 8);
 564                 }
 565                 cto->ct_syshandle = hdl;
 566         } else {
 567                 at2_entry_t *aep;
 568                 ct2_entry_t *cto = &un._ctio2;
 569
 570                 va_start(ap, isp);
 571                 aep = va_arg(ap, at2_entry_t *);
 572                 /* nphdl and vpidx are unused here. */
 573                 nphdl = va_arg(ap, int);
 574                 vpidx = va_arg(ap, int);
 575                 code = va_arg(ap, uint32_t);
 576                 hdl = va_arg(ap, uint32_t);
 577                 va_end(ap);
 578
 579                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: [RX_ID 0x%x] code %x", __func__, aep->at_rxid, code);
 580
 581                 sts = code & 0xff;
 582                 cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
 583                 cto->ct_header.rqs_entry_count = 1;
 584                 if (ISP_CAP_SCCFW(isp) == 0) {
 585                         cto->ct_lun = aep->at_lun;
 586                 }
 587                 if (ISP_CAP_2KLOGIN(isp)) {
 588                         un._ctio2e.ct_iid = ((at2e_entry_t *)aep)->at_iid;
 589                 } else {
 590                         cto->ct_iid = aep->at_iid;
 591                 }
 592                 cto->ct_rxid = aep->at_rxid;
 593                 cto->rsp.m1.ct_scsi_status = sts;
 594                 cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
 595                 if (hdl == 0) {
 596                         cto->ct_flags |= CT2_CCINCR;
 597                 }
 598                 if (aep->at_datalen) {
 599                         cto->ct_resid = aep->at_datalen;
 600                         cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
 601                 }
 602                 if (sts == SCSI_CHECK && (code & ECMD_SVALID)) {
 603                         cto->rsp.m1.ct_resp[0] = 0xf0;
 604                         cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
 605                         cto->rsp.m1.ct_resp[7] = 8;
 606                         cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
 607                         cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
 608                         cto->rsp.m1.ct_senselen = 16;
 609                         cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
 610                 }
 611                 cto->ct_syshandle = hdl;
 612         }
 613         return (isp_target_put_entry(isp, &un));
 614 }
 615
 616 /*
 617  * These are either broadcast events or specifically CTIO fast completion
 618  */
 619
 620 void
 621 isp_target_async(ispsoftc_t *isp, int bus, int event)
 622 {
 623         isp_notify_t notify;
 624
 625         ISP_MEMZERO(&notify, sizeof (isp_notify_t));
 626         notify.nt_hba = isp;
 627         notify.nt_wwn = INI_ANY;
 628         notify.nt_nphdl = NIL_HANDLE;
 629         notify.nt_sid = PORT_ANY;
 630         notify.nt_did = PORT_ANY;
 631         notify.nt_tgt = TGT_ANY;
 632         notify.nt_channel = bus;
 633         notify.nt_lun = LUN_ANY;
 634         notify.nt_tagval = TAG_ANY;
 635         notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
 636
 637         switch (event) {
 638         case ASYNC_LOOP_UP:
 639         case ASYNC_PTPMODE:
 640                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: LOOP UP", __func__);
 641                 notify.nt_ncode = NT_LINK_UP;
 642                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 643                 break;
 644         case ASYNC_LOOP_DOWN:
 645                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: LOOP DOWN", __func__);
 646                 notify.nt_ncode = NT_LINK_DOWN;
 647                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 648                 break;
 649         case ASYNC_LIP_ERROR:
 650         case ASYNC_LIP_NOS_OLS_RECV:
 651         case ASYNC_LIP_OCCURRED:
 652         case ASYNC_LOOP_RESET:
 653                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: LIP RESET", __func__);
 654                 notify.nt_ncode = NT_LIP_RESET;
 655                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 656                 break;
 657         case ASYNC_BUS_RESET:
 658         case ASYNC_TIMEOUT_RESET:       /* XXX: where does this come from ? */
 659                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: BUS RESET", __func__);
 660                 notify.nt_ncode = NT_BUS_RESET;
 661                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 662                 break;
 663         case ASYNC_DEVICE_RESET:
 664                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: DEVICE RESET", __func__);
 665                 notify.nt_ncode = NT_TARGET_RESET;
 666                 isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 667                 break;
 668         case ASYNC_CTIO_DONE:
 669         {
 670                 uint8_t storage[QENTRY_LEN];
 671                 isp_prt(isp, ISP_LOGTDEBUG0, "%s: CTIO DONE", __func__);
 672                 memset(storage, 0, QENTRY_LEN);
 673                 if (IS_24XX(isp)) {
 674                         ct7_entry_t *ct = (ct7_entry_t *) storage;
 675                         ct->ct_header.rqs_entry_type = RQSTYPE_CTIO7;
 676                         ct->ct_nphdl = CT7_OK;
 677                         ct->ct_syshandle = bus;
 678                         ct->ct_flags = CT7_SENDSTATUS;
 679                 } else {
 680                         /* This should also suffice for 2K login code */
 681                         ct2_entry_t *ct = (ct2_entry_t *) storage;
 682                         ct->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
 683                         ct->ct_status = CT_OK;
 684                         ct->ct_syshandle = bus;
 685                         ct->ct_flags = CT2_SENDSTATUS|CT2_FASTPOST;
 686                 }
 687                 isp_async(isp, ISPASYNC_TARGET_ACTION, storage);
 688                 break;
 689         }
 690         default:
 691                 isp_prt(isp, ISP_LOGERR, "%s: unknown event 0x%x", __func__, event);
 692                 if (isp->isp_state == ISP_RUNSTATE) {
 693                         isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, NULL);
 694                 }
 695                 break;
 696         }
 697 }
 698
 699 /*
 700  * Synthesize a message from the task management flags in a FCP_CMND_IU.
 701  */
 702 static void
 703 isp_got_msg_fc(ispsoftc_t *isp, in_fcentry_t *inp)
 704 {
 705         isp_notify_t notify;
 706         static const char f1[] = "%s from N-port handle 0x%x lun %x seq 0x%x";
 707         static const char f2[] = "unknown %s 0x%x lun %x N-Port handle 0x%x task flags 0x%x seq 0x%x\n";
 708         uint16_t seqid, nphdl;
 709
 710         ISP_MEMZERO(&notify, sizeof (isp_notify_t));
 711         notify.nt_hba = isp;
 712         notify.nt_wwn = INI_ANY;
 713         if (ISP_CAP_2KLOGIN(isp)) {
 714                 notify.nt_nphdl = ((in_fcentry_e_t *)inp)->in_iid;
 715                 nphdl = ((in_fcentry_e_t *)inp)->in_iid;
 716                 seqid = ((in_fcentry_e_t *)inp)->in_seqid;
 717         } else {
 718                 notify.nt_nphdl = inp->in_iid;
 719                 nphdl = inp->in_iid;
 720                 seqid = inp->in_seqid;
 721         }
 722         notify.nt_sid = PORT_ANY;
 723         notify.nt_did = PORT_ANY;
 724
 725         /* nt_tgt set in outer layers */
 726         if (ISP_CAP_SCCFW(isp)) {
 727                 notify.nt_lun = inp->in_scclun;
 728         } else {
 729                 notify.nt_lun = inp->in_lun;
 730         }
 731         notify.nt_tagval = seqid;
 732         notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
 733         notify.nt_need_ack = 1;
 734         notify.nt_lreserved = inp;
 735
 736         if (inp->in_status != IN_MSG_RECEIVED) {
 737                 isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status", inp->in_status, notify.nt_lun, nphdl, inp->in_task_flags, inp->in_seqid);
 738                 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inp);
 739                 return;
 740         }
 741
 742         if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK_SET) {
 743                 isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET", nphdl, notify.nt_lun, inp->in_seqid);
 744                 notify.nt_ncode = NT_ABORT_TASK_SET;
 745         } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
 746                 isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET", nphdl, notify.nt_lun, inp->in_seqid);
 747                 notify.nt_ncode = NT_CLEAR_TASK_SET;
 748         } else if (inp->in_task_flags & TASK_FLAGS_LUN_RESET) {
 749                 isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET", nphdl, notify.nt_lun, inp->in_seqid);
 750                 notify.nt_ncode = NT_LUN_RESET;
 751         } else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
 752                 isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET", nphdl, notify.nt_lun, inp->in_seqid);
 753                 notify.nt_ncode = NT_TARGET_RESET;
 754         } else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
 755                 isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA", nphdl, notify.nt_lun, inp->in_seqid);
 756                 notify.nt_ncode = NT_CLEAR_ACA;
 757         } else {
 758                 isp_prt(isp, ISP_LOGWARN, f2, "task flag", inp->in_status, notify.nt_lun, nphdl, inp->in_task_flags,  inp->in_seqid);
 759                 isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inp);
 760                 return;
 761         }
 762         isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 763 }
 764
 765 static void
 766 isp_got_tmf_24xx(ispsoftc_t *isp, at7_entry_t *aep)
 767 {
 768         isp_notify_t notify;
 769         static const char f1[] = "%s from PortID 0x%06x lun %x seq 0x%08x";
 770         static const char f2[] = "unknown Task Flag 0x%x lun %x PortID 0x%x tag 0x%08x";
 771         fcportdb_t *lp;
 772         uint16_t chan;
 773         uint32_t sid, did;
 774
 775         ISP_MEMZERO(&notify, sizeof (isp_notify_t));
 776         notify.nt_hba = isp;
 777         notify.nt_wwn = INI_ANY;
 778         notify.nt_lun = (aep->at_cmnd.fcp_cmnd_lun[0] << 8) | (aep->at_cmnd.fcp_cmnd_lun[1]);
 779         notify.nt_tagval = aep->at_rxid;
 780         notify.nt_tagval |= (((uint64_t)(isp->isp_serno++)) << 32);
 781         notify.nt_lreserved = aep;
 782         sid = (aep->at_hdr.s_id[0] << 16) | (aep->at_hdr.s_id[1] << 8) | aep->at_hdr.s_id[2];
 783         did = (aep->at_hdr.d_id[0] << 16) | (aep->at_hdr.d_id[1] << 8) | aep->at_hdr.d_id[2];
 784         if (ISP_CAP_MULTI_ID(isp) && isp->isp_nchan > 1) {
 785                 /* Channel has to be derived from D_ID */
 786                 isp_find_chan_by_did(isp, did, &chan);
 787                 if (chan == ISP_NOCHAN) {
 788                         isp_prt(isp, ISP_LOGWARN, "%s: D_ID 0x%x not found on any channel", __func__, did);
 789                         isp_endcmd(isp, aep, NIL_HANDLE, ISP_NOCHAN, ECMD_TERMINATE, 0);
 790                         return;
 791                 }
 792         } else {
 793                 chan = 0;
 794         }
 795         if (isp_find_pdb_by_portid(isp, chan, sid, &lp))
 796                 notify.nt_nphdl = lp->handle;
 797         else
 798                 notify.nt_nphdl = NIL_HANDLE;
 799         notify.nt_sid = sid;
 800         notify.nt_did = did;
 801         notify.nt_channel = chan;
 802         if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_QUERY_TASK_SET) {
 803                 isp_prt(isp, ISP_LOGINFO, f1, "QUERY TASK SET", sid, notify.nt_lun, aep->at_rxid);
 804                 notify.nt_ncode = NT_QUERY_TASK_SET;
 805         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_ABORT_TASK_SET) {
 806                 isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK SET", sid, notify.nt_lun, aep->at_rxid);
 807                 notify.nt_ncode = NT_ABORT_TASK_SET;
 808         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_CLEAR_TASK_SET) {
 809                 isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET", sid, notify.nt_lun, aep->at_rxid);
 810                 notify.nt_ncode = NT_CLEAR_TASK_SET;
 811         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_QUERY_ASYNC_EVENT) {
 812                 isp_prt(isp, ISP_LOGINFO, f1, "QUERY ASYNC EVENT", sid, notify.nt_lun, aep->at_rxid);
 813                 notify.nt_ncode = NT_QUERY_ASYNC_EVENT;
 814         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_LUN_RESET) {
 815                 isp_prt(isp, ISP_LOGINFO, f1, "LUN RESET", sid, notify.nt_lun, aep->at_rxid);
 816                 notify.nt_ncode = NT_LUN_RESET;
 817         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_TGT_RESET) {
 818                 isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET", sid, notify.nt_lun, aep->at_rxid);
 819                 notify.nt_ncode = NT_TARGET_RESET;
 820         } else if (aep->at_cmnd.fcp_cmnd_task_management & FCP_CMND_TMF_CLEAR_ACA) {
 821                 isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA", sid, notify.nt_lun, aep->at_rxid);
 822                 notify.nt_ncode = NT_CLEAR_ACA;
 823         } else {
 824                 isp_prt(isp, ISP_LOGWARN, f2, aep->at_cmnd.fcp_cmnd_task_management, notify.nt_lun, sid, aep->at_rxid);
 825                 notify.nt_ncode = NT_UNKNOWN;
 826                 isp_endcmd(isp, aep, notify.nt_nphdl, chan, ECMD_RVALID | (0x4 << 12), 0);
 827                 return;
 828         }
 829         isp_async(isp, ISPASYNC_TARGET_NOTIFY, &notify);
 830 }
 831
 832 int
 833 isp_notify_ack(ispsoftc_t *isp, void *arg)
 834 {
 835         char storage[QENTRY_LEN];
 836         void *outp;
 837
 838         /*
 839          * This is in case a Task Management Function ends up here.
 840          */
 841         if (IS_24XX(isp) && arg != NULL && (((isphdr_t *)arg)->rqs_entry_type == RQSTYPE_ATIO)) {
 842                 at7_entry_t *aep = arg;
 843                 return (isp_endcmd(isp, aep, NIL_HANDLE, 0, 0, 0));
 844         }
 845
 846         outp = isp_getrqentry(isp);
 847         if (outp == NULL) {
 848                 isp_prt(isp, ISP_LOGWARN, rqo, __func__);
 849                 return (1);
 850         }
 851
 852         ISP_MEMZERO(storage, QENTRY_LEN);
 853
 854         if (IS_24XX(isp)) {
 855                 na_fcentry_24xx_t *na = (na_fcentry_24xx_t *) storage;
 856                 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 857                 na->na_header.rqs_entry_count = 1;
 858                 if (arg) {
 859                         in_fcentry_24xx_t *in = arg;
 860                         na->na_nphdl = in->in_nphdl;
 861                         na->na_flags = in->in_flags;
 862                         na->na_status = in->in_status;
 863                         na->na_status_subcode = in->in_status_subcode;
 864                         na->na_fwhandle = in->in_fwhandle;
 865                         na->na_rxid = in->in_rxid;
 866                         na->na_oxid = in->in_oxid;
 867                         na->na_vpidx = in->in_vpidx;
 868                         if (in->in_status == IN24XX_SRR_RCVD) {
 869                                 na->na_srr_rxid = in->in_srr_rxid;
 870                                 na->na_srr_reloff_hi = in->in_srr_reloff_hi;
 871                                 na->na_srr_reloff_lo = in->in_srr_reloff_lo;
 872                                 na->na_srr_iu = in->in_srr_iu;
 873                                 /*
 874                                  * Whether we're accepting the SRR or rejecting
 875                                  * it is determined by looking at the in_reserved
 876                                  * field in the original notify structure.
 877                                  */
 878                                 if (in->in_reserved) {
 879                                         na->na_srr_flags = 1;
 880                                         na->na_srr_reject_vunique = 0;
 881                                         na->na_srr_reject_code = 9;             /* unable to perform this command at this time */
 882                                         na->na_srr_reject_explanation = 0x2a;   /* unable to supply the requested data */
 883                                 }
 884                         }
 885                 }
 886                 isp_put_notify_24xx_ack(isp, na, (na_fcentry_24xx_t *)outp);
 887         } else {
 888                 na_fcentry_t *na = (na_fcentry_t *) storage;
 889                 int iid = 0;
 890
 891                 if (arg) {
 892                         in_fcentry_t *inp = arg;
 893                         ISP_MEMCPY(storage, arg, sizeof (isphdr_t));
 894                         if (ISP_CAP_2KLOGIN(isp)) {
 895                                 ((na_fcentry_e_t *)na)->na_iid = ((in_fcentry_e_t *)inp)->in_iid;
 896                                 iid = ((na_fcentry_e_t *)na)->na_iid;
 897                         } else {
 898                                 na->na_iid = inp->in_iid;
 899                                 iid = na->na_iid;
 900                         }
 901                         na->na_task_flags = inp->in_task_flags & TASK_FLAGS_RESERVED_MASK;
 902                         na->na_seqid = inp->in_seqid;
 903                         na->na_status = inp->in_status;
 904                         na->na_flags = NAFC_RCOUNT;
 905                         if (inp->in_status == IN_RESET) {
 906                                 na->na_flags = NAFC_RST_CLRD;   /* We do not modify resource counts for LIP resets */
 907                         }
 908                         if (inp->in_status == IN_MSG_RECEIVED) {
 909                                 na->na_flags |= NAFC_TVALID;
 910                                 na->na_response = 0;    /* XXX SUCCEEDED XXX */
 911                         }
 912                 } else {
 913                         na->na_flags = NAFC_RST_CLRD;
 914                 }
 915                 na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
 916                 na->na_header.rqs_entry_count = 1;
 917                 if (ISP_CAP_2KLOGIN(isp)) {
 918                         isp_put_notify_ack_fc_e(isp, (na_fcentry_e_t *) na, (na_fcentry_e_t *)outp);
 919                 } else {
 920                         isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
 921                 }
 922                 isp_prt(isp, ISP_LOGTDEBUG0, "notify ack handle %x seqid %x flags %x tflags %x response %x", iid, na->na_seqid,
 923                     na->na_flags, na->na_task_flags, na->na_response);
 924         }
 925         ISP_TDQE(isp, "isp_notify_ack", isp->isp_reqidx, storage);
 926         ISP_SYNC_REQUEST(isp);
 927         return (0);
 928 }
 929
 930 int
 931 isp_acknak_abts(ispsoftc_t *isp, void *arg, int errno)
 932 {
 933         char storage[QENTRY_LEN];
 934         uint16_t tmpw;
 935         uint8_t tmpb;
 936         abts_t *abts = arg;
 937         abts_rsp_t *rsp = (abts_rsp_t *) storage;
 938         void *outp;
 939
 940         if (!IS_24XX(isp)) {
 941                 isp_prt(isp, ISP_LOGERR, "%s: called for non-24XX card", __func__);
 942                 return (0);
 943         }
 944
 945         if (abts->abts_header.rqs_entry_type != RQSTYPE_ABTS_RCVD) {
 946                 isp_prt(isp, ISP_LOGERR, "%s: called for non-ABTS entry (0x%x)", __func__, abts->abts_header.rqs_entry_type);
 947                 return (0);
 948         }
 949
 950         outp = isp_getrqentry(isp);
 951         if (outp == NULL) {
 952                 isp_prt(isp, ISP_LOGWARN, rqo, __func__);
 953                 return (1);
 954         }
 955
 956         ISP_MEMCPY(rsp, abts, QENTRY_LEN);
 957         rsp->abts_rsp_header.rqs_entry_type = RQSTYPE_ABTS_RSP;
 958
 959         /*
 960          * Swap destination and source for response.
 961          */
 962         rsp->abts_rsp_r_ctl = BA_ACC;
 963         tmpw = rsp->abts_rsp_did_lo;
 964         tmpb = rsp->abts_rsp_did_hi;
 965         rsp->abts_rsp_did_lo = rsp->abts_rsp_sid_lo;
 966         rsp->abts_rsp_did_hi = rsp->abts_rsp_sid_hi;
 967         rsp->abts_rsp_sid_lo = tmpw;
 968         rsp->abts_rsp_sid_hi = tmpb;
 969
 970         rsp->abts_rsp_f_ctl_hi ^= 0x80;         /* invert Exchange Context */
 971         rsp->abts_rsp_f_ctl_hi &= ~0x7f;        /* clear Sequence Initiator and other bits */
 972         rsp->abts_rsp_f_ctl_hi |= 0x10;         /* abort the whole exchange */
 973         rsp->abts_rsp_f_ctl_hi |= 0x8;          /* last data frame of sequence */
 974         rsp->abts_rsp_f_ctl_hi |= 0x1;          /* transfer Sequence Initiative */
 975         rsp->abts_rsp_f_ctl_lo = 0;
 976
 977         if (errno == 0) {
 978                 uint16_t rx_id, ox_id;
 979
 980                 rx_id = rsp->abts_rsp_rx_id;
 981                 ox_id = rsp->abts_rsp_ox_id;
 982                 ISP_MEMZERO(&rsp->abts_rsp_payload.ba_acc, sizeof (rsp->abts_rsp_payload.ba_acc));
 983                 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);
 984                 rsp->abts_rsp_payload.ba_acc.aborted_rx_id = rx_id;
 985                 rsp->abts_rsp_payload.ba_acc.aborted_ox_id = ox_id;
 986                 rsp->abts_rsp_payload.ba_acc.high_seq_cnt = 0xffff;
 987         } else {
 988                 ISP_MEMZERO(&rsp->abts_rsp_payload.ba_rjt, sizeof (rsp->abts_rsp_payload.ba_acc));
 989                 switch (errno) {
 990                 case ENOMEM:
 991                         rsp->abts_rsp_payload.ba_rjt.reason = 5;        /* Logical Unit Busy */
 992                         break;
 993                 default:
 994                         rsp->abts_rsp_payload.ba_rjt.reason = 9;        /* Unable to perform command request */
 995                         break;
 996                 }
 997         }
 998
 999         /*
1000          * The caller will have set response values as appropriate
1001          * in the ABTS structure just before calling us.
1002          */
1003         isp_put_abts_rsp(isp, rsp, (abts_rsp_t *)outp);
1004         ISP_TDQE(isp, "isp_acknak_abts", isp->isp_reqidx, storage);
1005         ISP_SYNC_REQUEST(isp);
1006         return (0);
1007 }
1008
1009 static void
1010 isp_handle_atio2(ispsoftc_t *isp, at2_entry_t *aep)
1011 {
1012         int lun, iid;
1013
1014         if (ISP_CAP_SCCFW(isp)) {
1015                 lun = aep->at_scclun;
1016         } else {
1017                 lun = aep->at_lun;
1018         }
1019
1020         if (ISP_CAP_2KLOGIN(isp)) {
1021                 iid = ((at2e_entry_t *)aep)->at_iid;
1022         } else {
1023                 iid = aep->at_iid;
1024         }
1025
1026         /*
1027          * The firmware status (except for the QLTM_SVALID bit) indicates
1028          * why this ATIO was sent to us.
1029          *
1030          * If QLTM_SVALID is set, the firware has recommended Sense Data.
1031          *
1032          * If the DISCONNECTS DISABLED bit is set in the flags field,
1033          * we're still connected on the SCSI bus - i.e. the initiator
1034          * did not set DiscPriv in the identify message. We don't care
1035          * about this so it's ignored.
1036          */
1037
1038         switch (aep->at_status & ~QLTM_SVALID) {
1039         case AT_PATH_INVALID:
1040                 /*
1041                  * ATIO rejected by the firmware due to disabled lun.
1042                  */
1043                 isp_prt(isp, ISP_LOGERR, "rejected ATIO2 for disabled lun %x", lun);
1044                 break;
1045         case AT_NOCAP:
1046                 /*
1047                  * Requested Capability not available
1048                  * We sent an ATIO that overflowed the firmware's
1049                  * command resource count.
1050                  */
1051                 isp_prt(isp, ISP_LOGERR, "rejected ATIO2 for lun %x- command count overflow", lun);
1052                 break;
1053
1054         case AT_BDR_MSG:
1055                 /*
1056                  * If we send an ATIO to the firmware to increment
1057                  * its command resource count, and the firmware is
1058                  * recovering from a Bus Device Reset, it returns
1059                  * the ATIO with this status. We set the command
1060                  * resource count in the Enable Lun entry and no
1061                  * not increment it. Therefore we should never get
1062                  * this status here.
1063                  */
1064                 isp_prt(isp, ISP_LOGERR, atiocope, lun, 0);
1065                 break;
1066
1067         case AT_CDB:            /* Got a CDB */
1068                 /*
1069                  * Punt to platform specific layer.
1070                  */
1071                 isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
1072                 break;
1073
1074         case AT_RESET:
1075                 /*
1076                  * A bus reset came along an blew away this command. Why
1077                  * they do this in addition the async event code stuff,
1078                  * I dunno.
1079                  *
1080                  * Ignore it because the async event will clear things
1081                  * up for us.
1082                  */
1083                 isp_prt(isp, ISP_LOGERR, atior, lun, iid, 0);
1084                 break;
1085
1086
1087         default:
1088                 isp_prt(isp, ISP_LOGERR, "Unknown ATIO2 status 0x%x from handle %d for lun %x", aep->at_status, iid, lun);
1089                 (void) isp_target_put_atio(isp, aep);
1090                 break;
1091         }
1092 }
1093
1094 static void
1095 isp_handle_ctio2(ispsoftc_t *isp, ct2_entry_t *ct)
1096 {
1097         void *xs;
1098         int pl = ISP_LOGTDEBUG2;
1099         char *fmsg = NULL;
1100
1101         if (ct->ct_syshandle) {
1102                 xs = isp_find_xs(isp, ct->ct_syshandle);
1103                 if (xs == NULL) {
1104                         pl = ISP_LOGALL;
1105                 }
1106         } else {
1107                 xs = NULL;
1108         }
1109
1110         switch (ct->ct_status & ~QLTM_SVALID) {
1111         case CT_BUS_ERROR:
1112                 isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1113                 /* FALL Through */
1114         case CT_DATA_OVER:
1115         case CT_DATA_UNDER:
1116         case CT_OK:
1117                 /*
1118                  * There are generally 2 possibilities as to why we'd get
1119                  * this condition:
1120                  *      We sent or received data.
1121                  *      We sent status & command complete.
1122                  */
1123
1124                 break;
1125
1126         case CT_BDR_MSG:
1127                 /*
1128                  * Target Reset function received.
1129                  *
1130                  * The firmware generates an async mailbox interrupt to
1131                  * notify us of this and returns outstanding CTIOs with this
1132                  * status. These CTIOs are handled in that same way as
1133                  * CT_ABORTED ones, so just fall through here.
1134                  */
1135                 fmsg = "TARGET RESET";
1136                 /*FALLTHROUGH*/
1137         case CT_RESET:
1138                 if (fmsg == NULL)
1139                         fmsg = "LIP Reset";
1140                 /*FALLTHROUGH*/
1141         case CT_ABORTED:
1142                 /*
1143                  * When an Abort message is received the firmware goes to
1144                  * Bus Free and returns all outstanding CTIOs with the status
1145                  * set, then sends us an Immediate Notify entry.
1146                  */
1147                 if (fmsg == NULL) {
1148                         fmsg = "ABORT";
1149                 }
1150
1151                 isp_prt(isp, ISP_LOGTDEBUG0, "CTIO2 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
1152                 break;
1153
1154         case CT_INVAL:
1155                 /*
1156                  * CTIO rejected by the firmware - invalid data direction.
1157                  */
1158                 isp_prt(isp, ISP_LOGERR, "CTIO2 had wrong data direction");
1159                 break;
1160
1161         case CT_RSELTMO:
1162                 fmsg = "failure to reconnect to initiator";
1163                 /*FALLTHROUGH*/
1164         case CT_TIMEOUT:
1165                 if (fmsg == NULL)
1166                         fmsg = "command";
1167                 isp_prt(isp, ISP_LOGWARN, "Firmware timed out on %s", fmsg);
1168                 break;
1169
1170         case CT_ERR:
1171                 fmsg = "Completed with Error";
1172                 /*FALLTHROUGH*/
1173         case CT_LOGOUT:
1174                 if (fmsg == NULL)
1175                         fmsg = "Port Logout";
1176                 /*FALLTHROUGH*/
1177         case CT_PORTUNAVAIL:
1178                 if (fmsg == NULL)
1179                         fmsg = "Port not available";
1180                 /*FALLTHROUGH*/
1181         case CT_PORTCHANGED:
1182                 if (fmsg == NULL)
1183                         fmsg = "Port Changed";
1184                 /*FALLTHROUGH*/
1185         case CT_NOACK:
1186                 if (fmsg == NULL)
1187                         fmsg = "unacknowledged Immediate Notify pending";
1188                 isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
1189                 break;
1190
1191         case CT_INVRXID:
1192                 /*
1193                  * CTIO rejected by the firmware because an invalid RX_ID.
1194                  * Just print a message.
1195                  */
1196                 isp_prt(isp, ISP_LOGWARN, "CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1197                 break;
1198
1199         default:
1200                 isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x", ct->ct_status & ~QLTM_SVALID);
1201                 break;
1202         }
1203
1204         if (xs == NULL) {
1205                 /*
1206                  * There may be more than one CTIO for a data transfer,
1207                  * or this may be a status CTIO we're not monitoring.
1208                  *
1209                  * The assumption is that they'll all be returned in the
1210                  * order we got them.
1211                  */
1212                 if (ct->ct_syshandle == 0) {
1213                         if ((ct->ct_flags & CT2_SENDSTATUS) == 0) {
1214                                 isp_prt(isp, pl, "intermediate CTIO completed ok");
1215                         } else {
1216                                 isp_prt(isp, pl, "unmonitored CTIO completed ok");
1217                         }
1218                 } else {
1219                         isp_prt(isp, pl, "NO xs for CTIO (handle 0x%x) status 0x%x", ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
1220                 }
1221         } else {
1222                 if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
1223                         ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1224                 }
1225                 if (ct->ct_flags & CT2_SENDSTATUS) {
1226                         /*
1227                          * Sent status and command complete.
1228                          *
1229                          * We're now really done with this command, so we
1230                          * punt to the platform dependent layers because
1231                          * only there can we do the appropriate command
1232                          * complete thread synchronization.
1233                          */
1234                         isp_prt(isp, pl, "status CTIO complete");
1235                 } else {
1236                         /*
1237                          * Final CTIO completed. Release DMA resources and
1238                          * notify platform dependent layers.
1239                          */
1240                         isp_prt(isp, pl, "data CTIO complete");
1241                 }
1242                 isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1243                 /*
1244                  * The platform layer will destroy the handle if appropriate.
1245                  */
1246         }
1247 }
1248
1249 static void
1250 isp_handle_ctio7(ispsoftc_t *isp, ct7_entry_t *ct)
1251 {
1252         void *xs;
1253         int pl = ISP_LOGTDEBUG2;
1254         char *fmsg = NULL;
1255
1256         if (ct->ct_syshandle) {
1257                 xs = isp_find_xs(isp, ct->ct_syshandle);
1258                 if (xs == NULL) {
1259                         pl = ISP_LOGALL;
1260                 }
1261         } else {
1262                 xs = NULL;
1263         }
1264
1265         switch (ct->ct_nphdl) {
1266         case CT7_BUS_ERROR:
1267                 isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
1268                 /* FALL Through */
1269         case CT7_DATA_OVER:
1270         case CT7_DATA_UNDER:
1271         case CT7_OK:
1272                 /*
1273                  * There are generally 2 possibilities as to why we'd get
1274                  * this condition:
1275                  *      We sent or received data.
1276                  *      We sent status & command complete.
1277                  */
1278
1279                 break;
1280
1281         case CT7_RESET:
1282                 if (fmsg == NULL) {
1283                         fmsg = "LIP Reset";
1284                 }
1285                 /*FALLTHROUGH*/
1286         case CT7_ABORTED:
1287                 /*
1288                  * When an Abort message is received the firmware goes to
1289                  * Bus Free and returns all outstanding CTIOs with the status
1290                  * set, then sends us an Immediate Notify entry.
1291                  */
1292                 if (fmsg == NULL) {
1293                         fmsg = "ABORT";
1294                 }
1295                 isp_prt(isp, ISP_LOGTDEBUG0, "CTIO7 destroyed by %s: RX_ID=0x%x", fmsg, ct->ct_rxid);
1296                 break;
1297
1298         case CT7_TIMEOUT:
1299                 if (fmsg == NULL) {
1300                         fmsg = "command";
1301                 }
1302                 isp_prt(isp, ISP_LOGWARN, "Firmware timed out on %s", fmsg);
1303                 break;
1304
1305         case CT7_ERR:
1306                 fmsg = "Completed with Error";
1307                 /*FALLTHROUGH*/
1308         case CT7_LOGOUT:
1309                 if (fmsg == NULL) {
1310                         fmsg = "Port Logout";
1311                 }
1312                 /*FALLTHROUGH*/
1313         case CT7_PORTUNAVAIL:
1314                 if (fmsg == NULL) {
1315                         fmsg = "Port not available";
1316                 }
1317                 /*FALLTHROUGH*/
1318         case CT7_PORTCHANGED:
1319                 if (fmsg == NULL) {
1320                         fmsg = "Port Changed";
1321                 }
1322                 isp_prt(isp, ISP_LOGWARN, "CTIO returned by f/w- %s", fmsg);
1323                 break;
1324
1325         case CT7_INVRXID:
1326                 /*
1327                  * CTIO rejected by the firmware because an invalid RX_ID.
1328                  * Just print a message.
1329                  */
1330                 isp_prt(isp, ISP_LOGWARN, "CTIO7 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
1331                 break;
1332
1333         case CT7_REASSY_ERR:
1334                 isp_prt(isp, ISP_LOGWARN, "reassembly error");
1335                 break;
1336
1337         case CT7_SRR:
1338                 isp_prt(isp, ISP_LOGTDEBUG0, "SRR received");
1339                 break;
1340
1341         default:
1342                 isp_prt(isp, ISP_LOGERR, "Unknown CTIO7 status 0x%x", ct->ct_nphdl);
1343                 break;
1344         }
1345
1346         if (xs == NULL) {
1347                 /*
1348                  * There may be more than one CTIO for a data transfer,
1349                  * or this may be a status CTIO we're not monitoring.
1350                  *
1351                  * The assumption is that they'll all be returned in the
1352                  * order we got them.
1353                  */
1354                 if (ct->ct_syshandle == 0) {
1355                         if (ct->ct_flags & CT7_TERMINATE) {
1356                                 isp_prt(isp, ISP_LOGINFO, "termination of [RX_ID 0x%x] complete", ct->ct_rxid);
1357                         } else if ((ct->ct_flags & CT7_SENDSTATUS) == 0) {
1358                                 isp_prt(isp, pl, "intermediate CTIO completed ok");
1359                         } else {
1360                                 isp_prt(isp, pl, "unmonitored CTIO completed ok");
1361                         }
1362                 } else {
1363                         isp_prt(isp, pl, "NO xs for CTIO (handle 0x%x) status 0x%x", ct->ct_syshandle, ct->ct_nphdl);
1364                 }
1365         } else {
1366                 if ((ct->ct_flags & CT7_DATAMASK) != CT7_NO_DATA) {
1367                         ISP_DMAFREE(isp, xs, ct->ct_syshandle);
1368                 }
1369                 if (ct->ct_flags & CT7_SENDSTATUS) {
1370                         /*
1371                          * Sent status and command complete.
1372                          *
1373                          * We're now really done with this command, so we
1374                          * punt to the platform dependent layers because
1375                          * only there can we do the appropriate command
1376                          * complete thread synchronization.
1377                          */
1378                         isp_prt(isp, pl, "status CTIO complete");
1379                 } else {
1380                         /*
1381                          * Final CTIO completed. Release DMA resources and
1382                          * notify platform dependent layers.
1383                          */
1384                         isp_prt(isp, pl, "data CTIO complete");
1385                 }
1386                 isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
1387                 /*
1388                  * The platform layer will destroy the handle if appropriate.
1389                  */
1390         }
1391 }
1392
1393 static void
1394 isp_handle_24xx_inotify(ispsoftc_t *isp, in_fcentry_24xx_t *inot_24xx)
1395 {
1396         uint8_t ochan, chan, lochan, hichan;
1397
1398         /*
1399          * Check to see whether we got a wildcard channel.
1400          * If so, we have to iterate over all channels.
1401          */
1402         ochan = chan = ISP_GET_VPIDX(isp, inot_24xx->in_vpidx);
1403         if (chan == 0xff) {
1404                 lochan = 0;
1405                 hichan = isp->isp_nchan;
1406         } else {
1407                 if (chan >= isp->isp_nchan) {
1408                         char buf[64];
1409                         ISP_SNPRINTF(buf, sizeof buf, "%s: bad channel %d for status 0x%x", __func__, chan, inot_24xx->in_status);
1410                         isp_print_bytes(isp, buf, QENTRY_LEN, inot_24xx);
1411                         isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot_24xx);
1412                         return;
1413                 }
1414                 lochan = chan;
1415                 hichan = chan + 1;
1416         }
1417         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);
1418         for (chan = lochan; chan < hichan; chan++) {
1419                 if (FCPARAM(isp, chan)->role == ISP_ROLE_NONE)
1420                         continue;
1421                 switch (inot_24xx->in_status) {
1422                 case IN24XX_LIP_RESET:
1423                 case IN24XX_LINK_RESET:
1424                 case IN24XX_PORT_LOGOUT:
1425                 case IN24XX_PORT_CHANGED:
1426                 case IN24XX_LINK_FAILED:
1427                 case IN24XX_SRR_RCVD:
1428                 case IN24XX_ELS_RCVD:
1429                         inot_24xx->in_reserved = 0;     /* clear this for later usage */
1430                         inot_24xx->in_vpidx = chan;
1431                         isp_async(isp, ISPASYNC_TARGET_ACTION, inot_24xx);
1432                         break;
1433                 default:
1434                         isp_prt(isp, ISP_LOGINFO, "%s: unhandled status (0x%x) for chan %d", __func__, inot_24xx->in_status, chan);
1435                         isp_async(isp, ISPASYNC_TARGET_NOTIFY_ACK, inot_24xx);
1436                         break;
1437                 }
1438         }
1439         inot_24xx->in_vpidx = ochan;
1440 }
1441 #endif