root/dev/ic/isp.c

DEFINITIONS

1. isp_reset
2. isp_init
3. isp_scsi_init
4. isp_scsi_channel_init
5. isp_fibre_init
6. isp_getmap
7. isp_mark_getpdb_all
8. isp_getpdb
9. isp_get_portname
10. isp_fclink_test
11. isp2100_fw_statename
12. isp_pdb_sync
13. isp_scan_loop
14. isp_fabric_mbox_cmd
15. isp_scan_fabric
16. isp_scan_fabric
17. isp_register_fc4_type
18. isp_start
19. isp_control
20. isp_intr
21. isp_parse_async
22. isp_handle_other_response
23. isp_parse_status
24. isp_fastpost_complete
25. isp_mbox_continue
26. isp_mboxcmd_qnw
27. isp_mboxcmd
28. isp_fw_state
29. isp_update
30. isp_update_bus
31. isp_setdfltparm
32. isp_reinit
33. isp_read_nvram
34. isp_rdnvram_word
35. isp_parse_nvram_1020
36. isp_parse_nvram_1080
37. isp_parse_nvram_12160
38. isp_parse_nvram_2100
39. isp2200_fw_dump
40. isp2300_fw_dump
41. isp_fw_dump

    1 /*      $OpenBSD: isp.c,v 1.39 2007/05/23 01:32:25 ray Exp $ */
    2 /*
    3  * Machine and OS Independent (well, as best as possible)
    4  * code for the Qlogic ISP SCSI adapters.
    5  *
    6  * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob
    7  * Feral Software
    8  * All rights reserved.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice immediately at the beginning of the file, without modification,
   15  *    this list of conditions, and the following disclaimer.
   16  * 2. The name of the author may not be used to endorse or promote products
   17  *    derived from this software without specific prior written permission.
   18  *
   19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   22  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
   23  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   29  * SUCH DAMAGE.
   30  */
   32 /*
   33  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
   34  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
   35  * ideas dredged from the Solaris driver.
   36  */
   38 /*
   39  * Include header file appropriate for platform we're building on.
   40  */
   42 #ifdef  __NetBSD__
   43 #include <dev/ic/isp_netbsd.h>
   44 #endif
   45 #ifdef  __FreeBSD__
   46 #include <dev/isp/isp_freebsd.h>
   47 #endif
   48 #ifdef  __OpenBSD__
   49 #include <dev/ic/isp_openbsd.h>
   50 #endif
   51 #ifdef  __linux__
   52 #include "isp_linux.h"
   53 #endif
   54 #ifdef  __svr4__
   55 #include "isp_solaris.h"
   56 #endif
   58 /*
   59  * General defines
   60  */
   62 #define MBOX_DELAY_COUNT        1000000 / 100
   64 /*
   65  * Local static data
   66  */
   67 static const char portshift[] =
   68     "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
   69 static const char portdup[] =
   70     "Target %d duplicates Target %d- killing off both";
   71 static const char retained[] =
   72     "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
   73 static const char lretained[] =
   74     "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
   75 static const char plogout[] =
   76     "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
   77 static const char plogierr[] =
   78     "Command Error in PLOGI for Port 0x%x (0x%x)";
   79 static const char nopdb[] =
   80     "Could not get PDB for Device @ Port 0x%x";
   81 static const char pdbmfail1[] =
   82     "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
   83 static const char pdbmfail2[] =
   84     "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
   85 static const char ldumped[] =
   86     "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
   87 static const char notresp[] =
   88   "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";
   89 static const char xact1[] =
   90     "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
   91 static const char xact2[] =
   92     "HBA attempted queued transaction to target routine %d on target %d bus %d";
   93 static const char xact3[] =
   94     "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
   95 static const char pskip[] =
   96     "SCSI phase skipped for target %d.%d.%d";
   97 static const char topology[] =
   98     "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
   99 static const char swrej[] =
  100     "Fabric Nameserver rejected %s (Reason=0x%x Expl=0x%x) for Port ID 0x%x";
  101 static const char finmsg[] =
  102     "(%d.%d.%d): FIN dl%d resid %lu STS 0x%x SKEY %c XS_ERR=0x%x";
  103 static const char sc0[] =
  104     "%s CHAN %d FTHRSH %d IID %d RESETD %d RETRYC %d RETRYD %d ASD 0x%x";
  105 static const char sc1[] =
  106     "%s RAAN 0x%x DLAN 0x%x DDMAB 0x%x CDMAB 0x%x SELTIME %d MQD %d";
  107 static const char sc2[] = "%s CHAN %d TGT %d FLAGS 0x%x 0x%x/0x%x";
  108 static const char sc3[] = "Generated";
  109 static const char sc4[] = "NVRAM";
  110 static const char bun[] =
  111     "bad underrun for %d.%d (count %d, resid %d, status %s)";
  113 /*
  114  * Local function prototypes.
  115  */
  116 static int isp_parse_async(struct ispsoftc *, u_int16_t);
  117 static int isp_handle_other_response(struct ispsoftc *, int, isphdr_t *,
u_int16_t *);
  119 static void
isp_parse_status(struct ispsoftc *, ispstatusreq_t *, XS_T *);
  121 static void isp_fastpost_complete(struct ispsoftc *, u_int16_t);
  122 static int isp_mbox_continue(struct ispsoftc *);
  123 static void isp_scsi_init(struct ispsoftc *);
  124 static void isp_scsi_channel_init(struct ispsoftc *, int);
  125 static void isp_fibre_init(struct ispsoftc *);
  126 static void isp_mark_getpdb_all(struct ispsoftc *);
  127 static int isp_getmap(struct ispsoftc *, fcpos_map_t *);
  128 static int isp_getpdb(struct ispsoftc *, int, isp_pdb_t *);
  129 static u_int64_t isp_get_portname(struct ispsoftc *, int, int);
  130 static int isp_fclink_test(struct ispsoftc *, int);
  131 static char *isp2100_fw_statename(int);
  132 static int isp_pdb_sync(struct ispsoftc *);
  133 static int isp_scan_loop(struct ispsoftc *);
  134 static int isp_fabric_mbox_cmd(struct ispsoftc *, mbreg_t *);
  135 static int isp_scan_fabric(struct ispsoftc *, int);
  136 static void isp_register_fc4_type(struct ispsoftc *);
  137 static void isp_fw_state(struct ispsoftc *);
  138 static void isp_mboxcmd_qnw(struct ispsoftc *, mbreg_t *, int);
  139 static void isp_mboxcmd(struct ispsoftc *, mbreg_t *, int);
  141 static void isp_update(struct ispsoftc *);
  142 static void isp_update_bus(struct ispsoftc *, int);
  143 static void isp_setdfltparm(struct ispsoftc *, int);
  144 static int isp_read_nvram(struct ispsoftc *);
  145 static void isp_rdnvram_word(struct ispsoftc *, int, u_int16_t *);
  146 static void isp_parse_nvram_1020(struct ispsoftc *, u_int8_t *);
  147 static void isp_parse_nvram_1080(struct ispsoftc *, int, u_int8_t *);
  148 static void isp_parse_nvram_12160(struct ispsoftc *, int, u_int8_t *);
  149 static void isp_parse_nvram_2100(struct ispsoftc *, u_int8_t *);
  151 /*
  152  * Reset Hardware.
  153  *
  154  * Hit the chip over the head, download new f/w if available and set it running.
  155  *
  156  * Locking done elsewhere.
  157  */
  159 void
isp_reset(struct ispsoftc *isp)
  161 {
mbreg_t mbs;
u_int16_t code_org;
  164         int loops, i, dodnld = 1;
  165         char *btype = "????";
isp->isp_state = ISP_NILSTATE;
  169         /*
  170          * Basic types (SCSI, FibreChannel and PCI or SBus)
  171          * have been set in the MD code. We figure out more
  172          * here. Possibly more refined types based upon PCI
  173          * identification. Chip revision has been gathered.
  174          *
  175          * After we've fired this chip up, zero out the conf1 register
  176          * for SCSI adapters and do other settings for the 2100.
  177          */
  179         /*
  180          * Get the current running firmware revision out of the
  181          * chip before we hit it over the head (if this is our
  182          * first time through). Note that we store this as the
  183          * 'ROM' firmware revision- which it may not be. In any
  184          * case, we don't really use this yet, but we may in
  185          * the future.
  186          */
  187         if (isp->isp_touched == 0) {
  188                 /*
  189                  * First see whether or not we're sitting in the ISP PROM.
  190                  * If we've just been reset, we'll have the string "ISP   "
  191                  * spread through outgoing mailbox registers 1-3. We do
  192                  * this for PCI cards because otherwise we really don't
  193                  * know what state the card is in and we could hang if
  194                  * we try this command otherwise.
  195                  *
  196                  * For SBus cards, we just do this because they almost
  197                  * certainly will be running firmware by now.
  198                  */
  199                 if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
  202                         /*
  203                          * Just in case it was paused...
  204                          */
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
  208                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
isp->isp_romfw_rev[0] = mbs.param[1];
isp->isp_romfw_rev[1] = mbs.param[2];
isp->isp_romfw_rev[2] = mbs.param[3];
  212                         }
  213                 }
isp->isp_touched = 1;
  215         }
DISABLE_INTS(isp);
  219         /*
  220          * Set up default request/response queue in-pointer/out-pointer
  221          * register indices.
  222          */
  223         if (IS_23XX(isp)) {
isp->isp_rqstinrp = BIU_REQINP;
isp->isp_rqstoutrp = BIU_REQOUTP;
isp->isp_respinrp = BIU_RSPINP;
isp->isp_respoutrp = BIU_RSPOUTP;
  228         } else {
isp->isp_rqstinrp = INMAILBOX4;
isp->isp_rqstoutrp = OUTMAILBOX4;
isp->isp_respinrp = OUTMAILBOX5;
isp->isp_respoutrp = INMAILBOX5;
  233         }
  235         /*
  236          * Put the board into PAUSE mode (so we can read the SXP registers
  237          * or write FPM/FBM registers).
  238          */
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
  241         if (IS_FC(isp)) {
  242                 switch (isp->isp_type) {
  243                 case ISP_HA_FC_2100:
btype = "2100";
  245                         break;
  246                 case ISP_HA_FC_2200:
btype = "2200";
  248                         break;
  249                 case ISP_HA_FC_2300:
btype = "2300";
  251                         break;
  252                 case ISP_HA_FC_2312:
btype = "2312";
  254                         break;
  255                 default:
  256                         break;
  257                 }
  258                 /*
  259                  * While we're paused, reset the FPM module and FBM fifos.
  260                  */
ISP_WRITE(isp, BIU2100_CSR, BIU2100_FPM0_REGS);
ISP_WRITE(isp, FPM_DIAG_CONFIG, FPM_SOFT_RESET);
ISP_WRITE(isp, BIU2100_CSR, BIU2100_FB_REGS);
ISP_WRITE(isp, FBM_CMD, FBMCMD_FIFO_RESET_ALL);
ISP_WRITE(isp, BIU2100_CSR, BIU2100_RISC_REGS);
  266         } else if (IS_1240(isp)) {
sdparam *sdp = isp->isp_param;
btype = "1240";
isp->isp_clock = 60;
sdp->isp_ultramode = 1;
sdp++;
sdp->isp_ultramode = 1;
  273                 /*
  274                  * XXX: Should probably do some bus sensing.
  275                  */
  276         } else if (IS_ULTRA2(isp)) {
  277                 static const char m[] = "bus %d is in %s Mode";
u_int16_t l;
sdparam *sdp = isp->isp_param;
isp->isp_clock = 100;
  283                 if (IS_1280(isp))
btype = "1280";
  285                 else if (IS_1080(isp))
btype = "1080";
  287                 else if (IS_10160(isp))
btype = "10160";
  289                 else if (IS_12160(isp))
btype = "12160";
  291                 else
btype = "<UNKLVD>";
l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK;
  295                 switch (l) {
  296                 case ISP1080_LVD_MODE:
sdp->isp_lvdmode = 1;
isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
  299                         break;
  300                 case ISP1080_HVD_MODE:
sdp->isp_diffmode = 1;
isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
  303                         break;
  304                 case ISP1080_SE_MODE:
sdp->isp_ultramode = 1;
isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
  307                         break;
  308                 default:
isp_prt(isp, ISP_LOGERR,
  310                             "unknown mode on bus %d (0x%x)", 0, l);
  311                         break;
  312                 }
  314                 if (IS_DUALBUS(isp)) {
sdp++;
l = ISP_READ(isp, SXP_PINS_DIFF|SXP_BANK1_SELECT);
l &= ISP1080_MODE_MASK;
  318                         switch(l) {
  319                         case ISP1080_LVD_MODE:
sdp->isp_lvdmode = 1;
isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
  322                                 break;
  323                         case ISP1080_HVD_MODE:
sdp->isp_diffmode = 1;
isp_prt(isp, ISP_LOGCONFIG,
m, 1, "Differential");
  327                                 break;
  328                         case ISP1080_SE_MODE:
sdp->isp_ultramode = 1;
isp_prt(isp, ISP_LOGCONFIG,
m, 1, "Single-Ended");
  332                                 break;
  333                         default:
isp_prt(isp, ISP_LOGERR,
  335                                     "unknown mode on bus %d (0x%x)", 1, l);
  336                                 break;
  337                         }
  338                 }
  339         } else {
sdparam *sdp = isp->isp_param;
i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
  342                 switch (i) {
  343                 default:
isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
  345                         /* FALLTHROUGH */
  346                 case 1:
btype = "1020";
isp->isp_type = ISP_HA_SCSI_1020;
isp->isp_clock = 40;
  350                         break;
  351                 case 2:
  352                         /*
  353                          * Some 1020A chips are Ultra Capable, but don't
  354                          * run the clock rate up for that unless told to
  355                          * do so by the Ultra Capable bits being set.
  356                          */
btype = "1020A";
isp->isp_type = ISP_HA_SCSI_1020A;
isp->isp_clock = 40;
  360                         break;
  361                 case 3:
btype = "1040";
isp->isp_type = ISP_HA_SCSI_1040;
isp->isp_clock = 60;
  365                         break;
  366                 case 4:
btype = "1040A";
isp->isp_type = ISP_HA_SCSI_1040A;
isp->isp_clock = 60;
  370                         break;
  371                 case 5:
btype = "1040B";
isp->isp_type = ISP_HA_SCSI_1040B;
isp->isp_clock = 60;
  375                         break;
  376                 case 6:
btype = "1040C";
isp->isp_type = ISP_HA_SCSI_1040C;
isp->isp_clock = 60;
  380                         break;
  381                 }
  382                 /*
  383                  * Now, while we're at it, gather info about ultra
  384                  * and/or differential mode.
  385                  */
  386                 if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
sdp->isp_diffmode = 1;
  389                 } else {
sdp->isp_diffmode = 0;
  391                 }
i = ISP_READ(isp, RISC_PSR);
  393                 if (isp->isp_bustype == ISP_BT_SBUS) {
i &= RISC_PSR_SBUS_ULTRA;
  395                 } else {
i &= RISC_PSR_PCI_ULTRA;
  397                 }
  398                 if (i != 0) {
isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
sdp->isp_ultramode = 1;
  401                         /*
  402                          * If we're in Ultra Mode, we have to be 60MHz clock-
  403                          * even for the SBus version.
  404                          */
isp->isp_clock = 60;
  406                 } else {
sdp->isp_ultramode = 0;
  408                         /*
  409                          * Clock is known. Gronk.
  410                          */
  411                 }
  413                 /*
  414                  * Machine dependent clock (if set) overrides
  415                  * our generic determinations.
  416                  */
  417                 if (isp->isp_mdvec->dv_clock) {
  418                         if (isp->isp_mdvec->dv_clock < isp->isp_clock) {
isp->isp_clock = isp->isp_mdvec->dv_clock;
  420                         }
  421                 }
  423         }
  425         /*
  426          * Clear instrumentation
  427          */
isp->isp_intcnt = isp->isp_intbogus = 0;
  430         /*
  431          * Do MD specific pre initialization
  432          */
ISP_RESET0(isp);
again:
  437         /*
  438          * Hit the chip over the head with hammer,
  439          * and give the ISP a chance to recover.
  440          */
  442         if (IS_SCSI(isp)) {
ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
  444                 /*
  445                  * A slight delay...
  446                  */
USEC_DELAY(100);
  449                 /*
  450                  * Clear data && control DMA engines.
  451                  */
ISP_WRITE(isp, CDMA_CONTROL,
DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
ISP_WRITE(isp, DDMA_CONTROL,
DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
  458         } else {
ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
  460                 /*
  461                  * A slight delay...
  462                  */
USEC_DELAY(100);
  465                 /*
  466                  * Clear data && control DMA engines.
  467                  */
ISP_WRITE(isp, CDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
ISP_WRITE(isp, TDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
ISP_WRITE(isp, RDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
  474         }
  476         /*
  477          * Wait for ISP to be ready to go...
  478          */
loops = MBOX_DELAY_COUNT;
  480         for (;;) {
  481                 if (IS_SCSI(isp)) {
  482                         if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
  483                                 break;
  484                 } else {
  485                         if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
  486                                 break;
  487                 }
USEC_DELAY(100);
  489                 if (--loops < 0) {
ISP_DUMPREGS(isp, "chip reset timed out");
  491                         return;
  492                 }
  493         }
  495         /*
  496          * After we've fired this chip up, zero out the conf1 register
  497          * for SCSI adapters and other settings for the 2100.
  498          */
  500         if (IS_SCSI(isp)) {
ISP_WRITE(isp, BIU_CONF1, 0);
  502         } else {
ISP_WRITE(isp, BIU2100_CSR, 0);
  504         }
  506         /*
  507          * Reset RISC Processor
  508          */
ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
USEC_DELAY(100);
  511         /* Clear semaphore register (just to be sure) */
ISP_WRITE(isp, BIU_SEMA, 0);
  514         /*
  515          * Establish some initial burst rate stuff.
  516          * (only for the 1XX0 boards). This really should
  517          * be done later after fetching from NVRAM.
  518          */
  519         if (IS_SCSI(isp)) {
u_int16_t tmp = isp->isp_mdvec->dv_conf1;
  521                 /*
  522                  * Busted FIFO. Turn off all but burst enables.
  523                  */
  524                 if (isp->isp_type == ISP_HA_SCSI_1040A) {
tmp &= BIU_BURST_ENABLE;
  526                 }
ISP_SETBITS(isp, BIU_CONF1, tmp);
  528                 if (tmp & BIU_BURST_ENABLE) {
ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
  531                 }
  532 #ifdef  PTI_CARDS
  533                 if (((sdparam *) isp->isp_param)->isp_ultramode) {
  534                         while (ISP_READ(isp, RISC_MTR) != 0x1313) {
ISP_WRITE(isp, RISC_MTR, 0x1313);
ISP_WRITE(isp, HCCR, HCCR_CMD_STEP);
  537                         }
  538                 } else {
ISP_WRITE(isp, RISC_MTR, 0x1212);
  540                 }
  541                 /*
  542                  * PTI specific register
  543                  */
ISP_WRITE(isp, RISC_EMB, DUAL_BANK)
  545 #else
ISP_WRITE(isp, RISC_MTR, 0x1212);
  547 #endif
  548         } else {
ISP_WRITE(isp, RISC_MTR2100, 0x1212);
  550                 if (IS_2200(isp) || IS_23XX(isp)) {
ISP_WRITE(isp, HCCR, HCCR_2X00_DISABLE_PARITY_PAUSE);
  552                 }
  553         }
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
  557         /*
  558          * Do MD specific post initialization
  559          */
ISP_RESET1(isp);
  562         /*
  563          * Wait for everything to finish firing up.
  564          *
  565          * Avoid doing this on the 2312 because you can generate a PCI
  566          * parity error (chip breakage).
  567          */
  568         if (IS_23XX(isp)) {
USEC_DELAY(5);
  570         } else {
loops = MBOX_DELAY_COUNT;
  572                 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
USEC_DELAY(100);
  574                         if (--loops < 0) {
isp_prt(isp, ISP_LOGERR,
  576                                     "MBOX_BUSY never cleared on reset");
  577                                 return;
  578                         }
  579                 }
  580         }
  582         /*
  583          * Up until this point we've done everything by just reading or
  584          * setting registers. From this point on we rely on at least *some*
  585          * kind of firmware running in the card.
  586          */
  588         /*
  589          * Do some sanity checking.
  590          */
mbs.param[0] = MBOX_NO_OP;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  593         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  594                 return;
  595         }
  597         if (IS_SCSI(isp)) {
mbs.param[0] = MBOX_MAILBOX_REG_TEST;
mbs.param[1] = 0xdead;
mbs.param[2] = 0xbeef;
mbs.param[3] = 0xffff;
mbs.param[4] = 0x1111;
mbs.param[5] = 0xa5a5;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  605                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  606                         return;
  607                 }
  608                 if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
mbs.param[5] != 0xa5a5) {
isp_prt(isp, ISP_LOGERR,
  612                             "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
mbs.param[1], mbs.param[2], mbs.param[3],
mbs.param[4], mbs.param[5]);
  615                         return;
  616                 }
  618         }
  620         /*
  621          * Download new Firmware, unless requested not to do so.
  622          * This is made slightly trickier in some cases where the
  623          * firmware of the ROM revision is newer than the revision
  624          * compiled into the driver. So, where we used to compare
  625          * versions of our f/w and the ROM f/w, now we just see
  626          * whether we have f/w at all and whether a config flag
  627          * has disabled our download.
  628          */
  629         if ((isp->isp_mdvec->dv_ispfw == NULL) ||
  630             (isp->isp_confopts & ISP_CFG_NORELOAD)) {
dodnld = 0;
  632         }
  634         if (IS_23XX(isp))
code_org = ISP_CODE_ORG_2300;
  636         else
code_org = ISP_CODE_ORG;
  639         if (dodnld) {
isp->isp_mbxworkp = (void *) &isp->isp_mdvec->dv_ispfw[1];
isp->isp_mbxwrk0 = isp->isp_mdvec->dv_ispfw[3] - 1;
isp->isp_mbxwrk1 = code_org + 1;
mbs.param[0] = MBOX_WRITE_RAM_WORD;
mbs.param[1] = code_org;
mbs.param[2] = isp->isp_mdvec->dv_ispfw[0];
isp_mboxcmd(isp, &mbs, MBLOGNONE);
  647                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGERR,
  649                             "F/W download failed at word %d",
isp->isp_mbxwrk1 - code_org);
dodnld = 0;
  652                         goto again;
  653                 }
  654                 /*
  655                  * Verify that it downloaded correctly.
  656                  */
mbs.param[0] = MBOX_VERIFY_CHECKSUM;
mbs.param[1] = code_org;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
  660                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
  662                         return;
  663                 }
isp->isp_loaded_fw = 1;
  665         } else {
isp->isp_loaded_fw = 0;
isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
  668         }
  670         /*
  671          * Now start it rolling.
  672          *
  673          * If we didn't actually download f/w,
  674          * we still need to (re)start it.
  675          */
mbs.param[0] = MBOX_EXEC_FIRMWARE;
mbs.param[1] = code_org;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
  681         /*
  682          * Give it a chance to start.
  683          */
USEC_DELAY(500);
  686         if (IS_SCSI(isp)) {
  687                 /*
  688                  * Set CLOCK RATE, but only if asked to.
  689                  */
  690                 if (isp->isp_clock) {
mbs.param[0] = MBOX_SET_CLOCK_RATE;
mbs.param[1] = isp->isp_clock;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  694                         /* we will try not to care if this fails */
  695                 }
  696         }
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  700         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  701                 return;
  702         }
  704         /*
  705          * The SBus firmware that we are using apparently does not return
  706          * major, minor, micro revisions in the mailbox registers, which
  707          * is really, really, annoying.
  708          */
  709         if (ISP_SBUS_SUPPORTED && isp->isp_bustype == ISP_BT_SBUS) {
  710                 if (dodnld) {
  711 #ifdef  ISP_TARGET_MODE
isp->isp_fwrev[0] = 7;
isp->isp_fwrev[1] = 55;
  714 #else
isp->isp_fwrev[0] = 1;
isp->isp_fwrev[1] = 37;
  717 #endif
isp->isp_fwrev[2] = 0;
  719                 } 
  720         } else {
isp->isp_fwrev[0] = mbs.param[1];
isp->isp_fwrev[1] = mbs.param[2];
isp->isp_fwrev[2] = mbs.param[3];
  724         }
isp_prt(isp, ISP_LOGCONFIG,
  726             "Board Type %s, Chip Revision 0x%x, %s F/W Revision %d.%d.%d",
btype, isp->isp_revision, dodnld? "loaded" : "resident",
isp->isp_fwrev[0], isp->isp_fwrev[1], isp->isp_fwrev[2]);
  730         if (IS_FC(isp)) {
  731                 /*
  732                  * We do not believe firmware attributes for 2100 code less
  733                  * than 1.17.0, unless it's the firmware we specifically
  734                  * are loading.
  735                  *
  736                  * Note that all 22XX and 23XX f/w is greater than 1.X.0.
  737                  */
  738                 if (!(ISP_FW_NEWER_THAN(isp, 1, 17, 0))) {
  739 #ifdef  USE_SMALLER_2100_FIRMWARE
FCPARAM(isp)->isp_fwattr = ISP_FW_ATTR_SCCLUN;
  741 #else
FCPARAM(isp)->isp_fwattr = 0;
  743 #endif
  744                 } else {
FCPARAM(isp)->isp_fwattr = mbs.param[6];
isp_prt(isp, ISP_LOGDEBUG0,
  747                             "Firmware Attributes = 0x%x", mbs.param[6]);
  748                 }
  749                 if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) {
isp_prt(isp, ISP_LOGCONFIG,
  751                             "Installed in 64-Bit PCI slot");
  752                 }
  753         }
  755         if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
isp->isp_romfw_rev[2]) {
isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
isp->isp_romfw_rev[2]);
  760         }
mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  764         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  765                 return;
  766         }
isp->isp_maxcmds = mbs.param[2];
isp_prt(isp, ISP_LOGINFO,
  769             "%d max I/O commands supported", mbs.param[2]);
isp_fw_state(isp);
  772         /*
  773          * Set up DMA for the request and result mailboxes.
  774          */
  775         if (ISP_MBOXDMASETUP(isp) != 0) {
isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
  777                 return;
  778         }
isp->isp_state = ISP_RESETSTATE;
  781         /*
  782          * Okay- now that we have new firmware running, we now (re)set our
  783          * notion of how many luns we support. This is somewhat tricky because
  784          * if we haven't loaded firmware, we sometimes do not have an easy way
  785          * of knowing how many luns we support.
  786          *
  787          * Expanded lun firmware gives you 32 luns for SCSI cards and
  788          * 16384 luns for Fibre Channel cards.
  789          *
  790          * It turns out that even for QLogic 2100s with ROM 1.10 and above
  791          * we do get a firmware attributes word returned in mailbox register 6.
  792          *
  793          * Because the lun is in a different position in the Request Queue
  794          * Entry structure for Fibre Channel with expanded lun firmware, we
  795          * can only support one lun (lun zero) when we don't know what kind
  796          * of firmware we're running.
  797          */
  798         if (IS_SCSI(isp)) {
  799                 if (dodnld) {
  800                         if (IS_ULTRA2(isp) || IS_ULTRA3(isp)) {
isp->isp_maxluns = 32;
  802                         } else {
isp->isp_maxluns = 8;
  804                         }
  805                 } else {
isp->isp_maxluns = 8;
  807                 }
  808         } else {
  809                 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
isp->isp_maxluns = 16384;
  811                 } else {
isp->isp_maxluns = 16;
  813                 }
  814         }
  815 }
  817 /*
  818  * Initialize Parameters of Hardware to a known state.
  819  *
  820  * Locks are held before coming here.
  821  */
  823 void
isp_init(struct ispsoftc *isp)
  825 {
  826         /*
  827          * Must do this first to get defaults established.
  828          */
isp_setdfltparm(isp, 0);
  830         if (IS_DUALBUS(isp)) {
isp_setdfltparm(isp, 1);
  832         }
  833         if (IS_FC(isp)) {
isp_fibre_init(isp);
  835         } else {
isp_scsi_init(isp);
  837         }
  838 }
  840 static void
isp_scsi_init(struct ispsoftc *isp)
  842 {
sdparam *sdp_chan0, *sdp_chan1;
mbreg_t mbs;
sdp_chan0 = isp->isp_param;
sdp_chan1 = sdp_chan0;
  848         if (IS_DUALBUS(isp)) {
sdp_chan1++;
  850         }
  852         /*
  853          * If we have no role (neither target nor initiator), return.
  854          */
  855         if (isp->isp_role == ISP_ROLE_NONE) {
  856                 return;
  857         }
  859         /* First do overall per-card settings. */
  861         /*
  862          * If we have fast memory timing enabled, turn it on.
  863          */
  864         if (sdp_chan0->isp_fast_mttr) {
ISP_WRITE(isp, RISC_MTR, 0x1313);
  866         }
  868         /*
  869          * Set Retry Delay and Count.
  870          * You set both channels at the same time.
  871          */
mbs.param[0] = MBOX_SET_RETRY_COUNT;
mbs.param[1] = sdp_chan0->isp_retry_count;
mbs.param[2] = sdp_chan0->isp_retry_delay;
mbs.param[6] = sdp_chan1->isp_retry_count;
mbs.param[7] = sdp_chan1->isp_retry_delay;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  879         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  880                 return;
  881         }
  883         /*
  884          * Set ASYNC DATA SETUP time. This is very important.
  885          */
mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
mbs.param[1] = sdp_chan0->isp_async_data_setup;
mbs.param[2] = sdp_chan1->isp_async_data_setup;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  890         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  891                 return;
  892         }
  894         /*
  895          * Set ACTIVE Negation State.
  896          */
mbs.param[0] = MBOX_SET_ACT_NEG_STATE;
mbs.param[1] =
  899             (sdp_chan0->isp_req_ack_active_neg << 4) |
  900             (sdp_chan0->isp_data_line_active_neg << 5);
mbs.param[2] =
  902             (sdp_chan1->isp_req_ack_active_neg << 4) |
  903             (sdp_chan1->isp_data_line_active_neg << 5);
isp_mboxcmd(isp, &mbs, MBLOGNONE);
  906         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGERR,
  908                     "failed to set active negation state (%d,%d), (%d,%d)",
