sys/dev/disk/isp/isp.c

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