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