sdp_chan0->isp_req_ack_active_neg,
sdp_chan0->isp_data_line_active_neg,
sdp_chan1->isp_req_ack_active_neg,
sdp_chan1->isp_data_line_active_neg);
  913                 /*
  914                  * But don't return.
  915                  */
  916         }
  918         /*
  919          * Set the Tag Aging limit
  920          */
mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
mbs.param[1] = sdp_chan0->isp_tag_aging;
mbs.param[2] = sdp_chan1->isp_tag_aging;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  925         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
  928                 return;
  929         }
  931         /*
  932          * Set selection timeout.
  933          */
mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
mbs.param[1] = sdp_chan0->isp_selection_timeout;
mbs.param[2] = sdp_chan1->isp_selection_timeout;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  938         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  939                 return;
  940         }
  942         /* now do per-channel settings */
isp_scsi_channel_init(isp, 0);
  944         if (IS_DUALBUS(isp))
isp_scsi_channel_init(isp, 1);
  947         /*
  948          * Now enable request/response queues
  949          */
  951         if (IS_ULTRA2(isp) || IS_1240(isp)) {
mbs.param[0] = MBOX_INIT_RES_QUEUE_A64;
mbs.param[1] = RESULT_QUEUE_LEN(isp);
mbs.param[2] = DMA_WD1(isp->isp_result_dma);
mbs.param[3] = DMA_WD0(isp->isp_result_dma);
mbs.param[4] = 0;
mbs.param[6] = DMA_WD3(isp->isp_result_dma);
mbs.param[7] = DMA_WD2(isp->isp_result_dma);
isp_mboxcmd(isp, &mbs, MBLOGALL);
  960                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  961                         return;
  962                 }
isp->isp_residx = mbs.param[5];
mbs.param[0] = MBOX_INIT_REQ_QUEUE_A64;
mbs.param[1] = RQUEST_QUEUE_LEN(isp);
mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
mbs.param[5] = 0;
mbs.param[6] = DMA_WD3(isp->isp_result_dma);
mbs.param[7] = DMA_WD2(isp->isp_result_dma);
isp_mboxcmd(isp, &mbs, MBLOGALL);
  973                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  974                         return;
  975                 }
isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
  977         } else {
mbs.param[0] = MBOX_INIT_RES_QUEUE;
mbs.param[1] = RESULT_QUEUE_LEN(isp);
mbs.param[2] = DMA_WD1(isp->isp_result_dma);
mbs.param[3] = DMA_WD0(isp->isp_result_dma);
mbs.param[4] = 0;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  984                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  985                         return;
  986                 }
isp->isp_residx = mbs.param[5];
mbs.param[0] = MBOX_INIT_REQ_QUEUE;
mbs.param[1] = RQUEST_QUEUE_LEN(isp);
mbs.param[2] = DMA_WD1(isp->isp_rquest_dma);
mbs.param[3] = DMA_WD0(isp->isp_rquest_dma);
mbs.param[5] = 0;
isp_mboxcmd(isp, &mbs, MBLOGALL);
  995                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
  996                         return;
  997                 }
isp->isp_reqidx = isp->isp_reqodx = mbs.param[4];
  999         }
 1001         /*
 1002          * Turn on Fast Posting, LVD transitions
 1003          *
 1004          * Ultra2 F/W always has had fast posting (and LVD transitions)
 1005          *
 1006          * Ultra and older (i.e., SBus) cards may not. It's just safer
 1007          * to assume not for them.
 1008          */
mbs.param[0] = MBOX_SET_FW_FEATURES;
mbs.param[1] = 0;
 1012         if (IS_ULTRA2(isp))
mbs.param[1] |= FW_FEATURE_LVD_NOTIFY;
 1014 #ifndef ISP_NO_RIO
 1015         if (IS_ULTRA2(isp) || IS_1240(isp))
mbs.param[1] |= FW_FEATURE_RIO_16BIT;
 1017 #else
 1018 #ifndef ISP_NO_FASTPOST
 1019         if (IS_ULTRA2(isp) || IS_1240(isp))
mbs.param[1] |= FW_FEATURE_FAST_POST;
 1021 #endif
 1022 #endif
 1023         if (mbs.param[1] != 0) {
u_int16_t sfeat = mbs.param[1];
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1026                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGINFO,
 1028                             "Enabled FW features (0x%x)", sfeat);
 1029                 }
 1030         }
 1032         /*
 1033          * Let the outer layers decide whether to issue a SCSI bus reset.
 1034          */
isp->isp_state = ISP_INITSTATE;
 1036 }
 1038 static void
isp_scsi_channel_init(struct ispsoftc *isp, int channel)
 1040 {
sdparam *sdp;
mbreg_t mbs;
 1043         int tgt;
sdp = isp->isp_param;
sdp += channel;
 1048         /*
 1049          * Set (possibly new) Initiator ID.
 1050          */
mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1054         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 1055                 return;
 1056         }
isp_prt(isp, ISP_LOGINFO, "Initiator ID is %d on Channel %d",
sdp->isp_initiator_id, channel);
 1061         /*
 1062          * Set current per-target parameters to an initial safe minimum.
 1063          */
 1064         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
 1065                 int lun;
u_int16_t sdf;
 1068                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
 1069                         continue;
 1070                 }
 1071 #ifndef ISP_TARGET_MODE
sdf = sdp->isp_devparam[tgt].goal_flags;
sdf &= DPARM_SAFE_DFLT;
 1074                 /*
 1075                  * It is not quite clear when this changed over so that
 1076                  * we could force narrow and async for 1000/1020 cards,
 1077                  * but assume that this is only the case for loaded
 1078                  * firmware.
 1079                  */
 1080                 if (isp->isp_loaded_fw) {
sdf |= DPARM_NARROW | DPARM_ASYNC;
 1082                 }
 1083 #else
 1084                 /*
 1085                  * The !$*!)$!$)* f/w uses the same index into some
 1086                  * internal table to decide how to respond to negotiations,
 1087                  * so if we've said "let's be safe" for ID X, and ID X
 1088                  * selects *us*, the negotiations will back to 'safe'
 1089                  * (as in narrow/async). What the f/w *should* do is
 1090                  * use the initiator id settings to decide how to respond.
 1091                  */
sdp->isp_devparam[tgt].goal_flags = sdf = DPARM_DEFAULT;
 1093 #endif
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
mbs.param[1] = (channel << 15) | (tgt << 8);
mbs.param[2] = sdf;
 1097                 if ((sdf & DPARM_SYNC) == 0) {
mbs.param[3] = 0;
 1099                 } else {
mbs.param[3] =
 1101                             (sdp->isp_devparam[tgt].goal_offset << 8) |
 1102                             (sdp->isp_devparam[tgt].goal_period);
 1103                 }
isp_prt(isp, ISP_LOGDEBUG0,
 1105                     "Initial Settings bus%d tgt%d flags 0x%x off 0x%x per 0x%x",
channel, tgt, mbs.param[2], mbs.param[3] >> 8,
mbs.param[3] & 0xff);
isp_mboxcmd(isp, &mbs, MBLOGNONE);
 1109                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
sdf = DPARM_SAFE_DFLT;
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
mbs.param[1] = (tgt << 8) | (channel << 15);
mbs.param[2] = sdf;
mbs.param[3] = 0;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1116                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 1117                                 continue;
 1118                         }
 1119                 }
 1121                 /*
 1122                  * We don't update any information directly from the f/w
 1123                  * because we need to run at least one command to cause a
 1124                  * new state to be latched up. So, we just assume that we
 1125                  * converge to the values we just had set.
 1126                  *
 1127                  * Ensure that we don't believe tagged queuing is enabled yet.
 1128                  * It turns out that sometimes the ISP just ignores our
 1129                  * attempts to set parameters for devices that it hasn't
 1130                  * seen yet.
 1131                  */
sdp->isp_devparam[tgt].actv_flags = sdf & ~DPARM_TQING;
 1133                 for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
mbs.param[2] = sdp->isp_max_queue_depth;
mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1139                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 1140                                 break;
 1141                         }
 1142                 }
 1143         }
 1144         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
 1145                 if (sdp->isp_devparam[tgt].dev_refresh) {
isp->isp_sendmarker |= (1 << channel);
isp->isp_update |= (1 << channel);
 1148                         break;
 1149                 }
 1150         }
 1151 }
 1153 /*
 1154  * Fibre Channel specific initialization.
 1155  *
 1156  * Locks are held before coming here.
 1157  */
 1158 static void
isp_fibre_init(struct ispsoftc *isp)
 1160 {
fcparam *fcp;
isp_icb_t local, *icbp = &local;
mbreg_t mbs;
 1164         int loopid;
u_int64_t nwwn, pwwn;
fcp = isp->isp_param;
 1169         /*
 1170          * Do this *before* initializing the firmware.
 1171          */
isp_mark_getpdb_all(isp);
fcp->isp_fwstate = FW_CONFIG_WAIT;
fcp->isp_loopstate = LOOP_NIL;
 1176         /*
 1177          * If we have no role (neither target nor initiator), return.
 1178          */
 1179         if (isp->isp_role == ISP_ROLE_NONE) {
 1180                 return;
 1181         }
loopid = fcp->isp_loopid;
MEMZERO(icbp, sizeof (*icbp));
icbp->icb_version = ICB_VERSION1;
 1187         /*
 1188          * Firmware Options are either retrieved from NVRAM or
 1189          * are patched elsewhere. We check them for sanity here
 1190          * and make changes based on board revision, but otherwise
 1191          * let others decide policy.
 1192          */
 1194         /*
 1195          * If this is a 2100 < revision 5, we have to turn off FAIRNESS.
 1196          */
 1197         if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) {
fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS;
 1199         }
 1201         /*
 1202          * We have to use FULL LOGIN even though it resets the loop too much
 1203          * because otherwise port database entries don't get updated after
 1204          * a LIP- this is a known f/w bug for 2100 f/w less than 1.17.0.
 1205          */
 1206         if (!ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
 1208         }
 1210         /*
 1211          * Insist on Port Database Update Async notifications
 1212          */
fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
 1215         /*
 1216          * Make sure that target role reflects into fwoptions.
 1217          */
 1218         if (isp->isp_role & ISP_ROLE_TARGET) {
fcp->isp_fwoptions |= ICBOPT_TGT_ENABLE;
 1220         } else {
fcp->isp_fwoptions &= ~ICBOPT_TGT_ENABLE;
 1222         }
 1224         /*
 1225          * Propagate all of this into the ICB structure.
 1226          */
icbp->icb_fwoptions = fcp->isp_fwoptions;
icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
 1229         if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
isp_prt(isp, ISP_LOGERR,
 1232                     "bad frame length (%d) from NVRAM- using %d",
fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
 1235         }
icbp->icb_maxalloc = fcp->isp_maxalloc;
 1237         if (icbp->icb_maxalloc < 1) {
isp_prt(isp, ISP_LOGERR,
 1239                     "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
icbp->icb_maxalloc = 16;
 1241         }
icbp->icb_execthrottle = fcp->isp_execthrottle;
 1243         if (icbp->icb_execthrottle < 1) {
isp_prt(isp, ISP_LOGERR,
 1245                     "bad execution throttle of %d- using 16",
fcp->isp_execthrottle);
icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
 1248         }
icbp->icb_retry_delay = fcp->isp_retry_delay;
icbp->icb_retry_count = fcp->isp_retry_count;
icbp->icb_hardaddr = loopid;
 1252         /*
 1253          * Right now we just set extended options to prefer point-to-point
 1254          * over loop based upon some soft config options.
 1255          * 
 1256          * NB: for the 2300, ICBOPT_EXTENDED is required.
 1257          */
 1258         if (IS_2200(isp) || IS_23XX(isp)) {
icbp->icb_fwoptions |= ICBOPT_EXTENDED;
 1260                 /*
 1261                  * Prefer or force Point-To-Point instead Loop?
 1262                  */
 1263                 switch(isp->isp_confopts & ISP_CFG_PORT_PREF) {
 1264                 case ISP_CFG_NPORT:
icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
 1266                         break;
 1267                 case ISP_CFG_NPORT_ONLY:
icbp->icb_xfwoptions |= ICBXOPT_PTP_ONLY;
 1269                         break;
 1270                 case ISP_CFG_LPORT_ONLY:
icbp->icb_xfwoptions |= ICBXOPT_LOOP_ONLY;
 1272                         break;
 1273                 default:
icbp->icb_xfwoptions |= ICBXOPT_LOOP_2_PTP;
 1275                         break;
 1276                 }
 1277                 if (IS_23XX(isp)) {
 1278                         /*
 1279                          * QLogic recommends that FAST Posting be turned
 1280                          * off for 23XX cards and instead allow the HBA
 1281                          * to write response queue entries and interrupt
 1282                          * after a delay (ZIO).
 1283                          *
 1284                          * If we set ZIO, it will disable fast posting,
 1285                          * so we don't need to clear it in fwoptions.
 1286                          */
icbp->icb_xfwoptions |= ICBXOPT_ZIO;
 1288 #if     0
 1289                         /*
 1290                          * Values, in 100us increments. The default
 1291                          * is 2 (200us) if a value 0 (default) is
 1292                          * selected.
 1293                          */
icbp->icb_idelaytimer = 2;
 1295 #endif
 1297                         if (isp->isp_confopts & ISP_CFG_ONEGB) {
icbp->icb_zfwoptions |= ICBZOPT_RATE_ONEGB;
 1299                         } else if (isp->isp_confopts & ISP_CFG_TWOGB) {
icbp->icb_zfwoptions |= ICBZOPT_RATE_TWOGB;
 1301                         } else {
icbp->icb_zfwoptions |= ICBZOPT_RATE_AUTO;
 1303                         }
 1304                 }
 1305         }
 1307 #ifndef ISP_NO_RIO_FC
 1308         /*
 1309          * RIO seems to be enabled in 2100s for fw >= 1.17.0.
 1310          *
 1311          * I've had some questionable problems with RIO on 2200.
 1312          * More specifically, on a 2204 I had problems with RIO
 1313          * on a Linux system where I was dropping commands right
 1314          * and left. It's not clear to me what the actual problem
 1315          * was.
 1316          *
 1317          * 23XX Cards do not support RIO. Instead they support ZIO.
 1318          */
 1319 #if     0
 1320         if (!IS_23XX(isp) && ISP_FW_NEWER_THAN(isp, 1, 17, 0)) {
icbp->icb_xfwoptions |= ICBXOPT_RIO_16BIT;
icbp->icb_racctimer = 4;
icbp->icb_idelaytimer = 8;
 1324         }
 1325 #endif
 1326 #endif
 1328         /*
 1329          * For 22XX > 2.1.26 && 23XX, set someoptions.
 1330          * XXX: Probably okay for newer 2100 f/w too.
 1331          */
 1332         if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
 1333                 /*
 1334                  * Turn on LIP F8 async event (1)
 1335                  * Turn on generate AE 8013 on all LIP Resets (2)
 1336                  * Disable LIP F7 switching (8)
 1337                  */
mbs.param[0] = MBOX_SET_FIRMWARE_OPTIONS;
mbs.param[1] = 0xb;
mbs.param[2] = 0;
mbs.param[3] = 0;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1343         }
icbp->icb_logintime = 30;       /* 30 second login timeout */
 1346         if (IS_23XX(isp)) {
ISP_WRITE(isp, isp->isp_rqstinrp, 0);
ISP_WRITE(isp, isp->isp_rqstoutrp, 0);
ISP_WRITE(isp, isp->isp_respinrp, 0);
ISP_WRITE(isp, isp->isp_respoutrp, 0);
 1351         }
nwwn = ISP_NODEWWN(isp);
pwwn = ISP_PORTWWN(isp);
 1355         if (nwwn && pwwn) {
icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, nwwn);
MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pwwn);
isp_prt(isp, ISP_LOGDEBUG1,
 1360                     "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
 1361                     ((u_int32_t) (nwwn >> 32)),
 1362                     ((u_int32_t) (nwwn & 0xffffffff)),
 1363                     ((u_int32_t) (pwwn >> 32)),
 1364                     ((u_int32_t) (pwwn & 0xffffffff)));
 1365         } else {
isp_prt(isp, ISP_LOGDEBUG1, "Not using any WWNs");
icbp->icb_fwoptions &= ~(ICBOPT_BOTH_WWNS|ICBOPT_FULL_LOGIN);
 1368         }
icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_rquest_dma);
icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_rquest_dma);
icbp->icb_rqstaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_rquest_dma);
icbp->icb_rqstaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_rquest_dma);
icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_WD0(isp->isp_result_dma);
icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_WD1(isp->isp_result_dma);
icbp->icb_respaddr[RQRSP_ADDR3247] = DMA_WD2(isp->isp_result_dma);
icbp->icb_respaddr[RQRSP_ADDR4863] = DMA_WD3(isp->isp_result_dma);
isp_prt(isp, ISP_LOGDEBUG0,
 1380             "isp_fibre_init: fwopt 0x%x xfwopt 0x%x zfwopt 0x%x",
icbp->icb_fwoptions, icbp->icb_xfwoptions, icbp->icb_zfwoptions);
FC_SCRATCH_ACQUIRE(isp);
isp_put_icb(isp, icbp, (isp_icb_t *)fcp->isp_scratch);
 1386         /*
 1387          * Init the firmware
 1388          */
mbs.param[0] = MBOX_INIT_FIRMWARE;
mbs.param[1] = 0;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
mbs.param[4] = 0;
mbs.param[5] = 0;
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
isp_mboxcmd(isp, &mbs, MBLOGALL);
FC_SCRATCH_RELEASE(isp);
 1399         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 1400                 return;
 1401         }
isp->isp_reqidx = isp->isp_reqodx = 0;
isp->isp_residx = 0;
isp->isp_sendmarker = 1;
 1406         /*
 1407          * Whatever happens, we're now committed to being here.
 1408          */
isp->isp_state = ISP_INITSTATE;
 1410 }
 1412 /*
 1413  * Fibre Channel Support- get the port database for the id.
 1414  *
 1415  * Locks are held before coming here. Return 0 if success,
 1416  * else failure.
 1417  */
 1419 static int
isp_getmap(struct ispsoftc *isp, fcpos_map_t *map)
 1421 {
fcparam *fcp = (fcparam *) isp->isp_param;
mbreg_t mbs;
mbs.param[0] = MBOX_GET_FC_AL_POSITION_MAP;
mbs.param[1] = 0;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 1429         /*
 1430          * Unneeded. For the 2100, except for initializing f/w, registers
 1431          * 4/5 have to not be written to.
 1432          *      mbs.param[4] = 0;
 1433          *      mbs.param[5] = 0;
 1434          *
 1435          */
mbs.param[6] = 0;
mbs.param[7] = 0;
FC_SCRATCH_ACQUIRE(isp);
isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
 1440         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
MEMCPY(map, fcp->isp_scratch, sizeof (fcpos_map_t));
map->fwmap = mbs.param[1] != 0;
FC_SCRATCH_RELEASE(isp);
 1444                 return (0);
 1445         }
FC_SCRATCH_RELEASE(isp);
 1447         return (-1);
 1448 }
 1450 static void
isp_mark_getpdb_all(struct ispsoftc *isp)
 1452 {
fcparam *fcp = (fcparam *) isp->isp_param;
 1454         int i;
 1455         for (i = 0; i < MAX_FC_TARG; i++) {
fcp->portdb[i].valid = fcp->portdb[i].fabric_dev = 0;
 1457         }
 1458 }
 1460 static int
isp_getpdb(struct ispsoftc *isp, int id, isp_pdb_t *pdbp)
 1462 {
fcparam *fcp = (fcparam *) isp->isp_param;
mbreg_t mbs;
mbs.param[0] = MBOX_GET_PORT_DB;
mbs.param[1] = id << 8;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 1470         /*
 1471          * Unneeded. For the 2100, except for initializing f/w, registers
 1472          * 4/5 have to not be written to.
 1473          *      mbs.param[4] = 0;
 1474          *      mbs.param[5] = 0;
 1475          *
 1476          */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
FC_SCRATCH_ACQUIRE(isp);
isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
 1481         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
isp_get_pdb(isp, (isp_pdb_t *)fcp->isp_scratch, pdbp);
FC_SCRATCH_RELEASE(isp);
 1484                 return (0);
 1485         }
FC_SCRATCH_RELEASE(isp);
 1487         return (-1);
 1488 }
 1490 static u_int64_t
