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