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