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