isp_get_portname(struct ispsoftc *isp, int loopid, int nodename)
 1492 {
u_int64_t wwn = 0;
mbreg_t mbs;
mbs.param[0] = MBOX_GET_PORT_NAME;
mbs.param[1] = loopid << 8;
 1498         if (nodename)
mbs.param[1] |= 1;
isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
 1501         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
wwn =
 1503                     (((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
 1504                     (((u_int64_t)(mbs.param[2] >> 8))   << 48) |
 1505                     (((u_int64_t)(mbs.param[3] & 0xff)) << 40) |
 1506                     (((u_int64_t)(mbs.param[3] >> 8))   << 32) |
 1507                     (((u_int64_t)(mbs.param[6] & 0xff)) << 24) |
 1508                     (((u_int64_t)(mbs.param[6] >> 8))   << 16) |
 1509                     (((u_int64_t)(mbs.param[7] & 0xff)) <<  8) |
 1510                     (((u_int64_t)(mbs.param[7] >> 8)));
 1511         }
 1512         return (wwn);
 1513 }
 1515 /*
 1516  * Make sure we have good FC link and know our Loop ID.
 1517  */
 1519 static int
isp_fclink_test(struct ispsoftc *isp, int usdelay)
 1521 {
 1522         static char *toponames[] = {
 1523                 "Private Loop",
 1524                 "FL Port",
 1525                 "N-Port to N-Port",
 1526                 "F Port",
 1527                 "F Port (no FLOGI_ACC response)"
 1528         };
mbreg_t mbs;
 1530         int count, check_for_fabric;
u_int8_t lwfs;
fcparam *fcp;
 1533         struct lportdb *lp;
isp_pdb_t pdb;
fcp = isp->isp_param;
 1538         /*
 1539          * XXX: Here is where we would start a 'loop dead' timeout
 1540          */
 1542         /*
 1543          * Wait up to N microseconds for F/W to go to a ready state.
 1544          */
lwfs = FW_CONFIG_WAIT;
count = 0;
 1547         while (count < usdelay) {
u_int64_t enano;
u_int32_t wrk;
NANOTIME_T hra, hrb;
GET_NANOTIME(&hra);
isp_fw_state(isp);
 1554                 if (lwfs != fcp->isp_fwstate) {
isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
isp2100_fw_statename((int)lwfs),
isp2100_fw_statename((int)fcp->isp_fwstate));
lwfs = fcp->isp_fwstate;
 1559                 }
 1560                 if (fcp->isp_fwstate == FW_READY) {
 1561                         break;
 1562                 }
GET_NANOTIME(&hrb);
 1565                 /*
 1566                  * Get the elapsed time in nanoseconds.
 1567                  * Always guaranteed to be non-zero.
 1568                  */
enano = NANOTIME_SUB(&hrb, &hra);
isp_prt(isp, ISP_LOGDEBUG1,
 1572                     "usec%d: 0x%lx->0x%lx enano 0x%x%08x",
count, (long) GET_NANOSEC(&hra), (long) GET_NANOSEC(&hrb),
 1574                     (u_int32_t)(enano >> 32), (u_int32_t)(enano & 0xffffffff));
 1576                 /*
 1577                  * If the elapsed time is less than 1 millisecond,
 1578                  * delay a period of time up to that millisecond of
 1579                  * waiting.
 1580                  *
 1581                  * This peculiar code is an attempt to try and avoid
 1582                  * invoking u_int64_t math support functions for some
 1583                  * platforms where linkage is a problem.
 1584                  */
 1585                 if (enano < (1000 * 1000)) {
count += 1000;
enano = (1000 * 1000) - enano;
 1588                         while (enano > (u_int64_t) 4000000000U) {
USEC_SLEEP(isp, 4000000);
enano -= (u_int64_t) 4000000000U;
 1591                         }
wrk = enano;
wrk /= 1000;
USEC_SLEEP(isp, wrk);
 1595                 } else {
 1596                         while (enano > (u_int64_t) 4000000000U) {
count += 4000000;
enano -= (u_int64_t) 4000000000U;
 1599                         }
wrk = enano;
count += (wrk / 1000);
 1602                 }
 1603         }
 1605         /*
 1606          * If we haven't gone to 'ready' state, return.
 1607          */
 1608         if (fcp->isp_fwstate != FW_READY) {
 1609                 return (-1);
 1610         }
 1612         /*
 1613          * Get our Loop ID (if possible). We really need to have it.
 1614          */
mbs.param[0] = MBOX_GET_LOOP_ID;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1617         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 1618                 return (-1);
 1619         }
fcp->isp_loopid = mbs.param[1];
 1621         if (IS_2200(isp) || IS_23XX(isp)) {
 1622                 int topo = (int) mbs.param[6];
 1623                 if (topo < TOPO_NL_PORT || topo > TOPO_PTP_STUB)
topo = TOPO_PTP_STUB;
fcp->isp_topo = topo;
 1626         } else {
fcp->isp_topo = TOPO_NL_PORT;
 1628         }
fcp->isp_portid = fcp->isp_alpa = mbs.param[2] & 0xff;
 1631         /*
 1632          * Check to see if we're on a fabric by trying to see if we
 1633          * can talk to the fabric name server. This can be a bit
 1634          * tricky because if we're a 2100, we should check always
 1635          * (in case we're connected to a server doing aliasing).
 1636          */
fcp->isp_onfabric = 0;
 1639         if (IS_2100(isp)) {
 1640                 /*
 1641                  * Don't bother with fabric if we are using really old
 1642                  * 2100 firmware. It's just not worth it.
 1643                  */
 1644                 if (ISP_FW_NEWER_THAN(isp, 1, 15, 37)) {
check_for_fabric = 1;
 1646                 } else {
check_for_fabric = 0;
 1648                 }
 1649         } else if (fcp->isp_topo == TOPO_FL_PORT ||
fcp->isp_topo == TOPO_F_PORT) {
check_for_fabric = 1;
 1652         } else
check_for_fabric = 0;
 1655         if (check_for_fabric && isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) {
 1656                 int loopid = FL_PORT_ID;
 1657                 if (IS_2100(isp)) {
fcp->isp_topo = TOPO_FL_PORT;
 1659                 }
 1661                 if (BITS2WORD(pdb.pdb_portid_bits) == 0) {
 1662                         /*
 1663                          * Crock.
 1664                          */
fcp->isp_topo = TOPO_NL_PORT;
 1666                         goto not_on_fabric;
 1667                 }
fcp->isp_portid = mbs.param[2] | ((int) mbs.param[3] << 16);
 1670                 /*
 1671                  * Save the Fabric controller's port database entry.
 1672                  */
lp = &fcp->portdb[loopid];
lp->node_wwn =
 1675                     (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
 1676                     (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
 1677                     (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
 1678                     (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
 1679                     (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
 1680                     (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
 1681                     (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
 1682                     (((u_int64_t)pdb.pdb_nodename[7]));
lp->port_wwn =
 1684                     (((u_int64_t)pdb.pdb_portname[0]) << 56) |
 1685                     (((u_int64_t)pdb.pdb_portname[1]) << 48) |
 1686                     (((u_int64_t)pdb.pdb_portname[2]) << 40) |
 1687                     (((u_int64_t)pdb.pdb_portname[3]) << 32) |
 1688                     (((u_int64_t)pdb.pdb_portname[4]) << 24) |
 1689                     (((u_int64_t)pdb.pdb_portname[5]) << 16) |
 1690                     (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
 1691                     (((u_int64_t)pdb.pdb_portname[7]));
lp->roles =
 1693                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
lp->portid = BITS2WORD(pdb.pdb_portid_bits);
lp->loopid = pdb.pdb_loopid;
lp->loggedin = lp->valid = 1;
fcp->isp_onfabric = 1;
 1698                 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
isp_register_fc4_type(isp);
 1700         } else {
not_on_fabric:
fcp->isp_onfabric = 0;
fcp->portdb[FL_PORT_ID].valid = 0;
 1704         }
fcp->isp_gbspeed = 1;
 1707         if (IS_23XX(isp)) {
mbs.param[0] = MBOX_GET_SET_DATA_RATE;
mbs.param[1] = MBGSD_GET_RATE;
 1710                 /* mbs.param[2] undefined if we're just getting rate */
isp_mboxcmd(isp, &mbs, MBLOGALL);
 1712                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 1713                         if (mbs.param[1] == MBGSD_TWOGB) {
isp_prt(isp, ISP_LOGINFO, "2Gb link speed/s");
fcp->isp_gbspeed = 2;
 1716                         }
 1717                 }
 1718         }
isp_prt(isp, ISP_LOGCONFIG, topology, fcp->isp_loopid, fcp->isp_alpa,
fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
 1723         /*
 1724          * Announce ourselves, too. This involves synthesizing an entry.
 1725          */
 1726         if (fcp->isp_iid_set == 0) {
fcp->isp_iid_set = 1;
fcp->isp_iid = fcp->isp_loopid;
lp = &fcp->portdb[fcp->isp_iid];
 1730         } else {
lp = &fcp->portdb[fcp->isp_iid];
 1732                 if (fcp->isp_portid != lp->portid ||
fcp->isp_loopid != lp->loopid ||
fcp->isp_nodewwn != ISP_NODEWWN(isp) ||
fcp->isp_portwwn != ISP_PORTWWN(isp)) {
lp->valid = 0;
count = fcp->isp_iid;
 1738                         (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
 1739                 }
 1740         }
lp->loopid = fcp->isp_loopid;
lp->portid = fcp->isp_portid;
lp->node_wwn = ISP_NODEWWN(isp);
lp->port_wwn = ISP_PORTWWN(isp);
 1745         switch (isp->isp_role) {
 1746         case ISP_ROLE_NONE:
lp->roles = 0;
 1748                 break;
 1749         case ISP_ROLE_TARGET:
lp->roles = SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT;
 1751                 break;
 1752         case ISP_ROLE_INITIATOR:
lp->roles = SVC3_INI_ROLE >> SVC3_ROLE_SHIFT;
 1754                 break;
 1755         case ISP_ROLE_BOTH:
lp->roles = (SVC3_INI_ROLE|SVC3_TGT_ROLE) >> SVC3_ROLE_SHIFT;
 1757                 break;
 1758         }
lp->loggedin = lp->valid = 1;
count = fcp->isp_iid;
 1761         (void) isp_async(isp, ISPASYNC_PROMENADE, &count);
 1762         return (0);
 1763 }
 1765 static char *
isp2100_fw_statename(int state)
 1767 {
 1768         switch(state) {
 1769         case FW_CONFIG_WAIT:    return "Config Wait";
 1770         case FW_WAIT_AL_PA:     return "Waiting for AL_PA";
 1771         case FW_WAIT_LOGIN:     return "Wait Login";
 1772         case FW_READY:          return "Ready";
 1773         case FW_LOSS_OF_SYNC:   return "Loss Of Sync";
 1774         case FW_ERROR:          return "Error";
 1775         case FW_REINIT:         return "Re-Init";
 1776         case FW_NON_PART:       return "Nonparticipating";
 1777         default:                return "?????";
 1778         }
 1779 }
 1781 /*
 1782  * Synchronize our soft copy of the port database with what the f/w thinks
 1783  * (with a view toward possibly for a specific target....)
 1784  */
 1786 static int
isp_pdb_sync(struct ispsoftc *isp)
 1788 {
 1789         struct lportdb *lp;
fcparam *fcp = isp->isp_param;
isp_pdb_t pdb;
 1792         int loopid, base, lim;
 1794         /*
 1795          * Make sure we're okay for doing this right now.
 1796          */
 1797         if (fcp->isp_loopstate != LOOP_PDB_RCVD &&
fcp->isp_loopstate != LOOP_FSCAN_DONE &&
fcp->isp_loopstate != LOOP_LSCAN_DONE) {
 1800                 return (-1);
 1801         }
 1803         if (fcp->isp_topo == TOPO_FL_PORT || fcp->isp_topo == TOPO_NL_PORT ||
fcp->isp_topo == TOPO_N_PORT) {
 1805                 if (fcp->isp_loopstate < LOOP_LSCAN_DONE) {
 1806                         if (isp_scan_loop(isp) != 0) {
 1807                                 return (-1);
 1808                         }
 1809                 }
 1810         }
fcp->isp_loopstate = LOOP_SYNCING_PDB;
 1813         /*
 1814          * If we get this far, we've settled our differences with the f/w
 1815          * (for local loop device) and we can say that the loop state is ready.
 1816          */
 1818         if (fcp->isp_topo == TOPO_NL_PORT) {
fcp->loop_seen_once = 1;
fcp->isp_loopstate = LOOP_READY;
 1821                 return (0);
 1822         }
 1824         /*
 1825          * Find all Fabric Entities that didn't make it from one scan to the
 1826          * next and let the world know they went away. Scan the whole database.
 1827          */
 1828         for (lp = &fcp->portdb[0]; lp < &fcp->portdb[MAX_FC_TARG]; lp++) {
 1829                 if (lp->was_fabric_dev && lp->fabric_dev == 0) {
loopid = lp - fcp->portdb;
lp->valid = 0;  /* should already be set */
 1832                         (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
MEMZERO((void *) lp, sizeof (*lp));
 1834                         continue;
 1835                 }
lp->was_fabric_dev = lp->fabric_dev;
 1837         }
 1839         if (fcp->isp_topo == TOPO_FL_PORT)
base = FC_SNS_ID+1;
 1841         else
base = 0;
 1844         if (fcp->isp_topo == TOPO_N_PORT)
lim = 1;
 1846         else
lim = MAX_FC_TARG;
 1849         /*
 1850          * Now log in any fabric devices that the outer layer has
 1851          * left for us to see. This seems the most sane policy
 1852          * for the moment.
 1853          */
 1854         for (lp = &fcp->portdb[base]; lp < &fcp->portdb[lim]; lp++) {
u_int32_t portid;
mbreg_t mbs;
loopid = lp - fcp->portdb;
 1859                 if (loopid >= FL_PORT_ID && loopid <= FC_SNS_ID) {
 1860                         continue;
 1861                 }
 1863                 /*
 1864                  * Anything here?
 1865                  */
 1866                 if (lp->port_wwn == 0) {
 1867                         continue;
 1868                 }
 1870                 /*
 1871                  * Don't try to log into yourself.
 1872                  */
 1873                 if ((portid = lp->portid) == fcp->isp_portid) {
 1874                         continue;
 1875                 }
 1878                 /*
 1879                  * If we'd been logged in- see if we still are and we haven't
 1880                  * changed. If so, no need to log ourselves out, etc..
 1881                  *
 1882                  * Unfortunately, our charming Qlogic f/w has decided to
 1883                  * return a valid port database entry for a fabric device
 1884                  * that has, in fact, gone away. And it hangs trying to
 1885                  * log it out.
 1886                  */
 1887                 if (lp->loggedin && lp->force_logout == 0 &&
isp_getpdb(isp, lp->loopid, &pdb) == 0) {
 1889                         int nrole;
u_int64_t nwwnn, nwwpn;
nwwnn =
 1892                             (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
 1893                             (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
 1894                             (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
 1895                             (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
 1896                             (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
 1897                             (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
 1898                             (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
 1899                             (((u_int64_t)pdb.pdb_nodename[7]));
nwwpn =
 1901                             (((u_int64_t)pdb.pdb_portname[0]) << 56) |
 1902                             (((u_int64_t)pdb.pdb_portname[1]) << 48) |
 1903                             (((u_int64_t)pdb.pdb_portname[2]) << 40) |
 1904                             (((u_int64_t)pdb.pdb_portname[3]) << 32) |
 1905                             (((u_int64_t)pdb.pdb_portname[4]) << 24) |
 1906                             (((u_int64_t)pdb.pdb_portname[5]) << 16) |
 1907                             (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
 1908                             (((u_int64_t)pdb.pdb_portname[7]));
nrole = (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >>
SVC3_ROLE_SHIFT;
 1911                         if (pdb.pdb_loopid == lp->loopid && lp->portid ==
 1912                             (u_int32_t) BITS2WORD(pdb.pdb_portid_bits) &&
nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
lp->roles == nrole && lp->force_logout == 0) {
lp->loggedin = lp->valid = 1;
isp_prt(isp, ISP_LOGCONFIG, lretained,
 1917                                     (int) (lp - fcp->portdb),
 1918                                     (int) lp->loopid, lp->portid);
 1919                                 continue;
 1920                         }
 1921                 }
 1923                 if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_SYNCING_PDB) {
 1925                         return (-1);
 1926                 }
 1928                 /*
 1929                  * Force a logout if we were logged in.
 1930                  */
 1931                 if (lp->loggedin) {
 1932                         if (lp->force_logout ||
isp_getpdb(isp, lp->loopid, &pdb) == 0) {
mbs.param[0] = MBOX_FABRIC_LOGOUT;
mbs.param[1] = lp->loopid << 8;
mbs.param[2] = 0;
mbs.param[3] = 0;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
isp_prt(isp, ISP_LOGINFO, plogout,
 1940                                     (int) (lp - fcp->portdb), lp->loopid,
lp->portid);
 1942                         }
lp->force_logout = lp->loggedin = 0;
 1944                         if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_SYNCING_PDB) {
 1946                                 return (-1);
 1947                         }
 1948                 }
 1950                 /*
 1951                  * And log in....
 1952                  */
loopid = lp - fcp->portdb;
lp->loopid = FL_PORT_ID;
 1955                 do {
mbs.param[0] = MBOX_FABRIC_LOGIN;
mbs.param[1] = loopid << 8;
mbs.param[2] = portid >> 16;
mbs.param[3] = portid & 0xffff;
isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
 1962                         if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_SYNCING_PDB) {
 1964                                 return (-1);
 1965                         }
 1966                         switch (mbs.param[0]) {
 1967                         case MBOX_LOOP_ID_USED:
 1968                                 /*
 1969                                  * Try the next available loop id.
 1970                                  */
loopid++;
 1972                                 break;
 1973                         case MBOX_PORT_ID_USED:
 1974                                 /*
 1975                                  * This port is already logged in.
 1976                                  * Snaffle the loop id it's using if it's
 1977                                  * nonzero, otherwise we're hosed.
 1978                                  */
 1979                                 if (mbs.param[1] != 0) {
loopid = mbs.param[1];
isp_prt(isp, ISP_LOGINFO, retained,
loopid, (int) (lp - fcp->portdb),
lp->portid);
 1984                                 } else {
loopid = MAX_FC_TARG;
 1986                                         break;
 1987                                 }
 1988                                 /* FALLTHROUGH */
 1989                         case MBOX_COMMAND_COMPLETE:
lp->loggedin = 1;
lp->loopid = loopid;
 1992                                 break;
 1993                         case MBOX_COMMAND_ERROR:
isp_prt(isp, ISP_LOGINFO, plogierr,
portid, mbs.param[1]);
 1996                                 /* FALLTHROUGH */
 1997                         case MBOX_ALL_IDS_USED: /* We're outta IDs */
 1998                         default:
loopid = MAX_FC_TARG;
 2000                                 break;
 2001                         }
 2002                 } while (lp->loopid == FL_PORT_ID && loopid < MAX_FC_TARG);
 2004                 /*
 2005                  * If we get here and we haven't set a Loop ID,
 2006                  * we failed to log into this device.
 2007                  */
 2009                 if (lp->loopid == FL_PORT_ID) {
lp->loopid = 0;
 2011                         continue;
 2012                 }
 2014                 /*
 2015                  * Make sure we can get the appropriate port information.
 2016                  */
 2017                 if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
 2019                         goto dump_em;
 2020                 }
 2022                 if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_SYNCING_PDB) {
 2024                         return (-1);
 2025                 }
 2027                 if (pdb.pdb_loopid != lp->loopid) {
isp_prt(isp, ISP_LOGWARN, pdbmfail1,
lp->portid, pdb.pdb_loopid);
 2030                         goto dump_em;
 2031                 }
 2033                 if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
isp_prt(isp, ISP_LOGWARN, pdbmfail2,
lp->portid, BITS2WORD(pdb.pdb_portid_bits));
 2036                         goto dump_em;
 2037                 }
lp->roles =
 2040                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
lp->node_wwn =
 2042                     (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
 2043                     (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
 2044                     (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
 2045                     (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
 2046                     (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
 2047                     (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
 2048                     (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
 2049                     (((u_int64_t)pdb.pdb_nodename[7]));
lp->port_wwn =
 2051                     (((u_int64_t)pdb.pdb_portname[0]) << 56) |
 2052                     (((u_int64_t)pdb.pdb_portname[1]) << 48) |
 2053                     (((u_int64_t)pdb.pdb_portname[2]) << 40) |
 2054                     (((u_int64_t)pdb.pdb_portname[3]) << 32) |
 2055                     (((u_int64_t)pdb.pdb_portname[4]) << 24) |
 2056                     (((u_int64_t)pdb.pdb_portname[5]) << 16) |
 2057                     (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
 2058                     (((u_int64_t)pdb.pdb_portname[7]));
 2059                 /*
 2060                  * Check to make sure this all makes sense.
 2061                  */
 2062                 if (lp->node_wwn && lp->port_wwn) {
lp->valid = 1;
loopid = lp - fcp->portdb;
 2065                         (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
 2066                         continue;
 2067                 }
dump_em:
lp->valid = 0;
isp_prt(isp, ISP_LOGINFO,
ldumped, loopid, lp->loopid, lp->portid);
mbs.param[0] = MBOX_FABRIC_LOGOUT;
mbs.param[1] = lp->loopid << 8;
mbs.param[2] = 0;
mbs.param[3] = 0;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
 2077                 if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_SYNCING_PDB) {
 2079                         return (-1);
 2080                 }
 2081         }
 2082         /*
 2083          * If we get here, we've for sure seen not only a valid loop
 2084          * but know what is or isn't on it, so mark this for usage
 2085          * in isp_start.
 2086          */
fcp->loop_seen_once = 1;
fcp->isp_loopstate = LOOP_READY;
 2089         return (0);
 2090 }
 2092 static int
isp_scan_loop(struct ispsoftc *isp)
 2094 {
 2095         struct lportdb *lp;
fcparam *fcp = isp->isp_param;
isp_pdb_t pdb;
 2098         int loopid, lim, hival;
 2100         switch (fcp->isp_topo) {
 2101         case TOPO_NL_PORT:
hival = FL_PORT_ID;
 2103                 break;
 2104         case TOPO_N_PORT:
hival = 2;
 2106                 break;
 2107         case TOPO_FL_PORT:
hival = FC_PORT_ID;
 2109                 break;
 2110         default:
fcp->isp_loopstate = LOOP_LSCAN_DONE;
 2112                 return (0);
 2113         }
fcp->isp_loopstate = LOOP_SCANNING_LOOP;
 2116         /*
 2117          * make sure the temp port database is clean...
 2118          */
MEMZERO((void *)fcp->tport, sizeof (fcp->tport));
 2121         /*
 2122          * Run through the local loop ports and get port database info
 2123          * for each loop ID.
 2124          *
 2125          * There's a somewhat unexplained situation where the f/w passes back
 2126          * the wrong database entity- if that happens, just restart (up to
 2127          * FL_PORT_ID times).
 2128          */
 2129         for (lim = loopid = 0; loopid < hival; loopid++) {
lp = &fcp->tport[loopid];
 2132                 /*
 2133                  * Don't even try for ourselves...
 2134                  */
 2135                 if (loopid == fcp->isp_loopid)
 2136                         continue;
lp->node_wwn = isp_get_portname(isp, loopid, 1);
 2139                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
 2140                         return (-1);
 2141                 if (lp->node_wwn == 0)
 2142                         continue;
lp->port_wwn = isp_get_portname(isp, loopid, 0);
 2144                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
 2145                         return (-1);
 2146                 if (lp->port_wwn == 0) {
lp->node_wwn = 0;
 2148                         continue;
 2149                 }
 2151                 /*
 2152                  * Get an entry....
 2153                  */
 2154                 if (isp_getpdb(isp, loopid, &pdb) != 0) {
 2155                         if (fcp->isp_loopstate < LOOP_SCANNING_LOOP)
 2156                                 return (-1);
 2157                         continue;
 2158                 }
 2159                 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
 2160                         return (-1);
 2161                 }
 2163                 /*
 2164                  * If the returned database element doesn't match what we
 2165                  * asked for, restart the process entirely (up to a point...).
 2166                  */
 2167                 if (pdb.pdb_loopid != loopid) {
loopid = 0;
 2169                         if (lim++ < hival) {
 2170                                 continue;
 2171                         }
isp_prt(isp, ISP_LOGWARN,
 2173                             "giving up on synchronizing the port database");
 2174                         return (-1);
 2175                 }
 2177                 /*
 2178                  * Save the pertinent info locally.
 2179                  */
lp->node_wwn =
 2181                     (((u_int64_t)pdb.pdb_nodename[0]) << 56) |
 2182                     (((u_int64_t)pdb.pdb_nodename[1]) << 48) |
 2183                     (((u_int64_t)pdb.pdb_nodename[2]) << 40) |
 2184                     (((u_int64_t)pdb.pdb_nodename[3]) << 32) |
 2185                     (((u_int64_t)pdb.pdb_nodename[4]) << 24) |
 2186                     (((u_int64_t)pdb.pdb_nodename[5]) << 16) |
 2187                     (((u_int64_t)pdb.pdb_nodename[6]) <<  8) |
 2188                     (((u_int64_t)pdb.pdb_nodename[7]));
lp->port_wwn =
 2190                     (((u_int64_t)pdb.pdb_portname[0]) << 56) |
 2191                     (((u_int64_t)pdb.pdb_portname[1]) << 48) |
 2192                     (((u_int64_t)pdb.pdb_portname[2]) << 40) |
 2193                     (((u_int64_t)pdb.pdb_portname[3]) << 32) |
 2194                     (((u_int64_t)pdb.pdb_portname[4]) << 24) |
 2195                     (((u_int64_t)pdb.pdb_portname[5]) << 16) |
 2196                     (((u_int64_t)pdb.pdb_portname[6]) <<  8) |
 2197                     (((u_int64_t)pdb.pdb_portname[7]));
lp->roles =
 2199                     (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
lp->portid = BITS2WORD(pdb.pdb_portid_bits);
lp->loopid = pdb.pdb_loopid;
 2202         }
 2204         /*
 2205          * Mark all of the permanent local loop database entries as invalid
 2206          * (except our own entry).
 2207          */
 2208         for (loopid = 0; loopid < hival; loopid++) {
 2209                 if (loopid == fcp->isp_iid) {
fcp->portdb[loopid].valid = 1;
fcp->portdb[loopid].loopid = fcp->isp_loopid;
 2212                         continue;
 2213                 }
fcp->portdb[loopid].valid = 0;
 2215         }
 2217         /*
 2218          * Now merge our local copy of the port database into our saved copy.
 2219          * Notify the outer layers of new devices arriving.
 2220          */
 2221         for (loopid = 0; loopid < hival; loopid++) {
 2222                 int i;
 2224                 /*
 2225                  * If we don't have a non-zero Port WWN, we're not here.
 2226                  */
 2227                 if (fcp->tport[loopid].port_wwn == 0) {
 2228                         continue;
 2229                 }
 2231                 /*
 2232                  * Skip ourselves.
 2233                  */
 2234                 if (loopid == fcp->isp_iid) {
 2235                         continue;
 2236                 }
 2238                 /*
 2239                  * For the purposes of deciding whether this is the
 2240                  * 'same' device or not, we only search for an identical
 2241                  * Port WWN. Node WWNs may or may not be the same as
 2242                  * the Port WWN, and there may be multiple different
 2243                  * Port WWNs with the same Node WWN. It would be chaos
 2244                  * to have multiple identical Port WWNs, so we don't
 2245                  * allow that.
 2246                  */
 2248                 for (i = 0; i < hival; i++) {
 2249                         int j;
 2250                         if (fcp->portdb[i].port_wwn == 0)
 2251                                 continue;
 2252                         if (fcp->portdb[i].port_wwn !=
fcp->tport[loopid].port_wwn)
 2254                                 continue;
 2255                         /*
 2256                          * We found this WWN elsewhere- it's changed
 2257                          * loopids then. We don't change its actual
 2258                          * position in our cached port database- we
 2259                          * just change the actual loop ID we'd use.
 2260                          */
 2261                         if (fcp->portdb[i].loopid != loopid) {
isp_prt(isp, ISP_LOGINFO, portshift, i,
fcp->portdb[i].loopid,
fcp->portdb[i].portid, loopid,
fcp->tport[loopid].portid);
 2266                         }
fcp->portdb[i].portid = fcp->tport[loopid].portid;
fcp->portdb[i].loopid = loopid;
fcp->portdb[i].valid = 1;
fcp->portdb[i].roles = fcp->tport[loopid].roles;
 2272                         /*
 2273                          * Now make sure this Port WWN doesn't exist elsewhere
 2274                          * in the port database.
 2275                          */
 2276                         for (j = i+1; j < hival; j++) {
 2277                                 if (fcp->portdb[i].port_wwn !=
fcp->portdb[j].port_wwn) {
 2279                                         continue;
 2280                                 }
isp_prt(isp, ISP_LOGWARN, portdup, j, i);
 2282                                 /*
 2283                                  * Invalidate the 'old' *and* 'new' ones.
 2284                                  * This is really harsh and not quite right,
 2285                                  * but if this happens, we really don't know
 2286                                  * who is what at this point.
 2287                                  */
fcp->portdb[i].valid = 0;
fcp->portdb[j].valid = 0;
 2290                         }
 2291                         break;
 2292                 }
 2294                 /*
 2295                  * If we didn't traverse the entire port database,
 2296                  * then we found (and remapped) an existing entry.
 2297                  * No need to notify anyone- go for the next one.
 2298                  */
 2299                 if (i < hival) {
isp_prt(isp, ISP_LOGINFO, retained,
fcp->portdb[i].loopid, i, fcp->portdb[i].portid);
 2302                         continue;
 2303                 }
 2305                 /*
 2306                  * We've not found this Port WWN anywhere. It's a new entry.
 2307                  * See if we can leave it where it is (with target == loopid).
 2308                  */
 2309                 if (fcp->portdb[loopid].port_wwn != 0) {
 2310                         for (lim = 0; lim < hival; lim++) {
 2311                                 if (fcp->portdb[lim].port_wwn == 0)
 2312                                         break;
 2313                         }
 2314                         /* "Cannot Happen" */
 2315                         if (lim == hival) {
isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
 2317                                 continue;
 2318                         }
i = lim;
 2320                 } else {
i = loopid;
 2322                 }
 2324                 /*
 2325                  * NB:  The actual loopid we use here is loopid- we may
 2326                  *      in fact be at a completely different index (target).
 2327                  */
fcp->portdb[i].loopid = loopid;
fcp->portdb[i].port_wwn = fcp->tport[loopid].port_wwn;
fcp->portdb[i].node_wwn = fcp->tport[loopid].node_wwn;
fcp->portdb[i].roles = fcp->tport[loopid].roles;
fcp->portdb[i].portid = fcp->tport[loopid].portid;
fcp->portdb[i].valid = 1;
 2335                 /*
 2336                  * Tell the outside world we've arrived.
 2337                  */
 2338                 (void) isp_async(isp, ISPASYNC_PROMENADE, &i);
 2339         }
 2341         /*
 2342          * Now find all previously used targets that are now invalid and
 2343          * notify the outer layers that they're gone.
 2344          */
 2345         for (lp = &fcp->portdb[0]; lp < &fcp->portdb[hival]; lp++) {
 2346                 if (lp->valid || lp->port_wwn == 0) {
 2347                         continue;
 2348                 }
 2350                 /*
 2351                  * Tell the outside world we've gone
 2352                  * away and erase our pdb entry.
 2353                  *
 2354                  */
loopid = lp - fcp->portdb;
 2356                 (void) isp_async(isp, ISPASYNC_PROMENADE, &loopid);
MEMZERO((void *) lp, sizeof (*lp));
 2358         }
fcp->isp_loopstate = LOOP_LSCAN_DONE;
 2360         return (0);
 2361 }
 2364 static int
isp_fabric_mbox_cmd(struct ispsoftc *isp, mbreg_t *mbp)
 2366 {
isp_mboxcmd(isp, mbp, MBLOGNONE);
 2368         if (mbp->param[0] != MBOX_COMMAND_COMPLETE) {
 2369                 if (FCPARAM(isp)->isp_loopstate == LOOP_SCANNING_FABRIC) {
FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
 2371                 }
 2372                 if (mbp->param[0] == MBOX_COMMAND_ERROR) {
 2373                         char tbuf[16];
 2374                         char *m;
 2375                         switch (mbp->param[1]) {
 2376                         case 1:
m = "No Loop";
 2378                                 break;
 2379                         case 2:
m = "Failed to allocate IOCB buffer";
 2381                                 break;
 2382                         case 3:
m = "Failed to allocate XCB buffer";
 2384                                 break;
 2385                         case 4:
m = "timeout or transmit failed";
 2387                                 break;
 2388                         case 5:
m = "no fabric loop";
 2390                                 break;
 2391                         case 6:
m = "remote device not a target";
 2393                                 break;
 2394                         default:
SNPRINTF(tbuf, sizeof tbuf, "%x",
mbp->param[1]);
m = tbuf;
 2398                                 break;
 2399                         }
isp_prt(isp, ISP_LOGERR, "SNS Failed- %s", m);
 2401                 }
 2402                 return (-1);
 2403         }
 2405         if (FCPARAM(isp)->isp_fwstate != FW_READY ||
FCPARAM(isp)->isp_loopstate < LOOP_SCANNING_FABRIC) {
 2407                 return (-1);
 2408         }
 2409         return(0);
 2410 }
 2412 #ifdef  ISP_USE_GA_NXT
 2413 static int
isp_scan_fabric(struct ispsoftc *isp, int ftype)
 2415 {
fcparam *fcp = isp->isp_param;
u_int32_t portid, first_portid, last_portid;
 2418         int hicap, last_port_same;
 2420         if (fcp->isp_onfabric == 0) {
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2422                 return (0);
 2423         }
FC_SCRATCH_ACQUIRE(isp);
 2427         /*
 2428          * Since Port IDs are 24 bits, we can check against having seen
 2429          * anything yet with this value.
 2430          */
last_port_same = 0;
last_portid = 0xffffffff;       /* not a port */
first_portid = portid = fcp->isp_portid;
fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
 2436         for (hicap = 0; hicap < GA_NXT_MAX; hicap++) {
mbreg_t mbs;
sns_screq_t *rq;
sns_ga_nxt_rsp_t *rs0, *rs1;
 2440                 struct lportdb lcl;
u_int8_t sc[SNS_GA_NXT_RESP_SIZE];
rq = (sns_screq_t *)sc;
MEMZERO((void *) rq, SNS_GA_NXT_REQ_SIZE);
rq->snscb_rblen = SNS_GA_NXT_RESP_SIZE >> 1;
rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+0x100);
rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+0x100);
rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+0x100);
rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+0x100);
rq->snscb_sblen = 6;
rq->snscb_data[0] = SNS_GA_NXT;
rq->snscb_data[4] = portid & 0xffff;
rq->snscb_data[5] = (portid >> 16) & 0xff;
isp_put_sns_request(isp, rq, (sns_screq_t *) fcp->isp_scratch);
MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GA_NXT_REQ_SIZE);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_GA_NXT_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2460                 /*
 2461                  * Leave 4 and 5 alone
 2462                  */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 2465                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
 2466                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
fcp->isp_loopstate = LOOP_PDB_RCVD;
 2468                         }
FC_SCRATCH_RELEASE(isp);
 2470                         return (-1);
 2471                 }
MEMORYBARRIER(isp, SYNC_SFORCPU, 0x100, SNS_GA_NXT_RESP_SIZE);
rs1 = (sns_ga_nxt_rsp_t *) sc;
rs0 = (sns_ga_nxt_rsp_t *) ((u_int8_t *)fcp->isp_scratch+0x100);
isp_get_ga_nxt_response(isp, rs0, rs1);
 2476                 if (rs1->snscb_cthdr.ct_response != FS_ACC) {
 2477                         int level;
 2478                         if (rs1->snscb_cthdr.ct_reason == 9 &&
rs1->snscb_cthdr.ct_explanation == 7)
level = ISP_LOGDEBUG0;
 2481                         else
level = ISP_LOGWARN;
isp_prt(isp, level, swrej, "GA_NXT",
rs1->snscb_cthdr.ct_reason,
rs1->snscb_cthdr.ct_explanation, portid);
FC_SCRATCH_RELEASE(isp);
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2488                         return (0);
 2489                 }
portid =
 2491                     (((u_int32_t) rs1->snscb_port_id[0]) << 16) |
 2492                     (((u_int32_t) rs1->snscb_port_id[1]) << 8) |
 2493                     (((u_int32_t) rs1->snscb_port_id[2]));
 2495                 /*
 2496                  * XXX: We should check to make sure that this entry
 2497                  * XXX: supports the type(s) we are interested in.
 2498                  */
 2499                 /*
 2500                  * Okay, we now have information about a fabric object.
 2501                  * If it is the type we're interested in, tell the outer layers
 2502                  * about it. The outer layer needs to  know: Port ID, WWNN,
 2503                  * WWPN, FC4 type, and port type.
 2504                  *
 2505                  * The lportdb structure is adequate for this.
 2506                  */
MEMZERO(&lcl, sizeof (lcl));
lcl.port_type = rs1->snscb_port_type;
lcl.fc4_type = ftype;
lcl.portid = portid;
lcl.node_wwn =
 2512                     (((u_int64_t)rs1->snscb_nodename[0]) << 56) |
 2513                     (((u_int64_t)rs1->snscb_nodename[1]) << 48) |
 2514                     (((u_int64_t)rs1->snscb_nodename[2]) << 40) |
 2515                     (((u_int64_t)rs1->snscb_nodename[3]) << 32) |
 2516                     (((u_int64_t)rs1->snscb_nodename[4]) << 24) |
 2517                     (((u_int64_t)rs1->snscb_nodename[5]) << 16) |
 2518                     (((u_int64_t)rs1->snscb_nodename[6]) <<  8) |
 2519                     (((u_int64_t)rs1->snscb_nodename[7]));
lcl.port_wwn =
 2521                     (((u_int64_t)rs1->snscb_portname[0]) << 56) |
 2522                     (((u_int64_t)rs1->snscb_portname[1]) << 48) |
 2523                     (((u_int64_t)rs1->snscb_portname[2]) << 40) |
 2524                     (((u_int64_t)rs1->snscb_portname[3]) << 32) |
 2525                     (((u_int64_t)rs1->snscb_portname[4]) << 24) |
 2526                     (((u_int64_t)rs1->snscb_portname[5]) << 16) |
 2527                     (((u_int64_t)rs1->snscb_portname[6]) <<  8) |
 2528                     (((u_int64_t)rs1->snscb_portname[7]));
 2530                 /*
 2531                  * Does this fabric object support the type we want?
 2532                  * If not, skip it.
 2533                  */
 2534                 if (rs1->snscb_fc4_types[ftype >> 5] & (1 << (ftype & 0x1f))) {
 2535                         if (first_portid == portid) {
lcl.last_fabric_dev = 1;
 2537                         } else {
lcl.last_fabric_dev = 0;
 2539                         }
 2540                         (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
 2541                 } else {
isp_prt(isp, ISP_LOGDEBUG0,
 2543                             "PortID 0x%x doesn't support FC4 type 0x%x",
portid, ftype);
 2545                 }
 2546                 if (first_portid == portid) {
fcp->isp_loopstate = LOOP_FSCAN_DONE;
FC_SCRATCH_RELEASE(isp);
 2549                         return (0);
 2550                 }
 2551                 if (portid == last_portid) {
 2552                         if (last_port_same++ > 20) {
isp_prt(isp, ISP_LOGWARN,
 2554                                     "tangled fabric database detected");
 2555                                 break;
 2556                         }
 2557                 } else {
last_port_same = 0 ;
last_portid = portid;
 2560                 }
 2561         }
FC_SCRATCH_RELEASE(isp);
 2563         if (hicap >= GA_NXT_MAX) {
isp_prt(isp, ISP_LOGWARN, "fabric too big (> %d)", GA_NXT_MAX);
 2565         }
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2567         return (0);
 2568 }
 2569 #else
 2570 #define GIDLEN  ((ISP2100_SCRLEN >> 1) + 16)
 2571 #define NGENT   ((GIDLEN - 16) >> 2)
 2573 #define IGPOFF  (ISP2100_SCRLEN - GIDLEN)
 2574 #define GXOFF   (256)
 2576 static int
isp_scan_fabric(struct ispsoftc *isp, int ftype)
 2578 {
fcparam *fcp = FCPARAM(isp);
mbreg_t mbs;
 2581         int i;
sns_gid_ft_req_t *rq;
sns_gid_ft_rsp_t *rs0, *rs1;
 2585         if (fcp->isp_onfabric == 0) {
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2587                 return (0);
 2588         }
FC_SCRATCH_ACQUIRE(isp);
fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
rq = (sns_gid_ft_req_t *)fcp->tport;
MEMZERO((void *) rq, SNS_GID_FT_REQ_SIZE);
rq->snscb_rblen = GIDLEN >> 1;
rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+IGPOFF);
rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+IGPOFF);
rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+IGPOFF);
rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+IGPOFF);
rq->snscb_sblen = 6;
rq->snscb_cmd = SNS_GID_FT;
rq->snscb_mword_div_2 = NGENT;
rq->snscb_fc4_type = ftype;
isp_put_gid_ft_request(isp, rq, (sns_gid_ft_req_t *) fcp->isp_scratch);
MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GID_FT_REQ_SIZE);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_GID_FT_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2611         /*
 2612          * Leave 4 and 5 alone
 2613          */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 2616         if (isp_fabric_mbox_cmd(isp, &mbs)) {
 2617                 if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
fcp->isp_loopstate = LOOP_PDB_RCVD;
 2619                 }
FC_SCRATCH_RELEASE(isp);
 2621                 return (-1);
 2622         }
 2623         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2625                 return (-1);
 2626         }
MEMORYBARRIER(isp, SYNC_SFORCPU, IGPOFF, GIDLEN);
rs1 = (sns_gid_ft_rsp_t *) fcp->tport;
rs0 = (sns_gid_ft_rsp_t *) ((u_int8_t *)fcp->isp_scratch+IGPOFF);
isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
 2631         if (rs1->snscb_cthdr.ct_response != FS_ACC) {
 2632                 int level;
 2633                 if (rs1->snscb_cthdr.ct_reason == 9 &&
rs1->snscb_cthdr.ct_explanation == 7)
level = ISP_LOGDEBUG0;
 2636                 else
level = ISP_LOGWARN;
isp_prt(isp, level, swrej, "GID_FT",
rs1->snscb_cthdr.ct_reason,
rs1->snscb_cthdr.ct_explanation, 0);
FC_SCRATCH_RELEASE(isp);
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2643                 return (0);
 2644         }
 2646         /*
 2647          * Okay, we now have a list of Port IDs for this class of device.
 2648          * Go through the list and for each one get the WWPN/WWNN for it
 2649          * and tell the outer layers about it. The outer layer needs to
 2650          * know: Port ID, WWNN, WWPN, FC4 type, and (possibly) port type.
 2651          *
 2652          * The lportdb structure is adequate for this.
 2653          */
i = -1;
 2655         do {
sns_gxn_id_req_t grqbuf, *gq = &grqbuf;
sns_gxn_id_rsp_t *gs0, grsbuf, *gs1 = &grsbuf;
 2658                 struct lportdb lcl;
 2659 #if     0
sns_gff_id_rsp_t *fs0, ffsbuf, *fs1 = &ffsbuf;
 2661 #endif
i++;
MEMZERO(&lcl, sizeof (lcl));
lcl.fc4_type = ftype;
lcl.portid =
 2667                     (((u_int32_t) rs1->snscb_ports[i].portid[0]) << 16) |
 2668                     (((u_int32_t) rs1->snscb_ports[i].portid[1]) << 8) |
 2669                     (((u_int32_t) rs1->snscb_ports[i].portid[2]));
MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
gq->snscb_sblen = 6;
gq->snscb_cmd = SNS_GPN_ID;
gq->snscb_portid = lcl.portid;
isp_put_gxn_id_request(isp, gq,
 2681                     (sns_gxn_id_req_t *) fcp->isp_scratch);
MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2687                 /*
 2688                  * Leave 4 and 5 alone
 2689                  */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 2692                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
 2693                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
fcp->isp_loopstate = LOOP_PDB_RCVD;
 2695                         }
FC_SCRATCH_RELEASE(isp);
 2697                         return (-1);
 2698                 }
 2699                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2701                         return (-1);
 2702                 }
MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
isp_get_gxn_id_response(isp, gs0, gs1);
 2706                 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
isp_prt(isp, ISP_LOGWARN, swrej, "GPN_ID",
gs1->snscb_cthdr.ct_reason,
gs1->snscb_cthdr.ct_explanation, lcl.portid);
 2710                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2712                                 return (-1);
 2713                         }
 2714                         continue;
 2715                 }
lcl.port_wwn = 
 2717                     (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
 2718                     (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
 2719                     (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
 2720                     (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
 2721                     (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
 2722                     (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
 2723                     (((u_int64_t)gs1->snscb_wwn[6]) <<  8) |
 2724                     (((u_int64_t)gs1->snscb_wwn[7]));
MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
gq->snscb_rblen = SNS_GXN_ID_RESP_SIZE >> 1;
gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
gq->snscb_sblen = 6;
gq->snscb_cmd = SNS_GNN_ID;
gq->snscb_portid = lcl.portid;
isp_put_gxn_id_request(isp, gq,
 2736                     (sns_gxn_id_req_t *) fcp->isp_scratch);
MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2742                 /*
 2743                  * Leave 4 and 5 alone
 2744                  */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 2747                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
 2748                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
fcp->isp_loopstate = LOOP_PDB_RCVD;
 2750                         }
FC_SCRATCH_RELEASE(isp);
 2752                         return (-1);
 2753                 }
 2754                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2756                         return (-1);
 2757                 }
MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GXN_ID_RESP_SIZE);
gs0 = (sns_gxn_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
isp_get_gxn_id_response(isp, gs0, gs1);
 2761                 if (gs1->snscb_cthdr.ct_response != FS_ACC) {
isp_prt(isp, ISP_LOGWARN, swrej, "GNN_ID",
gs1->snscb_cthdr.ct_reason,
gs1->snscb_cthdr.ct_explanation, lcl.portid);
 2765                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2767                                 return (-1);
 2768                         }
 2769                         continue;
 2770                 }
lcl.node_wwn = 
 2772                     (((u_int64_t)gs1->snscb_wwn[0]) << 56) |
 2773                     (((u_int64_t)gs1->snscb_wwn[1]) << 48) |
 2774                     (((u_int64_t)gs1->snscb_wwn[2]) << 40) |
 2775                     (((u_int64_t)gs1->snscb_wwn[3]) << 32) |
 2776                     (((u_int64_t)gs1->snscb_wwn[4]) << 24) |
 2777                     (((u_int64_t)gs1->snscb_wwn[5]) << 16) |
 2778                     (((u_int64_t)gs1->snscb_wwn[6]) <<  8) |
 2779                     (((u_int64_t)gs1->snscb_wwn[7]));
 2781                 /*
 2782                  * The QLogic f/w is bouncing this with a parameter error.
 2783                  */
 2784 #if     0
 2785                 /*
 2786                  * Try and get FC4 Features (FC-GS-3 only).
 2787                  * We can use the sns_gxn_id_req_t for this request.
 2788                  */
MEMZERO((void *) gq, sizeof (sns_gxn_id_req_t));
gq->snscb_rblen = SNS_GFF_ID_RESP_SIZE >> 1;
gq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma+GXOFF);
gq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma+GXOFF);
gq->snscb_sblen = 6;
gq->snscb_cmd = SNS_GFF_ID;
gq->snscb_portid = lcl.portid;
isp_put_gxn_id_request(isp, gq,
 2799                     (sns_gxn_id_req_t *) fcp->isp_scratch);
MEMORYBARRIER(isp, SYNC_SFORDEV, 0, SNS_GXN_ID_REQ_SIZE);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_GXN_ID_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2805                 /*
 2806                  * Leave 4 and 5 alone
 2807                  */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
 2810                 if (isp_fabric_mbox_cmd(isp, &mbs)) {
 2811                         if (fcp->isp_loopstate >= LOOP_SCANNING_FABRIC) {
fcp->isp_loopstate = LOOP_PDB_RCVD;
 2813                         }
FC_SCRATCH_RELEASE(isp);
 2815                         return (-1);
 2816                 }
 2817                 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2819                         return (-1);
 2820                 }
MEMORYBARRIER(isp, SYNC_SFORCPU, GXOFF, SNS_GFF_ID_RESP_SIZE);
fs0 = (sns_gff_id_rsp_t *) ((u_int8_t *)fcp->isp_scratch+GXOFF);
isp_get_gff_id_response(isp, fs0, fs1);
 2824                 if (fs1->snscb_cthdr.ct_response != FS_ACC) {
isp_prt(isp, /* ISP_LOGDEBUG0 */ ISP_LOGWARN,
swrej, "GFF_ID",
fs1->snscb_cthdr.ct_reason,
fs1->snscb_cthdr.ct_explanation, lcl.portid);
 2829                         if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
FC_SCRATCH_RELEASE(isp);
 2831                                 return (-1);
 2832                         }
 2833                 } else {
 2834                         int index = (ftype >> 3);
 2835                         int bshft = (ftype & 0x7) * 4;
 2836                         int fc4_fval =
 2837                             (fs1->snscb_fc4_features[index] >> bshft) & 0xf;
 2838                         if (fc4_fval & 0x1) {
lcl.roles |=
 2840                                     (SVC3_INI_ROLE >> SVC3_ROLE_SHIFT);
 2841                         }
 2842                         if (fc4_fval & 0x2) {
lcl.roles |=
 2844                                     (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT);
 2845                         }
 2846                 }
 2847 #endif
 2849                 /*
 2850                  * If we really want to know what kind of port type this is,
 2851                  * we have to run another CT command. Otherwise, we'll leave
 2852                  * it as undefined.
 2853                  *
 2854                 lcl.port_type = 0;
 2855                  */
 2856                 if (rs1->snscb_ports[i].control & 0x80) {
lcl.last_fabric_dev = 1;
 2858                 } else {
lcl.last_fabric_dev = 0;
 2860                 }
 2861                 (void) isp_async(isp, ISPASYNC_FABRIC_DEV, &lcl);
 2863         } while ((rs1->snscb_ports[i].control & 0x80) == 0 && i < NGENT-1);
 2865         /*
 2866          * If we're not at the last entry, our list isn't big enough.
 2867          */
 2868         if ((rs1->snscb_ports[i].control & 0x80) == 0) {
isp_prt(isp, ISP_LOGWARN, "fabric too big for scratch area");
 2870         }
FC_SCRATCH_RELEASE(isp);
fcp->isp_loopstate = LOOP_FSCAN_DONE;
 2874         return (0);
 2875 }
 2876 #endif
 2878 static void
isp_register_fc4_type(struct ispsoftc *isp)
 2880 {
fcparam *fcp = isp->isp_param;
u_int8_t local[SNS_RFT_ID_REQ_SIZE];
sns_screq_t *reqp = (sns_screq_t *) local;
mbreg_t mbs;
MEMZERO((void *) reqp, SNS_RFT_ID_REQ_SIZE);
reqp->snscb_rblen = SNS_RFT_ID_RESP_SIZE >> 1;
reqp->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + 0x100);
reqp->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + 0x100);
reqp->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + 0x100);
reqp->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + 0x100);
reqp->snscb_sblen = 22;
reqp->snscb_data[0] = SNS_RFT_ID;
reqp->snscb_data[4] = fcp->isp_portid & 0xffff;
reqp->snscb_data[5] = (fcp->isp_portid >> 16) & 0xff;
reqp->snscb_data[6] = (1 << FC4_SCSI);
 2897 #if     0
