sys/dev/isp/isp.c

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