The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/ic/isp.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: c86ad9763a3faf6b35a36ed98cff7226


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.