reqp->snscb_data[6] |= (1 << FC4_IP);   /* ISO/IEC 8802-2 LLC/SNAP */
 2899 #endif
FC_SCRATCH_ACQUIRE(isp);
isp_put_sns_request(isp, reqp, (sns_screq_t *) fcp->isp_scratch);
mbs.param[0] = MBOX_SEND_SNS;
mbs.param[1] = SNS_RFT_ID_REQ_SIZE >> 1;
mbs.param[2] = DMA_WD1(fcp->isp_scdma);
mbs.param[3] = DMA_WD0(fcp->isp_scdma);
 2906         /*
 2907          * Leave 4 and 5 alone
 2908          */
mbs.param[6] = DMA_WD3(fcp->isp_scdma);
mbs.param[7] = DMA_WD2(fcp->isp_scdma);
isp_mboxcmd(isp, &mbs, MBLOGALL);
FC_SCRATCH_RELEASE(isp);
 2913         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGDEBUG0, "Register FC4 types succeeded");
 2915         }
 2916 }
 2918 /*
 2919  * Start a command. Locking is assumed done in the caller.
 2920  */
 2922 int
isp_start(XS_T *xs)
 2924 {
 2925         struct ispsoftc *isp;
u_int16_t nxti, optr, handle;
u_int8_t local[QENTRY_LEN];
ispreq_t *reqp, *qep;
 2929         int target, i;
XS_INITERR(xs);
isp = XS_ISP(xs);
 2934         /*
 2935          * Check to make sure we're supporting initiator role.
 2936          */
 2937         if ((isp->isp_role & ISP_ROLE_INITIATOR) == 0) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 2939                 return (CMD_COMPLETE);
 2940         }
 2942         /*
 2943          * Now make sure we're running.
 2944          */
 2946         if (isp->isp_state != ISP_RUNSTATE) {
isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
XS_SETERR(xs, HBA_BOTCH);
 2949                 return (CMD_COMPLETE);
 2950         }
 2952         /*
 2953          * Check command CDB length, etc.. We really are limited to 16 bytes
 2954          * for Fibre Channel, but can do up to 44 bytes in parallel SCSI,
 2955          * but probably only if we're running fairly new firmware (we'll
 2956          * let the old f/w choke on an extended command queue entry).
 2957          */
 2959         if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
isp_prt(isp, ISP_LOGERR,
 2961                     "unsupported cdb length (%d, CDB[0]=0x%x)",
XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
XS_SETERR(xs, HBA_BOTCH);
 2964                 return (CMD_COMPLETE);
 2965         }
 2967         /*
 2968          * Check to see whether we have good firmware state still or
 2969          * need to refresh our port database for this target.
 2970          */
target = XS_TGT(xs);
 2972         if (IS_FC(isp)) {
fcparam *fcp = isp->isp_param;
 2974                 struct lportdb *lp;
 2975 #ifdef  HANDLE_LOOPSTATE_IN_OUTER_LAYERS
 2976                 if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_READY) {
 2978                         return (CMD_RQLATER);
 2979                 }
 2981                 /*
 2982                  * If we're not on a Fabric, we can't have a target
 2983                  * above FL_PORT_ID-1.
 2984                  *
 2985                  * If we're on a fabric and *not* connected as an F-port,
 2986                  * we can't have a target less than FC_SNS_ID+1. This
 2987                  * keeps us from having to sort out the difference between
 2988                  * local public loop devices and those which we might get
 2989                  * from a switch's database.
 2990                  */
 2991                 if (fcp->isp_onfabric == 0) {
 2992                         if (target >= FL_PORT_ID) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 2994                                 return (CMD_COMPLETE);
 2995                         }
 2996                 } else {
 2997                         if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 2999                                 return (CMD_COMPLETE);
 3000                         }
 3001                         /*
 3002                          * We used to exclude having local loop ports
 3003                          * at the same time that we have fabric ports.
 3004                          * That is, we used to exclude having ports
 3005                          * at < FL_PORT_ID if we're FL-port.
 3006                          *
 3007                          * That's wrong. The only thing that could be
 3008                          * dicey is if the switch you're connected to
 3009                          * has these local loop ports appear on the
 3010                          * fabric and we somehow attach them twice.
 3011                          */
 3012                 }
 3013 #else
 3014                 /*
 3015                  * Check for f/w being in ready state. If the f/w
 3016                  * isn't in ready state, then we don't know our
 3017                  * loop ID and the f/w hasn't completed logging
 3018                  * into all targets on the loop. If this is the
 3019                  * case, then bounce the command. We pretend this is
 3020                  * a SELECTION TIMEOUT error if we've never gone to
 3021                  * FW_READY state at all- in this case we may not
 3022                  * be hooked to a loop at all and we shouldn't hang
 3023                  * the machine for this. Otherwise, defer this command
 3024                  * until later.
 3025                  */
 3026                 if (fcp->isp_fwstate != FW_READY) {
 3027                         /*
 3028                          * Give ourselves at most a 250ms delay.
 3029                          */
 3030                         if (isp_fclink_test(isp, 250000)) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3032                                 if (fcp->loop_seen_once) {
 3033                                         return (CMD_RQLATER);
 3034                                 } else {
 3035                                         return (CMD_COMPLETE);
 3036                                 }
 3037                         }
 3038                 }
 3040                 /*
 3041                  * If we're not on a Fabric, we can't have a target
 3042                  * above FL_PORT_ID-1.
 3043                  *
 3044                  * If we're on a fabric and *not* connected as an F-port,
 3045                  * we can't have a target less than FC_SNS_ID+1. This
 3046                  * keeps us from having to sort out the difference between
 3047                  * local public loop devices and those which we might get
 3048                  * from a switch's database.
 3049                  */
 3050                 if (fcp->isp_onfabric == 0) {
 3051                         if (target >= FL_PORT_ID) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3053                                 return (CMD_COMPLETE);
 3054                         }
 3055                 } else {
 3056                         if (target >= FL_PORT_ID && target <= FC_SNS_ID) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3058                                 return (CMD_COMPLETE);
 3059                         }
 3060                         if (fcp->isp_topo != TOPO_F_PORT &&
target < FL_PORT_ID) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3063                                 return (CMD_COMPLETE);
 3064                         }
 3065                 }
 3067                 /*
 3068                  * If our loop state is such that we haven't yet received
 3069                  * a "Port Database Changed" notification (after a LIP or
 3070                  * a Loop Reset or firmware initialization), then defer
 3071                  * sending commands for a little while, but only if we've
 3072                  * seen a valid loop at one point (otherwise we can get
 3073                  * stuck at initialization time).
 3074                  */
 3075                 if (fcp->isp_loopstate < LOOP_PDB_RCVD) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3077                         if (fcp->loop_seen_once) {
 3078                                 return (CMD_RQLATER);
 3079                         } else {
 3080                                 return (CMD_COMPLETE);
 3081                         }
 3082                 }
 3084                 /*
 3085                  * If we're in the middle of loop or fabric scanning
 3086                  * or merging the port databases, retry this command later.
 3087                  */
 3088                 if (fcp->isp_loopstate == LOOP_SCANNING_FABRIC ||
fcp->isp_loopstate == LOOP_SCANNING_LOOP ||
fcp->isp_loopstate == LOOP_SYNCING_PDB) {
 3091                         return (CMD_RQLATER);
 3092                 }
 3094                 /*
 3095                  * If our loop state is now such that we've just now
 3096                  * received a Port Database Change notification, then
 3097                  * we have to go off and (re)scan the fabric. We back
 3098                  * out and try again later if this doesn't work.
 3099                  */
 3100                 if (fcp->isp_loopstate == LOOP_PDB_RCVD && fcp->isp_onfabric) {
 3101                         if (isp_scan_fabric(isp, FC4_SCSI)) {
 3102                                 return (CMD_RQLATER);
 3103                         }
 3104                         if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate < LOOP_FSCAN_DONE) {
 3106                                 return (CMD_RQLATER);
 3107                         }
 3108                 }
 3110                 /*
 3111                  * If our loop state is now such that we've just now
 3112                  * received a Port Database Change notification, then
 3113                  * we have to go off and (re)synchronize our port
 3114                  * database.
 3115                  */
 3116                 if (fcp->isp_loopstate < LOOP_READY) {
 3117                         if (isp_pdb_sync(isp)) {
 3118                                 return (CMD_RQLATER);
 3119                         }
 3120                         if (fcp->isp_fwstate != FW_READY ||
fcp->isp_loopstate != LOOP_READY) {
 3122                                 return (CMD_RQLATER);
 3123                         }
 3124                 }
 3126                 /*
 3127                  * XXX: Here's were we would cancel any loop_dead flag
 3128                  * XXX: also cancel in dead_loop timeout that's running
 3129                  */
 3130 #endif
 3132                 /*
 3133                  * Now check whether we should even think about pursuing this.
 3134                  */
lp = &fcp->portdb[target];
 3136                 if (lp->valid == 0) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 3138                         return (CMD_COMPLETE);
 3139                 }
 3140                 if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
isp_prt(isp, ISP_LOGDEBUG2,
 3142                             "Target %d does not have target service", target);
XS_SETERR(xs, HBA_SELTIMEOUT);
 3144                         return (CMD_COMPLETE);
 3145                 }
 3146                 /*
 3147                  * Now turn target into what the actual Loop ID is.
 3148                  */
target = lp->loopid;
xs->sc_link->node_wwn = lp->node_wwn;
xs->sc_link->port_wwn = lp->port_wwn;
 3153         }
 3155         /*
 3156          * Next check to see if any HBA or Device
 3157          * parameters need to be updated.
 3158          */
 3159         if (isp->isp_update != 0) {
isp_update(isp);
 3161         }
 3163         if (isp_getrqentry(isp, &nxti, &optr, (void *)&qep)) {
isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
XS_SETERR(xs, HBA_BOTCH);
 3166                 return (CMD_EAGAIN);
 3167         }
 3169         /*
 3170          * Now see if we need to synchronize the ISP with respect to anything.
 3171          * We do dual duty here (cough) for synchronizing for busses other
 3172          * than which we got here to send a command to.
 3173          */
reqp = (ispreq_t *) local;
 3175         if (isp->isp_sendmarker) {
u_int8_t n = (IS_DUALBUS(isp)? 2: 1);
 3177                 /*
 3178                  * Check ports to send markers for...
 3179                  */
 3180                 for (i = 0; i < n; i++) {
 3181                         if ((isp->isp_sendmarker & (1 << i)) == 0) {
 3182                                 continue;
 3183                         }
MEMZERO((void *) reqp, QENTRY_LEN);
reqp->req_header.rqs_entry_count = 1;
reqp->req_header.rqs_entry_type = RQSTYPE_MARKER;
reqp->req_modifier = SYNC_ALL;
reqp->req_target = i << 7;      /* insert bus number */
isp_put_request(isp, reqp, qep);
ISP_ADD_REQUEST(isp, nxti);
isp->isp_sendmarker &= ~(1 << i);
 3192                         if (isp_getrqentry(isp, &nxti, &optr, (void *) &qep)) {
isp_prt(isp, ISP_LOGDEBUG0,
 3194                                     "Request Queue Overflow+");
XS_SETERR(xs, HBA_BOTCH);
 3196                                 return (CMD_EAGAIN);
 3197                         }
 3198                 }
 3199         }
MEMZERO((void *)reqp, QENTRY_LEN);
reqp->req_header.rqs_entry_count = 1;
 3203         if (IS_FC(isp)) {
reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
 3205         } else {
 3206                 if (XS_CDBLEN(xs) > 12)
reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
 3208                 else
reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
 3210         }
 3211         /* reqp->req_header.rqs_flags = 0; */
 3212         /* reqp->req_header.rqs_seqno = 0; */
 3213         if (IS_FC(isp)) {
 3214                 /*
 3215                  * See comment in isp_intr
 3216                  */
 3217                 /* XS_RESID(xs) = 0; */
 3219                 /*
 3220                  * Fibre Channel always requires some kind of tag.
 3221                  * The Qlogic drivers seem be happy not to use a tag,
 3222                  * but this breaks for some devices (IBM drives).
 3223                  */
 3224                 if (XS_TAG_P(xs)) {
 3225                         ((ispreqt2_t *)reqp)->req_flags = XS_TAG_TYPE(xs);
 3226                 } else {
 3227                         /*
 3228                          * If we don't know what tag to use, use HEAD OF QUEUE
 3229                          * for Request Sense or Simple.
 3230                          */
 3231                         if (XS_CDBP(xs)[0] == 0x3)      /* REQUEST SENSE */
 3232                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_HTAG;
 3233                         else
 3234                                 ((ispreqt2_t *)reqp)->req_flags = REQFLAG_STAG;
 3235                 }
 3236         } else {
sdparam *sdp = (sdparam *)isp->isp_param;
sdp += XS_CHANNEL(xs);
 3239                 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) &&
XS_TAG_P(xs)) {
reqp->req_flags = XS_TAG_TYPE(xs);
 3242                 }
 3243         }
reqp->req_target = target | (XS_CHANNEL(xs) << 7);
 3245         if (IS_SCSI(isp)) {
reqp->req_lun_trn = XS_LUN(xs);
reqp->req_cdblen = XS_CDBLEN(xs);
 3248         } else {
 3249                 if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)
 3250                         ((ispreqt2_t *)reqp)->req_scclun = XS_LUN(xs);
 3251                 else
 3252                         ((ispreqt2_t *)reqp)->req_lun_trn = XS_LUN(xs);
 3253         }
MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs));
reqp->req_time = XS_TIME(xs) / 1000;
 3257         if (reqp->req_time == 0 && XS_TIME(xs)) {
reqp->req_time = 1;
 3259         }
 3261         if (isp_save_xs(isp, xs, &handle)) {
isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
XS_SETERR(xs, HBA_BOTCH);
 3264                 return (CMD_EAGAIN);
 3265         }
reqp->req_handle = handle;
 3268         /*
 3269          * Set up DMA and/or do any bus swizzling of the request entry
 3270          * so that the Qlogic F/W understands what is being asked of it.
 3271          */
i = ISP_DMASETUP(isp, xs, reqp, &nxti, optr);
 3273         if (i != CMD_QUEUED) {
isp_destroy_handle(isp, handle);
 3275                 /*
 3276                  * dmasetup sets actual error in packet, and
 3277                  * return what we were given to return.
 3278                  */
 3279                 return (i);
 3280         }
XS_SETERR(xs, HBA_NOERROR);
isp_prt(isp, ISP_LOGDEBUG2,
 3283             "START cmd for %d.%d.%d cmd 0x%x datalen %ld",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), XS_CDBP(xs)[0],
 3285             (long) XS_XFRLEN(xs));
ISP_ADD_REQUEST(isp, nxti);
isp->isp_nactive++;
 3288         return (CMD_QUEUED);
 3289 }
 3291 /*
 3292  * isp control
 3293  * Locks (ints blocked) assumed held.
 3294  */
 3296 int
isp_control(struct ispsoftc *isp, ispctl_t ctl, void *arg)
 3298 {
XS_T *xs;
mbreg_t mbs;
 3301         int bus, tgt;
u_int16_t handle;
 3304         switch (ctl) {
 3305         default:
isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
 3307                 break;
 3309         case ISPCTL_RESET_BUS:
 3310                 /*
 3311                  * Issue a bus reset.
 3312                  */
mbs.param[0] = MBOX_BUS_RESET;
mbs.param[2] = 0;
 3315                 if (IS_SCSI(isp)) {
mbs.param[1] =
 3317                             ((sdparam *) isp->isp_param)->isp_bus_reset_delay;
 3318                         if (mbs.param[1] < 2)
mbs.param[1] = 2;
bus = *((int *) arg);
 3321                         if (IS_DUALBUS(isp))
mbs.param[2] = bus;
 3323                 } else {
mbs.param[1] = 10;
bus = 0;
 3326                 }
isp->isp_sendmarker |= (1 << bus);
isp_mboxcmd(isp, &mbs, MBLOGALL);
 3329                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 3330                         break;
 3331                 }
isp_prt(isp, ISP_LOGINFO,
 3333                     "driver initiated bus reset of bus %d", bus);
 3334                 return (0);
 3336         case ISPCTL_RESET_DEV:
tgt = (*((int *) arg)) & 0xffff;
bus = (*((int *) arg)) >> 16;
mbs.param[0] = MBOX_ABORT_TARGET;
mbs.param[1] = (tgt << 8) | (bus << 15);
mbs.param[2] = 3;       /* 'delay', in seconds */
isp_mboxcmd(isp, &mbs, MBLOGALL);
 3343                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 3344                         break;
 3345                 }
isp_prt(isp, ISP_LOGINFO,
 3347                     "Target %d on Bus %d Reset Succeeded", tgt, bus);
isp->isp_sendmarker |= (1 << bus);
 3349                 return (0);
 3351         case ISPCTL_ABORT_CMD:
xs = (XS_T *) arg;
tgt = XS_TGT(xs);
handle = isp_find_handle(isp, xs);
 3355                 if (handle == 0) {
isp_prt(isp, ISP_LOGWARN,
 3357                             "cannot find handle for command to abort");
 3358                         break;
 3359                 }
bus = XS_CHANNEL(xs);
mbs.param[0] = MBOX_ABORT;
 3362                 if (IS_FC(isp)) {
 3363                         if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN)  {
mbs.param[1] = tgt << 8;
mbs.param[4] = 0;
mbs.param[5] = 0;
mbs.param[6] = XS_LUN(xs);
 3368                         } else {
mbs.param[1] = tgt << 8 | XS_LUN(xs);
 3370                         }
 3371                 } else {
mbs.param[1] =
 3373                             (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs);
 3374                 }
mbs.param[3] = 0;
mbs.param[2] = handle;
isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
 3378                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 3379                         return (0);
 3380                 }
 3381                 /*
 3382                  * XXX: Look for command in the REQUEST QUEUE. That is,
 3383                  * XXX: It hasn't been picked up by firmware yet.
 3384                  */
 3385                 break;
 3387         case ISPCTL_UPDATE_PARAMS:
