sys/dev/isp/isp.c

   1 /*-
   2  * Machine and OS Independent (well, as best as possible)
   3  * code for the Qlogic ISP SCSI adapters.
   4  *
   5  * Copyright (c) 1997-2006 by Matthew Jacob
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice immediately at the beginning of the file, without modification,
  13  *    this list of conditions, and the following disclaimer.
  14  * 2. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
  32  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
  33  * ideas dredged from the Solaris driver.
  34  */
  35 #ifdef  __FreeBSD__
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38 #endif
  39
  40 /*
  41  * Include header file appropriate for platform we're building on.
  42  */
  43 #ifdef  __NetBSD__
  44 #include <dev/ic/isp_netbsd.h>
  45 #endif
  46 #ifdef  __FreeBSD__
  47 #include <dev/isp/isp_freebsd.h>
  48 #endif
  49 #ifdef  __OpenBSD__
  50 #include <dev/ic/isp_openbsd.h>
  51 #endif
  52 #ifdef  __linux__
  53 #include "isp_linux.h"
  54 #endif
  55 #ifdef  __svr4__
  56 #include "isp_solaris.h"
  57 #endif
  58
  59 /*
  60  * General defines
  61  */
  62
  63 #define MBOX_DELAY_COUNT        1000000 / 100
  64
  65 /*
  66  * Local static data
  67  */
  68 static const char portshift[] =
  69     "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
  70 static const char portdup[] =
  71     "Target %d duplicates Target %d- killing off both";
  72 static const char retained[] =
  73     "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
  74 static const char lretained[] =
  75     "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
  76 static const char plogout[] =
  77     "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
  78 static const char plogierr[] =
  79     "Command Error in PLOGI for Port 0x%x (0x%x)";
  80 static const char nopdb[] =
  81     "Could not get PDB for Device @ Port 0x%x";
  82 static const char pdbmfail1[] =
  83     "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
  84 static const char pdbmfail2[] =
  85     "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
  86 static const char ldumped[] =
  87     "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
  88 static const char notresp[] =
  89   "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
  90 static const char xact1[] =
  91     "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
  92 static const char xact2[] =
  93     "HBA attempted queued transaction to target routine %d on target %d bus %d";
  94 static const char xact3[] =
  95     "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
  96 static const char pskip[] =
  97     "SCSI phase skipped for target %d.%d.%d";
  98 static const char topology[] =
  99     "Loop ID %d, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
 100 static const char swrej[] =
 101     "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x";
 102 static const char finmsg[] =
 103     "(%d.%d.%d): FIN dl%d resid %d STS 0x%x SKEY %c XS_ERR=0x%x";
 104 static const char sc0[] =
 105     "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
 106 static const char sc1[] =
 107     "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
 108 static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
 109 static const char sc3[] = "Generated";
 110 static const char sc4[] = "NVRAM";
 111 static const char bun[] =
 112     "bad underrun for %d.%d (count %d, resid %d, status %s)";
 113
 114 /*
 115  * Local function prototypes.
 116  */
 117 static int isp_parse_async(ispsoftc_t *, uint16_t);
 118 static int isp_handle_other_response(ispsoftc_t *, int, isphdr_t *,
 119     uint16_t *);
 120 static void
 121 isp_parse_status(ispsoftc_t *, ispstatusreq_t *, XS_T *);
 122 static void isp_fastpost_complete(ispsoftc_t *, uint16_t);
 123 static int isp_mbox_continue(ispsoftc_t *);
 124 static void isp_scsi_init(ispsoftc_t *);
 125 static void isp_scsi_channel_init(ispsoftc_t *, int);
 126 static void isp_fibre_init(ispsoftc_t *);
 127 static void isp_mark_getpdb_all(ispsoftc_t *);
 128 static int isp_getmap(ispsoftc_t *, fcpos_map_t *);
 129 static int isp_getpdb(ispsoftc_t *, int, isp_pdb_t *);
 130 static uint64_t isp_get_portname(ispsoftc_t *, int, int);
 131 static int isp_fclink_test(ispsoftc_t *, int);
 132 static char *isp2100_fw_statename(int);
 133 static int isp_pdb_sync(ispsoftc_t *);
 134 static int isp_scan_loop(ispsoftc_t *);
 135 static int isp_fabric_mbox_cmd(ispsoftc_t *, mbreg_t *);
 136 static int isp_scan_fabric(ispsoftc_t *, int);
 137 static void isp_register_fc4_type(ispsoftc_t *);
 138 static void isp_fw_state(ispsoftc_t *);
 139 static void isp_mboxcmd_qnw(ispsoftc_t *, mbreg_t *, int);
 140 static void isp_mboxcmd(ispsoftc_t *, mbreg_t *, int);
 141
 142 static void isp_update(ispsoftc_t *);
 143 static void isp_update_bus(ispsoftc_t *, int);
 144 static void isp_setdfltparm(ispsoftc_t *, int);
 145 static int isp_read_nvram(ispsoftc_t *);
 146 static void isp_rdnvram_word(ispsoftc_t *, int, uint16_t *);
 147 static void isp_parse_nvram_1020(ispsoftc_t *, uint8_t *);
 148 static void isp_parse_nvram_1080(ispsoftc_t *, int, uint8_t *);
 149 static void isp_parse_nvram_12160(ispsoftc_t *, int, uint8_t *);
 150 static void isp_parse_nvram_2100(ispsoftc_t *, uint8_t *);
 151
 152 /*
 153  * Reset Hardware.
 154  *
 155  * Hit the chip over the head, download new f/w if available and set it running.
 156  *
 157  * Locking done elsewhere.
 158  */
 159
 160 void
 161 isp_reset(ispsoftc_t *isp)
 162 {
 163         mbreg_t mbs;
 164         uint16_t code_org;
 165         int loops, i, dodnld = 1;
 166         char *btype = "????";
 167
 168         isp->isp_state = ISP_NILSTATE;
 169         MEMZERO(&mbs, sizeof (mbs));
 170
 171         /*
 172          * Basic types (SCSI, FibreChannel and PCI or SBus)
 173          * have been set in the MD code. We figure out more
 174          * here. Possibly more refined types based upon PCI
 175          * identification. Chip revision has been gathered.
 176          *
 177          * After we've fired this chip up, zero out the conf1 register
 178          * for SCSI adapters and do other settings for the 2100.
 179          */
 180
 181         /*
 182          * Get the current running firmware revision out of the
 183          * chip before we hit it over the head (if this is our
 184          * first time through). Note that we store this as the
 185          * 'ROM' firmware revision- which it may not be. In any
 186          * case, we don't really use this yet, but we may in
 187          * the future.
 188          */
 189         if (isp->isp_touched == 0) {
 190                 /*
 191                  * First see whether or not we're sitting in the ISP PROM.
 192                  * If we've just been reset, we'll have the string "ISP   "
 193                  * spread through outgoing mailbox registers 1-3. We do
 194                  * this for PCI cards because otherwise we really don't
 195                  * know what state the card is in and we could hang if
 196                  * we try this command otherwise.
 197                  *
 198                  * For SBus cards, we just do this because they almost
 199                  * certainly will be running firmware by now.
 200                  */
 201                 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
 202                     ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
 203                     ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
 204                         /*
 205                          * Just in case it was paused...
 206                          */
 207                         ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 208                         mbs.param[0] = MBOX_ABOUT_FIRMWARE;
 209                         isp_mboxcmd(isp, &mbs, MBLOGNONE);
 210                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 211                                 isp->isp_romfw_rev[0] = mbs.param[1];
 212                                 isp->isp_romfw_rev[1] = mbs.param[2];
 213                                 isp->isp_romfw_rev[2] = mbs.param[3];
 214                         }
 215                 }
 216                 isp->isp_touched = 1;
 217         }
 218
 219         DISABLE_INTS(isp);
 220
 221         /*
 222          * Set up default request/response queue in-pointer/out-pointer
 223          * register indices.
 224          */
 225         if (IS_23XX(isp)) {
 226                 isp->isp_rqstinrp = BIU_REQINP;
 227                 isp->isp_rqstoutrp = BIU_REQOUTP;
 228                 isp->isp_respinrp = BIU_RSPINP;
 229                 isp->isp_respoutrp = BIU_RSPOUTP;
 230         } else {
 231                 isp->isp_rqstinrp = INMAILBOX4;
 232                 isp->isp_rqstoutrp = OUTMAILBOX4;
 233                 isp->isp_respinrp = OUTMAILBOX5;
 234                 isp->isp_respoutrp = INMAILBOX5;
 235         }
 236
 237         /*
 238          * Put the board into PAUSE mode (so we can read the SXP registers
 239          * or write FPM/FBM registers).
 240          */
 241         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 242
 243         if (IS_FC(isp)) {
 244                 switch (isp->isp_type) {
 245                 case ISP_HA_FC_2100:
 246                         btype = "2100";
 247                         break;
 248                 case ISP_HA_FC_2200:
 249                         btype = "2200";
 250                         break;
 251                 case ISP_HA_FC_2300:
 252                         btype = "2300";
 253                         break;
 254                 case ISP_HA_FC_2312:
 255                         btype = "2312";
 256                         break;
 257                 case ISP_HA_FC_2322:
 258                         btype = "2322";
 259                         break;
 260                 case ISP_HA_FC_2422:
 261                         btype = "2422";
 262                         break;
 263                 default:
 264                         break;
 265                 }
 266                 /*
 267                  * While we're paused, reset the FPM module and FBM fifos.
 268                  */
 269                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
 270                 ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
 271                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
 272                 ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
 273                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
 274         } else if (IS_1240(isp)) {
 275                 sdparam *sdp = isp->isp_param;
 276                 btype = "1240";
 277                 isp->isp_clock = 60;
 278                 sdp->isp_ultramode = 1;
 279                 sdp++;
 280                 sdp->isp_ultramode = 1;
 281                 /*
 282                  * XXX: Should probably do some bus sensing.
 283                  */
 284         } else if (IS_ULTRA2(isp)) {
 285                 static const char m[] = "bus %d is in %s Mode";
 286                 uint16_t l;
 287                 sdparam *sdp = isp->isp_param;
 288
 289                 isp->isp_clock = 100;
 290
 291                 if (IS_1280(isp))
 292                         btype = "1280";
 293                 else if (IS_1080(isp))
 294                         btype = "1080";
 295                 else if (IS_10160(isp))
 296                         btype = "10160";
 297                 else if (IS_12160(isp))
 298                         btype = "12160";
 299                 else
 300                         btype = "<UNKLVD>";
 301
 302                 l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
 303                 switch (l) {
 304                 case ISP1080_LVD_MODE:
 305                         sdp->isp_lvdmode = 1;
 306                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
 307                         break;
 308                 case ISP1080_HVD_MODE:
 309                         sdp->isp_diffmode = 1;
 310                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
 311                         break;
 312                 case ISP1080_SE_MODE:
 313                         sdp->isp_ultramode = 1;
 314                         isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
 315                         break;
 316                 default:
 317                         isp_prt(isp, ISP_LOGERR,
 318                             "unknown mode on bus %d (0x%x)", 0, l);
 319                         break;
 320                 }
 321
 322                 if (IS_DUALBUS(isp)) {
 323                         sdp++;
 324                         l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
 325                         l &= ISP1080_MODE_MASK;
 326                         switch(l) {
 327                         case ISP1080_LVD_MODE:
 328                                 sdp->isp_lvdmode = 1;
 329                                 isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
 330                                 break;
 331                         case ISP1080_HVD_MODE:
 332                                 sdp->isp_diffmode = 1;
 333                                 isp_prt(isp, ISP_LOGCONFIG,
 334                                     m, 1, "Differential");
 335                                 break;
 336                         case ISP1080_SE_MODE:
 337                                 sdp->isp_ultramode = 1;
 338                                 isp_prt(isp, ISP_LOGCONFIG,
 339                                     m, 1, "Single-Ended");
 340                                 break;
 341                         default:
 342                                 isp_prt(isp, ISP_LOGERR,
 343                                     "unknown mode on bus %d (0x%x)", 1, l);
 344                                 break;
 345                         }
 346                 }
 347         } else {
 348                 sdparam *sdp = isp->isp_param;
 349                 i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
 350                 switch (i) {
 351                 default:
 352                         isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
 353                         /* FALLTHROUGH */
 354                 case 1:
 355                         btype = "1020";
 356                         isp->isp_type = ISP_HA_SCSI_1020;
 357                         isp->isp_clock = 40;
 358                         break;
 359                 case 2:
 360                         /*
 361                          * Some 1020A chips are Ultra Capable, but don't
 362                          * run the clock rate up for that unless told to
 363                          * do so by the Ultra Capable bits being set.
 364                          */
 365                         btype = "1020A";
 366                         isp->isp_type = ISP_HA_SCSI_1020A;
 367                         isp->isp_clock = 40;
 368                         break;
 369                 case 3:
 370                         btype = "1040";
 371                         isp->isp_type = ISP_HA_SCSI_1040;
 372                         isp->isp_clock = 60;
 373                         break;
 374                 case 4:
 375                         btype = "1040A";
 376                         isp->isp_type = ISP_HA_SCSI_1040A;
 377                         isp->isp_clock = 60;
 378                         break;
 379                 case 5:
 380                         btype = "1040B";
 381                         isp->isp_type = ISP_HA_SCSI_1040B;
 382                         isp->isp_clock = 60;
 383                         break;
 384                 case 6:
 385                         btype = "1040C";
 386                         isp->isp_type = ISP_HA_SCSI_1040C;
 387                         isp->isp_clock = 60;
 388                         break;
 389                 }
 390                 /*
 391                  * Now, while we're at it, gather info about ultra
 392                  * and/or differential mode.
 393                  */
 394                 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
 395                         isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
 396                         sdp->isp_diffmode = 1;
 397                 } else {
 398                         sdp->isp_diffmode = 0;
 399                 }
 400                 i = ISP_READ(isp, RISC_PSR);
 401                 if (isp->isp_bustype == ISP_BT_SBUS) {
 402                         i &= RISC_PSR_SBUS_ULTRA;
 403                 } else {
 404                         i &= RISC_PSR_PCI_ULTRA;
 405                 }
 406                 if (i != 0) {
 407                         isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
 408                         sdp->isp_ultramode = 1;
 409                         /*
 410                          * If we're in Ultra Mode, we have to be 60MHz clock-
 411                          * even for the SBus version.
 412                          */
 413                         isp->isp_clock = 60;
 414                 } else {
 415                         sdp->isp_ultramode = 0;
 416                         /*
 417                          * Clock is known. Gronk.
 418                          */
 419                 }
 420
 421                 /*
 422                  * Machine dependent clock (if set) overrides
 423                  * our generic determinations.
 424                  */
 425                 if (isp->isp_mdvec->dv_clock) {
 426                         if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
 427                                 isp->isp_clock = isp->isp_mdvec->dv_clock;
 428                         }
 429                 }
 430
 431         }
 432
 433         /*
 434          * Clear instrumentation
 435          */
 436         isp->isp_intcnt = isp->isp_intbogus = 0;
 437
 438         /*
 439          * Do MD specific pre initialization
 440          */
 441         ISP_RESET0(isp);
 442
 443 again:
 444
 445         /*
 446          * Hit the chip over the head with hammer,
 447          * and give the ISP a chance to recover.
 448          */
 449
 450         if (IS_SCSI(isp)) {
 451                 ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
 452                 /*
 453                  * A slight delay...
 454                  */
 455                 USEC_DELAY(100);
 456
 457                 /*
 458                  * Clear data && control DMA engines.
 459                  */
 460                 ISP_WRITE(isp, CDMA_CONTROL,
 461                     DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 462                 ISP_WRITE(isp, DDMA_CONTROL,
 463                     DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
 464
 465
 466         } else {
 467                 ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 468                 /*
 469                  * A slight delay...
 470                  */
 471                 USEC_DELAY(100);
 472
 473                 /*
 474                  * Clear data && control DMA engines.
 475                  */
 476                 ISP_WRITE(isp, CDMA2100_CONTROL,
 477                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 478                 ISP_WRITE(isp, TDMA2100_CONTROL,
 479                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 480                 ISP_WRITE(isp, RDMA2100_CONTROL,
 481                         DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
 482         }
 483
 484         /*
 485          * Wait for ISP to be ready to go...
 486          */
 487         loops = MBOX_DELAY_COUNT;
 488         for (;;) {
 489                 if (IS_SCSI(isp)) {
 490                         if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
 491                                 break;
 492                 } else {
 493                         if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
 494                                 break;
 495                 }
 496                 USEC_DELAY(100);
 497                 if (--loops < 0) {
 498                         ISP_DUMPREGS(isp, "chip reset timed out");
 499                         return;
 500                 }
 501         }
 502
 503         /*
 504          * After we've fired this chip up, zero out the conf1 register
 505          * for SCSI adapters and other settings for the 2100.
 506          */
 507
 508         if (IS_SCSI(isp)) {
 509                 ISP_WRITE(isp, BIU_CONF1, 0);
 510         } else {
 511                 ISP_WRITE(isp, BIU2100_CSR, 0);
 512         }
 513
 514         /*
 515          * Reset RISC Processor
 516          */
 517         ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
 518         USEC_DELAY(100);
 519         /* Clear semaphore register (just to be sure) */
 520         ISP_WRITE(isp, BIU_SEMA, 0);
 521
 522         /*
 523          * Establish some initial burst rate stuff.
 524          * (only for the 1XX0 boards). This really should
 525          * be done later after fetching from NVRAM.
 526          */
 527         if (IS_SCSI(isp)) {
 528                 uint16_t tmp = isp->isp_mdvec->dv_conf1;
 529                 /*
 530                  * Busted FIFO. Turn off all but burst enables.
 531                  */
 532                 if (isp->isp_type == ISP_HA_SCSI_1040A) {
 533                         tmp &= BIU_BURST_ENABLE;
 534                 }
 535                 ISP_SETBITS(isp, BIU_CONF1, tmp);
 536                 if (tmp & BIU_BURST_ENABLE) {
 537                         ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
 538                         ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
 539                 }
 540 #ifdef  PTI_CARDS
 541                 if (((sdparam *) isp->isp_param)->isp_ultramode) {
 542                         while (ISP_READ(isp, RISC_MTR) != 0x1313) {
 543                                 ISP_WRITE(isp, RISC_MTR, 0x1313);
 544                                 ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
 545                         }
 546                 } else {
 547                         ISP_WRITE(isp, RISC_MTR, 0x1212);
 548                 }
 549                 /*
 550                  * PTI specific register
 551                  */
 552                 ISP_WRITE(isp, RISC_EMB, DUAL_BANK)
 553 #else
 554                 ISP_WRITE(isp, RISC_MTR, 0x1212);
 555 #endif
 556         } else {
 557                 ISP_WRITE(isp, RISC_MTR2100, 0x1212);
 558                 if (IS_2200(isp) || IS_23XX(isp)) {
 559                         ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
 560                 }
 561         }
 562
 563         ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
 564
 565         /*
 566          * Do MD specific post initialization
 567          */
 568         ISP_RESET1(isp);
 569
 570         /*
 571          * Wait for everything to finish firing up.
 572          *
 573          * Avoid doing this on the 2312 because you can generate a PCI
 574          * parity error (chip breakage).
 575          */
 576         if (IS_23XX(isp)) {
 577                 USEC_DELAY(5);
 578         } else {
 579                 loops = MBOX_DELAY_COUNT;
 580                 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
 581                         USEC_DELAY(100);
 582                         if (--loops < 0) {
 583                                 isp_prt(isp, ISP_LOGERR,
 584                                     "MBOX_BUSY never cleared on reset");
 585                                 return;
 586                         }
 587                 }
 588         }
 589
 590         /*
 591          * Up until this point we've done everything by just reading or
 592          * setting registers. From this point on we rely on at least *some*
 593          * kind of firmware running in the card.
 594          */
 595
 596         /*
 597          * Do some sanity checking.
 598          */
 599         mbs.param[0] = MBOX_NO_OP;
 600         isp_mboxcmd(isp, &mbs, MBLOGALL);
 601         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 602                 return;
 603         }
 604
 605         if (IS_SCSI(isp)) {
 606                 mbs.param[0] = MBOX_MAILBOX_REG_TEST;
 607                 mbs.param[1] = 0xdead;
 608                 mbs.param[2] = 0xbeef;
 609                 mbs.param[3] = 0xffff;
 610                 mbs.param[4] = 0x1111;
 611                 mbs.param[5] = 0xa5a5;
 612                 isp_mboxcmd(isp, &mbs, MBLOGALL);
 613                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 614                         return;
 615                 }
 616                 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
 617                     mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
 618                     mbs.param[5] != 0xa5a5) {
 619                         isp_prt(isp, ISP_LOGERR,
 620                             "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
 621                             mbs.param[1], mbs.param[2], mbs.param[3],
 622                             mbs.param[4], mbs.param[5]);
 623                         return;
 624                 }
 625
 626         }
 627
 628         /*
 629          * Download new Firmware, unless requested not to do so.
 630          * This is made slightly trickier in some cases where the
 631          * firmware of the ROM revision is newer than the revision
 632          * compiled into the driver. So, where we used to compare
 633          * versions of our f/w and the ROM f/w, now we just see
 634          * whether we have f/w at all and whether a config flag
 635          * has disabled our download.
 636          */
 637         if ((isp->isp_mdvec->dv_ispfw == NULL) ||
 638             (isp->isp_confopts & ISP_CFG_NORELOAD)) {
 639                 dodnld = 0;
 640         }
 641
 642         if (IS_23XX(isp))
 643                 code_org = ISP_CODE_ORG_2300;
 644         else
 645                 code_org = ISP_CODE_ORG;
 646
 647         if (dodnld) {
 648                 isp->isp_mbxworkp = (void *) &isp->isp_mdvec->dv_ispfw[1];
 649                 isp->isp_mbxwrk0 = isp->isp_mdvec->dv_ispfw[3] - 1;
 650                 isp->isp_mbxwrk1 = code_org + 1;
 651                 mbs.param[0] = MBOX_WRITE_RAM_WORD;
 652                 mbs.param[1] = code_org;
 653                 mbs.param[2] = isp->isp_mdvec->dv_ispfw[0];
 654                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
 655                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 656                         isp_prt(isp, ISP_LOGERR,
 657                             "F/W download failed at word %d",
 658                             isp->isp_mbxwrk1 - code_org);
 659                         dodnld = 0;
 660                         goto again;
 661                 }
 662                 /*
 663                  * Verify that it downloaded correctly.
 664                  */
 665                 mbs.param[0] = MBOX_VERIFY_CHECKSUM;
 666                 mbs.param[1] = code_org;
 667                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
 668                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 669                         isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
 670                         return;
 671                 }
 672                 isp->isp_loaded_fw = 1;
 673         } else {
 674                 isp->isp_loaded_fw = 0;
 675                 isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
 676         }
 677
 678         /*
 679          * Now start it rolling.
 680          *
 681          * If we didn't actually download f/w,
 682          * we still need to (re)start it.
 683          */
 684
 685
 686         mbs.param[0] = MBOX_EXEC_FIRMWARE;
 687         mbs.param[1] = code_org;
 688         if (IS_2322(isp) || IS_24XX(isp)) {
 689                 if (isp->isp_loaded_fw) {
 690                         mbs.param[2] = 1;
 691                 } else {
 692                         mbs.param[2] = 0;
 693                 }
 694                 mbs.obits |= 2;
 695         }
 696
 697         isp_mboxcmd(isp, &mbs, MBLOGNONE);
 698         /*
 699          * Give it a chance to start.
 700          */
 701         USEC_DELAY(500);
 702
 703         if (IS_SCSI(isp)) {
 704                 /*
 705                  * Set CLOCK RATE, but only if asked to.
 706                  */
 707                 if (isp->isp_clock) {
 708                         mbs.param[0] = MBOX_SET_CLOCK_RATE;
 709                         mbs.param[1] = isp->isp_clock;
 710                         isp_mboxcmd(isp, &mbs, MBLOGALL);
 711                         /* we will try not to care if this fails */
 712                 }
 713         }
 714
 715         mbs.param[0] = MBOX_ABOUT_FIRMWARE;
 716         isp_mboxcmd(isp, &mbs, MBLOGALL);
 717         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 718                 return;
 719         }
 720
 721         /*
 722          * The SBus firmware that we are using apparently does not return
 723          * major, minor, micro revisions in the mailbox registers, which
 724          * is really, really, annoying.
 725          */
 726         if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
 727                 if (dodnld) {
 728 #ifdef  ISP_TARGET_MODE
 729                         isp->isp_fwrev[0] = 7;
 730                         isp->isp_fwrev[1] = 55;
 731 #else
 732                         isp->isp_fwrev[0] = 1;
 733                         isp->isp_fwrev[1] = 37;
 734 #endif
 735                         isp->isp_fwrev[2] = 0;
 736                 }
 737         } else {
 738                 isp->isp_fwrev[0] = mbs.param[1];
 739                 isp->isp_fwrev[1] = mbs.param[2];
 740                 isp->isp_fwrev[2] = mbs.param[3];
 741         }
 742         isp_prt(isp, ISP_LOGCONFIG,
 743             "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
 744             btype, isp->isp_revision, dodnld? "loaded" : "resident",
 745             isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
 746
 747         if (IS_FC(isp)) {
 748                 /*
 749                  * We do not believe firmware attributes for 2100 code less
 750                  * than 1.17.0, unless it's the firmware we specifically
 751                  * are loading.
 752                  *
 753                  * Note that all 22XX and 23XX f/w is greater than 1.X.0.
 754                  */
 755                 if (!(ISP_FW_NEWER_THAN(isp, 1, 17, 0))) {
 756 #ifdef  USE_SMALLER_2100_FIRMWARE
 757                         FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
 758 #else
 759                         FCPARAM(isp)->isp_fwattr = 0;
 760 #endif
 761                 } else {
 762                         FCPARAM(isp)->isp_fwattr = mbs.param[6];
 763                         isp_prt(isp, ISP_LOGDEBUG0,
 764                             "Firmware Attributes = 0x%x", mbs.param[6]);
 765                 }
 766                 if (IS_2KLOGIN(isp)) {
 767                         isp_prt(isp, ISP_LOGCONFIG, "2K Logins Supported");
 768                 }
 769         }
 770
 771         if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
 772             isp->isp_romfw_rev[2]) {
 773                 isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
 774                     isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
 775                     isp->isp_romfw_rev[2]);
 776         }
 777
 778         mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
 779         isp_mboxcmd(isp, &mbs, MBLOGALL);
 780         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 781                 return;
 782         }
 783         isp->isp_maxcmds = mbs.param[2];
 784         isp_prt(isp, ISP_LOGINFO,
 785             "%d max I/O commands supported", mbs.param[2]);
 786         isp_fw_state(isp);
 787
 788         /*
 789          * Set up DMA for the request and result mailboxes.
 790          */
 791         if (ISP_MBOXDMASETUP(isp) != 0) {
 792                 isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
 793                 return;
 794         }
 795         isp->isp_state = ISP_RESETSTATE;
 796
 797         /*
 798          * Okay- now that we have new firmware running, we now (re)set our
 799          * notion of how many luns we support. This is somewhat tricky because
 800          * if we haven't loaded firmware, we sometimes do not have an easy way
 801          * of knowing how many luns we support.
 802          *
 803          * Expanded lun firmware gives you 32 luns for SCSI cards and
 804          * 16384 luns for Fibre Channel cards.
 805          *
 806          * It turns out that even for QLogic 2100s with ROM 1.10 and above
 807          * we do get a firmware attributes word returned in mailbox register 6.
 808          *
 809          * Because the lun is in a different position in the Request Queue
 810          * Entry structure for Fibre Channel with expanded lun firmware, we
 811          * can only support one lun (lun zero) when we don't know what kind
 812          * of firmware we're running.
 813          */
 814         if (IS_SCSI(isp)) {
 815                 if (dodnld) {
 816                         if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
 817                                 isp->isp_maxluns = 32;
 818                         } else {
 819                                 isp->isp_maxluns = 8;
 820                         }
 821                 } else {
 822                         isp->isp_maxluns = 8;
 823                 }
 824         } else {
 825                 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
 826                         isp->isp_maxluns = 16384;
 827                 } else {
 828                         isp->isp_maxluns = 16;
 829                 }
 830         }
 831 }
 832
 833 /*
 834  * Initialize Parameters of Hardware to a known state.
 835  *
 836  * Locks are held before coming here.
 837  */
 838
 839 void
 840 isp_init(ispsoftc_t *isp)
 841 {
 842         /*
 843          * Must do this first to get defaults established.
 844          */
 845         isp_setdfltparm(isp, 0);
 846         if (IS_DUALBUS(isp)) {
 847                 isp_setdfltparm(isp, 1);
 848         }
 849         if (IS_FC(isp)) {
 850                 isp_fibre_init(isp);
 851         } else {
 852                 isp_scsi_init(isp);
 853         }
 854 }
 855
 856 static void
 857 isp_scsi_init(ispsoftc_t *isp)
 858 {
 859         sdparam *sdp_chan0, *sdp_chan1;
 860         mbreg_t mbs;
 861
 862         sdp_chan0 = isp->isp_param;
 863         sdp_chan1 = sdp_chan0;
 864         if (IS_DUALBUS(isp)) {
 865                 sdp_chan1++;
 866         }
 867
 868         /*
 869          * If we have no role (neither target nor initiator), return.
 870          */
 871         if (isp->isp_role == ISP_ROLE_NONE) {
 872                 return;
 873         }
 874
 875         /* First do overall per-card settings. */
 876
 877         /*
 878          * If we have fast memory timing enabled, turn it on.
 879          */
 880         if (sdp_chan0->isp_fast_mttr) {
 881                 ISP_WRITE(isp, RISC_MTR, 0x1313);
 882         }
 883
 884         /*
 885          * Set Retry Delay and Count.
 886          * You set both channels at the same time.
 887          */
 888         MEMZERO(&mbs, sizeof (mbs));
 889         mbs.param[0] = MBOX_SET_RETRY_COUNT;
 890         mbs.param[1] = sdp_chan0->isp_retry_count;
 891         mbs.param[2] = sdp_chan0->isp_retry_delay;
 892         mbs.param[6] = sdp_chan1->isp_retry_count;
 893         mbs.param[7] = sdp_chan1->isp_retry_delay;
 894
 895         isp_mboxcmd(isp, &mbs, MBLOGALL);
 896         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 897                 return;
 898         }
 899
 900         /*
 901          * Set ASYNC DATA SETUP time. This is very important.
 902          */
 903         mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
 904         mbs.param[1] = sdp_chan0->isp_async_data_setup;
 905         mbs.param[2] = sdp_chan1->isp_async_data_setup;
 906         isp_mboxcmd(isp, &mbs, MBLOGALL);
 907         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 908                 return;
 909         }
 910
 911         /*
 912          * Set ACTIVE Negation State.
 913          */
 914         mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
 915         mbs.param[1] =
 916             (sdp_chan0->isp_req_ack_active_neg << 4) |
 917             (sdp_chan0->isp_data_line_active_neg << 5);
 918         mbs.param[2] =
 919             (sdp_chan1->isp_req_ack_active_neg << 4) |
 920             (sdp_chan1->isp_data_line_active_neg << 5);
 921
 922         isp_mboxcmd(isp, &mbs, MBLOGNONE);
 923         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 924                 isp_prt(isp, ISP_LOGERR,
 925                     "failed to set active negation state (%d,%d), (%d,%d)",
 926                     sdp_chan0->isp_req_ack_active_neg,
 927                     sdp_chan0->isp_data_line_active_neg,
 928                     sdp_chan1->isp_req_ack_active_neg,
 929                     sdp_chan1->isp_data_line_active_neg);
 930                 /*
 931                  * But don't return.
 932                  */
 933         }
 934
 935         /*
 936          * Set the Tag Aging limit
 937          */
 938         mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
 939         mbs.param[1] = sdp_chan0->isp_tag_aging;
 940         mbs.param[2] = sdp_chan1->isp_tag_aging;
 941         isp_mboxcmd(isp, &mbs, MBLOGALL);
 942         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 943                 isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
 944                     sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
 945                 return;
 946         }
 947
 948         /*
 949          * Set selection timeout.
 950          */
 951         mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
 952         mbs.param[1] = sdp_chan0->isp_selection_timeout;
 953         mbs.param[2] = sdp_chan1->isp_selection_timeout;
 954         isp_mboxcmd(isp, &mbs, MBLOGALL);
 955         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 956                 return;
 957         }
 958
 959         /* now do per-channel settings */
 960         isp_scsi_channel_init(isp, 0);
 961         if (IS_DUALBUS(isp))
 962                 isp_scsi_channel_init(isp, 1);
 963
 964         /*
 965          * Now enable request/response queues
 966          */
 967
 968         if (IS_ULTRA2(isp) || IS_1240(isp)) {
 969                 mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
 970                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
 971                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
 972                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
 973                 mbs.param[4] = 0;
 974                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
 975                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
 976                 isp_mboxcmd(isp, &mbs, MBLOGALL);
 977                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 978                         return;
 979                 }
 980                 isp->isp_residx = mbs.param[5];
 981
 982                 mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
 983                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
 984                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
 985                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
 986                 mbs.param[5] = 0;
 987                 mbs.param[6] = DMA_WD3(isp->isp_result_dma);
 988                 mbs.param[7] = DMA_WD2(isp->isp_result_dma);
 989                 isp_mboxcmd(isp, &mbs, MBLOGALL);
 990                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 991                         return;
 992                 }
 993                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
 994         } else {
 995                 mbs.param[0] = MBOX_INIT_RES_QUEUE;
 996                 mbs.param[1] = RESULT_QUEUE_LEN(isp);
 997                 mbs.param[2] = DMA_WD1(isp->isp_result_dma);
 998                 mbs.param[3] = DMA_WD0(isp->isp_result_dma);
 999                 mbs.param[4] = 0;
1000                 isp_mboxcmd(isp, &mbs, MBLOGALL);
1001                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1002                         return;
1003                 }
1004                 isp->isp_residx = mbs.param[5];
1005
1006                 mbs.param[0] = MBOX_INIT_REQ_QUEUE;
1007                 mbs.param[1] = RQUEST_QUEUE_LEN(isp);
1008                 mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
1009                 mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
1010                 mbs.param[5] = 0;
1011                 isp_mboxcmd(isp, &mbs, MBLOGALL);
1012                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1013                         return;
1014                 }
1015                 isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
1016         }
1017
1018         /*
1019          * Turn on Fast Posting, LVD transitions
1020          *
1021          * Ultra2 F/W always has had fast posting (and LVD transitions)
1022          *
1023          * Ultra and older (i.e., SBus) cards may not. It's just safer
1024          * to assume not for them.
1025          */
1026
1027         mbs.param[0] = MBOX_SET_FW_FEATURES;
1028         mbs.param[1] = 0;
1029         if (IS_ULTRA2(isp))
1030                 mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
1031 #ifndef ISP_NO_RIO
1032         if (IS_ULTRA2(isp) || IS_1240(isp))
1033                 mbs.param[1] |= FW_FEATURE_RIO_16BIT;
1034 #else
1035 #ifndef ISP_NO_FASTPOST
1036         if (IS_ULTRA2(isp) || IS_1240(isp))
1037                 mbs.param[1] |= FW_FEATURE_FAST_POST;
1038 #endif
1039 #endif
1040         if (mbs.param[1] != 0) {
1041                 uint16_t sfeat = mbs.param[1];
1042                 isp_mboxcmd(isp, &mbs, MBLOGALL);
1043                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1044                         isp_prt(isp, ISP_LOGINFO,
1045                             "Enabled FW features (0x%x)", sfeat);
1046                 }
1047         }
1048
1049         /*
1050          * Let the outer layers decide whether to issue a SCSI bus reset.
1051          */
1052         isp->isp_state = ISP_INITSTATE;
1053 }
1054
1055 static void
1056 isp_scsi_channel_init(ispsoftc_t *isp, int channel)
1057 {
1058         sdparam *sdp;
1059         mbreg_t mbs;
1060         int tgt;
1061
1062         sdp = isp->isp_param;
1063         sdp += channel;
1064
1065         /*
1066          * Set (possibly new) Initiator ID.
1067          */
1068         MEMZERO(&mbs, sizeof (mbs));
1069         mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
1070         mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
1071         isp_mboxcmd(isp, &mbs, MBLOGALL);
1072         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1073                 return;
1074         }
1075         isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
1076             sdp->isp_initiator_id, channel);
1077
1078
1079         /*
1080          * Set current per-target parameters to an initial safe minimum.
1081          */
1082         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1083                 int lun;
1084                 uint16_t sdf;
1085
1086                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
1087                         continue;
1088                 }
1089 #ifndef ISP_TARGET_MODE
1090                 sdf = sdp->isp_devparam[tgt].goal_flags;
1091                 sdf &= DPARM_SAFE_DFLT;
1092                 /*
1093                  * It is not quite clear when this changed over so that
1094                  * we could force narrow and async for 1000/1020 cards,
1095                  * but assume that this is only the case for loaded
1096                  * firmware.
1097                  */
1098                 if (isp->isp_loaded_fw) {
1099                         sdf |= DPARM_NARROW | DPARM_ASYNC;
1100                 }
1101 #else
1102                 /*
1103                  * The !$*!)$!$)* f/w uses the same index into some
1104                  * internal table to decide how to respond to negotiations,
1105                  * so if we've said "let's be safe" for ID X, and ID X
1106                  * selects *us*, the negotiations will back to 'safe'
1107                  * (as in narrow/async). What the f/w *should* do is
1108                  * use the initiator id settings to decide how to respond.
1109                  */
1110                 sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
1111 #endif
1112                 mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1113                 mbs.param[1] = (channel << 15) | (tgt << 8);
1114                 mbs.param[2] = sdf;
1115                 if ((sdf & DPARM_SYNC) == 0) {
1116                         mbs.param[3] = 0;
1117                 } else {
1118                         mbs.param[3] =
1119                             (sdp->isp_devparam[tgt].goal_offset << 8) |
1120                             (sdp->isp_devparam[tgt].goal_period);
1121                 }
1122                 isp_prt(isp, ISP_LOGDEBUG0,
1123                     "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
1124                     channel, tgt, mbs.param[2], mbs.param[3] >> 8,
1125                     mbs.param[3] & 0xff);
1126                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
1127                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1128                         sdf = DPARM_SAFE_DFLT;
1129                         mbs.param[0] = MBOX_SET_TARGET_PARAMS;
1130                         mbs.param[1] = (tgt << 8) | (channel << 15);
1131                         mbs.param[2] = sdf;
1132                         mbs.param[3] = 0;
1133                         isp_mboxcmd(isp, &mbs, MBLOGALL);
1134                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1135                                 continue;
1136                         }
1137                 }
1138
1139                 /*
1140                  * We don't update any information directly from the f/w
1141                  * because we need to run at least one command to cause a
1142                  * new state to be latched up. So, we just assume that we
1143                  * converge to the values we just had set.
1144                  *
1145                  * Ensure that we don't believe tagged queuing is enabled yet.
1146                  * It turns out that sometimes the ISP just ignores our
1147                  * attempts to set parameters for devices that it hasn't
1148                  * seen yet.
1149                  */
1150                 sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
1151                 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
1152                         mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
1153                         mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
1154                         mbs.param[2] = sdp->isp_max_queue_depth;
1155                         mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
1156                         isp_mboxcmd(isp, &mbs, MBLOGALL);
1157                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1158                                 break;
1159                         }
1160                 }
1161         }
1162         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
1163                 if (sdp->isp_devparam[tgt].dev_refresh) {
1164                         isp->isp_sendmarker |= (1 << channel);
1165                         isp->isp_update |= (1 << channel);
1166                         break;
1167                 }
1168         }
1169 }
1170
1171 /*
1172  * Fibre Channel specific initialization.
1173  *
1174  * Locks are held before coming here.
1175  */
1176 static void
1177 isp_fibre_init(ispsoftc_t *isp)
1178 {
1179         fcparam *fcp;
1180         isp_icb_t local, *icbp = &local;
1181         mbreg_t mbs;
1182         int loopid;
1183         uint64_t nwwn, pwwn;
1184
1185         fcp = isp->isp_param;
1186
1187         /*
1188          * Do this *before* initializing the firmware.
1189          */
1190         isp_mark_getpdb_all(isp);
1191         fcp->isp_fwstate = FW_CONFIG_WAIT;
1192         fcp->isp_loopstate = LOOP_NIL;
1193
1194         /*
1195          * If we have no role (neither target nor initiator), return.
1196          */
1197         if (isp->isp_role == ISP_ROLE_NONE) {
1198                 return;
1199         }
1200
1201         loopid = fcp->isp_loopid;
1202         MEMZERO(icbp, sizeof (*icbp));
1203         icbp->icb_version = ICB_VERSION1;
1204
1205         /*
1206          * Firmware Options are either retrieved from NVRAM or
1207          * are patched elsewhere. We check them for sanity here
1208          * and make changes based on board revision, but otherwise
1209          * let others decide policy.
1210          */
1211
1212         /*
1213          * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
1214          */
1215         if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
1216                 fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
1217         }
1218
1219         /*
1220          * We have to use FULL LOGIN even though it resets the loop too much
1221          * because otherwise port database entries don't get updated after
1222          * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
1223          */
1224         if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1225                 fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
1226         }
1227
1228         /*
1229          * Insist on Port Database Update Async notifications
1230          */
1231         fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
1232
1233         /*
1234          * Make sure that target role reflects into fwoptions.
1235          */
1236         if (isp->isp_role & ISP_ROLE_TARGET) {
1237                 fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
1238         } else {
1239                 fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
1240         }
1241
1242         if (isp->isp_role & ISP_ROLE_INITIATOR) {
1243                 fcp->isp_fwoptions &= ~ICBOPT_INI_DISABLE;
1244         } else {
1245                 fcp->isp_fwoptions |= ICBOPT_INI_DISABLE;
1246         }
1247
1248         /*
1249          * Propagate all of this into the ICB structure.
1250          */
1251         icbp->icb_fwoptions = fcp->isp_fwoptions;
1252         icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
1253         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
1254             icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
1255                 isp_prt(isp, ISP_LOGERR,
1256                     "bad frame length (%d) from NVRAM- using %d",
1257                     fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
1258                 icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
1259         }
1260         icbp->icb_maxalloc = fcp->isp_maxalloc;
1261         if (icbp->icb_maxalloc < 1) {
1262                 isp_prt(isp, ISP_LOGERR,
1263                     "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
1264                 icbp->icb_maxalloc = 16;
1265         }
1266         icbp->icb_execthrottle = fcp->isp_execthrottle;
1267         if (icbp->icb_execthrottle < 1) {
1268                 isp_prt(isp, ISP_LOGERR,
1269                     "bad execution throttle of %d- using 16",
1270                     fcp->isp_execthrottle);
1271                 icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
1272         }
1273         icbp->icb_retry_delay = fcp->isp_retry_delay;
1274         icbp->icb_retry_count = fcp->isp_retry_count;
1275         icbp->icb_hardaddr = loopid;
1276         if (icbp->icb_hardaddr >= 125) {
1277                 /*
1278                  * We end up with these Loop IDs for F-Port topologies
1279                  */
1280                 if (icbp->icb_hardaddr != 0xff && icbp->icb_hardaddr != 0x800) {
1281                     isp_prt(isp, ISP_LOGERR,
1282                         "bad hard address %u- resetting to zero",
1283                         icbp->icb_hardaddr);
1284                 }
1285                 icbp->icb_hardaddr = 0;
1286         }
1287         /*
1288          * Right now we just set extended options to prefer point-to-point
1289          * over loop based upon some soft config options.
1290          *
1291          * NB: for the 2300, ICBOPT_EXTENDED is required.
1292          */
1293         if (IS_2200(isp) || IS_23XX(isp)) {
1294                 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1295                 /*
1296                  * Prefer or force Point-To-Point instead Loop?
1297                  */
1298                 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
1299                 case ISP_CFG_NPORT:
1300                         icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1301                         break;
1302                 case ISP_CFG_NPORT_ONLY:
1303                         icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
1304                         break;
1305                 case ISP_CFG_LPORT_ONLY:
1306                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
1307                         break;
1308                 default:
1309                         icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
1310                         break;
1311                 }
1312                 if (IS_23XX(isp)) {
1313                         /*
1314                          * QLogic recommends that FAST Posting be turned
1315                          * off for 23XX cards and instead allow the HBA
1316                          * to write response queue entries and interrupt
1317                          * after a delay (ZIO).
1318                          *
1319                          * If we set ZIO, it will disable fast posting,
1320                          * so we don't need to clear it in fwoptions.
1321                          *
1322                          * Depending on the role we're selecting, we
1323                          * chose fast posting or not as it still is
1324                          * a win for target mode.
1325                          */
1326 #ifndef ISP_NO_ZIO
1327                         if (isp->isp_role == ISP_ROLE_TARGET) {
1328                                 icbp->icb_fwoptions |= ICBOPT_FAST_POST;
1329                         } else {
1330                                 icbp->icb_xfwoptions |= ICBXOPT_ZIO;
1331                         }
1332 #else
1333                         icbp->icb_fwoptions |= ICBOPT_FAST_POST;
1334 #endif
1335 #if     0
1336                         /*
1337                          * Values, in 100us increments. The default
1338                          * is 2 (200us) if a value 0 (default) is
1339                          * selected.
1340                          */
1341                         icbp->icb_idelaytimer = 2;
1342 #endif
1343
1344                         if (isp->isp_confopts & ISP_CFG_ONEGB) {
1345                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
1346                         } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
1347                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
1348                         } else {
1349                                 icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
1350                         }
1351                 }
1352         }
1353
1354 #ifndef ISP_NO_RIO_FC
1355         /*
1356          * RIO seems to be enabled in 2100s for fw >= 1.17.0.
1357          *
1358          * I've had some questionable problems with RIO on 2200.
1359          * More specifically, on a 2204 I had problems with RIO
1360          * on a Linux system where I was dropping commands right
1361          * and left. It's not clear to me what the actual problem
1362          * was.
1363          *
1364          * 23XX Cards do not support RIO. Instead they support ZIO.
1365          */
1366 #if     0
1367         if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
1368                 icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
1369                 icbp->icb_racctimer = 4;
1370                 icbp->icb_idelaytimer = 8;
1371         }
1372 #endif
1373 #endif
1374
1375         MEMZERO(&mbs, sizeof (mbs));
1376
1377         /*
1378          * For 22XX > 2.1.26 && 23XX, set some options.
1379          * XXX: Probably okay for newer 2100 f/w too.
1380          */
1381         if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1382                 /*
1383                  * Turn on LIP F8 async event (1)
1384                  * Turn on generate AE 8013 on all LIP Resets (2)
1385                  * Disable LIP F7 switching (8)
1386                  */
1387                 mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
1388                 mbs.param[1] = 0xb;
1389                 mbs.param[2] = 0;
1390                 mbs.param[3] = 0;
1391                 isp_mboxcmd(isp, &mbs, MBLOGALL);
1392         }
1393         icbp->icb_logintime = ICB_LOGIN_TOV;
1394         icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1395
1396         if (IS_23XX(isp)) {
1397                 ISP_WRITE(isp, isp->isp_rqstinrp, 0);
1398                 ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
1399                 ISP_WRITE(isp, isp->isp_respinrp, 0);
1400                 ISP_WRITE(isp, isp->isp_respoutrp, 0);
1401         }
1402
1403         nwwn = ISP_NODEWWN(isp);
1404         pwwn = ISP_PORTWWN(isp);
1405         if (nwwn && pwwn) {
1406                 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1407                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
1408                 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
1409                 isp_prt(isp, ISP_LOGDEBUG1,
1410                     "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1411                     ((uint32_t) (nwwn >> 32)),
1412                     ((uint32_t) (nwwn & 0xffffffff)),
1413                     ((uint32_t) (pwwn >> 32)),
1414                     ((uint32_t) (pwwn & 0xffffffff)));
1415         } else {
1416                 isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
1417                 icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN);
1418         }
1419         icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
1420         if (icbp->icb_rqstqlen < 1) {
1421                 isp_prt(isp, ISP_LOGERR, "bad request queue length");
1422         }
1423         icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
1424         if (icbp->icb_rsltqlen < 1) {
1425                 isp_prt(isp, ISP_LOGERR, "bad result queue length");
1426         }
1427         icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
1428         icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
1429         icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
1430         icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
1431         icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
1432         icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
1433         icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
1434         icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
1435         isp_prt(isp, ISP_LOGDEBUG0,
1436             "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
1437             icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
1438
1439         FC_SCRATCH_ACQUIRE(isp);
1440         isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
1441
1442         /*
1443          * Init the firmware
1444          */
1445         mbs.param[0] = MBOX_INIT_FIRMWARE;
1446         mbs.param[1] = 0;
1447         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1448         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1449         mbs.param[4] = 0;
1450         mbs.param[5] = 0;
1451         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1452         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1453         isp_mboxcmd(isp, &mbs, MBLOGALL);
1454         FC_SCRATCH_RELEASE(isp);
1455         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1456                 return;
1457         }
1458         isp->isp_reqidx = isp->isp_reqodx = 0;
1459         isp->isp_residx = 0;
1460         isp->isp_sendmarker = 1;
1461
1462         /*
1463          * Whatever happens, we're now committed to being here.
1464          */
1465         isp->isp_state = ISP_INITSTATE;
1466 }
1467
1468 /*
1469  * Fibre Channel Support- get the port database for the id.
1470  *
1471  * Locks are held before coming here. Return 0 if success,
1472  * else failure.
1473  */
1474
1475 static int
1476 isp_getmap(ispsoftc_t *isp, fcpos_map_t *map)
1477 {
1478         fcparam *fcp = (fcparam *) isp->isp_param;
1479         mbreg_t mbs;
1480
1481         MEMZERO(&mbs, sizeof (mbs));
1482         mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP;
1483         mbs.param[1] = 0;
1484         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1485         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1486         /*
1487          * Unneeded. For the 2100, except for initializing f/w, registers
1488          * 4/5 have to not be written to.
1489          *      mbs.param[4] = 0;
1490          *      mbs.param[5] = 0;
1491          *
1492          */
1493         mbs.param[6] = 0;
1494         mbs.param[7] = 0;
1495         FC_SCRATCH_ACQUIRE(isp);
1496         isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1497         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1498                 MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t));
1499                 map->fwmap = mbs.param[1] != 0;
1500                 FC_SCRATCH_RELEASE(isp);
1501                 return (0);
1502         }
1503         FC_SCRATCH_RELEASE(isp);
1504         return (-1);
1505 }
1506
1507 static void
1508 isp_mark_getpdb_all(ispsoftc_t *isp)
1509 {
1510         fcparam *fcp = (fcparam *) isp->isp_param;
1511         int i;
1512         for (i = 0; i < MAX_FC_TARG; i++) {
1513                 fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0;
1514         }
1515 }
1516
1517 static int
1518 isp_getpdb(ispsoftc_t *isp, int id, isp_pdb_t *pdbp)
1519 {
1520         fcparam *fcp = (fcparam *) isp->isp_param;
1521         mbreg_t mbs;
1522
1523         MEMZERO(&mbs, sizeof (mbs));
1524         mbs.param[0] = MBOX_GET_PORT_DB;
1525         if (IS_2KLOGIN(isp)) {
1526                 mbs.param[1] = id;
1527                 mbs.obits |= (1 << 10);
1528         } else {
1529                 mbs.param[1] = id << 8;
1530         }
1531         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
1532         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
1533         /*
1534          * Unneeded. For the 2100, except for initializing f/w, registers
1535          * 4/5 have to not be written to.
1536          *      mbs.param[4] = 0;
1537          *      mbs.param[5] = 0;
1538          *
1539          */
1540         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
1541         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
1542         FC_SCRATCH_ACQUIRE(isp);
1543         isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1544         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1545                 isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp);
1546                 FC_SCRATCH_RELEASE(isp);
1547                 return (0);
1548         }
1549         FC_SCRATCH_RELEASE(isp);
1550         return (-1);
1551 }
1552
1553 static uint64_t
1554 isp_get_portname(ispsoftc_t *isp, int loopid, int nodename)
1555 {
1556         uint64_t wwn = 0;
1557         mbreg_t mbs;
1558
1559         MEMZERO(&mbs, sizeof (mbs));
1560         mbs.param[0] = MBOX_GET_PORT_NAME;
1561         if (IS_2KLOGIN(isp)) {
1562                 mbs.param[1] = loopid;
1563                 if (nodename)
1564                         mbs.param[10] = 1;
1565                 mbs.obits |= (1 << 10);
1566         } else {
1567                 mbs.param[1] = loopid << 8;
1568                 if (nodename)
1569                         mbs.param[1] |= 1;
1570         }
1571         isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
1572         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1573                 wwn =
1574                     (((uint64_t)(mbs.param[2] & 0xff)) << 56) |
1575                     (((uint64_t)(mbs.param[2] >> 8))    << 48) |
1576                     (((uint64_t)(mbs.param[3] & 0xff))  << 40) |
1577                     (((uint64_t)(mbs.param[3] >> 8))    << 32) |
1578                     (((uint64_t)(mbs.param[6] & 0xff))  << 24) |
1579                     (((uint64_t)(mbs.param[6] >> 8))    << 16) |
1580                     (((uint64_t)(mbs.param[7] & 0xff))  <<  8) |
1581                     (((uint64_t)(mbs.param[7] >> 8)));
1582         }
1583         return (wwn);
1584 }
1585
1586 /*
1587  * Make sure we have good FC link and know our Loop ID.
1588  */
1589
1590 static int
1591 isp_fclink_test(ispsoftc_t *isp, int usdelay)
1592 {
1593         static char *toponames[] = {
1594                 "Private Loop",
1595                 "FL Port",
1596                 "N-Port to N-Port",
1597                 "F Port",
1598                 "F Port (no FLOGI_ACC response)"
1599         };
1600         mbreg_t mbs;
1601         int count, check_for_fabric;
1602         uint8_t lwfs;
1603         fcparam *fcp;
1604         struct lportdb *lp;
1605         isp_pdb_t pdb;
1606
1607         fcp = isp->isp_param;
1608
1609         /*
1610          * XXX: Here is where we would start a 'loop dead' timeout
1611          */
1612
1613         /*
1614          * Wait up to N microseconds for F/W to go to a ready state.
1615          */
1616         lwfs = FW_CONFIG_WAIT;
1617         count = 0;
1618         while (count < usdelay) {
1619                 uint64_t enano;
1620                 uint32_t wrk;
1621                 NANOTIME_T hra, hrb;
1622
1623                 GET_NANOTIME(&hra);
1624                 isp_fw_state(isp);
1625                 if (lwfs != fcp->isp_fwstate) {
1626                         isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
1627                             isp2100_fw_statename((int)lwfs),
1628                             isp2100_fw_statename((int)fcp->isp_fwstate));
1629                         lwfs = fcp->isp_fwstate;
1630                 }
1631                 if (fcp->isp_fwstate == FW_READY) {
1632                         break;
1633                 }
1634                 GET_NANOTIME(&hrb);
1635
1636                 /*
1637                  * Get the elapsed time in nanoseconds.
1638                  * Always guaranteed to be non-zero.
1639                  */
1640                 enano = NANOTIME_SUB(&hrb, &hra);
1641
1642                 isp_prt(isp, ISP_LOGDEBUG1,
1643                     "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
1644                     count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
1645                     (uint32_t)(enano >> 32), (uint32_t)(enano & 0xffffffff));
1646
1647                 /*
1648                  * If the elapsed time is less than 1 millisecond,
1649                  * delay a period of time up to that millisecond of
1650                  * waiting.
1651                  *
1652                  * This peculiar code is an attempt to try and avoid
1653                  * invoking uint64_t math support functions for some
1654                  * platforms where linkage is a problem.
1655                  */
1656                 if (enano < (1000 * 1000)) {
1657                         count += 1000;
1658                         enano = (1000 * 1000) - enano;
1659                         while (enano > (uint64_t) 4000000000U) {
1660                                 USEC_SLEEP(isp, 4000000);
1661                                 enano -= (uint64_t) 4000000000U;
1662                         }
1663                         wrk = enano;
1664                         wrk /= 1000;
1665                         USEC_SLEEP(isp, wrk);
1666                 } else {
1667                         while (enano > (uint64_t) 4000000000U) {
1668                                 count += 4000000;
1669                                 enano -= (uint64_t) 4000000000U;
1670                         }
1671                         wrk = enano;
1672                         count += (wrk / 1000);
1673                 }
1674         }
1675
1676         /*
1677          * If we haven't gone to 'ready' state, return.
1678          */
1679         if (fcp->isp_fwstate != FW_READY) {
1680                 return (-1);
1681         }
1682
1683         /*
1684          * Get our Loop ID (if possible). We really need to have it.
1685          */
1686         MEMZERO(&mbs, sizeof (mbs));
1687         mbs.param[0] = MBOX_GET_LOOP_ID;
1688         isp_mboxcmd(isp, &mbs, MBLOGALL);
1689         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1690                 return (-1);
1691         }
1692         fcp->isp_loopid = mbs.param[1];
1693         if (fcp->isp_loopid == 0xffff) {        /* happens with 2k login f/w */
1694                 fcp->isp_loopid = MAX_FC_TARG-1;
1695         } else if (fcp->isp_loopid >= MAX_FC_TARG) {
1696                 isp_prt(isp, ISP_LOGWARN, "bad initiator loopid (0x%x)", fcp->isp_loopid);
1697                 fcp->isp_loopid = MAX_FC_TARG-1;
1698         }
1699         if (IS_2200(isp) || IS_23XX(isp)) {
1700                 int topo = (int) mbs.param[6];
1701                 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
1702                         topo = TOPO_PTP_STUB;
1703                 fcp->isp_topo = topo;
1704         } else {
1705                 fcp->isp_topo = TOPO_NL_PORT;
1706         }
1707         /*
1708          * Get the port id.
1709          */
1710         fcp->isp_portid = mbs.param[2] | (mbs.param[3] << 16);
1711
1712         /*
1713          * Check to see if we're on a fabric by trying to see if we
1714          * can talk to the fabric name server. This can be a bit
1715          * tricky because if we're a 2100, we should check always
1716          * (in case we're connected to a server doing aliasing).
1717          */
1718         fcp->isp_onfabric = 0;
1719
1720         if (IS_2100(isp)) {
1721                 /*
1722                  * Don't bother with fabric if we are using really old
1723                  * 2100 firmware. It's just not worth it.
1724                  */
1725                 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
1726                         check_for_fabric = 1;
1727                 } else {
1728                         check_for_fabric = 0;
1729                 }
1730         } else if (fcp->isp_topo == TOPO_FL_PORT ||
1731             fcp->isp_topo == TOPO_F_PORT) {
1732                 check_for_fabric = 1;
1733         } else
1734                 check_for_fabric = 0;
1735
1736         if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
1737                 int loopid = FL_PORT_ID;
1738                 if (IS_2100(isp)) {
1739                         fcp->isp_topo = TOPO_FL_PORT;
1740                 }
1741
1742                 if (BITS2WORD(pdb.pdb_portid_bits) == 0) {
1743                         /*
1744                          * Crock.
1745                          */
1746                         fcp->isp_topo = TOPO_NL_PORT;
1747                         goto not_on_fabric;
1748                 }
1749                 fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16);
1750
1751                 /*
1752                  * Save the Fabric controller's port database entry.
1753                  */
1754                 lp = &fcp->portdb[loopid];
1755                 lp->node_wwn =
1756                     (((uint64_t)pdb.pdb_nodename[0]) << 56) |
1757                     (((uint64_t)pdb.pdb_nodename[1]) << 48) |
1758                     (((uint64_t)pdb.pdb_nodename[2]) << 40) |
1759                     (((uint64_t)pdb.pdb_nodename[3]) << 32) |
1760                     (((uint64_t)pdb.pdb_nodename[4]) << 24) |
1761                     (((uint64_t)pdb.pdb_nodename[5]) << 16) |
1762                     (((uint64_t)pdb.pdb_nodename[6]) <<  8) |
1763                     (((uint64_t)pdb.pdb_nodename[7]));
1764                 lp->port_wwn =
1765                     (((uint64_t)pdb.pdb_portname[0]) << 56) |
1766                     (((uint64_t)pdb.pdb_portname[1]) << 48) |
1767                     (((uint64_t)pdb.pdb_portname[2]) << 40) |
1768                     (((uint64_t)pdb.pdb_portname[3]) << 32) |
1769                     (((uint64_t)pdb.pdb_portname[4]) << 24) |
1770                     (((uint64_t)pdb.pdb_portname[5]) << 16) |
1771                     (((uint64_t)pdb.pdb_portname[6]) <<  8) |
1772                     (((uint64_t)pdb.pdb_portname[7]));
1773                 lp->roles =
1774                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
1775                 lp->portid = BITS2WORD(pdb.pdb_portid_bits);
1776                 lp->loopid = pdb.pdb_loopid;
1777                 lp->loggedin = lp->valid = 1;
1778                 fcp->isp_onfabric = 1;
1779                 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1780                 isp_register_fc4_type(isp);
1781         } else {
1782 not_on_fabric:
1783                 fcp->isp_onfabric = 0;
1784                 fcp->portdb[FL_PORT_ID].valid = 0;
1785         }
1786
1787         fcp->isp_gbspeed = 1;
1788         if (IS_23XX(isp)) {
1789                 mbs.param[0] = MBOX_GET_SET_DATA_RATE;
1790                 mbs.param[1] = MBGSD_GET_RATE;
1791                 /* mbs.param[2] undefined if we're just getting rate */
1792                 isp_mboxcmd(isp, &mbs, MBLOGALL);
1793                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
1794                         if (mbs.param[1] == MBGSD_TWOGB) {
1795                                 isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
1796                                 fcp->isp_gbspeed = 2;
1797                         }
1798                 }
1799         }
1800
1801         isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid,
1802             fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
1803
1804         /*
1805          * Announce ourselves, too. This involves synthesizing an entry.
1806          */
1807         if (fcp->isp_iid_set == 0) {
1808                 fcp->isp_iid_set = 1;
1809                 fcp->isp_iid = fcp->isp_loopid;
1810                 lp = &fcp->portdb[fcp->isp_iid];
1811         } else {
1812                 lp = &fcp->portdb[fcp->isp_iid];
1813                 if (fcp->isp_portid != lp->portid ||
1814                     fcp->isp_loopid != lp->loopid ||
1815                     fcp->isp_nodewwn != ISP_NODEWWN(isp) ||
1816                     fcp->isp_portwwn != ISP_PORTWWN(isp)) {
1817                         lp->valid = 0;
1818                         count = fcp->isp_iid;
1819                         (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1820                 }
1821         }
1822         lp->loopid = fcp->isp_loopid;
1823         lp->portid = fcp->isp_portid;
1824         lp->node_wwn = ISP_NODEWWN(isp);
1825         lp->port_wwn = ISP_PORTWWN(isp);
1826         switch (isp->isp_role) {
1827         case ISP_ROLE_NONE:
1828                 lp->roles = 0;
1829                 break;
1830         case ISP_ROLE_TARGET:
1831                 lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
1832                 break;
1833         case ISP_ROLE_INITIATOR:
1834                 lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
1835                 break;
1836         case ISP_ROLE_BOTH:
1837                 lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
1838                 break;
1839         }
1840         lp->loggedin = lp->valid = 1;
1841         count = fcp->isp_iid;
1842         (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
1843         return (0);
1844 }
1845
1846 static char *
1847 isp2100_fw_statename(int state)
1848 {
1849         switch(state) {
1850         case FW_CONFIG_WAIT:    return "Config Wait";
1851         case FW_WAIT_AL_PA:     return "Waiting for AL_PA";
1852         case FW_WAIT_LOGIN:     return "Wait Login";
1853         case FW_READY:          return "Ready";
1854         case FW_LOSS_OF_SYNC:   return "Loss Of Sync";
1855         case FW_ERROR:          return "Error";
1856         case FW_REINIT:         return "Re-Init";
1857         case FW_NON_PART:       return "Nonparticipating";
1858         default:                return "?????";
1859         }
1860 }
1861
1862 /*
1863  * Synchronize our soft copy of the port database with what the f/w thinks
1864  * (with a view toward possibly for a specific target....)
1865  */
1866
1867 static int
1868 isp_pdb_sync(ispsoftc_t *isp)
1869 {
1870         struct lportdb *lp;
1871         fcparam *fcp = isp->isp_param;
1872         isp_pdb_t pdb;
1873         int loopid, base, lim;
1874
1875         /*
1876          * Make sure we're okay for doing this right now.
1877          */
1878         if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
1879             fcp->isp_loopstate != LOOP_FSCAN_DONE &&
1880             fcp->isp_loopstate != LOOP_LSCAN_DONE) {
1881                 return (-1);
1882         }
1883
1884         if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT ||
1885             fcp->isp_topo == TOPO_N_PORT) {
1886                 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
1887                         if (isp_scan_loop(isp) != 0) {
1888                                 return (-1);
1889                         }
1890                 }
1891         }
1892         fcp->isp_loopstate = LOOP_SYNCING_PDB;
1893
1894         /*
1895          * If we get this far, we've settled our differences with the f/w
1896          * (for local loop device) and we can say that the loop state is ready.
1897          */
1898
1899         if (fcp->isp_topo == TOPO_NL_PORT) {
1900                 fcp->loop_seen_once = 1;
1901                 fcp->isp_loopstate = LOOP_READY;
1902                 return (0);
1903         }
1904
1905         /*
1906          * Find all Fabric Entities that didn't make it from one scan to the
1907          * next and let the world know they went away. Scan the whole database.
1908          */
1909         for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
1910                 if (lp->was_fabric_dev && lp->fabric_dev == 0) {
1911                         loopid = lp - fcp->portdb;
1912                         lp->valid = 0;  /* should already be set */
1913                         (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
1914                         MEMZERO((void *) lp, sizeof (*lp));
1915                         continue;
1916                 }
1917                 lp->was_fabric_dev = lp->fabric_dev;
1918         }
1919
1920         if (fcp->isp_topo == TOPO_FL_PORT)
1921                 base = FC_SNS_ID+1;
1922         else
1923                 base = 0;
1924
1925         if (fcp->isp_topo == TOPO_N_PORT)
1926                 lim = 1;
1927         else
1928                 lim = MAX_FC_TARG;
1929
1930         /*
1931          * Now log in any fabric devices that the outer layer has
1932          * left for us to see. This seems the most sane policy
1933          * for the moment.
1934          */
1935         for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
1936                 uint32_t portid;
1937                 mbreg_t mbs;
1938
1939                 loopid = lp - fcp->portdb;
1940                 if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) {
1941                         continue;
1942                 }
1943
1944                 /*
1945                  * Anything here?
1946                  */
1947                 if (lp->port_wwn == 0) {
1948                         continue;
1949                 }
1950
1951                 /*
1952                  * Don't try to log into yourself.
1953                  */
1954                 if ((portid = lp->portid) == fcp->isp_portid) {
1955                         continue;
1956                 }
1957
1958
1959                 /*
1960                  * If we'd been logged in- see if we still are and we haven't
1961                  * changed. If so, no need to log ourselves out, etc..
1962                  *
1963                  * Unfortunately, our charming Qlogic f/w has decided to
1964                  * return a valid port database entry for a fabric device
1965                  * that has, in fact, gone away. And it hangs trying to
1966                  * log it out.
1967                  */
1968                 if (lp->loggedin && lp->force_logout == 0 &&
1969                     isp_getpdb(isp, lp->loopid, &pdb) == 0) {
1970                         int nrole;
1971                         uint64_t nwwnn, nwwpn;
1972                         nwwnn =
1973                             (((uint64_t)pdb.pdb_nodename[0]) << 56) |
1974                             (((uint64_t)pdb.pdb_nodename[1]) << 48) |
1975                             (((uint64_t)pdb.pdb_nodename[2]) << 40) |
1976                             (((uint64_t)pdb.pdb_nodename[3]) << 32) |
1977                             (((uint64_t)pdb.pdb_nodename[4]) << 24) |
1978                             (((uint64_t)pdb.pdb_nodename[5]) << 16) |
1979                             (((uint64_t)pdb.pdb_nodename[6]) <<  8) |
1980                             (((uint64_t)pdb.pdb_nodename[7]));
1981                         nwwpn =
1982                             (((uint64_t)pdb.pdb_portname[0]) << 56) |
1983                             (((uint64_t)pdb.pdb_portname[1]) << 48) |
1984                             (((uint64_t)pdb.pdb_portname[2]) << 40) |
1985                             (((uint64_t)pdb.pdb_portname[3]) << 32) |
1986                             (((uint64_t)pdb.pdb_portname[4]) << 24) |
1987                             (((uint64_t)pdb.pdb_portname[5]) << 16) |
1988                             (((uint64_t)pdb.pdb_portname[6]) <<  8) |
1989                             (((uint64_t)pdb.pdb_portname[7]));
1990                         nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
1991                             SVC3_ROLE_SHIFT;
1992                         if (pdb.pdb_loopid == lp->loopid && lp->portid ==
1993                             (uint32_t) BITS2WORD(pdb.pdb_portid_bits) &&
1994                             nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
1995                             lp->roles == nrole && lp->force_logout == 0) {
1996                                 lp->loggedin = lp->valid = 1;
1997                                 isp_prt(isp, ISP_LOGCONFIG, lretained,
1998                                     (int) (lp - fcp->portdb),
1999                                     (int) lp->loopid, lp->portid);
2000                                 continue;
2001                         }
2002                 }
2003
2004                 if (fcp->isp_fwstate != FW_READY ||
2005                     fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2006                         return (-1);
2007                 }
2008
2009                 /*
2010                  * Force a logout if we were logged in.
2011                  */
2012                 if (lp->loggedin) {
2013                         if (lp->force_logout ||
2014                             isp_getpdb(isp, lp->loopid, &pdb) == 0) {
2015                                 MEMZERO(&mbs, sizeof (mbs));
2016                                 mbs.param[0] = MBOX_FABRIC_LOGOUT;
2017                                 if (IS_2KLOGIN(isp)) {
2018                                         mbs.param[1] = lp->loopid;
2019                                         mbs.obits |= (1 << 10);
2020                                 } else {
2021                                         mbs.param[1] = lp->loopid << 8;
2022                                 }
2023                                 mbs.param[2] = 0;
2024                                 mbs.param[3] = 0;
2025                                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
2026                                 isp_prt(isp, ISP_LOGINFO, plogout,
2027                                     (int) (lp - fcp->portdb), lp->loopid,
2028                                     lp->portid);
2029                         }
2030                         lp->force_logout = lp->loggedin = 0;
2031                         if (fcp->isp_fwstate != FW_READY ||
2032                             fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2033                                 return (-1);
2034                         }
2035                 }
2036
2037                 /*
2038                  * And log in....
2039                  */
2040                 loopid = lp - fcp->portdb;
2041                 lp->loopid = FL_PORT_ID;
2042                 do {
2043                         MEMZERO(&mbs, sizeof (mbs));
2044                         mbs.param[0] = MBOX_FABRIC_LOGIN;
2045                         if (IS_2KLOGIN(isp)) {
2046                                 mbs.param[1] = loopid;
2047                                 mbs.obits |= (1 << 10);
2048                         } else {
2049                                 mbs.param[1] = loopid << 8;
2050                         }
2051                         mbs.param[2] = portid >> 16;
2052                         mbs.param[3] = portid & 0xffff;
2053                         isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
2054                             MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
2055                         if (fcp->isp_fwstate != FW_READY ||
2056                             fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2057                                 return (-1);
2058                         }
2059                         switch (mbs.param[0]) {
2060                         case MBOX_LOOP_ID_USED:
2061                                 /*
2062                                  * Try the next available loop id.
2063                                  */
2064                                 loopid++;
2065                                 break;
2066                         case MBOX_PORT_ID_USED:
2067                                 /*
2068                                  * This port is already logged in.
2069                                  * Snaffle the loop id it's using if it's
2070                                  * nonzero, otherwise we're hosed.
2071                                  */
2072                                 if (mbs.param[1] != 0) {
2073                                         loopid = mbs.param[1];
2074                                         if (loopid >= MAX_FC_TARG) {
2075                                                 loopid = MAX_FC_TARG;
2076                                                 break;
2077                                         }
2078                                         isp_prt(isp, ISP_LOGINFO, retained,
2079                                             loopid, (int) (lp - fcp->portdb),
2080                                             lp->portid);
2081                                 } else {
2082                                         loopid = MAX_FC_TARG;
2083                                         break;
2084                                 }
2085                                 /* FALLTHROUGH */
2086                         case MBOX_COMMAND_COMPLETE:
2087                                 lp->loggedin = 1;
2088                                 lp->loopid = loopid;
2089                                 break;
2090                         case MBOX_COMMAND_ERROR:
2091                                 isp_prt(isp, ISP_LOGINFO, plogierr,
2092                                     portid, mbs.param[1]);
2093                                 /* FALLTHROUGH */
2094                         case MBOX_ALL_IDS_USED: /* We're outta IDs */
2095                         default:
2096                                 loopid = MAX_FC_TARG;
2097                                 break;
2098                         }
2099                 } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
2100
2101                 /*
2102                  * If we get here and we haven't set a Loop ID,
2103                  * we failed to log into this device.
2104                  */
2105
2106                 if (lp->loopid == FL_PORT_ID) {
2107                         lp->loopid = 0;
2108                         continue;
2109                 }
2110
2111                 /*
2112                  * Make sure we can get the approriate port information.
2113                  */
2114                 if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
2115                         isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
2116                         goto dump_em;
2117                 }
2118
2119                 if (fcp->isp_fwstate != FW_READY ||
2120                     fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2121                         return (-1);
2122                 }
2123
2124                 if (pdb.pdb_loopid != lp->loopid) {
2125                         isp_prt(isp, ISP_LOGWARN, pdbmfail1,
2126                             lp->portid, pdb.pdb_loopid);
2127                         goto dump_em;
2128                 }
2129
2130                 if (lp->portid != (uint32_t) BITS2WORD(pdb.pdb_portid_bits)) {
2131                         isp_prt(isp, ISP_LOGWARN, pdbmfail2,
2132                             lp->portid, BITS2WORD(pdb.pdb_portid_bits));
2133                         goto dump_em;
2134                 }
2135
2136                 lp->roles =
2137                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2138                 lp->node_wwn =
2139                     (((uint64_t)pdb.pdb_nodename[0]) << 56) |
2140                     (((uint64_t)pdb.pdb_nodename[1]) << 48) |
2141                     (((uint64_t)pdb.pdb_nodename[2]) << 40) |
2142                     (((uint64_t)pdb.pdb_nodename[3]) << 32) |
2143                     (((uint64_t)pdb.pdb_nodename[4]) << 24) |
2144                     (((uint64_t)pdb.pdb_nodename[5]) << 16) |
2145                     (((uint64_t)pdb.pdb_nodename[6]) <<  8) |
2146                     (((uint64_t)pdb.pdb_nodename[7]));
2147                 lp->port_wwn =
2148                     (((uint64_t)pdb.pdb_portname[0]) << 56) |
2149                     (((uint64_t)pdb.pdb_portname[1]) << 48) |
2150                     (((uint64_t)pdb.pdb_portname[2]) << 40) |
2151                     (((uint64_t)pdb.pdb_portname[3]) << 32) |
2152                     (((uint64_t)pdb.pdb_portname[4]) << 24) |
2153                     (((uint64_t)pdb.pdb_portname[5]) << 16) |
2154                     (((uint64_t)pdb.pdb_portname[6]) <<  8) |
2155                     (((uint64_t)pdb.pdb_portname[7]));
2156                 /*
2157                  * Check to make sure this all makes sense.
2158                  */
2159                 if (lp->node_wwn && lp->port_wwn) {
2160                         lp->valid = 1;
2161                         loopid = lp - fcp->portdb;
2162                         (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2163                         continue;
2164                 }
2165 dump_em:
2166                 lp->valid = 0;
2167                 isp_prt(isp, ISP_LOGINFO,
2168                     ldumped, loopid, lp->loopid, lp->portid);
2169                 MEMZERO(&mbs, sizeof (mbs));
2170                 mbs.param[0] = MBOX_FABRIC_LOGOUT;
2171                 if (IS_2KLOGIN(isp)) {
2172                         mbs.param[1] = lp->loopid;
2173                         mbs.obits |= (1 << 10);
2174                 } else {
2175                         mbs.param[1] = lp->loopid << 8;
2176                 }
2177                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
2178                 if (fcp->isp_fwstate != FW_READY ||
2179                     fcp->isp_loopstate != LOOP_SYNCING_PDB) {
2180                         return (-1);
2181                 }
2182         }
2183         /*
2184          * If we get here, we've for sure seen not only a valid loop
2185          * but know what is or isn't on it, so mark this for usage
2186          * in isp_start.
2187          */
2188         fcp->loop_seen_once = 1;
2189         fcp->isp_loopstate = LOOP_READY;
2190         return (0);
2191 }
2192
2193 static int
2194 isp_scan_loop(ispsoftc_t *isp)
2195 {
2196         struct lportdb *lp;
2197         fcparam *fcp = isp->isp_param;
2198         isp_pdb_t pdb;
2199         int loopid, lim, hival;
2200
2201         switch (fcp->isp_topo) {
2202         case TOPO_NL_PORT:
2203                 hival = FL_PORT_ID;
2204                 break;
2205         case TOPO_N_PORT:
2206                 hival = 2;
2207                 break;
2208         case TOPO_FL_PORT:
2209                 hival = FC_PORT_ID;
2210                 break;
2211         default:
2212                 fcp->isp_loopstate = LOOP_LSCAN_DONE;
2213                 return (0);
2214         }
2215         fcp->isp_loopstate = LOOP_SCANNING_LOOP;
2216
2217         /*
2218          * make sure the temp port database is clean...
2219          */
2220         MEMZERO((void *)fcp->tport, sizeof (fcp->tport));
2221
2222         /*
2223          * Run through the local loop ports and get port database info
2224          * for each loop ID.
2225          *
2226          * There's a somewhat unexplained situation where the f/w passes back
2227          * the wrong database entity- if that happens, just restart (up to
2228          * FL_PORT_ID times).
2229          */
2230         for (lim = loopid = 0; loopid < hival; loopid++) {
2231                 lp = &fcp->tport[loopid];
2232
2233                 /*
2234                  * Don't even try for ourselves...
2235                  */
2236                 if (loopid == fcp->isp_loopid)
2237                         continue;
2238
2239                 lp->node_wwn = isp_get_portname(isp, loopid, 1);
2240                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2241                         return (-1);
2242                 if (lp->node_wwn == 0)
2243                         continue;
2244                 lp->port_wwn = isp_get_portname(isp, loopid, 0);
2245                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2246                         return (-1);
2247                 if (lp->port_wwn == 0) {
2248                         lp->node_wwn = 0;
2249                         continue;
2250                 }
2251
2252                 /*
2253                  * Get an entry....
2254                  */
2255                 if (isp_getpdb(isp, loopid, &pdb) != 0) {
2256                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
2257                                 return (-1);
2258                         continue;
2259                 }
2260                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
2261                         return (-1);
2262                 }
2263
2264                 /*
2265                  * If the returned database element doesn't match what we
2266                  * asked for, restart the process entirely (up to a point...).
2267                  */
2268                 if (pdb.pdb_loopid != loopid) {
2269                         loopid = 0;
2270                         if (lim++ < hival) {
2271                                 continue;
2272                         }
2273                         isp_prt(isp, ISP_LOGWARN,
2274                             "giving up on synchronizing the port database");
2275                         return (-1);
2276                 }
2277
2278                 /*
2279                  * Save the pertinent info locally.
2280                  */
2281                 lp->node_wwn =
2282                     (((uint64_t)pdb.pdb_nodename[0]) << 56) |
2283                     (((uint64_t)pdb.pdb_nodename[1]) << 48) |
2284                     (((uint64_t)pdb.pdb_nodename[2]) << 40) |
2285                     (((uint64_t)pdb.pdb_nodename[3]) << 32) |
2286                     (((uint64_t)pdb.pdb_nodename[4]) << 24) |
2287                     (((uint64_t)pdb.pdb_nodename[5]) << 16) |
2288                     (((uint64_t)pdb.pdb_nodename[6]) <<  8) |
2289                     (((uint64_t)pdb.pdb_nodename[7]));
2290                 lp->port_wwn =
2291                     (((uint64_t)pdb.pdb_portname[0]) << 56) |
2292                     (((uint64_t)pdb.pdb_portname[1]) << 48) |
2293                     (((uint64_t)pdb.pdb_portname[2]) << 40) |
2294                     (((uint64_t)pdb.pdb_portname[3]) << 32) |
2295                     (((uint64_t)pdb.pdb_portname[4]) << 24) |
2296                     (((uint64_t)pdb.pdb_portname[5]) << 16) |
2297                     (((uint64_t)pdb.pdb_portname[6]) <<  8) |
2298                     (((uint64_t)pdb.pdb_portname[7]));
2299                 lp->roles =
2300                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2301                 lp->portid = BITS2WORD(pdb.pdb_portid_bits);
2302                 lp->loopid = pdb.pdb_loopid;
2303         }
2304
2305         /*
2306          * Mark all of the permanent local loop database entries as invalid
2307          * (except our own entry).
2308          */
2309         for (loopid = 0; loopid < hival; loopid++) {
2310                 if (loopid == fcp->isp_iid) {
2311                         fcp->portdb[loopid].valid = 1;
2312                         fcp->portdb[loopid].loopid = fcp->isp_loopid;
2313                         continue;
2314                 }
2315                 fcp->portdb[loopid].valid = 0;
2316         }
2317
2318         /*
2319          * Now merge our local copy of the port database into our saved copy.
2320          * Notify the outer layers of new devices arriving.
2321          */
2322         for (loopid = 0; loopid < hival; loopid++) {
2323                 int i;
2324
2325                 /*
2326                  * If we don't have a non-zero Port WWN, we're not here.
2327                  */
2328                 if (fcp->tport[loopid].port_wwn == 0) {
2329                         continue;
2330                 }
2331
2332                 /*
2333                  * Skip ourselves.
2334                  */
2335                 if (loopid == fcp->isp_iid) {
2336                         continue;
2337                 }
2338
2339                 /*
2340                  * For the purposes of deciding whether this is the
2341                  * 'same' device or not, we only search for an identical
2342                  * Port WWN. Node WWNs may or may not be the same as
2343                  * the Port WWN, and there may be multiple different
2344                  * Port WWNs with the same Node WWN. It would be chaos
2345                  * to have multiple identical Port WWNs, so we don't
2346                  * allow that.
2347                  */
2348
2349                 for (i = 0; i < hival; i++) {
2350                         int j;
2351                         if (fcp->portdb[i].port_wwn == 0)
2352                                 continue;
2353                         if (fcp->portdb[i].port_wwn !=
2354                             fcp->tport[loopid].port_wwn)
2355                                 continue;
2356                         /*
2357                          * We found this WWN elsewhere- it's changed
2358                          * loopids then. We don't change it's actual
2359                          * position in our cached port database- we
2360                          * just change the actual loop ID we'd use.
2361                          */
2362                         if (fcp->portdb[i].loopid != loopid) {
2363                                 isp_prt(isp, ISP_LOGINFO, portshift, i,
2364                                     fcp->portdb[i].loopid,
2365                                     fcp->portdb[i].portid, loopid,
2366                                     fcp->tport[loopid].portid);
2367                         }
2368                         fcp->portdb[i].portid = fcp->tport[loopid].portid;
2369                         fcp->portdb[i].loopid = loopid;
2370                         fcp->portdb[i].valid = 1;
2371                         fcp->portdb[i].roles = fcp->tport[loopid].roles;
2372
2373                         /*
2374                          * Now make sure this Port WWN doesn't exist elsewhere
2375                          * in the port database.
2376                          */
2377                         for (j = i+1; j < hival; j++) {
2378                                 if (fcp->portdb[i].port_wwn !=
2379                                     fcp->portdb[j].port_wwn) {
2380                                         continue;
2381                                 }
2382                                 isp_prt(isp, ISP_LOGWARN, portdup, j, i);
2383                                 /*
2384                                  * Invalidate the 'old' *and* 'new' ones.
2385                                  * This is really harsh and not quite right,
2386                                  * but if this happens, we really don't know
2387                                  * who is what at this point.
2388                                  */
2389                                 fcp->portdb[i].valid = 0;
2390                                 fcp->portdb[j].valid = 0;
2391                         }
2392                         break;
2393                 }
2394
2395                 /*
2396                  * If we didn't traverse the entire port database,
2397                  * then we found (and remapped) an existing entry.
2398                  * No need to notify anyone- go for the next one.
2399                  */
2400                 if (i < hival) {
2401                         isp_prt(isp, ISP_LOGINFO, retained,
2402                             fcp->portdb[i].loopid, i, fcp->portdb[i].portid);
2403                         continue;
2404                 }
2405
2406                 /*
2407                  * We've not found this Port WWN anywhere. It's a new entry.
2408                  * See if we can leave it where it is (with target == loopid).
2409                  */
2410                 if (fcp->portdb[loopid].port_wwn != 0) {
2411                         for (lim = 0; lim < hival; lim++) {
2412                                 if (fcp->portdb[lim].port_wwn == 0)
2413                                         break;
2414                         }
2415                         /* "Cannot Happen" */
2416                         if (lim == hival) {
2417                                 isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
2418                                 continue;
2419                         }
2420                         i = lim;
2421                 } else {
2422                         i = loopid;
2423                 }
2424
2425                 /*
2426                  * NB:  The actual loopid we use here is loopid- we may
2427                  *      in fact be at a completely different index (target).
2428                  */
2429                 fcp->portdb[i].loopid = loopid;
2430                 fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn;
2431                 fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn;
2432                 fcp->portdb[i].roles = fcp->tport[loopid].roles;
2433                 fcp->portdb[i].portid = fcp->tport[loopid].portid;
2434                 fcp->portdb[i].valid = 1;
2435
2436                 /*
2437                  * Tell the outside world we've arrived.
2438                  */
2439                 (void) isp_async(isp, ISPASYNC_PROMENADE, &i);
2440         }
2441
2442         /*
2443          * Now find all previously used targets that are now invalid and
2444          * notify the outer layers that they're gone.
2445          */
2446         for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
2447                 if (lp->valid || lp->port_wwn == 0) {
2448                         continue;
2449                 }
2450
2451                 /*
2452                  * Tell the outside world we've gone
2453                  * away and erase our pdb entry.
2454                  *
2455                  */
2456                 loopid = lp - fcp->portdb;
2457                 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
2458                 MEMZERO((void *) lp, sizeof (*lp));
2459         }
2460         fcp->isp_loopstate = LOOP_LSCAN_DONE;
2461         return (0);
2462 }
2463
2464
2465 static int
2466 isp_fabric_mbox_cmd(ispsoftc_t *isp, mbreg_t *mbp)
2467 {
2468         isp_mboxcmd(isp, mbp, MBLOGNONE);
2469         if (mbp->param[0] != MBOX_COMMAND_COMPLETE) {
2470                 if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) {
2471                         FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
2472                 }
2473                 if (mbp->param[0] == MBOX_COMMAND_ERROR) {
2474                         char tbuf[16];
2475                         char *m;
2476                         switch (mbp->param[1]) {
2477                         case 1:
2478                                 m = "No Loop";
2479                                 break;
2480                         case 2:
2481                                 m = "Failed to allocate IOCB buffer";
2482                                 break;
2483                         case 3:
2484                                 m = "Failed to allocate XCB buffer";
2485                                 break;
2486                         case 4:
2487                                 m = "timeout or transmit failed";
2488                                 break;
2489                         case 5:
2490                                 m = "no fabric loop";
2491                                 break;
2492                         case 6:
2493                                 m = "remote device not a target";
2494                                 break;
2495                         default:
2496                                 SNPRINTF(tbuf, sizeof tbuf, "%x",
2497                                     mbp->param[1]);
2498                                 m = tbuf;
2499                                 break;
2500                         }
2501                         isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m);
2502                 }
2503                 return (-1);
2504         }
2505
2506         if (FCPARAM(isp)->isp_fwstate != FW_READY ||
2507             FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) {
2508                 return (-1);
2509         }
2510         return(0);
2511 }
2512
2513 #ifdef  ISP_USE_GA_NXT
2514 static int
2515 isp_scan_fabric(ispsoftc_t *isp, int ftype)
2516 {
2517         fcparam *fcp = isp->isp_param;
2518         uint32_t portid, first_portid, last_portid;
2519         int hicap, last_port_same;
2520
2521         if (fcp->isp_onfabric == 0) {
2522                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2523                 return (0);
2524         }
2525
2526         FC_SCRATCH_ACQUIRE(isp);
2527
2528         /*
2529          * Since Port IDs are 24 bits, we can check against having seen
2530          * anything yet with this value.
2531          */
2532         last_port_same = 0;
2533         last_portid = 0xffffffff;       /* not a port */
2534         first_portid = portid = fcp->isp_portid;
2535         fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2536
2537         for (hicap = 0; hicap < GA_NXT_MAX; hicap++) {
2538                 mbreg_t mbs;
2539                 sns_screq_t *rq;
2540                 sns_ga_nxt_rsp_t *rs0, *rs1;
2541                 struct lportdb lcl;
2542                 uint8_t sc[SNS_GA_NXT_RESP_SIZE];
2543
2544                 rq = (sns_screq_t *)sc;
2545                 MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE);
2546                 rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1;
2547                 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100);
2548                 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100);
2549                 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100);
2550                 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100);
2551                 rq->snscb_sblen = 6;
2552                 rq->snscb_data[0] = SNS_GA_NXT;
2553                 rq->snscb_data[4] = portid & 0xffff;
2554                 rq->snscb_data[5] = (portid >> 16) & 0xff;
2555                 isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch);
2556                 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE);
2557                 MEMZERO(&mbs, sizeof (mbs));
2558                 mbs.param[0] = MBOX_SEND_SNS;
2559                 mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1;
2560                 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2561                 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2562                 /*
2563                  * Leave 4 and 5 alone
2564                  */
2565                 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2566                 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2567                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2568                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2569                                 fcp->isp_loopstate = LOOP_PDB_RCVD;
2570                         }
2571                         FC_SCRATCH_RELEASE(isp);
2572                         return (-1);
2573                 }
2574                 MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE);
2575                 rs1 = (sns_ga_nxt_rsp_t *) sc;
2576                 rs0 = (sns_ga_nxt_rsp_t *) ((uint8_t *)fcp->isp_scratch+0x100);
2577                 isp_get_ga_nxt_response(isp, rs0, rs1);
2578                 if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2579                         int level;
2580                         if (rs1->snscb_cthdr.ct_reason == 9 &&
2581                             rs1->snscb_cthdr.ct_explanation == 7)
2582                                 level = ISP_LOGDEBUG0;
2583                         else
2584                                 level = ISP_LOGWARN;
2585                         isp_prt(isp, level, swrej, "GA_NXT",
2586                             rs1->snscb_cthdr.ct_reason,
2587                             rs1->snscb_cthdr.ct_explanation, portid);
2588                         FC_SCRATCH_RELEASE(isp);
2589                         fcp->isp_loopstate = LOOP_FSCAN_DONE;
2590                         return (0);
2591                 }
2592                 portid =
2593                     (((uint32_t) rs1->snscb_port_id[0]) << 16) |
2594                     (((uint32_t) rs1->snscb_port_id[1]) << 8) |
2595                     (((uint32_t) rs1->snscb_port_id[2]));
2596
2597                 /*
2598                  * XXX: We should check to make sure that this entry
2599                  * XXX: supports the type(s) we are interested in.
2600                  */
2601                 /*
2602                  * Okay, we now have information about a fabric object.
2603                  * If it is the type we're interested in, tell the outer layers
2604                  * about it. The outer layer needs to  know: Port ID, WWNN,
2605                  * WWPN, FC4 type, and port type.
2606                  *
2607                  * The lportdb structure is adequate for this.
2608                  */
2609                 MEMZERO(&lcl, sizeof (lcl));
2610                 lcl.port_type = rs1->snscb_port_type;
2611                 lcl.fc4_type = ftype;
2612                 lcl.portid = portid;
2613                 lcl.node_wwn =
2614                     (((uint64_t)rs1->snscb_nodename[0]) << 56) |
2615                     (((uint64_t)rs1->snscb_nodename[1]) << 48) |
2616                     (((uint64_t)rs1->snscb_nodename[2]) << 40) |
2617                     (((uint64_t)rs1->snscb_nodename[3]) << 32) |
2618                     (((uint64_t)rs1->snscb_nodename[4]) << 24) |
2619                     (((uint64_t)rs1->snscb_nodename[5]) << 16) |
2620                     (((uint64_t)rs1->snscb_nodename[6]) <<  8) |
2621                     (((uint64_t)rs1->snscb_nodename[7]));
2622                 lcl.port_wwn =
2623                     (((uint64_t)rs1->snscb_portname[0]) << 56) |
2624                     (((uint64_t)rs1->snscb_portname[1]) << 48) |
2625                     (((uint64_t)rs1->snscb_portname[2]) << 40) |
2626                     (((uint64_t)rs1->snscb_portname[3]) << 32) |
2627                     (((uint64_t)rs1->snscb_portname[4]) << 24) |
2628                     (((uint64_t)rs1->snscb_portname[5]) << 16) |
2629                     (((uint64_t)rs1->snscb_portname[6]) <<  8) |
2630                     (((uint64_t)rs1->snscb_portname[7]));
2631
2632                 /*
2633                  * Does this fabric object support the type we want?
2634                  * If not, skip it.
2635                  */
2636                 if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) {
2637                         if (first_portid == portid) {
2638                                 lcl.last_fabric_dev = 1;
2639                         } else {
2640                                 lcl.last_fabric_dev = 0;
2641                         }
2642                         (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2643                 } else {
2644                         isp_prt(isp, ISP_LOGDEBUG0,
2645                             "PortID 0x%x doesn't support FC4 type 0x%x",
2646                             portid, ftype);
2647                 }
2648                 if (first_portid == portid) {
2649                         fcp->isp_loopstate = LOOP_FSCAN_DONE;
2650                         FC_SCRATCH_RELEASE(isp);
2651                         return (0);
2652                 }
2653                 if (portid == last_portid) {
2654                         if (last_port_same++ > 20) {
2655                                 isp_prt(isp, ISP_LOGWARN,
2656                                     "tangled fabric database detected");
2657                                 break;
2658                         }
2659                 } else {
2660                         last_port_same = 0 ;
2661                         last_portid = portid;
2662                 }
2663         }
2664         FC_SCRATCH_RELEASE(isp);
2665         if (hicap >= GA_NXT_MAX) {
2666                 isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX);
2667         }
2668         fcp->isp_loopstate = LOOP_FSCAN_DONE;
2669         return (0);
2670 }
2671 #else
2672 #define GIDLEN  ((ISP2100_SCRLEN >> 1) + 16)
2673 #define NGENT   ((GIDLEN - 16) >> 2)
2674
2675 #define IGPOFF  (ISP2100_SCRLEN - GIDLEN)
2676 #define GXOFF   (256)
2677
2678 static int
2679 isp_scan_fabric(ispsoftc_t *isp, int ftype)
2680 {
2681         fcparam *fcp = FCPARAM(isp);
2682         mbreg_t mbs;
2683         int i;
2684         sns_gid_ft_req_t *rq;
2685         sns_gid_ft_rsp_t *rs0, *rs1;
2686
2687         if (fcp->isp_onfabric == 0) {
2688                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2689                 return (0);
2690         }
2691
2692         FC_SCRATCH_ACQUIRE(isp);
2693         fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
2694
2695         rq = (sns_gid_ft_req_t *)fcp->tport;
2696         MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE);
2697         rq->snscb_rblen = GIDLEN >> 1;
2698         rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF);
2699         rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF);
2700         rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF);
2701         rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF);
2702         rq->snscb_sblen = 6;
2703         rq->snscb_cmd = SNS_GID_FT;
2704         rq->snscb_mword_div_2 = NGENT;
2705         rq->snscb_fc4_type = ftype;
2706         isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch);
2707         MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
2708         MEMZERO(&mbs, sizeof (mbs));
2709         mbs.param[0] = MBOX_SEND_SNS;
2710         mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
2711         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2712         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2713
2714         /*
2715          * Leave 4 and 5 alone
2716          */
2717         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2718         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2719         if (isp_fabric_mbox_cmd(isp, &mbs)) {
2720                 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2721                         fcp->isp_loopstate = LOOP_PDB_RCVD;
2722                 }
2723                 FC_SCRATCH_RELEASE(isp);
2724                 return (-1);
2725         }
2726         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2727                 FC_SCRATCH_RELEASE(isp);
2728                 return (-1);
2729         }
2730         MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
2731         rs1 = (sns_gid_ft_rsp_t *) fcp->tport;
2732         rs0 = (sns_gid_ft_rsp_t *) ((uint8_t *)fcp->isp_scratch+IGPOFF);
2733         isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
2734         if (rs1->snscb_cthdr.ct_response != FS_ACC) {
2735                 int level;
2736                 if (rs1->snscb_cthdr.ct_reason == 9 &&
2737                     rs1->snscb_cthdr.ct_explanation == 7)
2738                         level = ISP_LOGDEBUG0;
2739                 else
2740                         level = ISP_LOGWARN;
2741                 isp_prt(isp, level, swrej, "GID_FT",
2742                     rs1->snscb_cthdr.ct_reason,
2743                     rs1->snscb_cthdr.ct_explanation, 0);
2744                 FC_SCRATCH_RELEASE(isp);
2745                 fcp->isp_loopstate = LOOP_FSCAN_DONE;
2746                 return (0);
2747         }
2748
2749         /*
2750          * Okay, we now have a list of Port IDs for this class of device.
2751          * Go through the list and for each one get the WWPN/WWNN for it
2752          * and tell the outer layers about it. The outer layer needs to
2753          * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type.
2754          *
2755          * The lportdb structure is adequate for this.
2756          */
2757         i = -1;
2758         do {
2759                 sns_gxn_id_req_t grqbuf, *gq = &grqbuf;
2760                 sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf;
2761                 struct lportdb lcl;
2762 #if     0
2763                 sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf;
2764 #endif
2765
2766                 i++;
2767                 MEMZERO(&lcl, sizeof (lcl));
2768                 lcl.fc4_type = ftype;
2769                 lcl.portid =
2770                     (((uint32_t) rs1->snscb_ports[i].portid[0]) << 16) |
2771                     (((uint32_t) rs1->snscb_ports[i].portid[1]) << 8) |
2772                     (((uint32_t) rs1->snscb_ports[i].portid[2]));
2773
2774                 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2775                 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2776                 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2777                 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2778                 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2779                 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2780                 gq->snscb_sblen = 6;
2781                 gq->snscb_cmd = SNS_GPN_ID;
2782                 gq->snscb_portid = lcl.portid;
2783                 isp_put_gxn_id_request(isp, gq,
2784                     (sns_gxn_id_req_t *) fcp->isp_scratch);
2785                 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2786                 MEMZERO(&mbs, sizeof (mbs));
2787                 mbs.param[0] = MBOX_SEND_SNS;
2788                 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2789                 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2790                 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2791                 /*
2792                  * Leave 4 and 5 alone
2793                  */
2794                 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2795                 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2796                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2797                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2798                                 fcp->isp_loopstate = LOOP_PDB_RCVD;
2799                         }
2800                         FC_SCRATCH_RELEASE(isp);
2801                         return (-1);
2802                 }
2803                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2804                         FC_SCRATCH_RELEASE(isp);
2805                         return (-1);
2806                 }
2807                 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2808                 gs0 = (sns_gxn_id_rsp_t *) ((uint8_t *)fcp->isp_scratch+GXOFF);
2809                 isp_get_gxn_id_response(isp, gs0, gs1);
2810                 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2811                         isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID",
2812                             gs1->snscb_cthdr.ct_reason,
2813                             gs1->snscb_cthdr.ct_explanation, lcl.portid);
2814                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2815                                 FC_SCRATCH_RELEASE(isp);
2816                                 return (-1);
2817                         }
2818                         continue;
2819                 }
2820                 lcl.port_wwn =
2821                     (((uint64_t)gs1->snscb_wwn[0]) << 56) |
2822                     (((uint64_t)gs1->snscb_wwn[1]) << 48) |
2823                     (((uint64_t)gs1->snscb_wwn[2]) << 40) |
2824                     (((uint64_t)gs1->snscb_wwn[3]) << 32) |
2825                     (((uint64_t)gs1->snscb_wwn[4]) << 24) |
2826                     (((uint64_t)gs1->snscb_wwn[5]) << 16) |
2827                     (((uint64_t)gs1->snscb_wwn[6]) <<  8) |
2828                     (((uint64_t)gs1->snscb_wwn[7]));
2829
2830                 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2831                 gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
2832                 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2833                 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2834                 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2835                 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2836                 gq->snscb_sblen = 6;
2837                 gq->snscb_cmd = SNS_GNN_ID;
2838                 gq->snscb_portid = lcl.portid;
2839                 isp_put_gxn_id_request(isp, gq,
2840                     (sns_gxn_id_req_t *) fcp->isp_scratch);
2841                 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2842                 MEMZERO(&mbs, sizeof (mbs));
2843                 mbs.param[0] = MBOX_SEND_SNS;
2844                 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2845                 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2846                 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2847                 /*
2848                  * Leave 4 and 5 alone
2849                  */
2850                 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2851                 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2852                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2853                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2854                                 fcp->isp_loopstate = LOOP_PDB_RCVD;
2855                         }
2856                         FC_SCRATCH_RELEASE(isp);
2857                         return (-1);
2858                 }
2859                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2860                         FC_SCRATCH_RELEASE(isp);
2861                         return (-1);
2862                 }
2863                 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
2864                 gs0 = (sns_gxn_id_rsp_t *) ((uint8_t *)fcp->isp_scratch+GXOFF);
2865                 isp_get_gxn_id_response(isp, gs0, gs1);
2866                 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
2867                         isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID",
2868                             gs1->snscb_cthdr.ct_reason,
2869                             gs1->snscb_cthdr.ct_explanation, lcl.portid);
2870                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2871                                 FC_SCRATCH_RELEASE(isp);
2872                                 return (-1);
2873                         }
2874                         continue;
2875                 }
2876                 lcl.node_wwn =
2877                     (((uint64_t)gs1->snscb_wwn[0]) << 56) |
2878                     (((uint64_t)gs1->snscb_wwn[1]) << 48) |
2879                     (((uint64_t)gs1->snscb_wwn[2]) << 40) |
2880                     (((uint64_t)gs1->snscb_wwn[3]) << 32) |
2881                     (((uint64_t)gs1->snscb_wwn[4]) << 24) |
2882                     (((uint64_t)gs1->snscb_wwn[5]) << 16) |
2883                     (((uint64_t)gs1->snscb_wwn[6]) <<  8) |
2884                     (((uint64_t)gs1->snscb_wwn[7]));
2885
2886                 /*
2887                  * The QLogic f/w is bouncing this with a parameter error.
2888                  */
2889 #if     0
2890                 /*
2891                  * Try and get FC4 Features (FC-GS-3 only).
2892                  * We can use the sns_gxn_id_req_t for this request.
2893                  */
2894                 MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
2895                 gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1;
2896                 gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
2897                 gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
2898                 gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
2899                 gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
2900                 gq->snscb_sblen = 6;
2901                 gq->snscb_cmd = SNS_GFF_ID;
2902                 gq->snscb_portid = lcl.portid;
2903                 isp_put_gxn_id_request(isp, gq,
2904                     (sns_gxn_id_req_t *) fcp->isp_scratch);
2905                 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
2906                 MEMZERO(&mbs, sizeof (mbs));
2907                 mbs.param[0] = MBOX_SEND_SNS;
2908                 mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
2909                 mbs.param[2] = DMA_WD1(fcp->isp_scdma);
2910                 mbs.param[3] = DMA_WD0(fcp->isp_scdma);
2911                 /*
2912                  * Leave 4 and 5 alone
2913                  */
2914                 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
2915                 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
2916                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
2917                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
2918                                 fcp->isp_loopstate = LOOP_PDB_RCVD;
2919                         }
2920                         FC_SCRATCH_RELEASE(isp);
2921                         return (-1);
2922                 }
2923                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2924                         FC_SCRATCH_RELEASE(isp);
2925                         return (-1);
2926                 }
2927                 MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE);
2928                 fs0 = (sns_gff_id_rsp_t *) ((uint8_t *)fcp->isp_scratch+GXOFF);
2929                 isp_get_gff_id_response(isp, fs0, fs1);
2930                 if (fs1->snscb_cthdr.ct_response != FS_ACC) {
2931                         isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN,
2932                             swrej, "GFF_ID",
2933                             fs1->snscb_cthdr.ct_reason,
2934                             fs1->snscb_cthdr.ct_explanation, lcl.portid);
2935                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
2936                                 FC_SCRATCH_RELEASE(isp);
2937                                 return (-1);
2938                         }
2939                 } else {
2940                         int index = (ftype >> 3);
2941                         int bshft = (ftype & 0x7) * 4;
2942                         int fc4_fval =
2943                             (fs1->snscb_fc4_features[index] >> bshft) & 0xf;
2944                         if (fc4_fval & 0x1) {
2945                                 lcl.roles |=
2946                                     (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT);
2947                         }
2948                         if (fc4_fval & 0x2) {
2949                                 lcl.roles |=
2950                                     (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT);
2951                         }
2952                 }
2953 #endif
2954
2955                 /*
2956                  * If we really want to know what kind of port type this is,
2957                  * we have to run another CT command. Otherwise, we'll leave
2958                  * it as undefined.
2959                  *
2960                 lcl.port_type = 0;
2961                  */
2962                 if (rs1->snscb_ports[i].control & 0x80) {
2963                         lcl.last_fabric_dev = 1;
2964                 } else {
2965                         lcl.last_fabric_dev = 0;
2966                 }
2967                 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
2968
2969         } while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1);
2970
2971         /*
2972          * If we're not at the last entry, our list isn't big enough.
2973          */
2974         if ((rs1->snscb_ports[i].control & 0x80) == 0) {
2975                 isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area");
2976         }
2977
2978         FC_SCRATCH_RELEASE(isp);
2979         fcp->isp_loopstate = LOOP_FSCAN_DONE;
2980         return (0);
2981 }
2982 #endif
2983
2984 static void
2985 isp_register_fc4_type(ispsoftc_t *isp)
2986 {
2987         fcparam *fcp = isp->isp_param;
2988         uint8_t local[SNS_RFT_ID_REQ_SIZE];
2989         sns_screq_t *reqp = (sns_screq_t *) local;
2990         mbreg_t mbs;
2991
2992         MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
2993         reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
2994         reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
2995         reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
2996         reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
2997         reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
2998         reqp->snscb_sblen = 22;
2999         reqp->snscb_data[0] = SNS_RFT_ID;
3000         reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
3001         reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
3002         reqp->snscb_data[6] = (1 << FC4_SCSI);
3003 #if     0
3004         reqp->snscb_data[6] |= (1 << FC4_IP);   /* ISO/IEC 8802-2 LLC/SNAP */
3005 #endif
3006         FC_SCRATCH_ACQUIRE(isp);
3007         isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
3008         MEMZERO(&mbs, sizeof (mbs));
3009         mbs.param[0] = MBOX_SEND_SNS;
3010         mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
3011         mbs.param[2] = DMA_WD1(fcp->isp_scdma);
3012         mbs.param[3] = DMA_WD0(fcp->isp_scdma);
3013         /*
3014          * Leave 4 and 5 alone
3015          */
3016         mbs.param[6] = DMA_WD3(fcp->isp_scdma);
3017         mbs.param[7] = DMA_WD2(fcp->isp_scdma);
3018         isp_mboxcmd(isp, &mbs, MBLOGALL);
3019         FC_SCRATCH_RELEASE(isp);
3020         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3021                 isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded");
3022         }
3023 }
3024
3025 /*
3026  * Start a command. Locking is assumed done in the caller.
3027  */
3028
3029 int
3030 isp_start(XS_T *xs)
3031 {
3032         ispsoftc_t *isp;
3033         uint16_t nxti, optr, handle;
3034         uint8_t local[QENTRY_LEN];
3035         ispreq_t *reqp, *qep;
3036         int target, i;
3037
3038         XS_INITERR(xs);
3039         isp = XS_ISP(xs);
3040
3041         /*
3042          * Check to make sure we're supporting initiator role.
3043          */
3044         if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
3045                 XS_SETERR(xs, HBA_SELTIMEOUT);
3046                 return (CMD_COMPLETE);
3047         }
3048
3049         /*
3050          * Now make sure we're running.
3051          */
3052
3053         if (isp->isp_state != ISP_RUNSTATE) {
3054                 isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
3055                 XS_SETERR(xs, HBA_BOTCH);
3056                 return (CMD_COMPLETE);
3057         }
3058
3059         /*
3060          * Check command CDB length, etc.. We really are limited to 16 bytes
3061          * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
3062          * but probably only if we're running fairly new firmware (we'll
3063          * let the old f/w choke on an extended command queue entry).
3064          */
3065
3066         if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
3067                 isp_prt(isp, ISP_LOGERR,
3068                     "unsupported cdb length (%d, CDB[0]=0x%x)",
3069                     XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
3070                 XS_SETERR(xs, HBA_BOTCH);
3071                 return (CMD_COMPLETE);
3072         }
3073
3074         /*
3075          * Check to see whether we have good firmware state still or
3076          * need to refresh our port database for this target.
3077          */
3078         target = XS_TGT(xs);
3079         if (IS_FC(isp)) {
3080                 fcparam *fcp = isp->isp_param;
3081                 struct lportdb *lp;
3082 #ifdef  HANDLE_LOOPSTATE_IN_OUTER_LAYERS
3083                 if (fcp->isp_fwstate != FW_READY ||
3084                     fcp->isp_loopstate != LOOP_READY) {
3085                         return (CMD_RQLATER);
3086                 }
3087
3088                 /*
3089                  * If we're not on a Fabric, we can't have a target
3090                  * above FL_PORT_ID-1.
3091                  *
3092                  * If we're on a fabric and *not* connected as an F-port,
3093                  * we can't have a target less than FC_SNS_ID+1. This
3094                  * keeps us from having to sort out the difference between
3095                  * local public loop devices and those which we might get
3096                  * from a switch's database.
3097                  */
3098                 if (fcp->isp_onfabric == 0) {
3099                         if (target >= FL_PORT_ID) {
3100                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3101                                 return (CMD_COMPLETE);
3102                         }
3103                 } else {
3104                         if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
3105                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3106                                 return (CMD_COMPLETE);
3107                         }
3108                         /*
3109                          * We used to exclude having local loop ports
3110                          * at the same time that we have fabric ports.
3111                          * That is, we used to exclude having ports
3112                          * at < FL_PORT_ID if we're FL-port.
3113                          *
3114                          * That's wrong. The only thing that could be
3115                          * dicey is if the switch you're connected to
3116                          * has these local loop ports appear on the
3117                          * fabric and we somehow attach them twice.
3118                          */
3119                 }
3120 #else
3121                 /*
3122                  * Check for f/w being in ready state. If the f/w
3123                  * isn't in ready state, then we don't know our
3124                  * loop ID and the f/w hasn't completed logging
3125                  * into all targets on the loop. If this is the
3126                  * case, then bounce the command. We pretend this is
3127                  * a SELECTION TIMEOUT error if we've never gone to
3128                  * FW_READY state at all- in this case we may not
3129                  * be hooked to a loop at all and we shouldn't hang
3130                  * the machine for this. Otherwise, defer this command
3131                  * until later.
3132                  */
3133                 if (fcp->isp_fwstate != FW_READY) {
3134                         /*
3135                          * Give ourselves at most a 250ms delay.
3136                          */
3137                         if (isp_fclink_test(isp, 250000)) {
3138                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3139                                 if (fcp->loop_seen_once) {
3140                                         return (CMD_RQLATER);
3141                                 } else {
3142                                         return (CMD_COMPLETE);
3143                                 }
3144                         }
3145                 }
3146
3147                 /*
3148                  * If we're not on a Fabric, we can't have a target
3149                  * above FL_PORT_ID-1.
3150                  *
3151                  * If we're on a fabric and *not* connected as an F-port,
3152                  * we can't have a target less than FC_SNS_ID+1. This
3153                  * keeps us from having to sort out the difference between
3154                  * local public loop devices and those which we might get
3155                  * from a switch's database.
3156                  */
3157                 if (fcp->isp_onfabric == 0) {
3158                         if (target >= FL_PORT_ID) {
3159                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3160                                 return (CMD_COMPLETE);
3161                         }
3162                 } else {
3163                         if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
3164                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3165                                 return (CMD_COMPLETE);
3166                         }
3167                         if (fcp->isp_topo != TOPO_F_PORT &&
3168                             target < FL_PORT_ID) {
3169                                 XS_SETERR(xs, HBA_SELTIMEOUT);
3170                                 return (CMD_COMPLETE);
3171                         }
3172                 }
3173
3174                 /*
3175                  * If our loop state is such that we haven't yet received
3176                  * a "Port Database Changed" notification (after a LIP or
3177                  * a Loop Reset or firmware initialization), then defer
3178                  * sending commands for a little while, but only if we've
3179                  * seen a valid loop at one point (otherwise we can get
3180                  * stuck at initialization time).
3181                  */
3182                 if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
3183                         XS_SETERR(xs, HBA_SELTIMEOUT);
3184                         if (fcp->loop_seen_once) {
3185                                 return (CMD_RQLATER);
3186                         } else {
3187                                 return (CMD_COMPLETE);
3188                         }
3189                 }
3190
3191                 /*
3192                  * If we're in the middle of loop or fabric scanning
3193                  * or merging the port databases, retry this command later.
3194                  */
3195                 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC ||
3196                     fcp->isp_loopstate == LOOP_SCANNING_LOOP ||
3197                     fcp->isp_loopstate == LOOP_SYNCING_PDB) {
3198                         return (CMD_RQLATER);
3199                 }
3200
3201                 /*
3202                  * If our loop state is now such that we've just now
3203                  * received a Port Database Change notification, then
3204                  * we have to go off and (re)scan the fabric. We back
3205                  * out and try again later if this doesn't work.
3206                  */
3207                 if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) {
3208                         if (isp_scan_fabric(isp, FC4_SCSI)) {
3209                                 return (CMD_RQLATER);
3210                         }
3211                         if (fcp->isp_fwstate != FW_READY ||
3212                             fcp->isp_loopstate < LOOP_FSCAN_DONE) {
3213                                 return (CMD_RQLATER);
3214                         }
3215                 }
3216
3217                 /*
3218                  * If our loop state is now such that we've just now
3219                  * received a Port Database Change notification, then
3220                  * we have to go off and (re)synchronize our port
3221                  * database.
3222                  */
3223                 if (fcp->isp_loopstate < LOOP_READY) {
3224                         if (isp_pdb_sync(isp)) {
3225                                 return (CMD_RQLATER);
3226                         }
3227                         if (fcp->isp_fwstate != FW_READY ||
3228                             fcp->isp_loopstate != LOOP_READY) {
3229                                 return (CMD_RQLATER);
3230                         }
3231                 }
3232
3233                 /*
3234                  * XXX: Here's were we would cancel any loop_dead flag
3235                  * XXX: also cancel in dead_loop timeout that's running
3236                  */
3237 #endif
3238
3239                 /*
3240                  * Now check whether we should even think about pursuing this.
3241                  */
3242                 lp = &fcp->portdb[target];
3243                 if (lp->valid == 0) {
3244                         XS_SETERR(xs, HBA_SELTIMEOUT);
3245                         return (CMD_COMPLETE);
3246                 }
3247                 if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
3248                         isp_prt(isp, ISP_LOGDEBUG2,
3249                             "Target %d does not have target service", target);
3250                         XS_SETERR(xs, HBA_SELTIMEOUT);
3251                         return (CMD_COMPLETE);
3252                 }
3253                 /*
3254                  * Now turn target into what the actual Loop ID is.
3255                  */
3256                 target = lp->loopid;
3257         }
3258
3259         /*
3260          * Next check to see if any HBA or Device
3261          * parameters need to be updated.
3262          */
3263         if (isp->isp_update != 0) {
3264                 isp_update(isp);
3265         }
3266
3267         if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
3268                 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
3269                 XS_SETERR(xs, HBA_BOTCH);
3270                 return (CMD_EAGAIN);
3271         }
3272
3273         /*
3274          * Now see if we need to synchronize the ISP with respect to anything.
3275          * We do dual duty here (cough) for synchronizing for busses other
3276          * than which we got here to send a command to.
3277          */
3278         reqp = (ispreq_t *) local;
3279         if (isp->isp_sendmarker) {
3280                 uint8_t n = (IS_DUALBUS(isp)? 2: 1);
3281                 /*
3282                  * Check ports to send markers for...
3283                  */
3284                 for (i = 0; i < n; i++) {
3285                         if ((isp->isp_sendmarker & (1 << i)) == 0) {
3286                                 continue;
3287                         }
3288                         MEMZERO((void *) reqp, QENTRY_LEN);
3289                         reqp->req_header.rqs_entry_count = 1;
3290                         reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
3291                         reqp->req_modifier = SYNC_ALL;
3292                         reqp->req_target = i << 7;      /* insert bus number */
3293                         isp_put_request(isp, reqp, qep);
3294                         ISP_ADD_REQUEST(isp, nxti);
3295                         isp->isp_sendmarker &= ~(1 << i);
3296                         if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) {
3297                                 isp_prt(isp, ISP_LOGDEBUG0,
3298                                     "Request Queue Overflow+");
3299                                 XS_SETERR(xs, HBA_BOTCH);
3300                                 return (CMD_EAGAIN);
3301                         }
3302                 }
3303         }
3304
3305         MEMZERO((void *)reqp, QENTRY_LEN);
3306         reqp->req_header.rqs_entry_count = 1;
3307         if (IS_FC(isp)) {
3308                 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
3309         } else {
3310                 if (XS_CDBLEN(xs) > 12)
3311                         reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
3312                 else
3313                         reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
3314         }
3315         /* reqp->req_header.rqs_flags = 0; */
3316         /* reqp->req_header.rqs_seqno = 0; */
3317         if (IS_FC(isp)) {
3318                 /*
3319                  * See comment in isp_intr
3320                  */
3321                 /* XS_RESID(xs) = 0; */
3322
3323                 /*
3324                  * Fibre Channel always requires some kind of tag.
3325                  * The Qlogic drivers seem be happy not to use a tag,
3326                  * but this breaks for some devices (IBM drives).
3327                  */
3328                 if (XS_TAG_P(xs)) {
3329                         ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
3330                 } else {
3331                         /*
3332                          * If we don't know what tag to use, use HEAD OF QUEUE
3333                          * for Request Sense or Simple.
3334                          */
3335                         if (XS_CDBP(xs)[0] == 0x3)      /* REQUEST SENSE */
3336                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
3337                         else
3338                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
3339                 }
3340         } else {
3341                 sdparam *sdp = (sdparam *)isp->isp_param;
3342                 sdp += XS_CHANNEL(xs);
3343                 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
3344                     XS_TAG_P(xs)) {
3345                         reqp->req_flags = XS_TAG_TYPE(xs);
3346                 }
3347         }
3348         if (IS_SCSI(isp)) {
3349                 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
3350                 reqp->req_lun_trn = XS_LUN(xs);
3351                 reqp->req_cdblen = XS_CDBLEN(xs);
3352         } else if (IS_2KLOGIN(isp)) {
3353                 ((ispreqt2e_t *)reqp)->req_target = target;
3354                 ((ispreqt2e_t *)reqp)->req_scclun = XS_LUN(xs);
3355         } else if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
3356                 ((ispreqt2_t *)reqp)->req_target = target;
3357                 ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
3358         } else {
3359                 ((ispreqt2_t *)reqp)->req_target = target;
3360                 ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
3361         }
3362         MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
3363
3364         reqp->req_time = XS_TIME(xs) / 1000;
3365         if (reqp->req_time == 0 && XS_TIME(xs)) {
3366                 reqp->req_time = 1;
3367         }
3368
3369         if (isp_save_xs(isp, xs, &handle)) {
3370                 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
3371                 XS_SETERR(xs, HBA_BOTCH);
3372                 return (CMD_EAGAIN);
3373         }
3374         reqp->req_handle = handle;
3375
3376         /*
3377          * Set up DMA and/or do any bus swizzling of the request entry
3378          * so that the Qlogic F/W understands what is being asked of it.
3379          */
3380         i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
3381         if (i != CMD_QUEUED) {
3382                 isp_destroy_handle(isp, handle);
3383                 /*
3384                  * dmasetup sets actual error in packet, and
3385                  * return what we were given to return.
3386                  */
3387                 return (i);
3388         }
3389         XS_SETERR(xs, HBA_NOERROR);
3390         isp_prt(isp, ISP_LOGDEBUG2,
3391             "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
3392             XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
3393             (long) XS_XFRLEN(xs));
3394         ISP_ADD_REQUEST(isp, nxti);
3395         isp->isp_nactive++;
3396         return (CMD_QUEUED);
3397 }
3398
3399 /*
3400  * isp control
3401  * Locks (ints blocked) assumed held.
3402  */
3403
3404 int
3405 isp_control(ispsoftc_t *isp, ispctl_t ctl, void *arg)
3406 {
3407         XS_T *xs;
3408         mbreg_t mbs;
3409         int bus, tgt;
3410         uint16_t handle;
3411
3412         MEMZERO(&mbs, sizeof (mbs));
3413
3414         switch (ctl) {
3415         default:
3416                 isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
3417                 break;
3418
3419         case ISPCTL_RESET_BUS:
3420                 /*
3421                  * Issue a bus reset.
3422                  */
3423                 mbs.param[0] = MBOX_BUS_RESET;
3424                 mbs.param[2] = 0;
3425                 if (IS_SCSI(isp)) {
3426                         mbs.param[1] =
3427                             ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
3428                         if (mbs.param[1] < 2)
3429                                 mbs.param[1] = 2;
3430                         bus = *((int *) arg);
3431                         if (IS_DUALBUS(isp))
3432                                 mbs.param[2] = bus;
3433                 } else {
3434                         mbs.param[1] = 10;
3435                         bus = 0;
3436                 }
3437                 isp->isp_sendmarker |= (1 << bus);
3438                 isp_mboxcmd(isp, &mbs, MBLOGALL);
3439                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3440                         break;
3441                 }
3442                 isp_prt(isp, ISP_LOGINFO,
3443                     "driver initiated bus reset of bus %d", bus);
3444                 return (0);
3445
3446         case ISPCTL_RESET_DEV:
3447                 tgt = (*((int *) arg)) & 0xffff;
3448                 bus = (*((int *) arg)) >> 16;
3449                 mbs.param[0] = MBOX_ABORT_TARGET;
3450                 if (IS_SCSI(isp)) {
3451                         mbs.param[1] = (tgt << 8) | (bus << 15);
3452                 } else {
3453                         if (IS_2KLOGIN(isp)) {
3454                                 mbs.param[1] = tgt;
3455                                 mbs.obits |= (1 << 10);
3456                         } else {
3457                                 mbs.param[1] = (tgt << 8);
3458                         }
3459                 }
3460                 mbs.param[2] = 3;       /* 'delay', in seconds */
3461                 isp_mboxcmd(isp, &mbs, MBLOGALL);
3462                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3463                         break;
3464                 }
3465                 isp_prt(isp, ISP_LOGINFO,
3466                     "Target %d on Bus %d Reset Succeeded", tgt, bus);
3467                 isp->isp_sendmarker |= (1 << bus);
3468                 return (0);
3469
3470         case ISPCTL_ABORT_CMD:
3471                 xs = (XS_T *) arg;
3472                 tgt = XS_TGT(xs);
3473                 handle = isp_find_handle(isp, xs);
3474                 if (handle == 0) {
3475                         isp_prt(isp, ISP_LOGWARN,
3476                             "cannot find handle for command to abort");
3477                         break;
3478                 }
3479                 bus = XS_CHANNEL(xs);
3480                 mbs.param[0] = MBOX_ABORT;
3481                 if (IS_FC(isp)) {
3482                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)  {
3483                                 if (IS_2KLOGIN(isp)) {
3484                                         mbs.param[1] = tgt;
3485                                 } else {
3486                                         mbs.param[1] = tgt << 8;
3487                                 }
3488                                 mbs.param[4] = 0;
3489                                 mbs.param[5] = 0;
3490                                 mbs.param[6] = XS_LUN(xs);
3491                         } else {
3492                                 mbs.param[1] = tgt << 8 | XS_LUN(xs);
3493                         }
3494                 } else {
3495                         mbs.param[1] =
3496                             (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
3497                 }
3498                 mbs.param[3] = 0;
3499                 mbs.param[2] = handle;
3500                 isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
3501                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3502                         return (0);
3503                 }
3504                 /*
3505                  * XXX: Look for command in the REQUEST QUEUE. That is,
3506                  * XXX: It hasen't been picked up by firmware yet.
3507                  */
3508                 break;
3509
3510         case ISPCTL_UPDATE_PARAMS:
3511
3512                 isp_update(isp);
3513                 return (0);
3514
3515         case ISPCTL_FCLINK_TEST:
3516
3517                 if (IS_FC(isp)) {
3518                         int usdelay = *((int *) arg);
3519                         if (usdelay == 0) {
3520                                 usdelay =  250000;
3521                         }
3522                         return (isp_fclink_test(isp, usdelay));
3523                 }
3524                 break;
3525
3526         case ISPCTL_SCAN_FABRIC:
3527
3528                 if (IS_FC(isp)) {
3529                         int ftype = (arg)? *((int *) arg) : FC4_SCSI;
3530                         return (isp_scan_fabric(isp, ftype));
3531                 }
3532                 break;
3533
3534         case ISPCTL_SCAN_LOOP:
3535
3536                 if (IS_FC(isp)) {
3537                         return (isp_scan_loop(isp));
3538                 }
3539                 break;
3540
3541         case ISPCTL_PDB_SYNC:
3542
3543                 if (IS_FC(isp)) {
3544                         return (isp_pdb_sync(isp));
3545                 }
3546                 break;
3547
3548         case ISPCTL_SEND_LIP:
3549
3550                 if (IS_FC(isp)) {
3551                         mbs.param[0] = MBOX_INIT_LIP;
3552                         isp_mboxcmd(isp, &mbs, MBLOGALL);
3553                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
3554                                 return (0);
3555                         }
3556                 }
3557                 break;
3558
3559         case ISPCTL_GET_POSMAP:
3560
3561                 if (IS_FC(isp) && arg) {
3562                         return (isp_getmap(isp, arg));
3563                 }
3564                 break;
3565
3566
3567         case ISPCTL_GET_PDB:
3568                 if (IS_FC(isp) && arg) {
3569                         int id = *((int *)arg);
3570                         isp_pdb_t *pdb = arg;
3571                         return (isp_getpdb(isp, id, pdb));
3572                 }
3573                 break;
3574
3575         case ISPCTL_RUN_MBOXCMD:
3576
3577                 isp_mboxcmd(isp, arg, MBLOGALL);
3578                 return(0);
3579
3580 #ifdef  ISP_TARGET_MODE
3581         case ISPCTL_TOGGLE_TMODE:
3582         {
3583
3584                 /*
3585                  * We don't check/set against role here- that's the
3586                  * responsibility for the outer layer to coordinate.
3587                  */
3588                 if (IS_SCSI(isp)) {
3589                         int param = *(int *)arg;
3590                         mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
3591                         mbs.param[1] = param & 0xffff;
3592                         mbs.param[2] = param >> 16;
3593                         isp_mboxcmd(isp, &mbs, MBLOGALL);
3594                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
3595                                 break;
3596                         }
3597                 }
3598                 return (0);
3599         }
3600 #endif
3601         }
3602         return (-1);
3603 }
3604
3605 /*
3606  * Interrupt Service Routine(s).
3607  *
3608  * External (OS) framework has done the appropriate locking,
3609  * and the locking will be held throughout this function.
3610  */
3611
3612 /*
3613  * Limit our stack depth by sticking with the max likely number
3614  * of completions on a request queue at any one time.
3615  */
3616 #ifndef MAX_REQUESTQ_COMPLETIONS
3617 #define MAX_REQUESTQ_COMPLETIONS        64
3618 #endif
3619
3620 void
3621 isp_intr(ispsoftc_t *isp, uint16_t isr, uint16_t sema, uint16_t mbox)
3622 {
3623         XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
3624         uint16_t iptr, optr, junk;
3625         int i, nlooked = 0, ndone = 0;
3626
3627 again:
3628         /*
3629          * Is this a mailbox related interrupt?
3630          * The mailbox semaphore will be nonzero if so.
3631          */
3632         if (sema) {
3633                 if (mbox & 0x4000) {
3634                         isp->isp_intmboxc++;
3635                         if (isp->isp_mboxbsy) {
3636                                 int i = 0, obits = isp->isp_obits;
3637                                 isp->isp_mboxtmp[i++] = mbox;
3638                                 for (i = 1; i < MAX_MAILBOX(isp); i++) {
3639                                         if ((obits & (1 << i)) == 0) {
3640                                                 continue;
3641                                         }
3642                                         isp->isp_mboxtmp[i] =
3643                                             ISP_READ(isp, MBOX_OFF(i));
3644                                 }
3645                                 if (isp->isp_mbxwrk0) {
3646                                         if (isp_mbox_continue(isp) == 0) {
3647                                                 return;
3648                                         }
3649                                 }
3650                                 MBOX_NOTIFY_COMPLETE(isp);
3651                         } else {
3652                                 isp_prt(isp, ISP_LOGWARN,
3653                                     "Mbox Command Async (0x%x) with no waiters",
3654                                     mbox);
3655                         }
3656                 } else if (isp_parse_async(isp, mbox) < 0) {
3657                         return;
3658                 }
3659                 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
3660                     isp->isp_state != ISP_RUNSTATE) {
3661                         ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3662                         ISP_WRITE(isp, BIU_SEMA, 0);
3663                         return;
3664                 }
3665         }
3666
3667         /*
3668          * We can't be getting this now.
3669          */
3670         if (isp->isp_state != ISP_RUNSTATE) {
3671                 isp_prt(isp, ISP_LOGWARN,
3672                     "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
3673                 /*
3674                  * Thank you very much!  *Burrrp*!
3675                  */
3676                 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp,
3677                     READ_RESPONSE_QUEUE_IN_POINTER(isp));
3678
3679                 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3680                 ISP_WRITE(isp, BIU_SEMA, 0);
3681                 return;
3682         }
3683
3684         /*
3685          * Get the current Response Queue Out Pointer.
3686          *
3687          * If we're a 2300, we can ask what hardware what it thinks.
3688          */
3689         if (IS_23XX(isp)) {
3690                 optr = ISP_READ(isp, isp->isp_respoutrp);
3691                 /*
3692                  * Debug: to be taken out eventually
3693                  */
3694                 if (isp->isp_residx != optr) {
3695                         isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x",
3696                             optr, isp->isp_residx);
3697                 }
3698         } else {
3699                 optr = isp->isp_residx;
3700         }
3701
3702         /*
3703          * You *must* read the Response Queue In Pointer
3704          * prior to clearing the RISC interrupt.
3705          *
3706          * Debounce the 2300 if revision less than 2.
3707          */
3708         if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
3709                 i = 0;
3710                 do {
3711                         iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3712                         junk = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3713                 } while (junk != iptr && ++i < 1000);
3714
3715                 if (iptr != junk) {
3716                         ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3717                         isp_prt(isp, ISP_LOGWARN,
3718                             "Response Queue Out Pointer Unstable (%x, %x)",
3719                             iptr, junk);
3720                         return;
3721                 }
3722         } else {
3723                 iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3724         }
3725         isp->isp_resodx = iptr;
3726
3727
3728         if (optr == iptr && sema == 0) {
3729                 /*
3730                  * There are a lot of these- reasons unknown- mostly on
3731                  * faster Alpha machines.
3732                  *
3733                  * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
3734                  * make sure the old interrupt went away (to avoid 'ringing'
3735                  * effects), but that didn't stop this from occurring.
3736                  */
3737                 if (IS_23XX(isp)) {
3738                         USEC_DELAY(100);
3739                         iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
3740                         junk = ISP_READ(isp, BIU_R2HSTSLO);
3741                 } else {
3742                         junk = ISP_READ(isp, BIU_ISR);
3743                 }
3744                 if (optr == iptr) {
3745                         if (IS_23XX(isp)) {
3746                                 ;
3747                         } else {
3748                                 sema = ISP_READ(isp, BIU_SEMA);
3749                                 mbox = ISP_READ(isp, OUTMAILBOX0);
3750                                 if ((sema & 0x3) && (mbox & 0x8000)) {
3751                                         goto again;
3752                                 }
3753                         }
3754                         isp->isp_intbogus++;
3755                         isp_prt(isp, ISP_LOGDEBUG1,
3756                             "bogus intr- isr %x (%x) iptr %x optr %x",
3757                             isr, junk, iptr, optr);
3758                 }
3759         }
3760         isp->isp_resodx = iptr;
3761         ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
3762         ISP_WRITE(isp, BIU_SEMA, 0);
3763
3764         if (isp->isp_rspbsy) {
3765                 return;
3766         }
3767         isp->isp_rspbsy = 1;
3768
3769         while (optr != iptr) {
3770                 ispstatusreq_t local, *sp = &local;
3771                 isphdr_t *hp;
3772                 int type;
3773                 uint16_t oop;
3774                 int buddaboom = 0;
3775
3776                 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
3777                 oop = optr;
3778                 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
3779                 nlooked++;
3780  read_again:
3781                 /*
3782                  * Synchronize our view of this response queue entry.
3783                  */
3784                 MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
3785
3786                 type = isp_get_response_type(isp, hp);
3787
3788                 if (type == RQSTYPE_RESPONSE) {
3789                         isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3790                 } else if (type == RQSTYPE_RIO2) {
3791                         isp_rio2_t rio;
3792                         isp_get_rio2(isp, (isp_rio2_t *) hp, &rio);
3793                         for (i = 0; i < rio.req_header.rqs_seqno; i++) {
3794                                 isp_fastpost_complete(isp, rio.req_handles[i]);
3795                         }
3796                         if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno)
3797                                 isp->isp_fpcchiwater = rio.req_header.rqs_seqno;
3798                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
3799                         continue;
3800                 } else {
3801                         /*
3802                          * Somebody reachable via isp_handle_other_response
3803                          * may have updated the response queue pointers for
3804                          * us, so we reload our goal index.
3805                          */
3806                         int i = isp_handle_other_response(isp, type, hp, &optr);
3807                         if (i < 0) {
3808                                 goto read_again;
3809                         } else if (i > 0) {
3810                                 iptr = isp->isp_resodx;
3811                                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
3812                                 continue;
3813                         }
3814
3815                         /*
3816                          * After this point, we'll just look at the header as
3817                          * we don't know how to deal with the rest of the
3818                          * response.
3819                          */
3820                         isp_get_response(isp, (ispstatusreq_t *) hp, sp);
3821
3822                         /*
3823                          * It really has to be a bounced request just copied
3824                          * from the request queue to the response queue. If
3825                          * not, something bad has happened.
3826                          */
3827                         if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
3828                                 isp_prt(isp, ISP_LOGERR, notresp,
3829                                     sp->req_header.rqs_entry_type, oop, optr,
3830                                     nlooked);
3831                                 if (isp->isp_dblev & ISP_LOGDEBUG0) {
3832                                         isp_print_bytes(isp, "Queue Entry",
3833                                             QENTRY_LEN, sp);
3834                                 }
3835                                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
3836                                 continue;
3837                         }
3838                         buddaboom = 1;
3839                 }
3840
3841                 if (sp->req_header.rqs_flags & 0xf) {
3842 #define _RQS_OFLAGS     \
3843         ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
3844                         if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
3845                                 isp_prt(isp, ISP_LOGWARN,
3846                                     "continuation segment");
3847                                 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3848                                 continue;
3849                         }
3850                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3851                                 isp_prt(isp, ISP_LOGDEBUG1,
3852                                     "internal queues full");
3853                                 /*
3854                                  * We'll synthesize a QUEUE FULL message below.
3855                                  */
3856                         }
3857                         if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
3858                                 isp_prt(isp, ISP_LOGERR,  "bad header flag");
3859                                 buddaboom++;
3860                         }
3861                         if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
3862                                 isp_prt(isp, ISP_LOGERR, "bad request packet");
3863                                 buddaboom++;
3864                         }
3865                         if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
3866                                 isp_prt(isp, ISP_LOGERR,
3867                                     "unknown flags (0x%x) in response",
3868                                     sp->req_header.rqs_flags);
3869                                 buddaboom++;
3870                         }
3871 #undef  _RQS_OFLAGS
3872                 }
3873                 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
3874                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
3875                         isp_prt(isp, ISP_LOGERR,
3876                             "bad request handle %d (type 0x%x, flags 0x%x)",
3877                             sp->req_handle, sp->req_header.rqs_entry_type,
3878                             sp->req_header.rqs_flags);
3879                         WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3880                         continue;
3881                 }
3882                 xs = isp_find_xs(isp, sp->req_handle);
3883                 if (xs == NULL) {
3884                         uint8_t ts = sp->req_completion_status & 0xff;
3885                         MEMZERO(hp, QENTRY_LEN);        /* PERF */
3886                         /*
3887                          * Only whine if this isn't the expected fallout of
3888                          * aborting the command.
3889                          */
3890                         if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
3891                                 isp_prt(isp, ISP_LOGERR,
3892                                     "cannot find handle 0x%x (type 0x%x)",
3893                                     sp->req_handle,
3894                                     sp->req_header.rqs_entry_type);
3895                         } else if (ts != RQCS_ABORTED) {
3896                                 isp_prt(isp, ISP_LOGERR,
3897                                     "cannot find handle 0x%x (status 0x%x)",
3898                                     sp->req_handle, ts);
3899                         }
3900                         WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
3901                         continue;
3902                 }
3903                 isp_destroy_handle(isp, sp->req_handle);
3904                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
3905                         XS_SETERR(xs, HBA_BUSRESET);
3906                         isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
3907                 }
3908                 if (buddaboom) {
3909                         XS_SETERR(xs, HBA_BOTCH);
3910                 }
3911
3912                 if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
3913                         /*
3914                          * Fibre Channel F/W doesn't say we got status
3915                          * if there's Sense Data instead. I guess they
3916                          * think it goes w/o saying.
3917                          */
3918                         sp->req_state_flags |= RQSF_GOT_STATUS;
3919                 }
3920                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
3921                         *XS_STSP(xs) = sp->req_scsi_status & 0xff;
3922                 }
3923
3924                 switch (sp->req_header.rqs_entry_type) {
3925                 case RQSTYPE_RESPONSE:
3926                         XS_SET_STATE_STAT(isp, xs, sp);
3927                         isp_parse_status(isp, sp, xs);
3928                         if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
3929                             (*XS_STSP(xs) == SCSI_BUSY)) {
3930                                 XS_SETERR(xs, HBA_TGTBSY);
3931                         }
3932                         if (IS_SCSI(isp)) {
3933                                 XS_RESID(xs) = sp->req_resid;
3934                                 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3935                                     (*XS_STSP(xs) == SCSI_CHECK) &&
3936                                     (sp->req_state_flags & RQSF_GOT_SENSE)) {
3937                                         XS_SAVE_SENSE(xs, sp);
3938                                 }
3939                                 /*
3940                                  * A new synchronous rate was negotiated for
3941                                  * this target. Mark state such that we'll go
3942                                  * look up that which has changed later.
3943                                  */
3944                                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
3945                                         int t = XS_TGT(xs);
3946                                         sdparam *sdp = isp->isp_param;
3947                                         sdp += XS_CHANNEL(xs);
3948                                         sdp->isp_devparam[t].dev_refresh = 1;
3949                                         isp->isp_update |=
3950                                             (1 << XS_CHANNEL(xs));
3951                                 }
3952                         } else {
3953                                 if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
3954                                         XS_RESID(xs) = 0;
3955                                 } else if (sp->req_scsi_status & RQCS_RESID) {
3956                                         XS_RESID(xs) = sp->req_resid;
3957                                 } else {
3958                                         XS_RESID(xs) = 0;
3959                                 }
3960                                 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
3961                                     (*XS_STSP(xs) == SCSI_CHECK) &&
3962                                     (sp->req_scsi_status & RQCS_SV)) {
3963                                         XS_SAVE_SENSE(xs, sp);
3964                                         /* solely for the benefit of debug */
3965                                         sp->req_state_flags |= RQSF_GOT_SENSE;
3966                                 }
3967                         }
3968                         isp_prt(isp, ISP_LOGDEBUG2,
3969                            "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
3970                            (long) sp->req_resid);
3971                         break;
3972                 case RQSTYPE_REQUEST:
3973                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
3974                                 /*
3975                                  * Force Queue Full status.
3976                                  */
3977                                 *XS_STSP(xs) = SCSI_QFULL;
3978                                 XS_SETERR(xs, HBA_NOERROR);
3979                         } else if (XS_NOERR(xs)) {
3980                                 /*
3981                                  * ????
3982                                  */
3983                                 isp_prt(isp, ISP_LOGDEBUG0,
3984                                     "Request Queue Entry bounced back");
3985                                 XS_SETERR(xs, HBA_BOTCH);
3986                         }
3987                         XS_RESID(xs) = XS_XFRLEN(xs);
3988                         break;
3989                 default:
3990                         isp_prt(isp, ISP_LOGWARN,
3991                             "unhandled response queue type 0x%x",
3992                             sp->req_header.rqs_entry_type);
3993                         if (XS_NOERR(xs)) {
3994                                 XS_SETERR(xs, HBA_BOTCH);
3995                         }
3996                         break;
3997                 }
3998
3999                 /*
4000                  * Free any DMA resources. As a side effect, this may
4001                  * also do any cache flushing necessary for data coherence.                      */
4002                 if (XS_XFRLEN(xs)) {
4003                         ISP_DMAFREE(isp, xs, sp->req_handle);
4004                 }
4005
4006                 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
4007                     ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
4008                     (*XS_STSP(xs) != SCSI_GOOD)))) {
4009                         char skey;
4010                         if (sp->req_state_flags & RQSF_GOT_SENSE) {
4011                                 skey = XS_SNSKEY(xs) & 0xf;
4012                                 if (skey < 10)
4013                                         skey += '0';
4014                                 else
4015                                         skey += 'a' - 10;
4016                         } else if (*XS_STSP(xs) == SCSI_CHECK) {
4017                                 skey = '?';
4018                         } else {
4019                                 skey = '.';
4020                         }
4021                         isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
4022                             XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
4023                             *XS_STSP(xs), skey, XS_ERR(xs));
4024                 }
4025
4026                 if (isp->isp_nactive > 0)
4027                     isp->isp_nactive--;
4028                 complist[ndone++] = xs; /* defer completion call until later */
4029                 MEMZERO(hp, QENTRY_LEN);        /* PERF */
4030                 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
4031                         break;
4032                 }
4033         }
4034
4035         /*
4036          * If we looked at any commands, then it's valid to find out
4037          * what the outpointer is. It also is a trigger to update the
4038          * ISP's notion of what we've seen so far.
4039          */
4040         if (nlooked) {
4041                 WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
4042                 /*
4043                  * While we're at it, read the requst queue out pointer.
4044                  */
4045                 isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
4046                 if (isp->isp_rscchiwater < ndone)
4047                         isp->isp_rscchiwater = ndone;
4048         }
4049
4050         isp->isp_residx = optr;
4051         isp->isp_rspbsy = 0;
4052         for (i = 0; i < ndone; i++) {
4053                 xs = complist[i];
4054                 if (xs) {
4055                         isp->isp_rsltccmplt++;
4056                         isp_done(xs);
4057                 }
4058         }
4059 }
4060
4061 /*
4062  * Support routines.
4063  */
4064
4065 static int
4066 isp_parse_async(ispsoftc_t *isp, uint16_t mbox)
4067 {
4068         int rval = 0;
4069         int bus;
4070
4071         if (IS_DUALBUS(isp)) {
4072                 bus = ISP_READ(isp, OUTMAILBOX6);
4073         } else {
4074                 bus = 0;
4075         }
4076         isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
4077
4078         switch (mbox) {
4079         case ASYNC_BUS_RESET:
4080                 isp->isp_sendmarker |= (1 << bus);
4081 #ifdef  ISP_TARGET_MODE
4082                 if (isp_target_async(isp, bus, mbox))
4083                         rval = -1;
4084 #endif
4085                 isp_async(isp, ISPASYNC_BUS_RESET, &bus);
4086                 break;
4087         case ASYNC_SYSTEM_ERROR:
4088 #ifdef  ISP_FW_CRASH_DUMP
4089                 /*
4090                  * If we have crash dumps enabled, it's up to the handler
4091                  * for isp_async to reinit stuff and restart the firmware
4092                  * after performing the crash dump. The reason we do things
4093                  * this way is that we may need to activate a kernel thread
4094                  * to do all the crash dump goop.
4095                  */
4096                 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4097 #else
4098                 isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4099                 isp_reinit(isp);
4100                 isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
4101 #endif
4102                 rval = -1;
4103                 break;
4104
4105         case ASYNC_RQS_XFER_ERR:
4106                 isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
4107                 break;
4108
4109         case ASYNC_RSP_XFER_ERR:
4110                 isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
4111                 break;
4112
4113         case ASYNC_QWAKEUP:
4114                 /*
4115                  * We've just been notified that the Queue has woken up.
4116                  * We don't need to be chatty about this- just unlatch things
4117                  * and move on.
4118                  */
4119                 mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp);
4120                 break;
4121
4122         case ASYNC_TIMEOUT_RESET:
4123                 isp_prt(isp, ISP_LOGWARN,
4124                     "timeout initiated SCSI bus reset of bus %d", bus);
4125                 isp->isp_sendmarker |= (1 << bus);
4126 #ifdef  ISP_TARGET_MODE
4127                 if (isp_target_async(isp, bus, mbox))
4128                         rval = -1;
4129 #endif
4130                 break;
4131
4132         case ASYNC_DEVICE_RESET:
4133                 isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
4134                 isp->isp_sendmarker |= (1 << bus);
4135 #ifdef  ISP_TARGET_MODE
4136                 if (isp_target_async(isp, bus, mbox))
4137                         rval = -1;
4138 #endif
4139                 break;
4140
4141         case ASYNC_EXTMSG_UNDERRUN:
4142                 isp_prt(isp, ISP_LOGWARN, "extended message underrun");
4143                 break;
4144
4145         case ASYNC_SCAM_INT:
4146                 isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
4147                 break;
4148
4149         case ASYNC_HUNG_SCSI:
4150                 isp_prt(isp, ISP_LOGERR,
4151                     "stalled SCSI Bus after DATA Overrun");
4152                 /* XXX: Need to issue SCSI reset at this point */
4153                 break;
4154
4155         case ASYNC_KILLED_BUS:
4156                 isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
4157                 break;
4158
4159         case ASYNC_BUS_TRANSIT:
4160                 mbox = ISP_READ(isp, OUTMAILBOX2);
4161                 switch (mbox & 0x1c00) {
4162                 case SXP_PINS_LVD_MODE:
4163                         isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
4164                         SDPARAM(isp)->isp_diffmode = 0;
4165                         SDPARAM(isp)->isp_ultramode = 0;
4166                         SDPARAM(isp)->isp_lvdmode = 1;
4167                         break;
4168                 case SXP_PINS_HVD_MODE:
4169                         isp_prt(isp, ISP_LOGINFO,
4170                             "Transition to Differential mode");
4171                         SDPARAM(isp)->isp_diffmode = 1;
4172                         SDPARAM(isp)->isp_ultramode = 0;
4173                         SDPARAM(isp)->isp_lvdmode = 0;
4174                         break;
4175                 case SXP_PINS_SE_MODE:
4176                         isp_prt(isp, ISP_LOGINFO,
4177                             "Transition to Single Ended mode");
4178                         SDPARAM(isp)->isp_diffmode = 0;
4179                         SDPARAM(isp)->isp_ultramode = 1;
4180                         SDPARAM(isp)->isp_lvdmode = 0;
4181                         break;
4182                 default:
4183                         isp_prt(isp, ISP_LOGWARN,
4184                             "Transition to Unknown Mode 0x%x", mbox);
4185                         break;
4186                 }
4187                 /*
4188                  * XXX: Set up to renegotiate again!
4189                  */
4190                 /* Can only be for a 1080... */
4191                 isp->isp_sendmarker |= (1 << bus);
4192                 break;
4193
4194         /*
4195          * We can use bus, which will always be zero for FC cards,
4196          * as a mailbox pattern accumulator to be checked below.
4197          */
4198         case ASYNC_RIO5:
4199                 bus = 0x1ce;    /* outgoing mailbox regs 1-3, 6-7 */
4200                 break;
4201
4202         case ASYNC_RIO4:
4203                 bus = 0x14e;    /* outgoing mailbox regs 1-3, 6 */
4204                 break;
4205
4206         case ASYNC_RIO3:
4207                 bus = 0x10e;    /* outgoing mailbox regs 1-3 */
4208                 break;
4209
4210         case ASYNC_RIO2:
4211                 bus = 0x106;    /* outgoing mailbox regs 1-2 */
4212                 break;
4213
4214         case ASYNC_RIO1:
4215         case ASYNC_CMD_CMPLT:
4216                 bus = 0x102;    /* outgoing mailbox regs 1 */
4217                 break;
4218
4219         case ASYNC_RIO_RESP:
4220                 return (rval);
4221
4222         case ASYNC_CTIO_DONE:
4223         {
4224 #ifdef  ISP_TARGET_MODE
4225                 int handle =
4226                     (ISP_READ(isp, OUTMAILBOX2) << 16) |
4227                     (ISP_READ(isp, OUTMAILBOX1));
4228                 if (isp_target_async(isp, handle, mbox)) {
4229                         rval = -1;
4230                 } else {
4231                         /* count it as a fast posting intr */
4232                         isp->isp_fphccmplt++;
4233                 }
4234 #else
4235                 isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
4236                 isp->isp_fphccmplt++;   /* count it as a fast posting intr */
4237 #endif
4238                 break;
4239         }
4240         case ASYNC_LIP_F8:
4241         case ASYNC_LIP_OCCURRED:
4242                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4243                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4244                 isp->isp_sendmarker = 1;
4245                 isp_mark_getpdb_all(isp);
4246                 isp_async(isp, ISPASYNC_LIP, NULL);
4247 #ifdef  ISP_TARGET_MODE
4248                 if (isp_target_async(isp, bus, mbox))
4249                         rval = -1;
4250 #endif
4251                 /*
4252                  * We've had problems with data corruption occuring on
4253                  * commands that complete (with no apparent error) after
4254                  * we receive a LIP. This has been observed mostly on
4255                  * Local Loop topologies. To be safe, let's just mark
4256                  * all active commands as dead.
4257                  */
4258                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
4259                     FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
4260                         int i, j;
4261                         for (i = j = 0; i < isp->isp_maxcmds; i++) {
4262                                 XS_T *xs;
4263                                 xs = isp->isp_xflist[i];
4264                                 if (xs != NULL) {
4265                                         j++;
4266                                         XS_SETERR(xs, HBA_BUSRESET);
4267                                 }
4268                         }
4269                         if (j) {
4270                                 isp_prt(isp, ISP_LOGERR,
4271                                     "LIP destroyed %d active commands", j);
4272                         }
4273                 }
4274                 break;
4275
4276         case ASYNC_LOOP_UP:
4277                 isp->isp_sendmarker = 1;
4278                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4279                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4280                 isp_mark_getpdb_all(isp);
4281                 isp_async(isp, ISPASYNC_LOOP_UP, NULL);
4282 #ifdef  ISP_TARGET_MODE
4283                 if (isp_target_async(isp, bus, mbox))
4284                         rval = -1;
4285 #endif
4286                 break;
4287
4288         case ASYNC_LOOP_DOWN:
4289                 isp->isp_sendmarker = 1;
4290                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4291                 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
4292                 isp_mark_getpdb_all(isp);
4293                 isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
4294 #ifdef  ISP_TARGET_MODE
4295                 if (isp_target_async(isp, bus, mbox))
4296                         rval = -1;
4297 #endif
4298                 break;
4299
4300         case ASYNC_LOOP_RESET:
4301                 isp->isp_sendmarker = 1;
4302                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4303                 FCPARAM(isp)->isp_loopstate = LOOP_NIL;
4304                 isp_mark_getpdb_all(isp);
4305                 isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
4306 #ifdef  ISP_TARGET_MODE
4307                 if (isp_target_async(isp, bus, mbox))
4308                         rval = -1;
4309 #endif
4310                 break;
4311
4312         case ASYNC_PDB_CHANGED:
4313                 isp->isp_sendmarker = 1;
4314                 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4315                 isp_mark_getpdb_all(isp);
4316                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
4317                 break;
4318
4319         case ASYNC_CHANGE_NOTIFY:
4320                 /*
4321                  * Not correct, but it will force us to rescan the loop.
4322                  */
4323                 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4324                 isp_mark_getpdb_all(isp);
4325                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
4326                 break;
4327
4328         case ASYNC_PTPMODE:
4329                 if (FCPARAM(isp)->isp_onfabric)
4330                         FCPARAM(isp)->isp_topo = TOPO_F_PORT;
4331                 else
4332                         FCPARAM(isp)->isp_topo = TOPO_N_PORT;
4333                 isp_mark_getpdb_all(isp);
4334                 isp->isp_sendmarker = 1;
4335                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4336                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4337                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4338 #ifdef  ISP_TARGET_MODE
4339                 if (isp_target_async(isp, bus, mbox))
4340                         rval = -1;
4341 #endif
4342                 isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
4343                 break;
4344
4345         case ASYNC_CONNMODE:
4346                 mbox = ISP_READ(isp, OUTMAILBOX1);
4347                 isp_mark_getpdb_all(isp);
4348                 switch (mbox) {
4349                 case ISP_CONN_LOOP:
4350                         isp_prt(isp, ISP_LOGINFO,
4351                             "Point-to-Point -> Loop mode");
4352                         break;
4353                 case ISP_CONN_PTP:
4354                         isp_prt(isp, ISP_LOGINFO,
4355                             "Loop -> Point-to-Point mode");
4356                         break;
4357                 case ISP_CONN_BADLIP:
4358                         isp_prt(isp, ISP_LOGWARN,
4359                             "Point-to-Point -> Loop mode (BAD LIP)");
4360                         break;
4361                 case ISP_CONN_FATAL:
4362                         isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
4363 #ifdef  ISP_FW_CRASH_DUMP
4364                         isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4365 #else
4366                         isp_async(isp, ISPASYNC_FW_CRASH, NULL);
4367                         isp_reinit(isp);
4368                         isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
4369 #endif
4370                         return (-1);
4371                 case ISP_CONN_LOOPBACK:
4372                         isp_prt(isp, ISP_LOGWARN,
4373                             "Looped Back in Point-to-Point mode");
4374                         break;
4375                 default:
4376                         isp_prt(isp, ISP_LOGWARN,
4377                             "Unknown connection mode (0x%x)", mbox);
4378                         break;
4379                 }
4380                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4381                 isp->isp_sendmarker = 1;
4382                 FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
4383                 FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
4384                 break;
4385
4386         default:
4387                 isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
4388                 break;
4389         }
4390
4391         if (bus & 0x100) {
4392                 int i, nh;
4393                 uint16_t handles[16];
4394
4395                 for (nh = 0, i = 1; i < MAX_MAILBOX(isp); i++) {
4396                         if ((bus & (1 << i)) == 0) {
4397                                 continue;
4398                         }
4399                         handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
4400                 }
4401                 for (i = 0; i < nh; i++) {
4402                         isp_fastpost_complete(isp, handles[i]);
4403                         isp_prt(isp,  ISP_LOGDEBUG3,
4404                             "fast post completion of %u", handles[i]);
4405                 }
4406                 if (isp->isp_fpcchiwater < nh)
4407                         isp->isp_fpcchiwater = nh;
4408         } else {
4409                 isp->isp_intoasync++;
4410         }
4411         return (rval);
4412 }
4413
4414 /*
4415  * Handle other response entries. A pointer to the request queue output
4416  * index is here in case we want to eat several entries at once, although
4417  * this is not used currently.
4418  */
4419
4420 static int
4421 isp_handle_other_response(ispsoftc_t *isp, int type,
4422     isphdr_t *hp, uint16_t *optrp)
4423 {
4424         switch (type) {
4425         case RQSTYPE_STATUS_CONT:
4426                 isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response");
4427                 return (1);
4428         case RQSTYPE_ATIO:
4429         case RQSTYPE_CTIO:
4430         case RQSTYPE_ENABLE_LUN:
4431         case RQSTYPE_MODIFY_LUN:
4432         case RQSTYPE_NOTIFY:
4433         case RQSTYPE_NOTIFY_ACK:
4434         case RQSTYPE_CTIO1:
4435         case RQSTYPE_ATIO2:
4436         case RQSTYPE_CTIO2:
4437         case RQSTYPE_CTIO3:
4438                 isp->isp_rsltccmplt++;  /* count as a response completion */
4439 #ifdef  ISP_TARGET_MODE
4440                 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
4441                         return (1);
4442                 }
4443 #endif
4444                 /* FALLTHROUGH */
4445         case RQSTYPE_REQUEST:
4446         default:
4447                 USEC_DELAY(100);
4448                 if (type != isp_get_response_type(isp, hp)) {
4449                         /*
4450                          * This is questionable- we're just papering over
4451                          * something we've seen on SMP linux in target
4452                          * mode- we don't really know what's happening
4453                          * here that causes us to think we've gotten
4454                          * an entry, but that either the entry isn't
4455                          * filled out yet or our CPU read data is stale.
4456                          */
4457                         isp_prt(isp, ISP_LOGINFO,
4458                                 "unstable type in response queue");
4459                         return (-1);
4460                 }
4461                 isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
4462                     isp_get_response_type(isp, hp));
4463                 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
4464                         return (1);
4465                 }
4466                 return (0);
4467         }
4468 }
4469
4470 static void
4471 isp_parse_status(ispsoftc_t *isp, ispstatusreq_t *sp, XS_T *xs)
4472 {
4473         switch (sp->req_completion_status & 0xff) {
4474         case RQCS_COMPLETE:
4475                 if (XS_NOERR(xs)) {
4476                         XS_SETERR(xs, HBA_NOERROR);
4477                 }
4478                 return;
4479
4480         case RQCS_INCOMPLETE:
4481                 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
4482                         isp_prt(isp, ISP_LOGDEBUG1,
4483                             "Selection Timeout for %d.%d.%d",
4484                             XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4485                         if (XS_NOERR(xs)) {
4486                                 XS_SETERR(xs, HBA_SELTIMEOUT);
4487                         }
4488                         return;
4489                 }
4490                 isp_prt(isp, ISP_LOGERR,
4491                     "command incomplete for %d.%d.%d, state 0x%x",
4492                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
4493                     sp->req_state_flags);
4494                 break;
4495
4496         case RQCS_DMA_ERROR:
4497                 isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
4498                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4499                 break;
4500
4501         case RQCS_TRANSPORT_ERROR:
4502         {
4503                 char buf[172];
4504                 SNPRINTF(buf, sizeof (buf), "states=>");
4505                 if (sp->req_state_flags & RQSF_GOT_BUS) {
4506                         SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
4507                 }
4508                 if (sp->req_state_flags & RQSF_GOT_TARGET) {
4509                         SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
4510                 }
4511                 if (sp->req_state_flags & RQSF_SENT_CDB) {
4512                         SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
4513                 }
4514                 if (sp->req_state_flags & RQSF_XFRD_DATA) {
4515                         SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
4516                 }
4517                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
4518                         SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
4519                 }
4520                 if (sp->req_state_flags & RQSF_GOT_SENSE) {
4521                         SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
4522                 }
4523                 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
4524                         SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
4525                 }
4526                 SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
4527                 if (sp->req_status_flags & RQSTF_DISCONNECT) {
4528                         SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
4529                 }
4530                 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
4531                         SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
4532                 }
4533                 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
4534                         SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
4535                 }
4536                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
4537                         SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
4538                 }
4539                 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
4540                         SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
4541                 }
4542                 if (sp->req_status_flags & RQSTF_ABORTED) {
4543                         SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
4544                 }
4545                 if (sp->req_status_flags & RQSTF_TIMEOUT) {
4546                         SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
4547                 }
4548                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
4549                         SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
4550                 }
4551                 isp_prt(isp, ISP_LOGERR, "%s", buf);
4552                 isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
4553                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
4554                 break;
4555         }
4556         case RQCS_RESET_OCCURRED:
4557                 isp_prt(isp, ISP_LOGWARN,
4558                     "bus reset destroyed command for %d.%d.%d",
4559                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4560                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4561                 if (XS_NOERR(xs)) {
4562                         XS_SETERR(xs, HBA_BUSRESET);
4563                 }
4564                 return;
4565
4566         case RQCS_ABORTED:
4567                 isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
4568                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4569                 isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
4570                 if (XS_NOERR(xs)) {
4571                         XS_SETERR(xs, HBA_ABORTED);
4572                 }
4573                 return;
4574
4575         case RQCS_TIMEOUT:
4576                 isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
4577                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4578                 /*
4579                  * Check to see if we logged out the device.
4580                  */
4581                 if (IS_FC(isp)) {
4582                         if ((sp->req_completion_status & RQSTF_LOGOUT) &&
4583                             FCPARAM(isp)->portdb[XS_TGT(xs)].valid &&
4584                             FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) {
4585                                 FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1;
4586                         }
4587                 }
4588                 if (XS_NOERR(xs)) {
4589                         XS_SETERR(xs, HBA_CMDTIMEOUT);
4590                 }
4591                 return;
4592
4593         case RQCS_DATA_OVERRUN:
4594                 XS_RESID(xs) = sp->req_resid;
4595                 isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
4596                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4597                 if (XS_NOERR(xs)) {
4598                         XS_SETERR(xs, HBA_DATAOVR);
4599                 }
4600                 return;
4601
4602         case RQCS_COMMAND_OVERRUN:
4603                 isp_prt(isp, ISP_LOGERR,
4604                     "command overrun for command on %d.%d.%d",
4605                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4606                 break;
4607
4608         case RQCS_STATUS_OVERRUN:
4609                 isp_prt(isp, ISP_LOGERR,
4610                     "status overrun for command on %d.%d.%d",
4611                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4612                 break;
4613
4614         case RQCS_BAD_MESSAGE:
4615                 isp_prt(isp, ISP_LOGERR,
4616                     "msg not COMMAND COMPLETE after status %d.%d.%d",
4617                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4618                 break;
4619
4620         case RQCS_NO_MESSAGE_OUT:
4621                 isp_prt(isp, ISP_LOGERR,
4622                     "No MESSAGE OUT phase after selection on %d.%d.%d",
4623                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4624                 break;
4625
4626         case RQCS_EXT_ID_FAILED:
4627                 isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
4628                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4629                 break;
4630
4631         case RQCS_IDE_MSG_FAILED:
4632                 isp_prt(isp, ISP_LOGERR,
4633                     "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
4634                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4635                 break;
4636
4637         case RQCS_ABORT_MSG_FAILED:
4638                 isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
4639                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4640                 break;
4641
4642         case RQCS_REJECT_MSG_FAILED:
4643                 isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
4644                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4645                 break;
4646
4647         case RQCS_NOP_MSG_FAILED:
4648                 isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
4649                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4650                 break;
4651
4652         case RQCS_PARITY_ERROR_MSG_FAILED:
4653                 isp_prt(isp, ISP_LOGERR,
4654                     "MESSAGE PARITY ERROR rejected by %d.%d.%d",
4655                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4656                 break;
4657
4658         case RQCS_DEVICE_RESET_MSG_FAILED:
4659                 isp_prt(isp, ISP_LOGWARN,
4660                     "BUS DEVICE RESET rejected by %d.%d.%d",
4661                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4662                 break;
4663
4664         case RQCS_ID_MSG_FAILED:
4665                 isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
4666                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4667                 break;
4668
4669         case RQCS_UNEXP_BUS_FREE:
4670                 isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
4671                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4672                 break;
4673
4674         case RQCS_DATA_UNDERRUN:
4675         {
4676                 if (IS_FC(isp)) {
4677                         int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
4678                         if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
4679                                 isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
4680                                     XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
4681                                     (ru_marked)? "marked" : "not marked");
4682                                 if (XS_NOERR(xs)) {
4683                                         XS_SETERR(xs, HBA_BOTCH);
4684                                 }
4685                                 return;
4686                         }
4687                 }
4688                 XS_RESID(xs) = sp->req_resid;
4689                 if (XS_NOERR(xs)) {
4690                         XS_SETERR(xs, HBA_NOERROR);
4691                 }
4692                 return;
4693         }
4694
4695         case RQCS_XACT_ERR1:
4696                 isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
4697                     XS_TGT(xs), XS_LUN(xs));
4698                 break;
4699
4700         case RQCS_XACT_ERR2:
4701                 isp_prt(isp, ISP_LOGERR, xact2,
4702                     XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
4703                 break;
4704
4705         case RQCS_XACT_ERR3:
4706                 isp_prt(isp, ISP_LOGERR, xact3,
4707                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4708                 break;
4709
4710         case RQCS_BAD_ENTRY:
4711                 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
4712                 break;
4713
4714         case RQCS_QUEUE_FULL:
4715                 isp_prt(isp, ISP_LOGDEBUG0,
4716                     "internal queues full for %d.%d.%d status 0x%x",
4717                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
4718
4719                 /*
4720                  * If QFULL or some other status byte is set, then this
4721                  * isn't an error, per se.
4722                  *
4723                  * Unfortunately, some QLogic f/w writers have, in
4724                  * some cases, ommitted to *set* status to QFULL.
4725                  *
4726
4727                 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
4728                         XS_SETERR(xs, HBA_NOERROR);
4729                         return;
4730                 }
4731
4732                  *
4733                  *
4734                  */
4735
4736                 *XS_STSP(xs) = SCSI_QFULL;
4737                 XS_SETERR(xs, HBA_NOERROR);
4738                 return;
4739
4740         case RQCS_PHASE_SKIPPED:
4741                 isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
4742                     XS_TGT(xs), XS_LUN(xs));
4743                 break;
4744
4745         case RQCS_ARQS_FAILED:
4746                 isp_prt(isp, ISP_LOGERR,
4747                     "Auto Request Sense failed for %d.%d.%d",
4748                     XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4749                 if (XS_NOERR(xs)) {
4750                         XS_SETERR(xs, HBA_ARQFAIL);
4751                 }
4752                 return;
4753
4754         case RQCS_WIDE_FAILED:
4755                 isp_prt(isp, ISP_LOGERR,
4756                     "Wide Negotiation failed for %d.%d.%d",
4757                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4758                 if (IS_SCSI(isp)) {
4759                         sdparam *sdp = isp->isp_param;
4760                         sdp += XS_CHANNEL(xs);
4761                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
4762                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
4763                         isp->isp_update |= (1 << XS_CHANNEL(xs));
4764                 }
4765                 if (XS_NOERR(xs)) {
4766                         XS_SETERR(xs, HBA_NOERROR);
4767                 }
4768                 return;
4769
4770         case RQCS_SYNCXFER_FAILED:
4771                 isp_prt(isp, ISP_LOGERR,
4772                     "SDTR Message failed for target %d.%d.%d",
4773                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4774                 if (IS_SCSI(isp)) {
4775                         sdparam *sdp = isp->isp_param;
4776                         sdp += XS_CHANNEL(xs);
4777                         sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
4778                         sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
4779                         isp->isp_update |= (1 << XS_CHANNEL(xs));
4780                 }
4781                 break;
4782
4783         case RQCS_LVD_BUSERR:
4784                 isp_prt(isp, ISP_LOGERR,
4785                     "Bad LVD condition while talking to %d.%d.%d",
4786                     XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
4787                 break;
4788
4789         case RQCS_PORT_UNAVAILABLE:
4790                 /*
4791                  * No such port on the loop. Moral equivalent of SELTIMEO
4792                  */
4793         case RQCS_PORT_LOGGED_OUT:
4794                 /*
4795                  * It was there (maybe)- treat as a selection timeout.
4796                  */
4797                 if ((sp->req_completion_status & 0xff) == RQCS_PORT_UNAVAILABLE)
4798                         isp_prt(isp, ISP_LOGINFO,
4799                             "port unavailable for target %d", XS_TGT(xs));
4800                 else
4801                         isp_prt(isp, ISP_LOGINFO,
4802                             "port logout for target %d", XS_TGT(xs));
4803                 /*
4804                  * If we're on a local loop, force a LIP (which is overkill)
4805                  * to force a re-login of this unit. If we're on fabric,
4806                  * then we'll have to relogin as a matter of course.
4807                  */
4808                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
4809                     FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
4810                         mbreg_t mbs;
4811                         MEMZERO(&mbs, sizeof (mbs));
4812                         mbs.param[0] = MBOX_INIT_LIP;
4813                         isp_mboxcmd_qnw(isp, &mbs, 1);
4814                 }
4815
4816                 /*
4817                  * Probably overkill.
4818                  */
4819                 isp->isp_sendmarker = 1;
4820                 FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
4821                 isp_mark_getpdb_all(isp);
4822                 isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
4823                 if (XS_NOERR(xs)) {
4824                         XS_SETERR(xs, HBA_SELTIMEOUT);
4825                 }
4826                 return;
4827
4828         case RQCS_PORT_CHANGED:
4829                 isp_prt(isp, ISP_LOGWARN,
4830                     "port changed for target %d", XS_TGT(xs));
4831                 if (XS_NOERR(xs)) {
4832                         XS_SETERR(xs, HBA_SELTIMEOUT);
4833                 }
4834                 return;
4835
4836         case RQCS_PORT_BUSY:
4837                 isp_prt(isp, ISP_LOGWARN,
4838                     "port busy for target %d", XS_TGT(xs));
4839                 if (XS_NOERR(xs)) {
4840                         XS_SETERR(xs, HBA_TGTBSY);
4841                 }
4842                 return;
4843
4844         default:
4845                 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
4846                     sp->req_completion_status);
4847                 break;
4848         }
4849         if (XS_NOERR(xs)) {
4850                 XS_SETERR(xs, HBA_BOTCH);
4851         }
4852 }
4853
4854 static void
4855 isp_fastpost_complete(ispsoftc_t *isp, uint16_t fph)
4856 {
4857         XS_T *xs;
4858
4859         if (fph == 0) {
4860                 return;
4861         }
4862         xs = isp_find_xs(isp, fph);
4863         if (xs == NULL) {
4864                 isp_prt(isp, ISP_LOGWARN,
4865                     "Command for fast post handle 0x%x not found", fph);
4866                 return;
4867         }
4868         isp_destroy_handle(isp, fph);
4869
4870         /*
4871          * Since we don't have a result queue entry item,
4872          * we must believe that SCSI status is zero and
4873          * that all data transferred.
4874          */
4875         XS_SET_STATE_STAT(isp, xs, NULL);
4876         XS_RESID(xs) = 0;
4877         *XS_STSP(xs) = SCSI_GOOD;
4878         if (XS_XFRLEN(xs)) {
4879                 ISP_DMAFREE(isp, xs, fph);
4880         }
4881         if (isp->isp_nactive)
4882                 isp->isp_nactive--;
4883         isp->isp_fphccmplt++;
4884         isp_done(xs);
4885 }
4886
4887 static int
4888 isp_mbox_continue(ispsoftc_t *isp)
4889 {
4890         mbreg_t mbs;
4891         uint16_t *ptr;
4892
4893         switch (isp->isp_lastmbxcmd) {
4894         case MBOX_WRITE_RAM_WORD:
4895         case MBOX_READ_RAM_WORD:
4896         case MBOX_READ_RAM_WORD_EXTENDED:
4897                 break;
4898         default:
4899                 return (1);
4900         }
4901         if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
4902                 isp->isp_mbxwrk0 = 0;
4903                 return (-1);
4904         }
4905
4906         /*
4907          * Clear the previous interrupt.
4908          */
4909         ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
4910         ISP_WRITE(isp, BIU_SEMA, 0);
4911
4912         /*
4913          * Continue with next word.
4914          */
4915         MEMZERO(&mbs, sizeof (mbs));
4916         ptr = isp->isp_mbxworkp;
4917         switch (isp->isp_lastmbxcmd) {
4918         case MBOX_WRITE_RAM_WORD:
4919                 mbs.param[2] = *ptr++;
4920                 mbs.param[1] = isp->isp_mbxwrk1++;
4921                 break;
4922         case MBOX_READ_RAM_WORD:
4923         case MBOX_READ_RAM_WORD_EXTENDED:
4924                 *ptr++ = isp->isp_mboxtmp[2];
4925                 mbs.param[1] = isp->isp_mbxwrk1++;
4926                 break;
4927         }
4928         isp->isp_mbxworkp = ptr;
4929         mbs.param[0] = isp->isp_lastmbxcmd;
4930         isp->isp_mbxwrk0 -= 1;
4931         isp_mboxcmd_qnw(isp, &mbs, 0);
4932         return (0);
4933 }
4934
4935
4936 #define HIWRD(x)                        ((x) >> 16)
4937 #define LOWRD(x)                        ((x)  & 0xffff)
4938 #define ISPOPMAP(a, b)                  (((a) << 16) | (b))
4939 static const uint32_t mbpscsi[] = {
4940         ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
4941         ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
4942         ISPOPMAP(0x03, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
4943         ISPOPMAP(0x1f, 0x01),   /* 0x03: MBOX_DUMP_RAM */
4944         ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
4945         ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
4946         ISPOPMAP(0x3f, 0x3f),   /* 0x06: MBOX_MAILBOX_REG_TEST */
4947         ISPOPMAP(0x03, 0x07),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
4948         ISPOPMAP(0x01, 0x0f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
4949         ISPOPMAP(0x00, 0x00),   /* 0x09: */
4950         ISPOPMAP(0x00, 0x00),   /* 0x0a: */
4951         ISPOPMAP(0x00, 0x00),   /* 0x0b: */
4952         ISPOPMAP(0x00, 0x00),   /* 0x0c: */
4953         ISPOPMAP(0x00, 0x00),   /* 0x0d: */
4954         ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
4955         ISPOPMAP(0x00, 0x00),   /* 0x0f: */
4956         ISPOPMAP(0x1f, 0x1f),   /* 0x10: MBOX_INIT_REQ_QUEUE */
4957         ISPOPMAP(0x3f, 0x3f),   /* 0x11: MBOX_INIT_RES_QUEUE */
4958         ISPOPMAP(0x0f, 0x0f),   /* 0x12: MBOX_EXECUTE_IOCB */
4959         ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
4960         ISPOPMAP(0x01, 0x3f),   /* 0x14: MBOX_STOP_FIRMWARE */
4961         ISPOPMAP(0x0f, 0x0f),   /* 0x15: MBOX_ABORT */
4962         ISPOPMAP(0x03, 0x03),   /* 0x16: MBOX_ABORT_DEVICE */
4963         ISPOPMAP(0x07, 0x07),   /* 0x17: MBOX_ABORT_TARGET */
4964         ISPOPMAP(0x07, 0x07),   /* 0x18: MBOX_BUS_RESET */
4965         ISPOPMAP(0x03, 0x07),   /* 0x19: MBOX_STOP_QUEUE */
4966         ISPOPMAP(0x03, 0x07),   /* 0x1a: MBOX_START_QUEUE */
4967         ISPOPMAP(0x03, 0x07),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
4968         ISPOPMAP(0x03, 0x07),   /* 0x1c: MBOX_ABORT_QUEUE */
4969         ISPOPMAP(0x03, 0x4f),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
4970         ISPOPMAP(0x00, 0x00),   /* 0x1e: */
4971         ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
4972         ISPOPMAP(0x01, 0x07),   /* 0x20: MBOX_GET_INIT_SCSI_ID */
4973         ISPOPMAP(0x01, 0x07),   /* 0x21: MBOX_GET_SELECT_TIMEOUT */
4974         ISPOPMAP(0x01, 0xc7),   /* 0x22: MBOX_GET_RETRY_COUNT   */
4975         ISPOPMAP(0x01, 0x07),   /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
4976         ISPOPMAP(0x01, 0x03),   /* 0x24: MBOX_GET_CLOCK_RATE */
4977         ISPOPMAP(0x01, 0x07),   /* 0x25: MBOX_GET_ACT_NEG_STATE */
4978         ISPOPMAP(0x01, 0x07),   /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
4979         ISPOPMAP(0x01, 0x07),   /* 0x27: MBOX_GET_PCI_PARAMS */
4980         ISPOPMAP(0x03, 0x4f),   /* 0x28: MBOX_GET_TARGET_PARAMS */
4981         ISPOPMAP(0x03, 0x0f),   /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
4982         ISPOPMAP(0x01, 0x07),   /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
4983         ISPOPMAP(0x00, 0x00),   /* 0x2b: */
4984         ISPOPMAP(0x00, 0x00),   /* 0x2c: */
4985         ISPOPMAP(0x00, 0x00),   /* 0x2d: */
4986         ISPOPMAP(0x00, 0x00),   /* 0x2e: */
4987         ISPOPMAP(0x00, 0x00),   /* 0x2f: */
4988         ISPOPMAP(0x03, 0x03),   /* 0x30: MBOX_SET_INIT_SCSI_ID */
4989         ISPOPMAP(0x07, 0x07),   /* 0x31: MBOX_SET_SELECT_TIMEOUT */
4990         ISPOPMAP(0xc7, 0xc7),   /* 0x32: MBOX_SET_RETRY_COUNT   */
4991         ISPOPMAP(0x07, 0x07),   /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
4992         ISPOPMAP(0x03, 0x03),   /* 0x34: MBOX_SET_CLOCK_RATE */
4993         ISPOPMAP(0x07, 0x07),   /* 0x35: MBOX_SET_ACT_NEG_STATE */
4994         ISPOPMAP(0x07, 0x07),   /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
4995         ISPOPMAP(0x07, 0x07),   /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
4996         ISPOPMAP(0x4f, 0x4f),   /* 0x38: MBOX_SET_TARGET_PARAMS */
4997         ISPOPMAP(0x0f, 0x0f),   /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
4998         ISPOPMAP(0x07, 0x07),   /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
4999         ISPOPMAP(0x00, 0x00),   /* 0x3b: */
5000         ISPOPMAP(0x00, 0x00),   /* 0x3c: */
5001         ISPOPMAP(0x00, 0x00),   /* 0x3d: */
5002         ISPOPMAP(0x00, 0x00),   /* 0x3e: */
5003         ISPOPMAP(0x00, 0x00),   /* 0x3f: */
5004         ISPOPMAP(0x01, 0x03),   /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
5005         ISPOPMAP(0x3f, 0x01),   /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
5006         ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_EXEC_BIOS_IOCB */
5007         ISPOPMAP(0x00, 0x00),   /* 0x43: */
5008         ISPOPMAP(0x00, 0x00),   /* 0x44: */
5009         ISPOPMAP(0x03, 0x03),   /* 0x45: SET SYSTEM PARAMETER */
5010         ISPOPMAP(0x01, 0x03),   /* 0x46: GET SYSTEM PARAMETER */
5011         ISPOPMAP(0x00, 0x00),   /* 0x47: */
5012         ISPOPMAP(0x01, 0xcf),   /* 0x48: GET SCAM CONFIGURATION */
5013         ISPOPMAP(0xcf, 0xcf),   /* 0x49: SET SCAM CONFIGURATION */
5014         ISPOPMAP(0x03, 0x03),   /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
5015         ISPOPMAP(0x01, 0x03),   /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
5016         ISPOPMAP(0x00, 0x00),   /* 0x4c: */
5017         ISPOPMAP(0x00, 0x00),   /* 0x4d: */
5018         ISPOPMAP(0x00, 0x00),   /* 0x4e: */
5019         ISPOPMAP(0x00, 0x00),   /* 0x4f: */
5020         ISPOPMAP(0xdf, 0xdf),   /* 0x50: LOAD RAM A64 */
5021         ISPOPMAP(0xdf, 0xdf),   /* 0x51: DUMP RAM A64 */
5022         ISPOPMAP(0xdf, 0xff),   /* 0x52: INITIALIZE REQUEST QUEUE A64 */
5023         ISPOPMAP(0xef, 0xff),   /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
5024         ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUTE IOCB A64 */
5025         ISPOPMAP(0x07, 0x01),   /* 0x55: ENABLE TARGET MODE */
5026         ISPOPMAP(0x03, 0x0f),   /* 0x56: GET TARGET STATUS */
5027         ISPOPMAP(0x00, 0x00),   /* 0x57: */
5028         ISPOPMAP(0x00, 0x00),   /* 0x58: */
5029         ISPOPMAP(0x00, 0x00),   /* 0x59: */
5030         ISPOPMAP(0x03, 0x03),   /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
5031         ISPOPMAP(0x01, 0x03),   /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
5032         ISPOPMAP(0x0f, 0x0f),   /* 0x5c: SET HOST DATA */
5033         ISPOPMAP(0x01, 0x01)    /* 0x5d: GET NOST DATA */
5034 };
5035
5036 #ifndef ISP_STRIPPED
5037 static char *scsi_mbcmd_names[] = {
5038         "NO-OP",
5039         "LOAD RAM",
5040         "EXEC FIRMWARE",
5041         "DUMP RAM",
5042         "WRITE RAM WORD",
5043         "READ RAM WORD",
5044         "MAILBOX REG TEST",
5045         "VERIFY CHECKSUM",
5046         "ABOUT FIRMWARE",
5047         NULL,
5048         NULL,
5049         NULL,
5050         NULL,
5051         NULL,
5052         "CHECK FIRMWARE",
5053         NULL,
5054         "INIT REQUEST QUEUE",
5055         "INIT RESULT QUEUE",
5056         "EXECUTE IOCB",
5057         "WAKE UP",
5058         "STOP FIRMWARE",
5059         "ABORT",
5060         "ABORT DEVICE",
5061         "ABORT TARGET",
5062         "BUS RESET",
5063         "STOP QUEUE",
5064         "START QUEUE",
5065         "SINGLE STEP QUEUE",
5066         "ABORT QUEUE",
5067         "GET DEV QUEUE STATUS",
5068         NULL,
5069         "GET FIRMWARE STATUS",
5070         "GET INIT SCSI ID",
5071         "GET SELECT TIMEOUT",
5072         "GET RETRY COUNT",
5073         "GET TAG AGE LIMIT",
5074         "GET CLOCK RATE",
5075         "GET ACT NEG STATE",
5076         "GET ASYNC DATA SETUP TIME",
5077         "GET PCI PARAMS",
5078         "GET TARGET PARAMS",
5079         "GET DEV QUEUE PARAMS",
5080         "GET RESET DELAY PARAMS",
5081         NULL,
5082         NULL,
5083         NULL,
5084         NULL,
5085         NULL,
5086         "SET INIT SCSI ID",
5087         "SET SELECT TIMEOUT",
5088         "SET RETRY COUNT",
5089         "SET TAG AGE LIMIT",
5090         "SET CLOCK RATE",
5091         "SET ACT NEG STATE",
5092         "SET ASYNC DATA SETUP TIME",
5093         "SET PCI CONTROL PARAMS",
5094         "SET TARGET PARAMS",
5095         "SET DEV QUEUE PARAMS",
5096         "SET RESET DELAY PARAMS",
5097         NULL,
5098         NULL,
5099         NULL,
5100         NULL,
5101         NULL,
5102         "RETURN BIOS BLOCK ADDR",
5103         "WRITE FOUR RAM WORDS",
5104         "EXEC BIOS IOCB",
5105         NULL,
5106         NULL,
5107         "SET SYSTEM PARAMETER",
5108         "GET SYSTEM PARAMETER",
5109         NULL,
5110         "GET SCAM CONFIGURATION",
5111         "SET SCAM CONFIGURATION",
5112         "SET FIRMWARE FEATURES",
5113         "GET FIRMWARE FEATURES",
5114         NULL,
5115         NULL,
5116         NULL,
5117         NULL,
5118         "LOAD RAM A64",
5119         "DUMP RAM A64",
5120         "INITIALIZE REQUEST QUEUE A64",
5121         "INITIALIZE RESPONSE QUEUE A64",
5122         "EXECUTE IOCB A64",
5123         "ENABLE TARGET MODE",
5124         "GET TARGET MODE STATE",
5125         NULL,
5126         NULL,
5127         NULL,
5128         "SET DATA OVERRUN RECOVERY MODE",
5129         "GET DATA OVERRUN RECOVERY MODE",
5130         "SET HOST DATA",
5131         "GET NOST DATA",
5132 };
5133 #endif
5134
5135 static const uint32_t mbpfc[] = {
5136         ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
5137         ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
5138         ISPOPMAP(0x03, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
5139         ISPOPMAP(0xdf, 0x01),   /* 0x03: MBOX_DUMP_RAM */
5140         ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
5141         ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
5142         ISPOPMAP(0xff, 0xff),   /* 0x06: MBOX_MAILBOX_REG_TEST */
5143         ISPOPMAP(0x03, 0x05),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
5144         ISPOPMAP(0x01, 0x4f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
5145         ISPOPMAP(0xdf, 0x01),   /* 0x09: LOAD RAM */
5146         ISPOPMAP(0xdf, 0x01),   /* 0x0a: DUMP RAM */
5147         ISPOPMAP(0x00, 0x00),   /* 0x0b: */
5148         ISPOPMAP(0x00, 0x00),   /* 0x0c: */
5149         ISPOPMAP(0x00, 0x00),   /* 0x0d: */
5150         ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
5151         ISPOPMAP(0x03, 0x07),   /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED(1) */
5152         ISPOPMAP(0x1f, 0x11),   /* 0x10: MBOX_INIT_REQ_QUEUE */
5153         ISPOPMAP(0x2f, 0x21),   /* 0x11: MBOX_INIT_RES_QUEUE */
5154         ISPOPMAP(0x0f, 0x01),   /* 0x12: MBOX_EXECUTE_IOCB */
5155         ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
5156         ISPOPMAP(0x01, 0xff),   /* 0x14: MBOX_STOP_FIRMWARE */
5157         ISPOPMAP(0x4f, 0x01),   /* 0x15: MBOX_ABORT */
5158         ISPOPMAP(0x07, 0x01),   /* 0x16: MBOX_ABORT_DEVICE */
5159         ISPOPMAP(0x07, 0x01),   /* 0x17: MBOX_ABORT_TARGET */
5160         ISPOPMAP(0x03, 0x03),   /* 0x18: MBOX_BUS_RESET */
5161         ISPOPMAP(0x07, 0x05),   /* 0x19: MBOX_STOP_QUEUE */
5162         ISPOPMAP(0x07, 0x05),   /* 0x1a: MBOX_START_QUEUE */
5163         ISPOPMAP(0x07, 0x05),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
5164         ISPOPMAP(0x07, 0x05),   /* 0x1c: MBOX_ABORT_QUEUE */
5165         ISPOPMAP(0x07, 0x03),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
5166         ISPOPMAP(0x00, 0x00),   /* 0x1e: */
5167         ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
5168         ISPOPMAP(0x01, 0x4f),   /* 0x20: MBOX_GET_LOOP_ID */
5169         ISPOPMAP(0x00, 0x00),   /* 0x21: */
5170         ISPOPMAP(0x01, 0x07),   /* 0x22: MBOX_GET_RETRY_COUNT   */
5171         ISPOPMAP(0x00, 0x00),   /* 0x23: */
5172         ISPOPMAP(0x00, 0x00),   /* 0x24: */
5173         ISPOPMAP(0x00, 0x00),   /* 0x25: */
5174         ISPOPMAP(0x00, 0x00),   /* 0x26: */
5175         ISPOPMAP(0x00, 0x00),   /* 0x27: */
5176         ISPOPMAP(0x01, 0x03),   /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
5177         ISPOPMAP(0x03, 0x07),   /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
5178         ISPOPMAP(0x00, 0x00),   /* 0x2a: */
5179         ISPOPMAP(0x00, 0x00),   /* 0x2b: */
5180         ISPOPMAP(0x00, 0x00),   /* 0x2c: */
5181         ISPOPMAP(0x00, 0x00),   /* 0x2d: */
5182         ISPOPMAP(0x00, 0x00),   /* 0x2e: */
5183         ISPOPMAP(0x00, 0x00),   /* 0x2f: */
5184         ISPOPMAP(0x00, 0x00),   /* 0x30: */
5185         ISPOPMAP(0x00, 0x00),   /* 0x31: */
5186         ISPOPMAP(0x07, 0x07),   /* 0x32: MBOX_SET_RETRY_COUNT   */
5187         ISPOPMAP(0x00, 0x00),   /* 0x33: */
5188         ISPOPMAP(0x00, 0x00),   /* 0x34: */
5189         ISPOPMAP(0x00, 0x00),   /* 0x35: */
5190         ISPOPMAP(0x00, 0x00),   /* 0x36: */
5191         ISPOPMAP(0x00, 0x00),   /* 0x37: */
5192         ISPOPMAP(0x0f, 0x01),   /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
5193         ISPOPMAP(0x0f, 0x07),   /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
5194         ISPOPMAP(0x00, 0x00),   /* 0x3a: */
5195         ISPOPMAP(0x00, 0x00),   /* 0x3b: */
5196         ISPOPMAP(0x00, 0x00),   /* 0x3c: */
5197         ISPOPMAP(0x00, 0x00),   /* 0x3d: */
5198         ISPOPMAP(0x00, 0x00),   /* 0x3e: */
5199         ISPOPMAP(0x00, 0x00),   /* 0x3f: */
5200         ISPOPMAP(0x03, 0x01),   /* 0x40: MBOX_LOOP_PORT_BYPASS */
5201         ISPOPMAP(0x03, 0x01),   /* 0x41: MBOX_LOOP_PORT_ENABLE */
5202         ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_GET_RESOURCE_COUNTS */
5203         ISPOPMAP(0x01, 0x01),   /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */
5204         ISPOPMAP(0x00, 0x00),   /* 0x44: */
5205         ISPOPMAP(0x00, 0x00),   /* 0x45: */
5206         ISPOPMAP(0x00, 0x00),   /* 0x46: */
5207         ISPOPMAP(0xcf, 0x03),   /* 0x47: GET PORT_DATABASE ENHANCED */
5208         ISPOPMAP(0x00, 0x00),   /* 0x48: */
5209         ISPOPMAP(0x00, 0x00),   /* 0x49: */
5210         ISPOPMAP(0x00, 0x00),   /* 0x4a: */
5211         ISPOPMAP(0x00, 0x00),   /* 0x4b: */
5212         ISPOPMAP(0x00, 0x00),   /* 0x4c: */
5213         ISPOPMAP(0x00, 0x00),   /* 0x4d: */
5214         ISPOPMAP(0x00, 0x00),   /* 0x4e: */
5215         ISPOPMAP(0x00, 0x00),   /* 0x4f: */
5216         ISPOPMAP(0x00, 0x00),   /* 0x50: */
5217         ISPOPMAP(0x00, 0x00),   /* 0x51: */
5218         ISPOPMAP(0x00, 0x00),   /* 0x52: */
5219         ISPOPMAP(0x00, 0x00),   /* 0x53: */
5220         ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUTE IOCB A64 */
5221         ISPOPMAP(0x00, 0x00),   /* 0x55: */
5222         ISPOPMAP(0x00, 0x00),   /* 0x56: */
5223         ISPOPMAP(0x00, 0x00),   /* 0x57: */
5224         ISPOPMAP(0x00, 0x00),   /* 0x58: */
5225         ISPOPMAP(0x00, 0x00),   /* 0x59: */
5226         ISPOPMAP(0x00, 0x00),   /* 0x5a: */
5227         ISPOPMAP(0x03, 0x01),   /* 0x5b: MBOX_DRIVER_HEARTBEAT */
5228         ISPOPMAP(0xcf, 0x01),   /* 0x5c: MBOX_FW_HEARTBEAT */
5229         ISPOPMAP(0x07, 0x03),   /* 0x5d: MBOX_GET_SET_DATA_RATE */
5230         ISPOPMAP(0x00, 0x00),   /* 0x5e: */
5231         ISPOPMAP(0x00, 0x00),   /* 0x5f: */
5232         ISPOPMAP(0xfd, 0x31),   /* 0x60: MBOX_INIT_FIRMWARE */
5233         ISPOPMAP(0x00, 0x00),   /* 0x61: */
5234         ISPOPMAP(0x01, 0x01),   /* 0x62: MBOX_INIT_LIP */
5235         ISPOPMAP(0xcd, 0x03),   /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
5236         ISPOPMAP(0xcf, 0x01),   /* 0x64: MBOX_GET_PORT_DB */
5237         ISPOPMAP(0x07, 0x01),   /* 0x65: MBOX_CLEAR_ACA */
5238         ISPOPMAP(0x07, 0x01),   /* 0x66: MBOX_TARGET_RESET */
5239         ISPOPMAP(0x07, 0x01),   /* 0x67: MBOX_CLEAR_TASK_SET */
5240         ISPOPMAP(0x07, 0x01),   /* 0x68: MBOX_ABORT_TASK_SET */
5241         ISPOPMAP(0x01, 0x07),   /* 0x69: MBOX_GET_FW_STATE */
5242         ISPOPMAP(0x03, 0xcf),   /* 0x6a: MBOX_GET_PORT_NAME */
5243         ISPOPMAP(0xcf, 0x01),   /* 0x6b: MBOX_GET_LINK_STATUS */
5244         ISPOPMAP(0x0f, 0x01),   /* 0x6c: MBOX_INIT_LIP_RESET */
5245         ISPOPMAP(0x00, 0x00),   /* 0x6d: */
5246         ISPOPMAP(0xcf, 0x03),   /* 0x6e: MBOX_SEND_SNS */
5247         ISPOPMAP(0x0f, 0x07),   /* 0x6f: MBOX_FABRIC_LOGIN */
5248         ISPOPMAP(0x03, 0x01),   /* 0x70: MBOX_SEND_CHANGE_REQUEST */
5249         ISPOPMAP(0x03, 0x03),   /* 0x71: MBOX_FABRIC_LOGOUT */
5250         ISPOPMAP(0x0f, 0x0f),   /* 0x72: MBOX_INIT_LIP_LOGIN */
5251         ISPOPMAP(0x00, 0x00),   /* 0x73: */
5252         ISPOPMAP(0x07, 0x01),   /* 0x74: LOGIN LOOP PORT */
5253         ISPOPMAP(0xcf, 0x03),   /* 0x75: GET PORT/NODE NAME LIST */
5254         ISPOPMAP(0x4f, 0x01),   /* 0x76: SET VENDOR ID */
5255         ISPOPMAP(0xcd, 0x01),   /* 0x77: INITIALIZE IP MAILBOX */
5256         ISPOPMAP(0x00, 0x00),   /* 0x78: */
5257         ISPOPMAP(0x00, 0x00),   /* 0x79: */
5258         ISPOPMAP(0x00, 0x00),   /* 0x7a: */
5259         ISPOPMAP(0x00, 0x00),   /* 0x7b: */
5260         ISPOPMAP(0x4f, 0x03),   /* 0x7c: Get ID List */
5261         ISPOPMAP(0xcf, 0x01),   /* 0x7d: SEND LFA */
5262         ISPOPMAP(0x0f, 0x01)    /* 0x7e: LUN RESET */
5263 };
5264 /*
5265  * Footnotes
5266  *
5267  * (1): this sets bits 21..16 in mailbox register #8, which we nominally
5268  *      do not access at this time in the core driver. The caller is
5269  *      responsible for setting this register first (Gross!).
5270  */
5271
5272 #ifndef ISP_STRIPPED
5273 static char *fc_mbcmd_names[] = {
5274         "NO-OP",
5275         "LOAD RAM",
5276         "EXEC FIRMWARE",
5277         "DUMP RAM",
5278         "WRITE RAM WORD",
5279         "READ RAM WORD",
5280         "MAILBOX REG TEST",
5281         "VERIFY CHECKSUM",
5282         "ABOUT FIRMWARE",
5283         "LOAD RAM",
5284         "DUMP RAM",
5285         NULL,
5286         NULL,
5287         "READ RAM WORD EXTENDED",
5288         "CHECK FIRMWARE",
5289         NULL,
5290         "INIT REQUEST QUEUE",
5291         "INIT RESULT QUEUE",
5292         "EXECUTE IOCB",
5293         "WAKE UP",
5294         "STOP FIRMWARE",
5295         "ABORT",
5296         "ABORT DEVICE",
5297         "ABORT TARGET",
5298         "BUS RESET",
5299         "STOP QUEUE",
5300         "START QUEUE",
5301         "SINGLE STEP QUEUE",
5302         "ABORT QUEUE",
5303         "GET DEV QUEUE STATUS",
5304         NULL,
5305         "GET FIRMWARE STATUS",
5306         "GET LOOP ID",
5307         NULL,
5308         "GET RETRY COUNT",
5309         NULL,
5310         NULL,
5311         NULL,
5312         NULL,
5313         NULL,
5314         "GET FIRMWARE OPTIONS",
5315         "GET PORT QUEUE PARAMS",
5316         NULL,
5317         NULL,
5318         NULL,
5319         NULL,
5320         NULL,
5321         NULL,
5322         NULL,
5323         NULL,
5324         "SET RETRY COUNT",
5325         NULL,
5326         NULL,
5327         NULL,
5328         NULL,
5329         NULL,
5330         "SET FIRMWARE OPTIONS",
5331         "SET PORT QUEUE PARAMS",
5332         NULL,
5333         NULL,
5334         NULL,
5335         NULL,
5336         NULL,
5337         NULL,
5338         "LOOP PORT BYPASS",
5339         "LOOP PORT ENABLE",
5340         "GET RESOURCE COUNTS",
5341         "REQUEST NON PARTICIPATING MODE",
5342         NULL,
5343         NULL,
5344         NULL,
5345         "GET PORT DATABASE,, ENHANCED",
5346         NULL,
5347         NULL,
5348         NULL,
5349         NULL,
5350         NULL,
5351         NULL,
5352         NULL,
5353         NULL,
5354         NULL,
5355         NULL,
5356         NULL,
5357         NULL,
5358         "EXECUTE IOCB A64",
5359         NULL,
5360         NULL,
5361         NULL,
5362         NULL,
5363         NULL,
5364         NULL,
5365         "DRIVER HEARTBEAT",
5366         NULL,
5367         "GET/SET DATA RATE",
5368         NULL,
5369         NULL,
5370         "INIT FIRMWARE",
5371         NULL,
5372         "INIT LIP",
5373         "GET FC-AL POSITION MAP",
5374         "GET PORT DATABASE",
5375         "CLEAR ACA",
5376         "TARGET RESET",
5377         "CLEAR TASK SET",
5378         "ABORT TASK SET",
5379         "GET FW STATE",
5380         "GET PORT NAME",
5381         "GET LINK STATUS",
5382         "INIT LIP RESET",
5383         NULL,
5384         "SEND SNS",
5385         "FABRIC LOGIN",
5386         "SEND CHANGE REQUEST",
5387         "FABRIC LOGOUT",
5388         "INIT LIP LOGIN",
5389         NULL,
5390         "LOGIN LOOP PORT",
5391         "GET PORT/NODE NAME LIST",
5392         "SET VENDOR ID",
5393         "INITIALIZE IP MAILBOX",
5394         NULL,
5395         NULL,
5396         NULL,
5397         NULL,
5398         "Get ID List",
5399         "SEND LFA",
5400         "Lun RESET"
5401 };
5402 #endif
5403
5404 static void
5405 isp_mboxcmd_qnw(ispsoftc_t *isp, mbreg_t *mbp, int nodelay)
5406 {
5407         unsigned int ibits, obits, box, opcode;
5408         const uint32_t *mcp;
5409
5410         if (IS_FC(isp)) {
5411                 mcp = mbpfc;
5412         } else {
5413                 mcp = mbpscsi;
5414         }
5415         opcode = mbp->param[0];
5416         ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
5417         obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
5418         ibits |= mbp->ibits;
5419         obits |= mbp->obits;
5420         for (box = 0; box < MAX_MAILBOX(isp); box++) {
5421                 if (ibits & (1 << box)) {
5422                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
5423                 }
5424                 if (nodelay == 0) {
5425                         isp->isp_mboxtmp[box] = mbp->param[box] = 0;
5426                 }
5427         }
5428         if (nodelay == 0) {
5429                 isp->isp_lastmbxcmd = opcode;
5430                 isp->isp_obits = obits;
5431                 isp->isp_mboxbsy = 1;
5432         }
5433         ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
5434         /*
5435          * Oddly enough, if we're not delaying for an answer,
5436          * delay a bit to give the f/w a chance to pick up the
5437          * command.
5438          */
5439         if (nodelay) {
5440                 USEC_DELAY(1000);
5441         }
5442 }
5443
5444 static void
5445 isp_mboxcmd(ispsoftc_t *isp, mbreg_t *mbp, int logmask)
5446 {
5447         char *cname, *xname, tname[16], mname[16];
5448         unsigned int lim, ibits, obits, box, opcode;
5449         const uint32_t *mcp;
5450
5451         if (IS_FC(isp)) {
5452                 mcp = mbpfc;
5453                 lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
5454         } else {
5455                 mcp = mbpscsi;
5456                 lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
5457         }
5458
5459         if ((opcode = mbp->param[0]) >= lim) {
5460                 mbp->param[0] = MBOX_INVALID_COMMAND;
5461                 isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
5462                 return;
5463         }
5464
5465         ibits = HIWRD(mcp[opcode]) & NMBOX_BMASK(isp);
5466         obits = LOWRD(mcp[opcode]) & NMBOX_BMASK(isp);
5467
5468         ibits |= mbp->ibits;
5469         obits |= mbp->obits;
5470
5471         if (ibits == 0 && obits == 0) {
5472                 mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
5473                 isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
5474                 return;
5475         }
5476
5477         /*
5478          * Get exclusive usage of mailbox registers.
5479          */
5480         MBOX_ACQUIRE(isp);
5481
5482         for (box = 0; box < MAX_MAILBOX(isp); box++) {
5483                 if (ibits & (1 << box)) {
5484                         ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
5485                 }
5486                 isp->isp_mboxtmp[box] = mbp->param[box] = 0;
5487         }
5488
5489         isp->isp_lastmbxcmd = opcode;
5490
5491         /*
5492          * We assume that we can't overwrite a previous command.
5493          */
5494         isp->isp_obits = obits;
5495         isp->isp_mboxbsy = 1;
5496
5497         /*
5498          * Set Host Interrupt condition so that RISC will pick up mailbox regs.
5499          */
5500         ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
5501
5502         /*
5503          * While we haven't finished the command, spin our wheels here.
5504          */
5505         MBOX_WAIT_COMPLETE(isp);
5506
5507         if (isp->isp_mboxbsy) {
5508                 /*
5509                  * Command timed out.
5510                  */
5511                 isp->isp_mboxbsy = 0;
5512                 MBOX_RELEASE(isp);
5513                 return;
5514         }
5515
5516         /*
5517          * Copy back output registers.
5518          */
5519         for (box = 0; box < MAX_MAILBOX(isp); box++) {
5520                 if (obits & (1 << box)) {
5521                         mbp->param[box] = isp->isp_mboxtmp[box];
5522                 }
5523         }
5524
5525         MBOX_RELEASE(isp);
5526
5527         if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
5528                 return;
5529         }
5530 #ifdef  ISP_STRIPPED
5531         cname = NULL;
5532 #else
5533         cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
5534 #endif
5535         if (cname == NULL) {
5536                 cname = tname;
5537                 SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
5538         }
5539
5540         /*
5541          * Just to be chatty here...
5542          */
5543         xname = NULL;
5544         switch (mbp->param[0]) {
5545         case MBOX_COMMAND_COMPLETE:
5546                 break;
5547         case MBOX_INVALID_COMMAND:
5548                 if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
5549                         xname = "INVALID COMMAND";
5550                 break;
5551         case MBOX_HOST_INTERFACE_ERROR:
5552                 if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
5553                         xname = "HOST INTERFACE ERROR";
5554                 break;
5555         case MBOX_TEST_FAILED:
5556                 if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
5557                         xname = "TEST FAILED";
5558                 break;
5559         case MBOX_COMMAND_ERROR:
5560                 if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
5561                         xname = "COMMAND ERROR";
5562                 break;
5563         case MBOX_COMMAND_PARAM_ERROR:
5564                 if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
5565                         xname = "COMMAND PARAMETER ERROR";
5566                 break;
5567         case MBOX_LOOP_ID_USED:
5568                 if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
5569                         xname = "LOOP ID ALREADY IN USE";
5570                 break;
5571         case MBOX_PORT_ID_USED:
5572                 if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
5573                         xname = "PORT ID ALREADY IN USE";
5574                 break;
5575         case MBOX_ALL_IDS_USED:
5576                 if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
5577                         xname = "ALL LOOP IDS IN USE";
5578                 break;
5579         case 0:         /* special case */
5580                 xname = "TIMEOUT";
5581                 break;
5582         default:
5583                 SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
5584                 xname = mname;
5585                 break;
5586         }
5587         if (xname)
5588                 isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
5589                     cname, xname);
5590 }
5591
5592 static void
5593 isp_fw_state(ispsoftc_t *isp)
5594 {
5595         if (IS_FC(isp)) {
5596                 mbreg_t mbs;
5597                 fcparam *fcp = isp->isp_param;
5598
5599                 MEMZERO(&mbs, sizeof (mbs));
5600                 mbs.param[0] = MBOX_GET_FW_STATE;
5601                 isp_mboxcmd(isp, &mbs, MBLOGALL);
5602                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
5603                         fcp->isp_fwstate = mbs.param[1];
5604                 }
5605         }
5606 }
5607
5608 static void
5609 isp_update(ispsoftc_t *isp)
5610 {
5611         int bus, upmask;
5612
5613         for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
5614                 if (upmask & (1 << bus)) {
5615                         isp_update_bus(isp, bus);
5616                 }
5617                 upmask &= ~(1 << bus);
5618         }
5619 }
5620
5621 static void
5622 isp_update_bus(ispsoftc_t *isp, int bus)
5623 {
5624         int tgt;
5625         mbreg_t mbs;
5626         sdparam *sdp;
5627
5628         isp->isp_update &= ~(1 << bus);
5629         if (IS_FC(isp)) {
5630                 /*
5631                  * There are no 'per-bus' settings for Fibre Channel.
5632                  */
5633                 return;
5634         }
5635         sdp = isp->isp_param;
5636         sdp += bus;
5637         MEMZERO(&mbs, sizeof (mbs));
5638
5639         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5640                 uint16_t flags, period, offset;
5641                 int get;
5642
5643                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
5644                         sdp->isp_devparam[tgt].dev_update = 0;
5645                         sdp->isp_devparam[tgt].dev_refresh = 0;
5646                         isp_prt(isp, ISP_LOGDEBUG0,
5647                             "skipping target %d bus %d update", tgt, bus);
5648                         continue;
5649                 }
5650                 /*
5651                  * If the goal is to update the status of the device,
5652                  * take what's in goal_flags and try and set the device
5653                  * toward that. Otherwise, if we're just refreshing the
5654                  * current device state, get the current parameters.
5655                  */
5656
5657                 /*
5658                  * Refresh overrides set
5659                  */
5660                 if (sdp->isp_devparam[tgt].dev_refresh) {
5661                         mbs.param[0] = MBOX_GET_TARGET_PARAMS;
5662                         sdp->isp_devparam[tgt].dev_refresh = 0;
5663                         get = 1;
5664                 } else if (sdp->isp_devparam[tgt].dev_update) {
5665                         mbs.param[0] = MBOX_SET_TARGET_PARAMS;
5666                         /*
5667                          * Make sure goal_flags has "Renegotiate on Error"
5668                          * on and "Freeze Queue on Error" off.
5669                          */
5670                         sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
5671                         sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
5672
5673                         mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
5674
5675                         /*
5676                          * Insist that PARITY must be enabled
5677                          * if SYNC or WIDE is enabled.
5678                          */
5679                         if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
5680                                 mbs.param[2] |= DPARM_PARITY;
5681                         }
5682
5683                         if ((mbs.param[2] & DPARM_SYNC) == 0) {
5684                                 mbs.param[3] = 0;
5685                         } else {
5686                                 mbs.param[3] =
5687                                     (sdp->isp_devparam[tgt].goal_offset << 8) |
5688                                     (sdp->isp_devparam[tgt].goal_period);
5689                         }
5690                         /*
5691                          * A command completion later that has
5692                          * RQSTF_NEGOTIATION set can cause
5693                          * the dev_refresh/announce cycle also.
5694                          *
5695                          * Note: It is really important to update our current
5696                          * flags with at least the state of TAG capabilities-
5697                          * otherwise we might try and send a tagged command
5698                          * when we have it all turned off. So change it here
5699                          * to say that current already matches goal.
5700                          */
5701                         sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
5702                         sdp->isp_devparam[tgt].actv_flags |=
5703                             (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
5704                         isp_prt(isp, ISP_LOGDEBUG0,
5705                             "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
5706                             bus, tgt, mbs.param[2], mbs.param[3] >> 8,
5707                             mbs.param[3] & 0xff);
5708                         sdp->isp_devparam[tgt].dev_update = 0;
5709                         sdp->isp_devparam[tgt].dev_refresh = 1;
5710                         get = 0;
5711                 } else {
5712                         continue;
5713                 }
5714                 mbs.param[1] = (bus << 15) | (tgt << 8);
5715                 isp_mboxcmd(isp, &mbs, MBLOGALL);
5716                 if (get == 0) {
5717                         isp->isp_sendmarker |= (1 << bus);
5718                         continue;
5719                 }
5720                 flags = mbs.param[2];
5721                 period = mbs.param[3] & 0xff;
5722                 offset = mbs.param[3] >> 8;
5723                 sdp->isp_devparam[tgt].actv_flags = flags;
5724                 sdp->isp_devparam[tgt].actv_period = period;
5725                 sdp->isp_devparam[tgt].actv_offset = offset;
5726                 get = (bus << 16) | tgt;
5727                 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
5728         }
5729
5730         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5731                 if (sdp->isp_devparam[tgt].dev_update ||
5732                     sdp->isp_devparam[tgt].dev_refresh) {
5733                         isp->isp_update |= (1 << bus);
5734                         break;
5735                 }
5736         }
5737 }
5738
5739 #ifndef DEFAULT_FRAMESIZE
5740 #define DEFAULT_FRAMESIZE(isp)          ICB_DFLT_FRMLEN
5741 #endif
5742 #ifndef DEFAULT_EXEC_THROTTLE
5743 #define DEFAULT_EXEC_THROTTLE(isp)      ISP_EXEC_THROTTLE
5744 #endif
5745
5746 static void
5747 isp_setdfltparm(ispsoftc_t *isp, int channel)
5748 {
5749         int tgt;
5750         mbreg_t mbs;
5751         sdparam *sdp;
5752
5753         MEMZERO(&mbs, sizeof (mbs));
5754         if (IS_FC(isp)) {
5755                 fcparam *fcp = (fcparam *) isp->isp_param;
5756                 int nvfail;
5757
5758                 fcp += channel;
5759                 if (fcp->isp_gotdparms) {
5760                         return;
5761                 }
5762                 fcp->isp_gotdparms = 1;
5763                 fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
5764                 fcp->isp_maxalloc = ICB_DFLT_ALLOC;
5765                 fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
5766                 fcp->isp_retry_delay = ICB_DFLT_RDELAY;
5767                 fcp->isp_retry_count = ICB_DFLT_RCOUNT;
5768                 /* Platform specific.... */
5769                 fcp->isp_loopid = DEFAULT_LOOPID(isp);
5770                 fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
5771                 fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
5772                 fcp->isp_fwoptions = 0;
5773                 fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
5774                 fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
5775                 fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
5776 #ifndef ISP_NO_FASTPOST_FC
5777                 fcp->isp_fwoptions |= ICBOPT_FAST_POST;
5778 #endif
5779                 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
5780                         fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
5781
5782                 /*
5783                  * Make sure this is turned off now until we get
5784                  * extended options from NVRAM
5785                  */
5786                 fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
5787
5788                 /*
5789                  * Now try and read NVRAM unless told to not do so.
5790                  * This will set fcparam's isp_nodewwn && isp_portwwn.
5791                  */
5792                 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5793                         nvfail = isp_read_nvram(isp);
5794                         if (nvfail)
5795                                 isp->isp_confopts |= ISP_CFG_NONVRAM;
5796                 } else {
5797                         nvfail = 1;
5798                 }
5799                 /*
5800                  * Set node && port to override platform set defaults
5801                  * unless the nvram read failed (or none was done),
5802                  * or the platform code wants to use what had been
5803                  * set in the defaults.
5804                  */
5805                 if (nvfail) {
5806                         isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
5807                 }
5808                 if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
5809                         isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
5810                             (uint32_t) (DEFAULT_NODEWWN(isp) >> 32),
5811                             (uint32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
5812                         ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
5813                 } else {
5814                         /*
5815                          * We always start out with values derived
5816                          * from NVRAM or our platform default.
5817                          */
5818                         ISP_NODEWWN(isp) = fcp->isp_nodewwn;
5819                 }
5820                 if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
5821                         isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
5822                             (uint32_t) (DEFAULT_PORTWWN(isp) >> 32),
5823                             (uint32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
5824                         ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
5825                 } else {
5826                         /*
5827                          * We always start out with values derived
5828                          * from NVRAM or our platform default.
5829                          */
5830                         ISP_PORTWWN(isp) = fcp->isp_portwwn;
5831                 }
5832                 return;
5833         }
5834
5835         sdp = (sdparam *) isp->isp_param;
5836         sdp += channel;
5837
5838         /*
5839          * Been there, done that, got the T-shirt...
5840          */
5841         if (sdp->isp_gotdparms) {
5842                 return;
5843         }
5844         sdp->isp_gotdparms = 1;
5845
5846         /*
5847          * Establish some default parameters.
5848          */
5849         sdp->isp_cmd_dma_burst_enable = 0;
5850         sdp->isp_data_dma_burst_enabl = 1;
5851         sdp->isp_fifo_threshold = 0;
5852         sdp->isp_initiator_id = DEFAULT_IID(isp);
5853         if (isp->isp_type >= ISP_HA_SCSI_1040) {
5854                 sdp->isp_async_data_setup = 9;
5855         } else {
5856                 sdp->isp_async_data_setup = 6;
5857         }
5858         sdp->isp_selection_timeout = 250;
5859         sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
5860         sdp->isp_tag_aging = 8;
5861         sdp->isp_bus_reset_delay = 5;
5862         /*
5863          * Don't retry selection, busy or queue full automatically- reflect
5864          * these back to us.
5865          */
5866         sdp->isp_retry_count = 0;
5867         sdp->isp_retry_delay = 0;
5868
5869         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5870                 sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
5871                 sdp->isp_devparam[tgt].dev_enable = 1;
5872         }
5873
5874         /*
5875          * If we've not been told to avoid reading NVRAM, try and read it.
5876          * If we're successful reading it, we can then return because NVRAM
5877          * will tell us what the desired settings are. Otherwise, we establish
5878          * some reasonable 'fake' nvram and goal defaults.
5879          */
5880
5881         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5882                 if (isp_read_nvram(isp) == 0) {
5883                         return;
5884                 }
5885         }
5886
5887         /*
5888          * Now try and see whether we have specific values for them.
5889          */
5890         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
5891                 mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
5892                 isp_mboxcmd(isp, &mbs, MBLOGNONE);
5893                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
5894                         sdp->isp_req_ack_active_neg = 1;
5895                         sdp->isp_data_line_active_neg = 1;
5896                 } else {
5897                         sdp->isp_req_ack_active_neg =
5898                             (mbs.param[1+channel] >> 4) & 0x1;
5899                         sdp->isp_data_line_active_neg =
5900                             (mbs.param[1+channel] >> 5) & 0x1;
5901                 }
5902         }
5903
5904         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
5905             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
5906             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
5907             sdp->isp_retry_delay, sdp->isp_async_data_setup);
5908         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
5909             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
5910             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
5911             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
5912
5913         /*
5914          * The trick here is to establish a default for the default (honk!)
5915          * state (goal_flags). Then try and get the current status from
5916          * the card to fill in the current state. We don't, in fact, set
5917          * the default to the SAFE default state- that's not the goal state.
5918          */
5919         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
5920                 uint8_t off, per;
5921                 sdp->isp_devparam[tgt].actv_offset = 0;
5922                 sdp->isp_devparam[tgt].actv_period = 0;
5923                 sdp->isp_devparam[tgt].actv_flags = 0;
5924
5925                 sdp->isp_devparam[tgt].goal_flags =
5926                     sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
5927
5928                 /*
5929                  * We default to Wide/Fast for versions less than a 1040
5930                  * (unless it's SBus).
5931                  */
5932                 if (IS_ULTRA3(isp)) {
5933                         off = ISP_80M_SYNCPARMS >> 8;
5934                         per = ISP_80M_SYNCPARMS & 0xff;
5935                 } else if (IS_ULTRA2(isp)) {
5936                         off = ISP_40M_SYNCPARMS >> 8;
5937                         per = ISP_40M_SYNCPARMS & 0xff;
5938                 } else if (IS_1240(isp)) {
5939                         off = ISP_20M_SYNCPARMS >> 8;
5940                         per = ISP_20M_SYNCPARMS & 0xff;
5941                 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
5942                     isp->isp_type < ISP_HA_SCSI_1020A) ||
5943                     (isp->isp_bustype == ISP_BT_PCI &&
5944                     isp->isp_type < ISP_HA_SCSI_1040) ||
5945                     (isp->isp_clock && isp->isp_clock < 60) ||
5946                     (sdp->isp_ultramode == 0)) {
5947                         off = ISP_10M_SYNCPARMS >> 8;
5948                         per = ISP_10M_SYNCPARMS & 0xff;
5949                 } else {
5950                         off = ISP_20M_SYNCPARMS_1040 >> 8;
5951                         per = ISP_20M_SYNCPARMS_1040 & 0xff;
5952                 }
5953                 sdp->isp_devparam[tgt].goal_offset =
5954                     sdp->isp_devparam[tgt].nvrm_offset = off;
5955                 sdp->isp_devparam[tgt].goal_period =
5956                     sdp->isp_devparam[tgt].nvrm_period = per;
5957
5958                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
5959                     channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
5960                     sdp->isp_devparam[tgt].nvrm_offset,
5961                     sdp->isp_devparam[tgt].nvrm_period);
5962         }
5963 }
5964
5965 /*
5966  * Re-initialize the ISP and complete all orphaned commands
5967  * with a 'botched' notice. The reset/init routines should
5968  * not disturb an already active list of commands.
5969  *
5970  * Locks held prior to coming here.
5971  */
5972
5973 void
5974 isp_reinit(ispsoftc_t *isp)
5975 {
5976         XS_T *xs;
5977         int i;
5978
5979         if (IS_FC(isp)) {
5980                 isp_mark_getpdb_all(isp);
5981         }
5982         isp_reset(isp);
5983         if (isp->isp_state != ISP_RESETSTATE) {
5984                 isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
5985         } else if (isp->isp_role != ISP_ROLE_NONE) {
5986                 isp_init(isp);
5987                 if (isp->isp_state == ISP_INITSTATE) {
5988                         isp->isp_state = ISP_RUNSTATE;
5989                 }
5990                 if (isp->isp_state != ISP_RUNSTATE) {
5991                         isp_prt(isp, ISP_LOGERR,
5992                             "isp_reinit cannot restart card");
5993                 }
5994         }
5995         isp->isp_nactive = 0;
5996
5997         for (i = 0; i < isp->isp_maxcmds; i++) {
5998                 uint16_t handle;
5999                 xs = isp->isp_xflist[i];
6000                 if (xs == NULL) {
6001                         continue;
6002                 }
6003                 handle = isp_index_handle(i);
6004                 isp_destroy_handle(isp, handle);
6005                 if (XS_XFRLEN(xs)) {
6006                         ISP_DMAFREE(isp, xs, handle);
6007                         XS_RESID(xs) = XS_XFRLEN(xs);
6008                 } else {
6009                         XS_RESID(xs) = 0;
6010                 }
6011                 XS_SETERR(xs, HBA_BUSRESET);
6012                 isp_done(xs);
6013         }
6014 }
6015
6016 /*
6017  * NVRAM Routines
6018  */
6019 static int
6020 isp_read_nvram(ispsoftc_t *isp)
6021 {
6022         int i, amt;
6023         uint8_t csum, minversion;
6024         union {
6025                 uint8_t _x[ISP2100_NVRAM_SIZE];
6026                 uint16_t _s[ISP2100_NVRAM_SIZE>>1];
6027         } _n;
6028 #define nvram_data      _n._x
6029 #define nvram_words     _n._s
6030
6031         if (IS_FC(isp)) {
6032                 amt = ISP2100_NVRAM_SIZE;
6033                 minversion = 1;
6034         } else if (IS_ULTRA2(isp)) {
6035                 amt = ISP1080_NVRAM_SIZE;
6036                 minversion = 0;
6037         } else {
6038                 amt = ISP_NVRAM_SIZE;
6039                 minversion = 2;
6040         }
6041
6042         /*
6043          * Just read the first two words first to see if we have a valid
6044          * NVRAM to continue reading the rest with.
6045          */
6046         for (i = 0; i < 2; i++) {
6047                 isp_rdnvram_word(isp, i, &nvram_words[i]);
6048         }
6049         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
6050             nvram_data[2] != 'P') {
6051                 if (isp->isp_bustype != ISP_BT_SBUS) {
6052                         isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
6053                         isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
6054                             nvram_data[0], nvram_data[1], nvram_data[2]);
6055                 }
6056                 return (-1);
6057         }
6058         for (i = 2; i < amt>>1; i++) {
6059                 isp_rdnvram_word(isp, i, &nvram_words[i]);
6060         }
6061         for (csum = 0, i = 0; i < amt; i++) {
6062                 csum += nvram_data[i];
6063         }
6064         if (csum != 0) {
6065                 isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
6066                 return (-1);
6067         }
6068         if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
6069                 isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
6070                     ISP_NVRAM_VERSION(nvram_data));
6071                 return (-1);
6072         }
6073
6074         if (IS_ULTRA3(isp)) {
6075                 isp_parse_nvram_12160(isp, 0, nvram_data);
6076                 if (IS_12160(isp))
6077                         isp_parse_nvram_12160(isp, 1, nvram_data);
6078         } else if (IS_1080(isp)) {
6079                 isp_parse_nvram_1080(isp, 0, nvram_data);
6080         } else if (IS_1280(isp) || IS_1240(isp)) {
6081                 isp_parse_nvram_1080(isp, 0, nvram_data);
6082                 isp_parse_nvram_1080(isp, 1, nvram_data);
6083         } else if (IS_SCSI(isp)) {
6084                 isp_parse_nvram_1020(isp, nvram_data);
6085         } else {
6086                 isp_parse_nvram_2100(isp, nvram_data);
6087         }
6088         return (0);
6089 #undef  nvram_data
6090 #undef  nvram_words
6091 }
6092
6093 static void
6094 isp_rdnvram_word(ispsoftc_t *isp, int wo, uint16_t *rp)
6095 {
6096         int i, cbits;
6097         uint16_t bit, rqst;
6098
6099         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
6100         USEC_DELAY(2);
6101         ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
6102         USEC_DELAY(2);
6103
6104         if (IS_FC(isp)) {
6105                 wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
6106                 if (IS_2312(isp) && isp->isp_port) {
6107                         wo += 128;
6108                 }
6109                 rqst = (ISP_NVRAM_READ << 8) | wo;
6110                 cbits = 10;
6111         } else if (IS_ULTRA2(isp)) {
6112                 wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
6113                 rqst = (ISP_NVRAM_READ << 8) | wo;
6114                 cbits = 10;
6115         } else {
6116                 wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
6117                 rqst = (ISP_NVRAM_READ << 6) | wo;
6118                 cbits = 8;
6119         }
6120
6121         /*
6122          * Clock the word select request out...
6123          */
6124         for (i = cbits; i >= 0; i--) {
6125                 if ((rqst >> i) & 1) {
6126                         bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
6127                 } else {
6128                         bit = BIU_NVRAM_SELECT;
6129                 }
6130                 ISP_WRITE(isp, BIU_NVRAM, bit);
6131                 USEC_DELAY(2);
6132                 ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
6133                 USEC_DELAY(2);
6134                 ISP_WRITE(isp, BIU_NVRAM, bit);
6135                 USEC_DELAY(2);
6136         }
6137         /*
6138          * Now read the result back in (bits come back in MSB format).
6139          */
6140         *rp = 0;
6141         for (i = 0; i < 16; i++) {
6142                 uint16_t rv;
6143                 *rp <<= 1;
6144                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
6145                 USEC_DELAY(2);
6146                 rv = ISP_READ(isp, BIU_NVRAM);
6147                 if (rv & BIU_NVRAM_DATAIN) {
6148                         *rp |= 1;
6149                 }
6150                 USEC_DELAY(2);
6151                 ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
6152                 USEC_DELAY(2);
6153         }
6154         ISP_WRITE(isp, BIU_NVRAM, 0);
6155         USEC_DELAY(2);
6156         ISP_SWIZZLE_NVRAM_WORD(isp, rp);
6157 }
6158
6159 static void
6160 isp_parse_nvram_1020(ispsoftc_t *isp, uint8_t *nvram_data)
6161 {
6162         sdparam *sdp = (sdparam *) isp->isp_param;
6163         int tgt;
6164
6165         sdp->isp_fifo_threshold =
6166                 ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
6167                 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
6168
6169         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6170                 sdp->isp_initiator_id =
6171                         ISP_NVRAM_INITIATOR_ID(nvram_data);
6172
6173         sdp->isp_bus_reset_delay =
6174                 ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
6175
6176         sdp->isp_retry_count =
6177                 ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
6178
6179         sdp->isp_retry_delay =
6180                 ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
6181
6182         sdp->isp_async_data_setup =
6183                 ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
6184
6185         if (isp->isp_type >= ISP_HA_SCSI_1040) {
6186                 if (sdp->isp_async_data_setup < 9) {
6187                         sdp->isp_async_data_setup = 9;
6188                 }
6189         } else {
6190                 if (sdp->isp_async_data_setup != 6) {
6191                         sdp->isp_async_data_setup = 6;
6192                 }
6193         }
6194
6195         sdp->isp_req_ack_active_neg =
6196                 ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
6197
6198         sdp->isp_data_line_active_neg =
6199                 ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
6200
6201         sdp->isp_data_dma_burst_enabl =
6202                 ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
6203
6204         sdp->isp_cmd_dma_burst_enable =
6205                 ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
6206
6207         sdp->isp_tag_aging =
6208                 ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
6209
6210         sdp->isp_selection_timeout =
6211                 ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
6212
6213         sdp->isp_max_queue_depth =
6214                 ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
6215
6216         sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
6217
6218         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6219             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6220             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6221             sdp->isp_retry_delay, sdp->isp_async_data_setup);
6222         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6223             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6224             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6225             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6226
6227         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6228                 sdp->isp_devparam[tgt].dev_enable =
6229                         ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
6230                 sdp->isp_devparam[tgt].exc_throttle =
6231                         ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
6232                 sdp->isp_devparam[tgt].nvrm_offset =
6233                         ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
6234                 sdp->isp_devparam[tgt].nvrm_period =
6235                         ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
6236                 /*
6237                  * We probably shouldn't lie about this, but it
6238                  * it makes it much safer if we limit NVRAM values
6239                  * to sanity.
6240                  */
6241                 if (isp->isp_type < ISP_HA_SCSI_1040) {
6242                         /*
6243                          * If we're not ultra, we can't possibly
6244                          * be a shorter period than this.
6245                          */
6246                         if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
6247                                 sdp->isp_devparam[tgt].nvrm_period = 0x19;
6248                         }
6249                         if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
6250                                 sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
6251                         }
6252                 } else {
6253                         if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
6254                                 sdp->isp_devparam[tgt].nvrm_offset = 0x8;
6255                         }
6256                 }
6257                 sdp->isp_devparam[tgt].nvrm_flags = 0;
6258                 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
6259                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6260                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6261                 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
6262                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6263                 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
6264                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6265                 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
6266                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6267                 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
6268                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6269                 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
6270                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6271                 sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
6272                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6273                     0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6274                     sdp->isp_devparam[tgt].nvrm_offset,
6275                     sdp->isp_devparam[tgt].nvrm_period);
6276                 sdp->isp_devparam[tgt].goal_offset =
6277                     sdp->isp_devparam[tgt].nvrm_offset;
6278                 sdp->isp_devparam[tgt].goal_period =
6279                     sdp->isp_devparam[tgt].nvrm_period;
6280                 sdp->isp_devparam[tgt].goal_flags =
6281                     sdp->isp_devparam[tgt].nvrm_flags;
6282         }
6283 }
6284
6285 static void
6286 isp_parse_nvram_1080(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
6287 {
6288         sdparam *sdp = (sdparam *) isp->isp_param;
6289         int tgt;
6290
6291         sdp += bus;
6292
6293         sdp->isp_fifo_threshold =
6294             ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
6295
6296         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6297                 sdp->isp_initiator_id =
6298                     ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
6299
6300         sdp->isp_bus_reset_delay =
6301             ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
6302
6303         sdp->isp_retry_count =
6304             ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
6305
6306         sdp->isp_retry_delay =
6307             ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
6308
6309         sdp->isp_async_data_setup =
6310             ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
6311
6312         sdp->isp_req_ack_active_neg =
6313             ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
6314
6315         sdp->isp_data_line_active_neg =
6316             ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
6317
6318         sdp->isp_data_dma_burst_enabl =
6319             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
6320
6321         sdp->isp_cmd_dma_burst_enable =
6322             ISP1080_NVRAM_BURST_ENABLE(nvram_data);
6323
6324         sdp->isp_selection_timeout =
6325             ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
6326
6327         sdp->isp_max_queue_depth =
6328              ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
6329
6330         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6331             bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6332             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6333             sdp->isp_retry_delay, sdp->isp_async_data_setup);
6334         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6335             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6336             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6337             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6338
6339
6340         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6341                 sdp->isp_devparam[tgt].dev_enable =
6342                     ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
6343                 sdp->isp_devparam[tgt].exc_throttle =
6344                         ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
6345                 sdp->isp_devparam[tgt].nvrm_offset =
6346                         ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
6347                 sdp->isp_devparam[tgt].nvrm_period =
6348                         ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
6349                 sdp->isp_devparam[tgt].nvrm_flags = 0;
6350                 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
6351                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6352                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6353                 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
6354                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6355                 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
6356                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6357                 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
6358                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6359                 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
6360                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6361                 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
6362                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6363                 sdp->isp_devparam[tgt].actv_flags = 0;
6364                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6365                     bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6366                     sdp->isp_devparam[tgt].nvrm_offset,
6367                     sdp->isp_devparam[tgt].nvrm_period);
6368                 sdp->isp_devparam[tgt].goal_offset =
6369                     sdp->isp_devparam[tgt].nvrm_offset;
6370                 sdp->isp_devparam[tgt].goal_period =
6371                     sdp->isp_devparam[tgt].nvrm_period;
6372                 sdp->isp_devparam[tgt].goal_flags =
6373                     sdp->isp_devparam[tgt].nvrm_flags;
6374         }
6375 }
6376
6377 static void
6378 isp_parse_nvram_12160(ispsoftc_t *isp, int bus, uint8_t *nvram_data)
6379 {
6380         sdparam *sdp = (sdparam *) isp->isp_param;
6381         int tgt;
6382
6383         sdp += bus;
6384
6385         sdp->isp_fifo_threshold =
6386             ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
6387
6388         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6389                 sdp->isp_initiator_id =
6390                     ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
6391
6392         sdp->isp_bus_reset_delay =
6393             ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
6394
6395         sdp->isp_retry_count =
6396             ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
6397
6398         sdp->isp_retry_delay =
6399             ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
6400
6401         sdp->isp_async_data_setup =
6402             ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
6403
6404         sdp->isp_req_ack_active_neg =
6405             ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
6406
6407         sdp->isp_data_line_active_neg =
6408             ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
6409
6410         sdp->isp_data_dma_burst_enabl =
6411             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
6412
6413         sdp->isp_cmd_dma_burst_enable =
6414             ISP12160_NVRAM_BURST_ENABLE(nvram_data);
6415
6416         sdp->isp_selection_timeout =
6417             ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
6418
6419         sdp->isp_max_queue_depth =
6420              ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
6421
6422         isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
6423             bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
6424             sdp->isp_bus_reset_delay, sdp->isp_retry_count,
6425             sdp->isp_retry_delay, sdp->isp_async_data_setup);
6426         isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
6427             sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
6428             sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
6429             sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
6430
6431         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
6432                 sdp->isp_devparam[tgt].dev_enable =
6433                     ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
6434                 sdp->isp_devparam[tgt].exc_throttle =
6435                         ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
6436                 sdp->isp_devparam[tgt].nvrm_offset =
6437                         ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
6438                 sdp->isp_devparam[tgt].nvrm_period =
6439                         ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
6440                 sdp->isp_devparam[tgt].nvrm_flags = 0;
6441                 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
6442                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
6443                 sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
6444                 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
6445                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
6446                 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
6447                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
6448                 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
6449                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
6450                 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
6451                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
6452                 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
6453                         sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
6454                 sdp->isp_devparam[tgt].actv_flags = 0;
6455                 isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
6456                     bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
6457                     sdp->isp_devparam[tgt].nvrm_offset,
6458                     sdp->isp_devparam[tgt].nvrm_period);
6459                 sdp->isp_devparam[tgt].goal_offset =
6460                     sdp->isp_devparam[tgt].nvrm_offset;
6461                 sdp->isp_devparam[tgt].goal_period =
6462                     sdp->isp_devparam[tgt].nvrm_period;
6463                 sdp->isp_devparam[tgt].goal_flags =
6464                     sdp->isp_devparam[tgt].nvrm_flags;
6465         }
6466 }
6467
6468 static void
6469 isp_parse_nvram_2100(ispsoftc_t *isp, uint8_t *nvram_data)
6470 {
6471         fcparam *fcp = (fcparam *) isp->isp_param;
6472         uint64_t wwn;
6473
6474         /*
6475          * There is NVRAM storage for both Port and Node entities-
6476          * but the Node entity appears to be unused on all the cards
6477          * I can find. However, we should account for this being set
6478          * at some point in the future.
6479          *
6480          * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
6481          * bits 48..60. In the case of the 2202, it appears that they do
6482          * use bit 48 to distinguish between the two instances on the card.
6483          * The 2204, which I've never seen, *probably* extends this method.
6484          */
6485         wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
6486         if (wwn) {
6487                 isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
6488                     (uint32_t) (wwn >> 32), (uint32_t) (wwn & 0xffffffff));
6489                 if ((wwn >> 60) == 0) {
6490                         wwn |= (((uint64_t) 2)<< 60);
6491                 }
6492         }
6493         fcp->isp_portwwn = wwn;
6494         if (IS_2200(isp) || IS_23XX(isp)) {
6495                 wwn = ISP2200_NVRAM_NODE_NAME(nvram_data);
6496                 if (wwn) {
6497                         isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
6498                             (uint32_t) (wwn >> 32),
6499                             (uint32_t) (wwn & 0xffffffff));
6500                         if ((wwn >> 60) == 0) {
6501                                 wwn |= (((uint64_t) 2)<< 60);
6502                         }
6503                 }
6504         } else {
6505                 wwn &= ~((uint64_t) 0xfff << 48);
6506         }
6507         fcp->isp_nodewwn = wwn;
6508
6509         /*
6510          * Make sure we have both Node and Port as non-zero values.
6511          */
6512         if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) {
6513                 fcp->isp_portwwn = fcp->isp_nodewwn;
6514         } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) {
6515                 fcp->isp_nodewwn = fcp->isp_portwwn;
6516         }
6517
6518         /*
6519          * Make the Node and Port values sane if they're NAA == 2.
6520          * This means to clear bits 48..56 for the Node WWN and
6521          * make sure that there's some non-zero value in 48..56
6522          * for the Port WWN.
6523          */
6524         if (fcp->isp_nodewwn && fcp->isp_portwwn) {
6525                 if ((fcp->isp_nodewwn & (((uint64_t) 0xfff) << 48)) != 0 &&
6526                     (fcp->isp_nodewwn >> 60) == 2) {
6527                         fcp->isp_nodewwn &= ~((uint64_t) 0xfff << 48);
6528                 }
6529                 if ((fcp->isp_portwwn & (((uint64_t) 0xfff) << 48)) == 0 &&
6530                     (fcp->isp_portwwn >> 60) == 2) {
6531                         fcp->isp_portwwn |= ((uint64_t) 1 << 56);
6532                 }
6533         }
6534
6535         isp_prt(isp, ISP_LOGDEBUG0,
6536             "NVRAM: maxfrmlen %d execthrottle %d fwoptions 0x%x loopid %x",
6537             ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data),
6538             ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
6539             ISP2100_NVRAM_OPTIONS(nvram_data),
6540             ISP2100_NVRAM_HARDLOOPID(nvram_data));
6541
6542         fcp->isp_maxalloc =
6543                 ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
6544         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0)
6545                 fcp->isp_maxfrmlen =
6546                         ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
6547         fcp->isp_retry_delay =
6548                 ISP2100_NVRAM_RETRY_DELAY(nvram_data);
6549         fcp->isp_retry_count =
6550                 ISP2100_NVRAM_RETRY_COUNT(nvram_data);
6551         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
6552                 fcp->isp_loopid =
6553                         ISP2100_NVRAM_HARDLOOPID(nvram_data);
6554         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0)
6555                 fcp->isp_execthrottle =
6556                         ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
6557         fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
6558 }
6559
6560 #ifdef  ISP_FW_CRASH_DUMP
6561 static void isp2200_fw_dump(ispsoftc_t *);
6562 static void isp2300_fw_dump(ispsoftc_t *);
6563
6564 static void
6565 isp2200_fw_dump(ispsoftc_t *isp)
6566 {
6567         int i, j;
6568         mbreg_t mbs;
6569         uint16_t *ptr;
6570
6571         MEMZERO(&mbs, sizeof (mbs));
6572         ptr = FCPARAM(isp)->isp_dump_data;
6573         if (ptr == NULL) {
6574                 isp_prt(isp, ISP_LOGERR,
6575                    "No place to dump RISC registers and SRAM");
6576                 return;
6577         }
6578         if (*ptr++) {
6579                 isp_prt(isp, ISP_LOGERR,
6580                    "dump area for RISC registers and SRAM already used");
6581                 return;
6582         }
6583         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6584         for (i = 0; i < 100; i++) {
6585                 USEC_DELAY(100);
6586                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6587                         break;
6588                 }
6589         }
6590         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6591                 /*
6592                  * PBIU Registers
6593                  */
6594                 for (i = 0; i < 8; i++) {
6595                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
6596                 }
6597
6598                 /*
6599                  * Mailbox Registers
6600                  */
6601                 for (i = 0; i < 8; i++) {
6602                         *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
6603                 }
6604
6605                 /*
6606                  * DMA Registers
6607                  */
6608                 for (i = 0; i < 48; i++) {
6609                         *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
6610                 }
6611
6612                 /*
6613                  * RISC H/W Registers
6614                  */
6615                 ISP_WRITE(isp, BIU2100_CSR, 0);
6616                 for (i = 0; i < 16; i++) {
6617                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
6618                 }
6619
6620                 /*
6621                  * RISC GP Registers
6622                  */
6623                 for (j = 0; j < 8; j++) {
6624                         ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
6625                         for (i = 0; i < 16; i++) {
6626                                 *ptr++ =
6627                                     ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6628                         }
6629                 }
6630
6631                 /*
6632                  * Frame Buffer Hardware Registers
6633                  */
6634                 ISP_WRITE(isp, BIU2100_CSR, 0x10);
6635                 for (i = 0; i < 16; i++) {
6636                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6637                 }
6638
6639                 /*
6640                  * Fibre Protocol Module 0 Hardware Registers
6641                  */
6642                 ISP_WRITE(isp, BIU2100_CSR, 0x20);
6643                 for (i = 0; i < 64; i++) {
6644                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6645                 }
6646
6647                 /*
6648                  * Fibre Protocol Module 1 Hardware Registers
6649                  */
6650                 ISP_WRITE(isp, BIU2100_CSR, 0x30);
6651                 for (i = 0; i < 64; i++) {
6652                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6653                 }
6654         } else {
6655                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
6656                 return;
6657         }
6658         isp_prt(isp, ISP_LOGALL,
6659            "isp_fw_dump: RISC registers dumped successfully");
6660         ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
6661         for (i = 0; i < 100; i++) {
6662                 USEC_DELAY(100);
6663                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
6664                         break;
6665                 }
6666         }
6667         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
6668                 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
6669                 return;
6670         }
6671         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6672         for (i = 0; i < 100; i++) {
6673                 USEC_DELAY(100);
6674                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6675                         break;
6676                 }
6677         }
6678         if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
6679                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
6680                 return;
6681         }
6682         ISP_WRITE(isp, RISC_EMB, 0xf2);
6683         ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
6684         for (i = 0; i < 100; i++) {
6685                 USEC_DELAY(100);
6686                 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
6687                         break;
6688                 }
6689         }
6690         ENABLE_INTS(isp);
6691         mbs.param[0] = MBOX_READ_RAM_WORD;
6692         mbs.param[1] = 0x1000;
6693         isp->isp_mbxworkp = (void *) ptr;
6694         isp->isp_mbxwrk0 = 0xefff;      /* continuation count */
6695         isp->isp_mbxwrk1 = 0x1001;      /* next SRAM address */
6696         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6697         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6698                 isp_prt(isp, ISP_LOGWARN,
6699                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
6700                 return;
6701         }
6702         ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
6703         *ptr++ = isp->isp_mboxtmp[2];
6704         isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
6705         FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
6706         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
6707 }
6708
6709 static void
6710 isp2300_fw_dump(ispsoftc_t *isp)
6711 {
6712         int i, j;
6713         mbreg_t mbs;
6714         uint16_t *ptr;
6715
6716         MEMZERO(&mbs, sizeof (mbs));
6717         ptr = FCPARAM(isp)->isp_dump_data;
6718         if (ptr == NULL) {
6719                 isp_prt(isp, ISP_LOGERR,
6720                    "No place to dump RISC registers and SRAM");
6721                 return;
6722         }
6723         if (*ptr++) {
6724                 isp_prt(isp, ISP_LOGERR,
6725                    "dump area for RISC registers and SRAM already used");
6726                 return;
6727         }
6728         ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
6729         for (i = 0; i < 100; i++) {
6730                 USEC_DELAY(100);
6731                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6732                         break;
6733                 }
6734         }
6735         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
6736                 /*
6737                  * PBIU registers
6738                  */
6739                 for (i = 0; i < 8; i++) {
6740                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
6741                 }
6742
6743                 /*
6744                  * ReqQ-RspQ-Risc2Host Status registers
6745                  */
6746                 for (i = 0; i < 8; i++) {
6747                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
6748                 }
6749
6750                 /*
6751                  * Mailbox Registers
6752                  */
6753                 for (i = 0; i < 32; i++) {
6754                         *ptr++ =
6755                             ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
6756                 }
6757
6758                 /*
6759                  * Auto Request Response DMA registers
6760                  */
6761                 ISP_WRITE(isp, BIU2100_CSR, 0x40);
6762                 for (i = 0; i < 32; i++) {
6763                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6764                 }
6765
6766                 /*
6767                  * DMA registers
6768                  */
6769                 ISP_WRITE(isp, BIU2100_CSR, 0x50);
6770                 for (i = 0; i < 48; i++) {
6771                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6772                 }
6773
6774                 /*
6775                  * RISC hardware registers
6776                  */
6777                 ISP_WRITE(isp, BIU2100_CSR, 0);
6778                 for (i = 0; i < 16; i++) {
6779                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
6780                 }
6781
6782                 /*
6783                  * RISC GP? registers
6784                  */
6785                 for (j = 0; j < 8; j++) {
6786                         ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
6787                         for (i = 0; i < 16; i++) {
6788                                 *ptr++ =
6789                                     ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6790                         }
6791                 }
6792
6793                 /*
6794                  * frame buffer hardware registers
6795                  */
6796                 ISP_WRITE(isp, BIU2100_CSR, 0x10);
6797                 for (i = 0; i < 64; i++) {
6798                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6799                 }
6800
6801                 /*
6802                  * FPM B0 hardware registers
6803                  */
6804                 ISP_WRITE(isp, BIU2100_CSR, 0x20);
6805                 for (i = 0; i < 64; i++) {
6806                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6807                 }
6808
6809                 /*
6810                  * FPM B1 hardware registers
6811                  */
6812                 ISP_WRITE(isp, BIU2100_CSR, 0x30);
6813                 for (i = 0; i < 64; i++) {
6814                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
6815                 }
6816         } else {
6817                 isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
6818                 return;
6819         }
6820         isp_prt(isp, ISP_LOGALL,
6821            "isp_fw_dump: RISC registers dumped successfully");
6822         ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
6823         for (i = 0; i < 100; i++) {
6824                 USEC_DELAY(100);
6825                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
6826                         break;
6827                 }
6828         }
6829         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
6830                 isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
6831                 return;
6832         }
6833         ENABLE_INTS(isp);
6834         mbs.param[0] = MBOX_READ_RAM_WORD;
6835         mbs.param[1] = 0x800;
6836         isp->isp_mbxworkp = (void *) ptr;
6837         isp->isp_mbxwrk0 = 0xf7ff;      /* continuation count */
6838         isp->isp_mbxwrk1 = 0x801;       /* next SRAM address */
6839         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6840         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6841                 isp_prt(isp, ISP_LOGWARN,
6842                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
6843                 return;
6844         }
6845         ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
6846         *ptr++ = isp->isp_mboxtmp[2];
6847
6848         /*
6849          * We don't have access to mailbox registers 8.. onward
6850          * in our 'common' device model- so we have to set it
6851          * here and hope it stays the same!
6852          */
6853         ISP_WRITE(isp, PCI_MBOX_REGS2300_OFF + (8 << 1), 0x1);
6854
6855         mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
6856         mbs.param[1] = 0;
6857         isp->isp_mbxworkp = (void *) ptr;
6858         isp->isp_mbxwrk0 = 0xffff;      /* continuation count */
6859         isp->isp_mbxwrk1 = 0x1;         /* next SRAM address */
6860         isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
6861         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
6862                 isp_prt(isp, ISP_LOGWARN,
6863                     "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
6864                 return;
6865         }
6866         ptr = isp->isp_mbxworkp;        /* finish final word */
6867         *ptr++ = mbs.param[2];
6868         isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
6869         FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
6870         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
6871 }
6872
6873 void
6874 isp_fw_dump(ispsoftc_t *isp)
6875 {
6876         if (IS_2200(isp))
6877                 isp2200_fw_dump(isp);
6878         else if (IS_23XX(isp))
6879                 isp2300_fw_dump(isp);
6880 }
6881 #endif