sys/dev/isp/isp.c

   1 /*-
   2  *  Copyright (c) 1997-2007 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 (well, as best as possible)
  30  * code for the Qlogic ISP SCSI and FC-SCSI adapters.
  31  */
  32
  33 /*
  34  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
  35  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
  36  * ideas dredged from the Solaris driver.
  37  */
  38
  39 /*
  40  * Include header file appropriate for platform we're building on.
  41  */
  42 #ifdef  __NetBSD__
  43 #include <sys/cdefs.h>
  44 __KERNEL_RCSID(0, "$NetBSD$");
  45 #include <dev/ic/isp_netbsd.h>
  46 #endif
  47 #ifdef  __FreeBSD__
  48 #include <sys/cdefs.h>
  49 __FBSDID("$FreeBSD$");
  50 #include <dev/isp/isp_freebsd.h>
  51 #endif
  52 #ifdef  __OpenBSD__
  53 #include <dev/ic/isp_openbsd.h>
  54 #endif
  55 #ifdef  __linux__
  56 #include "isp_linux.h"
  57 #endif
  58 #ifdef  __svr4__
  59 #include "isp_solaris.h"
  60 #endif
  61
  62 /*
  63  * General defines
  64  */
  65
  66 #define MBOX_DELAY_COUNT        1000000 / 100
  67 #define ISP_MARK_PORTDB(a, b)   \
  68     isp_prt(isp, ISP_LOGSANCFG, "line %d: markportdb", __LINE__); \
  69     isp_mark_portdb(a, b)
  70
  71 /*
  72  * Local static data
  73  */
  74 static const char fconf[] =
  75     "PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n"
  76     " database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
  77 static const char notresp[] =
  78   "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
  79 static const char xact1[] =
  80     "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
  81 static const char xact2[] =
  82     "HBA attempted queued transaction to target routine %d on target %d bus %d";
  83 static const char xact3[] =
  84     "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
  85 static const char pskip[] =
  86     "SCSI phase skipped for target %d.%d.%d";
  87 static const char topology[] =
  88     "HBA PortID 0x%06x N-Port Handle %d, Connection Topology '%s'";
  89 static const char ourwwn[] =
  90     "HBA WWNN 0x%08x%08x HBA WWPN 0x%08x%08x";
  91 static const char finmsg[] =
  92     "%d.%d.%d: FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
  93 static const char sc0[] =
  94     "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
  95 static const char sc1[] =
  96     "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
  97 static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
  98 static const char sc3[] = "Generated";
  99 static const char sc4[] = "NVRAM";
 100 static const char bun[] =
 101     "bad underrun for %d.%d (count %d, resid %d, status %s)";
 102
 103 /*
 104  * Local function prototypes.
 105  */
 106 static int isp_parse_async(ispsoftc_t *, uint16_t);
 107 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *,
 108     uint32_t *);
 109 static void
 110 isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *, long *);
 111 static void
 112 isp_parse_status_24xx(ispsoftc_t *, isp24xx_statusreq_t *, XS_T *, long *);
 113 static void isp_fastpost_complete(ispsoftc_t *, uint16_t);
 114 static int isp_mbox_continue(ispsoftc_t *);
 115 static void isp_scsi_init(ispsoftc_t *);
 116 static void isp_scsi_channel_init(ispsoftc_t *, int);
 117 static void isp_fibre_init(ispsoftc_t *);
 118 static void isp_fibre_init_2400(ispsoftc_t *);
 119 static void isp_mark_portdb(ispsoftc_t *, int);
 120 static int isp_plogx(ispsoftc_t *, uint16_t, uint32_t, int, int);
 121 static int isp_port_login(ispsoftc_t *, uint16_t, uint32_t);
 122 static int isp_port_logout(ispsoftc_t *, uint16_t, uint32_t);
 123 static int isp_getpdb(ispsoftc_t *, uint16_t, isp_pdb_t *, int);
 124 static uint64_t isp_get_portname(ispsoftc_t *, int, int);
 125 static int isp_fclink_test(ispsoftc_t *, int);
 126 static const char *ispfc_fw_statename(int);
 127 static int isp_pdb_sync(ispsoftc_t *);
 128 static int isp_scan_loop(ispsoftc_t *);
 129 static int isp_gid_ft_sns(ispsoftc_t *);
 130 static int isp_gid_ft_ct_passthru(ispsoftc_t *);
 131 static int isp_scan_fabric(ispsoftc_t *);
 132 static int isp_login_device(ispsoftc_t *, uint32_t, isp_pdb_t *, uint16_t *);
 133 static int isp_register_fc4_type(ispsoftc_t *);
 134 static int isp_register_fc4_type_24xx(ispsoftc_t *);
 135 static uint16_t isp_nxt_handle(ispsoftc_t *, uint16_t);
 136 static void isp_fw_state(ispsoftc_t *);
 137 static void isp_mboxcmd_qnw(ispsoftc_t *, mbreg_t *, int);
 138 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *);
 139
 140 static void isp_update(ispsoftc_t *);
 141 static void isp_update_bus(ispsoftc_t *, int);
 142 static void isp_setdfltparm(ispsoftc_t *, int);
 143 static void isp_setdfltfcparm(ispsoftc_t *);
 144 static int isp_read_nvram(ispsoftc_t *);
 145 static int isp_read_nvram_2400(ispsoftc_t *);
 146 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
 147 static void isp_rd_2400_nvram(ispsoftc_t *, uint32_t, uint32_t *);
 148 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
 149 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
 150 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
 151 static void isp_fix_nvram_wwns(ispsoftc_t *);
 152 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
 153 static void isp_parse_nvram_2400(ispsoftc_t *, uint8_t *);
 154
 155 /*
 156  * Reset Hardware.
 157  *
 158  * Hit the chip over the head, download new f/w if available and set it running.
 159  *
 160  * Locking done elsewhere.
 161  */
 162
 163 void
 164 isp_reset(ispsoftc_t *isp)
 165 {
 166         mbreg_t mbs;
 167         uint32_t code_org, val;
 168         int loops, i, dodnld = 1;
 169         static const char *btype = "????";
 170         static const char dcrc[] = "Downloaded RISC Code Checksum Failure";
 171
 172         isp->isp_state = ISP_NILSTATE;
 173
 174         /*
 175          * Basic types (SCSI, FibreChannel and PCI or SBus)
 176          * have been set in the MD code. We figure out more
 177          * here. Possibly more refined types based upon PCI
 178          * identification. Chip revision has been gathered.
 179          *
 180          * After we've fired this chip up, zero out the conf1 register
 181          * for SCSI adapters and do other settings for the 2100.
 182          */
 183
 184         /*
 185          * Get the current running firmware revision out of the
 186          * chip before we hit it over the head (if this is our
 187          * first time through). Note that we store this as the
 188          * 'ROM' firmware revision- which it may not be. In any
 189          * case, we don't really use this yet, but we may in
 190          * the future.
 191          */
 192         if (isp->isp_touched == 0) {
 193                 /*
 194                  * First see whether or not we're sitting in the ISP PROM.
 195                  * If we've just been reset, we'll have the string "ISP   "
 196                  * spread through outgoing mailbox registers 1-3. We do
 197                  * this for PCI cards because otherwise we really don't
 198                  * know what state the card is in and we could hang if
 199                  * we try this command otherwise.
 200                  *
 201                  * For SBus cards, we just do this because they almost
 202                  * certainly will be running firmware by now.
 203                  */
 204                 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
 205                     ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
 206                     ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
 207                         /*
 208                          * Just in case it was paused...
 209                          */
 210                         if (IS_24XX(isp)) {
 211                                 ISP_WRITE(isp, BIU2400_HCCR,
 212                                     HCCR_2400_CMD_RELEASE);
 213                         } else {
 214                                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 215                         }
 216                         MEMZERO(&mbs, sizeof (mbs));
 217                         mbs.param[0] = MBOX_ABOUT_FIRMWARE;
 218                         mbs.logval = MBLOGNONE;
 219                         isp_mboxcmd(isp, &mbs);
 220                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 221                                 isp->isp_romfw_rev[0] = mbs.param[1];
 222                                 isp->isp_romfw_rev[1] = mbs.param[2];
 223                                 isp->isp_romfw_rev[2] = mbs.param[3];
 224                         }
 225                 }
 226                 isp->isp_touched = 1;
 227         }
 228
 229         ISP_DISABLE_INTS(isp);
 230
 231         /*
 232          * Pick an initial maxcmds value which will be used
 233          * to allocate xflist pointer space. It may be changed
 234          * later by the firmware.
 235          */
 236         if (IS_24XX(isp)) {
 237                 isp->isp_maxcmds = 4096;
 238         } else if (IS_2322(isp)) {
 239                 isp->isp_maxcmds = 2048;
 240         } else if (IS_23XX(isp) || IS_2200(isp)) {
 241                 isp->isp_maxcmds = 1024;
 242         } else {
 243                 isp->isp_maxcmds = 512;
 244         }
 245
 246         /*
 247          * Set up DMA for the request and result queues.
 248          *
 249          * We do this now so we can use the request queue
 250          * for a dma
 251          */
 252         if (ISP_MBOXDMASETUP(isp) != 0) {
 253                 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
 254                 return;
 255         }
 256
 257
 258         /*
 259          * Set up default request/response queue in-pointer/out-pointer
 260          * register indices.
 261          */
 262         if (IS_24XX(isp)) {
 263                 isp->isp_rqstinrp = BIU2400_REQINP;
 264                 isp->isp_rqstoutrp = BIU2400_REQOUTP;
 265                 isp->isp_respinrp = BIU2400_RSPINP;
 266                 isp->isp_respoutrp = BIU2400_RSPOUTP;
 267                 isp->isp_atioinrp = BIU2400_ATIO_RSPINP;
 268                 isp->isp_atiooutrp = BIU2400_ATIO_REQINP;
 269         } else if (IS_23XX(isp)) {
 270                 isp->isp_rqstinrp = BIU_REQINP;
 271                 isp->isp_rqstoutrp = BIU_REQOUTP;
 272                 isp->isp_respinrp = BIU_RSPINP;
 273                 isp->isp_respoutrp = BIU_RSPOUTP;
 274         } else {
 275                 isp->isp_rqstinrp = INMAILBOX4;
 276                 isp->isp_rqstoutrp = OUTMAILBOX4;
 277                 isp->isp_respinrp = OUTMAILBOX5;
 278                 isp->isp_respoutrp = INMAILBOX5;
 279         }
 280
 281         /*
 282          * Put the board into PAUSE mode (so we can read the SXP registers
 283          * or write FPM/FBM registers).
 284          */
 285         if (IS_24XX(isp)) {
 286                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_HOST_INT);
 287                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
 288                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_PAUSE);
 289         } else {
 290                 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 291         }
 292
 293         if (IS_FC(isp)) {
 294                 switch (isp->isp_type) {
 295                 case ISP_HA_FC_2100:
 296                         btype = "2100";
 297                         break;
 298                 case ISP_HA_FC_2200:
 299                         btype = "2200";
 300                         break;
 301                 case ISP_HA_FC_2300:
 302                         btype = "2300";
 303                         break;
 304                 case ISP_HA_FC_2312:
 305                         btype = "2312";
 306                         break;
 307                 case ISP_HA_FC_2322:
 308                         btype = "2322";
 309                         break;
 310                 case ISP_HA_FC_2400:
 311                         btype = "2422";
 312                         break;
 313                 default:
 314                         break;
 315                 }
 316
 317                 if (!IS_24XX(isp)) {
 318                         /*
 319                          * While we're paused, reset the FPM module and FBM
 320                          * fifos.
 321                          */
 322                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
 323                         ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
 324                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
 325                         ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
 326                         ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
 327                 }
 328         } else if (IS_1240(isp)) {
 329                 sdparam *sdp = isp->isp_param;
 330                 btype = "1240";
 331                 isp->isp_clock = 60;
 332                 sdp->isp_ultramode = 1;
 333                 sdp++;
 334                 sdp->isp_ultramode = 1;
 335                 /*
 336                  * XXX: Should probably do some bus sensing.
 337                  */
 338         } else if (IS_ULTRA2(isp)) {
 339                 static const char m[] = "bus %d is in %s Mode";
 340                 uint16_t l;
 341                 sdparam *sdp = isp->isp_param;
 342
 343                 isp->isp_clock = 100;
 344
 345                 if (IS_1280(isp))
 346                         btype = "1280";
 347                 else if (IS_1080(isp))
 348                         btype = "1080";
 349                 else if (IS_10160(isp))
 350                         btype = "10160";
 351                 else if (IS_12160(isp))
 352                         btype = "12160";
 353                 else
 354                         btype = "<UNKLVD>";
 355
 356                 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
 357                 switch (l) {
 358                 case ISP1080_LVD_MODE:
 359                         sdp->isp_lvdmode = 1;
 360                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
 361                         break;
 362                 case ISP1080_HVD_MODE:
 363                         sdp->isp_diffmode = 1;
 364                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
 365                         break;
 366                 case ISP1080_SE_MODE:
 367                         sdp->isp_ultramode = 1;
 368                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
 369                         break;
 370                 default:
 371                         isp_prt(isp, ISP_LOGERR,
 372                             "unknown mode on bus %d (0x%x)", 0, l);
 373                         break;
 374                 }
 375
 376                 if (IS_DUALBUS(isp)) {
 377                         sdp++;
 378                         l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
 379                         l &= ISP1080_MODE_MASK;
 380                         switch(l) {
 381                         case ISP1080_LVD_MODE:
 382                                 sdp->isp_lvdmode = 1;
 383                                 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
 384                                 break;
 385                         case ISP1080_HVD_MODE:
 386                                 sdp->isp_diffmode = 1;
 387                                 isp_prt(isp, ISP_LOGCONFIG,
 388                                     m, 1, "Differential");
 389                                 break;
 390                         case ISP1080_SE_MODE:
 391                                 sdp->isp_ultramode = 1;
 392                                 isp_prt(isp, ISP_LOGCONFIG,
 393                                     m, 1, "Single-Ended");
 394                                 break;
 395                         default:
 396                                 isp_prt(isp, ISP_LOGERR,
 397                                     "unknown mode on bus %d (0x%x)", 1, l);
 398                                 break;
 399                         }
 400                 }
 401         } else {
 402                 sdparam *sdp = isp->isp_param;
 403                 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
 404                 switch (i) {
 405                 default:
 406                         isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
 407                         /* FALLTHROUGH */
 408                 case 1:
 409                         btype = "1020";
 410                         isp->isp_type = ISP_HA_SCSI_1020;
 411                         isp->isp_clock = 40;
 412                         break;
 413                 case 2:
 414                         /*
 415                          * Some 1020A chips are Ultra Capable, but don't
 416                          * run the clock rate up for that unless told to
 417                          * do so by the Ultra Capable bits being set.
 418                          */
 419                         btype = "1020A";
 420                         isp->isp_type = ISP_HA_SCSI_1020A;
 421                         isp->isp_clock = 40;
 422                         break;
 423                 case 3:
 424                         btype = "1040";
 425                         isp->isp_type = ISP_HA_SCSI_1040;
 426                         isp->isp_clock = 60;
 427                         break;
 428                 case 4:
 429                         btype = "1040A";
 430                         isp->isp_type = ISP_HA_SCSI_1040A;
 431                         isp->isp_clock = 60;
 432                         break;
 433                 case 5:
 434                         btype = "1040B";
 435                         isp->isp_type = ISP_HA_SCSI_1040B;
 436                         isp->isp_clock = 60;
 437                         break;
 438                 case 6:
 439                         btype = "1040C";
 440                         isp->isp_type = ISP_HA_SCSI_1040C;
 441                         isp->isp_clock = 60;
 442                         break;
 443                 }
 444                 /*
 445                  * Now, while we're at it, gather info about ultra
 446                  * and/or differential mode.
 447                  */
 448                 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
 449                         isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
 450                         sdp->isp_diffmode = 1;
 451                 } else {
 452                         sdp->isp_diffmode = 0;
 453                 }
 454                 i = ISP_READ(isp, RISC_PSR);
 455                 if (isp->isp_bustype == ISP_BT_SBUS) {
 456                         i &= RISC_PSR_SBUS_ULTRA;
 457                 } else {
 458                         i &= RISC_PSR_PCI_ULTRA;
 459                 }
 460                 if (i != 0) {
 461                         isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
 462                         sdp->isp_ultramode = 1;
 463                         /*
 464                          * If we're in Ultra Mode, we have to be 60MHz clock-
 465                          * even for the SBus version.
 466                          */
 467                         isp->isp_clock = 60;
 468                 } else {
 469                         sdp->isp_ultramode = 0;
 470                         /*
 471                          * Clock is known. Gronk.
 472                          */
 473                 }
 474
 475                 /*
 476                  * Machine dependent clock (if set) overrides
 477                  * our generic determinations.
 478                  */
 479                 if (isp->isp_mdvec->dv_clock) {
 480                         if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
 481                                 isp->isp_clock = isp->isp_mdvec->dv_clock;
 482                         }
 483                 }
 484
 485         }
 486
 487         /*
 488          * Clear instrumentation
 489          */
 490         isp->isp_intcnt = isp->isp_intbogus = 0;
 491
 492         /*
 493          * Do MD specific pre initialization
 494          */
 495         ISP_RESET0(isp);
 496
 497         /*
 498          * Hit the chip over the head with hammer,
 499          * and give the ISP a chance to recover.
 500          */
 501
 502         if (IS_SCSI(isp)) {
 503                 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
 504                 /*
 505                  * A slight delay...
 506                  */
 507                 USEC_DELAY(100);
 508
 509                 /*
 510                  * Clear data && control DMA engines.
 511                  */
 512                 ISP_WRITE(isp, CDMA_CONTROL,
 513                     DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 514                 ISP_WRITE(isp, DDMA_CONTROL,
 515                     DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 516
 517
 518         } else if (IS_24XX(isp)) {
 519                 /*
 520                  * Stop DMA and wait for it to stop.
 521                  */
 522                 ISP_WRITE(isp, BIU2400_CSR, BIU2400_DMA_STOP|(3 << 4));
 523                 for (val = loops = 0; loops < 30000; loops++) {
 524                         USEC_DELAY(10);
 525                         val = ISP_READ(isp, BIU2400_CSR);
 526                         if ((val & BIU2400_DMA_ACTIVE) == 0) {
 527                                 break;
 528                         }
 529                 }
 530                 if (val & BIU2400_DMA_ACTIVE) {
 531                         ISP_RESET0(isp);
 532                         isp_prt(isp, ISP_LOGERR, "DMA Failed to Stop on Reset");
 533                         return;
 534                 }
 535                 /*
 536                  * Hold it in SOFT_RESET and STOP state for 100us.
 537                  */
 538                 ISP_WRITE(isp, BIU2400_CSR,
 539                     BIU2400_SOFT_RESET|BIU2400_DMA_STOP|(3 << 4));
 540                 USEC_DELAY(100);
 541                 for (loops = 0; loops < 10000; loops++) {
 542                         USEC_DELAY(5);
 543                         val = ISP_READ(isp, OUTMAILBOX0);
 544                 }
 545                 for (val = loops = 0; loops < 500000; loops ++) {
 546                         val = ISP_READ(isp, BIU2400_CSR);
 547                         if ((val & BIU2400_SOFT_RESET) == 0) {
 548                                 break;
 549                         }
 550                 }
 551                 if (val & BIU2400_SOFT_RESET) {
 552                         ISP_RESET0(isp);
 553                         isp_prt(isp, ISP_LOGERR, "Failed to come out of reset");
 554                         return;
 555                 }
 556         } else {
 557                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 558                 /*
 559                  * A slight delay...
 560                  */
 561                 USEC_DELAY(100);
 562
 563                 /*
 564                  * Clear data && control DMA engines.
 565                  */
 566                 ISP_WRITE(isp, CDMA2100_CONTROL,
 567                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 568                 ISP_WRITE(isp, TDMA2100_CONTROL,
 569                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 570                 ISP_WRITE(isp, RDMA2100_CONTROL,
 571                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 572         }
 573
 574         /*
 575          * Wait for ISP to be ready to go...
 576          */
 577         loops = MBOX_DELAY_COUNT;
 578         for (;;) {
 579                 if (IS_SCSI(isp)) {
 580                         if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) {
 581                                 break;
 582                         }
 583                 } else if (IS_24XX(isp)) {
 584                         if (ISP_READ(isp, OUTMAILBOX0) == 0) {
 585                                 break;
 586                         }
 587                 } else {
 588                         if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
 589                                 break;
 590                 }
 591                 USEC_DELAY(100);
 592                 if (--loops < 0) {
 593                         ISP_DUMPREGS(isp, "chip reset timed out");
 594                         ISP_RESET0(isp);
 595                         return;
 596                 }
 597         }
 598
 599         /*
 600          * After we've fired this chip up, zero out the conf1 register
 601          * for SCSI adapters and other settings for the 2100.
 602          */
 603
 604         if (IS_SCSI(isp)) {
 605                 ISP_WRITE(isp, BIU_CONF1, 0);
 606         } else if (!IS_24XX(isp)) {
 607                 ISP_WRITE(isp, BIU2100_CSR, 0);
 608         }
 609
 610         /*
 611          * Reset RISC Processor
 612          */
 613         if (IS_24XX(isp)) {
 614                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RESET);
 615                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_RELEASE);
 616                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RESET);
 617         } else {
 618                 ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
 619                 USEC_DELAY(100);
 620                 ISP_WRITE(isp, BIU_SEMA, 0);
 621         }
 622
 623
 624         /*
 625          * Post-RISC Reset stuff.
 626          */
 627         if (IS_24XX(isp)) {
 628                 for (val = loops = 0; loops < 5000000; loops++) {
 629                         USEC_DELAY(5);
 630                         val = ISP_READ(isp, OUTMAILBOX0);
 631                         if (val == 0) {
 632                                 break;
 633                         }
 634                 }
 635                 if (val != 0) {
 636                         ISP_RESET0(isp);
 637                         isp_prt(isp, ISP_LOGERR, "reset didn't clear");
 638                         return;
 639                 }
 640         } else if (IS_SCSI(isp)) {
 641                 uint16_t tmp = isp->isp_mdvec->dv_conf1;
 642                 /*
 643                  * Busted FIFO. Turn off all but burst enables.
 644                  */
 645                 if (isp->isp_type == ISP_HA_SCSI_1040A) {
 646                         tmp &= BIU_BURST_ENABLE;
 647                 }
 648                 ISP_SETBITS(isp, BIU_CONF1, tmp);
 649                 if (tmp & BIU_BURST_ENABLE) {
 650                         ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
 651                         ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
 652                 }
 653                 if (SDPARAM(isp)->isp_ptisp) {
 654                         if (SDPARAM(isp)->isp_ultramode) {
 655                                 while (ISP_READ(isp, RISC_MTR) != 0x1313) {
 656                                         ISP_WRITE(isp, RISC_MTR, 0x1313);
 657                                         ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
 658                                 }
 659                         } else {
 660                                 ISP_WRITE(isp, RISC_MTR, 0x1212);
 661                         }
 662                         /*
 663                          * PTI specific register
 664                          */
 665                         ISP_WRITE(isp, RISC_EMB, DUAL_BANK);
 666                 } else {
 667                         ISP_WRITE(isp, RISC_MTR, 0x1212);
 668                 }
 669                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 670         } else {
 671                 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
 672                 if (IS_2200(isp) || IS_23XX(isp)) {
 673                         ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
 674                 }
 675                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 676         }
 677
 678         ISP_WRITE(isp, isp->isp_rqstinrp, 0);
 679         ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
 680         ISP_WRITE(isp, isp->isp_respinrp, 0);
 681         ISP_WRITE(isp, isp->isp_respoutrp, 0);
 682
 683
 684         /*
 685          * Do MD specific post initialization
 686          */
 687         ISP_RESET1(isp);
 688
 689         /*
 690          * Wait for everything to finish firing up.
 691          *
 692          * Avoid doing this on the 2312 because you can generate a PCI
 693          * parity error (chip breakage).
 694          */
 695         if (IS_2312(isp)) {
 696                 USEC_DELAY(100);
 697         } else {
 698                 loops = MBOX_DELAY_COUNT;
 699                 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
 700                         USEC_DELAY(100);
 701                         if (--loops < 0) {
 702                                 ISP_RESET0(isp);
 703                                 isp_prt(isp, ISP_LOGERR,
 704                                     "MBOX_BUSY never cleared on reset");
 705                                 return;
 706                         }
 707                 }
 708         }
 709
 710         /*
 711          * Up until this point we've done everything by just reading or
 712          * setting registers. From this point on we rely on at least *some*
 713          * kind of firmware running in the card.
 714          */
 715
 716         /*
 717          * Do some sanity checking.
 718          */
 719         MEMZERO(&mbs, sizeof (mbs));
 720         mbs.param[0] = MBOX_NO_OP;
 721         mbs.logval = MBLOGALL;
 722         isp_mboxcmd(isp, &mbs);
 723         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 724                 ISP_RESET0(isp);
 725                 return;
 726         }
 727
 728         if (IS_SCSI(isp) || IS_24XX(isp)) {
 729                 MEMZERO(&mbs, sizeof (mbs));
 730                 mbs.param[0] = MBOX_MAILBOX_REG_TEST;
 731                 mbs.param[1] = 0xdead;
 732                 mbs.param[2] = 0xbeef;
 733                 mbs.param[3] = 0xffff;
 734                 mbs.param[4] = 0x1111;
 735                 mbs.param[5] = 0xa5a5;
 736                 mbs.param[6] = 0x0000;
 737                 mbs.param[7] = 0x0000;
 738                 mbs.logval = MBLOGALL;
 739                 isp_mboxcmd(isp, &mbs);
 740                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 741                         ISP_RESET0(isp);
 742                         return;
 743                 }
 744                 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
 745                     mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
 746                     mbs.param[5] != 0xa5a5) {
 747                         ISP_RESET0(isp);
 748                         isp_prt(isp, ISP_LOGERR,
 749                             "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
 750                             mbs.param[1], mbs.param[2], mbs.param[3],
 751                             mbs.param[4], mbs.param[5]);
 752                         return;
 753                 }
 754
 755         }
 756
 757         /*
 758          * Download new Firmware, unless requested not to do so.
 759          * This is made slightly trickier in some cases where the
 760          * firmware of the ROM revision is newer than the revision
 761          * compiled into the driver. So, where we used to compare
 762          * versions of our f/w and the ROM f/w, now we just see
 763          * whether we have f/w at all and whether a config flag
 764          * has disabled our download.
 765          */
 766         if ((isp->isp_mdvec->dv_ispfw == NULL) ||
 767             (isp->isp_confopts & ISP_CFG_NORELOAD)) {
 768                 dodnld = 0;
 769         }
 770
 771         if (IS_24XX(isp)) {
 772                 code_org = ISP_CODE_ORG_2400;
 773         } else if (IS_23XX(isp)) {
 774                 code_org = ISP_CODE_ORG_2300;
 775         } else {
 776                 code_org = ISP_CODE_ORG;
 777         }
 778
 779         if (dodnld && IS_24XX(isp)) {
 780                 const uint32_t *ptr = isp->isp_mdvec->dv_ispfw;
 781
 782                 /*
 783                  * NB: Whatever you do do, do *not* issue the VERIFY FIRMWARE
 784                  * NB: command to the 2400 while loading new firmware. This
 785                  * NB: causes the new f/w to start and immediately crash back
 786                  * NB: to the ROM.
 787                  */
 788
 789                 /*
 790                  * Keep loading until we run out of f/w.
 791                  */
 792                 code_org = ptr[2];      /* 1st load address is our start addr */
 793
 794                 for (;;) {
 795                         uint32_t la, wi, wl;
 796
 797                         isp_prt(isp, ISP_LOGDEBUG0,
 798                             "load 0x%x words of code at load address 0x%x",
 799                             ptr[3], ptr[2]);
 800
 801                         wi = 0;
 802                         la = ptr[2];
 803                         wl = ptr[3];
 804
 805                         while (wi < ptr[3]) {
 806                                 uint32_t *cp;
 807                                 uint32_t nw;
 808
 809                                 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 2;
 810                                 if (nw > wl) {
 811                                         nw = wl;
 812                                 }
 813                                 cp = isp->isp_rquest;
 814                                 for (i = 0; i < nw; i++) {
 815                                         ISP_IOXPUT_32(isp,  ptr[wi++], &cp[i]);
 816                                         wl--;
 817                                 }
 818                                 MEMORYBARRIER(isp, SYNC_REQUEST,
 819                                     0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
 820                                 MEMZERO(&mbs, sizeof (mbs));
 821                                 mbs.param[0] = MBOX_LOAD_RISC_RAM;
 822                                 mbs.param[1] = la;
 823                                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 824                                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 825                                 mbs.param[4] = nw >> 16;
 826                                 mbs.param[5] = nw;
 827                                 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 828                                 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 829                                 mbs.param[8] = la >> 16;
 830                                 mbs.logval = MBLOGALL;
 831                                 isp_mboxcmd(isp, &mbs);
 832                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 833                                         isp_prt(isp, ISP_LOGERR,
 834                                             "F/W Risc Ram Load Failed");
 835                                         ISP_RESET0(isp);
 836                                         return;
 837                                 }
 838                                 la += nw;
 839                         }
 840
 841                         if (ptr[1] == 0) {
 842                                 break;
 843                         }
 844                         ptr += ptr[3];
 845                 }
 846                 isp->isp_loaded_fw = 1;
 847         } else if (dodnld && IS_23XX(isp)) {
 848                 const uint16_t *ptr = isp->isp_mdvec->dv_ispfw;
 849                 uint16_t wi, wl, segno;
 850                 uint32_t la;
 851
 852                 la = code_org;
 853                 segno = 0;
 854
 855                 for (;;) {
 856                         uint32_t nxtaddr;
 857
 858                         isp_prt(isp, ISP_LOGDEBUG0,
 859                             "load 0x%x words of code at load address 0x%x",
 860                             ptr[3], la);
 861
 862                         wi = 0;
 863                         wl = ptr[3];
 864
 865                         while (wi < ptr[3]) {
 866                                 uint16_t *cp;
 867                                 uint32_t nw;
 868
 869                                 nw = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)) >> 1;
 870                                 if (nw > wl) {
 871                                         nw = wl;
 872                                 }
 873                                 if (nw > (1 << 15)) {
 874                                         nw = 1 << 15;
 875                                 }
 876                                 cp = isp->isp_rquest;
 877                                 for (i = 0; i < nw; i++) {
 878                                         ISP_IOXPUT_16(isp,  ptr[wi++], &cp[i]);
 879                                         wl--;
 880                                 }
 881                                 MEMORYBARRIER(isp, SYNC_REQUEST,
 882                                     0, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
 883                                 MEMZERO(&mbs, sizeof (mbs));
 884                                 mbs.param[0] = MBOX_LOAD_RISC_RAM;
 885                                 mbs.param[1] = la;
 886                                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 887                                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 888                                 mbs.param[4] = nw;
 889                                 mbs.param[6] = DMA_WD3(isp->isp_rquest_dma);
 890                                 mbs.param[7] = DMA_WD2(isp->isp_rquest_dma);
 891                                 mbs.param[8] = la >> 16;
 892                                 mbs.logval = MBLOGALL;
 893                                 isp_mboxcmd(isp, &mbs);
 894                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 895                                         isp_prt(isp, ISP_LOGERR,
 896                                             "F/W Risc Ram Load Failed");
 897                                         ISP_RESET0(isp);
 898                                         return;
 899                                 }
 900                                 la += nw;
 901                         }
 902
 903                         if (!IS_2322(isp)) {
 904                                 /*
 905                                  * Verify that it downloaded correctly.
 906                                  */
 907                                 MEMZERO(&mbs, sizeof (mbs));
 908                                 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
 909                                 mbs.param[1] = code_org;
 910                                 mbs.logval = MBLOGNONE;
 911                                 isp_mboxcmd(isp, &mbs);
 912                                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 913                                         isp_prt(isp, ISP_LOGERR, dcrc);
 914                                         ISP_RESET0(isp);
 915                                         return;
 916                                 }
 917                                 break;
 918                         }
 919
 920                         if (++segno == 3) {
 921                                 break;
 922                         }
 923
 924                         /*
 925                          * If we're a 2322, the firmware actually comes in
 926                          * three chunks. We loaded the first at the code_org
 927                          * address. The other two chunks, which follow right
 928                          * after each other in memory here, get loaded at
 929                          * addresses specfied at offset 0x9..0xB.
 930                          */
 931
 932                         nxtaddr = ptr[3];
 933                         ptr = &ptr[nxtaddr];
 934                         la = ptr[5] | ((ptr[4] & 0x3f) << 16);
 935                 }
 936                 isp->isp_loaded_fw = 1;
 937         } else if (dodnld) {
 938                 union {
 939                         const uint16_t *cp;
 940                         uint16_t *np;
 941                 } u;
 942                 u.cp = isp->isp_mdvec->dv_ispfw;
 943                 isp->isp_mbxworkp = &u.np[1];
 944                 isp->isp_mbxwrk0 = u.np[3] - 1;
 945                 isp->isp_mbxwrk1 = code_org + 1;
 946                 MEMZERO(&mbs, sizeof (mbs));
 947                 mbs.param[0] = MBOX_WRITE_RAM_WORD;
 948                 mbs.param[1] = code_org;
 949                 mbs.param[2] = u.np[0];
 950                 mbs.logval = MBLOGNONE;
 951                 isp_mboxcmd(isp, &mbs);
 952                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 953                         isp_prt(isp, ISP_LOGERR,
 954                             "F/W download failed at word %d",
 955                             isp->isp_mbxwrk1 - code_org);
 956                         ISP_RESET0(isp);
 957                         return;
 958                 }
 959                 /*
 960                  * Verify that it downloaded correctly.
 961                  */
 962                 MEMZERO(&mbs, sizeof (mbs));
 963                 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
 964                 mbs.param[1] = code_org;
 965                 mbs.logval = MBLOGNONE;
 966                 isp_mboxcmd(isp, &mbs);
 967                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 968                         isp_prt(isp, ISP_LOGERR, dcrc);
 969                         ISP_RESET0(isp);
 970                         return;
 971                 }
 972                 isp->isp_loaded_fw = 1;
 973         } else {
 974                 isp->isp_loaded_fw = 0;
 975                 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
 976         }
 977
 978         /*
 979          * Now start it rolling.
 980          *
 981          * If we didn't actually download f/w,
 982          * we still need to (re)start it.
 983          */
 984
 985
 986         MEMZERO(&mbs, sizeof (mbs));
 987         mbs.timeout = 1000000;
 988         mbs.param[0] = MBOX_EXEC_FIRMWARE;
 989         if (IS_24XX(isp)) {
 990                 mbs.param[1] = code_org >> 16;
 991                 mbs.param[2] = code_org;
 992                 if (isp->isp_loaded_fw) {
 993                         mbs.param[3] = 0;
 994                 } else {
 995                         mbs.param[3] = 1;
 996                 }
 997         } else if (IS_2322(isp)) {
 998                 mbs.param[1] = code_org;
 999                 if (isp->isp_loaded_fw) {
1000                         mbs.param[2] = 0;
1001                 } else {
1002                         mbs.param[2] = 1;
1003                 }
1004         } else {
1005                 mbs.param[1] = code_org;
1006         }
1007
1008         mbs.logval = MBLOGALL;
1009         isp_mboxcmd(isp, &mbs);
1010         if (IS_2322(isp) || IS_24XX(isp)) {
1011                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1012                         ISP_RESET0(isp);
1013                         return;
1014                 }
1015         }
1016
1017         /*
1018          * Give it a chance to finish starting up.
1019          */
1020         USEC_DELAY(250000);
1021
1022         if (IS_SCSI(isp)) {
1023                 /*
1024                  * Set CLOCK RATE, but only if asked to.
1025                  */
1026                 if (isp->isp_clock) {
1027                         mbs.param[0] = MBOX_SET_CLOCK_RATE;
1028                         mbs.param[1] = isp->isp_clock;
1029                         mbs.logval = MBLOGNONE;
1030                         isp_mboxcmd(isp, &mbs);
1031                         /* we will try not to care if this fails */
1032                 }
1033         }
1034
1035         MEMZERO(&mbs, sizeof (mbs));
1036         mbs.param[0] = MBOX_ABOUT_FIRMWARE;
1037         mbs.logval = MBLOGALL;
1038         isp_mboxcmd(isp, &mbs);
1039         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1040                 ISP_RESET0(isp);
1041                 return;
1042         }
1043
1044         if (IS_24XX(isp) && mbs.param[1] == 0xdead) {
1045                 isp_prt(isp, ISP_LOGERR, "f/w didn't *really* start");
1046                 ISP_RESET0(isp);
1047                 return;
1048         }
1049
1050         /*
1051          * The SBus firmware that we are using apparently does not return
1052          * major, minor, micro revisions in the mailbox registers, which
1053          * is really, really, annoying.
1054          */
1055         if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
1056                 if (dodnld) {
1057 #ifdef  ISP_TARGET_MODE
1058                         isp->isp_fwrev[0] = 7;
1059                         isp->isp_fwrev[1] = 55;
1060 #else
1061                         isp->isp_fwrev[0] = 1;
1062                         isp->isp_fwrev[1] = 37;
1063 #endif
1064                         isp->isp_fwrev[2] = 0;
1065                 }
1066         } else {
1067                 isp->isp_fwrev[0] = mbs.param[1];
1068                 isp->isp_fwrev[1] = mbs.param[2];
1069                 isp->isp_fwrev[2] = mbs.param[3];
1070         }
1071
1072         isp_prt(isp, ISP_LOGALL,
1073             "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
1074             btype, isp->isp_revision, dodnld? "loaded" : "resident",
1075             isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
1076
1077         if (IS_FC(isp)) {
1078                 /*
1079                  * We do not believe firmware attributes for 2100 code less
1080                  * than 1.17.0, unless it's the firmware we specifically
1081                  * are loading.
1082                  *
1083                  * Note that all 22XX and later f/w is greater than 1.X.0.
1084                  */
1085                 if ((ISP_FW_OLDER_THAN(isp, 1, 17, 1))) {
1086 #ifdef  USE_SMALLER_2100_FIRMWARE
1087                         FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
1088 #else
1089                         FCPARAM(isp)->isp_fwattr = 0;
1090 #endif
1091                 } else {
1092                         FCPARAM(isp)->isp_fwattr = mbs.param[6];
1093                         isp_prt(isp, ISP_LOGDEBUG0,
1094                             "Firmware Attributes = 0x%x", mbs.param[6]);
1095                 }
1096                 FCPARAM(isp)->isp_2klogin = 0;
1097                 FCPARAM(isp)->isp_sccfw = 0;
1098                 FCPARAM(isp)->isp_tmode = 0;
1099                 if (IS_24XX(isp)) {
1100                         FCPARAM(isp)->isp_2klogin = 1;
1101                         FCPARAM(isp)->isp_sccfw = 1;
1102                         FCPARAM(isp)->isp_tmode = 1;
1103                 } else {
1104                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
1105                                 FCPARAM(isp)->isp_sccfw = 1;
1106                         }
1107                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_2KLOGINS) {
1108                                 FCPARAM(isp)->isp_2klogin = 1;
1109                                 FCPARAM(isp)->isp_sccfw = 1;
1110                         }
1111                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_TMODE) {
1112                                 FCPARAM(isp)->isp_tmode = 1;
1113                         }
1114                 }
1115                 if (FCPARAM(isp)->isp_2klogin) {
1116                         isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported");
1117                 }
1118         }
1119
1120         if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
1121             isp->isp_romfw_rev[2]) {
1122                 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
1123                     isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
1124                     isp->isp_romfw_rev[2]);
1125         }
1126
1127         if (!IS_24XX(isp)) {
1128                 MEMZERO(&mbs, sizeof (mbs));
1129                 mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
1130                 mbs.logval = MBLOGALL;
1131                 isp_mboxcmd(isp, &mbs);
1132                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1133                         ISP_RESET0(isp);
1134                         return;
1135                 }
1136                 if (isp->isp_maxcmds >= mbs.param[2]) {
1137                         isp->isp_maxcmds = mbs.param[2];
1138                 }
1139         }
1140         isp_prt(isp, ISP_LOGCONFIG,
1141             "%d max I/O command limit set", isp->isp_maxcmds);
1142         isp_fw_state(isp);
1143
1144         isp->isp_state = ISP_RESETSTATE;
1145
1146         /*
1147          * Okay- now that we have new firmware running, we now (re)set our
1148          * notion of how many luns we support. This is somewhat tricky because
1149          * if we haven't loaded firmware, we sometimes do not have an easy way
1150          * of knowing how many luns we support.
1151          *
1152          * Expanded lun firmware gives you 32 luns for SCSI cards and
1153          * 16384 luns for Fibre Channel cards.
1154          *
1155          * It turns out that even for QLogic 2100s with ROM 1.10 and above
1156          * we do get a firmware attributes word returned in mailbox register 6.
1157          *
1158          * Because the lun is in a different position in the Request Queue
1159          * Entry structure for Fibre Channel with expanded lun firmware, we
1160          * can only support one lun (lun zero) when we don't know what kind
1161          * of firmware we're running.
1162          */
1163         if (IS_SCSI(isp)) {
1164                 if (dodnld) {
1165                         if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
1166                                 isp->isp_maxluns = 32;
1167                         } else {
1168                                 isp->isp_maxluns = 8;
1169                         }
1170                 } else {
1171                         isp->isp_maxluns = 8;
1172                 }
1173         } else {
1174                 if (FCPARAM(isp)->isp_sccfw) {
1175                         isp->isp_maxluns = 16384;
1176                 } else {
1177                         isp->isp_maxluns = 16;
1178                 }
1179         }
1180         /*
1181          * Must do this first to get defaults established.
1182          */
1183         if (IS_SCSI(isp)) {
1184                 isp_setdfltparm(isp, 0);
1185                 if (IS_DUALBUS(isp)) {
1186                         isp_setdfltparm(isp, 1);
1187                 }
1188         } else {
1189                 isp_setdfltfcparm(isp);
1190         }
1191
1192 }
1193
1194 /*
1195  * Initialize Parameters of Hardware to a known state.
1196  *
1197  * Locks are held before coming here.
1198  */
1199
1200 void
1201 isp_init(ispsoftc_t *isp)
1202 {
1203         if (IS_FC(isp)) {
1204                 /*
1205                  * Do this *before* initializing the firmware.
1206                  */
1207                 ISP_MARK_PORTDB(isp, 0);
1208                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
1209                 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
1210
1211                 if (isp->isp_role != ISP_ROLE_NONE) {
1212                         if (IS_24XX(isp)) {
1213                                 isp_fibre_init_2400(isp);
1214                         } else {
1215                                 isp_fibre_init(isp);
1216                         }
1217                 }
1218         } else {
1219                 isp_scsi_init(isp);
1220         }
1221 }
1222
1223 static void
1224 isp_scsi_init(ispsoftc_t *isp)
1225 {
1226         sdparam *sdp_chan0, *sdp_chan1;
1227         mbreg_t mbs;
1228
1229         sdp_chan0 = isp->isp_param;
1230         sdp_chan1 = sdp_chan0;
1231         if (IS_DUALBUS(isp)) {
1232                 sdp_chan1++;
1233         }
1234
1235         /*
1236          * If we have no role (neither target nor initiator), return.
1237          */
1238         if (isp->isp_role == ISP_ROLE_NONE) {
1239                 return;
1240         }
1241
1242         /* First do overall per-card settings. */
1243
1244         /*
1245          * If we have fast memory timing enabled, turn it on.
1246          */
1247         if (sdp_chan0->isp_fast_mttr) {
1248                 ISP_WRITE(isp, RISC_MTR, 0x1313);
1249         }
1250
1251         /*
1252          * Set Retry Delay and Count.
1253          * You set both channels at the same time.
1254          */
1255         MEMZERO(&mbs, sizeof (mbs));
1256         mbs.param[0] = MBOX_SET_RETRY_COUNT;
1257         mbs.param[1] = sdp_chan0->isp_retry_count;
1258         mbs.param[2] = sdp_chan0->isp_retry_delay;
1259         mbs.param[6] = sdp_chan1->isp_retry_count;
1260         mbs.param[7] = sdp_chan1->isp_retry_delay;
1261         mbs.logval = MBLOGALL;
1262         isp_mboxcmd(isp, &mbs);
1263         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1264                 return;
1265         }
1266
1267         /*
1268          * Set ASYNC DATA SETUP time. This is very important.
1269          */
1270         MEMZERO(&mbs, sizeof (mbs));
1271         mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
1272         mbs.param[1] = sdp_chan0->isp_async_data_setup;
1273         mbs.param[2] = sdp_chan1->isp_async_data_setup;
1274         mbs.logval = MBLOGALL;
1275         isp_mboxcmd(isp, &mbs);
1276         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1277                 return;
1278         }
1279
1280         /*
1281          * Set ACTIVE Negation State.
1282          */
1283         MEMZERO(&mbs, sizeof (mbs));
1284         mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
1285         mbs.param[1] =
1286             (sdp_chan0->isp_req_ack_active_neg << 4) |
1287             (sdp_chan0->isp_data_line_active_neg << 5);
1288         mbs.param[2] =
1289             (sdp_chan1->isp_req_ack_active_neg << 4) |
1290             (sdp_chan1->isp_data_line_active_neg << 5);
1291         mbs.logval = MBLOGNONE;
1292         isp_mboxcmd(isp, &mbs);
1293         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1294                 isp_prt(isp, ISP_LOGERR,
1295                     "failed to set active negation state (%d,%d), (%d,%d)",
1296                     sdp_chan0->isp_req_ack_active_neg,
1297                     sdp_chan0->isp_data_line_active_neg,
1298                     sdp_chan1->isp_req_ack_active_neg,
1299                     sdp_chan1->isp_data_line_active_neg);
1300                 /*
1301                  * But don't return.
1302                  */
1303         }
1304
1305         /*
1306          * Set the Tag Aging limit
1307          */
1308         MEMZERO(&mbs, sizeof (mbs));
1309         mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
1310         mbs.param[1] = sdp_chan0->isp_tag_aging;
1311         mbs.param[2] = sdp_chan1->isp_tag_aging;
1312         mbs.logval = MBLOGALL;
1313         isp_mboxcmd(isp, &mbs);
1314         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1315                 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
1316                     sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
1317                 return;
1318         }
1319
1320         /*
1321          * Set selection timeout.
1322          */
1323         MEMZERO(&mbs, sizeof (mbs));
1324         mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
1325         mbs.param[1] = sdp_chan0->isp_selection_timeout;
1326         mbs.param[2] = sdp_chan1->isp_selection_timeout;
1327         mbs.logval = MBLOGALL;
1328         isp_mboxcmd(isp, &mbs);
1329         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1330                 return;
1331         }
1332
1333         /* now do per-channel settings */
1334         isp_scsi_channel_init(isp, 0);
1335         if (IS_DUALBUS(isp))
1336                 isp_scsi_channel_init(isp, 1);
1337
1338         /*
1339          * Now enable request/response queues
1340          */
1341
1342         if (IS_ULTRA2(isp) || IS_1240(isp)) {
1343                 MEMZERO(&mbs, sizeof (mbs));
1344                 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
1345                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1346                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1347                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1348                 mbs.param[4] = 0;
1349                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1350                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1351                 mbs.logval = MBLOGALL;
1352                 isp_mboxcmd(isp, &mbs);
1353                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1354                         return;
1355                 }
1356                 isp->isp_residx = mbs.param[5];
1357
1358                 MEMZERO(&mbs, sizeof (mbs));
1359                 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
1360                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1361                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1362                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1363                 mbs.param[5] = 0;
1364                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
1365                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
1366                 mbs.logval = MBLOGALL;
1367                 isp_mboxcmd(isp, &mbs);
1368                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1369                         return;
1370                 }
1371                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1372         } else {
1373                 MEMZERO(&mbs, sizeof (mbs));
1374                 mbs.param[0] = MBOX_INIT_RES_QUEUE;
1375                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
1376                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
1377                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
1378                 mbs.param[4] = 0;
1379                 mbs.logval = MBLOGALL;
1380                 isp_mboxcmd(isp, &mbs);
1381                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1382                         return;
1383                 }
1384                 isp->isp_residx = mbs.param[5];
1385
1386                 MEMZERO(&mbs, sizeof (mbs));
1387                 mbs.param[0] = MBOX_INIT_REQ_QUEUE;
1388                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1389                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1390                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1391                 mbs.param[5] = 0;
1392                 mbs.logval = MBLOGALL;
1393                 isp_mboxcmd(isp, &mbs);
1394                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1395                         return;
1396                 }
1397                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1398         }
1399
1400         /*
1401          * Turn on Fast Posting, LVD transitions
1402          *
1403          * Ultra2 F/W always has had fast posting (and LVD transitions)
1404          *
1405          * Ultra and older (i.e., SBus) cards may not. It's just safer
1406          * to assume not for them.
1407          */
1408
1409         MEMZERO(&mbs, sizeof (mbs));
1410         mbs.param[0] = MBOX_SET_FW_FEATURES;
1411         mbs.param[1] = 0;
1412         if (IS_ULTRA2(isp))
1413                 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1414 #ifndef ISP_NO_RIO
1415         if (IS_ULTRA2(isp) || IS_1240(isp))
1416                 mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1417 #else
1418         if (IS_ULTRA2(isp) || IS_1240(isp))
1419                 mbs.param[1] |= FW_FEATURE_FAST_POST;
1420 #endif
1421         if (mbs.param[1] != 0) {
1422                 uint16_t sfeat = mbs.param[1];
1423                 mbs.logval = MBLOGALL;
1424                 isp_mboxcmd(isp, &mbs);
1425                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1426                         isp_prt(isp, ISP_LOGINFO,
1427                             "Enabled FW features (0x%x)", sfeat);
1428                 }
1429         }
1430
1431         /*
1432          * Let the outer layers decide whether to issue a SCSI bus reset.
1433          */
1434         isp->isp_state = ISP_INITSTATE;
1435 }
1436
1437 static void
1438 isp_scsi_channel_init(ispsoftc_t *isp, int channel)
1439 {
1440         sdparam *sdp;
1441         mbreg_t mbs;
1442         int tgt;
1443
1444         sdp = isp->isp_param;
1445         sdp += channel;
1446
1447         /*
1448          * Set (possibly new) Initiator ID.
1449          */
1450         MEMZERO(&mbs, sizeof (mbs));
1451         mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1452         mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1453         mbs.logval = MBLOGALL;
1454         isp_mboxcmd(isp, &mbs);
1455         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1456                 return;
1457         }
1458         isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1459             sdp->isp_initiator_id, channel);
1460
1461
1462         /*
1463          * Set current per-target parameters to an initial safe minimum.
1464          */
1465         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1466                 int lun;
1467                 uint16_t sdf;
1468
1469                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1470                         continue;
1471                 }
1472 #ifndef ISP_TARGET_MODE
1473                 sdf = sdp->isp_devparam[tgt].goal_flags;
1474                 sdf &= DPARM_SAFE_DFLT;
1475                 /*
1476                  * It is not quite clear when this changed over so that
1477                  * we could force narrow and async for 1000/1020 cards,
1478                  * but assume that this is only the case for loaded
1479                  * firmware.
1480                  */
1481                 if (isp->isp_loaded_fw) {
1482                         sdf |= DPARM_NARROW | DPARM_ASYNC;
1483                 }
1484 #else
1485                 /*
1486                  * The !$*!)$!$)* f/w uses the same index into some
1487                  * internal table to decide how to respond to negotiations,
1488                  * so if we've said "let's be safe" for ID X, and ID X
1489                  * selects *us*, the negotiations will back to 'safe'
1490                  * (as in narrow/async). What the f/w *should* do is
1491                  * use the initiator id settings to decide how to respond.
1492                  */
1493                 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1494 #endif
1495                 MEMZERO(&mbs, sizeof (mbs));
1496                 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1497                 mbs.param[1] = (channel << 15) | (tgt << 8);
1498                 mbs.param[2] = sdf;
1499                 if ((sdf & DPARM_SYNC) == 0) {
1500                         mbs.param[3] = 0;
1501                 } else {
1502                         mbs.param[3] =
1503                             (sdp->isp_devparam[tgt].goal_offset << 8) |
1504                             (sdp->isp_devparam[tgt].goal_period);
1505                 }
1506                 isp_prt(isp, ISP_LOGDEBUG0,
1507                     "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1508                     channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1509                     mbs.param[3] & 0xff);
1510                 mbs.logval = MBLOGNONE;
1511                 isp_mboxcmd(isp, &mbs);
1512                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1513                         sdf = DPARM_SAFE_DFLT;
1514                         MEMZERO(&mbs, sizeof (mbs));
1515                         mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1516                         mbs.param[1] = (tgt << 8) | (channel << 15);
1517                         mbs.param[2] = sdf;
1518                         mbs.param[3] = 0;
1519                         mbs.logval = MBLOGALL;
1520                         isp_mboxcmd(isp, &mbs);
1521                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1522                                 continue;
1523                         }
1524                 }
1525
1526                 /*
1527                  * We don't update any information directly from the f/w
1528                  * because we need to run at least one command to cause a
1529                  * new state to be latched up. So, we just assume that we
1530                  * converge to the values we just had set.
1531                  *
1532                  * Ensure that we don't believe tagged queuing is enabled yet.
1533                  * It turns out that sometimes the ISP just ignores our
1534                  * attempts to set parameters for devices that it hasn't
1535                  * seen yet.
1536                  */
1537                 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1538                 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1539                         MEMZERO(&mbs, sizeof (mbs));
1540                         mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1541                         mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1542                         mbs.param[2] = sdp->isp_max_queue_depth;
1543                         mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1544                         mbs.logval = MBLOGALL;
1545                         isp_mboxcmd(isp, &mbs);
1546                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1547                                 break;
1548                         }
1549                 }
1550         }
1551         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1552                 if (sdp->isp_devparam[tgt].dev_refresh) {
1553                         isp->isp_sendmarker |= (1 << channel);
1554                         isp->isp_update |= (1 << channel);
1555                         break;
1556                 }
1557         }
1558 }
1559
1560 /*
1561  * Fibre Channel specific initialization.
1562  */
1563 static void
1564 isp_fibre_init(ispsoftc_t *isp)
1565 {
1566         fcparam *fcp;
1567         isp_icb_t local, *icbp = &local;
1568         mbreg_t mbs;
1569         int ownloopid;
1570         uint64_t nwwn, pwwn;
1571
1572         fcp = isp->isp_param;
1573
1574         MEMZERO(icbp, sizeof (*icbp));
1575         icbp->icb_version = ICB_VERSION1;
1576         icbp->icb_fwoptions = fcp->isp_fwoptions;
1577
1578         /*
1579          * Firmware Options are either retrieved from NVRAM or
1580          * are patched elsewhere. We check them for sanity here
1581          * and make changes based on board revision, but otherwise
1582          * let others decide policy.
1583          */
1584
1585         /*
1586          * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1587          */
1588         if (IS_2100(isp) && isp->isp_revision < 5) {
1589                 icbp->icb_fwoptions &= ~ICBOPT_FAIRNESS;
1590         }
1591
1592         /*
1593          * We have to use FULL LOGIN even though it resets the loop too much
1594          * because otherwise port database entries don't get updated after
1595          * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1596          */
1597         if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1598                 icbp->icb_fwoptions |= ICBOPT_FULL_LOGIN;
1599         }
1600
1601         /*
1602          * Insist on Port Database Update Async notifications
1603          */
1604         icbp->icb_fwoptions |= ICBOPT_PDBCHANGE_AE;
1605
1606         /*
1607          * Make sure that target role reflects into fwoptions.
1608          */
1609         if (isp->isp_role & ISP_ROLE_TARGET) {
1610                 icbp->icb_fwoptions |= ICBOPT_TGT_ENABLE;
1611         } else {
1612                 icbp->icb_fwoptions &= ~ICBOPT_TGT_ENABLE;
1613         }
1614
1615         if (isp->isp_role & ISP_ROLE_INITIATOR) {
1616                 icbp->icb_fwoptions &= ~ICBOPT_INI_DISABLE;
1617         } else {
1618                 icbp->icb_fwoptions |= ICBOPT_INI_DISABLE;
1619         }
1620
1621         icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1622         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1623             icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1624                 isp_prt(isp, ISP_LOGERR,
1625                     "bad frame length (%d) from NVRAM- using %d",
1626                     fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1627                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1628         }
1629         icbp->icb_maxalloc = fcp->isp_maxalloc;
1630         if (icbp->icb_maxalloc < 1) {
1631                 isp_prt(isp, ISP_LOGERR,
1632                     "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1633                 icbp->icb_maxalloc = 16;
1634         }
1635         icbp->icb_execthrottle = fcp->isp_execthrottle;
1636         if (icbp->icb_execthrottle < 1) {
1637                 isp_prt(isp, ISP_LOGERR,
1638                     "bad execution throttle of %d- using 16",
1639                     fcp->isp_execthrottle);
1640                 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1641         }
1642         icbp->icb_retry_delay = fcp->isp_retry_delay;
1643         icbp->icb_retry_count = fcp->isp_retry_count;
1644         icbp->icb_hardaddr = fcp->isp_loopid;
1645         ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1646         if (icbp->icb_hardaddr > 125) {
1647                 icbp->icb_hardaddr = 0;
1648                 ownloopid = 0;
1649         }
1650
1651         /*
1652          * Our life seems so much better with 2200s and later with
1653          * the latest f/w if we set Hard Address.
1654          */
1655         if (ownloopid || ISP_FW_NEWER_THAN(isp, 2, 2, 5)) {
1656                 icbp->icb_fwoptions |= ICBOPT_HARD_ADDRESS;
1657         }
1658
1659         /*
1660          * Right now we just set extended options to prefer point-to-point
1661          * over loop based upon some soft config options.
1662          *
1663          * NB: for the 2300, ICBOPT_EXTENDED is required.
1664          */
1665         if (IS_2200(isp) || IS_23XX(isp)) {
1666                 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1667                 /*
1668                  * Prefer or force Point-To-Point instead Loop?
1669                  */
1670                 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1671                 case ISP_CFG_NPORT:
1672                         icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1673                         break;
1674                 case ISP_CFG_NPORT_ONLY:
1675                         icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1676                         break;
1677                 case ISP_CFG_LPORT_ONLY:
1678                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1679                         break;
1680                 default:
1681                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1682                         break;
1683                 }
1684                 if (IS_2200(isp)) {
1685                         icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1686                 } else {
1687                         /*
1688                          * QLogic recommends that FAST Posting be turned
1689                          * off for 23XX cards and instead allow the HBA
1690                          * to write response queue entries and interrupt
1691                          * after a delay (ZIO).
1692                          */
1693                         icbp->icb_fwoptions &= ~ICBOPT_FAST_POST;
1694                         if ((fcp->isp_xfwoptions & ICBXOPT_TIMER_MASK) ==
1695                             ICBXOPT_ZIO) {
1696                                 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1697                                 icbp->icb_idelaytimer = 10;
1698                         }
1699                         if (isp->isp_confopts & ISP_CFG_ONEGB) {
1700                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1701                         } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1702                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1703                         } else {
1704                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1705                         }
1706                         if (fcp->isp_zfwoptions & ICBZOPT_50_OHM) {
1707                                 icbp->icb_zfwoptions |= ICBZOPT_50_OHM;
1708                         }
1709                 }
1710         }
1711
1712
1713         /*
1714          * For 22XX > 2.1.26 && 23XX, set some options.
1715          * XXX: Probably okay for newer 2100 f/w too.
1716          */
1717         if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1718                 /*
1719                  * Turn on LIP F8 async event (1)
1720                  * Turn on generate AE 8013 on all LIP Resets (2)
1721                  * Disable LIP F7 switching (8)
1722                  */
1723                 MEMZERO(&mbs, sizeof (mbs));
1724                 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1725                 mbs.param[1] = 0xb;
1726                 mbs.param[2] = 0;
1727                 mbs.param[3] = 0;
1728                 mbs.logval = MBLOGALL;
1729                 isp_mboxcmd(isp, &mbs);
1730                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1731                         return;
1732                 }
1733         }
1734         icbp->icb_logintime = ICB_LOGIN_TOV;
1735         icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1736
1737         nwwn = ISP_NODEWWN(isp);
1738         pwwn = ISP_PORTWWN(isp);
1739         if (nwwn && pwwn) {
1740                 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1741                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1742                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1743                 isp_prt(isp, ISP_LOGDEBUG1,
1744                     "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1745                     ((uint32_t) (nwwn >> 32)),
1746                     ((uint32_t) (nwwn & 0xffffffff)),
1747                     ((uint32_t) (pwwn >> 32)),
1748                     ((uint32_t) (pwwn & 0xffffffff)));
1749         } else if (pwwn) {
1750                 icbp->icb_fwoptions &= ~ICBOPT_BOTH_WWNS;
1751                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1752                 isp_prt(isp, ISP_LOGDEBUG1,
1753                     "Setting ICB Port 0x%08x%08x",
1754                     ((uint32_t) (pwwn >> 32)),
1755                     ((uint32_t) (pwwn & 0xffffffff)));
1756         } else {
1757                 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1758                 return;
1759         }
1760         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1761         if (icbp->icb_rqstqlen < 1) {
1762                 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1763         }
1764         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1765         if (icbp->icb_rsltqlen < 1) {
1766                 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1767         }
1768         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1769         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1770         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1771         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1772         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1773         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1774         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1775         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1776
1777         isp_prt(isp, ISP_LOGDEBUG0,
1778             "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1779             icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1780
1781         FC_SCRATCH_ACQUIRE(isp);
1782         isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1783
1784         /*
1785          * Init the firmware
1786          */
1787         MEMZERO(&mbs, sizeof (mbs));
1788         mbs.param[0] = MBOX_INIT_FIRMWARE;
1789         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1790         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1791         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1792         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1793         mbs.logval = MBLOGALL;
1794         mbs.timeout = 30 * 1000000;
1795         isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %p (%08x%08x)",
1796             fcp->isp_scratch, (uint32_t) ((uint64_t)fcp->isp_scdma >> 32),
1797             (uint32_t) fcp->isp_scdma);
1798         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
1799         isp_mboxcmd(isp, &mbs);
1800         FC_SCRATCH_RELEASE(isp);
1801         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1802                 isp_print_bytes(isp, "isp_fibre_init", sizeof (*icbp), icbp);
1803                 return;
1804         }
1805         isp->isp_reqidx = 0;
1806         isp->isp_reqodx = 0;
1807         isp->isp_residx = 0;
1808
1809         /*
1810          * Whatever happens, we're now committed to being here.
1811          */
1812         isp->isp_state = ISP_INITSTATE;
1813 }
1814
1815 static void
1816 isp_fibre_init_2400(ispsoftc_t *isp)
1817 {
1818         fcparam *fcp;
1819         isp_icb_2400_t local, *icbp = &local;
1820         mbreg_t mbs;
1821         int ownloopid;
1822         uint64_t nwwn, pwwn;
1823
1824         fcp = isp->isp_param;
1825
1826         /*
1827          * Turn on LIP F8 async event (1)
1828          */
1829         MEMZERO(&mbs, sizeof (mbs));
1830         mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1831         mbs.param[1] = 1;
1832         mbs.logval = MBLOGALL;
1833         isp_mboxcmd(isp, &mbs);
1834         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1835                 return;
1836         }
1837
1838         /*
1839          * XXX: This should be applied to icb- not fwoptions
1840          */
1841         if (isp->isp_role & ISP_ROLE_TARGET) {
1842                 fcp->isp_fwoptions |= ICB2400_OPT1_TGT_ENABLE;
1843         } else {
1844                 fcp->isp_fwoptions &= ~ICB2400_OPT1_TGT_ENABLE;
1845         }
1846
1847         if (isp->isp_role & ISP_ROLE_INITIATOR) {
1848                 fcp->isp_fwoptions &= ~ICB2400_OPT1_INI_DISABLE;
1849         } else {
1850                 fcp->isp_fwoptions |= ICB2400_OPT1_INI_DISABLE;
1851         }
1852
1853         MEMZERO(icbp, sizeof (*icbp));
1854         icbp->icb_version = ICB_VERSION1;
1855         icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1856         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1857             icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1858                 isp_prt(isp, ISP_LOGERR,
1859                     "bad frame length (%d) from NVRAM- using %d",
1860                     fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1861                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1862         }
1863
1864         icbp->icb_execthrottle = fcp->isp_execthrottle;
1865         if (icbp->icb_execthrottle < 1) {
1866                 isp_prt(isp, ISP_LOGERR,
1867                     "bad execution throttle of %d- using 16",
1868                     fcp->isp_execthrottle);
1869                 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1870         }
1871
1872         if (isp->isp_role & ISP_ROLE_TARGET) {
1873                 /*
1874                  * Get current resource count
1875                  */
1876                 MEMZERO(&mbs, sizeof (mbs));
1877                 mbs.param[0] = MBOX_GET_RESOURCE_COUNT;
1878                 mbs.obits = 0x4cf;
1879                 mbs.logval = MBLOGALL;
1880                 isp_mboxcmd(isp, &mbs);
1881                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1882                         return;
1883                 }
1884                 icbp->icb_xchgcnt = mbs.param[3];
1885         }
1886
1887         icbp->icb_fwoptions1 = fcp->isp_fwoptions;
1888
1889         icbp->icb_hardaddr = fcp->isp_loopid;
1890         ownloopid = (isp->isp_confopts & ISP_CFG_OWNLOOPID) != 0;
1891         if (icbp->icb_hardaddr > 125) {
1892                 icbp->icb_hardaddr = 0;
1893                 ownloopid = 0;
1894         }
1895         if (ownloopid) {
1896                 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
1897         }
1898
1899         icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1900         switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1901         case ISP_CFG_NPORT:
1902                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1903                 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_2_LOOP;
1904                 break;
1905         case ISP_CFG_NPORT_ONLY:
1906                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1907                 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
1908                 break;
1909         case ISP_CFG_LPORT_ONLY:
1910                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1911                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;
1912                 break;
1913         default:
1914                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1915                 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_2_PTP;
1916                 break;
1917         }
1918
1919         switch (icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK) {
1920         case ICB2400_OPT2_ZIO:
1921         case ICB2400_OPT2_ZIO1:
1922                 icbp->icb_idelaytimer = 0;
1923                 break;
1924         case 0:
1925                 break;
1926         default:
1927                 isp_prt(isp, ISP_LOGWARN, "bad value %x in fwopt2 timer field",
1928                     icbp->icb_fwoptions2 & ICB2400_OPT2_TIMER_MASK);
1929                 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TIMER_MASK;
1930                 break;
1931         }
1932
1933         icbp->icb_fwoptions3 = fcp->isp_zfwoptions;
1934         icbp->icb_fwoptions3 &= ~ICB2400_OPT3_RATE_AUTO;
1935         if (isp->isp_confopts & ISP_CFG_ONEGB) {
1936                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_ONEGB;
1937         } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1938                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_TWOGB;
1939         } else if (isp->isp_confopts & ISP_CFG_FOURGB) {
1940                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_FOURGB;
1941         } else {
1942                 icbp->icb_fwoptions3 |= ICB2400_OPT3_RATE_AUTO;
1943         }
1944
1945         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
1946                 icbp->icb_fwoptions3 |= ICB2400_OPT3_SOFTID;
1947         }
1948         icbp->icb_logintime = ICB_LOGIN_TOV;
1949
1950         nwwn = ISP_NODEWWN(isp);
1951         pwwn = ISP_PORTWWN(isp);
1952
1953         if (nwwn && pwwn) {
1954                 icbp->icb_fwoptions1 |= ICB2400_OPT1_BOTH_WWNS;
1955                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1956                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1957                 isp_prt(isp, ISP_LOGDEBUG1,
1958                     "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1959                     ((uint32_t) (nwwn >> 32)),
1960                     ((uint32_t) (nwwn & 0xffffffff)),
1961                     ((uint32_t) (pwwn >> 32)),
1962                     ((uint32_t) (pwwn & 0xffffffff)));
1963         } else if (pwwn) {
1964                 icbp->icb_fwoptions1 &= ~ICB2400_OPT1_BOTH_WWNS;
1965                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1966                 isp_prt(isp, ISP_LOGDEBUG1,
1967                     "Setting ICB Port 0x%08x%08x",
1968                     ((uint32_t) (pwwn >> 32)),
1969                     ((uint32_t) (pwwn & 0xffffffff)));
1970         } else {
1971                 isp_prt(isp, ISP_LOGERR, "No valid WWNs to use");
1972                 return;
1973         }
1974         icbp->icb_retry_count = fcp->isp_retry_count;
1975
1976         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1977         if (icbp->icb_rqstqlen < 8) {
1978                 isp_prt(isp, ISP_LOGERR, "bad request queue length %d",
1979                     icbp->icb_rqstqlen);
1980                 return;
1981         }
1982         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1983         if (icbp->icb_rsltqlen < 8) {
1984                 isp_prt(isp, ISP_LOGERR, "bad result queue length %d",
1985                     icbp->icb_rsltqlen);
1986                 return;
1987         }
1988         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1989         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1990         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1991         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1992
1993         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1994         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1995         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1996         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1997
1998 #ifdef  ISP_TARGET_MODE
1999         if (isp->isp_role & ISP_ROLE_TARGET) {
2000                 icbp->icb_atioqlen = RESULT_QUEUE_LEN(isp);
2001                 if (icbp->icb_atioqlen < 8) {
2002                         isp_prt(isp, ISP_LOGERR, "bad ATIO queue length %d",
2003                             icbp->icb_atioqlen);
2004                         return;
2005                 }
2006                 icbp->icb_atioqaddr[RQRSP_ADDR0015] =
2007                     DMA_WD0(isp->isp_atioq_dma);
2008                 icbp->icb_atioqaddr[RQRSP_ADDR1631] =
2009                     DMA_WD1(isp->isp_atioq_dma);
2010                 icbp->icb_atioqaddr[RQRSP_ADDR3247] =
2011                     DMA_WD2(isp->isp_atioq_dma);
2012                 icbp->icb_atioqaddr[RQRSP_ADDR4863] =
2013                     DMA_WD3(isp->isp_atioq_dma);
2014                 isp_prt(isp, ISP_LOGDEBUG0,
2015                     "isp_fibre_init_2400: atioq %04x%04x%04x%04x",
2016                     DMA_WD3(isp->isp_atioq_dma), DMA_WD2(isp->isp_atioq_dma),
2017                     DMA_WD1(isp->isp_atioq_dma), DMA_WD0(isp->isp_atioq_dma));
2018         }
2019 #endif
2020
2021         isp_prt(isp, ISP_LOGDEBUG0,
2022             "isp_fibre_init_2400: fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
2023             icbp->icb_fwoptions1, icbp->icb_fwoptions2, icbp->icb_fwoptions3);
2024
2025         isp_prt(isp, ISP_LOGDEBUG0,
2026             "isp_fibre_init_2400: rqst %04x%04x%04x%04x rsp %04x%04x%04x%04x",
2027             DMA_WD3(isp->isp_rquest_dma), DMA_WD2(isp->isp_rquest_dma),
2028             DMA_WD1(isp->isp_rquest_dma), DMA_WD0(isp->isp_rquest_dma),
2029             DMA_WD3(isp->isp_result_dma), DMA_WD2(isp->isp_result_dma),
2030             DMA_WD1(isp->isp_result_dma), DMA_WD0(isp->isp_result_dma));
2031
2032         if (isp->isp_dblev & ISP_LOGDEBUG1) {
2033                 isp_print_bytes(isp, "isp_fibre_init_2400", sizeof (*icbp),
2034                     icbp);
2035         }
2036         FC_SCRATCH_ACQUIRE(isp);
2037         isp_put_icb_2400(isp, icbp, fcp->isp_scratch);
2038
2039
2040         /*
2041          * Init the firmware
2042          */
2043         MEMZERO(&mbs, sizeof (mbs));
2044         mbs.param[0] = MBOX_INIT_FIRMWARE;
2045         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2046         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2047         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2048         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2049         mbs.logval = MBLOGALL;
2050         mbs.timeout = 30 * 1000000;
2051         isp_prt(isp, ISP_LOGDEBUG0, "INIT F/W from %04x%04x%04x%04x",
2052             DMA_WD3(fcp->isp_scdma), DMA_WD2(fcp->isp_scdma),
2053             DMA_WD1(fcp->isp_scdma), DMA_WD0(fcp->isp_scdma));
2054         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (*icbp));
2055         isp_mboxcmd(isp, &mbs);
2056         FC_SCRATCH_RELEASE(isp);
2057         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2058                 return;
2059         }
2060         isp->isp_reqidx = 0;
2061         isp->isp_reqodx = 0;
2062         isp->isp_residx = 0;
2063
2064         /*
2065          * Whatever happens, we're now committed to being here.
2066          */
2067         isp->isp_state = ISP_INITSTATE;
2068 }
2069
2070 static void
2071 isp_mark_portdb(ispsoftc_t *isp, int onprobation)
2072 {
2073         fcparam *fcp = (fcparam *) isp->isp_param;
2074         int i;
2075
2076         for (i = 0; i < MAX_FC_TARG; i++) {
2077                 if (onprobation == 0) {
2078                         MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2079                 } else {
2080                         switch (fcp->portdb[i].state) {
2081                         case FC_PORTDB_STATE_CHANGED:
2082                         case FC_PORTDB_STATE_PENDING_VALID:
2083                         case FC_PORTDB_STATE_VALID:
2084                         case FC_PORTDB_STATE_PROBATIONAL:
2085                                 fcp->portdb[i].state =
2086                                         FC_PORTDB_STATE_PROBATIONAL;
2087                                 break;
2088                         case FC_PORTDB_STATE_ZOMBIE:
2089                                 break;
2090                         case FC_PORTDB_STATE_NIL:
2091                         default:
2092                                 MEMZERO(&fcp->portdb[i], sizeof (fcportdb_t));
2093                                 fcp->portdb[i].state =
2094                                         FC_PORTDB_STATE_NIL;
2095                                 break;
2096                         }
2097                 }
2098         }
2099 }
2100
2101 /*
2102  * Perform an IOCB PLOGI or LOGO via EXECUTE IOCB A64 for 24XX cards
2103  * or via FABRIC LOGIN/FABRIC LOGOUT for other cards.
2104  */
2105 static int
2106 isp_plogx(ispsoftc_t *isp, uint16_t handle, uint32_t portid, int flags, int gs)
2107 {
2108         mbreg_t mbs;
2109         uint8_t q[QENTRY_LEN];
2110         isp_plogx_t *plp;
2111         uint8_t *scp;
2112         uint32_t sst, parm1;
2113         int rval;
2114
2115         if (!IS_24XX(isp)) {
2116                 int action = flags & PLOGX_FLG_CMD_MASK;
2117                 if (action == PLOGX_FLG_CMD_PLOGI) {
2118                         return (isp_port_login(isp, handle, portid));
2119                 } else if (action == PLOGX_FLG_CMD_LOGO) {
2120                         return (isp_port_logout(isp, handle, portid));
2121                 } else {
2122                         return (MBOX_INVALID_COMMAND);
2123                 }
2124         }
2125
2126         MEMZERO(q, QENTRY_LEN);
2127         plp = (isp_plogx_t *) q;
2128         plp->plogx_header.rqs_entry_count = 1;
2129         plp->plogx_header.rqs_entry_type = RQSTYPE_LOGIN;
2130         plp->plogx_handle = 0xffffffff;
2131         plp->plogx_nphdl = handle;
2132         plp->plogx_portlo = portid;
2133         plp->plogx_rspsz_porthi = (portid >> 16) & 0xff;
2134         plp->plogx_flags = flags;
2135
2136         if (isp->isp_dblev & ISP_LOGDEBUG1) {
2137                 isp_print_bytes(isp, "IOCB LOGX", QENTRY_LEN, plp);
2138         }
2139
2140         if (gs == 0) {
2141                 FC_SCRATCH_ACQUIRE(isp);
2142         }
2143         scp = FCPARAM(isp)->isp_scratch;
2144         isp_put_plogx(isp, plp, (isp_plogx_t *) scp);
2145
2146
2147         MEMZERO(&mbs, sizeof (mbs));
2148         mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
2149         mbs.param[1] = QENTRY_LEN;
2150         mbs.param[2] = DMA_WD1(FCPARAM(isp)->isp_scdma);
2151         mbs.param[3] = DMA_WD0(FCPARAM(isp)->isp_scdma);
2152         mbs.param[6] = DMA_WD3(FCPARAM(isp)->isp_scdma);
2153         mbs.param[7] = DMA_WD2(FCPARAM(isp)->isp_scdma);
2154         mbs.timeout = 500000;
2155         mbs.logval = MBLOGALL;
2156         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN);
2157         isp_mboxcmd(isp, &mbs);
2158         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2159                 rval = mbs.param[0];
2160                 goto out;
2161         }
2162         MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN);
2163         scp += QENTRY_LEN;
2164         isp_get_plogx(isp, (isp_plogx_t *) scp, plp);
2165         if (isp->isp_dblev & ISP_LOGDEBUG1) {
2166                 isp_print_bytes(isp, "IOCB LOGX response", QENTRY_LEN, plp);
2167         }
2168
2169         if (plp->plogx_status == PLOGX_STATUS_OK) {
2170                 rval = 0;
2171                 goto out;
2172         } else if (plp->plogx_status != PLOGX_STATUS_IOCBERR) {
2173                 isp_prt(isp, ISP_LOGWARN, "status 0x%x on port login IOCB",
2174                     plp->plogx_status);
2175                 rval = -1;
2176                 goto out;
2177         }
2178
2179         sst = plp->plogx_ioparm[0].lo16 | (plp->plogx_ioparm[0].hi16 << 16);
2180         parm1 = plp->plogx_ioparm[1].lo16 | (plp->plogx_ioparm[1].hi16 << 16);
2181
2182         rval = -1;
2183
2184         switch (sst) {
2185         case PLOGX_IOCBERR_NOLINK:
2186                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no link");
2187                 break;
2188         case PLOGX_IOCBERR_NOIOCB:
2189                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no IOCB buffer");
2190                 break;
2191         case PLOGX_IOCBERR_NOXGHG:
2192                 isp_prt(isp, ISP_LOGERR,
2193                     "PLOGX failed- no Exchange Control Block");
2194                 break;
2195         case PLOGX_IOCBERR_FAILED:
2196                 isp_prt(isp, ISP_LOGERR,
2197                     "PLOGX(0x%x) of Port 0x%06x failed: reason 0x%x (last LOGIN"
2198                     " state 0x%x)", flags, portid, parm1 & 0xff,
2199                     (parm1 >> 8) & 0xff);
2200                 break;
2201         case PLOGX_IOCBERR_NOFABRIC:
2202                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no fabric");
2203                 break;
2204         case PLOGX_IOCBERR_NOTREADY:
2205                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- f/w not ready");
2206                 break;
2207         case PLOGX_IOCBERR_NOLOGIN:
2208                 isp_prt(isp, ISP_LOGERR,
2209                     "PLOGX failed- not logged in (last LOGIN state 0x%x)",
2210                     parm1);
2211                 rval = MBOX_NOT_LOGGED_IN;
2212                 break;
2213         case PLOGX_IOCBERR_REJECT:
2214                 isp_prt(isp, ISP_LOGERR, "PLOGX failed: LS_RJT = 0x%x", parm1);
2215                 break;
2216         case PLOGX_IOCBERR_NOPCB:
2217                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no PCB allocated");
2218                 break;
2219         case PLOGX_IOCBERR_EINVAL:
2220                 isp_prt(isp, ISP_LOGERR,
2221                     "PLOGX failed: invalid parameter at offset 0x%x", parm1);
2222                 break;
2223         case PLOGX_IOCBERR_PORTUSED:
2224                 isp_prt(isp, ISP_LOGDEBUG0,
2225                     "portid 0x%x already logged in with N-port handle 0x%x",
2226                     portid, parm1);
2227                 rval = MBOX_PORT_ID_USED | (handle << 16);
2228                 break;
2229         case PLOGX_IOCBERR_HNDLUSED:
2230                 isp_prt(isp, ISP_LOGDEBUG0,
2231                     "N-port handle 0x%x already used for portid 0x%x",
2232                     handle, parm1);
2233                 rval = MBOX_LOOP_ID_USED;
2234                 break;
2235         case PLOGX_IOCBERR_NOHANDLE:
2236                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no handle allocated");
2237                 break;
2238         case PLOGX_IOCBERR_NOFLOGI:
2239                 isp_prt(isp, ISP_LOGERR, "PLOGX failed- no FLOGI_ACC");
2240                 break;
2241         default:
2242                 isp_prt(isp, ISP_LOGERR, "status %x from %x", plp->plogx_status,
2243                     flags);
2244                 rval = -1;
2245                 break;
2246         }
2247 out:
2248         if (gs == 0) {
2249                 FC_SCRATCH_RELEASE(isp);
2250         }
2251         return (rval);
2252 }
2253
2254 static int
2255 isp_port_login(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2256 {
2257         mbreg_t mbs;
2258
2259         MEMZERO(&mbs, sizeof (mbs));
2260         mbs.param[0] = MBOX_FABRIC_LOGIN;
2261         if (FCPARAM(isp)->isp_2klogin) {
2262                 mbs.param[1] = handle;
2263                 mbs.ibits = (1 << 10);
2264         } else {
2265                 mbs.param[1] = handle << 8;
2266         }
2267         mbs.param[2] = portid >> 16;
2268         mbs.param[3] = portid;
2269         mbs.logval = MBLOGNONE;
2270         mbs.timeout = 500000;
2271         isp_mboxcmd(isp, &mbs);
2272
2273         switch (mbs.param[0]) {
2274         case MBOX_PORT_ID_USED:
2275                 isp_prt(isp, ISP_LOGDEBUG0,
2276                     "isp_plogi_old: portid 0x%06x already logged in as %u",
2277                     portid, mbs.param[1]);
2278                 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2279
2280         case MBOX_LOOP_ID_USED:
2281                 isp_prt(isp, ISP_LOGDEBUG0,
2282                     "isp_plogi_old: handle %u in use for port id 0x%02xXXXX",
2283                     handle, mbs.param[1] & 0xff);
2284                 return (MBOX_LOOP_ID_USED);
2285
2286         case MBOX_COMMAND_COMPLETE:
2287                 return (0);
2288
2289         case MBOX_COMMAND_ERROR:
2290                 isp_prt(isp, ISP_LOGINFO,
2291                     "isp_plogi_old: error 0x%x in PLOGI to port 0x%06x",
2292                     mbs.param[1], portid);
2293                 return (MBOX_COMMAND_ERROR);
2294
2295         case MBOX_ALL_IDS_USED:
2296                 isp_prt(isp, ISP_LOGINFO,
2297                     "isp_plogi_old: all IDs used for fabric login");
2298                 return (MBOX_ALL_IDS_USED);
2299
2300         default:
2301                 isp_prt(isp, ISP_LOGINFO,
2302                     "isp_plogi_old: error 0x%x on port login of 0x%06x@0x%0x",
2303                     mbs.param[0], portid, handle);
2304                 return (mbs.param[0]);
2305         }
2306 }
2307
2308 static int
2309 isp_port_logout(ispsoftc_t *isp, uint16_t handle, uint32_t portid)
2310 {
2311         mbreg_t mbs;
2312
2313         MEMZERO(&mbs, sizeof (mbs));
2314         mbs.param[0] = MBOX_FABRIC_LOGOUT;
2315         if (FCPARAM(isp)->isp_2klogin) {
2316                 mbs.param[1] = handle;
2317                 mbs.ibits = (1 << 10);
2318         } else {
2319                 mbs.param[1] = handle << 8;
2320         }
2321         mbs.logval = MBLOGNONE;
2322         mbs.timeout = 100000;
2323         isp_mboxcmd(isp, &mbs);
2324         return (mbs.param[0] == MBOX_COMMAND_COMPLETE? 0 : mbs.param[0]);
2325 }
2326
2327 static int
2328 isp_getpdb(ispsoftc_t *isp, uint16_t id, isp_pdb_t *pdb, int dolock)
2329 {
2330         fcparam *fcp = (fcparam *) isp->isp_param;
2331         mbreg_t mbs;
2332         union {
2333                 isp_pdb_21xx_t fred;
2334                 isp_pdb_24xx_t bill;
2335         } un;
2336
2337         MEMZERO(&mbs, sizeof (mbs));
2338         mbs.param[0] = MBOX_GET_PORT_DB;
2339         if (IS_24XX(isp)) {
2340                 mbs.ibits = 0x3ff;
2341                 mbs.param[1] = id;
2342         } else if (FCPARAM(isp)->isp_2klogin) {
2343                 mbs.param[1] = id;
2344                 mbs.ibits = (1 << 10);
2345         } else {
2346                 mbs.param[1] = id << 8;
2347         }
2348         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2349         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2350         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2351         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2352         mbs.timeout = 250000;
2353         mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2354         if (dolock) {
2355                 FC_SCRATCH_ACQUIRE(isp);
2356         }
2357         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, sizeof (un));
2358         isp_mboxcmd(isp, &mbs);
2359         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2360                 if (dolock) {
2361                         FC_SCRATCH_RELEASE(isp);
2362                 }
2363                 return (-1);
2364         }
2365         if (IS_24XX(isp)) {
2366                 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2367                 pdb->handle = un.bill.pdb_handle;
2368                 pdb->s3_role = un.bill.pdb_prli_svc3;
2369                 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2370                 MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2371                 MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2372         } else {
2373                 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2374                 pdb->handle = un.fred.pdb_loopid;
2375                 pdb->s3_role = un.fred.pdb_prli_svc3;
2376                 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2377                 MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2378                 MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2379         }
2380         if (dolock) {
2381                 FC_SCRATCH_RELEASE(isp);
2382         }
2383         return (0);
2384 }
2385
2386 static uint64_t
2387 isp_get_portname(ispsoftc_t *isp, int loopid, int nodename)
2388 {
2389         uint64_t wwn = (uint64_t) -1;
2390         mbreg_t mbs;
2391
2392         MEMZERO(&mbs, sizeof (mbs));
2393         mbs.param[0] = MBOX_GET_PORT_NAME;
2394         if (FCPARAM(isp)->isp_2klogin || IS_24XX(isp)) {
2395                 mbs.param[1] = loopid;
2396                 mbs.ibits = (1 << 10);
2397                 if (nodename) {
2398                         mbs.param[10] = 1;
2399                 }
2400         } else {
2401                 mbs.param[1] = loopid << 8;
2402                 if (nodename) {
2403                         mbs.param[1] |= 1;
2404                 }
2405         }
2406         mbs.logval = MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR;
2407         isp_mboxcmd(isp, &mbs);
2408         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2409                 return (wwn);
2410         }
2411         if (IS_24XX(isp)) {
2412                 wwn =
2413                     (((uint64_t)(mbs.param[2] >> 8))  << 56) |
2414                     (((uint64_t)(mbs.param[2] & 0xff))  << 48) |
2415                     (((uint64_t)(mbs.param[3] >> 8))    << 40) |
2416                     (((uint64_t)(mbs.param[3] & 0xff))  << 32) |
2417                     (((uint64_t)(mbs.param[6] >> 8))    << 24) |
2418                     (((uint64_t)(mbs.param[6] & 0xff))  << 16) |
2419                     (((uint64_t)(mbs.param[7] >> 8))    <<  8) |
2420                     (((uint64_t)(mbs.param[7] & 0xff)));
2421         } else {
2422                 wwn =
2423                     (((uint64_t)(mbs.param[2] & 0xff))  << 56) |
2424                     (((uint64_t)(mbs.param[2] >> 8))    << 48) |
2425                     (((uint64_t)(mbs.param[3] & 0xff))  << 40) |
2426                     (((uint64_t)(mbs.param[3] >> 8))    << 32) |
2427                     (((uint64_t)(mbs.param[6] & 0xff))  << 24) |
2428                     (((uint64_t)(mbs.param[6] >> 8))    << 16) |
2429                     (((uint64_t)(mbs.param[7] & 0xff))  <<  8) |
2430                     (((uint64_t)(mbs.param[7] >> 8)));
2431         }
2432         return (wwn);
2433 }
2434
2435 /*
2436  * Make sure we have good FC link.
2437  */
2438
2439 static int
2440 isp_fclink_test(ispsoftc_t *isp, int usdelay)
2441 {
2442         static const char *toponames[] = {
2443                 "Private Loop",
2444                 "FL Port",
2445                 "N-Port to N-Port",
2446                 "F Port",
2447                 "F Port (no FLOGI_ACC response)"
2448         };
2449         mbreg_t mbs;
2450         int count, check_for_fabric;
2451         uint8_t lwfs;
2452         int loopid;
2453         fcparam *fcp;
2454         fcportdb_t *lp;
2455         isp_pdb_t pdb;
2456
2457         fcp = isp->isp_param;
2458
2459         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Entry");
2460         ISP_MARK_PORTDB(isp, 1);
2461
2462         /*
2463          * Wait up to N microseconds for F/W to go to a ready state.
2464          */
2465         lwfs = FW_CONFIG_WAIT;
2466         count = 0;
2467         while (count < usdelay) {
2468                 uint64_t enano;
2469                 uint32_t wrk;
2470                 NANOTIME_T hra, hrb;
2471
2472                 GET_NANOTIME(&hra);
2473                 isp_fw_state(isp);
2474                 if (lwfs != fcp->isp_fwstate) {
2475                         isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG,
2476                             "Firmware State <%s->%s>",
2477                             ispfc_fw_statename((int)lwfs),
2478                             ispfc_fw_statename((int)fcp->isp_fwstate));
2479                         lwfs = fcp->isp_fwstate;
2480                 }
2481                 if (fcp->isp_fwstate == FW_READY) {
2482                         break;
2483                 }
2484                 GET_NANOTIME(&hrb);
2485
2486                 /*
2487                  * Get the elapsed time in nanoseconds.
2488                  * Always guaranteed to be non-zero.
2489                  */
2490                 enano = NANOTIME_SUB(&hrb, &hra);
2491
2492                 isp_prt(isp, ISP_LOGDEBUG1,
2493                     "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
2494                     count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
2495                     (uint32_t)(enano >> 32), (uint32_t)(enano & 0xffffffff));
2496
2497                 /*
2498                  * If the elapsed time is less than 1 millisecond,
2499                  * delay a period of time up to that millisecond of
2500                  * waiting.
2501                  *
2502                  * This peculiar code is an attempt to try and avoid
2503                  * invoking uint64_t math support functions for some
2504                  * platforms where linkage is a problem.
2505                  */
2506                 if (enano < (1000 * 1000)) {
2507                         count += 1000;
2508                         enano = (1000 * 1000) - enano;
2509                         while (enano > (uint64_t) 4000000000U) {
2510                                 USEC_SLEEP(isp, 4000000);
2511                                 enano -= (uint64_t) 4000000000U;
2512                         }
2513                         wrk = enano;
2514                         wrk /= 1000;
2515                         USEC_SLEEP(isp, wrk);
2516                 } else {
2517                         while (enano > (uint64_t) 4000000000U) {
2518                                 count += 4000000;
2519                                 enano -= (uint64_t) 4000000000U;
2520                         }
2521                         wrk = enano;
2522                         count += (wrk / 1000);
2523                 }
2524         }
2525
2526         /*
2527          * If we haven't gone to 'ready' state, return.
2528          */
2529         if (fcp->isp_fwstate != FW_READY) {
2530                 isp_prt(isp, ISP_LOGSANCFG,
2531                     "isp_fclink_test: not at FW_READY state");
2532                 return (-1);
2533         }
2534
2535         /*
2536          * Get our Loop ID and Port ID.
2537          */
2538         MEMZERO(&mbs, sizeof (mbs));
2539         mbs.param[0] = MBOX_GET_LOOP_ID;
2540         mbs.logval = MBLOGALL;
2541         isp_mboxcmd(isp, &mbs);
2542         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
2543                 return (-1);
2544         }
2545
2546         if (FCPARAM(isp)->isp_2klogin) {
2547                 fcp->isp_loopid = mbs.param[1];
2548         } else {
2549                 fcp->isp_loopid = mbs.param[1] & 0xff;
2550         }
2551
2552         if (IS_2100(isp)) {
2553                 fcp->isp_topo = TOPO_NL_PORT;
2554         } else {
2555                 int topo = (int) mbs.param[6];
2556                 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB) {
2557                         topo = TOPO_PTP_STUB;
2558                 }
2559                 fcp->isp_topo = topo;
2560         }
2561         fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
2562
2563         if (IS_2100(isp)) {
2564                 /*
2565                  * Don't bother with fabric if we are using really old
2566                  * 2100 firmware. It's just not worth it.
2567                  */
2568                 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
2569                         check_for_fabric = 1;
2570                 } else {
2571                         check_for_fabric = 0;
2572                 }
2573         } else if (fcp->isp_topo == TOPO_FL_PORT ||
2574             fcp->isp_topo == TOPO_F_PORT) {
2575                 check_for_fabric = 1;
2576         } else {
2577                 check_for_fabric = 0;
2578         }
2579
2580         if (IS_24XX(isp)) {
2581                 loopid = NPH_FL_ID;
2582         } else {
2583                 loopid = FL_ID;
2584         }
2585
2586         if (check_for_fabric && isp_getpdb(isp, loopid, &pdb, 1) == 0) {
2587                 int r;
2588                 if (IS_2100(isp)) {
2589                         fcp->isp_topo = TOPO_FL_PORT;
2590                 }
2591                 if (pdb.portid == 0) {
2592                         /*
2593                          * Crock.
2594                          */
2595                         fcp->isp_topo = TOPO_NL_PORT;
2596                         goto not_on_fabric;
2597                 }
2598
2599                 /*
2600                  * Save the Fabric controller's port database entry.
2601                  */
2602                 lp = &fcp->portdb[FL_ID];
2603                 lp->state = FC_PORTDB_STATE_PENDING_VALID;
2604                 MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
2605                 MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
2606                 lp->roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2607                 lp->portid = pdb.portid;
2608                 lp->handle = pdb.handle;
2609                 lp->new_portid = lp->portid;
2610                 lp->new_roles = lp->roles;
2611                 if (IS_24XX(isp)) {
2612                         r = isp_register_fc4_type_24xx(isp);
2613                 } else {
2614                         r = isp_register_fc4_type(isp);
2615                 }
2616                 if (r) {
2617                         isp_prt(isp, ISP_LOGSANCFG,
2618                             "isp_fclink_test: register fc4 type failed");
2619                         return (-1);
2620                 }
2621         } else {
2622 not_on_fabric:
2623                 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
2624         }
2625
2626         fcp->isp_gbspeed = 1;
2627         if (IS_23XX(isp) || IS_24XX(isp)) {
2628                 MEMZERO(&mbs, sizeof (mbs));
2629                 mbs.param[0] = MBOX_GET_SET_DATA_RATE;
2630                 mbs.param[1] = MBGSD_GET_RATE;
2631                 /* mbs.param[2] undefined if we're just getting rate */
2632                 mbs.logval = MBLOGALL;
2633                 mbs.timeout = 3000000;
2634                 isp_mboxcmd(isp, &mbs);
2635                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
2636                         if (mbs.param[1] == MBGSD_FOURGB) {
2637                                 isp_prt(isp, ISP_LOGINFO, "4Gb link speed/s");
2638                                 fcp->isp_gbspeed = 4;
2639                         } if (mbs.param[1] == MBGSD_TWOGB) {
2640                                 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
2641                                 fcp->isp_gbspeed = 2;
2642                         }
2643                 }
2644         }
2645
2646         /*
2647          * Announce ourselves, too.
2648          */
2649         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, fcp->isp_portid,
2650             fcp->isp_loopid, toponames[fcp->isp_topo]);
2651         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, ourwwn,
2652             (uint32_t) (ISP_NODEWWN(isp) >> 32),
2653             (uint32_t) ISP_NODEWWN(isp),
2654             (uint32_t) (ISP_PORTWWN(isp) >> 32),
2655             (uint32_t) ISP_PORTWWN(isp));
2656         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Link Test Complete");
2657         return (0);
2658 }
2659
2660 static const char *
2661 ispfc_fw_statename(int state)
2662 {
2663         switch(state) {
2664         case FW_CONFIG_WAIT:    return "Config Wait";
2665         case FW_WAIT_AL_PA:     return "Waiting for AL_PA";
2666         case FW_WAIT_LOGIN:     return "Wait Login";
2667         case FW_READY:          return "Ready";
2668         case FW_LOSS_OF_SYNC:   return "Loss Of Sync";
2669         case FW_ERROR:          return "Error";
2670         case FW_REINIT:         return "Re-Init";
2671         case FW_NON_PART:       return "Nonparticipating";
2672         default:                return "?????";
2673         }
2674 }
2675
2676 /*
2677  * Complete the synchronization of our Port Database.
2678  *
2679  * At this point, we've scanned the local loop (if any) and the fabric
2680  * and performed fabric logins on all new devices.
2681  *
2682  * Our task here is to go through our port database and remove any entities
2683  * that are still marked probational (issuing PLOGO for ones which we had
2684  * PLOGI'd into) or are dead.
2685  *
2686  * Our task here is to also check policy to decide whether devices which
2687  * have *changed* in some way should still be kept active. For example,
2688  * if a device has just changed PortID, we can either elect to treat it
2689  * as an old device or as a newly arrived device (and notify the outer
2690  * layer appropriately).
2691  *
2692  * We also do initiator map target id assignment here for new initiator
2693  * devices and refresh old ones ot make sure that they point to the corret
2694  * entities.
2695  */
2696 static int
2697 isp_pdb_sync(ispsoftc_t *isp)
2698 {
2699         fcparam *fcp = isp->isp_param;
2700         fcportdb_t *lp;
2701         uint16_t dbidx;
2702
2703         if (fcp->isp_loopstate == LOOP_READY) {
2704                 return (0);
2705         }
2706
2707         /*
2708          * Make sure we're okay for doing this right now.
2709          */
2710         if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
2711             fcp->isp_loopstate != LOOP_FSCAN_DONE &&
2712             fcp->isp_loopstate != LOOP_LSCAN_DONE) {
2713                 isp_prt(isp, ISP_LOGWARN, "isp_pdb_sync: bad loopstate %d",
2714                     fcp->isp_loopstate);
2715                 return (-1);
2716         }
2717
2718         if (fcp->isp_topo == TOPO_FL_PORT ||
2719             fcp->isp_topo == TOPO_NL_PORT ||
2720             fcp->isp_topo == TOPO_N_PORT) {
2721                 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
2722                         if (isp_scan_loop(isp) != 0) {
2723                                 isp_prt(isp, ISP_LOGWARN,
2724                                     "isp_pdb_sync: isp_scan_loop failed");
2725                                 return (-1);
2726                         }
2727                 }
2728         }
2729
2730         if (fcp->isp_topo == TOPO_F_PORT || fcp->isp_topo == TOPO_FL_PORT) {
2731                 if (fcp->isp_loopstate < LOOP_FSCAN_DONE) {
2732                         if (isp_scan_fabric(isp) != 0) {
2733                                 isp_prt(isp, ISP_LOGWARN,
2734                                     "isp_pdb_sync: isp_scan_fabric failed");
2735                                 return (-1);
2736                         }
2737                 }
2738         }
2739
2740         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Synchronizing PDBs");
2741
2742         fcp->isp_loopstate = LOOP_SYNCING_PDB;
2743
2744         for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
2745                 lp = &fcp->portdb[dbidx];
2746
2747                 if (lp->state == FC_PORTDB_STATE_NIL) {
2748                         continue;
2749                 }
2750
2751                 if (lp->state == FC_PORTDB_STATE_VALID) {
2752                         if (dbidx != FL_ID) {
2753                                 isp_prt(isp,
2754                                     ISP_LOGERR, "portdb idx %d already valid",
2755                                     dbidx);
2756                         }
2757                         continue;
2758                 }
2759
2760                 switch (lp->state) {
2761                 case FC_PORTDB_STATE_PROBATIONAL:
2762                 case FC_PORTDB_STATE_DEAD:
2763                         /*
2764                          * It's up to the outer layers to clear isp_ini_map.
2765                          */
2766                         lp->state = FC_PORTDB_STATE_NIL;
2767                         isp_async(isp, ISPASYNC_DEV_GONE, lp);
2768                         if (lp->autologin == 0) {
2769                                 (void) isp_plogx(isp, lp->handle, lp->portid,
2770                                     PLOGX_FLG_CMD_LOGO |
2771                                     PLOGX_FLG_IMPLICIT |
2772                                     PLOGX_FLG_FREE_NPHDL, 0);
2773                         } else {
2774                                 lp->autologin = 0;
2775                         }
2776                         lp->new_roles = 0;
2777                         lp->new_portid = 0;
2778                         /*
2779                          * Note that we might come out of this with our state
2780                          * set to FC_PORTDB_STATE_ZOMBIE.
2781                          */
2782                         break;
2783                 case FC_PORTDB_STATE_NEW:
2784                         /*
2785                          * It's up to the outer layers to assign a virtual
2786                          * target id in isp_ini_map (if any).
2787                          */
2788                         lp->portid = lp->new_portid;
2789                         lp->roles = lp->new_roles;
2790                         lp->state = FC_PORTDB_STATE_VALID;
2791                         isp_async(isp, ISPASYNC_DEV_ARRIVED, lp);
2792                         lp->new_roles = 0;
2793                         lp->new_portid = 0;
2794                         lp->reserved = 0;
2795                         lp->new_reserved = 0;
2796                         break;
2797                 case FC_PORTDB_STATE_CHANGED:
2798 /*
2799  * XXXX FIX THIS
2800  */
2801                         lp->state = FC_PORTDB_STATE_VALID;
2802                         isp_async(isp, ISPASYNC_DEV_CHANGED, lp);
2803                         lp->new_roles = 0;
2804                         lp->new_portid = 0;
2805                         lp->reserved = 0;
2806                         lp->new_reserved = 0;
2807                         break;
2808                 case FC_PORTDB_STATE_PENDING_VALID:
2809                         lp->portid = lp->new_portid;
2810                         lp->roles = lp->new_roles;
2811                         if (lp->ini_map_idx) {
2812                                 int t = lp->ini_map_idx - 1;
2813                                 fcp->isp_ini_map[t] = dbidx + 1;
2814                         }
2815                         lp->state = FC_PORTDB_STATE_VALID;
2816                         isp_async(isp, ISPASYNC_DEV_STAYED, lp);
2817                         if (dbidx != FL_ID) {
2818                                 lp->new_roles = 0;
2819                                 lp->new_portid = 0;
2820                         }
2821                         lp->reserved = 0;
2822                         lp->new_reserved = 0;
2823                         break;
2824                 case FC_PORTDB_STATE_ZOMBIE:
2825                         break;
2826                 default:
2827                         isp_prt(isp, ISP_LOGWARN,
2828                             "isp_scan_loop: state %d for idx %d",
2829                             lp->state, dbidx);
2830                         isp_dump_portdb(isp);
2831                 }
2832         }
2833
2834         /*
2835          * If we get here, we've for sure seen not only a valid loop
2836          * but know what is or isn't on it, so mark this for usage
2837          * in isp_start.
2838          */
2839         fcp->loop_seen_once = 1;
2840         fcp->isp_loopstate = LOOP_READY;
2841         return (0);
2842 }
2843
2844 /*
2845  * Scan local loop for devices.
2846  */
2847 static int
2848 isp_scan_loop(ispsoftc_t *isp)
2849 {
2850         fcportdb_t *lp, tmp;
2851         fcparam *fcp = isp->isp_param;
2852         int i;
2853         isp_pdb_t pdb;
2854         uint16_t handle, lim = 0;
2855
2856         if (fcp->isp_fwstate < FW_READY ||
2857             fcp->isp_loopstate < LOOP_PDB_RCVD) {
2858                 return (-1);
2859         }
2860
2861         if (fcp->isp_loopstate > LOOP_SCANNING_LOOP) {
2862                 return (0);
2863         }
2864
2865         /*
2866          * Check our connection topology.
2867          *
2868          * If we're a public or private loop, we scan 0..125 as handle values.
2869          * The firmware has (typically) peformed a PLOGI for us.
2870          *
2871          * If we're a N-port connection, we treat this is a short loop (0..1).
2872          *
2873          * If we're in target mode, we can all possible handles to see who
2874          * might have logged into us.
2875          */
2876         switch (fcp->isp_topo) {
2877         case TOPO_NL_PORT:
2878         case TOPO_FL_PORT:
2879                 lim = LOCAL_LOOP_LIM;
2880                 break;
2881         case TOPO_N_PORT:
2882                 lim = 2;
2883                 break;
2884         default:
2885                 isp_prt(isp, ISP_LOGDEBUG0, "no loop topology to scan");
2886                 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2887                 return (0);
2888         }
2889
2890         fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2891
2892         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC scan loop 0..%d", lim-1);
2893
2894
2895         /*
2896          * Run through the list and get the port database info for each one.
2897          */
2898         for (handle = 0; handle < lim; handle++) {
2899                 /*
2900                  * But don't even try for ourselves...
2901                  */
2902                 if (handle == fcp->isp_loopid) {
2903                         continue;
2904                 }
2905
2906                 /*
2907                  * In older cards with older f/w GET_PORT_DATABASE has been
2908                  * known to hang. This trick gets around that problem.
2909                  */
2910                 if (IS_2100(isp) || IS_2200(isp)) {
2911                         uint64_t node_wwn = isp_get_portname(isp, handle, 1);
2912                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2913                                 return (-1);
2914                         }
2915                         if (node_wwn == 0) {
2916                                 continue;
2917                         }
2918                 }
2919
2920                 /*
2921                  * Get the port database entity for this index.
2922                  */
2923                 if (isp_getpdb(isp, handle, &pdb, 1) != 0) {
2924                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2925                                 ISP_MARK_PORTDB(isp, 1);
2926                                 return (-1);
2927                         }
2928                         continue;
2929                 }
2930
2931                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2932                         ISP_MARK_PORTDB(isp, 1);
2933                         return (-1);
2934                 }
2935
2936                 /*
2937                  * On *very* old 2100 firmware we would end up sometimes
2938                  * with the firmware returning the port database entry
2939                  * for something else. We used to restart this, but
2940                  * now we just punt.
2941                  */
2942                 if (IS_2100(isp) && pdb.handle != handle) {
2943                         isp_prt(isp, ISP_LOGWARN,
2944                             "giving up on synchronizing the port database");
2945                         ISP_MARK_PORTDB(isp, 1);
2946                         return (-1);
2947                 }
2948
2949                 /*
2950                  * Save the pertinent info locally.
2951                  */
2952                 MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
2953                 MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
2954                 tmp.roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2955                 tmp.portid = pdb.portid;
2956                 tmp.handle = pdb.handle;
2957
2958                 /*
2959                  * Check to make sure it's still a valid entry. The 24XX seems
2960                  * to return a portid but not a WWPN/WWNN or role for devices
2961                  * which shift on a loop.
2962                  */
2963                 if (tmp.node_wwn == 0 || tmp.port_wwn == 0 || tmp.portid == 0) {
2964                         int a, b, c;
2965                         a = (tmp.node_wwn == 0);
2966                         b = (tmp.port_wwn == 0);
2967                         c = (tmp.portid == 0);
2968                         isp_prt(isp, ISP_LOGWARN,
2969                             "bad pdb (%1d%1d%1d) @ handle 0x%x", a, b, c,
2970                             handle);
2971                         isp_dump_portdb(isp);
2972                         continue;
2973                 }
2974
2975                 /*
2976                  * Now search the entire port database
2977                  * for the same Port and Node WWN.
2978                  */
2979                 for (i = 0; i < MAX_FC_TARG; i++) {
2980                         lp = &fcp->portdb[i];
2981                         if (lp->state == FC_PORTDB_STATE_NIL) {
2982                                 continue;
2983                         }
2984                         if (lp->node_wwn != tmp.node_wwn) {
2985                                 continue;
2986                         }
2987                         if (lp->port_wwn != tmp.port_wwn) {
2988                                 continue;
2989                         }
2990
2991                         /*
2992                          * Okay- we've found a non-nil entry that matches.
2993                          * Check to make sure it's probational or a zombie.
2994                          */
2995                         if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
2996                             lp->state != FC_PORTDB_STATE_ZOMBIE) {
2997                                 isp_prt(isp, ISP_LOGERR,
2998                                     "[%d] not probational/zombie (0x%x)",
2999                                     i, lp->state);
3000                                 isp_dump_portdb(isp);
3001                                 ISP_MARK_PORTDB(isp, 1);
3002                                 return (-1);
3003                         }
3004
3005                         /*
3006                          * Mark the device as something the f/w logs into
3007                          * automatically.
3008                          */
3009                         lp->autologin = 1;
3010
3011                         /*
3012                          * Check to make see if really still the same
3013                          * device. If it is, we mark it pending valid.
3014                          */
3015                         if (lp->portid == tmp.portid &&
3016                             lp->handle == tmp.handle &&
3017                             lp->roles == tmp.roles) {
3018                                 lp->new_portid = tmp.portid;
3019                                 lp->new_roles = tmp.roles;
3020                                 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3021                                 isp_prt(isp, ISP_LOGSANCFG,
3022                                     "Loop Port 0x%02x@0x%x Pending Valid",
3023                                     tmp.portid, tmp.handle);
3024                                 break;
3025                         }
3026
3027                         /*
3028                          * We can wipe out the old handle value
3029                          * here because it's no longer valid.
3030                          */
3031                         lp->handle = tmp.handle;
3032
3033                         /*
3034                          * Claim that this has changed and let somebody else
3035                          * decide what to do.
3036                          */
3037                         isp_prt(isp, ISP_LOGSANCFG,
3038                             "Loop Port 0x%02x@0x%x changed",
3039                             tmp.portid, tmp.handle);
3040                         lp->state = FC_PORTDB_STATE_CHANGED;
3041                         lp->new_portid = tmp.portid;
3042                         lp->new_roles = tmp.roles;
3043                         break;
3044                 }
3045
3046                 /*
3047                  * Did we find and update an old entry?
3048                  */
3049                 if (i < MAX_FC_TARG) {
3050                         continue;
3051                 }
3052
3053                 /*
3054                  * Ah. A new device entry. Find an empty slot
3055                  * for it and save info for later disposition.
3056                  */
3057                 for (i = 0; i < MAX_FC_TARG; i++) {
3058                         if (fcp->portdb[i].state == FC_PORTDB_STATE_NIL) {
3059                                 break;
3060                         }
3061                 }
3062                 if (i == MAX_FC_TARG) {
3063                         isp_prt(isp, ISP_LOGERR, "out of portdb entries");
3064                         continue;
3065                 }
3066                 lp = &fcp->portdb[i];
3067
3068                 MEMZERO(lp, sizeof (fcportdb_t));
3069                 lp->autologin = 1;
3070                 lp->state = FC_PORTDB_STATE_NEW;
3071                 lp->new_portid = tmp.portid;
3072                 lp->new_roles = tmp.roles;
3073                 lp->handle = tmp.handle;
3074                 lp->port_wwn = tmp.port_wwn;
3075                 lp->node_wwn = tmp.node_wwn;
3076                 isp_prt(isp, ISP_LOGSANCFG,
3077                     "Loop Port 0x%02x@0x%x is New Entry",
3078                     tmp.portid, tmp.handle);
3079         }
3080         fcp->isp_loopstate = LOOP_LSCAN_DONE;
3081         return (0);
3082 }
3083
3084 /*
3085  * Scan the fabric for devices and add them to our port database.
3086  *
3087  * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
3088  *
3089  * For 2100-23XX cards, we can use the SNS mailbox command to pass simple
3090  * name server commands to the switch management server via the QLogic f/w.
3091  *
3092  * For the 24XX card, we have to use CT-Pass through run via the Execute IOCB
3093  * mailbox command.
3094  *
3095  * The net result is to leave the list of Port IDs setting untranslated in
3096  * offset IGPOFF of the FC scratch area, whereupon we'll canonicalize it to
3097  * host order at OGPOFF.
3098  */
3099
3100 /*
3101  * Take less than half of our scratch area to store Port IDs
3102  */
3103 #define GIDLEN  ((ISP2100_SCRLEN >> 1) - 16 - SNS_GID_FT_REQ_SIZE)
3104 #define NGENT   ((GIDLEN - 16) >> 2)
3105
3106 #define IGPOFF  (2 * QENTRY_LEN)
3107 #define OGPOFF  (ISP2100_SCRLEN >> 1)
3108 #define ZTXOFF  (ISP2100_SCRLEN - (1 * QENTRY_LEN))
3109 #define CTXOFF  (ISP2100_SCRLEN - (2 * QENTRY_LEN))
3110 #define XTXOFF  (ISP2100_SCRLEN - (3 * QENTRY_LEN))
3111
3112 static int
3113 isp_gid_ft_sns(ispsoftc_t *isp)
3114 {
3115         union {
3116                 sns_gid_ft_req_t _x;
3117                 uint8_t _y[SNS_GID_FT_REQ_SIZE];
3118         } un;
3119         fcparam *fcp = FCPARAM(isp);
3120         sns_gid_ft_req_t *rq = &un._x;
3121         mbreg_t mbs;
3122
3123         isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via SNS");
3124
3125         MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
3126         rq->snscb_rblen = GIDLEN >> 1;
3127         rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
3128         rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
3129         rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
3130         rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
3131         rq->snscb_sblen = 6;
3132         rq->snscb_cmd = SNS_GID_FT;
3133         rq->snscb_mword_div_2 = NGENT;
3134         rq->snscb_fc4_type = FC4_SCSI;
3135
3136         isp_put_gid_ft_request(isp, rq, fcp->isp_scratch);
3137         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
3138
3139         MEMZERO(&mbs, sizeof (mbs));
3140         mbs.param[0] = MBOX_SEND_SNS;
3141         mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
3142         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3143         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3144         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3145         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3146         mbs.logval = MBLOGALL;
3147         mbs.timeout = 10000000;
3148         isp_mboxcmd(isp, &mbs);
3149         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3150                 if (mbs.param[0] == MBOX_INVALID_COMMAND) {
3151                         return (1);
3152                 } else {
3153                         return (-1);
3154                 }
3155         }
3156         return (0);
3157 }
3158
3159 static int
3160 isp_gid_ft_ct_passthru(ispsoftc_t *isp)
3161 {
3162         mbreg_t mbs;
3163         fcparam *fcp = FCPARAM(isp);
3164         union {
3165                 isp_ct_pt_t plocal;
3166                 ct_hdr_t clocal;
3167                 uint8_t q[QENTRY_LEN];
3168         } un;
3169         isp_ct_pt_t *pt;
3170         ct_hdr_t *ct;
3171         uint32_t *rp;
3172         uint8_t *scp = fcp->isp_scratch;
3173
3174         isp_prt(isp, ISP_LOGDEBUG0, "scanning fabric (GID_FT) via CT");
3175
3176         if (!IS_24XX(isp)) {
3177                 return (1);
3178         }
3179
3180         /*
3181          * Build a Passthrough IOCB in memory.
3182          */
3183         pt = &un.plocal;
3184         MEMZERO(un.q, QENTRY_LEN);
3185         pt->ctp_header.rqs_entry_count = 1;
3186         pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3187         pt->ctp_handle = 0xffffffff;
3188         pt->ctp_nphdl = NPH_SNS_ID;
3189         pt->ctp_cmd_cnt = 1;
3190         pt->ctp_time = 30;
3191         pt->ctp_rsp_cnt = 1;
3192         pt->ctp_rsp_bcnt = GIDLEN;
3193         pt->ctp_cmd_bcnt = sizeof (*ct) + sizeof (uint32_t);
3194         pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3195         pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3196         pt->ctp_dataseg[0].ds_count = sizeof (*ct) + sizeof (uint32_t);
3197         pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3198         pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3199         pt->ctp_dataseg[1].ds_count = GIDLEN;
3200         if (isp->isp_dblev & ISP_LOGDEBUG1) {
3201                 isp_print_bytes(isp, "ct IOCB", QENTRY_LEN, pt);
3202         }
3203         isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3204
3205         /*
3206          * Build the CT header and command in memory.
3207          *
3208          * Note that the CT header has to end up as Big Endian format in memory.
3209          */
3210         ct = &un.clocal;
3211         MEMZERO(ct, sizeof (*ct));
3212         ct->ct_revision = CT_REVISION;
3213         ct->ct_fcs_type = CT_FC_TYPE_FC;
3214         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3215         ct->ct_cmd_resp = SNS_GID_FT;
3216         ct->ct_bcnt_resid = (GIDLEN - 16) >> 2;
3217
3218         isp_put_ct_hdr(isp, ct, (ct_hdr_t *) &scp[XTXOFF]);
3219         rp = (uint32_t *) &scp[XTXOFF+sizeof (*ct)];
3220         ISP_IOZPUT_32(isp, FC4_SCSI, rp);
3221         if (isp->isp_dblev & ISP_LOGDEBUG1) {
3222                 isp_print_bytes(isp, "CT HDR + payload after put",
3223                     sizeof (*ct) + sizeof (uint32_t), &scp[XTXOFF]);
3224         }
3225         MEMZERO(&scp[ZTXOFF], QENTRY_LEN);
3226         MEMZERO(&mbs, sizeof (mbs));
3227         mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3228         mbs.param[1] = QENTRY_LEN;
3229         mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3230         mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3231         mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3232         mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3233         mbs.timeout = 500000;
3234         mbs.logval = MBLOGALL;
3235         MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3236         isp_mboxcmd(isp, &mbs);
3237         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3238                 return (-1);
3239         }
3240         MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3241         pt = &un.plocal;
3242         isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3243         if (isp->isp_dblev & ISP_LOGDEBUG1) {
3244                 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3245         }
3246
3247         if (pt->ctp_status && pt->ctp_status != RQCS_DATA_UNDERRUN) {
3248                 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3249                     pt->ctp_status);
3250                 return (-1);
3251         }
3252         MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN + 16);
3253         if (isp->isp_dblev & ISP_LOGDEBUG1) {
3254                 isp_print_bytes(isp, "CT response", GIDLEN+16, &scp[IGPOFF]);
3255         }
3256         return (0);
3257 }
3258
3259 static int
3260 isp_scan_fabric(ispsoftc_t *isp)
3261 {
3262         fcparam *fcp = FCPARAM(isp);
3263         uint32_t portid;
3264         uint16_t handle, oldhandle;
3265         int portidx, portlim, r;
3266         sns_gid_ft_rsp_t *rs0, *rs1;
3267
3268         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric");
3269         if (fcp->isp_fwstate != FW_READY ||
3270             fcp->isp_loopstate < LOOP_LSCAN_DONE) {
3271                 return (-1);
3272         }
3273         if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
3274                 return (0);
3275         }
3276         if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
3277                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3278                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3279                     "FC Scan Fabric Done (no fabric)");
3280                 return (0);
3281         }
3282
3283         FC_SCRATCH_ACQUIRE(isp);
3284         fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3285
3286         if (IS_24XX(isp)) {
3287                 r = isp_gid_ft_ct_passthru(isp);
3288         } else {
3289                 r = isp_gid_ft_sns(isp);
3290         }
3291
3292         if (r > 0) {
3293                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3294                 FC_SCRATCH_RELEASE(isp);
3295                 return (0);
3296         } else if (r < 0) {
3297                 fcp->isp_loopstate = LOOP_PDB_RCVD;     /* try again */
3298                 FC_SCRATCH_RELEASE(isp);
3299                 return (0);
3300         }
3301         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3302                 FC_SCRATCH_RELEASE(isp);
3303                 return (-1);
3304         }
3305
3306         MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
3307         rs0 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+IGPOFF);
3308         rs1 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+OGPOFF);
3309         isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3310         if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3311                 int level;
3312                 if (rs1->snscb_cthdr.ct_reason == 9 &&
3313                     rs1->snscb_cthdr.ct_explanation == 7) {
3314                         level = ISP_LOGSANCFG|ISP_LOGDEBUG0;
3315                 } else {
3316                         level = ISP_LOGWARN;
3317                 }
3318                 isp_prt(isp, level, "Fabric Nameserver rejected GID_FT "
3319                     "(Reason=0x%x Expl=0x%x)", rs1->snscb_cthdr.ct_reason,
3320                     rs1->snscb_cthdr.ct_explanation);
3321                 FC_SCRATCH_RELEASE(isp);
3322                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3323                 return (0);
3324         }
3325
3326
3327         /*
3328          * If we get this far, we certainly still have the fabric controller.
3329          */
3330         fcp->portdb[FL_ID].state = FC_PORTDB_STATE_PENDING_VALID;
3331
3332         /*
3333          * Prime the handle we will start using.
3334          */
3335         oldhandle = NIL_HANDLE;
3336
3337         /*
3338          * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3339          * that the Fabric Name server knows about. Go through the list
3340          * and remove duplicate port ids.
3341          */
3342
3343         portlim = 0;
3344         portidx = 0;
3345         for (portidx = 0; portidx < NGENT-1; portidx++) {
3346                 if (rs1->snscb_ports[portidx].control & 0x80) {
3347                         break;
3348                 }
3349         }
3350
3351         /*
3352          * If we're not at the last entry, our list wasn't big enough.
3353          */
3354         if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
3355                 isp_prt(isp, ISP_LOGWARN,
3356                     "fabric too big for scratch area: increase ISP2100_SCRLEN");
3357         }
3358         portlim = portidx + 1;
3359         isp_prt(isp, ISP_LOGSANCFG,
3360             "got %d ports back from name server", portlim);
3361
3362         for (portidx = 0; portidx < portlim; portidx++) {
3363                 int npidx;
3364
3365                 portid =
3366                     ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3367                     ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3368                     ((rs1->snscb_ports[portidx].portid[2]));
3369
3370                 for (npidx = portidx + 1; npidx < portlim; npidx++) {
3371                         uint32_t new_portid =
3372                             ((rs1->snscb_ports[npidx].portid[0]) << 16) |
3373                             ((rs1->snscb_ports[npidx].portid[1]) << 8) |
3374                             ((rs1->snscb_ports[npidx].portid[2]));
3375                         if (new_portid == portid) {
3376                                 break;
3377                         }
3378                 }
3379
3380                 if (npidx < portlim) {
3381                         rs1->snscb_ports[npidx].portid[0] = 0;
3382                         rs1->snscb_ports[npidx].portid[1] = 0;
3383                         rs1->snscb_ports[npidx].portid[2] = 0;
3384                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3385                             "removing duplicate PortID 0x%x entry from list",
3386                             portid);
3387                 }
3388         }
3389
3390         /*
3391          * Okay, we now have a list of Port IDs for all FC4 SCSI devices
3392          * that the Fabric Name server knows about.
3393          *
3394          * For each entry on this list go through our port database looking
3395          * for probational entries- if we find one, then an old entry is
3396          * is maybe still this one. We get some information to find out.
3397          *
3398          * Otherwise, it's a new fabric device, and we log into it
3399          * (unconditionally). After searching the entire database
3400          * again to make sure that we never ever ever ever have more
3401          * than one entry that has the same PortID or the same
3402          * WWNN/WWPN duple, we enter the device into our database.
3403          */
3404
3405         for (portidx = 0; portidx < portlim; portidx++) {
3406                 fcportdb_t *lp;
3407                 isp_pdb_t pdb;
3408                 uint64_t wwnn, wwpn;
3409                 int dbidx, nr;
3410
3411                 portid =
3412                     ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3413                     ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3414                     ((rs1->snscb_ports[portidx].portid[2]));
3415
3416                 if (portid == 0) {
3417                         isp_prt(isp, ISP_LOGSANCFG,
3418                             "skipping null PortID at idx %d", portidx);
3419                         continue;
3420                 }
3421
3422                 /*
3423                  * Skip ourselves...
3424                  */
3425                 if (portid == fcp->isp_portid) {
3426                         isp_prt(isp, ISP_LOGSANCFG,
3427                             "skip ourselves @ PortID 0x%06x", portid);
3428                         continue;
3429                 }
3430                 isp_prt(isp, ISP_LOGSANCFG,
3431                     "Checking Fabric Port 0x%06x", portid);
3432
3433                 /*
3434                  * We now search our Port Database for any
3435                  * probational entries with this PortID. We don't
3436                  * look for zombies here- only probational
3437                  * entries (we've already logged out of zombies).
3438                  */
3439                 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3440                         lp = &fcp->portdb[dbidx];
3441
3442                         if (lp->state != FC_PORTDB_STATE_PROBATIONAL) {
3443                                 continue;
3444                         }
3445                         if (lp->portid == portid) {
3446                                 break;
3447                         }
3448                 }
3449
3450                 /*
3451                  * We found a probational entry with this Port ID.
3452                  */
3453                 if (dbidx < MAX_FC_TARG) {
3454                         int handle_changed = 0;
3455
3456                         lp = &fcp->portdb[dbidx];
3457
3458                         /*
3459                          * See if we're still logged into it.
3460                          *
3461                          * If we aren't, mark it as a dead device and
3462                          * leave the new portid in the database entry
3463                          * for somebody further along to decide what to
3464                          * do (policy choice).
3465                          *
3466                          * If we are, check to see if it's the same
3467                          * device still (it should be). If for some
3468                          * reason it isn't, mark it as a changed device
3469                          * and leave the new portid and role in the
3470                          * database entry for somebody further along to
3471                          * decide what to do (policy choice).
3472                          *
3473                          */
3474
3475                         r = isp_getpdb(isp, lp->handle, &pdb, 0);
3476                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3477                                 FC_SCRATCH_RELEASE(isp);
3478                                 ISP_MARK_PORTDB(isp, 1);
3479                                 return (-1);
3480                         }
3481                         if (r != 0) {
3482                                 lp->new_portid = portid;
3483                                 lp->state = FC_PORTDB_STATE_DEAD;
3484                                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3485                                     "Fabric Port 0x%06x considered dead",
3486                                     portid);
3487                                 continue;
3488                         }
3489
3490
3491                         /*
3492                          * Check to make sure that handle, portid, WWPN and
3493                          * WWNN agree. If they don't, then the association
3494                          * between this PortID and the stated handle has been
3495                          * broken by the firmware.
3496                          */
3497                         MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3498                         MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3499                         if (pdb.handle != lp->handle ||
3500                             pdb.portid != portid ||
3501                             wwpn != lp->port_wwn ||
3502                             wwnn != lp->node_wwn) {
3503                                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3504                                     fconf, dbidx, pdb.handle, pdb.portid,
3505                                     (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3506                                     (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3507                                     lp->handle, portid,
3508                                     (uint32_t) (lp->node_wwn >> 32),
3509                                     (uint32_t) lp->node_wwn,
3510                                     (uint32_t) (lp->port_wwn >> 32),
3511                                     (uint32_t) lp->port_wwn);
3512                                 /*
3513                                  * Try to re-login to this device using a
3514                                  * new handle. If that fails, mark it dead.
3515                                  *
3516                                  * isp_login_device will check for handle and
3517                                  * portid consistency after re-login.
3518                                  *
3519                                  */
3520                                 if (isp_login_device(isp, portid, &pdb,
3521                                     &oldhandle)) {
3522                                         lp->new_portid = portid;
3523                                         lp->state = FC_PORTDB_STATE_DEAD;
3524                                         if (fcp->isp_loopstate !=
3525                                             LOOP_SCANNING_FABRIC) {
3526                                                 FC_SCRATCH_RELEASE(isp);
3527                                                 ISP_MARK_PORTDB(isp, 1);
3528                                                 return (-1);
3529                                         }
3530                                         continue;
3531                                 }
3532                                 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3533                                 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3534                                 if (wwpn != lp->port_wwn ||
3535                                     wwnn != lp->node_wwn) {
3536                                         isp_prt(isp, ISP_LOGWARN, "changed WWN"
3537                                             " after relogin");
3538                                         lp->new_portid = portid;
3539                                         lp->state = FC_PORTDB_STATE_DEAD;
3540                                         continue;
3541                                 }
3542
3543                                 lp->handle = pdb.handle;
3544                                 handle_changed++;
3545                         }
3546
3547                         nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3548
3549                         /*
3550                          * Check to see whether the portid and roles have
3551                          * stayed the same. If they have stayed the same,
3552                          * we believe that this is the same device and it
3553                          * hasn't become disconnected and reconnected, so
3554                          * mark it as pending valid.
3555                          *
3556                          * If they aren't the same, mark the device as a
3557                          * changed device and save the new port id and role
3558                          * and let somebody else decide.
3559                          */
3560
3561                         lp->new_portid = portid;
3562                         lp->new_roles = nr;
3563                         if (pdb.portid != lp->portid || nr != lp->roles ||
3564                             handle_changed) {
3565                                 isp_prt(isp, ISP_LOGSANCFG,
3566                                     "Fabric Port 0x%06x changed", portid);
3567                                 lp->state = FC_PORTDB_STATE_CHANGED;
3568                         } else {
3569                                 isp_prt(isp, ISP_LOGSANCFG,
3570                                     "Fabric Port 0x%06x Now Pending Valid",
3571                                     portid);
3572                                 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3573                         }
3574                         continue;
3575                 }
3576
3577                 /*
3578                  * Ah- a new entry. Search the database again for all non-NIL
3579                  * entries to make sure we never ever make a new database entry
3580                  * with the same port id. While we're at it, mark where the
3581                  * last free entry was.
3582                  */
3583
3584                 dbidx = MAX_FC_TARG;
3585                 for (lp = fcp->portdb; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
3586                         if (lp >= &fcp->portdb[FL_ID] &&
3587                             lp <= &fcp->portdb[SNS_ID]) {
3588                                 continue;
3589                         }
3590                         if (lp->state == FC_PORTDB_STATE_NIL) {
3591                                 if (dbidx == MAX_FC_TARG) {
3592                                         dbidx = lp - fcp->portdb;
3593                                 }
3594                                 continue;
3595                         }
3596                         if (lp->state == FC_PORTDB_STATE_ZOMBIE) {
3597                                 continue;
3598                         }
3599                         if (lp->portid == portid) {
3600                                 break;
3601                         }
3602                 }
3603
3604                 if (lp < &fcp->portdb[MAX_FC_TARG]) {
3605                         isp_prt(isp, ISP_LOGWARN,
3606                             "PortID 0x%06x already at %d handle %d state %d",
3607                             portid, dbidx, lp->handle, lp->state);
3608                         continue;
3609                 }
3610
3611                 /*
3612                  * We should have the index of the first free entry seen.
3613                  */
3614                 if (dbidx == MAX_FC_TARG) {
3615                         isp_prt(isp, ISP_LOGERR,
3616                             "port database too small to login PortID 0x%06x"
3617                             "- increase MAX_FC_TARG", portid);
3618                         continue;
3619                 }
3620
3621                 /*
3622                  * Otherwise, point to our new home.
3623                  */
3624                 lp = &fcp->portdb[dbidx];
3625
3626                 /*
3627                  * Try to see if we are logged into this device,
3628                  * and maybe log into it.
3629                  *
3630                  * isp_login_device will check for handle and
3631                  * portid consistency after login.
3632                  */
3633                 if (isp_login_device(isp, portid, &pdb, &oldhandle)) {
3634                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3635                                 FC_SCRATCH_RELEASE(isp);
3636                                 ISP_MARK_PORTDB(isp, 1);
3637                                 return (-1);
3638                         }
3639                         continue;
3640                 }
3641
3642                 handle = pdb.handle;
3643                 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3644                 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3645                 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3646
3647                 /*
3648                  * And go through the database *one* more time to make sure
3649                  * that we do not make more than one entry that has the same
3650                  * WWNN/WWPN duple
3651                  */
3652                 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3653                         if (dbidx >= FL_ID && dbidx <= SNS_ID) {
3654                                 continue;
3655                         }
3656                         if (fcp->portdb[dbidx].state == FC_PORTDB_STATE_NIL) {
3657                                 continue;
3658                         }
3659                         if (fcp->portdb[dbidx].node_wwn == wwnn &&
3660                             fcp->portdb[dbidx].port_wwn == wwpn) {
3661                                 break;
3662                         }
3663                 }
3664
3665                 if (dbidx == MAX_FC_TARG) {
3666                         MEMZERO(lp, sizeof (fcportdb_t));
3667                         lp->handle = handle;
3668                         lp->node_wwn = wwnn;
3669                         lp->port_wwn = wwpn;
3670                         lp->new_portid = portid;
3671                         lp->new_roles = nr;
3672                         lp->state = FC_PORTDB_STATE_NEW;
3673                         isp_prt(isp, ISP_LOGSANCFG,
3674                             "Fabric Port 0x%06x is New Entry", portid);
3675                         continue;
3676                 }
3677
3678                 if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
3679                         isp_prt(isp, ISP_LOGWARN,
3680                             "PortID 0x%x 0x%08x%08x/0x%08x%08x %ld already at "
3681                             "idx %d, state 0x%x", portid,
3682                             (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3683                             (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3684                             (long) (lp - fcp->portdb), dbidx,
3685                             fcp->portdb[dbidx].state);
3686                         continue;
3687                 }
3688
3689                 /*
3690                  * We found a zombie entry that matches us.
3691                  * Revive it. We know that WWN and WWPN
3692                  * are the same. For fabric devices, we
3693                  * don't care that handle is different
3694                  * as we assign that. If role or portid
3695                  * are different, it maybe a changed device.
3696                  */
3697                 lp = &fcp->portdb[dbidx];
3698                 lp->handle = handle;
3699                 lp->new_portid = portid;
3700                 lp->new_roles = nr;
3701                 if (lp->portid != portid || lp->roles != nr) {
3702                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3703                             "Zombie Fabric Port 0x%06x Now Changed", portid);
3704                         lp->state = FC_PORTDB_STATE_CHANGED;
3705                 } else {
3706                         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3707                             "Zombie Fabric Port 0x%06x Now Pending Valid",
3708                             portid);
3709                         lp->state = FC_PORTDB_STATE_PENDING_VALID;
3710                 }
3711         }
3712
3713         FC_SCRATCH_RELEASE(isp);
3714         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3715                 ISP_MARK_PORTDB(isp, 1);
3716                 return (-1);
3717         }
3718         fcp->isp_loopstate = LOOP_FSCAN_DONE;
3719         isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "FC Scan Fabric Done");
3720         return (0);
3721 }
3722
3723 /*
3724  * Find an unused handle and try and use to login to a port.
3725  */
3726 static int
3727 isp_login_device(ispsoftc_t *isp, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)
3728 {
3729         int lim, i, r;
3730         uint16_t handle;
3731
3732         if (FCPARAM(isp)->isp_2klogin) {
3733                 lim = NPH_MAX_2K;
3734         } else {
3735                 lim = NPH_MAX;
3736         }
3737
3738         handle = isp_nxt_handle(isp, *ohp);
3739         for (i = 0; i < lim; i++) {
3740                 /*
3741                  * See if we're still logged into something with
3742                  * this handle and that something agrees with this
3743                  * port id.
3744                  */
3745                 r = isp_getpdb(isp, handle, p, 0);
3746                 if (r == 0 && p->portid != portid) {
3747                         (void) isp_plogx(isp, handle, portid,
3748                             PLOGX_FLG_CMD_LOGO | PLOGX_FLG_IMPLICIT, 1);
3749                 } else if (r == 0) {
3750                         break;
3751                 }
3752                 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3753                         return (-1);
3754                 }
3755                 /*
3756                  * Now try and log into the device
3757                  */
3758                 r = isp_plogx(isp, handle, portid, PLOGX_FLG_CMD_PLOGI, 1);
3759                 if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3760                         return (-1);
3761                 }
3762                 if (r == 0) {
3763                         *ohp = handle;
3764                         break;
3765                 } else if ((r & 0xffff) == MBOX_PORT_ID_USED) {
3766                         handle = r >> 16;
3767                         break;
3768                 } else if (r != MBOX_LOOP_ID_USED) {
3769                         i = lim;
3770                         break;
3771                 } else {
3772                         *ohp = handle;
3773                         handle = isp_nxt_handle(isp, *ohp);
3774                 }
3775         }
3776
3777         if (i == lim) {
3778                 isp_prt(isp, ISP_LOGWARN, "PLOGI 0x%06x failed", portid);
3779                 return (-1);
3780         }
3781
3782         /*
3783          * If we successfully logged into it, get the PDB for it
3784          * so we can crosscheck that it is still what we think it
3785          * is and that we also have the role it plays
3786          */
3787         r = isp_getpdb(isp, handle, p, 0);
3788         if (FCPARAM(isp)->isp_loopstate != LOOP_SCANNING_FABRIC) {
3789                 return (-1);
3790         }
3791         if (r != 0) {
3792                 isp_prt(isp, ISP_LOGERR, "new device 0x%06x@0x%x disappeared",
3793                     portid, handle);
3794                 return (-1);
3795         }
3796
3797         if (p->handle != handle || p->portid != portid) {
3798                 isp_prt(isp, ISP_LOGERR,
3799                     "new device 0x%06x@0x%x changed (0x%06x@0x%0x)",
3800                     portid, handle, p->portid, p->handle);
3801                 return (-1);
3802         }
3803         return (0);
3804 }
3805
3806 static int
3807 isp_register_fc4_type(ispsoftc_t *isp)
3808 {
3809         fcparam *fcp = isp->isp_param;
3810         uint8_t local[SNS_RFT_ID_REQ_SIZE];
3811         sns_screq_t *reqp = (sns_screq_t *) local;
3812         mbreg_t mbs;
3813
3814         MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
3815         reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
3816         reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
3817         reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
3818         reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
3819         reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
3820         reqp->snscb_sblen = 22;
3821         reqp->snscb_data[0] = SNS_RFT_ID;
3822         reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
3823         reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
3824         reqp->snscb_data[6] = (1 << FC4_SCSI);
3825         FC_SCRATCH_ACQUIRE(isp);
3826         isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
3827         MEMZERO(&mbs, sizeof (mbs));
3828         mbs.param[0] = MBOX_SEND_SNS;
3829         mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
3830         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3831         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3832         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3833         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3834         mbs.logval = MBLOGALL;
3835         mbs.timeout = 10000000;
3836         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_RFT_ID_REQ_SIZE);
3837         isp_mboxcmd(isp, &mbs);
3838         FC_SCRATCH_RELEASE(isp);
3839         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3840                 return (0);
3841         } else {
3842                 return (-1);
3843         }
3844 }
3845
3846 static int
3847 isp_register_fc4_type_24xx(ispsoftc_t *isp)
3848 {
3849         mbreg_t mbs;
3850         fcparam *fcp = FCPARAM(isp);
3851         union {
3852                 isp_ct_pt_t plocal;
3853                 rft_id_t clocal;
3854                 uint8_t q[QENTRY_LEN];
3855         } un;
3856         isp_ct_pt_t *pt;
3857         ct_hdr_t *ct;
3858         rft_id_t *rp;
3859         uint8_t *scp = fcp->isp_scratch;
3860
3861         FC_SCRATCH_ACQUIRE(isp);
3862         /*
3863          * Build a Passthrough IOCB in memory.
3864          */
3865         MEMZERO(un.q, QENTRY_LEN);
3866         pt = &un.plocal;
3867         pt->ctp_header.rqs_entry_count = 1;
3868         pt->ctp_header.rqs_entry_type = RQSTYPE_CT_PASSTHRU;
3869         pt->ctp_handle = 0xffffffff;
3870         pt->ctp_nphdl = NPH_SNS_ID;
3871         pt->ctp_cmd_cnt = 1;
3872         pt->ctp_time = 1;
3873         pt->ctp_rsp_cnt = 1;
3874         pt->ctp_rsp_bcnt = sizeof (ct_hdr_t);
3875         pt->ctp_cmd_bcnt = sizeof (rft_id_t);
3876         pt->ctp_dataseg[0].ds_base = DMA_LO32(fcp->isp_scdma+XTXOFF);
3877         pt->ctp_dataseg[0].ds_basehi = DMA_HI32(fcp->isp_scdma+XTXOFF);
3878         pt->ctp_dataseg[0].ds_count = sizeof (rft_id_t);
3879         pt->ctp_dataseg[1].ds_base = DMA_LO32(fcp->isp_scdma+IGPOFF);
3880         pt->ctp_dataseg[1].ds_basehi = DMA_HI32(fcp->isp_scdma+IGPOFF);
3881         pt->ctp_dataseg[1].ds_count = sizeof (ct_hdr_t);
3882         isp_put_ct_pt(isp, pt, (isp_ct_pt_t *) &scp[CTXOFF]);
3883
3884         /*
3885          * Build the CT header and command in memory.
3886          *
3887          * Note that the CT header has to end up as Big Endian format in memory.
3888          */
3889         MEMZERO(&un.clocal, sizeof (un.clocal));
3890         ct = &un.clocal.rftid_hdr;
3891         ct->ct_revision = CT_REVISION;
3892         ct->ct_fcs_type = CT_FC_TYPE_FC;
3893         ct->ct_fcs_subtype = CT_FC_SUBTYPE_NS;
3894         ct->ct_cmd_resp = SNS_RFT_ID;
3895         ct->ct_bcnt_resid = (sizeof (rft_id_t) - sizeof (ct_hdr_t)) >> 2;
3896         rp = &un.clocal;
3897         rp->rftid_portid[0] = fcp->isp_portid >> 16;
3898         rp->rftid_portid[1] = fcp->isp_portid >> 8;
3899         rp->rftid_portid[2] = fcp->isp_portid;
3900         rp->rftid_fc4types[FC4_SCSI >> 5] = 1 << (FC4_SCSI & 0x1f);
3901         isp_put_rft_id(isp, rp, (rft_id_t *) &scp[XTXOFF]);
3902
3903         MEMZERO(&scp[ZTXOFF], sizeof (ct_hdr_t));
3904
3905         MEMZERO(&mbs, sizeof (mbs));
3906         mbs.param[0] = MBOX_EXEC_COMMAND_IOCB_A64;
3907         mbs.param[1] = QENTRY_LEN;
3908         mbs.param[2] = DMA_WD1(fcp->isp_scdma + CTXOFF);
3909         mbs.param[3] = DMA_WD0(fcp->isp_scdma + CTXOFF);
3910         mbs.param[6] = DMA_WD3(fcp->isp_scdma + CTXOFF);
3911         mbs.param[7] = DMA_WD2(fcp->isp_scdma + CTXOFF);
3912         mbs.timeout = 500000;
3913         mbs.logval = MBLOGALL;
3914         MEMORYBARRIER(isp, SYNC_SFORDEV, XTXOFF, 2 * QENTRY_LEN);
3915         isp_mboxcmd(isp, &mbs);
3916         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3917                 FC_SCRATCH_RELEASE(isp);
3918                 return (-1);
3919         }
3920         MEMORYBARRIER(isp, SYNC_SFORCPU, ZTXOFF, QENTRY_LEN);
3921         pt = &un.plocal;
3922         isp_get_ct_pt(isp, (isp_ct_pt_t *) &scp[ZTXOFF], pt);
3923         if (isp->isp_dblev & ISP_LOGDEBUG1) {
3924                 isp_print_bytes(isp, "IOCB response", QENTRY_LEN, pt);
3925         }
3926         if (pt->ctp_status) {
3927                 FC_SCRATCH_RELEASE(isp);
3928                 isp_prt(isp, ISP_LOGWARN, "CT Passthrough returned 0x%x",
3929                     pt->ctp_status);
3930                 return (-1);
3931         }
3932
3933         isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
3934         FC_SCRATCH_RELEASE(isp);
3935
3936         if (ct->ct_cmd_resp == LS_RJT) {
3937                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3938                     "Register FC4 Type rejected");
3939                 return (-1);
3940         } else if (ct->ct_cmd_resp == LS_ACC) {
3941                 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3942                     "Register FC4 Type accepted");
3943                 return(0);
3944         } else {
3945                 isp_prt(isp, ISP_LOGWARN,
3946                     "Register FC4 Type: 0x%x", ct->ct_cmd_resp);
3947                 return (-1);
3948         }
3949 }
3950
3951 static uint16_t
3952 isp_nxt_handle(ispsoftc_t *isp, uint16_t handle)
3953 {
3954         int i;
3955         if (handle == NIL_HANDLE) {
3956                 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
3957                         handle = 0;
3958                 } else {
3959                         handle = SNS_ID+1;
3960                 }
3961         } else {
3962                 handle += 1;
3963                 if (handle >= FL_ID && handle <= SNS_ID) {
3964                         handle = SNS_ID+1;
3965                 }
3966                 if (handle >= NPH_RESERVED && handle <= NPH_FL_ID) {
3967                         handle = NPH_FL_ID+1;
3968                 }
3969                 if (FCPARAM(isp)->isp_2klogin) {
3970                         if (handle == NPH_MAX_2K) {
3971                                 handle = 0;
3972                         }
3973                 } else {
3974                         if (handle == NPH_MAX) {
3975                                 handle = 0;
3976                         }
3977                 }
3978         }
3979         if (handle == FCPARAM(isp)->isp_loopid) {
3980                 return (isp_nxt_handle(isp, handle));
3981         }
3982         for (i = 0; i < MAX_FC_TARG; i++) {
3983                 if (FCPARAM(isp)->portdb[i].state == FC_PORTDB_STATE_NIL) {
3984                         continue;
3985                 }
3986                 if (FCPARAM(isp)->portdb[i].handle == handle) {
3987                         return (isp_nxt_handle(isp, handle));
3988                 }
3989         }
3990         return (handle);
3991 }
3992
3993 /*
3994  * Start a command. Locking is assumed done in the caller.
3995  */
3996
3997 int
3998 isp_start(XS_T *xs)
3999 {
4000         ispsoftc_t *isp;
4001         uint32_t nxti, optr, handle;
4002         uint8_t local[QENTRY_LEN];
4003         ispreq_t *reqp, *qep;
4004         void *cdbp;
4005         uint16_t *tptr;
4006         int target, i, hdlidx = 0;
4007
4008         XS_INITERR(xs);
4009         isp = XS_ISP(xs);
4010
4011         /*
4012          * Check to make sure we're supporting initiator role.
4013          */
4014         if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
4015                 XS_SETERR(xs, HBA_SELTIMEOUT);
4016                 return (CMD_COMPLETE);
4017         }
4018
4019         /*
4020          * Now make sure we're running.
4021          */
4022
4023         if (isp->isp_state != ISP_RUNSTATE) {
4024                 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
4025                 XS_SETERR(xs, HBA_BOTCH);
4026                 return (CMD_COMPLETE);
4027         }
4028
4029         /*
4030          * Check command CDB length, etc.. We really are limited to 16 bytes
4031          * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
4032          * but probably only if we're running fairly new firmware (we'll
4033          * let the old f/w choke on an extended command queue entry).
4034          */
4035
4036         if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
4037                 isp_prt(isp, ISP_LOGERR,
4038                     "unsupported cdb length (%d, CDB[0]=0x%x)",
4039                     XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
4040                 XS_SETERR(xs, HBA_BOTCH);
4041                 return (CMD_COMPLETE);
4042         }
4043
4044         /*
4045          * Translate the target to device handle as appropriate, checking
4046          * for correct device state as well.
4047          */
4048         target = XS_TGT(xs);
4049         if (IS_FC(isp)) {
4050                 fcparam *fcp = isp->isp_param;
4051
4052                 /*
4053                  * Try again later.
4054                  */
4055                 if (fcp->isp_fwstate != FW_READY ||
4056                     fcp->isp_loopstate != LOOP_READY) {
4057                         return (CMD_RQLATER);
4058                 }
4059
4060                 if (XS_TGT(xs) >= MAX_FC_TARG) {
4061                         XS_SETERR(xs, HBA_SELTIMEOUT);
4062                         return (CMD_COMPLETE);
4063                 }
4064
4065                 hdlidx = fcp->isp_ini_map[XS_TGT(xs)] - 1;
4066                 isp_prt(isp, ISP_LOGDEBUG1, "XS_TGT(xs)=%d- hdlidx value %d",
4067                     XS_TGT(xs), hdlidx);
4068                 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4069                         XS_SETERR(xs, HBA_SELTIMEOUT);
4070                         return (CMD_COMPLETE);
4071                 }
4072                 if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
4073                         return (CMD_RQLATER);
4074                 }
4075                 if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
4076                         XS_SETERR(xs, HBA_SELTIMEOUT);
4077                         return (CMD_COMPLETE);
4078                 }
4079                 target = fcp->portdb[hdlidx].handle;
4080         }
4081
4082         /*
4083          * Next check to see if any HBA or Device parameters need to be updated.
4084          */
4085         if (isp->isp_update != 0) {
4086                 isp_update(isp);
4087         }
4088
4089  start_again:
4090
4091         if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
4092                 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
4093                 XS_SETERR(xs, HBA_BOTCH);
4094                 return (CMD_EAGAIN);
4095         }
4096
4097         /*
4098          * Now see if we need to synchronize the ISP with respect to anything.
4099          * We do dual duty here (cough) for synchronizing for busses other
4100          * than which we got here to send a command to.
4101          */
4102         reqp = (ispreq_t *) local;
4103         if (isp->isp_sendmarker) {
4104                 if (IS_24XX(isp)) {
4105                         isp_marker_24xx_t *m = (isp_marker_24xx_t *) qep;
4106                         MEMZERO(m, QENTRY_LEN);
4107                         m->mrk_header.rqs_entry_count = 1;
4108                         m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4109                         m->mrk_modifier = SYNC_ALL;
4110                         isp_put_marker_24xx(isp, m, (isp_marker_24xx_t *)qep);
4111                         ISP_ADD_REQUEST(isp, nxti);
4112                         isp->isp_sendmarker = 0;
4113                         goto start_again;
4114                 } else {
4115                         for (i = 0; i < (IS_DUALBUS(isp)? 2: 1); i++) {
4116                                 isp_marker_t *m = (isp_marker_t *) qep;
4117                                 if ((isp->isp_sendmarker & (1 << i)) == 0) {
4118                                         continue;
4119                                 }
4120                                 MEMZERO(m, QENTRY_LEN);
4121                                 m->mrk_header.rqs_entry_count = 1;
4122                                 m->mrk_header.rqs_entry_type = RQSTYPE_MARKER;
4123                                 m->mrk_target = (i << 7);       /* bus # */
4124                                 m->mrk_modifier = SYNC_ALL;
4125                                 isp_put_marker(isp, m, (isp_marker_t *) qep);
4126                                 ISP_ADD_REQUEST(isp, nxti);
4127                                 isp->isp_sendmarker &= ~(1 << i);
4128                                 goto start_again;
4129                         }
4130                 }
4131         }
4132
4133         MEMZERO((void *)reqp, QENTRY_LEN);
4134         reqp->req_header.rqs_entry_count = 1;
4135         if (IS_24XX(isp)) {
4136                 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4137         } else if (IS_FC(isp)) {
4138                 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4139         } else {
4140                 if (XS_CDBLEN(xs) > 12)
4141                         reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4142                 else
4143                         reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4144         }
4145         /* reqp->req_header.rqs_flags = 0; */
4146         /* reqp->req_header.rqs_seqno = 0; */
4147         if (IS_24XX(isp)) {
4148                 int ttype;
4149                 if (XS_TAG_P(xs)) {
4150                         ttype = XS_TAG_TYPE(xs);
4151                 } else {
4152                         if (XS_CDBP(xs)[0] == 0x3) {
4153                                 ttype = REQFLAG_HTAG;
4154                         } else {
4155                                 ttype = REQFLAG_STAG;
4156                         }
4157                 }
4158                 if (ttype == REQFLAG_OTAG) {
4159                         ttype = FCP_CMND_TASK_ATTR_ORDERED;
4160                 } else if (ttype == REQFLAG_HTAG) {
4161                         ttype = FCP_CMND_TASK_ATTR_HEAD;
4162                 } else {
4163                         ttype = FCP_CMND_TASK_ATTR_SIMPLE;
4164                 }
4165                 ((ispreqt7_t *)reqp)->req_task_attribute = ttype;
4166         } else if (IS_FC(isp)) {
4167                 /*
4168                  * See comment in isp_intr
4169                  */
4170                 /* XS_RESID(xs) = 0; */
4171
4172                 /*
4173                  * Fibre Channel always requires some kind of tag.
4174                  * The Qlogic drivers seem be happy not to use a tag,
4175                  * but this breaks for some devices (IBM drives).
4176                  */
4177                 if (XS_TAG_P(xs)) {
4178                         ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
4179                 } else {
4180                         /*
4181                          * If we don't know what tag to use, use HEAD OF QUEUE
4182                          * for Request Sense or Simple.
4183                          */
4184                         if (XS_CDBP(xs)[0] == 0x3)      /* REQUEST SENSE */
4185                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
4186                         else
4187                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
4188                 }
4189         } else {
4190                 sdparam *sdp = (sdparam *)isp->isp_param;
4191                 sdp += XS_CHANNEL(xs);
4192                 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
4193                     XS_TAG_P(xs)) {
4194                         reqp->req_flags = XS_TAG_TYPE(xs);
4195                 }
4196         }
4197         cdbp = reqp->req_cdb;
4198         tptr = &reqp->req_time;
4199
4200         if (IS_SCSI(isp)) {
4201                 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4202                 reqp->req_lun_trn = XS_LUN(xs);
4203                 reqp->req_cdblen = XS_CDBLEN(xs);
4204         } else if (IS_24XX(isp)) {
4205                 fcportdb_t *lp;
4206
4207                 lp = &FCPARAM(isp)->portdb[hdlidx];
4208                 ((ispreqt7_t *)reqp)->req_nphdl = target;
4209                 ((ispreqt7_t *)reqp)->req_tidlo = lp->portid;
4210                 ((ispreqt7_t *)reqp)->req_tidhi = lp->portid >> 16;
4211                 if (XS_LUN(xs) > 256) {
4212                         ((ispreqt7_t *)reqp)->req_lun[0] = XS_LUN(xs) >> 8;
4213                         ((ispreqt7_t *)reqp)->req_lun[0] |= 0x40;
4214                 }
4215                 ((ispreqt7_t *)reqp)->req_lun[1] = XS_LUN(xs);
4216                 cdbp = ((ispreqt7_t *)reqp)->req_cdb;
4217                 tptr = &((ispreqt7_t *)reqp)->req_time;
4218         } else if (FCPARAM(isp)->isp_2klogin) {
4219                 ((ispreqt2e_t *)reqp)->req_target = target;
4220                 ((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs);
4221         } else if (FCPARAM(isp)->isp_sccfw) {
4222                 ((ispreqt2_t *)reqp)->req_target = target;
4223                 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
4224         } else {
4225                 ((ispreqt2_t *)reqp)->req_target = target;
4226                 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
4227         }
4228         MEMCPY(cdbp, XS_CDBP(xs), XS_CDBLEN(xs));
4229
4230         *tptr = XS_TIME(xs) / 1000;
4231         if (*tptr == 0 && XS_TIME(xs)) {
4232                 *tptr = 1;
4233         }
4234         if (IS_24XX(isp) && *tptr > 0x1999) {
4235                 *tptr = 0x1999;
4236         }
4237
4238         if (isp_save_xs(isp, xs, &handle)) {
4239                 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
4240                 XS_SETERR(xs, HBA_BOTCH);
4241                 return (CMD_EAGAIN);
4242         }
4243         /* Whew. Thankfully the same for type 7 requests */
4244         reqp->req_handle = handle;
4245
4246         /*
4247          * Set up DMA and/or do any bus swizzling of the request entry
4248          * so that the Qlogic F/W understands what is being asked of it.
4249          */
4250         i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
4251         if (i != CMD_QUEUED) {
4252                 isp_destroy_handle(isp, handle);
4253                 /*
4254                  * dmasetup sets actual error in packet, and
4255                  * return what we were given to return.
4256                  */
4257                 return (i);
4258         }
4259         XS_SETERR(xs, HBA_NOERROR);
4260         isp_prt(isp, ISP_LOGDEBUG0,
4261             "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
4262             XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
4263             (long) XS_XFRLEN(xs));
4264         ISP_ADD_REQUEST(isp, nxti);
4265         isp->isp_nactive++;
4266         return (CMD_QUEUED);
4267 }
4268
4269 /*
4270  * isp control
4271  * Locks (ints blocked) assumed held.
4272  */
4273
4274 int
4275 isp_control(ispsoftc_t *isp, ispctl_t ctl, void *arg)
4276 {
4277         XS_T *xs;
4278         mbreg_t mbs;
4279         int bus, tgt;
4280         uint32_t handle;
4281
4282         MEMZERO(&mbs, sizeof (mbs));
4283
4284         switch (ctl) {
4285         default:
4286                 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
4287                 break;
4288
4289         case ISPCTL_RESET_BUS:
4290                 /*
4291                  * Issue a bus reset.
4292                  */
4293                 if (IS_24XX(isp)) {
4294                         isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLEMENTED");
4295                         break;
4296                 } else if (IS_FC(isp)) {
4297                         mbs.param[1] = 10;
4298                         bus = 0;
4299                 } else {
4300                         mbs.param[1] = SDPARAM(isp)->isp_bus_reset_delay;
4301                         if (mbs.param[1] < 2) {
4302                                 mbs.param[1] = 2;
4303                         }
4304                         bus = *((int *) arg);
4305                         if (IS_DUALBUS(isp)) {
4306                                 mbs.param[2] = bus;
4307                         }
4308                 }
4309                 mbs.param[0] = MBOX_BUS_RESET;
4310                 isp->isp_sendmarker |= (1 << bus);
4311                 mbs.logval = MBLOGALL;
4312                 isp_mboxcmd(isp, &mbs);
4313                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4314                         break;
4315                 }
4316                 isp_prt(isp, ISP_LOGINFO,
4317                     "driver initiated bus reset of bus %d", bus);
4318                 return (0);
4319
4320         case ISPCTL_RESET_DEV:
4321                 tgt = (*((int *) arg)) & 0xffff;
4322                 if (IS_24XX(isp)) {
4323                         isp_prt(isp, ISP_LOGWARN, "RESET DEV NOT IMPLEMENTED");
4324                         break;
4325                 } else if (IS_FC(isp)) {
4326                         if (FCPARAM(isp)->isp_2klogin) {
4327                                 mbs.param[1] = tgt;
4328                                 mbs.ibits = (1 << 10);
4329                         } else {
4330                                 mbs.param[1] = (tgt << 8);
4331                         }
4332                         bus = 0;
4333                 } else {
4334                         bus = (*((int *) arg)) >> 16;
4335                         mbs.param[1] = (bus << 15) | (tgt << 8);
4336                 }
4337                 mbs.param[0] = MBOX_ABORT_TARGET;
4338                 mbs.param[2] = 3;       /* 'delay', in seconds */
4339                 mbs.logval = MBLOGALL;
4340                 isp_mboxcmd(isp, &mbs);
4341                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4342                         break;
4343                 }
4344                 isp_prt(isp, ISP_LOGINFO,
4345                     "Target %d on Bus %d Reset Succeeded", tgt, bus);
4346                 isp->isp_sendmarker |= (1 << bus);
4347                 return (0);
4348
4349         case ISPCTL_ABORT_CMD:
4350                 xs = (XS_T *) arg;
4351                 tgt = XS_TGT(xs);
4352
4353                 handle = isp_find_handle(isp, xs);
4354                 if (handle == 0) {
4355                         isp_prt(isp, ISP_LOGWARN,
4356                             "cannot find handle for command to abort");
4357                         break;
4358                 }
4359                 if (IS_24XX(isp)) {
4360                         isp_prt(isp, ISP_LOGWARN, "ABORT CMD NOT IMPLEMENTED");
4361                         break;
4362                 } else if (IS_FC(isp)) {
4363                         if (FCPARAM(isp)->isp_sccfw) {
4364                                 if (FCPARAM(isp)->isp_2klogin) {
4365                                         mbs.param[1] = tgt;
4366                                 } else {
4367                                         mbs.param[1] = tgt << 8;
4368                                 }
4369                                 mbs.param[6] = XS_LUN(xs);
4370                         } else {
4371                                 mbs.param[1] = tgt << 8 | XS_LUN(xs);
4372                         }
4373                 } else {
4374                         bus = XS_CHANNEL(xs);
4375                         mbs.param[1] = (bus << 15) | (tgt << 8) | XS_LUN(xs);
4376                 }
4377                 mbs.param[0] = MBOX_ABORT;
4378                 mbs.param[2] = handle;
4379                 mbs.logval = MBLOGALL & ~MBOX_COMMAND_ERROR;
4380                 isp_mboxcmd(isp, &mbs);
4381                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4382                         break;
4383                 }
4384                 return (0);
4385
4386         case ISPCTL_UPDATE_PARAMS:
4387
4388                 isp_update(isp);
4389                 return (0);
4390
4391         case ISPCTL_FCLINK_TEST:
4392
4393                 if (IS_FC(isp)) {
4394                         int usdelay = *((int *) arg);
4395                         if (usdelay == 0) {
4396                                 usdelay =  250000;
4397                         }
4398                         return (isp_fclink_test(isp, usdelay));
4399                 }
4400                 break;
4401
4402         case ISPCTL_SCAN_FABRIC:
4403
4404                 if (IS_FC(isp)) {
4405                         return (isp_scan_fabric(isp));
4406                 }
4407                 break;
4408
4409         case ISPCTL_SCAN_LOOP:
4410
4411                 if (IS_FC(isp)) {
4412                         return (isp_scan_loop(isp));
4413                 }
4414                 break;
4415
4416         case ISPCTL_PDB_SYNC:
4417
4418                 if (IS_FC(isp)) {
4419                         return (isp_pdb_sync(isp));
4420                 }
4421                 break;
4422
4423         case ISPCTL_SEND_LIP:
4424
4425                 if (IS_FC(isp) && !IS_24XX(isp)) {
4426                         mbs.param[0] = MBOX_INIT_LIP;
4427                         if (FCPARAM(isp)->isp_2klogin) {
4428                                 mbs.ibits = (1 << 10);
4429                         }
4430                         mbs.logval = MBLOGALL;
4431                         isp_mboxcmd(isp, &mbs);
4432                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
4433                                 return (0);
4434                         }
4435                 }
4436                 break;
4437
4438         case ISPCTL_GET_PDB:
4439                 if (IS_FC(isp) && arg) {
4440                         int id = *((int *)arg);
4441                         isp_pdb_t *pdb = arg;
4442                         return (isp_getpdb(isp, id, pdb, 1));
4443                 }
4444                 break;
4445
4446         case ISPCTL_GET_PORTNAME:
4447         {
4448                 uint64_t *wwnp = arg;
4449                 int loopid = *wwnp;
4450                 *wwnp = isp_get_portname(isp, loopid, 0);
4451                 if (*wwnp == (uint64_t) -1) {
4452                         break;
4453                 } else {
4454                         return (0);
4455                 }
4456         }
4457         case ISPCTL_RUN_MBOXCMD:
4458
4459                 isp_mboxcmd(isp, arg);
4460                 return(0);
4461
4462         case ISPCTL_PLOGX:
4463         {
4464                 isp_plcmd_t *p = arg;
4465                 int r;
4466
4467                 if ((p->flags & PLOGX_FLG_CMD_MASK) != PLOGX_FLG_CMD_PLOGI ||
4468                     (p->handle != NIL_HANDLE)) {
4469                         return (isp_plogx(isp, p->handle, p->portid,
4470                             p->flags, 0));
4471                 }
4472                 do {
4473                         p->handle = isp_nxt_handle(isp, p->handle);
4474                         r = isp_plogx(isp, p->handle, p->portid, p->flags, 0);
4475                         if ((r & 0xffff) == MBOX_PORT_ID_USED) {
4476                                 p->handle = r >> 16;
4477                                 r = 0;
4478                                 break;
4479                         }
4480                 } while ((r & 0xffff) == MBOX_LOOP_ID_USED);
4481                 return (r);
4482         }
4483 #ifdef  ISP_TARGET_MODE
4484         case ISPCTL_TOGGLE_TMODE:
4485         {
4486
4487                 /*
4488                  * We don't check/set against role here- that's the
4489                  * responsibility for the outer layer to coordinate.
4490                  */
4491                 if (IS_SCSI(isp)) {
4492                         int param = *(int *)arg;
4493                         mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
4494                         mbs.param[1] = param & 0xffff;
4495                         mbs.param[2] = param >> 16;
4496                         mbs.logval = MBLOGALL;
4497                         isp_mboxcmd(isp, &mbs);
4498                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4499                                 break;
4500                         }
4501                 }
4502                 return (0);
4503         }
4504 #endif
4505         }
4506         return (-1);
4507 }
4508
4509 /*
4510  * Interrupt Service Routine(s).
4511  *
4512  * External (OS) framework has done the appropriate locking,
4513  * and the locking will be held throughout this function.
4514  */
4515
4516 /*
4517  * Limit our stack depth by sticking with the max likely number
4518  * of completions on a request queue at any one time.
4519  */
4520 #ifndef MAX_REQUESTQ_COMPLETIONS
4521 #define MAX_REQUESTQ_COMPLETIONS        32
4522 #endif
4523
4524 void
4525 isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
4526 {
4527         XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
4528         uint32_t iptr, optr, junk;
4529         int i, nlooked = 0, ndone = 0;
4530
4531 again:
4532         optr = isp->isp_residx;
4533         /*
4534          * Is this a mailbox related interrupt?
4535          * The mailbox semaphore will be nonzero if so.
4536          */
4537         if (sema) {
4538                 if (mbox & 0x4000) {
4539                         isp->isp_intmboxc++;
4540                         if (isp->isp_mboxbsy) {
4541                                 int obits = isp->isp_obits;
4542                                 isp->isp_mboxtmp[0] = mbox;
4543                                 for (i = 1; i < MAX_MAILBOX(isp); i++) {
4544                                         if ((obits & (1 << i)) == 0) {
4545                                                 continue;
4546                                         }
4547                                         isp->isp_mboxtmp[i] =
4548                                             ISP_READ(isp, MBOX_OFF(i));
4549                                 }
4550                                 if (isp->isp_mbxwrk0) {
4551                                         if (isp_mbox_continue(isp) == 0) {
4552                                                 return;
4553                                         }
4554                                 }
4555                                 MBOX_NOTIFY_COMPLETE(isp);
4556                         } else {
4557                                 isp_prt(isp, ISP_LOGWARN,
4558                                     "mailbox cmd (0x%x) with no waiters", mbox);
4559                         }
4560                 } else if (isp_parse_async(isp, mbox) < 0) {
4561                         return;
4562                 }
4563                 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
4564                     isp->isp_state != ISP_RUNSTATE) {
4565                         goto out;
4566                 }
4567         }
4568
4569         /*
4570          * We can't be getting this now.
4571          */
4572         if (isp->isp_state != ISP_RUNSTATE) {
4573                 isp_prt(isp, ISP_LOGINFO,
4574                     "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
4575                 /*
4576                  * Thank you very much!  *Burrrp*!
4577                  */
4578                 ISP_WRITE(isp, isp->isp_respoutrp,
4579                     ISP_READ(isp, isp->isp_respinrp));
4580                 if (IS_24XX(isp)) {
4581                         ISP_DISABLE_INTS(isp);
4582                 }
4583                 goto out;
4584         }
4585
4586 #ifdef  ISP_TARGET_MODE
4587         /*
4588          * Check for ATIO Queue entries.
4589          */
4590         if (isp->isp_rspbsy == 0 && (isp->isp_role & ISP_ROLE_TARGET) &&
4591             IS_24XX(isp)) {
4592                 iptr = ISP_READ(isp, isp->isp_atioinrp);
4593                 optr = ISP_READ(isp, isp->isp_atiooutrp);
4594
4595                 isp->isp_rspbsy = 1;
4596                 while (optr != iptr) {
4597                         uint8_t qe[QENTRY_LEN];
4598                         isphdr_t *hp;
4599                         uint32_t oop;
4600                         void *addr;
4601
4602                         oop = optr;
4603                         MEMORYBARRIER(isp, SYNC_ATIOQ, oop, QENTRY_LEN);
4604                         addr = ISP_QUEUE_ENTRY(isp->isp_atioq, oop);
4605                         isp_get_hdr(isp, addr, (isphdr_t *)qe);
4606                         hp = (isphdr_t *)qe;
4607                         switch (hp->rqs_entry_type) {
4608                         case RQSTYPE_NOTIFY:
4609                         case RQSTYPE_ATIO:
4610                                 (void) isp_target_notify(isp, addr, &oop);
4611                                 break;
4612                         default:
4613                                 isp_print_qentry(isp, "?ATIOQ entry?",
4614                                     oop, addr);
4615                                 break;
4616                         }
4617                         optr = ISP_NXT_QENTRY(oop, RESULT_QUEUE_LEN(isp));
4618                         ISP_WRITE(isp, isp->isp_atiooutrp, optr);
4619                 }
4620                 isp->isp_rspbsy = 0;
4621                 optr = isp->isp_residx;
4622         }
4623 #endif
4624
4625         /*
4626          * Get the current Response Queue Out Pointer.
4627          *
4628          * If we're a 2300 or 2400, we can ask what hardware what it thinks.
4629          */
4630         if (IS_23XX(isp) || IS_24XX(isp)) {
4631                 optr = ISP_READ(isp, isp->isp_respoutrp);
4632                 /*
4633                  * Debug: to be taken out eventually
4634                  */
4635                 if (isp->isp_residx != optr) {
4636                         isp_prt(isp, ISP_LOGINFO,
4637                             "isp_intr: hard optr=%x, soft optr %x",
4638                             optr, isp->isp_residx);
4639                         isp->isp_residx = optr;
4640                 }
4641         } else {
4642                 optr = isp->isp_residx;
4643         }
4644
4645         /*
4646          * You *must* read the Response Queue In Pointer
4647          * prior to clearing the RISC interrupt.
4648          *
4649          * Debounce the 2300 if revision less than 2.
4650          */
4651         if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
4652                 i = 0;
4653                 do {
4654                         iptr = ISP_READ(isp, isp->isp_respinrp);
4655                         junk = ISP_READ(isp, isp->isp_respinrp);
4656                 } while (junk != iptr && ++i < 1000);
4657
4658                 if (iptr != junk) {
4659                         isp_prt(isp, ISP_LOGWARN,
4660                             "Response Queue Out Pointer Unstable (%x, %x)",
4661                             iptr, junk);
4662                         goto out;
4663                 }
4664         } else {
4665                 iptr = ISP_READ(isp, isp->isp_respinrp);
4666         }
4667         isp->isp_resodx = iptr;
4668
4669
4670         if (optr == iptr && sema == 0) {
4671                 /*
4672                  * There are a lot of these- reasons unknown- mostly on
4673                  * faster Alpha machines.
4674                  *
4675                  * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
4676                  * make sure the old interrupt went away (to avoid 'ringing'
4677                  * effects), but that didn't stop this from occurring.
4678                  */
4679                 if (IS_24XX(isp)) {
4680                         junk = 0;
4681                 } else if (IS_23XX(isp)) {
4682                         USEC_DELAY(100);
4683                         iptr = ISP_READ(isp, isp->isp_respinrp);
4684                         junk = ISP_READ(isp, BIU_R2HSTSLO);
4685                 } else {
4686                         junk = ISP_READ(isp, BIU_ISR);
4687                 }
4688                 if (optr == iptr) {
4689                         if (IS_23XX(isp) || IS_24XX(isp)) {
4690                                 ;
4691                         } else {
4692                                 sema = ISP_READ(isp, BIU_SEMA);
4693                                 mbox = ISP_READ(isp, OUTMAILBOX0);
4694                                 if ((sema & 0x3) && (mbox & 0x8000)) {
4695                                         goto again;
4696                                 }
4697                         }
4698                         isp->isp_intbogus++;
4699                         isp_prt(isp, ISP_LOGDEBUG1,
4700                             "bogus intr- isr %x (%x) iptr %x optr %x",
4701                             isr, junk, iptr, optr);
4702                 }
4703         }
4704         isp->isp_resodx = iptr;
4705
4706
4707         if (isp->isp_rspbsy) {
4708                 goto out;
4709         }
4710         isp->isp_rspbsy = 1;
4711         while (optr != iptr) {
4712                 uint8_t qe[QENTRY_LEN];
4713                 ispstatusreq_t *sp = (ispstatusreq_t *) qe;
4714                 isphdr_t *hp;
4715                 int buddaboom, etype, scsi_status, completion_status;
4716                 int req_status_flags, req_state_flags;
4717                 uint8_t *snsp, *resp;
4718                 uint32_t rlen, slen;
4719                 long resid;
4720                 uint16_t oop;
4721
4722                 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
4723                 oop = optr;
4724                 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
4725                 nlooked++;
4726  read_again:
4727                 buddaboom = req_status_flags = req_state_flags = 0;
4728                 resid = 0L;
4729
4730                 /*
4731                  * Synchronize our view of this response queue entry.
4732                  */
4733                 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
4734                 isp_get_hdr(isp, hp, &sp->req_header);
4735                 etype = sp->req_header.rqs_entry_type;
4736
4737                 if (IS_24XX(isp) && etype == RQSTYPE_RESPONSE) {
4738                         isp24xx_statusreq_t *sp2 = (isp24xx_statusreq_t *)qe;
4739                         isp_get_24xx_response(isp,
4740                             (isp24xx_statusreq_t *)hp, sp2);
4741                         if (isp->isp_dblev & ISP_LOGDEBUG1) {
4742                                 isp_print_bytes(isp,
4743                                     "Response Queue Entry", QENTRY_LEN, sp2);
4744                         }
4745                         scsi_status = sp2->req_scsi_status;
4746                         completion_status = sp2->req_completion_status;
4747                         req_state_flags = 0;
4748                         resid = sp2->req_resid;
4749                 } else if (etype == RQSTYPE_RESPONSE) {
4750                         isp_get_response(isp, (ispstatusreq_t *) hp, sp);
4751                         if (isp->isp_dblev & ISP_LOGDEBUG1) {
4752                                 isp_print_bytes(isp,
4753                                     "Response Queue Entry", QENTRY_LEN, sp);
4754                         }
4755                         scsi_status = sp->req_scsi_status;
4756                         completion_status = sp->req_completion_status;
4757                         req_status_flags = sp->req_status_flags;
4758                         req_state_flags = sp->req_state_flags;
4759                         resid = sp->req_resid;
4760                 } else if (etype == RQSTYPE_RIO2) {
4761                         isp_rio2_t *rio = (isp_rio2_t *)qe;
4762                         isp_get_rio2(isp, (isp_rio2_t *) hp, rio);
4763                         if (isp->isp_dblev & ISP_LOGDEBUG1) {
4764                                 isp_print_bytes(isp,
4765                                     "Response Queue Entry", QENTRY_LEN, rio);
4766                         }
4767                         for (i = 0; i < rio->req_header.rqs_seqno; i++) {
4768                                 isp_fastpost_complete(isp, rio->req_handles[i]);
4769                         }
4770                         if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
4771                                 isp->isp_fpcchiwater =
4772                                     rio->req_header.rqs_seqno;
4773                         }
4774                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
4775                         continue;
4776                 } else {
4777                         /*
4778                          * Somebody reachable via isp_handle_other_response
4779                          * may have updated the response queue pointers for
4780                          * us, so we reload our goal index.
4781                          */
4782                         int r;
4783                         r = isp_handle_other_response(isp, etype, hp, &optr);
4784                         if (r < 0) {
4785                                 goto read_again;
4786                         }
4787                         if (r > 0) {
4788                                 iptr = isp->isp_resodx;
4789                                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
4790                                 continue;
4791                         }
4792
4793                         /*
4794                          * After this point, we'll just look at the header as
4795                          * we don't know how to deal with the rest of the
4796                          * response.
4797                          */
4798
4799                         /*
4800                          * It really has to be a bounced request just copied
4801                          * from the request queue to the response queue. If
4802                          * not, something bad has happened.
4803                          */
4804                         if (etype != RQSTYPE_REQUEST) {
4805                                 isp_prt(isp, ISP_LOGERR, notresp,
4806                                     etype, oop, optr, nlooked);
4807                                 isp_print_bytes(isp,
4808                                     "Request Queue Entry", QENTRY_LEN, sp);
4809                                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
4810                                 continue;
4811                         }
4812                         buddaboom = 1;
4813                         scsi_status = sp->req_scsi_status;
4814                         completion_status = sp->req_completion_status;
4815                         req_status_flags = sp->req_status_flags;
4816                         req_state_flags = sp->req_state_flags;
4817                         resid = sp->req_resid;
4818                 }
4819
4820                 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
4821                         if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
4822                                 isp_prt(isp, ISP_LOGWARN,
4823                                     "continuation segment");
4824                                 ISP_WRITE(isp, isp->isp_respoutrp, optr);
4825                                 continue;
4826                         }
4827                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4828                                 isp_prt(isp, ISP_LOGDEBUG1,
4829                                     "internal queues full");
4830                                 /*
4831                                  * We'll synthesize a QUEUE FULL message below.
4832                                  */
4833                         }
4834                         if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
4835                                 isp_print_bytes(isp, "bad header flag",
4836                                     QENTRY_LEN, sp);
4837                                 buddaboom++;
4838                         }
4839                         if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
4840                                 isp_print_bytes(isp, "bad request packet",
4841                                     QENTRY_LEN, sp);
4842                                 buddaboom++;
4843                         }
4844                 }
4845
4846                 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
4847                         isp_prt(isp, ISP_LOGERR,
4848                             "bad request handle %d (type 0x%x)",
4849                             sp->req_handle, etype);
4850                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
4851                         ISP_WRITE(isp, isp->isp_respoutrp, optr);
4852                         continue;
4853                 }
4854                 xs = isp_find_xs(isp, sp->req_handle);
4855                 if (xs == NULL) {
4856                         uint8_t ts = completion_status & 0xff;
4857                         /*
4858                          * Only whine if this isn't the expected fallout of
4859                          * aborting the command.
4860                          */
4861                         if (etype != RQSTYPE_RESPONSE) {
4862                                 isp_prt(isp, ISP_LOGERR,
4863                                     "cannot find handle 0x%x (type 0x%x)",
4864                                     sp->req_handle, etype);
4865                         } else if (ts != RQCS_ABORTED) {
4866                                 isp_prt(isp, ISP_LOGERR,
4867                                     "cannot find handle 0x%x (status 0x%x)",
4868                                     sp->req_handle, ts);
4869                         }
4870                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
4871                         ISP_WRITE(isp, isp->isp_respoutrp, optr);
4872                         continue;
4873                 }
4874                 isp_destroy_handle(isp, sp->req_handle);
4875                 if (req_status_flags & RQSTF_BUS_RESET) {
4876                         XS_SETERR(xs, HBA_BUSRESET);
4877                         isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4878                 }
4879                 if (buddaboom) {
4880                         XS_SETERR(xs, HBA_BOTCH);
4881                 }
4882
4883                 resp = NULL;
4884                 rlen = 0;
4885                 snsp = NULL;
4886                 slen = 0;
4887                 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
4888                         resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4889                         rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
4890                 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
4891                         resp = sp->req_response;
4892                         rlen = sp->req_response_len;
4893                 }
4894                 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
4895                         /*
4896                          * Fibre Channel F/W doesn't say we got status
4897                          * if there's Sense Data instead. I guess they
4898                          * think it goes w/o saying.
4899                          */
4900                         req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
4901                         if (IS_24XX(isp)) {
4902                                 snsp =
4903                                     ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
4904                                 snsp += rlen;
4905                                 slen =
4906                                     ((isp24xx_statusreq_t *)sp)->req_sense_len;
4907                         } else {
4908                                 snsp = sp->req_sense_data;
4909                                 slen = sp->req_sense_len;
4910                         }
4911                 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
4912                         snsp = sp->req_sense_data;
4913                         slen = sp->req_sense_len;
4914                 }
4915                 if (req_state_flags & RQSF_GOT_STATUS) {
4916                         *XS_STSP(xs) = scsi_status & 0xff;
4917                 }
4918
4919                 switch (etype) {
4920                 case RQSTYPE_RESPONSE:
4921                         XS_SET_STATE_STAT(isp, xs, sp);
4922                         if (resp && rlen >= 4 &&
4923                             resp[FCP_RSPNS_CODE_OFFSET] != 0) {
4924                                 isp_prt(isp, ISP_LOGWARN,
4925                                     "%d.%d.%d FCP RESPONSE: 0x%x",
4926                                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
4927                                     resp[FCP_RSPNS_CODE_OFFSET]);
4928                                 XS_SETERR(xs, HBA_BOTCH);
4929                         }
4930                         if (IS_24XX(isp)) {
4931                                 isp_parse_status_24xx(isp,
4932                                     (isp24xx_statusreq_t *)sp, xs, &resid);
4933                         } else {
4934                                 isp_parse_status(isp, (void *)sp, xs, &resid);
4935                         }
4936                         if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
4937                             (*XS_STSP(xs) == SCSI_BUSY)) {
4938                                 XS_SETERR(xs, HBA_TGTBSY);
4939                         }
4940                         if (IS_SCSI(isp)) {
4941                                 XS_RESID(xs) = resid;
4942                                 /*
4943                                  * A new synchronous rate was negotiated for
4944                                  * this target. Mark state such that we'll go
4945                                  * look up that which has changed later.
4946                                  */
4947                                 if (req_status_flags & RQSTF_NEGOTIATION) {
4948                                         int t = XS_TGT(xs);
4949                                         sdparam *sdp = isp->isp_param;
4950                                         sdp += XS_CHANNEL(xs);
4951                                         sdp->isp_devparam[t].dev_refresh = 1;
4952                                         isp->isp_update |=
4953                                             (1 << XS_CHANNEL(xs));
4954                                 }
4955                         } else {
4956                                 if (req_status_flags & RQSF_XFER_COMPLETE) {
4957                                         XS_RESID(xs) = 0;
4958                                 } else if (scsi_status & RQCS_RESID) {
4959                                         XS_RESID(xs) = resid;
4960                                 } else {
4961                                         XS_RESID(xs) = 0;
4962                                 }
4963                         }
4964                         if (snsp && slen) {
4965                                 XS_SAVE_SENSE(xs, snsp, slen);
4966                         }
4967                         isp_prt(isp, ISP_LOGDEBUG2,
4968                            "asked for %ld got raw resid %ld settled for %ld",
4969                             (long) XS_XFRLEN(xs), resid, (long) XS_RESID(xs));
4970                         break;
4971                 case RQSTYPE_REQUEST:
4972                 case RQSTYPE_A64:
4973                 case RQSTYPE_T2RQS:
4974                 case RQSTYPE_T3RQS:
4975                 case RQSTYPE_T7RQS:
4976                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
4977                                 /*
4978                                  * Force Queue Full status.
4979                                  */
4980                                 *XS_STSP(xs) = SCSI_QFULL;
4981                                 XS_SETERR(xs, HBA_NOERROR);
4982                         } else if (XS_NOERR(xs)) {
4983                                 /*
4984                                  * ????
4985                                  */
4986                                 XS_SETERR(xs, HBA_BOTCH);
4987                                 isp_prt(isp, ISP_LOGDEBUG0,
4988                                     "Request Queue Entry bounced back");
4989                                 if ((isp->isp_dblev & ISP_LOGDEBUG1) == 0) {
4990                                         isp_print_bytes(isp, "Bounced Request",
4991                                             QENTRY_LEN, qe);
4992                                 }
4993                         }
4994                         XS_RESID(xs) = XS_XFRLEN(xs);
4995                         break;
4996                 default:
4997                         isp_print_bytes(isp, "Unhandled Response Type",
4998                             QENTRY_LEN, qe);
4999                         if (XS_NOERR(xs)) {
5000                                 XS_SETERR(xs, HBA_BOTCH);
5001                         }
5002                         break;
5003                 }
5004
5005                 /*
5006                  * Free any DMA resources. As a side effect, this may
5007                  * also do any cache flushing necessary for data coherence.
5008                  */
5009                 if (XS_XFRLEN(xs)) {
5010                         ISP_DMAFREE(isp, xs, sp->req_handle);
5011                 }
5012
5013                 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5014                     ((isp->isp_dblev & ISP_LOGDEBUG0) && ((!XS_NOERR(xs)) ||
5015                     (*XS_STSP(xs) != SCSI_GOOD)))) {
5016                         char skey;
5017                         if (req_state_flags & RQSF_GOT_SENSE) {
5018                                 skey = XS_SNSKEY(xs) & 0xf;
5019                                 if (skey < 10)
5020                                         skey += '0';
5021                                 else
5022                                         skey += 'a' - 10;
5023                         } else if (*XS_STSP(xs) == SCSI_CHECK) {
5024                                 skey = '?';
5025                         } else {
5026                                 skey = '.';
5027                         }
5028                         isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
5029                             XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
5030                             *XS_STSP(xs), skey, XS_ERR(xs));
5031                 }
5032
5033                 if (isp->isp_nactive > 0)
5034                     isp->isp_nactive--;
5035                 complist[ndone++] = xs; /* defer completion call until later */
5036                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
5037                 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
5038                         break;
5039                 }
5040         }
5041
5042         /*
5043          * If we looked at any commands, then it's valid to find out
5044          * what the outpointer is. It also is a trigger to update the
5045          * ISP's notion of what we've seen so far.
5046          */
5047         if (nlooked) {
5048                 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5049                 /*
5050                  * While we're at it, read the requst queue out pointer.
5051                  */
5052                 isp->isp_reqodx = ISP_READ(isp, isp->isp_rqstoutrp);
5053                 if (isp->isp_rscchiwater < ndone) {
5054                         isp->isp_rscchiwater = ndone;
5055                 }
5056         }
5057
5058 out:
5059
5060         if (IS_24XX(isp)) {
5061                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
5062         } else {
5063                 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5064                 ISP_WRITE(isp, BIU_SEMA, 0);
5065         }
5066
5067         isp->isp_residx = optr;
5068         isp->isp_rspbsy = 0;
5069         for (i = 0; i < ndone; i++) {
5070                 xs = complist[i];
5071                 if (xs) {
5072                         isp->isp_rsltccmplt++;
5073                         isp_done(xs);
5074                 }
5075         }
5076 }
5077
5078 /*
5079  * Support routines.
5080  */
5081
5082 static int
5083 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
5084 {
5085         int rval = 0;
5086         int bus;
5087
5088         if (IS_DUALBUS(isp)) {
5089                 bus = ISP_READ(isp, OUTMAILBOX6);
5090         } else {
5091                 bus = 0;
5092         }
5093         isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
5094
5095         switch (mbox) {
5096         case ASYNC_BUS_RESET:
5097                 isp->isp_sendmarker |= (1 << bus);
5098 #ifdef  ISP_TARGET_MODE
5099                 if (isp_target_async(isp, bus, mbox)) {
5100                         rval = -1;
5101                 }
5102 #endif
5103                 isp_async(isp, ISPASYNC_BUS_RESET, &bus);
5104                 break;
5105         case ASYNC_SYSTEM_ERROR:
5106                 isp->isp_state = ISP_CRASHED;
5107                 if (IS_FC(isp)) {
5108                         FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5109                         FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5110                 }
5111                 /*
5112                  * Were we waiting for a mailbox command to complete?
5113                  * If so, it's dead, so wake up the waiter.
5114                  */
5115                 if (isp->isp_mboxbsy) {
5116                         isp->isp_obits = 1;
5117                         isp->isp_mboxtmp[0] = MBOX_HOST_INTERFACE_ERROR;
5118                         MBOX_NOTIFY_COMPLETE(isp);
5119                 }
5120                 /*
5121                  * It's up to the handler for isp_async to reinit stuff and
5122                  * restart the firmware
5123                  */
5124                 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5125                 rval = -1;
5126                 break;
5127
5128         case ASYNC_RQS_XFER_ERR:
5129                 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
5130                 break;
5131
5132         case ASYNC_RSP_XFER_ERR:
5133                 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
5134                 break;
5135
5136         case ASYNC_QWAKEUP:
5137                 /*
5138                  * We've just been notified that the Queue has woken up.
5139                  * We don't need to be chatty about this- just unlatch things
5140                  * and move on.
5141                  */
5142                 mbox = ISP_READ(isp, isp->isp_rqstoutrp);
5143                 break;
5144
5145         case ASYNC_TIMEOUT_RESET:
5146                 isp_prt(isp, ISP_LOGWARN,
5147                     "timeout initiated SCSI bus reset of bus %d", bus);
5148                 isp->isp_sendmarker |= (1 << bus);
5149 #ifdef  ISP_TARGET_MODE
5150                 if (isp_target_async(isp, bus, mbox)) {
5151                         rval = -1;
5152                 }
5153 #endif
5154                 break;
5155
5156         case ASYNC_DEVICE_RESET:
5157                 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
5158                 isp->isp_sendmarker |= (1 << bus);
5159 #ifdef  ISP_TARGET_MODE
5160                 if (isp_target_async(isp, bus, mbox)) {
5161                         rval = -1;
5162                 }
5163 #endif
5164                 break;
5165
5166         case ASYNC_EXTMSG_UNDERRUN:
5167                 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
5168                 break;
5169
5170         case ASYNC_SCAM_INT:
5171                 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
5172                 break;
5173
5174         case ASYNC_HUNG_SCSI:
5175                 isp_prt(isp, ISP_LOGERR,
5176                     "stalled SCSI Bus after DATA Overrun");
5177                 /* XXX: Need to issue SCSI reset at this point */
5178                 break;
5179
5180         case ASYNC_KILLED_BUS:
5181                 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
5182                 break;
5183
5184         case ASYNC_BUS_TRANSIT:
5185                 mbox = ISP_READ(isp, OUTMAILBOX2);
5186                 switch (mbox & 0x1c00) {
5187                 case SXP_PINS_LVD_MODE:
5188                         isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
5189                         SDPARAM(isp)->isp_diffmode = 0;
5190                         SDPARAM(isp)->isp_ultramode = 0;
5191                         SDPARAM(isp)->isp_lvdmode = 1;
5192                         break;
5193                 case SXP_PINS_HVD_MODE:
5194                         isp_prt(isp, ISP_LOGINFO,
5195                             "Transition to Differential mode");
5196                         SDPARAM(isp)->isp_diffmode = 1;
5197                         SDPARAM(isp)->isp_ultramode = 0;
5198                         SDPARAM(isp)->isp_lvdmode = 0;
5199                         break;
5200                 case SXP_PINS_SE_MODE:
5201                         isp_prt(isp, ISP_LOGINFO,
5202                             "Transition to Single Ended mode");
5203                         SDPARAM(isp)->isp_diffmode = 0;
5204                         SDPARAM(isp)->isp_ultramode = 1;
5205                         SDPARAM(isp)->isp_lvdmode = 0;
5206                         break;
5207                 default:
5208                         isp_prt(isp, ISP_LOGWARN,
5209                             "Transition to Unknown Mode 0x%x", mbox);
5210                         break;
5211                 }
5212                 /*
5213                  * XXX: Set up to renegotiate again!
5214                  */
5215                 /* Can only be for a 1080... */
5216                 isp->isp_sendmarker |= (1 << bus);
5217                 break;
5218
5219         /*
5220          * We can use bus, which will always be zero for FC cards,
5221          * as a mailbox pattern accumulator to be checked below.
5222          */
5223         case ASYNC_RIO5:
5224                 bus = 0x1ce;    /* outgoing mailbox regs 1-3, 6-7 */
5225                 break;
5226
5227         case ASYNC_RIO4:
5228                 bus = 0x14e;    /* outgoing mailbox regs 1-3, 6 */
5229                 break;
5230
5231         case ASYNC_RIO3:
5232                 bus = 0x10e;    /* outgoing mailbox regs 1-3 */
5233                 break;
5234
5235         case ASYNC_RIO2:
5236                 bus = 0x106;    /* outgoing mailbox regs 1-2 */
5237                 break;
5238
5239         case ASYNC_RIO1:
5240         case ASYNC_CMD_CMPLT:
5241                 bus = 0x102;    /* outgoing mailbox regs 1 */
5242                 break;
5243
5244         case ASYNC_RIO_RESP:
5245                 return (rval);
5246
5247         case ASYNC_CTIO_DONE:
5248         {
5249 #ifdef  ISP_TARGET_MODE
5250                 int handle =
5251                     (ISP_READ(isp, OUTMAILBOX2) << 16) |
5252                     (ISP_READ(isp, OUTMAILBOX1));
5253                 if (isp_target_async(isp, handle, mbox)) {
5254                         rval = -1;
5255                 } else {
5256                         /* count it as a fast posting intr */
5257                         isp->isp_fphccmplt++;
5258                 }
5259 #else
5260                 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
5261                 isp->isp_fphccmplt++;   /* count it as a fast posting intr */
5262 #endif
5263                 break;
5264         }
5265         case ASYNC_LIP_ERROR:
5266         case ASYNC_LIP_F8:
5267         case ASYNC_LIP_OCCURRED:
5268                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5269                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5270                 isp->isp_sendmarker = 1;
5271                 ISP_MARK_PORTDB(isp, 1);
5272                 isp_async(isp, ISPASYNC_LIP, NULL);
5273 #ifdef  ISP_TARGET_MODE
5274                 if (isp_target_async(isp, bus, mbox)) {
5275                         rval = -1;
5276                 }
5277 #endif
5278                 /*
5279                  * We've had problems with data corruption occuring on
5280                  * commands that complete (with no apparent error) after
5281                  * we receive a LIP. This has been observed mostly on
5282                  * Local Loop topologies. To be safe, let's just mark
5283                  * all active commands as dead.
5284                  */
5285                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5286                     FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5287                         int i, j;
5288                         for (i = j = 0; i < isp->isp_maxcmds; i++) {
5289                                 XS_T *xs;
5290                                 xs = isp->isp_xflist[i];
5291                                 if (xs != NULL) {
5292                                         j++;
5293                                         XS_SETERR(xs, HBA_BUSRESET);
5294                                 }
5295                         }
5296                         if (j) {
5297                                 isp_prt(isp, ISP_LOGERR,
5298                                     "LIP destroyed %d active commands", j);
5299                         }
5300                 }
5301                 break;
5302
5303         case ASYNC_LOOP_UP:
5304                 isp->isp_sendmarker = 1;
5305                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5306                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5307                 ISP_MARK_PORTDB(isp, 1);
5308                 isp_async(isp, ISPASYNC_LOOP_UP, NULL);
5309 #ifdef  ISP_TARGET_MODE
5310                 if (isp_target_async(isp, bus, mbox)) {
5311                         rval = -1;
5312                 }
5313 #endif
5314                 break;
5315
5316         case ASYNC_LOOP_DOWN:
5317                 isp->isp_sendmarker = 1;
5318                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5319                 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5320                 ISP_MARK_PORTDB(isp, 1);
5321                 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
5322 #ifdef  ISP_TARGET_MODE
5323                 if (isp_target_async(isp, bus, mbox)) {
5324                         rval = -1;
5325                 }
5326 #endif
5327                 break;
5328
5329         case ASYNC_LOOP_RESET:
5330                 isp->isp_sendmarker = 1;
5331                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5332                 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
5333                 ISP_MARK_PORTDB(isp, 1);
5334                 isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
5335 #ifdef  ISP_TARGET_MODE
5336                 if (isp_target_async(isp, bus, mbox)) {
5337                         rval = -1;
5338                 }
5339 #endif
5340                 break;
5341
5342         case ASYNC_PDB_CHANGED:
5343                 isp->isp_sendmarker = 1;
5344                 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5345                 ISP_MARK_PORTDB(isp, 1);
5346                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
5347                 break;
5348
5349         case ASYNC_CHANGE_NOTIFY:
5350                 if (FCPARAM(isp)->isp_topo == TOPO_F_PORT) {
5351                         FCPARAM(isp)->isp_loopstate = LOOP_LSCAN_DONE;
5352                 } else {
5353                         FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
5354                 }
5355                 ISP_MARK_PORTDB(isp, 1);
5356                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
5357                 break;
5358
5359         case ASYNC_PTPMODE:
5360                 ISP_MARK_PORTDB(isp, 1);
5361                 isp->isp_sendmarker = 1;
5362                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5363                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5364                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5365 #ifdef  ISP_TARGET_MODE
5366                 if (isp_target_async(isp, bus, mbox)) {
5367                         rval = -1;
5368                 }
5369 #endif
5370                 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
5371                 break;
5372
5373         case ASYNC_CONNMODE:
5374                 mbox = ISP_READ(isp, OUTMAILBOX1);
5375                 ISP_MARK_PORTDB(isp, 1);
5376                 switch (mbox) {
5377                 case ISP_CONN_LOOP:
5378                         isp_prt(isp, ISP_LOGINFO,
5379                             "Point-to-Point -> Loop mode");
5380                         break;
5381                 case ISP_CONN_PTP:
5382                         isp_prt(isp, ISP_LOGINFO,
5383                             "Loop -> Point-to-Point mode");
5384                         break;
5385                 case ISP_CONN_BADLIP:
5386                         isp_prt(isp, ISP_LOGWARN,
5387                             "Point-to-Point -> Loop mode (BAD LIP)");
5388                         break;
5389                 case ISP_CONN_FATAL:
5390                         isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
5391                         isp_async(isp, ISPASYNC_FW_CRASH, NULL);
5392                         return (-1);
5393                 case ISP_CONN_LOOPBACK:
5394                         isp_prt(isp, ISP_LOGWARN,
5395                             "Looped Back in Point-to-Point mode");
5396                         break;
5397                 default:
5398                         isp_prt(isp, ISP_LOGWARN,
5399                             "Unknown connection mode (0x%x)", mbox);
5400                         break;
5401                 }
5402                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
5403                 isp->isp_sendmarker = 1;
5404                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
5405                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
5406                 break;
5407
5408         case ASYNC_RJT_SENT:    /* same as ASYNC_QFULL_SENT */
5409                 if (IS_24XX(isp)) {
5410                         isp_prt(isp, ISP_LOGTDEBUG0, "LS_RJT sent");
5411                         break;
5412                 } else if (IS_2200(isp)) {
5413                         isp_prt(isp, ISP_LOGTDEBUG0, "QFULL sent");
5414                         break;
5415                 }
5416                 /* FALLTHROUGH */
5417         default:
5418                 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
5419                 break;
5420         }
5421
5422         if (bus & 0x100) {
5423                 int i, nh;
5424                 uint16_t handles[16];
5425
5426                 for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) {
5427                         if ((bus & (1 << i)) == 0) {
5428                                 continue;
5429                         }
5430                         handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
5431                 }
5432                 for (i = 0; i < nh; i++) {
5433                         isp_fastpost_complete(isp, handles[i]);
5434                         isp_prt(isp,  ISP_LOGDEBUG3,
5435                             "fast post completion of %u", handles[i]);
5436                 }
5437                 if (isp->isp_fpcchiwater < nh) {
5438                         isp->isp_fpcchiwater = nh;
5439                 }
5440         } else {
5441                 isp->isp_intoasync++;
5442         }
5443         return (rval);
5444 }
5445
5446 /*
5447  * Handle other response entries. A pointer to the request queue output
5448  * index is here in case we want to eat several entries at once, although
5449  * this is not used currently.
5450  */
5451
5452 static int
5453 isp_handle_other_response(ispsoftc_t *isp, int type,
5454     isphdr_t *hp, uint32_t *optrp)
5455 {
5456         switch (type) {
5457         case RQSTYPE_STATUS_CONT:
5458                 isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
5459                 return (1);
5460         case RQSTYPE_MARKER:
5461                 isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
5462                 return (1);
5463         case RQSTYPE_ATIO:
5464         case RQSTYPE_CTIO:
5465         case RQSTYPE_ENABLE_LUN:
5466         case RQSTYPE_MODIFY_LUN:
5467         case RQSTYPE_NOTIFY:
5468         case RQSTYPE_NOTIFY_ACK:
5469         case RQSTYPE_CTIO1:
5470         case RQSTYPE_ATIO2:
5471         case RQSTYPE_CTIO2:
5472         case RQSTYPE_CTIO3:
5473         case RQSTYPE_CTIO7:
5474         case RQSTYPE_ABTS_RCVD:
5475         case RQSTYPE_ABTS_RSP:
5476                 isp->isp_rsltccmplt++;  /* count as a response completion */
5477 #ifdef  ISP_TARGET_MODE
5478                 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
5479                         return (1);
5480                 }
5481 #endif
5482                 /* FALLTHROUGH */
5483         case RQSTYPE_REQUEST:
5484         default:
5485                 USEC_DELAY(100);
5486                 if (type != isp_get_response_type(isp, hp)) {
5487                         /*
5488                          * This is questionable- we're just papering over
5489                          * something we've seen on SMP linux in target
5490                          * mode- we don't really know what's happening
5491                          * here that causes us to think we've gotten
5492                          * an entry, but that either the entry isn't
5493                          * filled out yet or our CPU read data is stale.
5494                          */
5495                         isp_prt(isp, ISP_LOGINFO,
5496                                 "unstable type in response queue");
5497                         return (-1);
5498                 }
5499                 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
5500                     isp_get_response_type(isp, hp));
5501                 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
5502                         return (1);
5503                 }
5504                 return (0);
5505         }
5506 }
5507
5508 static void
5509 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs, long *rp)
5510 {
5511         switch (sp->req_completion_status & 0xff) {
5512         case RQCS_COMPLETE:
5513                 if (XS_NOERR(xs)) {
5514                         XS_SETERR(xs, HBA_NOERROR);
5515                 }
5516                 return;
5517
5518         case RQCS_INCOMPLETE:
5519                 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
5520                         isp_prt(isp, ISP_LOGDEBUG1,
5521                             "Selection Timeout for %d.%d.%d",
5522                             XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5523                         if (XS_NOERR(xs)) {
5524                                 XS_SETERR(xs, HBA_SELTIMEOUT);
5525                                 *rp = XS_XFRLEN(xs);
5526                         }
5527                         return;
5528                 }
5529                 isp_prt(isp, ISP_LOGERR,
5530                     "command incomplete for %d.%d.%d, state 0x%x",
5531                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
5532                     sp->req_state_flags);
5533                 break;
5534
5535         case RQCS_DMA_ERROR:
5536                 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5537                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5538                 *rp = XS_XFRLEN(xs);
5539                 break;
5540
5541         case RQCS_TRANSPORT_ERROR:
5542         {
5543                 char buf[172];
5544                 SNPRINTF(buf, sizeof (buf), "states=>");
5545                 if (sp->req_state_flags & RQSF_GOT_BUS) {
5546                         SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
5547                 }
5548                 if (sp->req_state_flags & RQSF_GOT_TARGET) {
5549                         SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
5550                 }
5551                 if (sp->req_state_flags & RQSF_SENT_CDB) {
5552                         SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
5553                 }
5554                 if (sp->req_state_flags & RQSF_XFRD_DATA) {
5555                         SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
5556                 }
5557                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
5558                         SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
5559                 }
5560                 if (sp->req_state_flags & RQSF_GOT_SENSE) {
5561                         SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
5562                 }
5563                 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
5564                         SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
5565                 }
5566                 SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
5567                 if (sp->req_status_flags & RQSTF_DISCONNECT) {
5568                         SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
5569                 }
5570                 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
5571                         SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
5572                 }
5573                 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
5574                         SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
5575                 }
5576                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
5577                         SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
5578                 }
5579                 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
5580                         SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
5581                 }
5582                 if (sp->req_status_flags & RQSTF_ABORTED) {
5583                         SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
5584                 }
5585                 if (sp->req_status_flags & RQSTF_TIMEOUT) {
5586                         SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
5587                 }
5588                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
5589                         SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
5590                 }
5591                 isp_prt(isp, ISP_LOGERR, "%s", buf);
5592                 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
5593                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
5594                 *rp = XS_XFRLEN(xs);
5595                 break;
5596         }
5597         case RQCS_RESET_OCCURRED:
5598                 isp_prt(isp, ISP_LOGWARN,
5599                     "bus reset destroyed command for %d.%d.%d",
5600                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5601                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5602                 if (XS_NOERR(xs)) {
5603                         XS_SETERR(xs, HBA_BUSRESET);
5604                 }
5605                 *rp = XS_XFRLEN(xs);
5606                 return;
5607
5608         case RQCS_ABORTED:
5609                 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5610                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5611                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5612                 if (XS_NOERR(xs)) {
5613                         XS_SETERR(xs, HBA_ABORTED);
5614                 }
5615                 return;
5616
5617         case RQCS_TIMEOUT:
5618                 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5619                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5620                 /*
5621                  * XXX: Check to see if we logged out of the device.
5622                  */
5623                 if (XS_NOERR(xs)) {
5624                         XS_SETERR(xs, HBA_CMDTIMEOUT);
5625                 }
5626                 return;
5627
5628         case RQCS_DATA_OVERRUN:
5629                 XS_RESID(xs) = sp->req_resid;
5630                 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
5631                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5632                 if (XS_NOERR(xs)) {
5633                         XS_SETERR(xs, HBA_DATAOVR);
5634                 }
5635                 return;
5636
5637         case RQCS_COMMAND_OVERRUN:
5638                 isp_prt(isp, ISP_LOGERR,
5639                     "command overrun for command on %d.%d.%d",
5640                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5641                 break;
5642
5643         case RQCS_STATUS_OVERRUN:
5644                 isp_prt(isp, ISP_LOGERR,
5645                     "status overrun for command on %d.%d.%d",
5646                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5647                 break;
5648
5649         case RQCS_BAD_MESSAGE:
5650                 isp_prt(isp, ISP_LOGERR,
5651                     "msg not COMMAND COMPLETE after status %d.%d.%d",
5652                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5653                 break;
5654
5655         case RQCS_NO_MESSAGE_OUT:
5656                 isp_prt(isp, ISP_LOGERR,
5657                     "No MESSAGE OUT phase after selection on %d.%d.%d",
5658                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5659                 break;
5660
5661         case RQCS_EXT_ID_FAILED:
5662                 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
5663                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5664                 break;
5665
5666         case RQCS_IDE_MSG_FAILED:
5667                 isp_prt(isp, ISP_LOGERR,
5668                     "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
5669                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5670                 break;
5671
5672         case RQCS_ABORT_MSG_FAILED:
5673                 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
5674                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5675                 break;
5676
5677         case RQCS_REJECT_MSG_FAILED:
5678                 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
5679                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5680                 break;
5681
5682         case RQCS_NOP_MSG_FAILED:
5683                 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
5684                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5685                 break;
5686
5687         case RQCS_PARITY_ERROR_MSG_FAILED:
5688                 isp_prt(isp, ISP_LOGERR,
5689                     "MESSAGE PARITY ERROR rejected by %d.%d.%d",
5690                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5691                 break;
5692
5693         case RQCS_DEVICE_RESET_MSG_FAILED:
5694                 isp_prt(isp, ISP_LOGWARN,
5695                     "BUS DEVICE RESET rejected by %d.%d.%d",
5696                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5697                 break;
5698
5699         case RQCS_ID_MSG_FAILED:
5700                 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
5701                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5702                 break;
5703
5704         case RQCS_UNEXP_BUS_FREE:
5705                 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
5706                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5707                 break;
5708
5709         case RQCS_DATA_UNDERRUN:
5710         {
5711                 if (IS_FC(isp)) {
5712                         int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
5713                         if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
5714                                 isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
5715                                     XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
5716                                     (ru_marked)? "marked" : "not marked");
5717                                 if (XS_NOERR(xs)) {
5718                                         XS_SETERR(xs, HBA_BOTCH);
5719                                 }
5720                                 return;
5721                         }
5722                 }
5723                 XS_RESID(xs) = sp->req_resid;
5724                 if (XS_NOERR(xs)) {
5725                         XS_SETERR(xs, HBA_NOERROR);
5726                 }
5727                 return;
5728         }
5729
5730         case RQCS_XACT_ERR1:
5731                 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
5732                     XS_TGT(xs), XS_LUN(xs));
5733                 break;
5734
5735         case RQCS_XACT_ERR2:
5736                 isp_prt(isp, ISP_LOGERR, xact2,
5737                     XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
5738                 break;
5739
5740         case RQCS_XACT_ERR3:
5741                 isp_prt(isp, ISP_LOGERR, xact3,
5742                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5743                 break;
5744
5745         case RQCS_BAD_ENTRY:
5746                 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
5747                 break;
5748
5749         case RQCS_QUEUE_FULL:
5750                 isp_prt(isp, ISP_LOGDEBUG0,
5751                     "internal queues full for %d.%d.%d status 0x%x",
5752                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
5753
5754                 /*
5755                  * If QFULL or some other status byte is set, then this
5756                  * isn't an error, per se.
5757                  *
5758                  * Unfortunately, some QLogic f/w writers have, in
5759                  * some cases, ommitted to *set* status to QFULL.
5760                  *
5761
5762                 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
5763                         XS_SETERR(xs, HBA_NOERROR);
5764                         return;
5765                 }
5766
5767                  *
5768                  *
5769                  */
5770
5771                 *XS_STSP(xs) = SCSI_QFULL;
5772                 XS_SETERR(xs, HBA_NOERROR);
5773                 return;
5774
5775         case RQCS_PHASE_SKIPPED:
5776                 isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
5777                     XS_TGT(xs), XS_LUN(xs));
5778                 break;
5779
5780         case RQCS_ARQS_FAILED:
5781                 isp_prt(isp, ISP_LOGERR,
5782                     "Auto Request Sense failed for %d.%d.%d",
5783                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5784                 if (XS_NOERR(xs)) {
5785                         XS_SETERR(xs, HBA_ARQFAIL);
5786                 }
5787                 return;
5788
5789         case RQCS_WIDE_FAILED:
5790                 isp_prt(isp, ISP_LOGERR,
5791                     "Wide Negotiation failed for %d.%d.%d",
5792                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5793                 if (IS_SCSI(isp)) {
5794                         sdparam *sdp = isp->isp_param;
5795                         sdp += XS_CHANNEL(xs);
5796                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
5797                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5798                         isp->isp_update |= (1 << XS_CHANNEL(xs));
5799                 }
5800                 if (XS_NOERR(xs)) {
5801                         XS_SETERR(xs, HBA_NOERROR);
5802                 }
5803                 return;
5804
5805         case RQCS_SYNCXFER_FAILED:
5806                 isp_prt(isp, ISP_LOGERR,
5807                     "SDTR Message failed for target %d.%d.%d",
5808                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5809                 if (IS_SCSI(isp)) {
5810                         sdparam *sdp = isp->isp_param;
5811                         sdp += XS_CHANNEL(xs);
5812                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
5813                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
5814                         isp->isp_update |= (1 << XS_CHANNEL(xs));
5815                 }
5816                 break;
5817
5818         case RQCS_LVD_BUSERR:
5819                 isp_prt(isp, ISP_LOGERR,
5820                     "Bad LVD condition while talking to %d.%d.%d",
5821                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
5822                 break;
5823
5824         case RQCS_PORT_UNAVAILABLE:
5825                 /*
5826                  * No such port on the loop. Moral equivalent of SELTIMEO
5827                  */
5828         case RQCS_PORT_LOGGED_OUT:
5829         {
5830                 const char *reason;
5831                 uint8_t sts = sp->req_completion_status & 0xff;
5832
5833                 /*
5834                  * It was there (maybe)- treat as a selection timeout.
5835                  */
5836                 if (sts == RQCS_PORT_UNAVAILABLE) {
5837                         reason = "unavailable";
5838                 } else {
5839                         reason = "logout";
5840                 }
5841
5842                 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
5843                     reason, XS_TGT(xs));
5844
5845                 /*
5846                  * If we're on a local loop, force a LIP (which is overkill)
5847                  * to force a re-login of this unit. If we're on fabric,
5848                  * then we'll have to log in again as a matter of course.
5849                  */
5850                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
5851                     FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
5852                         mbreg_t mbs;
5853                         MEMZERO(&mbs, sizeof (mbs));
5854                         mbs.param[0] = MBOX_INIT_LIP;
5855                         if (FCPARAM(isp)->isp_2klogin) {
5856                                 mbs.ibits = (1 << 10);
5857                         }
5858                         mbs.logval = MBLOGALL;
5859                         isp_mboxcmd_qnw(isp, &mbs, 1);
5860                 }
5861                 if (XS_NOERR(xs)) {
5862                         XS_SETERR(xs, HBA_SELTIMEOUT);
5863                 }
5864                 return;
5865         }
5866         case RQCS_PORT_CHANGED:
5867                 isp_prt(isp, ISP_LOGWARN,
5868                     "port changed for target %d", XS_TGT(xs));
5869                 if (XS_NOERR(xs)) {
5870                         XS_SETERR(xs, HBA_SELTIMEOUT);
5871                 }
5872                 return;
5873
5874         case RQCS_PORT_BUSY:
5875                 isp_prt(isp, ISP_LOGWARN,
5876                     "port busy for target %d", XS_TGT(xs));
5877                 if (XS_NOERR(xs)) {
5878                         XS_SETERR(xs, HBA_TGTBSY);
5879                 }
5880                 return;
5881
5882         default:
5883                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
5884                     sp->req_completion_status);
5885                 break;
5886         }
5887         if (XS_NOERR(xs)) {
5888                 XS_SETERR(xs, HBA_BOTCH);
5889         }
5890 }
5891
5892 static void
5893 isp_parse_status_24xx(ispsoftc_t *isp, isp24xx_statusreq_t *sp,
5894     XS_T *xs, long *rp)
5895 {
5896         int ru_marked, sv_marked;
5897         switch (sp->req_completion_status) {
5898         case RQCS_COMPLETE:
5899                 if (XS_NOERR(xs)) {
5900                         XS_SETERR(xs, HBA_NOERROR);
5901                 }
5902                 return;
5903
5904         case RQCS_DMA_ERROR:
5905                 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
5906                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5907                 break;
5908
5909         case RQCS_TRANSPORT_ERROR:
5910                 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d",
5911                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5912                 break;
5913
5914         case RQCS_RESET_OCCURRED:
5915                 isp_prt(isp, ISP_LOGWARN,
5916                     "bus reset destroyed command for %d.%d.%d",
5917                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5918                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5919                 if (XS_NOERR(xs)) {
5920                         XS_SETERR(xs, HBA_BUSRESET);
5921                 }
5922                 return;
5923
5924         case RQCS_ABORTED:
5925                 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
5926                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5927                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
5928                 if (XS_NOERR(xs)) {
5929                         XS_SETERR(xs, HBA_ABORTED);
5930                 }
5931                 return;
5932
5933         case RQCS_TIMEOUT:
5934                 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
5935                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5936                 if (XS_NOERR(xs)) {
5937                         XS_SETERR(xs, HBA_CMDTIMEOUT);
5938                 }
5939                 return;
5940
5941         case RQCS_DATA_OVERRUN:
5942                 XS_RESID(xs) = sp->req_resid;
5943                 isp_prt(isp, ISP_LOGERR,
5944                     "data overrun for command on %d.%d.%d",
5945                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5946                 if (XS_NOERR(xs)) {
5947                         XS_SETERR(xs, HBA_DATAOVR);
5948                 }
5949                 return;
5950
5951         case RQCS_24XX_DRE:     /* data reassembly error */
5952                 isp_prt(isp, ISP_LOGERR, "data reassembly error for target %d",
5953                     XS_TGT(xs));
5954                 if (XS_NOERR(xs)) {
5955                         XS_SETERR(xs, HBA_ABORTED);
5956                 }
5957                 *rp = XS_XFRLEN(xs);
5958                 return;
5959
5960         case RQCS_24XX_TABORT:  /* aborted by target */
5961                 isp_prt(isp, ISP_LOGERR, "target %d sent ABTS",
5962                     XS_TGT(xs));
5963                 if (XS_NOERR(xs)) {
5964                         XS_SETERR(xs, HBA_ABORTED);
5965                 }
5966                 return;
5967
5968         case RQCS_DATA_UNDERRUN:
5969                 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
5970                 /*
5971                  * We can get an underrun w/o things being marked
5972                  * if we got a non-zero status.
5973                  */
5974                 sv_marked = (sp->req_scsi_status & (RQCS_SV|RQCS_RV)) != 0;
5975                 if ((ru_marked == 0 && sv_marked == 0) ||
5976                     (sp->req_resid > XS_XFRLEN(xs))) {
5977                         isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
5978                             XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
5979                             (ru_marked)? "marked" : "not marked");
5980                         if (XS_NOERR(xs)) {
5981                                 XS_SETERR(xs, HBA_BOTCH);
5982                         }
5983                         return;
5984                 }
5985                 XS_RESID(xs) = sp->req_resid;
5986                 isp_prt(isp, ISP_LOGDEBUG0,
5987                     "%d.%d.%d data underrun (%d) for command 0x%x",
5988                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
5989                     sp->req_resid, XS_CDBP(xs)[0] & 0xff);
5990                 if (XS_NOERR(xs)) {
5991                         XS_SETERR(xs, HBA_NOERROR);
5992                 }
5993                 return;
5994
5995         case RQCS_PORT_UNAVAILABLE:
5996                 /*
5997                  * No such port on the loop. Moral equivalent of SELTIMEO
5998                  */
5999         case RQCS_PORT_LOGGED_OUT:
6000         {
6001                 const char *reason;
6002                 uint8_t sts = sp->req_completion_status & 0xff;
6003
6004                 /*
6005                  * It was there (maybe)- treat as a selection timeout.
6006                  */
6007                 if (sts == RQCS_PORT_UNAVAILABLE) {
6008                         reason = "unavailable";
6009                 } else {
6010                         reason = "logout";
6011                 }
6012
6013                 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
6014                     reason, XS_TGT(xs));
6015
6016                 /*
6017                  * If we're on a local loop, force a LIP (which is overkill)
6018                  * to force a re-login of this unit. If we're on fabric,
6019                  * then we'll have to log in again as a matter of course.
6020                  */
6021                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
6022                     FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
6023                         mbreg_t mbs;
6024                         MEMZERO(&mbs, sizeof (mbs));
6025                         mbs.param[0] = MBOX_INIT_LIP;
6026                         if (FCPARAM(isp)->isp_2klogin) {
6027                                 mbs.ibits = (1 << 10);
6028                         }
6029                         mbs.logval = MBLOGALL;
6030                         isp_mboxcmd_qnw(isp, &mbs, 1);
6031                 }
6032                 if (XS_NOERR(xs)) {
6033                         XS_SETERR(xs, HBA_SELTIMEOUT);
6034                 }
6035                 return;
6036         }
6037         case RQCS_PORT_CHANGED:
6038                 isp_prt(isp, ISP_LOGWARN,
6039                     "port changed for target %d", XS_TGT(xs));
6040                 if (XS_NOERR(xs)) {
6041                         XS_SETERR(xs, HBA_SELTIMEOUT);
6042                 }
6043                 return;
6044
6045
6046         case RQCS_24XX_ENOMEM:  /* f/w resource unavailable */
6047                 isp_prt(isp, ISP_LOGWARN,
6048                     "f/w resource unavailable for target %d", XS_TGT(xs));
6049                 if (XS_NOERR(xs)) {
6050                         *XS_STSP(xs) = SCSI_BUSY;
6051                         XS_SETERR(xs, HBA_TGTBSY);
6052                 }
6053                 return;
6054
6055         case RQCS_24XX_TMO:     /* task management overrun */
6056                 isp_prt(isp, ISP_LOGWARN,
6057                     "command for target %d overlapped task management",
6058                     XS_TGT(xs));
6059                 if (XS_NOERR(xs)) {
6060                         *XS_STSP(xs) = SCSI_BUSY;
6061                         XS_SETERR(xs, HBA_TGTBSY);
6062                 }
6063                 return;
6064
6065         default:
6066                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
6067                     sp->req_completion_status);
6068                 break;
6069         }
6070         if (XS_NOERR(xs)) {
6071                 XS_SETERR(xs, HBA_BOTCH);
6072         }
6073 }
6074
6075 static void
6076 isp_fastpost_complete(ispsoftc_t *isp, uint16_t fph)
6077 {
6078         XS_T *xs;
6079
6080         if (fph == 0) {
6081                 return;
6082         }
6083         xs = isp_find_xs(isp, fph);
6084         if (xs == NULL) {
6085                 isp_prt(isp, ISP_LOGDEBUG1,
6086                     "Command for fast post handle 0x%x not found", fph);
6087                 return;
6088         }
6089         isp_destroy_handle(isp, fph);
6090
6091         /*
6092          * Since we don't have a result queue entry item,
6093          * we must believe that SCSI status is zero and
6094          * that all data transferred.
6095          */
6096         XS_SET_STATE_STAT(isp, xs, NULL);
6097         XS_RESID(xs) = 0;
6098         *XS_STSP(xs) = SCSI_GOOD;
6099         if (XS_XFRLEN(xs)) {
6100                 ISP_DMAFREE(isp, xs, fph);
6101         }
6102         if (isp->isp_nactive)
6103                 isp->isp_nactive--;
6104         isp->isp_fphccmplt++;
6105         isp_done(xs);
6106 }
6107
6108 static int
6109 isp_mbox_continue(ispsoftc_t *isp)
6110 {
6111         mbreg_t mbs;
6112         uint16_t *ptr;
6113         uint32_t offset;
6114
6115         switch (isp->isp_lastmbxcmd) {
6116         case MBOX_WRITE_RAM_WORD:
6117         case MBOX_READ_RAM_WORD:
6118         case MBOX_WRITE_RAM_WORD_EXTENDED:
6119         case MBOX_READ_RAM_WORD_EXTENDED:
6120                 break;
6121         default:
6122                 return (1);
6123         }
6124         if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
6125                 isp->isp_mbxwrk0 = 0;
6126                 return (-1);
6127         }
6128
6129         /*
6130          * Clear the previous interrupt.
6131          */
6132         if (IS_24XX(isp)) {
6133                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
6134         } else {
6135                 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
6136                 ISP_WRITE(isp, BIU_SEMA, 0);
6137         }
6138
6139         /*
6140          * Continue with next word.
6141          */
6142         MEMZERO(&mbs, sizeof (mbs));
6143         ptr = isp->isp_mbxworkp;
6144         switch (isp->isp_lastmbxcmd) {
6145         case MBOX_WRITE_RAM_WORD:
6146                 mbs.param[1] = isp->isp_mbxwrk1++;;
6147                 mbs.param[2] = *ptr++;;
6148                 break;
6149         case MBOX_READ_RAM_WORD:
6150                 *ptr++ = isp->isp_mboxtmp[2];
6151                 mbs.param[1] = isp->isp_mbxwrk1++;
6152                 break;
6153         case MBOX_WRITE_RAM_WORD_EXTENDED:
6154                 offset = isp->isp_mbxwrk1;
6155                 offset |= isp->isp_mbxwrk8 << 16;
6156
6157                 mbs.param[2] = *ptr++;;
6158                 mbs.param[1] = offset;
6159                 mbs.param[8] = offset >> 16;
6160                 isp->isp_mbxwrk1 = ++offset;
6161                 isp->isp_mbxwrk8 = offset >> 16;
6162                 break;
6163         case MBOX_READ_RAM_WORD_EXTENDED:
6164                 offset = isp->isp_mbxwrk1;
6165                 offset |= isp->isp_mbxwrk8 << 16;
6166
6167                 *ptr++ = isp->isp_mboxtmp[2];
6168                 mbs.param[1] = offset;
6169                 mbs.param[8] = offset >> 16;
6170                 isp->isp_mbxwrk1 = ++offset;
6171                 isp->isp_mbxwrk8 = offset >> 16;
6172                 break;
6173         }
6174         isp->isp_mbxworkp = ptr;
6175         isp->isp_mbxwrk0--;
6176         mbs.param[0] = isp->isp_lastmbxcmd;
6177         mbs.logval = MBLOGALL;
6178         isp_mboxcmd_qnw(isp, &mbs, 0);
6179         return (0);
6180 }
6181
6182 #define HIWRD(x)                        ((x) >> 16)
6183 #define LOWRD(x)                        ((x)  & 0xffff)
6184 #define ISPOPMAP(a, b)                  (((a) << 16) | (b))
6185 static const uint32_t mbpscsi[] = {
6186         ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
6187         ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
6188         ISPOPMAP(0x03, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
6189         ISPOPMAP(0x1f, 0x01),   /* 0x03: MBOX_DUMP_RAM */
6190         ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
6191         ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
6192         ISPOPMAP(0x3f, 0x3f),   /* 0x06: MBOX_MAILBOX_REG_TEST */
6193         ISPOPMAP(0x07, 0x07),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
6194         ISPOPMAP(0x01, 0x0f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
6195         ISPOPMAP(0x00, 0x00),   /* 0x09: */
6196         ISPOPMAP(0x00, 0x00),   /* 0x0a: */
6197         ISPOPMAP(0x00, 0x00),   /* 0x0b: */
6198         ISPOPMAP(0x00, 0x00),   /* 0x0c: */
6199         ISPOPMAP(0x00, 0x00),   /* 0x0d: */
6200         ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
6201         ISPOPMAP(0x00, 0x00),   /* 0x0f: */
6202         ISPOPMAP(0x1f, 0x1f),   /* 0x10: MBOX_INIT_REQ_QUEUE */
6203         ISPOPMAP(0x3f, 0x3f),   /* 0x11: MBOX_INIT_RES_QUEUE */
6204         ISPOPMAP(0x0f, 0x0f),   /* 0x12: MBOX_EXECUTE_IOCB */
6205         ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
6206         ISPOPMAP(0x01, 0x3f),   /* 0x14: MBOX_STOP_FIRMWARE */
6207         ISPOPMAP(0x0f, 0x0f),   /* 0x15: MBOX_ABORT */
6208         ISPOPMAP(0x03, 0x03),   /* 0x16: MBOX_ABORT_DEVICE */
6209         ISPOPMAP(0x07, 0x07),   /* 0x17: MBOX_ABORT_TARGET */
6210         ISPOPMAP(0x07, 0x07),   /* 0x18: MBOX_BUS_RESET */
6211         ISPOPMAP(0x03, 0x07),   /* 0x19: MBOX_STOP_QUEUE */
6212         ISPOPMAP(0x03, 0x07),   /* 0x1a: MBOX_START_QUEUE */
6213         ISPOPMAP(0x03, 0x07),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6214         ISPOPMAP(0x03, 0x07),   /* 0x1c: MBOX_ABORT_QUEUE */
6215         ISPOPMAP(0x03, 0x4f),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6216         ISPOPMAP(0x00, 0x00),   /* 0x1e: */
6217         ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6218         ISPOPMAP(0x01, 0x07),   /* 0x20: MBOX_GET_INIT_SCSI_ID */
6219         ISPOPMAP(0x01, 0x07),   /* 0x21: MBOX_GET_SELECT_TIMEOUT */
6220         ISPOPMAP(0x01, 0xc7),   /* 0x22: MBOX_GET_RETRY_COUNT   */
6221         ISPOPMAP(0x01, 0x07),   /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
6222         ISPOPMAP(0x01, 0x03),   /* 0x24: MBOX_GET_CLOCK_RATE */
6223         ISPOPMAP(0x01, 0x07),   /* 0x25: MBOX_GET_ACT_NEG_STATE */
6224         ISPOPMAP(0x01, 0x07),   /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
6225         ISPOPMAP(0x01, 0x07),   /* 0x27: MBOX_GET_PCI_PARAMS */
6226         ISPOPMAP(0x03, 0x4f),   /* 0x28: MBOX_GET_TARGET_PARAMS */
6227         ISPOPMAP(0x03, 0x0f),   /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
6228         ISPOPMAP(0x01, 0x07),   /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
6229         ISPOPMAP(0x00, 0x00),   /* 0x2b: */
6230         ISPOPMAP(0x00, 0x00),   /* 0x2c: */
6231         ISPOPMAP(0x00, 0x00),   /* 0x2d: */
6232         ISPOPMAP(0x00, 0x00),   /* 0x2e: */
6233         ISPOPMAP(0x00, 0x00),   /* 0x2f: */
6234         ISPOPMAP(0x03, 0x03),   /* 0x30: MBOX_SET_INIT_SCSI_ID */
6235         ISPOPMAP(0x07, 0x07),   /* 0x31: MBOX_SET_SELECT_TIMEOUT */
6236         ISPOPMAP(0xc7, 0xc7),   /* 0x32: MBOX_SET_RETRY_COUNT   */
6237         ISPOPMAP(0x07, 0x07),   /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
6238         ISPOPMAP(0x03, 0x03),   /* 0x34: MBOX_SET_CLOCK_RATE */
6239         ISPOPMAP(0x07, 0x07),   /* 0x35: MBOX_SET_ACT_NEG_STATE */
6240         ISPOPMAP(0x07, 0x07),   /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
6241         ISPOPMAP(0x07, 0x07),   /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
6242         ISPOPMAP(0x4f, 0x4f),   /* 0x38: MBOX_SET_TARGET_PARAMS */
6243         ISPOPMAP(0x0f, 0x0f),   /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
6244         ISPOPMAP(0x07, 0x07),   /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
6245         ISPOPMAP(0x00, 0x00),   /* 0x3b: */
6246         ISPOPMAP(0x00, 0x00),   /* 0x3c: */
6247         ISPOPMAP(0x00, 0x00),   /* 0x3d: */
6248         ISPOPMAP(0x00, 0x00),   /* 0x3e: */
6249         ISPOPMAP(0x00, 0x00),   /* 0x3f: */
6250         ISPOPMAP(0x01, 0x03),   /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
6251         ISPOPMAP(0x3f, 0x01),   /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
6252         ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_EXEC_BIOS_IOCB */
6253         ISPOPMAP(0x00, 0x00),   /* 0x43: */
6254         ISPOPMAP(0x00, 0x00),   /* 0x44: */
6255         ISPOPMAP(0x03, 0x03),   /* 0x45: SET SYSTEM PARAMETER */
6256         ISPOPMAP(0x01, 0x03),   /* 0x46: GET SYSTEM PARAMETER */
6257         ISPOPMAP(0x00, 0x00),   /* 0x47: */
6258         ISPOPMAP(0x01, 0xcf),   /* 0x48: GET SCAM CONFIGURATION */
6259         ISPOPMAP(0xcf, 0xcf),   /* 0x49: SET SCAM CONFIGURATION */
6260         ISPOPMAP(0x03, 0x03),   /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
6261         ISPOPMAP(0x01, 0x03),   /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
6262         ISPOPMAP(0x00, 0x00),   /* 0x4c: */
6263         ISPOPMAP(0x00, 0x00),   /* 0x4d: */
6264         ISPOPMAP(0x00, 0x00),   /* 0x4e: */
6265         ISPOPMAP(0x00, 0x00),   /* 0x4f: */
6266         ISPOPMAP(0xdf, 0xdf),   /* 0x50: LOAD RAM A64 */
6267         ISPOPMAP(0xdf, 0xdf),   /* 0x51: DUMP RAM A64 */
6268         ISPOPMAP(0xdf, 0xff),   /* 0x52: INITIALIZE REQUEST QUEUE A64 */
6269         ISPOPMAP(0xef, 0xff),   /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
6270         ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUCUTE COMMAND IOCB A64 */
6271         ISPOPMAP(0x07, 0x01),   /* 0x55: ENABLE TARGET MODE */
6272         ISPOPMAP(0x03, 0x0f),   /* 0x56: GET TARGET STATUS */
6273         ISPOPMAP(0x00, 0x00),   /* 0x57: */
6274         ISPOPMAP(0x00, 0x00),   /* 0x58: */
6275         ISPOPMAP(0x00, 0x00),   /* 0x59: */
6276         ISPOPMAP(0x03, 0x03),   /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
6277         ISPOPMAP(0x01, 0x03),   /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
6278         ISPOPMAP(0x0f, 0x0f),   /* 0x5c: SET HOST DATA */
6279         ISPOPMAP(0x01, 0x01)    /* 0x5d: GET NOST DATA */
6280 };
6281
6282 static const char *scsi_mbcmd_names[] = {
6283         "NO-OP",
6284         "LOAD RAM",
6285         "EXEC FIRMWARE",
6286         "DUMP RAM",
6287         "WRITE RAM WORD",
6288         "READ RAM WORD",
6289         "MAILBOX REG TEST",
6290         "VERIFY CHECKSUM",
6291         "ABOUT FIRMWARE",
6292         NULL,
6293         NULL,
6294         NULL,
6295         NULL,
6296         NULL,
6297         "CHECK FIRMWARE",
6298         NULL,
6299         "INIT REQUEST QUEUE",
6300         "INIT RESULT QUEUE",
6301         "EXECUTE IOCB",
6302         "WAKE UP",
6303         "STOP FIRMWARE",
6304         "ABORT",
6305         "ABORT DEVICE",
6306         "ABORT TARGET",
6307         "BUS RESET",
6308         "STOP QUEUE",
6309         "START QUEUE",
6310         "SINGLE STEP QUEUE",
6311         "ABORT QUEUE",
6312         "GET DEV QUEUE STATUS",
6313         NULL,
6314         "GET FIRMWARE STATUS",
6315         "GET INIT SCSI ID",
6316         "GET SELECT TIMEOUT",
6317         "GET RETRY COUNT",
6318         "GET TAG AGE LIMIT",
6319         "GET CLOCK RATE",
6320         "GET ACT NEG STATE",
6321         "GET ASYNC DATA SETUP TIME",
6322         "GET PCI PARAMS",
6323         "GET TARGET PARAMS",
6324         "GET DEV QUEUE PARAMS",
6325         "GET RESET DELAY PARAMS",
6326         NULL,
6327         NULL,
6328         NULL,
6329         NULL,
6330         NULL,
6331         "SET INIT SCSI ID",
6332         "SET SELECT TIMEOUT",
6333         "SET RETRY COUNT",
6334         "SET TAG AGE LIMIT",
6335         "SET CLOCK RATE",
6336         "SET ACT NEG STATE",
6337         "SET ASYNC DATA SETUP TIME",
6338         "SET PCI CONTROL PARAMS",
6339         "SET TARGET PARAMS",
6340         "SET DEV QUEUE PARAMS",
6341         "SET RESET DELAY PARAMS",
6342         NULL,
6343         NULL,
6344         NULL,
6345         NULL,
6346         NULL,
6347         "RETURN BIOS BLOCK ADDR",
6348         "WRITE FOUR RAM WORDS",
6349         "EXEC BIOS IOCB",
6350         NULL,
6351         NULL,
6352         "SET SYSTEM PARAMETER",
6353         "GET SYSTEM PARAMETER",
6354         NULL,
6355         "GET SCAM CONFIGURATION",
6356         "SET SCAM CONFIGURATION",
6357         "SET FIRMWARE FEATURES",
6358         "GET FIRMWARE FEATURES",
6359         NULL,
6360         NULL,
6361         NULL,
6362         NULL,
6363         "LOAD RAM A64",
6364         "DUMP RAM A64",
6365         "INITIALIZE REQUEST QUEUE A64",
6366         "INITIALIZE RESPONSE QUEUE A64",
6367         "EXECUTE IOCB A64",
6368         "ENABLE TARGET MODE",
6369         "GET TARGET MODE STATE",
6370         NULL,
6371         NULL,
6372         NULL,
6373         "SET DATA OVERRUN RECOVERY MODE",
6374         "GET DATA OVERRUN RECOVERY MODE",
6375         "SET HOST DATA",
6376         "GET NOST DATA",
6377 };
6378
6379 static const uint32_t mbpfc[] = {
6380         ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
6381         ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
6382         ISPOPMAP(0x0f, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
6383         ISPOPMAP(0xdf, 0x01),   /* 0x03: MBOX_DUMP_RAM */
6384         ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
6385         ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
6386         ISPOPMAP(0xff, 0xff),   /* 0x06: MBOX_MAILBOX_REG_TEST */
6387         ISPOPMAP(0x03, 0x07),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
6388         ISPOPMAP(0x01, 0x4f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
6389         ISPOPMAP(0xdf, 0x01),   /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6390         ISPOPMAP(0xdf, 0x01),   /* 0x0a: DUMP RAM */
6391         ISPOPMAP(0x1ff, 0x01),  /* 0x0b: MBOX_LOAD_RISC_RAM */
6392         ISPOPMAP(0x00, 0x00),   /* 0x0c: */
6393         ISPOPMAP(0x10f, 0x01),  /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
6394         ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
6395         ISPOPMAP(0x10f, 0x05),  /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
6396         ISPOPMAP(0x1f, 0x11),   /* 0x10: MBOX_INIT_REQ_QUEUE */
6397         ISPOPMAP(0x2f, 0x21),   /* 0x11: MBOX_INIT_RES_QUEUE */
6398         ISPOPMAP(0x0f, 0x01),   /* 0x12: MBOX_EXECUTE_IOCB */
6399         ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
6400         ISPOPMAP(0x01, 0xff),   /* 0x14: MBOX_STOP_FIRMWARE */
6401         ISPOPMAP(0x4f, 0x01),   /* 0x15: MBOX_ABORT */
6402         ISPOPMAP(0x07, 0x01),   /* 0x16: MBOX_ABORT_DEVICE */
6403         ISPOPMAP(0x07, 0x01),   /* 0x17: MBOX_ABORT_TARGET */
6404         ISPOPMAP(0x03, 0x03),   /* 0x18: MBOX_BUS_RESET */
6405         ISPOPMAP(0x07, 0x05),   /* 0x19: MBOX_STOP_QUEUE */
6406         ISPOPMAP(0x07, 0x05),   /* 0x1a: MBOX_START_QUEUE */
6407         ISPOPMAP(0x07, 0x05),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
6408         ISPOPMAP(0x07, 0x05),   /* 0x1c: MBOX_ABORT_QUEUE */
6409         ISPOPMAP(0x07, 0x03),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
6410         ISPOPMAP(0x00, 0x00),   /* 0x1e: */
6411         ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
6412         ISPOPMAP(0x01, 0x4f),   /* 0x20: MBOX_GET_LOOP_ID */
6413         ISPOPMAP(0x00, 0x00),   /* 0x21: */
6414         ISPOPMAP(0x01, 0x07),   /* 0x22: MBOX_GET_RETRY_COUNT   */
6415         ISPOPMAP(0x00, 0x00),   /* 0x23: */
6416         ISPOPMAP(0x00, 0x00),   /* 0x24: */
6417         ISPOPMAP(0x00, 0x00),   /* 0x25: */
6418         ISPOPMAP(0x00, 0x00),   /* 0x26: */
6419         ISPOPMAP(0x00, 0x00),   /* 0x27: */
6420         ISPOPMAP(0x01, 0x03),   /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
6421         ISPOPMAP(0x03, 0x07),   /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
6422         ISPOPMAP(0x00, 0x00),   /* 0x2a: */
6423         ISPOPMAP(0x00, 0x00),   /* 0x2b: */
6424         ISPOPMAP(0x00, 0x00),   /* 0x2c: */
6425         ISPOPMAP(0x00, 0x00),   /* 0x2d: */
6426         ISPOPMAP(0x00, 0x00),   /* 0x2e: */
6427         ISPOPMAP(0x00, 0x00),   /* 0x2f: */
6428         ISPOPMAP(0x00, 0x00),   /* 0x30: */
6429         ISPOPMAP(0x00, 0x00),   /* 0x31: */
6430         ISPOPMAP(0x07, 0x07),   /* 0x32: MBOX_SET_RETRY_COUNT   */
6431         ISPOPMAP(0x00, 0x00),   /* 0x33: */
6432         ISPOPMAP(0x00, 0x00),   /* 0x34: */
6433         ISPOPMAP(0x00, 0x00),   /* 0x35: */
6434         ISPOPMAP(0x00, 0x00),   /* 0x36: */
6435         ISPOPMAP(0x00, 0x00),   /* 0x37: */
6436         ISPOPMAP(0x0f, 0x01),   /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
6437         ISPOPMAP(0x0f, 0x07),   /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
6438         ISPOPMAP(0x00, 0x00),   /* 0x3a: */
6439         ISPOPMAP(0x00, 0x00),   /* 0x3b: */
6440         ISPOPMAP(0x00, 0x00),   /* 0x3c: */
6441         ISPOPMAP(0x00, 0x00),   /* 0x3d: */
6442         ISPOPMAP(0x00, 0x00),   /* 0x3e: */
6443         ISPOPMAP(0x00, 0x00),   /* 0x3f: */
6444         ISPOPMAP(0x03, 0x01),   /* 0x40: MBOX_LOOP_PORT_BYPASS */
6445         ISPOPMAP(0x03, 0x01),   /* 0x41: MBOX_LOOP_PORT_ENABLE */
6446         ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_GET_RESOURCE_COUNT */
6447         ISPOPMAP(0x01, 0x01),   /* 0x43: MBOX_REQUEST_OFFLINE_MODE */
6448         ISPOPMAP(0x00, 0x00),   /* 0x44: */
6449         ISPOPMAP(0x00, 0x00),   /* 0x45: */
6450         ISPOPMAP(0x00, 0x00),   /* 0x46: */
6451         ISPOPMAP(0xcf, 0x03),   /* 0x47: GET PORT_DATABASE ENHANCED */
6452         ISPOPMAP(0x00, 0x00),   /* 0x48: */
6453         ISPOPMAP(0x00, 0x00),   /* 0x49: */
6454         ISPOPMAP(0x00, 0x00),   /* 0x4a: */
6455         ISPOPMAP(0x00, 0x00),   /* 0x4b: */
6456         ISPOPMAP(0x00, 0x00),   /* 0x4c: */
6457         ISPOPMAP(0x00, 0x00),   /* 0x4d: */
6458         ISPOPMAP(0x00, 0x00),   /* 0x4e: */
6459         ISPOPMAP(0x00, 0x00),   /* 0x4f: */
6460         ISPOPMAP(0x00, 0x00),   /* 0x50: */
6461         ISPOPMAP(0x00, 0x00),   /* 0x51: */
6462         ISPOPMAP(0x00, 0x00),   /* 0x52: */
6463         ISPOPMAP(0x00, 0x00),   /* 0x53: */
6464         ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUTE IOCB A64 */
6465         ISPOPMAP(0x00, 0x00),   /* 0x55: */
6466         ISPOPMAP(0x00, 0x00),   /* 0x56: */
6467         ISPOPMAP(0x00, 0x00),   /* 0x57: */
6468         ISPOPMAP(0x00, 0x00),   /* 0x58: */
6469         ISPOPMAP(0x00, 0x00),   /* 0x59: */
6470         ISPOPMAP(0x00, 0x00),   /* 0x5a: */
6471         ISPOPMAP(0x03, 0x01),   /* 0x5b: MBOX_DRIVER_HEARTBEAT */
6472         ISPOPMAP(0xcf, 0x01),   /* 0x5c: MBOX_FW_HEARTBEAT */
6473         ISPOPMAP(0x07, 0x03),   /* 0x5d: MBOX_GET_SET_DATA_RATE */
6474         ISPOPMAP(0x00, 0x00),   /* 0x5e: */
6475         ISPOPMAP(0x00, 0x00),   /* 0x5f: */
6476         ISPOPMAP(0xcd, 0x01),   /* 0x60: MBOX_INIT_FIRMWARE */
6477         ISPOPMAP(0x00, 0x00),   /* 0x61: */
6478         ISPOPMAP(0x01, 0x01),   /* 0x62: MBOX_INIT_LIP */
6479         ISPOPMAP(0xcd, 0x03),   /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
6480         ISPOPMAP(0xcf, 0x01),   /* 0x64: MBOX_GET_PORT_DB */
6481         ISPOPMAP(0x07, 0x01),   /* 0x65: MBOX_CLEAR_ACA */
6482         ISPOPMAP(0x07, 0x01),   /* 0x66: MBOX_TARGET_RESET */
6483         ISPOPMAP(0x07, 0x01),   /* 0x67: MBOX_CLEAR_TASK_SET */
6484         ISPOPMAP(0x07, 0x01),   /* 0x68: MBOX_ABORT_TASK_SET */
6485         ISPOPMAP(0x01, 0x07),   /* 0x69: MBOX_GET_FW_STATE */
6486         ISPOPMAP(0x03, 0xcf),   /* 0x6a: MBOX_GET_PORT_NAME */
6487         ISPOPMAP(0xcf, 0x01),   /* 0x6b: MBOX_GET_LINK_STATUS */
6488         ISPOPMAP(0x0f, 0x01),   /* 0x6c: MBOX_INIT_LIP_RESET */
6489         ISPOPMAP(0x00, 0x00),   /* 0x6d: */
6490         ISPOPMAP(0xcf, 0x03),   /* 0x6e: MBOX_SEND_SNS */
6491         ISPOPMAP(0x0f, 0x07),   /* 0x6f: MBOX_FABRIC_LOGIN */
6492         ISPOPMAP(0x03, 0x01),   /* 0x70: MBOX_SEND_CHANGE_REQUEST */
6493         ISPOPMAP(0x03, 0x03),   /* 0x71: MBOX_FABRIC_LOGOUT */
6494         ISPOPMAP(0x0f, 0x0f),   /* 0x72: MBOX_INIT_LIP_LOGIN */
6495         ISPOPMAP(0x00, 0x00),   /* 0x73: */
6496         ISPOPMAP(0x07, 0x01),   /* 0x74: LOGIN LOOP PORT */
6497         ISPOPMAP(0xcf, 0x03),   /* 0x75: GET PORT/NODE NAME LIST */
6498         ISPOPMAP(0x4f, 0x01),   /* 0x76: SET VENDOR ID */
6499         ISPOPMAP(0xcd, 0x01),   /* 0x77: INITIALIZE IP MAILBOX */
6500         ISPOPMAP(0x00, 0x00),   /* 0x78: */
6501         ISPOPMAP(0x00, 0x00),   /* 0x79: */
6502         ISPOPMAP(0x00, 0x00),   /* 0x7a: */
6503         ISPOPMAP(0x00, 0x00),   /* 0x7b: */
6504         ISPOPMAP(0x4f, 0x03),   /* 0x7c: Get ID List */
6505         ISPOPMAP(0xcf, 0x01),   /* 0x7d: SEND LFA */
6506         ISPOPMAP(0x0f, 0x01)    /* 0x7e: LUN RESET */
6507 };
6508 /*
6509  * Footnotes
6510  *
6511  * (1): this sets bits 21..16 in mailbox register #8, which we nominally
6512  *      do not access at this time in the core driver. The caller is
6513  *      responsible for setting this register first (Gross!). The assumption
6514  *      is that we won't overflow.
6515  */
6516
6517 static const char *fc_mbcmd_names[] = {
6518         "NO-OP",
6519         "LOAD RAM",
6520         "EXEC FIRMWARE",
6521         "DUMP RAM",
6522         "WRITE RAM WORD",
6523         "READ RAM WORD",
6524         "MAILBOX REG TEST",
6525         "VERIFY CHECKSUM",
6526         "ABOUT FIRMWARE",
6527         "LOAD RAM",
6528         "DUMP RAM",
6529         "WRITE RAM WORD EXTENDED",
6530         NULL,
6531         "READ RAM WORD EXTENDED",
6532         "CHECK FIRMWARE",
6533         NULL,
6534         "INIT REQUEST QUEUE",
6535         "INIT RESULT QUEUE",
6536         "EXECUTE IOCB",
6537         "WAKE UP",
6538         "STOP FIRMWARE",
6539         "ABORT",
6540         "ABORT DEVICE",
6541         "ABORT TARGET",
6542         "BUS RESET",
6543         "STOP QUEUE",
6544         "START QUEUE",
6545         "SINGLE STEP QUEUE",
6546         "ABORT QUEUE",
6547         "GET DEV QUEUE STATUS",
6548         NULL,
6549         "GET FIRMWARE STATUS",
6550         "GET LOOP ID",
6551         NULL,
6552         "GET RETRY COUNT",
6553         NULL,
6554         NULL,
6555         NULL,
6556         NULL,
6557         NULL,
6558         "GET FIRMWARE OPTIONS",
6559         "GET PORT QUEUE PARAMS",
6560         NULL,
6561         NULL,
6562         NULL,
6563         NULL,
6564         NULL,
6565         NULL,
6566         NULL,
6567         NULL,
6568         "SET RETRY COUNT",
6569         NULL,
6570         NULL,
6571         NULL,
6572         NULL,
6573         NULL,
6574         "SET FIRMWARE OPTIONS",
6575         "SET PORT QUEUE PARAMS",
6576         NULL,
6577         NULL,
6578         NULL,
6579         NULL,
6580         NULL,
6581         NULL,
6582         "LOOP PORT BYPASS",
6583         "LOOP PORT ENABLE",
6584         "GET RESOURCE COUNT",
6585         "REQUEST NON PARTICIPATING MODE",
6586         NULL,
6587         NULL,
6588         NULL,
6589         "GET PORT DATABASE ENHANCED",
6590         NULL,
6591         NULL,
6592         NULL,
6593         NULL,
6594         NULL,
6595         NULL,
6596         NULL,
6597         NULL,
6598         NULL,
6599         NULL,
6600         NULL,
6601         NULL,
6602         "EXECUTE IOCB A64",
6603         NULL,
6604         NULL,
6605         NULL,
6606         NULL,
6607         NULL,
6608         NULL,
6609         "DRIVER HEARTBEAT",
6610         NULL,
6611         "GET/SET DATA RATE",
6612         NULL,
6613         NULL,
6614         "INIT FIRMWARE",
6615         NULL,
6616         "INIT LIP",
6617         "GET FC-AL POSITION MAP",
6618         "GET PORT DATABASE",
6619         "CLEAR ACA",
6620         "TARGET RESET",
6621         "CLEAR TASK SET",
6622         "ABORT TASK SET",
6623         "GET FW STATE",
6624         "GET PORT NAME",
6625         "GET LINK STATUS",
6626         "INIT LIP RESET",
6627         NULL,
6628         "SEND SNS",
6629         "FABRIC LOGIN",
6630         "SEND CHANGE REQUEST",
6631         "FABRIC LOGOUT",
6632         "INIT LIP LOGIN",
6633         NULL,
6634         "LOGIN LOOP PORT",
6635         "GET PORT/NODE NAME LIST",
6636         "SET VENDOR ID",
6637         "INITIALIZE IP MAILBOX",
6638         NULL,
6639         NULL,
6640         NULL,
6641         NULL,
6642         "Get ID List",
6643         "SEND LFA",
6644         "Lun RESET"
6645 };
6646
6647 static void
6648 isp_mboxcmd_qnw(ispsoftc_t *isp, mbreg_t *mbp, int nodelay)
6649 {
6650         unsigned int ibits, obits, box, opcode;
6651         const uint32_t *mcp;
6652
6653         if (IS_FC(isp)) {
6654                 mcp = mbpfc;
6655         } else {
6656                 mcp = mbpscsi;
6657         }
6658         opcode = mbp->param[0];
6659         ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6660         obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6661         ibits |= mbp->ibits;
6662         obits |= mbp->obits;
6663         for (box = 0; box < MAX_MAILBOX(isp); box++) {
6664                 if (ibits & (1 << box)) {
6665                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6666                 }
6667                 if (nodelay == 0) {
6668                         isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6669                 }
6670         }
6671         if (nodelay == 0) {
6672                 isp->isp_lastmbxcmd = opcode;
6673                 isp->isp_obits = obits;
6674                 isp->isp_mboxbsy = 1;
6675         }
6676         if (IS_24XX(isp)) {
6677                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6678         } else {
6679                 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6680         }
6681         /*
6682          * Oddly enough, if we're not delaying for an answer,
6683          * delay a bit to give the f/w a chance to pick up the
6684          * command.
6685          */
6686         if (nodelay) {
6687                 USEC_DELAY(1000);
6688         }
6689 }
6690
6691 static void
6692 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp)
6693 {
6694         const char *cname, *xname;
6695         char tname[16], mname[16];
6696         unsigned int lim, ibits, obits, box, opcode;
6697         const uint32_t *mcp;
6698
6699         if (IS_FC(isp)) {
6700                 mcp = mbpfc;
6701                 lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
6702         } else {
6703                 mcp = mbpscsi;
6704                 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
6705         }
6706
6707         if ((opcode = mbp->param[0]) >= lim) {
6708                 mbp->param[0] = MBOX_INVALID_COMMAND;
6709                 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
6710                 return;
6711         }
6712
6713         ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6714         obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
6715
6716         /*
6717          * Pick up any additional bits that the caller might have set.
6718          */
6719         ibits |= mbp->ibits;
6720         obits |= mbp->obits;
6721
6722         if (ibits == 0 && obits == 0) {
6723                 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
6724                 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
6725                 return;
6726         }
6727
6728         /*
6729          * Get exclusive usage of mailbox registers.
6730          */
6731         if (MBOX_ACQUIRE(isp)) {
6732                 mbp->param[0] = MBOX_REGS_BUSY;
6733                 goto out;
6734         }
6735
6736         for (box = 0; box < MAX_MAILBOX(isp); box++) {
6737                 if (ibits & (1 << box)) {
6738                         isp_prt(isp, ISP_LOGDEBUG1, "IN mbox %d = 0x%04x", box,
6739                             mbp->param[box]);
6740                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
6741                 }
6742                 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
6743         }
6744
6745         isp->isp_lastmbxcmd = opcode;
6746
6747         /*
6748          * We assume that we can't overwrite a previous command.
6749          */
6750         isp->isp_obits = obits;
6751         isp->isp_mboxbsy = 1;
6752
6753         /*
6754          * Set Host Interrupt condition so that RISC will pick up mailbox regs.
6755          */
6756         if (IS_24XX(isp)) {
6757                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_SET_HOST_INT);
6758         } else {
6759                 ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
6760         }
6761
6762         /*
6763          * While we haven't finished the command, spin our wheels here.
6764          */
6765         MBOX_WAIT_COMPLETE(isp, mbp);
6766
6767         /*
6768          * Did the command time out?
6769          */
6770         if (mbp->param[0] == MBOX_TIMEOUT) {
6771                 MBOX_RELEASE(isp);
6772                 goto out;
6773         }
6774
6775         /*
6776          * Copy back output registers.
6777          */
6778         for (box = 0; box < MAX_MAILBOX(isp); box++) {
6779                 if (obits & (1 << box)) {
6780                         mbp->param[box] = isp->isp_mboxtmp[box];
6781                         isp_prt(isp, ISP_LOGDEBUG1, "OUT mbox %d = 0x%04x", box,
6782                             mbp->param[box]);
6783                 }
6784         }
6785
6786         MBOX_RELEASE(isp);
6787  out:
6788         isp->isp_mboxbsy = 0;
6789         if (mbp->logval == 0 || opcode == MBOX_EXEC_FIRMWARE) {
6790                 return;
6791         }
6792         cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
6793         if (cname == NULL) {
6794                 cname = tname;
6795                 SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
6796         }
6797
6798         /*
6799          * Just to be chatty here...
6800          */
6801         xname = NULL;
6802         switch (mbp->param[0]) {
6803         case MBOX_COMMAND_COMPLETE:
6804                 break;
6805         case MBOX_INVALID_COMMAND:
6806                 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_COMPLETE)) {
6807                         xname = "INVALID COMMAND";
6808                 }
6809                 break;
6810         case MBOX_HOST_INTERFACE_ERROR:
6811                 if (mbp->logval & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR)) {
6812                         xname = "HOST INTERFACE ERROR";
6813                 }
6814                 break;
6815         case MBOX_TEST_FAILED:
6816                 if (mbp->logval & MBLOGMASK(MBOX_TEST_FAILED)) {
6817                         xname = "TEST FAILED";
6818                 }
6819                 break;
6820         case MBOX_COMMAND_ERROR:
6821                 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_ERROR)) {
6822                         xname = "COMMAND ERROR";
6823                 }
6824                 break;
6825         case MBOX_COMMAND_PARAM_ERROR:
6826                 if (mbp->logval & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR)) {
6827                         xname = "COMMAND PARAMETER ERROR";
6828                 }
6829                 break;
6830         case MBOX_LOOP_ID_USED:
6831                 if (mbp->logval & MBLOGMASK(MBOX_LOOP_ID_USED)) {
6832                         xname = "LOOP ID ALREADY IN USE";
6833                 }
6834                 break;
6835         case MBOX_PORT_ID_USED:
6836                 if (mbp->logval & MBLOGMASK(MBOX_PORT_ID_USED)) {
6837                         xname = "PORT ID ALREADY IN USE";
6838                 }
6839                 break;
6840         case MBOX_ALL_IDS_USED:
6841                 if (mbp->logval & MBLOGMASK(MBOX_ALL_IDS_USED)) {
6842                         xname = "ALL LOOP IDS IN USE";
6843                 }
6844                 break;
6845         case MBOX_REGS_BUSY:
6846                 xname = "REGISTERS BUSY";
6847                 break;
6848         case MBOX_TIMEOUT:
6849                 xname = "TIMEOUT";
6850                 break;
6851         default:
6852                 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
6853                 xname = mname;
6854                 break;
6855         }
6856         if (xname) {
6857                 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
6858                     cname, xname);
6859         }
6860 }
6861
6862 static void
6863 isp_fw_state(ispsoftc_t *isp)
6864 {
6865         if (IS_FC(isp)) {
6866                 mbreg_t mbs;
6867                 fcparam *fcp = isp->isp_param;
6868
6869                 MEMZERO(&mbs, sizeof (mbs));
6870                 mbs.param[0] = MBOX_GET_FW_STATE;
6871                 mbs.logval = MBLOGALL;
6872                 isp_mboxcmd(isp, &mbs);
6873                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
6874                         fcp->isp_fwstate = mbs.param[1];
6875                 }
6876         }
6877 }
6878
6879 static void
6880 isp_update(ispsoftc_t *isp)
6881 {
6882         int bus, upmask;
6883
6884         for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
6885                 if (upmask & (1 << bus)) {
6886                         isp_update_bus(isp, bus);
6887                 }
6888                 upmask &= ~(1 << bus);
6889         }
6890 }
6891
6892 static void
6893 isp_update_bus(ispsoftc_t *isp, int bus)
6894 {
6895         int tgt;
6896         mbreg_t mbs;
6897         sdparam *sdp;
6898
6899         isp->isp_update &= ~(1 << bus);
6900         if (IS_FC(isp)) {
6901                 /*
6902                  * There are no 'per-bus' settings for Fibre Channel.
6903                  */
6904                 return;
6905         }
6906         sdp = isp->isp_param;
6907         sdp += bus;
6908
6909         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6910                 uint16_t flags, period, offset;
6911                 int get;
6912
6913                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
6914                         sdp->isp_devparam[tgt].dev_update = 0;
6915                         sdp->isp_devparam[tgt].dev_refresh = 0;
6916                         isp_prt(isp, ISP_LOGDEBUG0,
6917                             "skipping target %d bus %d update", tgt, bus);
6918                         continue;
6919                 }
6920                 /*
6921                  * If the goal is to update the status of the device,
6922                  * take what's in goal_flags and try and set the device
6923                  * toward that. Otherwise, if we're just refreshing the
6924                  * current device state, get the current parameters.
6925                  */
6926
6927                 MEMZERO(&mbs, sizeof (mbs));
6928
6929                 /*
6930                  * Refresh overrides set
6931                  */
6932                 if (sdp->isp_devparam[tgt].dev_refresh) {
6933                         mbs.param[0] = MBOX_GET_TARGET_PARAMS;
6934                         get = 1;
6935                 } else if (sdp->isp_devparam[tgt].dev_update) {
6936                         mbs.param[0] = MBOX_SET_TARGET_PARAMS;
6937
6938                         /*
6939                          * Make sure goal_flags has "Renegotiate on Error"
6940                          * on and "Freeze Queue on Error" off.
6941                          */
6942                         sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
6943                         sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
6944                         mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
6945
6946                         /*
6947                          * Insist that PARITY must be enabled
6948                          * if SYNC or WIDE is enabled.
6949                          */
6950                         if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
6951                                 mbs.param[2] |= DPARM_PARITY;
6952                         }
6953
6954                         if (mbs.param[2] & DPARM_SYNC) {
6955                                 mbs.param[3] =
6956                                     (sdp->isp_devparam[tgt].goal_offset << 8) |
6957                                     (sdp->isp_devparam[tgt].goal_period);
6958                         }
6959                         /*
6960                          * A command completion later that has
6961                          * RQSTF_NEGOTIATION set can cause
6962                          * the dev_refresh/announce cycle also.
6963                          *
6964                          * Note: It is really important to update our current
6965                          * flags with at least the state of TAG capabilities-
6966                          * otherwise we might try and send a tagged command
6967                          * when we have it all turned off. So change it here
6968                          * to say that current already matches goal.
6969                          */
6970                         sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
6971                         sdp->isp_devparam[tgt].actv_flags |=
6972                             (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
6973                         isp_prt(isp, ISP_LOGDEBUG0,
6974                             "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
6975                             bus, tgt, mbs.param[2], mbs.param[3] >> 8,
6976                             mbs.param[3] & 0xff);
6977                         get = 0;
6978                 } else {
6979                         continue;
6980                 }
6981                 mbs.param[1] = (bus << 15) | (tgt << 8);
6982                 mbs.logval = MBLOGALL;
6983                 isp_mboxcmd(isp, &mbs);
6984                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6985                         continue;
6986                 }
6987                 if (get == 0) {
6988                         isp->isp_sendmarker |= (1 << bus);
6989                         sdp->isp_devparam[tgt].dev_update = 0;
6990                         sdp->isp_devparam[tgt].dev_refresh = 1;
6991                 } else {
6992                         sdp->isp_devparam[tgt].dev_refresh = 0;
6993                         flags = mbs.param[2];
6994                         period = mbs.param[3] & 0xff;
6995                         offset = mbs.param[3] >> 8;
6996                         sdp->isp_devparam[tgt].actv_flags = flags;
6997                         sdp->isp_devparam[tgt].actv_period = period;
6998                         sdp->isp_devparam[tgt].actv_offset = offset;
6999                         get = (bus << 16) | tgt;
7000                         (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
7001                 }
7002         }
7003
7004         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7005                 if (sdp->isp_devparam[tgt].dev_update ||
7006                     sdp->isp_devparam[tgt].dev_refresh) {
7007                         isp->isp_update |= (1 << bus);
7008                         break;
7009                 }
7010         }
7011 }
7012
7013 #ifndef DEFAULT_EXEC_THROTTLE
7014 #define DEFAULT_EXEC_THROTTLE(isp)      ISP_EXEC_THROTTLE
7015 #endif
7016
7017 static void
7018 isp_setdfltparm(ispsoftc_t *isp, int channel)
7019 {
7020         int tgt;
7021         sdparam *sdp;
7022
7023         sdp = (sdparam *) isp->isp_param;
7024         sdp += channel;
7025
7026         /*
7027          * Been there, done that, got the T-shirt...
7028          */
7029         if (sdp->isp_gotdparms) {
7030                 return;
7031         }
7032         sdp->isp_gotdparms = 1;
7033         sdp->isp_bad_nvram = 0;
7034         /*
7035          * Establish some default parameters.
7036          */
7037         sdp->isp_cmd_dma_burst_enable = 0;
7038         sdp->isp_data_dma_burst_enabl = 1;
7039         sdp->isp_fifo_threshold = 0;
7040         sdp->isp_initiator_id = DEFAULT_IID(isp);
7041         if (isp->isp_type >= ISP_HA_SCSI_1040) {
7042                 sdp->isp_async_data_setup = 9;
7043         } else {
7044                 sdp->isp_async_data_setup = 6;
7045         }
7046         sdp->isp_selection_timeout = 250;
7047         sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
7048         sdp->isp_tag_aging = 8;
7049         sdp->isp_bus_reset_delay = 5;
7050         /*
7051          * Don't retry selection, busy or queue full automatically- reflect
7052          * these back to us.
7053          */
7054         sdp->isp_retry_count = 0;
7055         sdp->isp_retry_delay = 0;
7056
7057         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7058                 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
7059                 sdp->isp_devparam[tgt].dev_enable = 1;
7060         }
7061
7062         /*
7063          * If we've not been told to avoid reading NVRAM, try and read it.
7064          * If we're successful reading it, we can then return because NVRAM
7065          * will tell us what the desired settings are. Otherwise, we establish
7066          * some reasonable 'fake' nvram and goal defaults.
7067          */
7068
7069         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7070                 if (isp_read_nvram(isp) == 0) {
7071                         return;
7072                 }
7073                 sdp->isp_bad_nvram = 1;
7074         }
7075
7076         /*
7077          * Now try and see whether we have specific values for them.
7078          */
7079         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7080                 mbreg_t mbs;
7081
7082                 MEMZERO(&mbs, sizeof (mbs));
7083                 mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
7084                 mbs.logval = MBLOGNONE;
7085                 isp_mboxcmd(isp, &mbs);
7086                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
7087                         sdp->isp_req_ack_active_neg = 1;
7088                         sdp->isp_data_line_active_neg = 1;
7089                 } else {
7090                         sdp->isp_req_ack_active_neg =
7091                             (mbs.param[1+channel] >> 4) & 0x1;
7092                         sdp->isp_data_line_active_neg =
7093                             (mbs.param[1+channel] >> 5) & 0x1;
7094                 }
7095         }
7096
7097         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
7098             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7099             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7100             sdp->isp_retry_delay, sdp->isp_async_data_setup);
7101         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
7102             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7103             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7104             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7105
7106         /*
7107          * The trick here is to establish a default for the default (honk!)
7108          * state (goal_flags). Then try and get the current status from
7109          * the card to fill in the current state. We don't, in fact, set
7110          * the default to the SAFE default state- that's not the goal state.
7111          */
7112         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7113                 uint8_t off, per;
7114                 sdp->isp_devparam[tgt].actv_offset = 0;
7115                 sdp->isp_devparam[tgt].actv_period = 0;
7116                 sdp->isp_devparam[tgt].actv_flags = 0;
7117
7118                 sdp->isp_devparam[tgt].goal_flags =
7119                     sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
7120
7121                 /*
7122                  * We default to Wide/Fast for versions less than a 1040
7123                  * (unless it's SBus).
7124                  */
7125                 if (IS_ULTRA3(isp)) {
7126                         off = ISP_80M_SYNCPARMS >> 8;
7127                         per = ISP_80M_SYNCPARMS & 0xff;
7128                 } else if (IS_ULTRA2(isp)) {
7129                         off = ISP_40M_SYNCPARMS >> 8;
7130                         per = ISP_40M_SYNCPARMS & 0xff;
7131                 } else if (IS_1240(isp)) {
7132                         off = ISP_20M_SYNCPARMS >> 8;
7133                         per = ISP_20M_SYNCPARMS & 0xff;
7134                 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
7135                     isp->isp_type < ISP_HA_SCSI_1020A) ||
7136                     (isp->isp_bustype == ISP_BT_PCI &&
7137                     isp->isp_type < ISP_HA_SCSI_1040) ||
7138                     (isp->isp_clock && isp->isp_clock < 60) ||
7139                     (sdp->isp_ultramode == 0)) {
7140                         off = ISP_10M_SYNCPARMS >> 8;
7141                         per = ISP_10M_SYNCPARMS & 0xff;
7142                 } else {
7143                         off = ISP_20M_SYNCPARMS_1040 >> 8;
7144                         per = ISP_20M_SYNCPARMS_1040 & 0xff;
7145                 }
7146                 sdp->isp_devparam[tgt].goal_offset =
7147                     sdp->isp_devparam[tgt].nvrm_offset = off;
7148                 sdp->isp_devparam[tgt].goal_period =
7149                     sdp->isp_devparam[tgt].nvrm_period = per;
7150
7151                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
7152                     channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7153                     sdp->isp_devparam[tgt].nvrm_offset,
7154                     sdp->isp_devparam[tgt].nvrm_period);
7155         }
7156 }
7157
7158 #ifndef DEFAULT_FRAMESIZE
7159 #define DEFAULT_FRAMESIZE(isp)          ICB_DFLT_FRMLEN
7160 #endif
7161 static void
7162 isp_setdfltfcparm(ispsoftc_t *isp)
7163 {
7164         fcparam *fcp = FCPARAM(isp);
7165
7166         if (fcp->isp_gotdparms) {
7167                 return;
7168         }
7169         fcp->isp_gotdparms = 1;
7170         fcp->isp_bad_nvram = 0;
7171         fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
7172         fcp->isp_maxalloc = ICB_DFLT_ALLOC;
7173         fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
7174         fcp->isp_retry_delay = ICB_DFLT_RDELAY;
7175         fcp->isp_retry_count = ICB_DFLT_RCOUNT;
7176         /* Platform specific.... */
7177         fcp->isp_loopid = DEFAULT_LOOPID(isp);
7178         fcp->isp_wwnn_nvram = DEFAULT_NODEWWN(isp);
7179         fcp->isp_wwpn_nvram = DEFAULT_PORTWWN(isp);
7180         fcp->isp_fwoptions = 0;
7181         fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
7182         fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
7183         fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
7184         fcp->isp_fwoptions |= ICBOPT_FAST_POST;
7185         if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) {
7186                 fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
7187         }
7188
7189         /*
7190          * Make sure this is turned off now until we get
7191          * extended options from NVRAM
7192          */
7193         fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
7194
7195         /*
7196          * Now try and read NVRAM unless told to not do so.
7197          * This will set fcparam's isp_wwnn_nvram && isp_wwpn_nvram.
7198          */
7199         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
7200                 int i, j = 0;
7201                 /*
7202                  * Give a couple of tries at reading NVRAM.
7203                  */
7204                 for (i = 0; i < 2; i++) {
7205                         j = isp_read_nvram(isp);
7206                         if (j == 0) {
7207                                 break;
7208                         }
7209                 }
7210                 if (j) {
7211                         fcp->isp_bad_nvram = 1;
7212                         isp->isp_confopts |= ISP_CFG_NONVRAM;
7213                         isp->isp_confopts |= ISP_CFG_OWNWWPN;
7214                         isp->isp_confopts |= ISP_CFG_OWNWWNN;
7215                 }
7216         } else {
7217                 isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
7218         }
7219
7220         /*
7221          * Set node && port to override platform set defaults
7222          * unless the nvram read failed (or none was done),
7223          * or the platform code wants to use what had been
7224          * set in the defaults.
7225          */
7226         if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
7227                 isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
7228                     (uint32_t) (DEFAULT_NODEWWN(isp) >> 32),
7229                     (uint32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
7230                 ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7231         } else {
7232                 /*
7233                  * We always start out with values derived
7234                  * from NVRAM or our platform default.
7235                  */
7236                 ISP_NODEWWN(isp) = fcp->isp_wwnn_nvram;
7237                 if (fcp->isp_wwnn_nvram == 0) {
7238                         isp_prt(isp, ISP_LOGCONFIG,
7239                             "bad WWNN- using default");
7240                         ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
7241                 }
7242         }
7243         if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
7244                 isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
7245                     (uint32_t) (DEFAULT_PORTWWN(isp) >> 32),
7246                     (uint32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
7247                 ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7248         } else {
7249                 /*
7250                  * We always start out with values derived
7251                  * from NVRAM or our platform default.
7252                  */
7253                 ISP_PORTWWN(isp) = fcp->isp_wwpn_nvram;
7254                 if (fcp->isp_wwpn_nvram == 0) {
7255                         isp_prt(isp, ISP_LOGCONFIG,
7256                             "bad WWPN- using default");
7257                         ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
7258                 }
7259         }
7260 }
7261
7262 /*
7263  * Re-initialize the ISP and complete all orphaned commands
7264  * with a 'botched' notice. The reset/init routines should
7265  * not disturb an already active list of commands.
7266  */
7267
7268 void
7269 isp_reinit(ispsoftc_t *isp)
7270 {
7271         XS_T *xs;
7272         uint32_t tmp;
7273
7274         if (IS_FC(isp)) {
7275                 ISP_MARK_PORTDB(isp, 0);
7276         }
7277         isp_reset(isp);
7278         if (isp->isp_state != ISP_RESETSTATE) {
7279                 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
7280         } else if (isp->isp_role != ISP_ROLE_NONE) {
7281                 isp_init(isp);
7282                 if (isp->isp_state == ISP_INITSTATE) {
7283                         isp->isp_state = ISP_RUNSTATE;
7284                 }
7285                 if (isp->isp_state != ISP_RUNSTATE) {
7286                         isp_prt(isp, ISP_LOGERR,
7287                             "isp_reinit cannot restart card");
7288                         ISP_DISABLE_INTS(isp);
7289                 }
7290         } else {
7291                 ISP_DISABLE_INTS(isp);
7292                 if (IS_FC(isp)) {
7293                         /*
7294                          * If we're in ISP_ROLE_NONE, turn off the lasers.
7295                          */
7296                         if (!IS_24XX(isp)) {
7297                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
7298                                 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
7299                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
7300                                 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
7301                                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
7302                         }
7303                 }
7304         }
7305         isp->isp_nactive = 0;
7306
7307         for (tmp = 0; tmp < isp->isp_maxcmds; tmp++) {
7308                 uint32_t handle;
7309
7310                 xs = isp->isp_xflist[tmp];
7311                 if (xs == NULL) {
7312                         continue;
7313                 }
7314                 handle = isp_find_handle(isp, xs);
7315                 if (handle == 0) {
7316                         continue;
7317                 }
7318                 isp_destroy_handle(isp, handle);
7319                 if (XS_XFRLEN(xs)) {
7320                         ISP_DMAFREE(isp, xs, handle);
7321                         XS_RESID(xs) = XS_XFRLEN(xs);
7322                 } else {
7323                         XS_RESID(xs) = 0;
7324                 }
7325                 XS_SETERR(xs, HBA_BUSRESET);
7326                 isp_done(xs);
7327         }
7328 #ifdef  ISP_TARGET_MODE
7329         MEMZERO(isp->isp_tgtlist, isp->isp_maxcmds * sizeof (void **));
7330 #endif
7331 }
7332
7333 /*
7334  * NVRAM Routines
7335  */
7336 static int
7337 isp_read_nvram(ispsoftc_t *isp)
7338 {
7339         int i, amt, retval;
7340         uint8_t csum, minversion;
7341         union {
7342                 uint8_t _x[ISP2100_NVRAM_SIZE];
7343                 uint16_t _s[ISP2100_NVRAM_SIZE>>1];
7344         } _n;
7345 #define nvram_data      _n._x
7346 #define nvram_words     _n._s
7347
7348         if (IS_24XX(isp)) {
7349                 return (isp_read_nvram_2400(isp));
7350         } else if (IS_FC(isp)) {
7351                 amt = ISP2100_NVRAM_SIZE;
7352                 minversion = 1;
7353         } else if (IS_ULTRA2(isp)) {
7354                 amt = ISP1080_NVRAM_SIZE;
7355                 minversion = 0;
7356         } else {
7357                 amt = ISP_NVRAM_SIZE;
7358                 minversion = 2;
7359         }
7360
7361         for (i = 0; i < amt>>1; i++) {
7362                 isp_rdnvram_word(isp, i, &nvram_words[i]);
7363         }
7364
7365         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7366             nvram_data[2] != 'P') {
7367                 if (isp->isp_bustype != ISP_BT_SBUS) {
7368                         isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
7369                         isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
7370                             nvram_data[0], nvram_data[1], nvram_data[2]);
7371                 }
7372                 retval = -1;
7373                 goto out;
7374         }
7375
7376         for (csum = 0, i = 0; i < amt; i++) {
7377                 csum += nvram_data[i];
7378         }
7379         if (csum != 0) {
7380                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7381                 retval = -1;
7382                 goto out;
7383         }
7384
7385         if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
7386                 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
7387                     ISP_NVRAM_VERSION(nvram_data));
7388                 retval = -1;
7389                 goto out;
7390         }
7391
7392         if (IS_ULTRA3(isp)) {
7393                 isp_parse_nvram_12160(isp, 0, nvram_data);
7394                 if (IS_12160(isp))
7395                         isp_parse_nvram_12160(isp, 1, nvram_data);
7396         } else if (IS_1080(isp)) {
7397                 isp_parse_nvram_1080(isp, 0, nvram_data);
7398         } else if (IS_1280(isp) || IS_1240(isp)) {
7399                 isp_parse_nvram_1080(isp, 0, nvram_data);
7400                 isp_parse_nvram_1080(isp, 1, nvram_data);
7401         } else if (IS_SCSI(isp)) {
7402                 isp_parse_nvram_1020(isp, nvram_data);
7403         } else {
7404                 isp_parse_nvram_2100(isp, nvram_data);
7405         }
7406         retval = 0;
7407 out:
7408         return (retval);
7409 #undef  nvram_data
7410 #undef  nvram_words
7411 }
7412
7413 static int
7414 isp_read_nvram_2400(ispsoftc_t *isp)
7415 {
7416         uint8_t *nvram_data = FCPARAM(isp)->isp_scratch;
7417         int retval = 0;
7418         uint32_t addr, csum, lwrds, *dptr;
7419
7420         if (isp->isp_port) {
7421                 addr = ISP2400_NVRAM_PORT1_ADDR;
7422         } else {
7423                 addr = ISP2400_NVRAM_PORT0_ADDR;
7424         }
7425
7426         dptr = (uint32_t *) nvram_data;
7427         for (lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7428                 isp_rd_2400_nvram(isp, addr++, dptr++);
7429         }
7430         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
7431             nvram_data[2] != 'P') {
7432                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header (%x %x %x)",
7433                     nvram_data[0], nvram_data[1], nvram_data[2]);
7434                 retval = -1;
7435                 goto out;
7436         }
7437         dptr = (uint32_t *) nvram_data;
7438         for (csum = 0, lwrds = 0; lwrds < ISP2400_NVRAM_SIZE >> 2; lwrds++) {
7439                 uint32_t tmp;
7440                 ISP_IOXGET_32(isp, &dptr[lwrds], tmp);
7441                 csum += tmp;
7442         }
7443         if (csum != 0) {
7444                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
7445                 retval = -1;
7446                 goto out;
7447         }
7448         isp_parse_nvram_2400(isp, nvram_data);
7449 out:
7450         return (retval);
7451 }
7452
7453 static void
7454 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
7455 {
7456         int i, cbits;
7457         uint16_t bit, rqst, junk;
7458
7459         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7460         USEC_DELAY(10);
7461         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7462         USEC_DELAY(10);
7463
7464         if (IS_FC(isp)) {
7465                 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
7466                 if (IS_2312(isp) && isp->isp_port) {
7467                         wo += 128;
7468                 }
7469                 rqst = (ISP_NVRAM_READ << 8) | wo;
7470                 cbits = 10;
7471         } else if (IS_ULTRA2(isp)) {
7472                 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
7473                 rqst = (ISP_NVRAM_READ << 8) | wo;
7474                 cbits = 10;
7475         } else {
7476                 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
7477                 rqst = (ISP_NVRAM_READ << 6) | wo;
7478                 cbits = 8;
7479         }
7480
7481         /*
7482          * Clock the word select request out...
7483          */
7484         for (i = cbits; i >= 0; i--) {
7485                 if ((rqst >> i) & 1) {
7486                         bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
7487                 } else {
7488                         bit = BIU_NVRAM_SELECT;
7489                 }
7490                 ISP_WRITE(isp, BIU_NVRAM, bit);
7491                 USEC_DELAY(10);
7492                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7493                 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
7494                 USEC_DELAY(10);
7495                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7496                 ISP_WRITE(isp, BIU_NVRAM, bit);
7497                 USEC_DELAY(10);
7498                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7499         }
7500         /*
7501          * Now read the result back in (bits come back in MSB format).
7502          */
7503         *rp = 0;
7504         for (i = 0; i < 16; i++) {
7505                 uint16_t rv;
7506                 *rp <<= 1;
7507                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
7508                 USEC_DELAY(10);
7509                 rv = ISP_READ(isp, BIU_NVRAM);
7510                 if (rv & BIU_NVRAM_DATAIN) {
7511                         *rp |= 1;
7512                 }
7513                 USEC_DELAY(10);
7514                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
7515                 USEC_DELAY(10);
7516                 junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7517         }
7518         ISP_WRITE(isp, BIU_NVRAM, 0);
7519         USEC_DELAY(10);
7520         junk = ISP_READ(isp, BIU_NVRAM);        /* force PCI flush */
7521         ISP_SWIZZLE_NVRAM_WORD(isp, rp);
7522 }
7523
7524 static void
7525 isp_rd_2400_nvram(ispsoftc_t *isp, uint32_t addr, uint32_t *rp)
7526 {
7527         int loops = 0;
7528         const uint32_t base = 0x7ffe0000;
7529         uint32_t tmp = 0;
7530
7531         ISP_WRITE(isp, BIU2400_FLASH_ADDR, base | addr);
7532         for (loops = 0; loops < 5000; loops++) {
7533                 USEC_DELAY(10);
7534                 tmp = ISP_READ(isp, BIU2400_FLASH_ADDR);
7535                 if ((tmp & (1U << 31)) != 0) {
7536                         break;
7537                 }
7538         }
7539         if (tmp & (1U << 31)) {
7540                 *rp = ISP_READ(isp, BIU2400_FLASH_DATA);
7541                 ISP_SWIZZLE_NVRAM_LONG(isp, rp);
7542         } else {
7543                 *rp = 0xffffffff;
7544         }
7545 }
7546
7547 static void
7548 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
7549 {
7550         sdparam *sdp = (sdparam *) isp->isp_param;
7551         int tgt;
7552
7553         sdp->isp_fifo_threshold =
7554                 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
7555                 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
7556
7557         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7558                 sdp->isp_initiator_id =
7559                         ISP_NVRAM_INITIATOR_ID(nvram_data);
7560
7561         sdp->isp_bus_reset_delay =
7562                 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
7563
7564         sdp->isp_retry_count =
7565                 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
7566
7567         sdp->isp_retry_delay =
7568                 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
7569
7570         sdp->isp_async_data_setup =
7571                 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
7572
7573         if (isp->isp_type >= ISP_HA_SCSI_1040) {
7574                 if (sdp->isp_async_data_setup < 9) {
7575                         sdp->isp_async_data_setup = 9;
7576                 }
7577         } else {
7578                 if (sdp->isp_async_data_setup != 6) {
7579                         sdp->isp_async_data_setup = 6;
7580                 }
7581         }
7582
7583         sdp->isp_req_ack_active_neg =
7584                 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
7585
7586         sdp->isp_data_line_active_neg =
7587                 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
7588
7589         sdp->isp_data_dma_burst_enabl =
7590                 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
7591
7592         sdp->isp_cmd_dma_burst_enable =
7593                 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
7594
7595         sdp->isp_tag_aging =
7596                 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
7597
7598         sdp->isp_selection_timeout =
7599                 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
7600
7601         sdp->isp_max_queue_depth =
7602                 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
7603
7604         sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
7605
7606         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7607             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7608             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7609             sdp->isp_retry_delay, sdp->isp_async_data_setup);
7610         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7611             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7612             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7613             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7614
7615         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7616                 sdp->isp_devparam[tgt].dev_enable =
7617                         ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
7618                 sdp->isp_devparam[tgt].exc_throttle =
7619                         ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
7620                 sdp->isp_devparam[tgt].nvrm_offset =
7621                         ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
7622                 sdp->isp_devparam[tgt].nvrm_period =
7623                         ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
7624                 /*
7625                  * We probably shouldn't lie about this, but it
7626                  * it makes it much safer if we limit NVRAM values
7627                  * to sanity.
7628                  */
7629                 if (isp->isp_type < ISP_HA_SCSI_1040) {
7630                         /*
7631                          * If we're not ultra, we can't possibly
7632                          * be a shorter period than this.
7633                          */
7634                         if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
7635                                 sdp->isp_devparam[tgt].nvrm_period = 0x19;
7636                         }
7637                         if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
7638                                 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
7639                         }
7640                 } else {
7641                         if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
7642                                 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
7643                         }
7644                 }
7645                 sdp->isp_devparam[tgt].nvrm_flags = 0;
7646                 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
7647                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7648                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7649                 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
7650                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7651                 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
7652                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7653                 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
7654                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7655                 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
7656                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7657                 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
7658                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7659                 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
7660                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7661                     0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7662                     sdp->isp_devparam[tgt].nvrm_offset,
7663                     sdp->isp_devparam[tgt].nvrm_period);
7664                 sdp->isp_devparam[tgt].goal_offset =
7665                     sdp->isp_devparam[tgt].nvrm_offset;
7666                 sdp->isp_devparam[tgt].goal_period =
7667                     sdp->isp_devparam[tgt].nvrm_period;
7668                 sdp->isp_devparam[tgt].goal_flags =
7669                     sdp->isp_devparam[tgt].nvrm_flags;
7670         }
7671 }
7672
7673 static void
7674 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7675 {
7676         sdparam *sdp = (sdparam *) isp->isp_param;
7677         int tgt;
7678
7679         sdp += bus;
7680
7681         sdp->isp_fifo_threshold =
7682             ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
7683
7684         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7685                 sdp->isp_initiator_id =
7686                     ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
7687
7688         sdp->isp_bus_reset_delay =
7689             ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7690
7691         sdp->isp_retry_count =
7692             ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7693
7694         sdp->isp_retry_delay =
7695             ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7696
7697         sdp->isp_async_data_setup =
7698             ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7699
7700         sdp->isp_req_ack_active_neg =
7701             ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7702
7703         sdp->isp_data_line_active_neg =
7704             ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7705
7706         sdp->isp_data_dma_burst_enabl =
7707             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7708
7709         sdp->isp_cmd_dma_burst_enable =
7710             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
7711
7712         sdp->isp_selection_timeout =
7713             ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7714
7715         sdp->isp_max_queue_depth =
7716              ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7717
7718         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7719             bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7720             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7721             sdp->isp_retry_delay, sdp->isp_async_data_setup);
7722         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7723             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7724             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7725             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7726
7727
7728         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7729                 sdp->isp_devparam[tgt].dev_enable =
7730                     ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7731                 sdp->isp_devparam[tgt].exc_throttle =
7732                         ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7733                 sdp->isp_devparam[tgt].nvrm_offset =
7734                         ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7735                 sdp->isp_devparam[tgt].nvrm_period =
7736                         ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7737                 sdp->isp_devparam[tgt].nvrm_flags = 0;
7738                 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7739                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7740                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7741                 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7742                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7743                 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7744                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7745                 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7746                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7747                 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7748                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7749                 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7750                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7751                 sdp->isp_devparam[tgt].actv_flags = 0;
7752                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7753                     bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7754                     sdp->isp_devparam[tgt].nvrm_offset,
7755                     sdp->isp_devparam[tgt].nvrm_period);
7756                 sdp->isp_devparam[tgt].goal_offset =
7757                     sdp->isp_devparam[tgt].nvrm_offset;
7758                 sdp->isp_devparam[tgt].goal_period =
7759                     sdp->isp_devparam[tgt].nvrm_period;
7760                 sdp->isp_devparam[tgt].goal_flags =
7761                     sdp->isp_devparam[tgt].nvrm_flags;
7762         }
7763 }
7764
7765 static void
7766 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
7767 {
7768         sdparam *sdp = (sdparam *) isp->isp_param;
7769         int tgt;
7770
7771         sdp += bus;
7772
7773         sdp->isp_fifo_threshold =
7774             ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
7775
7776         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
7777                 sdp->isp_initiator_id =
7778                     ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
7779
7780         sdp->isp_bus_reset_delay =
7781             ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
7782
7783         sdp->isp_retry_count =
7784             ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
7785
7786         sdp->isp_retry_delay =
7787             ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
7788
7789         sdp->isp_async_data_setup =
7790             ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
7791
7792         sdp->isp_req_ack_active_neg =
7793             ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
7794
7795         sdp->isp_data_line_active_neg =
7796             ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
7797
7798         sdp->isp_data_dma_burst_enabl =
7799             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7800
7801         sdp->isp_cmd_dma_burst_enable =
7802             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
7803
7804         sdp->isp_selection_timeout =
7805             ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
7806
7807         sdp->isp_max_queue_depth =
7808              ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
7809
7810         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
7811             bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
7812             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
7813             sdp->isp_retry_delay, sdp->isp_async_data_setup);
7814         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
7815             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
7816             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
7817             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
7818
7819         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
7820                 sdp->isp_devparam[tgt].dev_enable =
7821                     ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
7822                 sdp->isp_devparam[tgt].exc_throttle =
7823                         ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
7824                 sdp->isp_devparam[tgt].nvrm_offset =
7825                         ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
7826                 sdp->isp_devparam[tgt].nvrm_period =
7827                         ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
7828                 sdp->isp_devparam[tgt].nvrm_flags = 0;
7829                 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
7830                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
7831                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
7832                 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
7833                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
7834                 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
7835                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
7836                 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
7837                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
7838                 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
7839                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
7840                 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
7841                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
7842                 sdp->isp_devparam[tgt].actv_flags = 0;
7843                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
7844                     bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
7845                     sdp->isp_devparam[tgt].nvrm_offset,
7846                     sdp->isp_devparam[tgt].nvrm_period);
7847                 sdp->isp_devparam[tgt].goal_offset =
7848                     sdp->isp_devparam[tgt].nvrm_offset;
7849                 sdp->isp_devparam[tgt].goal_period =
7850                     sdp->isp_devparam[tgt].nvrm_period;
7851                 sdp->isp_devparam[tgt].goal_flags =
7852                     sdp->isp_devparam[tgt].nvrm_flags;
7853         }
7854 }
7855
7856 static void
7857 isp_fix_nvram_wwns(ispsoftc_t *isp)
7858 {
7859         fcparam *fcp = FCPARAM(isp);
7860
7861         /*
7862          * Make sure we have both Node and Port as non-zero values.
7863          */
7864         if (fcp->isp_wwnn_nvram != 0 && fcp->isp_wwpn_nvram == 0) {
7865                 fcp->isp_wwpn_nvram = fcp->isp_wwnn_nvram;
7866         } else if (fcp->isp_wwnn_nvram == 0 && fcp->isp_wwpn_nvram != 0) {
7867                 fcp->isp_wwnn_nvram = fcp->isp_wwpn_nvram;
7868         }
7869
7870         /*
7871          * Make the Node and Port values sane if they're NAA == 2.
7872          * This means to clear bits 48..56 for the Node WWN and
7873          * make sure that there's some non-zero value in 48..56
7874          * for the Port WWN.
7875          */
7876         if (fcp->isp_wwnn_nvram && fcp->isp_wwpn_nvram) {
7877                 if ((fcp->isp_wwnn_nvram & (((uint64_t) 0xfff) << 48)) != 0 &&
7878                     (fcp->isp_wwnn_nvram >> 60) == 2) {
7879                         fcp->isp_wwnn_nvram &= ~((uint64_t) 0xfff << 48);
7880                 }
7881                 if ((fcp->isp_wwpn_nvram & (((uint64_t) 0xfff) << 48)) == 0 &&
7882                     (fcp->isp_wwpn_nvram >> 60) == 2) {
7883                         fcp->isp_wwpn_nvram |= ((uint64_t) 1 << 56);
7884                 }
7885         }
7886 }
7887
7888 static void
7889 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
7890 {
7891         fcparam *fcp = FCPARAM(isp);
7892         uint64_t wwn;
7893
7894         /*
7895          * There is NVRAM storage for both Port and Node entities-
7896          * but the Node entity appears to be unused on all the cards
7897          * I can find. However, we should account for this being set
7898          * at some point in the future.
7899          *
7900          * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
7901          * bits 48..60. In the case of the 2202, it appears that they do
7902          * use bit 48 to distinguish between the two instances on the card.
7903          * The 2204, which I've never seen, *probably* extends this method.
7904          */
7905         wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
7906         if (wwn) {
7907                 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
7908                     (uint32_t) (wwn >> 32), (uint32_t) (wwn & 0xffffffff));
7909                 if ((wwn >> 60) == 0) {
7910                         wwn |= (((uint64_t) 2)<< 60);
7911                 }
7912         }
7913         fcp->isp_wwpn_nvram = wwn;
7914         if (IS_2200(isp) || IS_23XX(isp)) {
7915                 wwn = ISP2100_NVRAM_NODE_NAME(nvram_data);
7916                 if (wwn) {
7917                         isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
7918                             (uint32_t) (wwn >> 32),
7919                             (uint32_t) (wwn & 0xffffffff));
7920                         if ((wwn >> 60) == 0) {
7921                                 wwn |= (((uint64_t) 2)<< 60);
7922                         }
7923                 }
7924         } else {
7925                 wwn &= ~((uint64_t) 0xfff << 48);
7926         }
7927         fcp->isp_wwnn_nvram = wwn;
7928
7929         isp_fix_nvram_wwns(isp);
7930
7931         fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
7932         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
7933                 fcp->isp_maxfrmlen = ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
7934         }
7935         fcp->isp_retry_delay = ISP2100_NVRAM_RETRY_DELAY(nvram_data);
7936         fcp->isp_retry_count = ISP2100_NVRAM_RETRY_COUNT(nvram_data);
7937         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
7938                 fcp->isp_loopid = ISP2100_NVRAM_HARDLOOPID(nvram_data);
7939         }
7940         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
7941                 fcp->isp_execthrottle =
7942                         ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
7943         }
7944         fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
7945         isp_prt(isp, ISP_LOGDEBUG0,
7946             "NVRAM 0x%08x%08x 0x%08x%08x maxalloc %d maxframelen %d",
7947             (uint32_t) (fcp->isp_wwnn_nvram >> 32), (uint32_t) fcp->isp_wwnn_nvram,
7948             (uint32_t) (fcp->isp_wwpn_nvram >> 32), (uint32_t) fcp->isp_wwpn_nvram,
7949             ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data),
7950             ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data));
7951         isp_prt(isp, ISP_LOGDEBUG0,
7952             "execthrottle %d fwoptions 0x%x hardloop %d tov %d",
7953             ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
7954             ISP2100_NVRAM_OPTIONS(nvram_data),
7955             ISP2100_NVRAM_HARDLOOPID(nvram_data),
7956             ISP2100_NVRAM_TOV(nvram_data));
7957         fcp->isp_xfwoptions = ISP2100_XFW_OPTIONS(nvram_data);
7958         fcp->isp_zfwoptions = ISP2100_ZFW_OPTIONS(nvram_data);
7959         isp_prt(isp, ISP_LOGDEBUG0,
7960             "xfwoptions 0x%x zfw options 0x%x",
7961             ISP2100_XFW_OPTIONS(nvram_data), ISP2100_ZFW_OPTIONS(nvram_data));
7962 }
7963
7964 static void
7965 isp_parse_nvram_2400(ispsoftc_t *isp, uint8_t *nvram_data)
7966 {
7967         fcparam *fcp = FCPARAM(isp);
7968         uint64_t wwn;
7969
7970         isp_prt(isp, ISP_LOGDEBUG0,
7971             "NVRAM 0x%08x%08x 0x%08x%08x exchg_cnt %d maxframelen %d",
7972             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data) >> 32),
7973             (uint32_t) (ISP2400_NVRAM_NODE_NAME(nvram_data)),
7974             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data) >> 32),
7975             (uint32_t) (ISP2400_NVRAM_PORT_NAME(nvram_data)),
7976             ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data),
7977             ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data));
7978         isp_prt(isp, ISP_LOGDEBUG0,
7979             "NVRAM execthr %d loopid %d fwopt1 0x%x fwopt2 0x%x fwopt3 0x%x",
7980             ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data),
7981             ISP2400_NVRAM_HARDLOOPID(nvram_data),
7982             ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data),
7983             ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data),
7984             ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data));
7985
7986         wwn = ISP2400_NVRAM_PORT_NAME(nvram_data);
7987         if (wwn) {
7988                 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7989                         wwn = 0;
7990                 }
7991         }
7992         fcp->isp_wwpn_nvram = wwn;
7993
7994         wwn = ISP2400_NVRAM_NODE_NAME(nvram_data);
7995         if (wwn) {
7996                 if ((wwn >> 60) != 2 && (wwn >> 60) != 5) {
7997                         wwn = 0;
7998                 }
7999         }
8000         fcp->isp_wwnn_nvram = wwn;
8001
8002         isp_fix_nvram_wwns(isp);
8003
8004         if (ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data)) {
8005                 fcp->isp_maxalloc = ISP2400_NVRAM_EXCHANGE_COUNT(nvram_data);
8006         }
8007         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0) {
8008                 fcp->isp_maxfrmlen = ISP2400_NVRAM_MAXFRAMELENGTH(nvram_data);
8009         }
8010         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0) {
8011                 fcp->isp_loopid = ISP2400_NVRAM_HARDLOOPID(nvram_data);
8012         }
8013         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0) {
8014                 fcp->isp_execthrottle =
8015                         ISP2400_NVRAM_EXECUTION_THROTTLE(nvram_data);
8016         }
8017         fcp->isp_fwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS1(nvram_data);
8018         fcp->isp_xfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS2(nvram_data);
8019         fcp->isp_zfwoptions = ISP2400_NVRAM_FIRMWARE_OPTIONS3(nvram_data);
8020 }
8021
8022 #ifdef  ISP_FW_CRASH_DUMP
8023 static void isp2200_fw_dump(ispsoftc_t *);
8024 static void isp2300_fw_dump(ispsoftc_t *);
8025
8026 static void
8027 isp2200_fw_dump(ispsoftc_t *isp)
8028 {
8029         int i, j;
8030         mbreg_t mbs;
8031         uint16_t *ptr;
8032
8033         MEMZERO(&mbs, sizeof (mbs));
8034         ptr = FCPARAM(isp)->isp_dump_data;
8035         if (ptr == NULL) {
8036                 isp_prt(isp, ISP_LOGERR,
8037                    "No place to dump RISC registers and SRAM");
8038                 return;
8039         }
8040         if (*ptr++) {
8041                 isp_prt(isp, ISP_LOGERR,
8042                    "dump area for RISC registers and SRAM already used");
8043                 return;
8044         }
8045         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8046         for (i = 0; i < 100; i++) {
8047                 USEC_DELAY(100);
8048                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8049                         break;
8050                 }
8051         }
8052         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8053                 /*
8054                  * PBIU Registers
8055                  */
8056                 for (i = 0; i < 8; i++) {
8057                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8058                 }
8059
8060                 /*
8061                  * Mailbox Registers
8062                  */
8063                 for (i = 0; i < 8; i++) {
8064                         *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
8065                 }
8066
8067                 /*
8068                  * DMA Registers
8069                  */
8070                 for (i = 0; i < 48; i++) {
8071                         *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
8072                 }
8073
8074                 /*
8075                  * RISC H/W Registers
8076                  */
8077                 ISP_WRITE(isp, BIU2100_CSR, 0);
8078                 for (i = 0; i < 16; i++) {
8079                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8080                 }
8081
8082                 /*
8083                  * RISC GP Registers
8084                  */
8085                 for (j = 0; j < 8; j++) {
8086                         ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
8087                         for (i = 0; i < 16; i++) {
8088                                 *ptr++ =
8089                                     ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8090                         }
8091                 }
8092
8093                 /*
8094                  * Frame Buffer Hardware Registers
8095                  */
8096                 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8097                 for (i = 0; i < 16; i++) {
8098                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8099                 }
8100
8101                 /*
8102                  * Fibre Protocol Module 0 Hardware Registers
8103                  */
8104                 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8105                 for (i = 0; i < 64; i++) {
8106                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8107                 }
8108
8109                 /*
8110                  * Fibre Protocol Module 1 Hardware Registers
8111                  */
8112                 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8113                 for (i = 0; i < 64; i++) {
8114                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8115                 }
8116         } else {
8117                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8118                 return;
8119         }
8120         isp_prt(isp, ISP_LOGALL,
8121            "isp_fw_dump: RISC registers dumped successfully");
8122         ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8123         for (i = 0; i < 100; i++) {
8124                 USEC_DELAY(100);
8125                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8126                         break;
8127                 }
8128         }
8129         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8130                 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8131                 return;
8132         }
8133         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8134         for (i = 0; i < 100; i++) {
8135                 USEC_DELAY(100);
8136                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8137                         break;
8138                 }
8139         }
8140         if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8141                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
8142                 return;
8143         }
8144         ISP_WRITE(isp, RISC_EMB, 0xf2);
8145         ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
8146         for (i = 0; i < 100; i++) {
8147                 USEC_DELAY(100);
8148                 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
8149                         break;
8150                 }
8151         }
8152         ISP_ENABLE_INTS(isp);
8153         mbs.param[0] = MBOX_READ_RAM_WORD;
8154         mbs.param[1] = 0x1000;
8155         isp->isp_mbxworkp = (void *) ptr;
8156         isp->isp_mbxwrk0 = 0xefff;      /* continuation count */
8157         isp->isp_mbxwrk1 = 0x1001;      /* next SRAM address */
8158         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8159         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8160                 isp_prt(isp, ISP_LOGWARN,
8161                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8162                 return;
8163         }
8164         ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
8165         *ptr++ = isp->isp_mboxtmp[2];
8166         isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8167         FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8168         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8169 }
8170
8171 static void
8172 isp2300_fw_dump(ispsoftc_t *isp)
8173 {
8174         int i, j;
8175         mbreg_t mbs;
8176         uint16_t *ptr;
8177
8178         MEMZERO(&mbs, sizeof (mbs));
8179         ptr = FCPARAM(isp)->isp_dump_data;
8180         if (ptr == NULL) {
8181                 isp_prt(isp, ISP_LOGERR,
8182                    "No place to dump RISC registers and SRAM");
8183                 return;
8184         }
8185         if (*ptr++) {
8186                 isp_prt(isp, ISP_LOGERR,
8187                    "dump area for RISC registers and SRAM already used");
8188                 return;
8189         }
8190         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
8191         for (i = 0; i < 100; i++) {
8192                 USEC_DELAY(100);
8193                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8194                         break;
8195                 }
8196         }
8197         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
8198                 /*
8199                  * PBIU registers
8200                  */
8201                 for (i = 0; i < 8; i++) {
8202                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
8203                 }
8204
8205                 /*
8206                  * ReqQ-RspQ-Risc2Host Status registers
8207                  */
8208                 for (i = 0; i < 8; i++) {
8209                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
8210                 }
8211
8212                 /*
8213                  * Mailbox Registers
8214                  */
8215                 for (i = 0; i < 32; i++) {
8216                         *ptr++ =
8217                             ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
8218                 }
8219
8220                 /*
8221                  * Auto Request Response DMA registers
8222                  */
8223                 ISP_WRITE(isp, BIU2100_CSR, 0x40);
8224                 for (i = 0; i < 32; i++) {
8225                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8226                 }
8227
8228                 /*
8229                  * DMA registers
8230                  */
8231                 ISP_WRITE(isp, BIU2100_CSR, 0x50);
8232                 for (i = 0; i < 48; i++) {
8233                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8234                 }
8235
8236                 /*
8237                  * RISC hardware registers
8238                  */
8239                 ISP_WRITE(isp, BIU2100_CSR, 0);
8240                 for (i = 0; i < 16; i++) {
8241                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
8242                 }
8243
8244                 /*
8245                  * RISC GP? registers
8246                  */
8247                 for (j = 0; j < 8; j++) {
8248                         ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
8249                         for (i = 0; i < 16; i++) {
8250                                 *ptr++ =
8251                                     ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8252                         }
8253                 }
8254
8255                 /*
8256                  * frame buffer hardware registers
8257                  */
8258                 ISP_WRITE(isp, BIU2100_CSR, 0x10);
8259                 for (i = 0; i < 64; i++) {
8260                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8261                 }
8262
8263                 /*
8264                  * FPM B0 hardware registers
8265                  */
8266                 ISP_WRITE(isp, BIU2100_CSR, 0x20);
8267                 for (i = 0; i < 64; i++) {
8268                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8269                 }
8270
8271                 /*
8272                  * FPM B1 hardware registers
8273                  */
8274                 ISP_WRITE(isp, BIU2100_CSR, 0x30);
8275                 for (i = 0; i < 64; i++) {
8276                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
8277                 }
8278         } else {
8279                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
8280                 return;
8281         }
8282         isp_prt(isp, ISP_LOGALL,
8283            "isp_fw_dump: RISC registers dumped successfully");
8284         ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
8285         for (i = 0; i < 100; i++) {
8286                 USEC_DELAY(100);
8287                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
8288                         break;
8289                 }
8290         }
8291         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
8292                 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
8293                 return;
8294         }
8295         ISP_ENABLE_INTS(isp);
8296         MEMZERO(&mbs, sizeof (mbs));
8297         mbs.param[0] = MBOX_READ_RAM_WORD;
8298         mbs.param[1] = 0x800;
8299         isp->isp_mbxworkp = (void *) ptr;
8300         isp->isp_mbxwrk0 = 0xf7ff;      /* continuation count */
8301         isp->isp_mbxwrk1 = 0x801;       /* next SRAM address */
8302         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8303         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8304                 isp_prt(isp, ISP_LOGWARN,
8305                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
8306                 return;
8307         }
8308         ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
8309         *ptr++ = isp->isp_mboxtmp[2];
8310         MEMZERO(&mbs, sizeof (mbs));
8311         mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
8312         mbs.param[8] = 1;
8313         isp->isp_mbxworkp = (void *) ptr;
8314         isp->isp_mbxwrk0 = 0xffff;      /* continuation count */
8315         isp->isp_mbxwrk1 = 0x1;         /* next SRAM address */
8316         isp->isp_mbxwrk8 = 0x1;
8317         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
8318         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
8319                 isp_prt(isp, ISP_LOGWARN,
8320                     "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
8321                 return;
8322         }
8323         ptr = isp->isp_mbxworkp;        /* finish final word */
8324         *ptr++ = mbs.param[2];
8325         isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
8326         FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
8327         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
8328 }
8329
8330 void
8331 isp_fw_dump(ispsoftc_t *isp)
8332 {
8333         if (IS_2200(isp))
8334                 isp2200_fw_dump(isp);
8335         else if (IS_23XX(isp))
8336                 isp2300_fw_dump(isp);
8337         else if (IS_24XX(isp))
8338                 isp_prt(isp, ISP_LOGERR, "24XX dump method undefined");
8339
8340 }
8341 #endif