isp_update(isp);
 3390                 return (0);
 3392         case ISPCTL_FCLINK_TEST:
 3394                 if (IS_FC(isp)) {
 3395                         int usdelay = (arg)? *((int *) arg) : 250000;
 3396                         return (isp_fclink_test(isp, usdelay));
 3397                 }
 3398                 break;
 3400         case ISPCTL_SCAN_FABRIC:
 3402                 if (IS_FC(isp)) {
 3403                         int ftype = (arg)? *((int *) arg) : FC4_SCSI;
 3404                         return (isp_scan_fabric(isp, ftype));
 3405                 }
 3406                 break;
 3408         case ISPCTL_SCAN_LOOP:
 3410                 if (IS_FC(isp)) {
 3411                         return (isp_scan_loop(isp));
 3412                 }
 3413                 break;
 3415         case ISPCTL_PDB_SYNC:
 3417                 if (IS_FC(isp)) {
 3418                         return (isp_pdb_sync(isp));
 3419                 }
 3420                 break;
 3422         case ISPCTL_SEND_LIP:
 3424                 if (IS_FC(isp)) {
mbs.param[0] = MBOX_INIT_LIP;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 3427                         if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
 3428                                 return (0);
 3429                         }
 3430                 }
 3431                 break;
 3433         case ISPCTL_GET_POSMAP:
 3435                 if (IS_FC(isp) && arg) {
 3436                         return (isp_getmap(isp, arg));
 3437                 }
 3438                 break;
 3440         case ISPCTL_RUN_MBOXCMD:
isp_mboxcmd(isp, arg, MBLOGALL);
 3443                 return(0);
 3445 #ifdef  ISP_TARGET_MODE
 3446         case ISPCTL_TOGGLE_TMODE:
 3447         {
 3449                 /*
 3450                  * We don't check/set against role here- that's the
 3451                  * responsibility for the outer layer to coordinate.
 3452                  */
 3453                 if (IS_SCSI(isp)) {
 3454                         int param = *(int *)arg;
mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
mbs.param[1] = param & 0xffff;
mbs.param[2] = param >> 16;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 3459                         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
 3460                                 break;
 3461                         }
 3462                 }
 3463                 return (0);
 3464         }
 3465 #endif
 3466         }
 3467         return (-1);
 3468 }
 3470 /*
 3471  * Interrupt Service Routine(s).
 3472  *
 3473  * External (OS) framework has done the appropriate locking,
 3474  * and the locking will be held throughout this function.
 3475  */
 3477 /*
 3478  * Limit our stack depth by sticking with the max likely number
 3479  * of completions on a request queue at any one time.
 3480  */
 3481 #ifndef MAX_REQUESTQ_COMPLETIONS
 3482 #define MAX_REQUESTQ_COMPLETIONS        64
 3483 #endif
 3485 void
isp_intr(struct ispsoftc *isp, u_int16_t isr, u_int16_t sema, u_int16_t mbox)
 3487 {
XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
u_int16_t iptr, optr, junk;
 3490         int i, nlooked = 0, ndone = 0;
again:
 3493         /*
 3494          * Is this a mailbox related interrupt?
 3495          * The mailbox semaphore will be nonzero if so.
 3496          */
 3497         if (sema) {
 3498                 if (mbox & 0x4000) {
isp->isp_intmboxc++;
 3500                         if (isp->isp_mboxbsy) {
 3501                                 int i = 0, obits = isp->isp_obits;
isp->isp_mboxtmp[i++] = mbox;
 3503                                 for (i = 1; i < MAX_MAILBOX; i++) {
 3504                                         if ((obits & (1 << i)) == 0) {
 3505                                                 continue;
 3506                                         }
isp->isp_mboxtmp[i] =
ISP_READ(isp, MBOX_OFF(i));
 3509                                 }
 3510                                 if (isp->isp_mbxwrk0) {
 3511                                         if (isp_mbox_continue(isp) == 0) {
 3512                                                 return;
 3513                                         }
 3514                                 }
MBOX_NOTIFY_COMPLETE(isp);
 3516                         } else {
isp_prt(isp, ISP_LOGWARN,
 3518                                     "Mbox Command Async (0x%x) with no waiters",
mbox);
 3520                         }
 3521                 } else if (isp_parse_async(isp, mbox) < 0) {
 3522                         return;
 3523                 }
 3524                 if ((IS_FC(isp) && mbox != ASYNC_RIO_RESP) ||
isp->isp_state != ISP_RUNSTATE) {
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
ISP_WRITE(isp, BIU_SEMA, 0);
 3528                         return;
 3529                 }
 3530         }
 3532         /*
 3533          * We can't be getting this now.
 3534          */
 3535         if (isp->isp_state != ISP_RUNSTATE) {
isp_prt(isp, ISP_LOGWARN,
 3537                     "interrupt (ISR=%x SEMA=%x) when not ready", isr, sema);
 3538                 /*
 3539                  * Thank you very much!  *Burrrp*!
 3540                  */
WRITE_RESPONSE_QUEUE_OUT_POINTER(isp,
READ_RESPONSE_QUEUE_IN_POINTER(isp));
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
ISP_WRITE(isp, BIU_SEMA, 0);
 3546                 return;
 3547         }
 3549         /*
 3550          * Get the current Response Queue Out Pointer.
 3551          *
 3552          * If we're a 2300, we can ask what hardware what it thinks.
 3553          */
 3554         if (IS_23XX(isp)) {
optr = ISP_READ(isp, isp->isp_respoutrp);
 3556                 /*
 3557                  * Debug: to be taken out eventually
 3558                  */
 3559                 if (isp->isp_residx != optr) {
isp_prt(isp, ISP_LOGWARN, "optr %x soft optr %x",
optr, isp->isp_residx);
 3562                 }
 3563         } else {
optr = isp->isp_residx;
 3565         }
 3567         /*
 3568          * You *must* read the Response Queue In Pointer
 3569          * prior to clearing the RISC interrupt.
 3570          *
 3571          * Debounce the 2300 if revision less than 2.
 3572          */
 3573         if (IS_2100(isp) || (IS_2300(isp) && isp->isp_revision < 2)) {
i = 0;
 3575                 do {
iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
junk = READ_RESPONSE_QUEUE_IN_POINTER(isp);
 3578                 } while (junk != iptr && ++i < 1000);
 3580                 if (iptr != junk) {
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
isp_prt(isp, ISP_LOGWARN,
 3583                             "Response Queue Out Pointer Unstable (%x, %x)",
iptr, junk);
 3585                         return;
 3586                 }
 3587         } else {
iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
 3589         }
isp->isp_resodx = iptr;
 3593         if (optr == iptr && sema == 0) {
 3594                 /*
 3595                  * There are a lot of these- reasons unknown- mostly on
 3596                  * faster Alpha machines.
 3597                  *
 3598                  * I tried delaying after writing HCCR_CMD_CLEAR_RISC_INT to
 3599                  * make sure the old interrupt went away (to avoid 'ringing'
 3600                  * effects), but that didn't stop this from occurring.
 3601                  */
 3602                 if (IS_23XX(isp)) {
USEC_DELAY(100);
iptr = READ_RESPONSE_QUEUE_IN_POINTER(isp);
junk = ISP_READ(isp, BIU_R2HSTSLO);
 3606                 } else {
junk = ISP_READ(isp, BIU_ISR);
 3608                 }
 3609                 if (optr == iptr) {
 3610                         if (IS_23XX(isp)) {
 3611                                 ;
 3612                         } else {
sema = ISP_READ(isp, BIU_SEMA);
mbox = ISP_READ(isp, OUTMAILBOX0);
 3615                                 if ((sema & 0x3) && (mbox & 0x8000)) {
 3616                                         goto again;
 3617                                 }
 3618                         }
isp->isp_intbogus++;
isp_prt(isp, ISP_LOGDEBUG1,
 3621                             "bogus intr- isr %x (%x) iptr %x optr %x",
isr, junk, iptr, optr);
 3623                 }
 3624         }
isp->isp_resodx = iptr;
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
ISP_WRITE(isp, BIU_SEMA, 0);
 3629         if (isp->isp_rspbsy) {
 3630                 return;
 3631         }
isp->isp_rspbsy = 1;
 3634         while (optr != iptr) {
ispstatusreq_t local, *sp = &local;
isphdr_t *hp;
 3637                 int type;
u_int16_t oop;
 3639                 int buddaboom = 0;
hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
oop = optr;
optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
nlooked++;
 3645                 /*
 3646                  * Synchronize our view of this response queue entry.
 3647                  */
MEMORYBARRIER(isp, SYNC_RESULT, oop, QENTRY_LEN);
type = isp_get_response_type(isp, hp);
 3652                 if (type == RQSTYPE_RESPONSE) {
isp_get_response(isp, (ispstatusreq_t *) hp, sp);
 3654                 } else if (type == RQSTYPE_RIO2) {
isp_rio2_t rio;
isp_get_rio2(isp, (isp_rio2_t *) hp, &rio);
 3657                         for (i = 0; i < rio.req_header.rqs_seqno; i++) {
isp_fastpost_complete(isp, rio.req_handles[i]);
 3659                         }
 3660                         if (isp->isp_fpcchiwater < rio.req_header.rqs_seqno)
isp->isp_fpcchiwater = rio.req_header.rqs_seqno;
MEMZERO(hp, QENTRY_LEN);        /* PERF */
 3663                         continue;
 3664                 } else {
 3665                         /*
 3666                          * Somebody reachable via isp_handle_other_response
 3667                          * may have updated the response queue pointers for
 3668                          * us, so we reload our goal index.
 3669                          */
 3670                         if (isp_handle_other_response(isp, type, hp, &optr)) {
iptr = isp->isp_resodx;
MEMZERO(hp, QENTRY_LEN);        /* PERF */
 3673                                 continue;
 3674                         }
 3676                         /*
 3677                          * After this point, we'll just look at the header as
 3678                          * we don't know how to deal with the rest of the
 3679                          * response.
 3680                          */
isp_get_response(isp, (ispstatusreq_t *) hp, sp);
 3683                         /*
 3684                          * It really has to be a bounced request just copied
 3685                          * from the request queue to the response queue. If
 3686                          * not, something bad has happened.
 3687                          */
 3688                         if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
isp_prt(isp, ISP_LOGERR, notresp,
sp->req_header.rqs_entry_type, oop, optr,
nlooked);
 3692                                 if (isp->isp_dblev & ISP_LOGDEBUG0) {
isp_print_bytes(isp, "Queue Entry",
QENTRY_LEN, sp);
 3695                                 }
MEMZERO(hp, QENTRY_LEN);        /* PERF */
 3697                                 continue;
 3698                         }
buddaboom = 1;
 3700                 }
 3702                 if (sp->req_header.rqs_flags & 0xf) {
 3703 #define _RQS_OFLAGS     \
 3704         ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
 3705                         if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
isp_prt(isp, ISP_LOGWARN,
 3707                                     "continuation segment");
WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
 3709                                 continue;
 3710                         }
 3711                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
isp_prt(isp, ISP_LOGDEBUG1,
 3713                                     "internal queues full");
 3714                                 /*
 3715                                  * We'll synthesize a QUEUE FULL message below.
 3716                                  */
 3717                         }
 3718                         if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
isp_prt(isp, ISP_LOGERR,  "bad header flag");
buddaboom++;
 3721                         }
 3722                         if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
isp_prt(isp, ISP_LOGERR, "bad request packet");
buddaboom++;
 3725                         }
 3726                         if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
isp_prt(isp, ISP_LOGERR,
 3728                                     "unknown flags (0x%x) in response",
sp->req_header.rqs_flags);
buddaboom++;
 3731                         }
 3732 #undef  _RQS_OFLAGS
 3733                 }
 3734                 if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
MEMZERO(hp, QENTRY_LEN);        /* PERF */
isp_prt(isp, ISP_LOGERR,
 3737                             "bad request handle %d (type 0x%x, flags 0x%x)",
sp->req_handle, sp->req_header.rqs_entry_type,
sp->req_header.rqs_flags);
WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
 3741                         continue;
 3742                 }
xs = isp_find_xs(isp, sp->req_handle);
 3744                 if (xs == NULL) {
u_int8_t ts = sp->req_completion_status & 0xff;
MEMZERO(hp, QENTRY_LEN);        /* PERF */
 3747                         /*
 3748                          * Only whine if this isn't the expected fallout of
 3749                          * aborting the command.
 3750                          */
 3751                         if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
isp_prt(isp, ISP_LOGERR,
 3753                                     "cannot find handle 0x%x (type 0x%x)",
sp->req_handle,
sp->req_header.rqs_entry_type);
 3756                         } else if (ts != RQCS_ABORTED) {
isp_prt(isp, ISP_LOGERR,
 3758                                     "cannot find handle 0x%x (status 0x%x)",
sp->req_handle, ts);
 3760                         }
WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
 3762                         continue;
 3763                 }
isp_destroy_handle(isp, sp->req_handle);
 3765                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
XS_SETERR(xs, HBA_BUSRESET);
isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
 3768                 }
 3769                 if (buddaboom) {
XS_SETERR(xs, HBA_BOTCH);
 3771                 }
 3773                 if (IS_FC(isp) && (sp->req_scsi_status & RQCS_SV)) {
 3774                         /*
 3775                          * Fibre Channel F/W doesn't say we got status
 3776                          * if there's Sense Data instead. I guess they
 3777                          * think it goes w/o saying.
 3778                          */
sp->req_state_flags |= RQSF_GOT_STATUS;
 3780                 }
 3781                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
 3782                         *XS_STSP(xs) = sp->req_scsi_status & 0xff;
 3783                 }
 3785                 switch (sp->req_header.rqs_entry_type) {
 3786                 case RQSTYPE_RESPONSE:
XS_SET_STATE_STAT(isp, xs, sp);
isp_parse_status(isp, sp, xs);
 3789                         if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
 3790                             (*XS_STSP(xs) == SCSI_BUSY)) {
XS_SETERR(xs, HBA_TGTBSY);
 3792                         }
 3793                         if (IS_SCSI(isp)) {
XS_RESID(xs) = sp->req_resid;
 3795                                 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
 3796                                     (*XS_STSP(xs) == SCSI_CHECK) &&
 3797                                     (sp->req_state_flags & RQSF_GOT_SENSE)) {
XS_SAVE_SENSE(xs, sp);
 3799                                 }
 3800                                 /*
 3801                                  * A new synchronous rate was negotiated for
 3802                                  * this target. Mark state such that we'll go
 3803                                  * look up that which has changed later.
 3804                                  */
 3805                                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
 3806                                         int t = XS_TGT(xs);
sdparam *sdp = isp->isp_param;
sdp += XS_CHANNEL(xs);
sdp->isp_devparam[t].dev_refresh = 1;
isp->isp_update |=
 3811                                             (1 << XS_CHANNEL(xs));
 3812                                 }
 3813                         } else {
 3814                                 if (sp->req_status_flags & RQSF_XFER_COMPLETE) {
XS_RESID(xs) = 0;
 3816                                 } else if (sp->req_scsi_status & RQCS_RESID) {
XS_RESID(xs) = sp->req_resid;
 3818                                 } else {
XS_RESID(xs) = 0;
 3820                                 }
 3821                                 if ((sp->req_state_flags & RQSF_GOT_STATUS) &&
 3822                                     (*XS_STSP(xs) == SCSI_CHECK) &&
 3823                                     (sp->req_scsi_status & RQCS_SV)) {
XS_SAVE_SENSE(xs, sp);
 3825                                         /* solely for the benefit of debug */
sp->req_state_flags |= RQSF_GOT_SENSE;
 3827                                 }
 3828                         }
isp_prt(isp, ISP_LOGDEBUG2,
 3830                            "asked for %ld got resid %ld", (long) XS_XFRLEN(xs),
 3831                            (long) sp->req_resid);
 3832                         break;
 3833                 case RQSTYPE_REQUEST:
 3834                         if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
 3835                                 /*
 3836                                  * Force Queue Full status.
 3837                                  */
 3838                                 *XS_STSP(xs) = SCSI_QFULL;
XS_SETERR(xs, HBA_NOERROR);
 3840                         } else if (XS_NOERR(xs)) {
 3841                                 /*
 3842                                  * ????
 3843                                  */
isp_prt(isp, ISP_LOGDEBUG0,
 3845                                     "Request Queue Entry bounced back");
XS_SETERR(xs, HBA_BOTCH);
 3847                         }
XS_RESID(xs) = XS_XFRLEN(xs);
 3849                         break;
 3850                 default:
isp_prt(isp, ISP_LOGWARN,
 3852                             "unhandled response queue type 0x%x",
sp->req_header.rqs_entry_type);
 3854                         if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BOTCH);
 3856                         }
 3857                         break;
 3858                 }
 3860                 /*
 3861                  * Free any dma resources. As a side effect, this may
 3862                  * also do any cache flushing necessary for data coherence.                      */
 3863                 if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, sp->req_handle);
 3865                 }
 3867                 if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
 3868                     ((isp->isp_dblev & ISP_LOGDEBUG1) && ((!XS_NOERR(xs)) ||
 3869                     (*XS_STSP(xs) != SCSI_GOOD)))) {
 3870                         char skey;
 3871                         if (sp->req_state_flags & RQSF_GOT_SENSE) {
skey = XS_SNSKEY(xs) & 0xf;
 3873                                 if (skey < 10)
skey += '0';
 3875                                 else
skey += 'a' - 10;
 3877                         } else if (*XS_STSP(xs) == SCSI_CHECK) {
skey = '?';
 3879                         } else {
skey = '.';
 3881                         }
isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs),
 3884                             (ulong)XS_RESID(xs),
 3885                             *XS_STSP(xs), skey, XS_ERR(xs));
 3886                 }
 3888                 if (isp->isp_nactive > 0)
isp->isp_nactive--;
complist[ndone++] = xs; /* defer completion call until later */
MEMZERO(hp, QENTRY_LEN);        /* PERF */
 3892                 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
 3893                         break;
 3894                 }
 3895         }
 3897         /*
 3898          * If we looked at any commands, then it's valid to find out
 3899          * what the outpointer is. It also is a trigger to update the
 3900          * ISP's notion of what we've seen so far.
 3901          */
 3902         if (nlooked) {
WRITE_RESPONSE_QUEUE_OUT_POINTER(isp, optr);
 3904                 /*
 3905                  * While we're at it, read the request queue out pointer.
 3906                  */
isp->isp_reqodx = READ_REQUEST_QUEUE_OUT_POINTER(isp);
 3908                 if (isp->isp_rscchiwater < ndone)
isp->isp_rscchiwater = ndone;
 3910         }
isp->isp_residx = optr;
isp->isp_rspbsy = 0;
 3914         for (i = 0; i < ndone; i++) {
xs = complist[i];
 3916                 if (xs) {
isp->isp_rsltccmplt++;
isp_done(xs);
 3919                 }
 3920         }
 3921 }
 3923 /*
 3924  * Support routines.
 3925  */
 3927 static int
isp_parse_async(struct ispsoftc *isp, u_int16_t mbox)
 3929 {
 3930         int rval = 0;
 3931         int bus;
 3933         if (IS_DUALBUS(isp)) {
bus = ISP_READ(isp, OUTMAILBOX6);
 3935         } else {
bus = 0;
 3937         }
isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
 3940         switch (mbox) {
 3941         case ASYNC_BUS_RESET:
isp->isp_sendmarker |= (1 << bus);
 3943 #ifdef  ISP_TARGET_MODE
 3944                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 3946 #endif
isp_async(isp, ISPASYNC_BUS_RESET, &bus);
 3948                 break;
 3949         case ASYNC_SYSTEM_ERROR:
 3950 #ifdef  ISP_FW_CRASH_DUMP
 3951                 /*
 3952                  * If we have crash dumps enabled, it's up to the handler
 3953                  * for isp_async to reinit stuff and restart the firmware
 3954                  * after performing the crash dump. The reason we do things
 3955                  * this way is that we may need to activate a kernel thread
 3956                  * to do all the crash dump goop.
 3957                  */
isp_async(isp, ISPASYNC_FW_CRASH, NULL);
 3959 #else
isp_async(isp, ISPASYNC_FW_CRASH, NULL);
isp_reinit(isp);
isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
 3963 #endif
rval = -1;
 3965                 break;
 3967         case ASYNC_RQS_XFER_ERR:
isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
 3969                 break;
 3971         case ASYNC_RSP_XFER_ERR:
isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
 3973                 break;
 3975         case ASYNC_QWAKEUP:
 3976                 /*
 3977                  * We've just been notified that the Queue has woken up.
 3978                  * We don't need to be chatty about this- just unlatch things
 3979                  * and move on.
 3980                  */
mbox = READ_REQUEST_QUEUE_OUT_POINTER(isp);
 3982                 break;
 3984         case ASYNC_TIMEOUT_RESET:
isp_prt(isp, ISP_LOGWARN,
 3986                     "timeout initiated SCSI bus reset of bus %d", bus);
isp->isp_sendmarker |= (1 << bus);
 3988 #ifdef  ISP_TARGET_MODE
 3989                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 3991 #endif
 3992                 break;
 3994         case ASYNC_DEVICE_RESET:
isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
isp->isp_sendmarker |= (1 << bus);
 3997 #ifdef  ISP_TARGET_MODE
 3998                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4000 #endif
 4001                 break;
 4003         case ASYNC_EXTMSG_UNDERRUN:
isp_prt(isp, ISP_LOGWARN, "extended message underrun");
 4005                 break;
 4007         case ASYNC_SCAM_INT:
isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
 4009                 break;
 4011         case ASYNC_HUNG_SCSI:
isp_prt(isp, ISP_LOGERR,
 4013                     "stalled SCSI Bus after DATA Overrun");
 4014                 /* XXX: Need to issue SCSI reset at this point */
 4015                 break;
 4017         case ASYNC_KILLED_BUS:
isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
 4019                 break;
 4021         case ASYNC_BUS_TRANSIT:
mbox = ISP_READ(isp, OUTMAILBOX2);
 4023                 switch (mbox & 0x1c00) {
 4024                 case SXP_PINS_LVD_MODE:
isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
SDPARAM(isp)->isp_diffmode = 0;
SDPARAM(isp)->isp_ultramode = 0;
SDPARAM(isp)->isp_lvdmode = 1;
 4029                         break;
 4030                 case SXP_PINS_HVD_MODE:
isp_prt(isp, ISP_LOGINFO,
 4032                             "Transition to Differential mode");
SDPARAM(isp)->isp_diffmode = 1;
SDPARAM(isp)->isp_ultramode = 0;
SDPARAM(isp)->isp_lvdmode = 0;
 4036                         break;
 4037                 case SXP_PINS_SE_MODE:
isp_prt(isp, ISP_LOGINFO,
 4039                             "Transition to Single Ended mode");
SDPARAM(isp)->isp_diffmode = 0;
SDPARAM(isp)->isp_ultramode = 1;
SDPARAM(isp)->isp_lvdmode = 0;
 4043                         break;
 4044                 default:
isp_prt(isp, ISP_LOGWARN,
 4046                             "Transition to Unknown Mode 0x%x", mbox);
 4047                         break;
 4048                 }
 4049                 /*
 4050                  * XXX: Set up to renegotiate again!
 4051                  */
 4052                 /* Can only be for a 1080... */
isp->isp_sendmarker |= (1 << bus);
 4054                 break;
 4056         /*
 4057          * We can use bus, which will always be zero for FC cards,
 4058          * as a mailbox pattern accumulator to be checked below.
 4059          */
 4060         case ASYNC_RIO5:
bus = 0x1ce;    /* outgoing mailbox regs 1-3, 6-7 */
 4062                 break;
 4064         case ASYNC_RIO4:
bus = 0x14e;    /* outgoing mailbox regs 1-3, 6 */
 4066                 break;
 4068         case ASYNC_RIO3:
bus = 0x10e;    /* outgoing mailbox regs 1-3 */
 4070                 break;
 4072         case ASYNC_RIO2:
bus = 0x106;    /* outgoing mailbox regs 1-2 */
 4074                 break;
 4076         case ASYNC_RIO1:
 4077         case ASYNC_CMD_CMPLT:
bus = 0x102;    /* outgoing mailbox regs 1 */
 4079                 break;
 4081         case ASYNC_RIO_RESP:
 4082                 return (rval);
 4084         case ASYNC_CTIO_DONE:
 4085         {
 4086 #ifdef  ISP_TARGET_MODE
 4087                 int handle =
 4088                     (ISP_READ(isp, OUTMAILBOX2) << 16) | 
 4089                     (ISP_READ(isp, OUTMAILBOX1));
 4090                 if (isp_target_async(isp, handle, mbox))
rval = -1;
 4092 #else
isp_prt(isp, ISP_LOGINFO, "Fast Posting CTIO done");
 4094 #endif
isp->isp_fphccmplt++;   /* count it as a fast posting intr */
 4096                 break;
 4097         }
 4098         case ASYNC_LIP_F8:
 4099         case ASYNC_LIP_OCCURRED:
FCPARAM(isp)->isp_lipseq =
ISP_READ(isp, OUTMAILBOX1);
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
isp->isp_sendmarker = 1;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_LIP, NULL);
 4107 #ifdef  ISP_TARGET_MODE
 4108                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4110 #endif
 4111                 /*
 4112                  * We've had problems with data corruption occurring on
 4113                  * commands that complete (with no apparent error) after
 4114                  * we receive a LIP. This has been observed mostly on
 4115                  * Local Loop topologies. To be safe, let's just mark
 4116                  * all active commands as dead.
 4117                  */
 4118                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
 4120                         int i, j;
 4121                         for (i = j = 0; i < isp->isp_maxcmds; i++) {
XS_T *xs;
xs = isp->isp_xflist[i];
 4124                                 if (xs != NULL) {
j++;
XS_SETERR(xs, HBA_BUSRESET);
 4127                                 }
 4128                         }
 4129                         if (j) {
isp_prt(isp, ISP_LOGERR,
 4131                                     "LIP destroyed %d active commands", j);
 4132                         }
 4133                 }
 4134                 break;
 4136         case ASYNC_LOOP_UP:
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_LOOP_UP, NULL);
 4142 #ifdef  ISP_TARGET_MODE
 4143                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4145 #endif
 4146                 break;
 4148         case ASYNC_LOOP_DOWN:
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_NIL;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_LOOP_DOWN, NULL);
 4154 #ifdef  ISP_TARGET_MODE
 4155                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4157 #endif
 4158                 break;
 4160         case ASYNC_LOOP_RESET:
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_NIL;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_LOOP_RESET, NULL);
 4166 #ifdef  ISP_TARGET_MODE
 4167                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4169 #endif
 4170                 break;
 4172         case ASYNC_PDB_CHANGED:
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_PDB);
 4177                 break;
 4179         case ASYNC_CHANGE_NOTIFY:
 4180                 /*
 4181                  * Not correct, but it will force us to rescan the loop.
 4182                  */
FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_SNS);
 4186                 break;
 4188         case ASYNC_PTPMODE:
 4189                 if (FCPARAM(isp)->isp_onfabric)
FCPARAM(isp)->isp_topo = TOPO_F_PORT;
 4191                 else
FCPARAM(isp)->isp_topo = TOPO_N_PORT;
isp_mark_getpdb_all(isp);
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
 4198 #ifdef  ISP_TARGET_MODE
 4199                 if (isp_target_async(isp, bus, mbox))
rval = -1;
 4201 #endif
isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
 4203                 break;
 4205         case ASYNC_CONNMODE:
mbox = ISP_READ(isp, OUTMAILBOX1);
isp_mark_getpdb_all(isp);
 4208                 switch (mbox) {
 4209                 case ISP_CONN_LOOP:
isp_prt(isp, ISP_LOGINFO,
 4211                             "Point-to-Point -> Loop mode");
 4212                         break;
 4213                 case ISP_CONN_PTP:
isp_prt(isp, ISP_LOGINFO,
 4215                             "Loop -> Point-to-Point mode");
 4216                         break;
 4217                 case ISP_CONN_BADLIP:
isp_prt(isp, ISP_LOGWARN,
 4219                             "Point-to-Point -> Loop mode (BAD LIP)");
 4220                         break;
 4221                 case ISP_CONN_FATAL:
isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
 4223 #ifdef  ISP_FW_CRASH_DUMP
isp_async(isp, ISPASYNC_FW_CRASH, NULL);
 4225 #else
isp_async(isp, ISPASYNC_FW_CRASH, NULL);
isp_reinit(isp);
isp_async(isp, ISPASYNC_FW_RESTARTED, NULL);
 4229 #endif
 4230                         return (-1);
 4231                 case ISP_CONN_LOOPBACK:
isp_prt(isp, ISP_LOGWARN,
 4233                             "Looped Back in Point-to-Point mode");
 4234                         break;
 4235                 default:
isp_prt(isp, ISP_LOGWARN,
 4237                             "Unknown connection mode (0x%x)", mbox);
 4238                         break;
 4239                 }
isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_fwstate = FW_CONFIG_WAIT;
FCPARAM(isp)->isp_loopstate = LOOP_LIP_RCVD;
 4244                 break;
 4246         default:
isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
 4248                 break;
 4249         }
 4251         if (bus & 0x100) {
 4252                 int i, nh;
u_int16_t handles[5];
 4255                 for (nh = 0, i = 1; i < MAX_MAILBOX; i++) {
 4256                         if ((bus & (1 << i)) == 0) {
 4257                                 continue;
 4258                         }
handles[nh++] = ISP_READ(isp, MBOX_OFF(i));
 4260                 }
 4261                 for (i = 0; i < nh; i++) {
isp_fastpost_complete(isp, handles[i]);
isp_prt(isp,  ISP_LOGDEBUG3,
 4264                             "fast post completion of %u", handles[i]);
 4265                 }
 4266                 if (isp->isp_fpcchiwater < nh)
isp->isp_fpcchiwater = nh;
 4268         } else {
isp->isp_intoasync++;
 4270         }
 4271         return (rval);
 4272 }
 4274 /*
 4275  * Handle other response entries. A pointer to the request queue output
 4276  * index is here in case we want to eat several entries at once, although
 4277  * this is not used currently.
 4278  */
 4280 static int
isp_handle_other_response(struct ispsoftc *isp, int type,
isphdr_t *hp, u_int16_t *optrp)
 4283 {
 4284         switch (type) {
 4285         case RQSTYPE_STATUS_CONT:
isp_prt(isp, ISP_LOGINFO, "Ignored Continuation Response");
 4287                 return (1);
 4288         case RQSTYPE_ATIO:
 4289         case RQSTYPE_CTIO:
 4290         case RQSTYPE_ENABLE_LUN:
 4291         case RQSTYPE_MODIFY_LUN:
 4292         case RQSTYPE_NOTIFY:
 4293         case RQSTYPE_NOTIFY_ACK:
 4294         case RQSTYPE_CTIO1:
 4295         case RQSTYPE_ATIO2:
 4296         case RQSTYPE_CTIO2:
 4297         case RQSTYPE_CTIO3:
isp->isp_rsltccmplt++;  /* count as a response completion */
 4299 #ifdef  ISP_TARGET_MODE
 4300                 if (isp_target_notify(isp, (ispstatusreq_t *) hp, optrp)) {
 4301                         return (1);
 4302                 }
 4303 #endif
 4304                 /* FALLTHROUGH */
 4305         case RQSTYPE_REQUEST:
 4306         default:
 4307                 if (isp_async(isp, ISPASYNC_UNHANDLED_RESPONSE, hp)) {
 4308                         return (1);
 4309                 }
isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
isp_get_response_type(isp, hp));
 4312                 return (0);
 4313         }
 4314 }
 4316 static void
