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