isp_parse_status(struct ispsoftc *isp, ispstatusreq_t *sp, XS_T *xs)
 4318 {
 4319         switch (sp->req_completion_status & 0xff) {
 4320         case RQCS_COMPLETE:
 4321                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_NOERROR);
 4323                 }
 4324                 return;
 4326         case RQCS_INCOMPLETE:
 4327                 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
isp_prt(isp, ISP_LOGDEBUG1,
 4329                             "Selection Timeout for %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4331                         if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 4333                         }
 4334                         return;
 4335                 }
isp_prt(isp, ISP_LOGERR,
 4337                     "command incomplete for %d.%d.%d, state 0x%x",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
sp->req_state_flags);
 4340                 break;
 4342         case RQCS_DMA_ERROR:
isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4345                 break;
 4347         case RQCS_TRANSPORT_ERROR:
 4348         {
 4349                 char buf[172];
SNPRINTF(buf, sizeof (buf), "states=>");
 4351                 if (sp->req_state_flags & RQSF_GOT_BUS) {
SNPRINTF(buf, sizeof (buf), "%s GOT_BUS", buf);
 4353                 }
 4354                 if (sp->req_state_flags & RQSF_GOT_TARGET) {
SNPRINTF(buf, sizeof (buf), "%s GOT_TGT", buf);
 4356                 }
 4357                 if (sp->req_state_flags & RQSF_SENT_CDB) {
SNPRINTF(buf, sizeof (buf), "%s SENT_CDB", buf);
 4359                 }
 4360                 if (sp->req_state_flags & RQSF_XFRD_DATA) {
SNPRINTF(buf, sizeof (buf), "%s XFRD_DATA", buf);
 4362                 }
 4363                 if (sp->req_state_flags & RQSF_GOT_STATUS) {
SNPRINTF(buf, sizeof (buf), "%s GOT_STS", buf);
 4365                 }
 4366                 if (sp->req_state_flags & RQSF_GOT_SENSE) {
SNPRINTF(buf, sizeof (buf), "%s GOT_SNS", buf);
 4368                 }
 4369                 if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
SNPRINTF(buf, sizeof (buf), "%s XFR_CMPLT", buf);
 4371                 }
SNPRINTF(buf, sizeof (buf), "%s\nstatus=>", buf);
 4373                 if (sp->req_status_flags & RQSTF_DISCONNECT) {
SNPRINTF(buf, sizeof (buf), "%s Disconnect", buf);
 4375                 }
 4376                 if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
SNPRINTF(buf, sizeof (buf), "%s Sync_xfr", buf);
 4378                 }
 4379                 if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
SNPRINTF(buf, sizeof (buf), "%s Parity", buf);
 4381                 }
 4382                 if (sp->req_status_flags & RQSTF_BUS_RESET) {
SNPRINTF(buf, sizeof (buf), "%s Bus_Reset", buf);
 4384                 }
 4385                 if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
SNPRINTF(buf, sizeof (buf), "%s Device_Reset", buf);
 4387                 }
 4388                 if (sp->req_status_flags & RQSTF_ABORTED) {
SNPRINTF(buf, sizeof (buf), "%s Aborted", buf);
 4390                 }
 4391                 if (sp->req_status_flags & RQSTF_TIMEOUT) {
SNPRINTF(buf, sizeof (buf), "%s Timeout", buf);
 4393                 }
 4394                 if (sp->req_status_flags & RQSTF_NEGOTIATION) {
SNPRINTF(buf, sizeof (buf), "%s Negotiation", buf);
 4396                 }
isp_prt(isp, ISP_LOGERR, "%s", buf);
isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
 4400                 break;
 4401         }
 4402         case RQCS_RESET_OCCURRED:
isp_prt(isp, ISP_LOGWARN,
 4404                     "bus reset destroyed command for %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
 4407                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BUSRESET);
 4409                 }
 4410                 return;
 4412         case RQCS_ABORTED:
isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
 4416                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_ABORTED);
 4418                 }
 4419                 return;
 4421         case RQCS_TIMEOUT:
isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4424                 /*
 4425                  * Check to see if we logged out the device.
 4426                  */
 4427                 if (IS_FC(isp)) {
 4428                         if ((sp->req_completion_status & RQSTF_LOGOUT) &&
FCPARAM(isp)->portdb[XS_TGT(xs)].valid &&
FCPARAM(isp)->portdb[XS_TGT(xs)].fabric_dev) {
FCPARAM(isp)->portdb[XS_TGT(xs)].relogin = 1;
 4432                         }
 4433                 }
 4434                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_CMDTIMEOUT);
 4436                 }
 4437                 return;
 4439         case RQCS_DATA_OVERRUN:
XS_RESID(xs) = sp->req_resid;
isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4443                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_DATAOVR);
 4445                 }
 4446                 return;
 4448         case RQCS_COMMAND_OVERRUN:
isp_prt(isp, ISP_LOGERR,
 4450                     "command overrun for command on %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4452                 break;
 4454         case RQCS_STATUS_OVERRUN:
isp_prt(isp, ISP_LOGERR,
 4456                     "status overrun for command on %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4458                 break;
 4460         case RQCS_BAD_MESSAGE:
isp_prt(isp, ISP_LOGERR,
 4462                     "msg not COMMAND COMPLETE after status %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4464                 break;
 4466         case RQCS_NO_MESSAGE_OUT:
isp_prt(isp, ISP_LOGERR,
 4468                     "No MESSAGE OUT phase after selection on %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4470                 break;
 4472         case RQCS_EXT_ID_FAILED:
isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4475                 break;
 4477         case RQCS_IDE_MSG_FAILED:
isp_prt(isp, ISP_LOGERR,
 4479                     "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4481                 break;
 4483         case RQCS_ABORT_MSG_FAILED:
isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4486                 break;
 4488         case RQCS_REJECT_MSG_FAILED:
isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4491                 break;
 4493         case RQCS_NOP_MSG_FAILED:
isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4496                 break;
 4498         case RQCS_PARITY_ERROR_MSG_FAILED:
isp_prt(isp, ISP_LOGERR,
 4500                     "MESSAGE PARITY ERROR rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4502                 break;
 4504         case RQCS_DEVICE_RESET_MSG_FAILED:
isp_prt(isp, ISP_LOGWARN,
 4506                     "BUS DEVICE RESET rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4508                 break;
 4510         case RQCS_ID_MSG_FAILED:
isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4513                 break;
 4515         case RQCS_UNEXP_BUS_FREE:
isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4518                 break;
 4520         case RQCS_DATA_UNDERRUN:
 4521         {
 4522                 if (IS_FC(isp)) {
 4523                         int ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
 4524                         if (!ru_marked || sp->req_resid > XS_XFRLEN(xs)) {
isp_prt(isp, ISP_LOGWARN, bun, XS_TGT(xs),
XS_LUN(xs), XS_XFRLEN(xs), sp->req_resid,
 4527                                     (ru_marked)? "marked" : "not marked");
 4528                                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BOTCH);
 4530                                 }
 4531                                 return;
 4532                         }
 4533                 }
XS_RESID(xs) = sp->req_resid;
 4535                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_NOERROR);
 4537                 }
 4538                 return;
 4539         }
 4541         case RQCS_XACT_ERR1:
isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
XS_TGT(xs), XS_LUN(xs));
 4544                 break;
 4546         case RQCS_XACT_ERR2:
isp_prt(isp, ISP_LOGERR, xact2,
XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
 4549                 break;
 4551         case RQCS_XACT_ERR3:
isp_prt(isp, ISP_LOGERR, xact3,
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4554                 break;
 4556         case RQCS_BAD_ENTRY:
isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
 4558                 break;
 4560         case RQCS_QUEUE_FULL:
isp_prt(isp, ISP_LOGDEBUG0,
 4562                     "internal queues full for %d.%d.%d status 0x%x",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), *XS_STSP(xs));
 4565                 /*
 4566                  * If QFULL or some other status byte is set, then this
 4567                  * isn't an error, per se.
 4568                  *
 4569                  * Unfortunately, some QLogic f/w writers have, in
 4570                  * some cases, ommitted to *set* status to QFULL.
 4571                  *
 4572 
 4573                 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
 4574                         XS_SETERR(xs, HBA_NOERROR);
 4575                         return;
 4576                 }
 4577 
 4578                  *
 4579                  *
 4580                  */
 4582                 *XS_STSP(xs) = SCSI_QFULL;
XS_SETERR(xs, HBA_NOERROR);
 4584                 return;
 4586         case RQCS_PHASE_SKIPPED:
isp_prt(isp, ISP_LOGERR, pskip, XS_CHANNEL(xs),
XS_TGT(xs), XS_LUN(xs));
 4589                 break;
 4591         case RQCS_ARQS_FAILED:
isp_prt(isp, ISP_LOGERR,
 4593                     "Auto Request Sense failed for %d.%d.%d",
XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
 4595                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_ARQFAIL);
 4597                 }
 4598                 return;
 4600         case RQCS_WIDE_FAILED:
isp_prt(isp, ISP_LOGERR,
 4602                     "Wide Negotiation failed for %d.%d.%d",
XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
 4604                 if (IS_SCSI(isp)) {
sdparam *sdp = isp->isp_param;
sdp += XS_CHANNEL(xs);
sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_WIDE;
sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
isp->isp_update |= (1 << XS_CHANNEL(xs));
 4610                 }
 4611                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_NOERROR);
 4613                 }
 4614                 return;
 4616         case RQCS_SYNCXFER_FAILED:
isp_prt(isp, ISP_LOGERR,
 4618                     "SDTR Message failed for target %d.%d.%d",
XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
 4620                 if (IS_SCSI(isp)) {
sdparam *sdp = isp->isp_param;
sdp += XS_CHANNEL(xs);
sdp->isp_devparam[XS_TGT(xs)].goal_flags &= ~DPARM_SYNC;
sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
isp->isp_update |= (1 << XS_CHANNEL(xs));
 4626                 }
 4627                 break;
 4629         case RQCS_LVD_BUSERR:
isp_prt(isp, ISP_LOGERR,
 4631                     "Bad LVD condition while talking to %d.%d.%d",
XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
 4633                 break;
 4635         case RQCS_PORT_UNAVAILABLE:
 4636                 /*
 4637                  * No such port on the loop. Moral equivalent of SELTIMEO
 4638                  */
 4639         case RQCS_PORT_LOGGED_OUT:
 4640                 /*
 4641                  * It was there (maybe)- treat as a selection timeout.
 4642                  */
 4643                 if ((sp->req_completion_status & 0xff) == RQCS_PORT_UNAVAILABLE)
isp_prt(isp, ISP_LOGINFO,
 4645                             "port unavailable for target %d", XS_TGT(xs));
 4646                 else
isp_prt(isp, ISP_LOGINFO,
 4648                             "port logout for target %d", XS_TGT(xs));
 4649                 /*
 4650                  * If we're on a local loop, force a LIP (which is overkill)
 4651                  * to force a re-login of this unit. If we're on fabric,
 4652                  * then we'll have to relogin as a matter of course.
 4653                  */
 4654                 if (FCPARAM(isp)->isp_topo == TOPO_NL_PORT ||
FCPARAM(isp)->isp_topo == TOPO_FL_PORT) {
mbreg_t mbs;
mbs.param[0] = MBOX_INIT_LIP;
isp_mboxcmd_qnw(isp, &mbs, 1);
 4659                 }
 4661                 /*
 4662                  * Probably overkill.
 4663                  */
isp->isp_sendmarker = 1;
FCPARAM(isp)->isp_loopstate = LOOP_PDB_RCVD;
isp_mark_getpdb_all(isp);
isp_async(isp, ISPASYNC_CHANGE_NOTIFY, ISPASYNC_CHANGE_OTHER);
 4668                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 4670                 }
 4671                 return;
 4673         case RQCS_PORT_CHANGED:
isp_prt(isp, ISP_LOGWARN,
 4675                     "port changed for target %d", XS_TGT(xs));
 4676                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_SELTIMEOUT);
 4678                 }
 4679                 return;
 4681         case RQCS_PORT_BUSY:
isp_prt(isp, ISP_LOGWARN,
 4683                     "port busy for target %d", XS_TGT(xs));
 4684                 if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_TGTBSY);
 4686                 }
 4687                 return;
 4689         default:
isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
sp->req_completion_status);
 4692                 break;
 4693         }
 4694         if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BOTCH);
 4696         }
 4697 }
 4699 static void
isp_fastpost_complete(struct ispsoftc *isp, u_int16_t fph)
 4701 {
XS_T *xs;
 4704         if (fph == 0) {
 4705                 return;
 4706         }
xs = isp_find_xs(isp, fph);
 4708         if (xs == NULL) {
isp_prt(isp, ISP_LOGWARN,
 4710                     "Command for fast post handle 0x%x not found", fph);
 4711                 return;
 4712         }
isp_destroy_handle(isp, fph);
 4715         /*
 4716          * Since we don't have a result queue entry item,
 4717          * we must believe that SCSI status is zero and
 4718          * that all data transferred.
 4719          */
XS_SET_STATE_STAT(isp, xs, NULL);
XS_RESID(xs) = 0;
 4722         *XS_STSP(xs) = SCSI_GOOD;
 4723         if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, fph);
 4725         }
 4726         if (isp->isp_nactive)
isp->isp_nactive--;
isp->isp_fphccmplt++;
isp_done(xs);
 4730 }
 4732 static int
isp_mbox_continue(struct ispsoftc *isp)
 4734 {
mbreg_t mbs;
u_int16_t *ptr;
 4738         switch (isp->isp_lastmbxcmd) {
 4739         case MBOX_WRITE_RAM_WORD:
 4740         case MBOX_READ_RAM_WORD:
 4741         case MBOX_READ_RAM_WORD_EXTENDED:
 4742                 break;
 4743         default:
 4744                 return (1);
 4745         }
 4746         if (isp->isp_mboxtmp[0] != MBOX_COMMAND_COMPLETE) {
isp->isp_mbxwrk0 = 0;
 4748                 return (-1);
 4749         }
 4752         /*
 4753          * Clear the previous interrupt.
 4754          */
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
ISP_WRITE(isp, BIU_SEMA, 0);
 4758         /*
 4759          * Continue with next word.
 4760          */
ptr = isp->isp_mbxworkp;
 4762         switch (isp->isp_lastmbxcmd) {
 4763         case MBOX_WRITE_RAM_WORD:
mbs.param[2] = *ptr++;
mbs.param[1] = isp->isp_mbxwrk1++;
 4766                 break;
 4767         case MBOX_READ_RAM_WORD:
 4768         case MBOX_READ_RAM_WORD_EXTENDED:
 4769                 *ptr++ = isp->isp_mboxtmp[2];
mbs.param[1] = isp->isp_mbxwrk1++;
 4771                 break;
 4772         }
isp->isp_mbxworkp = ptr;
mbs.param[0] = isp->isp_lastmbxcmd;
isp->isp_mbxwrk0 -= 1;
isp_mboxcmd_qnw(isp, &mbs, 0);
 4777         return (0);
 4778 }
 4781 #define HIBYT(x)                        ((x) >> 0x8)
 4782 #define LOBYT(x)                        ((x)  & 0xff)
 4783 #define ISPOPMAP(a, b)                  (((a) << 8) | (b))
 4784 static const u_int16_t mbpscsi[] = {
ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
ISPOPMAP(0x03, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
ISPOPMAP(0x1f, 0x01),   /* 0x03: MBOX_DUMP_RAM */
ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
ISPOPMAP(0x3f, 0x3f),   /* 0x06: MBOX_MAILBOX_REG_TEST */
ISPOPMAP(0x03, 0x07),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
ISPOPMAP(0x01, 0x0f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
ISPOPMAP(0x00, 0x00),   /* 0x09: */
ISPOPMAP(0x00, 0x00),   /* 0x0a: */
ISPOPMAP(0x00, 0x00),   /* 0x0b: */
ISPOPMAP(0x00, 0x00),   /* 0x0c: */
ISPOPMAP(0x00, 0x00),   /* 0x0d: */
ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
ISPOPMAP(0x00, 0x00),   /* 0x0f: */
ISPOPMAP(0x1f, 0x1f),   /* 0x10: MBOX_INIT_REQ_QUEUE */
ISPOPMAP(0x3f, 0x3f),   /* 0x11: MBOX_INIT_RES_QUEUE */
ISPOPMAP(0x0f, 0x0f),   /* 0x12: MBOX_EXECUTE_IOCB */
ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
ISPOPMAP(0x01, 0x3f),   /* 0x14: MBOX_STOP_FIRMWARE */
ISPOPMAP(0x0f, 0x0f),   /* 0x15: MBOX_ABORT */
ISPOPMAP(0x03, 0x03),   /* 0x16: MBOX_ABORT_DEVICE */
ISPOPMAP(0x07, 0x07),   /* 0x17: MBOX_ABORT_TARGET */
ISPOPMAP(0x07, 0x07),   /* 0x18: MBOX_BUS_RESET */
ISPOPMAP(0x03, 0x07),   /* 0x19: MBOX_STOP_QUEUE */
ISPOPMAP(0x03, 0x07),   /* 0x1a: MBOX_START_QUEUE */
ISPOPMAP(0x03, 0x07),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
ISPOPMAP(0x03, 0x07),   /* 0x1c: MBOX_ABORT_QUEUE */
ISPOPMAP(0x03, 0x4f),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
ISPOPMAP(0x00, 0x00),   /* 0x1e: */
ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
ISPOPMAP(0x01, 0x07),   /* 0x20: MBOX_GET_INIT_SCSI_ID */
ISPOPMAP(0x01, 0x07),   /* 0x21: MBOX_GET_SELECT_TIMEOUT */
ISPOPMAP(0x01, 0xc7),   /* 0x22: MBOX_GET_RETRY_COUNT   */
ISPOPMAP(0x01, 0x07),   /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
ISPOPMAP(0x01, 0x03),   /* 0x24: MBOX_GET_CLOCK_RATE */
ISPOPMAP(0x01, 0x07),   /* 0x25: MBOX_GET_ACT_NEG_STATE */
ISPOPMAP(0x01, 0x07),   /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
ISPOPMAP(0x01, 0x07),   /* 0x27: MBOX_GET_PCI_PARAMS */
ISPOPMAP(0x03, 0x4f),   /* 0x28: MBOX_GET_TARGET_PARAMS */
ISPOPMAP(0x03, 0x0f),   /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
ISPOPMAP(0x01, 0x07),   /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */
ISPOPMAP(0x00, 0x00),   /* 0x2b: */
ISPOPMAP(0x00, 0x00),   /* 0x2c: */
ISPOPMAP(0x00, 0x00),   /* 0x2d: */
ISPOPMAP(0x00, 0x00),   /* 0x2e: */
ISPOPMAP(0x00, 0x00),   /* 0x2f: */
ISPOPMAP(0x03, 0x03),   /* 0x30: MBOX_SET_INIT_SCSI_ID */
ISPOPMAP(0x07, 0x07),   /* 0x31: MBOX_SET_SELECT_TIMEOUT */
ISPOPMAP(0xc7, 0xc7),   /* 0x32: MBOX_SET_RETRY_COUNT   */
ISPOPMAP(0x07, 0x07),   /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
ISPOPMAP(0x03, 0x03),   /* 0x34: MBOX_SET_CLOCK_RATE */
ISPOPMAP(0x07, 0x07),   /* 0x35: MBOX_SET_ACT_NEG_STATE */
ISPOPMAP(0x07, 0x07),   /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
ISPOPMAP(0x07, 0x07),   /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
ISPOPMAP(0x4f, 0x4f),   /* 0x38: MBOX_SET_TARGET_PARAMS */
ISPOPMAP(0x0f, 0x0f),   /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
ISPOPMAP(0x07, 0x07),   /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */
ISPOPMAP(0x00, 0x00),   /* 0x3b: */
ISPOPMAP(0x00, 0x00),   /* 0x3c: */
ISPOPMAP(0x00, 0x00),   /* 0x3d: */
ISPOPMAP(0x00, 0x00),   /* 0x3e: */
ISPOPMAP(0x00, 0x00),   /* 0x3f: */
ISPOPMAP(0x01, 0x03),   /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
ISPOPMAP(0x3f, 0x01),   /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_EXEC_BIOS_IOCB */
ISPOPMAP(0x00, 0x00),   /* 0x43: */
ISPOPMAP(0x00, 0x00),   /* 0x44: */
ISPOPMAP(0x03, 0x03),   /* 0x45: SET SYSTEM PARAMETER */
ISPOPMAP(0x01, 0x03),   /* 0x46: GET SYSTEM PARAMETER */
ISPOPMAP(0x00, 0x00),   /* 0x47: */
ISPOPMAP(0x01, 0xcf),   /* 0x48: GET SCAM CONFIGURATION */
ISPOPMAP(0xcf, 0xcf),   /* 0x49: SET SCAM CONFIGURATION */
ISPOPMAP(0x03, 0x03),   /* 0x4a: MBOX_SET_FIRMWARE_FEATURES */
ISPOPMAP(0x01, 0x03),   /* 0x4b: MBOX_GET_FIRMWARE_FEATURES */
ISPOPMAP(0x00, 0x00),   /* 0x4c: */
ISPOPMAP(0x00, 0x00),   /* 0x4d: */
ISPOPMAP(0x00, 0x00),   /* 0x4e: */
ISPOPMAP(0x00, 0x00),   /* 0x4f: */
ISPOPMAP(0xdf, 0xdf),   /* 0x50: LOAD RAM A64 */
ISPOPMAP(0xdf, 0xdf),   /* 0x51: DUMP RAM A64 */
ISPOPMAP(0xdf, 0xff),   /* 0x52: INITIALIZE REQUEST QUEUE A64 */
ISPOPMAP(0xef, 0xff),   /* 0x53: INITIALIZE RESPONSE QUEUE A64 */
ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUTE IOCB A64 */
ISPOPMAP(0x07, 0x01),   /* 0x55: ENABLE TARGET MODE */
ISPOPMAP(0x03, 0x0f),   /* 0x56: GET TARGET STATUS */
ISPOPMAP(0x00, 0x00),   /* 0x57: */
ISPOPMAP(0x00, 0x00),   /* 0x58: */
ISPOPMAP(0x00, 0x00),   /* 0x59: */
ISPOPMAP(0x03, 0x03),   /* 0x5a: SET DATA OVERRUN RECOVERY MODE */
ISPOPMAP(0x01, 0x03),   /* 0x5b: GET DATA OVERRUN RECOVERY MODE */
ISPOPMAP(0x0f, 0x0f),   /* 0x5c: SET HOST DATA */
ISPOPMAP(0x01, 0x01)    /* 0x5d: GET NOST DATA */
 4879 };
 4881 #ifdef SMALL_KERNEL
 4882 #define ISP_STRIPPED
 4883 #endif
 4885 #ifndef ISP_STRIPPED
 4886 static char *scsi_mbcmd_names[] = {
 4887         "NO-OP",
 4888         "LOAD RAM",
 4889         "EXEC FIRMWARE",
 4890         "DUMP RAM",
 4891         "WRITE RAM WORD",
 4892         "READ RAM WORD",
 4893         "MAILBOX REG TEST",
 4894         "VERIFY CHECKSUM",
 4895         "ABOUT FIRMWARE",
NULL,
NULL,
NULL,
NULL,
NULL,
 4901         "CHECK FIRMWARE",
NULL,
 4903         "INIT REQUEST QUEUE",
 4904         "INIT RESULT QUEUE",
 4905         "EXECUTE IOCB",
 4906         "WAKE UP",
 4907         "STOP FIRMWARE",
 4908         "ABORT",
 4909         "ABORT DEVICE",
 4910         "ABORT TARGET",
 4911         "BUS RESET",
 4912         "STOP QUEUE",
 4913         "START QUEUE",
 4914         "SINGLE STEP QUEUE",
 4915         "ABORT QUEUE",
 4916         "GET DEV QUEUE STATUS",
NULL,
 4918         "GET FIRMWARE STATUS",
 4919         "GET INIT SCSI ID",
 4920         "GET SELECT TIMEOUT",
 4921         "GET RETRY COUNT",
 4922         "GET TAG AGE LIMIT",
 4923         "GET CLOCK RATE",
 4924         "GET ACT NEG STATE",
 4925         "GET ASYNC DATA SETUP TIME",
 4926         "GET PCI PARAMS",
 4927         "GET TARGET PARAMS",
 4928         "GET DEV QUEUE PARAMS",
 4929         "GET RESET DELAY PARAMS",
NULL,
NULL,
NULL,
NULL,
NULL,
 4935         "SET INIT SCSI ID",
 4936         "SET SELECT TIMEOUT",
 4937         "SET RETRY COUNT",
 4938         "SET TAG AGE LIMIT",
 4939         "SET CLOCK RATE",
 4940         "SET ACT NEG STATE",
 4941         "SET ASYNC DATA SETUP TIME",
 4942         "SET PCI CONTROL PARAMS",
 4943         "SET TARGET PARAMS",
 4944         "SET DEV QUEUE PARAMS",
 4945         "SET RESET DELAY PARAMS",
NULL,
NULL,
NULL,
NULL,
NULL,
 4951         "RETURN BIOS BLOCK ADDR",
 4952         "WRITE FOUR RAM WORDS",
 4953         "EXEC BIOS IOCB",
NULL,
NULL,
 4956         "SET SYSTEM PARAMETER",
 4957         "GET SYSTEM PARAMETER",
NULL,
 4959         "GET SCAM CONFIGURATION",
 4960         "SET SCAM CONFIGURATION",
 4961         "SET FIRMWARE FEATURES",
 4962         "GET FIRMWARE FEATURES",
NULL,
NULL,
NULL,
NULL,
 4967         "LOAD RAM A64",
 4968         "DUMP RAM A64",
 4969         "INITIALIZE REQUEST QUEUE A64",
 4970         "INITIALIZE RESPONSE QUEUE A64",
 4971         "EXECUTE IOCB A64",
 4972         "ENABLE TARGET MODE",
 4973         "GET TARGET MODE STATE",
NULL,
NULL,
NULL,
 4977         "SET DATA OVERRUN RECOVERY MODE",
 4978         "GET DATA OVERRUN RECOVERY MODE",
 4979         "SET HOST DATA",
 4980         "GET NOST DATA",
 4981 };
 4982 #endif
 4984 static const u_int16_t mbpfc[] = {
ISPOPMAP(0x01, 0x01),   /* 0x00: MBOX_NO_OP */
ISPOPMAP(0x1f, 0x01),   /* 0x01: MBOX_LOAD_RAM */
ISPOPMAP(0x03, 0x01),   /* 0x02: MBOX_EXEC_FIRMWARE */
ISPOPMAP(0xdf, 0x01),   /* 0x03: MBOX_DUMP_RAM */
ISPOPMAP(0x07, 0x07),   /* 0x04: MBOX_WRITE_RAM_WORD */
ISPOPMAP(0x03, 0x07),   /* 0x05: MBOX_READ_RAM_WORD */
ISPOPMAP(0xff, 0xff),   /* 0x06: MBOX_MAILBOX_REG_TEST */
ISPOPMAP(0x03, 0x05),   /* 0x07: MBOX_VERIFY_CHECKSUM   */
ISPOPMAP(0x01, 0x4f),   /* 0x08: MBOX_ABOUT_FIRMWARE */
ISPOPMAP(0xdf, 0x01),   /* 0x09: LOAD RAM */
ISPOPMAP(0xdf, 0x01),   /* 0x0a: DUMP RAM */
ISPOPMAP(0x00, 0x00),   /* 0x0b: */
ISPOPMAP(0x00, 0x00),   /* 0x0c: */
ISPOPMAP(0x00, 0x00),   /* 0x0d: */
ISPOPMAP(0x01, 0x05),   /* 0x0e: MBOX_CHECK_FIRMWARE */
ISPOPMAP(0x03, 0x07),   /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED(1) */
ISPOPMAP(0x1f, 0x11),   /* 0x10: MBOX_INIT_REQ_QUEUE */
ISPOPMAP(0x2f, 0x21),   /* 0x11: MBOX_INIT_RES_QUEUE */
ISPOPMAP(0x0f, 0x01),   /* 0x12: MBOX_EXECUTE_IOCB */
ISPOPMAP(0x03, 0x03),   /* 0x13: MBOX_WAKE_UP   */
ISPOPMAP(0x01, 0xff),   /* 0x14: MBOX_STOP_FIRMWARE */
ISPOPMAP(0x4f, 0x01),   /* 0x15: MBOX_ABORT */
ISPOPMAP(0x07, 0x01),   /* 0x16: MBOX_ABORT_DEVICE */
ISPOPMAP(0x07, 0x01),   /* 0x17: MBOX_ABORT_TARGET */
ISPOPMAP(0x03, 0x03),   /* 0x18: MBOX_BUS_RESET */
ISPOPMAP(0x07, 0x05),   /* 0x19: MBOX_STOP_QUEUE */
ISPOPMAP(0x07, 0x05),   /* 0x1a: MBOX_START_QUEUE */
ISPOPMAP(0x07, 0x05),   /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
ISPOPMAP(0x07, 0x05),   /* 0x1c: MBOX_ABORT_QUEUE */
ISPOPMAP(0x07, 0x03),   /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
ISPOPMAP(0x00, 0x00),   /* 0x1e: */
ISPOPMAP(0x01, 0x07),   /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
ISPOPMAP(0x01, 0x4f),   /* 0x20: MBOX_GET_LOOP_ID */
ISPOPMAP(0x00, 0x00),   /* 0x21: */
ISPOPMAP(0x01, 0x07),   /* 0x22: MBOX_GET_RETRY_COUNT   */
ISPOPMAP(0x00, 0x00),   /* 0x23: */
ISPOPMAP(0x00, 0x00),   /* 0x24: */
ISPOPMAP(0x00, 0x00),   /* 0x25: */
ISPOPMAP(0x00, 0x00),   /* 0x26: */
ISPOPMAP(0x00, 0x00),   /* 0x27: */
ISPOPMAP(0x01, 0x03),   /* 0x28: MBOX_GET_FIRMWARE_OPTIONS */
ISPOPMAP(0x03, 0x07),   /* 0x29: MBOX_GET_PORT_QUEUE_PARAMS */
ISPOPMAP(0x00, 0x00),   /* 0x2a: */
ISPOPMAP(0x00, 0x00),   /* 0x2b: */
ISPOPMAP(0x00, 0x00),   /* 0x2c: */
ISPOPMAP(0x00, 0x00),   /* 0x2d: */
ISPOPMAP(0x00, 0x00),   /* 0x2e: */
ISPOPMAP(0x00, 0x00),   /* 0x2f: */
ISPOPMAP(0x00, 0x00),   /* 0x30: */
ISPOPMAP(0x00, 0x00),   /* 0x31: */
ISPOPMAP(0x07, 0x07),   /* 0x32: MBOX_SET_RETRY_COUNT   */
ISPOPMAP(0x00, 0x00),   /* 0x33: */
ISPOPMAP(0x00, 0x00),   /* 0x34: */
ISPOPMAP(0x00, 0x00),   /* 0x35: */
ISPOPMAP(0x00, 0x00),   /* 0x36: */
ISPOPMAP(0x00, 0x00),   /* 0x37: */
ISPOPMAP(0x0f, 0x01),   /* 0x38: MBOX_SET_FIRMWARE_OPTIONS */
ISPOPMAP(0x0f, 0x07),   /* 0x39: MBOX_SET_PORT_QUEUE_PARAMS */
ISPOPMAP(0x00, 0x00),   /* 0x3a: */
ISPOPMAP(0x00, 0x00),   /* 0x3b: */
ISPOPMAP(0x00, 0x00),   /* 0x3c: */
ISPOPMAP(0x00, 0x00),   /* 0x3d: */
ISPOPMAP(0x00, 0x00),   /* 0x3e: */
ISPOPMAP(0x00, 0x00),   /* 0x3f: */
ISPOPMAP(0x03, 0x01),   /* 0x40: MBOX_LOOP_PORT_BYPASS */
ISPOPMAP(0x03, 0x01),   /* 0x41: MBOX_LOOP_PORT_ENABLE */
ISPOPMAP(0x03, 0x07),   /* 0x42: MBOX_GET_RESOURCE_COUNTS */
ISPOPMAP(0x01, 0x01),   /* 0x43: MBOX_REQUEST_NON_PARTICIPATING_MODE */
ISPOPMAP(0x00, 0x00),   /* 0x44: */
ISPOPMAP(0x00, 0x00),   /* 0x45: */
ISPOPMAP(0x00, 0x00),   /* 0x46: */
ISPOPMAP(0xcf, 0x03),   /* 0x47: GET PORT_DATABASE ENHANCED */
ISPOPMAP(0x00, 0x00),   /* 0x48: */
ISPOPMAP(0x00, 0x00),   /* 0x49: */
ISPOPMAP(0x00, 0x00),   /* 0x4a: */
ISPOPMAP(0x00, 0x00),   /* 0x4b: */
ISPOPMAP(0x00, 0x00),   /* 0x4c: */
ISPOPMAP(0x00, 0x00),   /* 0x4d: */
ISPOPMAP(0x00, 0x00),   /* 0x4e: */
ISPOPMAP(0x00, 0x00),   /* 0x4f: */
ISPOPMAP(0x00, 0x00),   /* 0x50: */
ISPOPMAP(0x00, 0x00),   /* 0x51: */
ISPOPMAP(0x00, 0x00),   /* 0x52: */
ISPOPMAP(0x00, 0x00),   /* 0x53: */
ISPOPMAP(0xcf, 0x01),   /* 0x54: EXECUTE IOCB A64 */
ISPOPMAP(0x00, 0x00),   /* 0x55: */
ISPOPMAP(0x00, 0x00),   /* 0x56: */
ISPOPMAP(0x00, 0x00),   /* 0x57: */
ISPOPMAP(0x00, 0x00),   /* 0x58: */
ISPOPMAP(0x00, 0x00),   /* 0x59: */
ISPOPMAP(0x00, 0x00),   /* 0x5a: */
ISPOPMAP(0x03, 0x01),   /* 0x5b: MBOX_DRIVER_HEARTBEAT */
ISPOPMAP(0xcf, 0x01),   /* 0x5c: MBOX_FW_HEARTBEAT */
ISPOPMAP(0x07, 0x03),   /* 0x5d: MBOX_GET_SET_DATA_RATE */
ISPOPMAP(0x00, 0x00),   /* 0x5e: */
ISPOPMAP(0x00, 0x00),   /* 0x5f: */
ISPOPMAP(0xfd, 0x31),   /* 0x60: MBOX_INIT_FIRMWARE */
ISPOPMAP(0x00, 0x00),   /* 0x61: */
ISPOPMAP(0x01, 0x01),   /* 0x62: MBOX_INIT_LIP */
ISPOPMAP(0xcd, 0x03),   /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
ISPOPMAP(0xcf, 0x01),   /* 0x64: MBOX_GET_PORT_DB */
ISPOPMAP(0x07, 0x01),   /* 0x65: MBOX_CLEAR_ACA */
ISPOPMAP(0x07, 0x01),   /* 0x66: MBOX_TARGET_RESET */
ISPOPMAP(0x07, 0x01),   /* 0x67: MBOX_CLEAR_TASK_SET */
ISPOPMAP(0x07, 0x01),   /* 0x68: MBOX_ABORT_TASK_SET */
ISPOPMAP(0x01, 0x07),   /* 0x69: MBOX_GET_FW_STATE */
ISPOPMAP(0x03, 0xcf),   /* 0x6a: MBOX_GET_PORT_NAME */
ISPOPMAP(0xcf, 0x01),   /* 0x6b: MBOX_GET_LINK_STATUS */
ISPOPMAP(0x0f, 0x01),   /* 0x6c: MBOX_INIT_LIP_RESET */
ISPOPMAP(0x00, 0x00),   /* 0x6d: */
ISPOPMAP(0xcf, 0x03),   /* 0x6e: MBOX_SEND_SNS */
ISPOPMAP(0x0f, 0x07),   /* 0x6f: MBOX_FABRIC_LOGIN */
ISPOPMAP(0x03, 0x01),   /* 0x70: MBOX_SEND_CHANGE_REQUEST */
ISPOPMAP(0x03, 0x03),   /* 0x71: MBOX_FABRIC_LOGOUT */
ISPOPMAP(0x0f, 0x0f),   /* 0x72: MBOX_INIT_LIP_LOGIN */
ISPOPMAP(0x00, 0x00),   /* 0x73: */
ISPOPMAP(0x07, 0x01),   /* 0x74: LOGIN LOOP PORT */
ISPOPMAP(0xcf, 0x03),   /* 0x75: GET PORT/NODE NAME LIST */
ISPOPMAP(0x4f, 0x01),   /* 0x76: SET VENDOR ID */
ISPOPMAP(0xcd, 0x01),   /* 0x77: INITIALIZE IP MAILBOX */
ISPOPMAP(0x00, 0x00),   /* 0x78: */
ISPOPMAP(0x00, 0x00),   /* 0x79: */
ISPOPMAP(0x00, 0x00),   /* 0x7a: */
ISPOPMAP(0x00, 0x00),   /* 0x7b: */
ISPOPMAP(0x4f, 0x03),   /* 0x7c: Get ID List */
ISPOPMAP(0xcf, 0x01),   /* 0x7d: SEND LFA */
ISPOPMAP(0x07, 0x01)    /* 0x7e: Lun RESET */
 5112 };
 5113 /*
 5114  * Footnotes
 5115  *
 5116  * (1): this sets bits 21..16 in mailbox register #8, which we nominally 
 5117  *      do not access at this time in the core driver. The caller is
 5118  *      responsible for setting this register first (Gross!).
 5119  */
 5121 #ifndef ISP_STRIPPED
 5122 static char *fc_mbcmd_names[] = {
 5123         "NO-OP",
 5124         "LOAD RAM",
 5125         "EXEC FIRMWARE",
 5126         "DUMP RAM",
 5127         "WRITE RAM WORD",
 5128         "READ RAM WORD",
 5129         "MAILBOX REG TEST",
 5130         "VERIFY CHECKSUM",
 5131         "ABOUT FIRMWARE",
 5132         "LOAD RAM",
 5133         "DUMP RAM",
NULL,
NULL,
 5136         "READ RAM WORD EXTENDED",
 5137         "CHECK FIRMWARE",
NULL,
 5139         "INIT REQUEST QUEUE",
 5140         "INIT RESULT QUEUE",
 5141         "EXECUTE IOCB",
 5142         "WAKE UP",
 5143         "STOP FIRMWARE",
 5144         "ABORT",
 5145         "ABORT DEVICE",
 5146         "ABORT TARGET",
 5147         "BUS RESET",
 5148         "STOP QUEUE",
 5149         "START QUEUE",
 5150         "SINGLE STEP QUEUE",
 5151         "ABORT QUEUE",
 5152         "GET DEV QUEUE STATUS",
NULL,
 5154         "GET FIRMWARE STATUS",
 5155         "GET LOOP ID",
NULL,
 5157         "GET RETRY COUNT",
NULL,
NULL,
NULL,
NULL,
NULL,
 5163         "GET FIRMWARE OPTIONS",
 5164         "GET PORT QUEUE PARAMS",
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
 5173         "SET RETRY COUNT",
NULL,
NULL,
NULL,
NULL,
NULL,
 5179         "SET FIRMWARE OPTIONS",
 5180         "SET PORT QUEUE PARAMS",
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
 5187         "LOOP PORT BYPASS",
 5188         "LOOP PORT ENABLE",
 5189         "GET RESOURCE COUNTS",
 5190         "REQUEST NON PARTICIPATING MODE",
NULL,
NULL,
NULL,
 5194         "GET PORT DATABASE,, ENHANCED",
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
 5207         "EXECUTE IOCB A64",
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
 5214         "DRIVER HEARTBEAT",
NULL,
 5216         "GET/SET DATA RATE",
NULL,
NULL,
 5219         "INIT FIRMWARE",
NULL,
 5221         "INIT LIP",
 5222         "GET FC-AL POSITION MAP",
 5223         "GET PORT DATABASE",
 5224         "CLEAR ACA",
 5225         "TARGET RESET",
 5226         "CLEAR TASK SET",
 5227         "ABORT TASK SET",
 5228         "GET FW STATE",
 5229         "GET PORT NAME",
 5230         "GET LINK STATUS",
 5231         "INIT LIP RESET",
NULL,
 5233         "SEND SNS",
 5234         "FABRIC LOGIN",
 5235         "SEND CHANGE REQUEST",
 5236         "FABRIC LOGOUT",
 5237         "INIT LIP LOGIN",
NULL,
 5239         "LOGIN LOOP PORT",
 5240         "GET PORT/NODE NAME LIST",
 5241         "SET VENDOR ID",
 5242         "INITIALIZE IP MAILBOX",
NULL,
NULL,
NULL,
NULL,
 5247         "Get ID List",
 5248         "SEND LFA",
 5249         "Lun RESET"
 5250 };
 5251 #endif
 5253 static void
isp_mboxcmd_qnw(struct ispsoftc *isp, mbreg_t *mbp, int nodelay)
 5255 {
 5256         unsigned int lim, ibits, obits, box, opcode;
 5257         const u_int16_t *mcp;
 5259         if (IS_FC(isp)) {
mcp = mbpfc;
lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
 5262         } else {
mcp = mbpscsi;
lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
 5265         }
opcode = mbp->param[0];
ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
 5269         for (box = 0; box < MAX_MAILBOX; box++) {
 5270                 if (ibits & (1 << box)) {
ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
 5272                 }
 5273                 if (nodelay == 0) {
isp->isp_mboxtmp[box] = mbp->param[box] = 0;
 5275                 }
 5276         }
 5277         if (nodelay == 0) {
isp->isp_lastmbxcmd = opcode;
isp->isp_obits = obits;
isp->isp_mboxbsy = 1;
 5281         }
ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
 5283         /*
 5284          * Oddly enough, if we're not delaying for an answer,
 5285          * delay a bit to give the f/w a chance to pick up the
 5286          * command.
 5287          */
 5288         if (nodelay) {
USEC_DELAY(1000);
 5290         }
 5291 }
 5293 static void
isp_mboxcmd(struct ispsoftc *isp, mbreg_t *mbp, int logmask)
 5295 {
 5296         char *cname, *xname, tname[16], mname[16];
 5297         unsigned int lim, ibits, obits, box, opcode;
 5298         const u_int16_t *mcp;
 5300         if (IS_FC(isp)) {
mcp = mbpfc;
lim = (sizeof (mbpfc) / sizeof (mbpfc[0]));
 5303         } else {
mcp = mbpscsi;
lim = (sizeof (mbpscsi) / sizeof (mbpscsi[0]));
 5306         }
 5308         if ((opcode = mbp->param[0]) >= lim) {
mbp->param[0] = MBOX_INVALID_COMMAND;
isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
 5311                 return;
 5312         }
ibits = HIBYT(mcp[opcode]) & NMBOX_BMASK(isp);
obits = LOBYT(mcp[opcode]) & NMBOX_BMASK(isp);
 5317         if (ibits == 0 && obits == 0) {
mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
 5320                 return;
 5321         }
 5323         /*
 5324          * Get exclusive usage of mailbox registers.
 5325          */
MBOX_ACQUIRE(isp);
 5328         for (box = 0; box < MAX_MAILBOX; box++) {
 5329                 if (ibits & (1 << box)) {
ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
 5331                 }
isp->isp_mboxtmp[box] = mbp->param[box] = 0;
 5333         }
isp->isp_lastmbxcmd = opcode;
 5337         /*
 5338          * We assume that we can't overwrite a previous command.
 5339          */
isp->isp_obits = obits;
isp->isp_mboxbsy = 1;
 5343         /*
 5344          * Set Host Interrupt condition so that RISC will pick up mailbox regs.
 5345          */
ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
 5348         /*
 5349          * While we haven't finished the command, spin our wheels here.
 5350          */
MBOX_WAIT_COMPLETE(isp);
 5353         if (isp->isp_mboxbsy) {
 5354                 /*
 5355                  * Command timed out.
 5356                  */
isp->isp_mboxbsy = 0;
MBOX_RELEASE(isp);
 5359                 return;
 5360         }
 5362         /*
 5363          * Copy back output registers.
 5364          */
 5365         for (box = 0; box < MAX_MAILBOX; box++) {
 5366                 if (obits & (1 << box)) {
mbp->param[box] = isp->isp_mboxtmp[box];
 5368                 }
 5369         }
MBOX_RELEASE(isp);
 5373         if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
 5374                 return;
 5375         }
 5376 #ifdef  ISP_STRIPPED
cname = NULL;
 5378 #else
cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
 5380 #endif
 5381         if (cname == NULL) {
cname = tname;
SNPRINTF(tname, sizeof tname, "opcode %x", opcode);
 5384         }
 5386         /*
 5387          * Just to be chatty here...
 5388          */
xname = NULL;
 5390         switch (mbp->param[0]) {
 5391         case MBOX_COMMAND_COMPLETE:
 5392                 break;
 5393         case MBOX_INVALID_COMMAND:
 5394                 if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
xname = "INVALID COMMAND";
 5396                 break;
 5397         case MBOX_HOST_INTERFACE_ERROR:
 5398                 if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
xname = "HOST INTERFACE ERROR";
 5400                 break;
 5401         case MBOX_TEST_FAILED:
 5402                 if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
xname = "TEST FAILED";
 5404                 break;
 5405         case MBOX_COMMAND_ERROR:
 5406                 if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
xname = "COMMAND ERROR";
 5408                 break;
 5409         case MBOX_COMMAND_PARAM_ERROR:
 5410                 if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
xname = "COMMAND PARAMETER ERROR";
 5412                 break;
 5413         case MBOX_LOOP_ID_USED:
 5414                 if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
xname = "LOOP ID ALREADY IN USE";
 5416                 break;
 5417         case MBOX_PORT_ID_USED:
 5418                 if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
xname = "PORT ID ALREADY IN USE";
 5420                 break;
 5421         case MBOX_ALL_IDS_USED:
 5422                 if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
xname = "ALL LOOP IDS IN USE";
 5424                 break;
 5425         case 0:         /* special case */
xname = "TIMEOUT";
 5427                 break;
 5428         default:
SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
xname = mname;
 5431                 break;
 5432         }
 5433         if (xname)
isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
cname, xname);
 5436 }
 5438 static void
isp_fw_state(struct ispsoftc *isp)
 5440 {
 5441         if (IS_FC(isp)) {
mbreg_t mbs;
fcparam *fcp = isp->isp_param;
mbs.param[0] = MBOX_GET_FW_STATE;
isp_mboxcmd(isp, &mbs, MBLOGALL);
 5447                 if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
fcp->isp_fwstate = mbs.param[1];
 5449                 }
 5450         }
 5451 }
 5453 static void
isp_update(struct ispsoftc *isp)
 5455 {
 5456         int bus, upmask;
 5458         for (bus = 0, upmask = isp->isp_update; upmask != 0; bus++) {
 5459                 if (upmask & (1 << bus)) {
isp_update_bus(isp, bus);
 5461                 }
upmask &= ~(1 << bus);
 5463         }
 5464 }
 5466 static void
isp_update_bus(struct ispsoftc *isp, int bus)
 5468 {
 5469         int tgt;
mbreg_t mbs;
sdparam *sdp;
isp->isp_update &= ~(1 << bus);
 5474         if (IS_FC(isp)) {
 5475                 /*
 5476                  * There are no 'per-bus' settings for Fibre Channel.
 5477                  */
 5478                 return;
 5479         }
sdp = isp->isp_param;
sdp += bus;
 5483         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
u_int16_t flags, period, offset;
 5485                 int get;
 5487                 if (sdp->isp_devparam[tgt].dev_enable == 0) {
sdp->isp_devparam[tgt].dev_update = 0;
sdp->isp_devparam[tgt].dev_refresh = 0;
isp_prt(isp, ISP_LOGDEBUG0,
 5491                             "skipping target %d bus %d update", tgt, bus);
 5492                         continue;
 5493                 }
 5494                 /*
 5495                  * If the goal is to update the status of the device,
 5496                  * take what's in goal_flags and try and set the device
 5497                  * toward that. Otherwise, if we're just refreshing the
 5498                  * current device state, get the current parameters.
 5499                  */
 5501                 /*
 5502                  * Refresh overrides set
 5503                  */
 5504                 if (sdp->isp_devparam[tgt].dev_refresh) {
mbs.param[0] = MBOX_GET_TARGET_PARAMS;
sdp->isp_devparam[tgt].dev_refresh = 0;
get = 1;
 5508                 } else if (sdp->isp_devparam[tgt].dev_update) {
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
 5510                         /*
 5511                          * Make sure goal_flags has "Renegotiate on Error"
 5512                          * on and "Freeze Queue on Error" off.
 5513                          */
sdp->isp_devparam[tgt].goal_flags |= DPARM_RENEG;
sdp->isp_devparam[tgt].goal_flags &= ~DPARM_QFRZ;
mbs.param[2] = sdp->isp_devparam[tgt].goal_flags;
 5519                         /*
 5520                          * Insist that PARITY must be enabled
 5521                          * if SYNC or WIDE is enabled.
 5522                          */
 5523                         if ((mbs.param[2] & (DPARM_SYNC|DPARM_WIDE)) != 0) {
mbs.param[2] |= DPARM_PARITY;
 5525                         }
 5527                         if ((mbs.param[2] & DPARM_SYNC) == 0) {
mbs.param[3] = 0;
 5529                         } else {
mbs.param[3] =
 5531                                     (sdp->isp_devparam[tgt].goal_offset << 8) |
 5532                                     (sdp->isp_devparam[tgt].goal_period);
 5533                         }
 5534                         /*
 5535                          * A command completion later that has
 5536                          * RQSTF_NEGOTIATION set can cause
 5537                          * the dev_refresh/announce cycle also.
 5538                          *
 5539                          * Note: It is really important to update our current
 5540                          * flags with at least the state of TAG capabilities-
 5541                          * otherwise we might try and send a tagged command
 5542                          * when we have it all turned off. So change it here
 5543                          * to say that current already matches goal.
 5544                          */
sdp->isp_devparam[tgt].actv_flags &= ~DPARM_TQING;
sdp->isp_devparam[tgt].actv_flags |=
 5547                             (sdp->isp_devparam[tgt].goal_flags & DPARM_TQING);
isp_prt(isp, ISP_LOGDEBUG0,
 5549                             "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
bus, tgt, mbs.param[2], mbs.param[3] >> 8,
mbs.param[3] & 0xff);
sdp->isp_devparam[tgt].dev_update = 0;
sdp->isp_devparam[tgt].dev_refresh = 1;
get = 0;
 5555                 } else {
 5556                         continue;
 5557                 }
mbs.param[1] = (bus << 15) | (tgt << 8);
isp_mboxcmd(isp, &mbs, MBLOGALL);
 5560                 if (get == 0) {
isp->isp_sendmarker |= (1 << bus);
 5562                         continue;
 5563                 }
flags = mbs.param[2];
period = mbs.param[3] & 0xff;
offset = mbs.param[3] >> 8;
sdp->isp_devparam[tgt].actv_flags = flags;
sdp->isp_devparam[tgt].actv_period = period;
sdp->isp_devparam[tgt].actv_offset = offset;
get = (bus << 16) | tgt;
 5571                 (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get);
 5572         }
 5574         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
 5575                 if (sdp->isp_devparam[tgt].dev_update ||
sdp->isp_devparam[tgt].dev_refresh) {
isp->isp_update |= (1 << bus);
 5578                         break;
 5579                 }
 5580         }
 5581 }
 5583 #ifndef DEFAULT_FRAMESIZE
 5584 #define DEFAULT_FRAMESIZE(isp)          ICB_DFLT_FRMLEN
 5585 #endif
 5586 #ifndef DEFAULT_EXEC_THROTTLE
 5587 #define DEFAULT_EXEC_THROTTLE(isp)      ISP_EXEC_THROTTLE
 5588 #endif
 5590 static void
isp_setdfltparm(struct ispsoftc *isp, int channel)
 5592 {
 5593         int tgt;
mbreg_t mbs;
sdparam *sdp;
 5597         if (IS_FC(isp)) {
fcparam *fcp = (fcparam *) isp->isp_param;
 5599                 int nvfail;
fcp += channel;
 5602                 if (fcp->isp_gotdparms) {
 5603                         return;
 5604                 }
fcp->isp_gotdparms = 1;
fcp->isp_maxfrmlen = DEFAULT_FRAMESIZE(isp);
fcp->isp_maxalloc = ICB_DFLT_ALLOC;
fcp->isp_execthrottle = DEFAULT_EXEC_THROTTLE(isp);
fcp->isp_retry_delay = ICB_DFLT_RDELAY;
fcp->isp_retry_count = ICB_DFLT_RCOUNT;
 5611                 /* Platform specific.... */
fcp->isp_loopid = DEFAULT_LOOPID(isp);
fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
fcp->isp_fwoptions = 0;
fcp->isp_fwoptions |= ICBOPT_FAIRNESS;
fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
 5619 #ifndef ISP_NO_FASTPOST_FC
fcp->isp_fwoptions |= ICBOPT_FAST_POST;
 5621 #endif
 5622                 if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX)
fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX;
 5625                 /*
 5626                  * Make sure this is turned off now until we get
 5627                  * extended options from NVRAM
 5628                  */
fcp->isp_fwoptions &= ~ICBOPT_EXTENDED;
 5631                 /*
 5632                  * Now try and read NVRAM unless told to not do so.
 5633                  * This will set fcparam's isp_nodewwn && isp_portwwn.
 5634                  */
 5635                 if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
nvfail = isp_read_nvram(isp);
 5637                         if (nvfail)
isp->isp_confopts |= ISP_CFG_NONVRAM;
 5639                 } else {
nvfail = 1;
 5641                 }
 5642                 /*
 5643                  * Set node && port to override platform set defaults
 5644                  * unless the nvram read failed (or none was done),
 5645                  * or the platform code wants to use what had been
 5646                  * set in the defaults.
 5647                  */
 5648                 if (nvfail) {
isp->isp_confopts |= ISP_CFG_OWNWWPN|ISP_CFG_OWNWWNN;
 5650                 }
 5651                 if (isp->isp_confopts & ISP_CFG_OWNWWNN) {
isp_prt(isp, ISP_LOGCONFIG, "Using Node WWN 0x%08x%08x",
 5653                             (u_int32_t) (DEFAULT_NODEWWN(isp) >> 32),
 5654                             (u_int32_t) (DEFAULT_NODEWWN(isp) & 0xffffffff));
ISP_NODEWWN(isp) = DEFAULT_NODEWWN(isp);
 5656                 } else {
 5657                         /*
 5658                          * We always start out with values derived
 5659                          * from NVRAM or our platform default.
 5660                          */
ISP_NODEWWN(isp) = fcp->isp_nodewwn;
 5662                 }
 5663                 if (isp->isp_confopts & ISP_CFG_OWNWWPN) {
isp_prt(isp, ISP_LOGCONFIG, "Using Port WWN 0x%08x%08x",
 5665                             (u_int32_t) (DEFAULT_PORTWWN(isp) >> 32),
 5666                             (u_int32_t) (DEFAULT_PORTWWN(isp) & 0xffffffff));
ISP_PORTWWN(isp) = DEFAULT_PORTWWN(isp);
 5668                 } else {
 5669                         /*
 5670                          * We always start out with values derived
 5671                          * from NVRAM or our platform default.
 5672                          */
ISP_PORTWWN(isp) = fcp->isp_portwwn;
 5674                 }
 5675                 return;
 5676         }
sdp = (sdparam *) isp->isp_param;
sdp += channel;
 5681         /*
 5682          * Been there, done that, got the T-shirt...
 5683          */
 5684         if (sdp->isp_gotdparms) {
 5685                 return;
 5686         }
sdp->isp_gotdparms = 1;
 5689         /*
 5690          * Establish some default parameters.
 5691          */
sdp->isp_cmd_dma_burst_enable = 0;
sdp->isp_data_dma_burst_enabl = 1;
sdp->isp_fifo_threshold = 0;
sdp->isp_initiator_id = DEFAULT_IID(isp);
 5696         if (isp->isp_type >= ISP_HA_SCSI_1040) {
sdp->isp_async_data_setup = 9;
 5698         } else {
sdp->isp_async_data_setup = 6;
 5700         }
sdp->isp_selection_timeout = 250;
sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
sdp->isp_tag_aging = 8;
sdp->isp_bus_reset_delay = 5;
 5705         /*
 5706          * Don't retry selection, busy or queue full automatically- reflect
 5707          * these back to us.
 5708          */
sdp->isp_retry_count = 0;
sdp->isp_retry_delay = 0;
 5712         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
sdp->isp_devparam[tgt].exc_throttle = ISP_EXEC_THROTTLE;
sdp->isp_devparam[tgt].dev_enable = 1;
 5715         }
 5717         /*
 5718          * If we've not been told to avoid reading NVRAM, try and read it.
 5719          * If we're successful reading it, we can then return because NVRAM
 5720          * will tell us what the desired settings are. Otherwise, we establish
 5721          * some reasonable 'fake' nvram and goal defaults.
 5722          */
 5724         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
 5725                 if (isp_read_nvram(isp) == 0) {
 5726                         return;
 5727                 }
 5728         }
 5730         /*
 5731          * Now try and see whether we have specific values for them.
 5732          */
 5733         if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
isp_mboxcmd(isp, &mbs, MBLOGNONE);
 5736                 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
sdp->isp_req_ack_active_neg = 1;
sdp->isp_data_line_active_neg = 1;
 5739                 } else {
sdp->isp_req_ack_active_neg =
 5741                             (mbs.param[1+channel] >> 4) & 0x1;
sdp->isp_data_line_active_neg =
 5743                             (mbs.param[1+channel] >> 5) & 0x1;
 5744                 }
 5745         }
isp_prt(isp, ISP_LOGDEBUG0, sc0, sc3,
 5748             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
sdp->isp_bus_reset_delay, sdp->isp_retry_count,
sdp->isp_retry_delay, sdp->isp_async_data_setup);
isp_prt(isp, ISP_LOGDEBUG0, sc1, sc3,
sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
 5756         /*
 5757          * The trick here is to establish a default for the default (honk!)
 5758          * state (goal_flags). Then try and get the current status from
 5759          * the card to fill in the current state. We don't, in fact, set
 5760          * the default to the SAFE default state- that's not the goal state.
 5761          */
 5762         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
u_int8_t off, per;
sdp->isp_devparam[tgt].actv_offset = 0;
sdp->isp_devparam[tgt].actv_period = 0;
sdp->isp_devparam[tgt].actv_flags = 0;
sdp->isp_devparam[tgt].goal_flags =
sdp->isp_devparam[tgt].nvrm_flags = DPARM_DEFAULT;
 5771                 /*
 5772                  * We default to Wide/Fast for versions less than a 1040
 5773                  * (unless its SBus).
 5774                  */
 5775                 if (IS_ULTRA3(isp)) {
off = ISP_80M_SYNCPARMS >> 8;
per = ISP_80M_SYNCPARMS & 0xff;
 5778                 } else if (IS_ULTRA2(isp)) {
off = ISP_40M_SYNCPARMS >> 8;
per = ISP_40M_SYNCPARMS & 0xff;
 5781                 } else if (IS_1240(isp)) {
off = ISP_20M_SYNCPARMS >> 8;
per = ISP_20M_SYNCPARMS & 0xff;
 5784                 } else if ((isp->isp_bustype == ISP_BT_SBUS &&
isp->isp_type < ISP_HA_SCSI_1020A) ||
 5786                     (isp->isp_bustype == ISP_BT_PCI &&
isp->isp_type < ISP_HA_SCSI_1040) ||
 5788                     (isp->isp_clock && isp->isp_clock < 60) ||
 5789                     (sdp->isp_ultramode == 0)) {
off = ISP_10M_SYNCPARMS >> 8;
per = ISP_10M_SYNCPARMS & 0xff;
 5792                 } else {
off = ISP_20M_SYNCPARMS_1040 >> 8;
per = ISP_20M_SYNCPARMS_1040 & 0xff;
 5795                 }
sdp->isp_devparam[tgt].goal_offset =
sdp->isp_devparam[tgt].nvrm_offset = off;
sdp->isp_devparam[tgt].goal_period =
sdp->isp_devparam[tgt].nvrm_period = per;
isp_prt(isp, ISP_LOGDEBUG0, sc2, sc3,
channel, tgt, sdp->isp_devparam[tgt].nvrm_flags,
sdp->isp_devparam[tgt].nvrm_offset,
sdp->isp_devparam[tgt].nvrm_period);
 5805         }
 5806 }
 5808 /*
 5809  * Re-initialize the ISP and complete all orphaned commands
 5810  * with a 'botched' notice. The reset/init routines should
 5811  * not disturb an already active list of commands.
 5812  *
 5813  * Locks held prior to coming here.
 5814  */
 5816 void
isp_reinit(struct ispsoftc *isp)
 5818 {
XS_T *xs;
u_int16_t handle;
isp_reset(isp);
 5823         if (isp->isp_state != ISP_RESETSTATE) {
isp_prt(isp, ISP_LOGERR, "isp_reinit cannot reset card");
 5825         } else if (isp->isp_role != ISP_ROLE_NONE) {
isp_init(isp);
 5827                 if (isp->isp_state == ISP_INITSTATE) {
isp->isp_state = ISP_RUNSTATE;
 5829                 }
 5830                 if (isp->isp_state != ISP_RUNSTATE) {
isp_prt(isp, ISP_LOGERR,
 5832                             "isp_reinit cannot restart card");
 5833                 }
 5834         }
isp->isp_nactive = 0;
 5837         for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) {
xs = isp_find_xs(isp, handle);
 5839                 if (xs == NULL) {
 5840                         continue;
 5841                 }
isp_destroy_handle(isp, handle);
 5843                 if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, handle);
XS_RESID(xs) = XS_XFRLEN(xs);
 5846                 } else {
XS_RESID(xs) = 0;
 5848                 }
XS_SETERR(xs, HBA_BUSRESET);
isp_done(xs);
 5851         }
 5852 }
 5854 /*
 5855  * NVRAM Routines
 5856  */
 5857 static int
isp_read_nvram(struct ispsoftc *isp)
 5859 {
 5860         int i, amt;
u_int8_t csum, minversion;
 5862         union {
u_int8_t _x[ISP2100_NVRAM_SIZE];
u_int16_t _s[ISP2100_NVRAM_SIZE>>1];
 5865         } _n;
 5866 #define nvram_data      _n._x
 5867 #define nvram_words     _n._s
 5869         if (IS_FC(isp)) {
amt = ISP2100_NVRAM_SIZE;
minversion = 1;
 5872         } else if (IS_ULTRA2(isp)) {
amt = ISP1080_NVRAM_SIZE;
minversion = 0;
 5875         } else {
amt = ISP_NVRAM_SIZE;
minversion = 2;
 5878         }
 5880         /*
 5881          * Just read the first two words first to see if we have a valid
 5882          * NVRAM to continue reading the rest with.
 5883          */
 5884         for (i = 0; i < 2; i++) {
isp_rdnvram_word(isp, i, &nvram_words[i]);
 5886         }
 5887         if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
nvram_data[2] != 'P') {
 5889                 if (isp->isp_bustype != ISP_BT_SBUS) {
isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
nvram_data[0], nvram_data[1], nvram_data[2]);
 5893                 }
 5894                 return (-1);
 5895         }
 5896         for (i = 2; i < amt>>1; i++) {
isp_rdnvram_word(isp, i, &nvram_words[i]);
 5898         }
 5899         for (csum = 0, i = 0; i < amt; i++) {
csum += nvram_data[i];
 5901         }
 5902         if (csum != 0) {
isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
 5904                 return (-1);
 5905         }
 5906         if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
ISP_NVRAM_VERSION(nvram_data));
 5909                 return (-1);
 5910         }
 5912         if (IS_ULTRA3(isp)) {
isp_parse_nvram_12160(isp, 0, nvram_data);
 5914                 if (IS_12160(isp))
isp_parse_nvram_12160(isp, 1, nvram_data);
 5916         } else if (IS_1080(isp)) {
isp_parse_nvram_1080(isp, 0, nvram_data);
 5918         } else if (IS_1280(isp) || IS_1240(isp)) {
isp_parse_nvram_1080(isp, 0, nvram_data);
isp_parse_nvram_1080(isp, 1, nvram_data);
 5921         } else if (IS_SCSI(isp)) {
isp_parse_nvram_1020(isp, nvram_data);
 5923         } else {
isp_parse_nvram_2100(isp, nvram_data);
 5925         }
 5926         return (0);
 5927 #undef  nvram_data
 5928 #undef  nvram_words
 5929 }
 5931 static void
isp_rdnvram_word(struct ispsoftc *isp, int wo, u_int16_t *rp)
 5933 {
 5934         int i, cbits;
u_int16_t bit, rqst;
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
USEC_DELAY(2);
 5942         if (IS_FC(isp)) {
wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
 5944                 if (IS_2312(isp) && isp->isp_port) {
wo += 128;
 5946                 }
rqst = (ISP_NVRAM_READ << 8) | wo;
cbits = 10;
 5949         } else if (IS_ULTRA2(isp)) {
wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1);
rqst = (ISP_NVRAM_READ << 8) | wo;
cbits = 10;
 5953         } else {
wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
rqst = (ISP_NVRAM_READ << 6) | wo;
cbits = 8;
 5957         }
 5959         /*
 5960          * Clock the word select request out...
 5961          */
 5962         for (i = cbits; i >= 0; i--) {
 5963                 if ((rqst >> i) & 1) {
bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
 5965                 } else {
bit = BIU_NVRAM_SELECT;
 5967                 }
ISP_WRITE(isp, BIU_NVRAM, bit);
USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, bit);
USEC_DELAY(2);
 5974         }
 5975         /*
 5976          * Now read the result back in (bits come back in MSB format).
 5977          */
 5978         *rp = 0;
 5979         for (i = 0; i < 16; i++) {
u_int16_t rv;
 5981                 *rp <<= 1;
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
USEC_DELAY(2);
rv = ISP_READ(isp, BIU_NVRAM);
 5985                 if (rv & BIU_NVRAM_DATAIN) {
 5986                         *rp |= 1;
 5987                 }
USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
USEC_DELAY(2);
 5991         }
ISP_WRITE(isp, BIU_NVRAM, 0);
USEC_DELAY(2);
ISP_SWIZZLE_NVRAM_WORD(isp, rp);
 5995 }
 5997 static void
isp_parse_nvram_1020(struct ispsoftc *isp, u_int8_t *nvram_data)
 5999 {
sdparam *sdp = (sdparam *) isp->isp_param;
 6001         int tgt;
sdp->isp_fifo_threshold =
ISP_NVRAM_FIFO_THRESHOLD(nvram_data) |
 6005                 (ISP_NVRAM_FIFO_THRESHOLD_128(nvram_data) << 2);
 6007         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
sdp->isp_initiator_id =
ISP_NVRAM_INITIATOR_ID(nvram_data);
sdp->isp_bus_reset_delay =
ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
sdp->isp_retry_count =
ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
sdp->isp_retry_delay =
ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
sdp->isp_async_data_setup =
ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
 6023         if (isp->isp_type >= ISP_HA_SCSI_1040) {
 6024                 if (sdp->isp_async_data_setup < 9) {
sdp->isp_async_data_setup = 9;
 6026                 }
 6027         } else {
 6028                 if (sdp->isp_async_data_setup != 6) {
sdp->isp_async_data_setup = 6;
 6030                 }
 6031         }
sdp->isp_req_ack_active_neg =
ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
sdp->isp_data_line_active_neg =
ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
sdp->isp_data_dma_burst_enabl =
ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
sdp->isp_cmd_dma_burst_enable =
ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
sdp->isp_tag_aging =
ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
sdp->isp_selection_timeout =
ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
sdp->isp_max_queue_depth =
ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
 6057             0, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
sdp->isp_bus_reset_delay, sdp->isp_retry_count,
sdp->isp_retry_delay, sdp->isp_async_data_setup);
isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
 6065         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
sdp->isp_devparam[tgt].dev_enable =
ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt);
sdp->isp_devparam[tgt].exc_throttle =
ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt);
sdp->isp_devparam[tgt].nvrm_offset =
ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt);
sdp->isp_devparam[tgt].nvrm_period =
ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt);
 6074                 /*
 6075                  * We probably shouldn't lie about this, but it
 6076                  * it makes it much safer if we limit NVRAM values
 6077                  * to sanity.
 6078                  */
 6079                 if (isp->isp_type < ISP_HA_SCSI_1040) {
 6080                         /*
 6081                          * If we're not ultra, we can't possibly
 6082                          * be a shorter period than this.
 6083                          */
 6084                         if (sdp->isp_devparam[tgt].nvrm_period < 0x19) {
sdp->isp_devparam[tgt].nvrm_period = 0x19;
 6086                         }
 6087                         if (sdp->isp_devparam[tgt].nvrm_offset > 0xc) {
sdp->isp_devparam[tgt].nvrm_offset = 0x0c;
 6089                         }
 6090                 } else {
 6091                         if (sdp->isp_devparam[tgt].nvrm_offset > 0x8) {
sdp->isp_devparam[tgt].nvrm_offset = 0x8;
 6093                         }
 6094                 }
sdp->isp_devparam[tgt].nvrm_flags = 0;
 6096                 if (ISP_NVRAM_TGT_RENEG(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
 6099                 if (ISP_NVRAM_TGT_TQING(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
 6101                 if (ISP_NVRAM_TGT_SYNC(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
 6103                 if (ISP_NVRAM_TGT_WIDE(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
 6105                 if (ISP_NVRAM_TGT_PARITY(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
 6107                 if (ISP_NVRAM_TGT_DISC(nvram_data, tgt))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
sdp->isp_devparam[tgt].actv_flags = 0; /* we don't know */
isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
 6111                     0, tgt, sdp->isp_devparam[tgt].nvrm_flags,
sdp->isp_devparam[tgt].nvrm_offset,
sdp->isp_devparam[tgt].nvrm_period);
sdp->isp_devparam[tgt].goal_offset =
sdp->isp_devparam[tgt].nvrm_offset;
sdp->isp_devparam[tgt].goal_period =
sdp->isp_devparam[tgt].nvrm_period;
sdp->isp_devparam[tgt].goal_flags =
sdp->isp_devparam[tgt].nvrm_flags;
 6120         }
 6121 }
 6123 static void
isp_parse_nvram_1080(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 6125 {
sdparam *sdp = (sdparam *) isp->isp_param;
 6127         int tgt;
sdp += bus;
sdp->isp_fifo_threshold =
ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data);
 6134         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
sdp->isp_initiator_id =
ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus);
sdp->isp_bus_reset_delay =
ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
sdp->isp_retry_count =
ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
sdp->isp_retry_delay =
ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
sdp->isp_async_data_setup =
ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
sdp->isp_req_ack_active_neg =
ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
sdp->isp_data_line_active_neg =
ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
sdp->isp_data_dma_burst_enabl =
ISP1080_NVRAM_BURST_ENABLE(nvram_data);
sdp->isp_cmd_dma_burst_enable =
ISP1080_NVRAM_BURST_ENABLE(nvram_data);
sdp->isp_selection_timeout =
ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
sdp->isp_max_queue_depth =
ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
sdp->isp_bus_reset_delay, sdp->isp_retry_count,
sdp->isp_retry_delay, sdp->isp_async_data_setup);
isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
 6178         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
sdp->isp_devparam[tgt].dev_enable =
ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].exc_throttle =
ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_offset =
ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_period =
ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_flags = 0;
 6188                 if (ISP1080_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
 6191                 if (ISP1080_NVRAM_TGT_TQING(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
 6193                 if (ISP1080_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
 6195                 if (ISP1080_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
 6197                 if (ISP1080_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
 6199                 if (ISP1080_NVRAM_TGT_DISC(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
sdp->isp_devparam[tgt].actv_flags = 0;
isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
sdp->isp_devparam[tgt].nvrm_offset,
sdp->isp_devparam[tgt].nvrm_period);
sdp->isp_devparam[tgt].goal_offset =
sdp->isp_devparam[tgt].nvrm_offset;
sdp->isp_devparam[tgt].goal_period =
sdp->isp_devparam[tgt].nvrm_period;
sdp->isp_devparam[tgt].goal_flags =
sdp->isp_devparam[tgt].nvrm_flags;
 6212         }
 6213 }
 6215 static void
isp_parse_nvram_12160(struct ispsoftc *isp, int bus, u_int8_t *nvram_data)
 6217 {
sdparam *sdp = (sdparam *) isp->isp_param;
 6219         int tgt;
sdp += bus;
sdp->isp_fifo_threshold =
ISP12160_NVRAM_FIFO_THRESHOLD(nvram_data);
 6226         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
sdp->isp_initiator_id =
ISP12160_NVRAM_INITIATOR_ID(nvram_data, bus);
sdp->isp_bus_reset_delay =
ISP12160_NVRAM_BUS_RESET_DELAY(nvram_data, bus);
sdp->isp_retry_count =
ISP12160_NVRAM_BUS_RETRY_COUNT(nvram_data, bus);
sdp->isp_retry_delay =
ISP12160_NVRAM_BUS_RETRY_DELAY(nvram_data, bus);
sdp->isp_async_data_setup =
ISP12160_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, bus);
sdp->isp_req_ack_active_neg =
ISP12160_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, bus);
sdp->isp_data_line_active_neg =
ISP12160_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, bus);
sdp->isp_data_dma_burst_enabl =
ISP12160_NVRAM_BURST_ENABLE(nvram_data);
sdp->isp_cmd_dma_burst_enable =
ISP12160_NVRAM_BURST_ENABLE(nvram_data);
sdp->isp_selection_timeout =
ISP12160_NVRAM_SELECTION_TIMEOUT(nvram_data, bus);
sdp->isp_max_queue_depth =
ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
isp_prt(isp, ISP_LOGDEBUG0, sc0, sc4,
bus, sdp->isp_fifo_threshold, sdp->isp_initiator_id,
sdp->isp_bus_reset_delay, sdp->isp_retry_count,
sdp->isp_retry_delay, sdp->isp_async_data_setup);
isp_prt(isp, ISP_LOGDEBUG0, sc1, sc4,
sdp->isp_req_ack_active_neg, sdp->isp_data_line_active_neg,
sdp->isp_data_dma_burst_enabl, sdp->isp_cmd_dma_burst_enable,
sdp->isp_selection_timeout, sdp->isp_max_queue_depth);
 6269         for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
sdp->isp_devparam[tgt].dev_enable =
ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].exc_throttle =
ISP12160_NVRAM_TGT_EXEC_THROTTLE(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_offset =
ISP12160_NVRAM_TGT_SYNC_OFFSET(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_period =
ISP12160_NVRAM_TGT_SYNC_PERIOD(nvram_data, tgt, bus);
sdp->isp_devparam[tgt].nvrm_flags = 0;
 6279                 if (ISP12160_NVRAM_TGT_RENEG(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_RENEG;
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_ARQ;
 6282                 if (ISP12160_NVRAM_TGT_TQING(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_TQING;
 6284                 if (ISP12160_NVRAM_TGT_SYNC(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_SYNC;
 6286                 if (ISP12160_NVRAM_TGT_WIDE(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_WIDE;
 6288                 if (ISP12160_NVRAM_TGT_PARITY(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_PARITY;
 6290                 if (ISP12160_NVRAM_TGT_DISC(nvram_data, tgt, bus))
sdp->isp_devparam[tgt].nvrm_flags |= DPARM_DISC;
sdp->isp_devparam[tgt].actv_flags = 0;
isp_prt(isp, ISP_LOGDEBUG0, sc2, sc4,
bus, tgt, sdp->isp_devparam[tgt].nvrm_flags,
sdp->isp_devparam[tgt].nvrm_offset,
sdp->isp_devparam[tgt].nvrm_period);
sdp->isp_devparam[tgt].goal_offset =
sdp->isp_devparam[tgt].nvrm_offset;
sdp->isp_devparam[tgt].goal_period =
sdp->isp_devparam[tgt].nvrm_period;
sdp->isp_devparam[tgt].goal_flags =
sdp->isp_devparam[tgt].nvrm_flags;
 6303         }
 6304 }
 6306 static void
isp_parse_nvram_2100(struct ispsoftc *isp, u_int8_t *nvram_data)
 6308 {
fcparam *fcp = (fcparam *) isp->isp_param;
u_int64_t wwn;
 6312         /*
 6313          * There is NVRAM storage for both Port and Node entities-
 6314          * but the Node entity appears to be unused on all the cards
 6315          * I can find. However, we should account for this being set
 6316          * at some point in the future.
 6317          *
 6318          * Qlogic WWNs have an NAA of 2, but usually nothing shows up in
 6319          * bits 48..60. In the case of the 2202, it appears that they do
 6320          * use bit 48 to distinguish between the two instances on the card.
 6321          * The 2204, which I've never seen, *probably* extends this method.
 6322          */
wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
 6324         if (wwn) {
isp_prt(isp, ISP_LOGCONFIG, "NVRAM Port WWN 0x%08x%08x",
 6326                     (u_int32_t) (wwn >> 32), (u_int32_t) (wwn & 0xffffffff));
 6327                 if ((wwn >> 60) == 0) {
wwn |= (((u_int64_t) 2)<< 60);
 6329                 }
 6330         }
fcp->isp_portwwn = wwn;
 6332         if (IS_2200(isp) || IS_23XX(isp)) {
wwn = ISP2200_NVRAM_NODE_NAME(nvram_data);
 6334                 if (wwn) {
isp_prt(isp, ISP_LOGCONFIG, "NVRAM Node WWN 0x%08x%08x",
 6336                             (u_int32_t) (wwn >> 32),
 6337                             (u_int32_t) (wwn & 0xffffffff));
 6338                         if ((wwn >> 60) == 0) {
wwn |= (((u_int64_t) 2)<< 60);
 6340                         }
 6341                 }
 6342         } else {
wwn &= ~((u_int64_t) 0xfff << 48);
 6344         }
fcp->isp_nodewwn = wwn;
 6347         /*
 6348          * Make sure we have both Node and Port as non-zero values.
 6349          */
 6350         if (fcp->isp_nodewwn != 0 && fcp->isp_portwwn == 0) {
fcp->isp_portwwn = fcp->isp_nodewwn;
 6352         } else if (fcp->isp_nodewwn == 0 && fcp->isp_portwwn != 0) {
fcp->isp_nodewwn = fcp->isp_portwwn;
 6354         }
 6356         /*
 6357          * Make the Node and Port values sane if they're NAA == 2.
 6358          * This means to clear bits 48..56 for the Node WWN and
 6359          * make sure that there's some non-zero value in 48..56
 6360          * for the Port WWN.
 6361          */
 6362         if (fcp->isp_nodewwn && fcp->isp_portwwn) {
 6363                 if ((fcp->isp_nodewwn & (((u_int64_t) 0xfff) << 48)) != 0 &&
 6364                     (fcp->isp_nodewwn >> 60) == 2) {
fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48);
 6366                 }
 6367                 if ((fcp->isp_portwwn & (((u_int64_t) 0xfff) << 48)) == 0 &&
 6368                     (fcp->isp_portwwn >> 60) == 2) {
fcp->isp_portwwn |= ((u_int64_t) 1 << 56);
 6370                 }
 6371         }
isp_prt(isp, ISP_LOGDEBUG0,
 6374             "NVRAM: maxfrmlen %d execthrottle %d fwoptions 0x%x loopid %x",
ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data),
ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data),
ISP2100_NVRAM_OPTIONS(nvram_data),
ISP2100_NVRAM_HARDLOOPID(nvram_data));
fcp->isp_maxalloc =
ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
 6382         if ((isp->isp_confopts & ISP_CFG_OWNFSZ) == 0)
fcp->isp_maxfrmlen =
ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
fcp->isp_retry_delay =
ISP2100_NVRAM_RETRY_DELAY(nvram_data);
fcp->isp_retry_count =
ISP2100_NVRAM_RETRY_COUNT(nvram_data);
 6389         if ((isp->isp_confopts & ISP_CFG_OWNLOOPID) == 0)
fcp->isp_loopid =
ISP2100_NVRAM_HARDLOOPID(nvram_data);
 6392         if ((isp->isp_confopts & ISP_CFG_OWNEXCTHROTTLE) == 0)
fcp->isp_execthrottle =
ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
 6396 }
 6398 #ifdef  ISP_FW_CRASH_DUMP
 6399 static void isp2200_fw_dump(struct ispsoftc *);
 6400 static void isp2300_fw_dump(struct ispsoftc *);
 6402 static void
isp2200_fw_dump(struct ispsoftc *isp)
 6404 {
 6405         int i, j;
mbreg_t mbs;
u_int16_t *ptr;
ptr = FCPARAM(isp)->isp_dump_data;
 6410         if (ptr == NULL) {
isp_prt(isp, ISP_LOGERR,
 6412                    "No place to dump RISC registers and SRAM");
 6413                 return;
 6414         }
 6415         if (*ptr++) {
isp_prt(isp, ISP_LOGERR,
 6417                    "dump area for RISC registers and SRAM already used");
 6418                 return;
 6419         }
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 6421         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6423                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
 6424                         break;
 6425                 }
 6426         }
 6427         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
 6428                 /*
 6429                  * PBIU Registers
 6430                  */
 6431                 for (i = 0; i < 8; i++) {
 6432                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
 6433                 }
 6435                 /*
 6436                  * Mailbox Registers
 6437                  */
 6438                 for (i = 0; i < 8; i++) {
 6439                         *ptr++ = ISP_READ(isp, MBOX_BLOCK + (i << 1));
 6440                 }
 6442                 /*
 6443                  * DMA Registers
 6444                  */
 6445                 for (i = 0; i < 48; i++) {
 6446                         *ptr++ = ISP_READ(isp, DMA_BLOCK + 0x20 + (i << 1));
 6447                 }
 6449                 /*
 6450                  * RISC H/W Registers
 6451                  */
ISP_WRITE(isp, BIU2100_CSR, 0);
 6453                 for (i = 0; i < 16; i++) {
 6454                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
 6455                 }
 6457                 /*
 6458                  * RISC GP Registers
 6459                  */
 6460                 for (j = 0; j < 8; j++) {
ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 8));
 6462                         for (i = 0; i < 16; i++) {
 6463                                 *ptr++ =
ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6465                         }
 6466                 }
 6468                 /*
 6469                  * Frame Buffer Hardware Registers
 6470                  */
ISP_WRITE(isp, BIU2100_CSR, 0x10);
 6472                 for (i = 0; i < 16; i++) {
 6473                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6474                 }
 6476                 /*
 6477                  * Fibre Protocol Module 0 Hardware Registers
 6478                  */
ISP_WRITE(isp, BIU2100_CSR, 0x20);
 6480                 for (i = 0; i < 64; i++) {
 6481                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6482                 }
 6484                 /*
 6485                  * Fibre Protocol Module 1 Hardware Registers
 6486                  */
ISP_WRITE(isp, BIU2100_CSR, 0x30);
 6488                 for (i = 0; i < 64; i++) {
 6489                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6490                 }
 6491         } else {
isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
 6493                 return;
 6494         }
isp_prt(isp, ISP_LOGALL,
 6496            "isp_fw_dump: RISC registers dumped successfully");
ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 6498         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6500                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
 6501                         break;
 6502                 }
 6503         }
 6504         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
 6506                 return;
 6507         }
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 6509         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6511                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
 6512                         break;
 6513                 }
 6514         }
 6515         if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause After Reset");
 6517                 return;
 6518         }
ISP_WRITE(isp, RISC_EMB, 0xf2);
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
 6521         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6523                 if ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
 6524                         break;
 6525                 }
 6526         }
ENABLE_INTS(isp);
mbs.param[0] = MBOX_READ_RAM_WORD;
mbs.param[1] = 0x1000;
isp->isp_mbxworkp = (void *) ptr;
isp->isp_mbxwrk0 = 0xefff;      /* continuation count */
isp->isp_mbxwrk1 = 0x1001;      /* next SRAM address */
isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 6534         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGWARN,
 6536                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
 6537                 return;
 6538         }
ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
 6540         *ptr++ = isp->isp_mboxtmp[2];
isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
 6543         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
 6544 }
 6546 static void
isp2300_fw_dump(struct ispsoftc *isp)
 6548 {
 6549         int i, j;
mbreg_t mbs;
u_int16_t *ptr;
ptr = FCPARAM(isp)->isp_dump_data;
 6554         if (ptr == NULL) {
isp_prt(isp, ISP_LOGERR,
 6556                    "No place to dump RISC registers and SRAM");
 6557                 return;
 6558         }
 6559         if (*ptr++) {
isp_prt(isp, ISP_LOGERR,
 6561                    "dump area for RISC registers and SRAM already used");
 6562                 return;
 6563         }
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
 6565         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6567                 if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
 6568                         break;
 6569                 }
 6570         }
 6571         if (ISP_READ(isp, HCCR) & HCCR_PAUSE) {
 6572                 /*
 6573                  * PBIU registers
 6574                  */
 6575                 for (i = 0; i < 8; i++) {
 6576                         *ptr++ = ISP_READ(isp, BIU_BLOCK + (i << 1));
 6577                 }
 6579                 /*
 6580                  * ReqQ-RspQ-Risc2Host Status registers
 6581                  */
 6582                 for (i = 0; i < 8; i++) {
 6583                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x10 + (i << 1));
 6584                 }
 6586                 /*
 6587                  * Mailbox Registers
 6588                  */
 6589                 for (i = 0; i < 32; i++) {
 6590                         *ptr++ =
ISP_READ(isp, PCI_MBOX_REGS2300_OFF + (i << 1));
 6592                 }
 6594                 /*
 6595                  * Auto Request Response DMA registers
 6596                  */
ISP_WRITE(isp, BIU2100_CSR, 0x40);
 6598                 for (i = 0; i < 32; i++) {
 6599                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6600                 }
 6602                 /*
 6603                  * DMA registers
 6604                  */
ISP_WRITE(isp, BIU2100_CSR, 0x50);
 6606                 for (i = 0; i < 48; i++) {
 6607                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6608                 }
 6610                 /*
 6611                  * RISC hardware registers
 6612                  */
ISP_WRITE(isp, BIU2100_CSR, 0);
 6614                 for (i = 0; i < 16; i++) {
 6615                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0xA0 + (i << 1));
 6616                 }
 6618                 /*
 6619                  * RISC GP? registers
 6620                  */
 6621                 for (j = 0; j < 8; j++) {
ISP_WRITE(isp, BIU_BLOCK + 0xA4, 0x2000 + (j << 9));
 6623                         for (i = 0; i < 16; i++) {
 6624                                 *ptr++ =
ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6626                         }
 6627                 }
 6629                 /*
 6630                  * frame buffer hardware registers
 6631                  */
ISP_WRITE(isp, BIU2100_CSR, 0x10);
 6633                 for (i = 0; i < 64; i++) {
 6634                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6635                 }
 6637                 /*
 6638                  * FPM B0 hardware registers
 6639                  */
ISP_WRITE(isp, BIU2100_CSR, 0x20);
 6641                 for (i = 0; i < 64; i++) {
 6642                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6643                 }
 6645                 /*
 6646                  * FPM B1 hardware registers
 6647                  */
ISP_WRITE(isp, BIU2100_CSR, 0x30);
 6649                 for (i = 0; i < 64; i++) {
 6650                         *ptr++ = ISP_READ(isp, BIU_BLOCK + 0x80 + (i << 1));
 6651                 }
 6652         } else {
isp_prt(isp, ISP_LOGERR, "RISC Would Not Pause");
 6654                 return;
 6655         }
isp_prt(isp, ISP_LOGALL,
 6657            "isp_fw_dump: RISC registers dumped successfully");
ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
 6659         for (i = 0; i < 100; i++) {
USEC_DELAY(100);
 6661                 if (ISP_READ(isp, OUTMAILBOX0) == 0) {
 6662                         break;
 6663                 }
 6664         }
 6665         if (ISP_READ(isp, OUTMAILBOX0) != 0) {
isp_prt(isp, ISP_LOGERR, "Board Would Not Reset");
 6667                 return;
 6668         }
ENABLE_INTS(isp);
mbs.param[0] = MBOX_READ_RAM_WORD;
mbs.param[1] = 0x800;
isp->isp_mbxworkp = (void *) ptr;
isp->isp_mbxwrk0 = 0xf7ff;      /* continuation count */
isp->isp_mbxwrk1 = 0x801;       /* next SRAM address */
isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 6676         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGWARN,
 6678                     "RAM DUMP FAILED @ WORD %x", isp->isp_mbxwrk1);
 6679                 return;
 6680         }
ptr = isp->isp_mbxworkp;        /* finish fetch of final word */
 6682         *ptr++ = isp->isp_mboxtmp[2];
 6684         /*
 6685          * We don't have access to mailbox registers 8.. onward
 6686          * in our 'common' device model- so we have to set it
 6687          * here and hope it stays the same!
 6688          */
ISP_WRITE(isp, PCI_MBOX_REGS2300_OFF + (8 << 1), 0x1);
mbs.param[0] = MBOX_READ_RAM_WORD_EXTENDED;
mbs.param[1] = 0;
isp->isp_mbxworkp = (void *) ptr;
isp->isp_mbxwrk0 = 0xffff;      /* continuation count */
isp->isp_mbxwrk1 = 0x1;         /* next SRAM address */
isp_control(isp, ISPCTL_RUN_MBOXCMD, &mbs);
 6697         if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_prt(isp, ISP_LOGWARN,
 6699                     "RAM DUMP FAILED @ WORD %x", 0x10000 + isp->isp_mbxwrk1);
 6700                 return;
 6701         }
ptr = isp->isp_mbxworkp;        /* finish final word */
 6703         *ptr++ = mbs.param[2];
isp_prt(isp, ISP_LOGALL, "isp_fw_dump: SRAM dumped successfully");
FCPARAM(isp)->isp_dump_data[0] = isp->isp_type; /* now used */
 6706         (void) isp_async(isp, ISPASYNC_FW_DUMPED, 0);
 6707 }
 6709 void
isp_fw_dump(struct ispsoftc *isp)
 6711 {
 6712         if (IS_2200(isp))
isp2200_fw_dump(isp);
 6714         else if (IS_23XX(isp))
isp2300_fw_dump(isp);
 6716 }
 6717 #endif