Home | History | Annotate | Line # | Download | only in ic
isp.c revision 1.23
      1  1.23   mjacob /* $NetBSD: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
      2  1.23   mjacob /* $Id: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
      3   1.1      cgd /*
      4   1.1      cgd  * Machine Independent (well, as best as possible)
      5   1.1      cgd  * code for the Qlogic ISP SCSI adapters.
      6   1.1      cgd  *
      7  1.23   mjacob  *---------------------------------------
      8  1.23   mjacob  * Copyright (c) 1997, 1998 by Matthew Jacob
      9  1.23   mjacob  * NASA/Ames Research Center
     10   1.1      cgd  * All rights reserved.
     11  1.23   mjacob  *---------------------------------------
     12   1.1      cgd  *
     13   1.1      cgd  * Redistribution and use in source and binary forms, with or without
     14   1.1      cgd  * modification, are permitted provided that the following conditions
     15   1.1      cgd  * are met:
     16   1.1      cgd  * 1. Redistributions of source code must retain the above copyright
     17   1.1      cgd  *    notice immediately at the beginning of the file, without modification,
     18   1.1      cgd  *    this list of conditions, and the following disclaimer.
     19   1.1      cgd  * 2. Redistributions in binary form must reproduce the above copyright
     20   1.1      cgd  *    notice, this list of conditions and the following disclaimer in the
     21   1.1      cgd  *    documentation and/or other materials provided with the distribution.
     22   1.1      cgd  * 3. The name of the author may not be used to endorse or promote products
     23   1.1      cgd  *    derived from this software without specific prior written permission.
     24   1.1      cgd  *
     25   1.1      cgd  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     26   1.1      cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     27   1.1      cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     28   1.1      cgd  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
     29   1.1      cgd  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     30   1.1      cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     31   1.1      cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     32   1.1      cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     33   1.1      cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     34   1.1      cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     35   1.1      cgd  * SUCH DAMAGE.
     36   1.1      cgd  */
     37   1.2      cgd 
     38   1.1      cgd /*
     39   1.1      cgd  * Inspiration and ideas about this driver are from Erik Moe's Linux driver
     40  1.23   mjacob  * (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
     41  1.23   mjacob  * ideas dredged from the Solaris driver.
     42   1.1      cgd  */
     43   1.1      cgd 
     44  1.23   mjacob /*
     45  1.23   mjacob  * Include header file appropriate for platform we're building on.
     46  1.23   mjacob  */
     47   1.1      cgd 
     48  1.23   mjacob #ifdef	__NetBSD__
     49  1.23   mjacob #include <dev/ic/isp_netbsd.h>
     50  1.23   mjacob #endif
     51  1.23   mjacob #ifdef	__FreeBSD__
     52  1.23   mjacob #include <dev/isp/isp_freebsd.h>
     53  1.23   mjacob #endif
     54  1.23   mjacob #ifdef	__linux__
     55  1.23   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.23   mjacob  * Function prototypes.
     66  1.23   mjacob  */
     67  1.23   mjacob static void isp_parse_status
     68  1.23   mjacob __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
     69  1.10   mjacob static void isp_fibre_init __P((struct ispsoftc *));
     70  1.10   mjacob static void isp_fw_state __P((struct ispsoftc *));
     71  1.10   mjacob static void isp_dumpregs __P((struct ispsoftc *, const char *));
     72  1.23   mjacob static void isp_dumpxflist __P((struct ispsoftc *));
     73  1.10   mjacob static void isp_setdparm __P((struct ispsoftc *));
     74  1.15   mjacob static void isp_prtstst __P((ispstatusreq_t *));
     75  1.23   mjacob static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
     76   1.1      cgd 
     77   1.1      cgd /*
     78   1.1      cgd  * Reset Hardware.
     79   1.1      cgd  */
     80   1.1      cgd void
     81   1.1      cgd isp_reset(isp)
     82   1.1      cgd 	struct ispsoftc *isp;
     83   1.1      cgd {
     84   1.1      cgd 	mbreg_t mbs;
     85  1.23   mjacob 	int loops, i, dodnld = 1;
     86  1.10   mjacob 	char *revname;
     87  1.23   mjacob 	ISP_LOCKVAL_DECL;
     88   1.1      cgd 
     89   1.1      cgd 	isp->isp_state = ISP_NILSTATE;
     90   1.4   mjacob 
     91   1.4   mjacob 	/*
     92  1.10   mjacob 	 * Basic types have been set in the MD code.
     93  1.10   mjacob 	 * See if we can't figure out more here.
     94   1.4   mjacob 	 */
     95  1.23   mjacob 	isp->isp_dblev = DFLT_DBLEVEL;
     96  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
     97  1.10   mjacob 		revname = "2100";
     98  1.10   mjacob 	} else {
     99  1.10   mjacob 		i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
    100  1.10   mjacob 		switch (i) {
    101  1.10   mjacob 		default:
    102  1.23   mjacob 			PRINTF("%s: unknown ISP type %x- assuming 1020\n",
    103  1.23   mjacob 			    isp->isp_name, i);
    104  1.14   mjacob 			isp->isp_type = ISP_HA_SCSI_1020;
    105  1.23   mjacob 			revname = "10X0";
    106  1.10   mjacob 			break;
    107  1.10   mjacob 		case 1:
    108  1.10   mjacob 			revname = "1020";
    109  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1020;
    110  1.22   mjacob 			break;
    111  1.22   mjacob 		case 2:
    112  1.22   mjacob 			revname = "1020A";
    113  1.22   mjacob 			isp->isp_type = ISP_HA_SCSI_1020A;
    114  1.10   mjacob 			break;
    115  1.10   mjacob 		case 3:
    116  1.10   mjacob 			revname = "1040A";
    117  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1040A;
    118  1.10   mjacob 			break;
    119  1.10   mjacob 		case 5:
    120  1.10   mjacob 			revname = "1040B";
    121  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1040B;
    122  1.10   mjacob 			break;
    123   1.8   mjacob 		}
    124   1.4   mjacob 	}
    125   1.8   mjacob 
    126   1.1      cgd 	/*
    127  1.10   mjacob 	 * Do MD specific pre initialization
    128   1.1      cgd 	 */
    129  1.23   mjacob 	ISP_LOCK(isp);
    130  1.10   mjacob 	ISP_RESET0(isp);
    131  1.23   mjacob 	isp_setdparm(isp);	/*
    132  1.23   mjacob 				 * XXX- need to get rid of thie call
    133  1.23   mjacob 				 * XXX- prior to a reset. We need
    134  1.23   mjacob 				 * XXX- to get this now only to try
    135  1.23   mjacob 				 * XXX- and read the clock settings.
    136  1.23   mjacob 				 * XXX- typically for SBus only.
    137  1.23   mjacob 				 */
    138   1.1      cgd 	/*
    139  1.10   mjacob 	 * Hit the chip over the head with hammer,
    140  1.10   mjacob 	 * and give the ISP a chance to recover.
    141   1.1      cgd 	 */
    142   1.1      cgd 
    143  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    144  1.10   mjacob 		ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
    145  1.10   mjacob 		/*
    146  1.10   mjacob 		 * A slight delay...
    147  1.10   mjacob 		 */
    148  1.23   mjacob 		SYS_DELAY(100);
    149  1.10   mjacob 
    150  1.10   mjacob 		/*
    151  1.10   mjacob 		 * Clear data && control DMA engines.
    152  1.10   mjacob 		 */
    153  1.10   mjacob 		ISP_WRITE(isp, CDMA_CONTROL,
    154   1.1      cgd 		      DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
    155  1.10   mjacob 		ISP_WRITE(isp, DDMA_CONTROL,
    156   1.1      cgd 		      DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
    157  1.10   mjacob 	} else {
    158  1.10   mjacob 		ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
    159  1.10   mjacob 		/*
    160  1.10   mjacob 		 * A slight delay...
    161  1.10   mjacob 		 */
    162  1.23   mjacob 		SYS_DELAY(100);
    163  1.10   mjacob 		ISP_WRITE(isp, CDMA2100_CONTROL,
    164  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    165  1.10   mjacob 		ISP_WRITE(isp, TDMA2100_CONTROL,
    166  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    167  1.10   mjacob 		ISP_WRITE(isp, RDMA2100_CONTROL,
    168  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    169  1.10   mjacob 	}
    170  1.10   mjacob 
    171   1.1      cgd 	/*
    172   1.1      cgd 	 * Wait for ISP to be ready to go...
    173   1.1      cgd 	 */
    174   1.1      cgd 	loops = MBOX_DELAY_COUNT;
    175  1.10   mjacob 	for (;;) {
    176  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
    177  1.10   mjacob 			if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
    178  1.10   mjacob 				break;
    179  1.10   mjacob 		} else {
    180  1.10   mjacob 			if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
    181  1.10   mjacob 				break;
    182  1.10   mjacob 		}
    183  1.23   mjacob 		SYS_DELAY(100);
    184   1.1      cgd 		if (--loops < 0) {
    185  1.10   mjacob 			isp_dumpregs(isp, "chip reset timed out");
    186  1.23   mjacob 			ISP_UNLOCK(isp);
    187   1.1      cgd 			return;
    188   1.1      cgd 		}
    189   1.1      cgd 	}
    190   1.1      cgd 	/*
    191   1.1      cgd 	 * More initialization
    192   1.1      cgd 	 */
    193  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    194  1.10   mjacob 		ISP_WRITE(isp, BIU_CONF1, 0);
    195  1.10   mjacob 	} else {
    196  1.10   mjacob 		ISP_WRITE(isp, BIU2100_CSR, 0);
    197  1.10   mjacob 		ISP_WRITE(isp, RISC_MTR2100, 0x1212);	/* FM */
    198  1.10   mjacob 	}
    199   1.1      cgd 
    200   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
    201  1.23   mjacob 	SYS_DELAY(100);
    202   1.1      cgd 
    203  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    204   1.1      cgd 		ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1);
    205   1.1      cgd 		if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) {
    206   1.1      cgd 			ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
    207   1.1      cgd 			ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
    208   1.1      cgd 		}
    209   1.1      cgd 	}
    210   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
    211   1.1      cgd 
    212   1.1      cgd 	/*
    213   1.1      cgd 	 * Do MD specific post initialization
    214   1.1      cgd 	 */
    215   1.1      cgd 	ISP_RESET1(isp);
    216   1.1      cgd 
    217   1.1      cgd 	/*
    218   1.1      cgd 	 * Enable interrupts
    219   1.1      cgd 	 */
    220  1.10   mjacob 	ENABLE_INTS(isp);
    221   1.1      cgd 
    222   1.1      cgd 	/*
    223   1.1      cgd 	 * Do some sanity checking.
    224   1.1      cgd 	 */
    225   1.1      cgd 	mbs.param[0] = MBOX_NO_OP;
    226  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    227   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    228  1.10   mjacob 		isp_dumpregs(isp, "NOP test failed");
    229  1.23   mjacob 		ISP_UNLOCK(isp);
    230   1.1      cgd 		return;
    231   1.1      cgd 	}
    232   1.1      cgd 
    233  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    234  1.10   mjacob 		mbs.param[0] = MBOX_MAILBOX_REG_TEST;
    235  1.10   mjacob 		mbs.param[1] = 0xdead;
    236  1.10   mjacob 		mbs.param[2] = 0xbeef;
    237  1.10   mjacob 		mbs.param[3] = 0xffff;
    238  1.10   mjacob 		mbs.param[4] = 0x1111;
    239  1.10   mjacob 		mbs.param[5] = 0xa5a5;
    240  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    241   1.1      cgd 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    242  1.10   mjacob 			isp_dumpregs(isp,
    243  1.10   mjacob 				"Mailbox Register test didn't complete");
    244  1.23   mjacob 			ISP_UNLOCK(isp);
    245  1.10   mjacob 			return;
    246  1.10   mjacob 		}
    247  1.10   mjacob 		if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
    248  1.10   mjacob 		    mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
    249  1.10   mjacob 		    mbs.param[5] != 0xa5a5) {
    250  1.10   mjacob 			isp_dumpregs(isp, "Register Test Failed");
    251  1.23   mjacob 			ISP_UNLOCK(isp);
    252   1.1      cgd 			return;
    253   1.1      cgd 		}
    254  1.10   mjacob 
    255   1.1      cgd 	}
    256   1.1      cgd 
    257   1.1      cgd 	/*
    258  1.18   mjacob 	 * Download new Firmware, unless requested not to do so.
    259  1.18   mjacob 	 * This is made slightly trickier in some cases where the
    260  1.18   mjacob 	 * firmware of the ROM revision is newer than the revision
    261  1.18   mjacob 	 * compiled into the driver. So, where we used to compare
    262  1.18   mjacob 	 * versions of our f/w and the ROM f/w, now we just see
    263  1.18   mjacob 	 * whether we have f/w at all and whether a config flag
    264  1.18   mjacob 	 * has disabled our download.
    265   1.1      cgd 	 */
    266  1.23   mjacob 	if ((isp->isp_mdvec->dv_fwlen == 0) ||
    267  1.23   mjacob 	    (isp->isp_confopts & ISP_CFG_NORELOAD)) {
    268  1.10   mjacob 		dodnld = 0;
    269  1.10   mjacob 	}
    270  1.10   mjacob 
    271  1.10   mjacob 	if (dodnld) {
    272  1.10   mjacob 		for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) {
    273  1.10   mjacob 			mbs.param[0] = MBOX_WRITE_RAM_WORD;
    274  1.10   mjacob 			mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
    275  1.10   mjacob 			mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
    276  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    277  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    278  1.10   mjacob 				isp_dumpregs(isp, "f/w download failed");
    279  1.23   mjacob 				ISP_UNLOCK(isp);
    280  1.10   mjacob 				return;
    281  1.10   mjacob 			}
    282  1.10   mjacob 		}
    283  1.10   mjacob 
    284  1.10   mjacob 		if (isp->isp_mdvec->dv_fwlen) {
    285  1.10   mjacob 			/*
    286  1.10   mjacob 			 * Verify that it downloaded correctly.
    287  1.10   mjacob 			 */
    288  1.10   mjacob 			mbs.param[0] = MBOX_VERIFY_CHECKSUM;
    289  1.10   mjacob 			mbs.param[1] = isp->isp_mdvec->dv_codeorg;
    290  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    291  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    292  1.10   mjacob 				isp_dumpregs(isp, "ram checksum failure");
    293  1.23   mjacob 				ISP_UNLOCK(isp);
    294  1.10   mjacob 				return;
    295  1.10   mjacob 			}
    296  1.10   mjacob 		}
    297  1.10   mjacob 	} else {
    298  1.20   mjacob 		IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
    299   1.1      cgd 	}
    300   1.1      cgd 
    301   1.1      cgd 	/*
    302  1.10   mjacob 	 * Now start it rolling.
    303  1.10   mjacob 	 *
    304  1.10   mjacob 	 * If we didn't actually download f/w,
    305  1.10   mjacob 	 * we still need to (re)start it.
    306   1.1      cgd 	 */
    307   1.1      cgd 
    308   1.1      cgd 	mbs.param[0] = MBOX_EXEC_FIRMWARE;
    309   1.1      cgd 	mbs.param[1] = isp->isp_mdvec->dv_codeorg;
    310  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    311   1.4   mjacob 
    312  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    313  1.10   mjacob 		/*
    314  1.10   mjacob 		 * Set CLOCK RATE
    315  1.10   mjacob 		 */
    316  1.10   mjacob 		if (((sdparam *)isp->isp_param)->isp_clock) {
    317  1.10   mjacob 			mbs.param[0] = MBOX_SET_CLOCK_RATE;
    318  1.10   mjacob 			mbs.param[1] = ((sdparam *)isp->isp_param)->isp_clock;
    319  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    320  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    321  1.10   mjacob 				isp_dumpregs(isp, "failed to set CLOCKRATE");
    322  1.23   mjacob 				ISP_UNLOCK(isp);
    323  1.10   mjacob 				return;
    324  1.10   mjacob 			}
    325   1.4   mjacob 		}
    326   1.4   mjacob 	}
    327   1.1      cgd 	mbs.param[0] = MBOX_ABOUT_FIRMWARE;
    328  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    329   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    330  1.10   mjacob 		isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
    331  1.23   mjacob 		ISP_UNLOCK(isp);
    332   1.1      cgd 		return;
    333   1.1      cgd 	}
    334  1.23   mjacob 	PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n",
    335  1.10   mjacob 		isp->isp_name, revname, dodnld? "loaded" : "ROM",
    336   1.1      cgd 		mbs.param[1], mbs.param[2]);
    337  1.10   mjacob 	isp_fw_state(isp);
    338   1.1      cgd 	isp->isp_state = ISP_RESETSTATE;
    339  1.23   mjacob 	ISP_UNLOCK(isp);
    340   1.1      cgd }
    341   1.1      cgd 
    342   1.1      cgd /*
    343   1.1      cgd  * Initialize Hardware to known state
    344   1.1      cgd  */
    345   1.1      cgd void
    346   1.1      cgd isp_init(isp)
    347   1.1      cgd 	struct ispsoftc *isp;
    348   1.1      cgd {
    349  1.10   mjacob 	sdparam *sdp;
    350   1.1      cgd 	mbreg_t mbs;
    351  1.23   mjacob 	int i, l;
    352  1.23   mjacob 	ISP_LOCKVAL_DECL;
    353   1.1      cgd 
    354  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    355  1.10   mjacob 		isp_fibre_init(isp);
    356  1.10   mjacob 		return;
    357   1.1      cgd 	}
    358   1.1      cgd 
    359  1.10   mjacob 	sdp = isp->isp_param;
    360   1.1      cgd 
    361  1.10   mjacob 	/*
    362  1.10   mjacob 	 * Try and figure out if we're connected to a differential bus.
    363  1.10   mjacob 	 * You have to pause the RISC processor to read SXP registers.
    364  1.23   mjacob 	 *
    365  1.23   mjacob 	 * This, by the way, is likely broken in that it should be
    366  1.23   mjacob 	 * getting this info from NVRAM settings too.
    367  1.10   mjacob 	 */
    368  1.23   mjacob 	ISP_LOCK(isp);
    369  1.10   mjacob 	ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
    370  1.10   mjacob 	if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_SENSE) {
    371  1.10   mjacob 		sdp->isp_diffmode = 1;
    372  1.23   mjacob 		PRINTF("%s: Differential Mode\n", isp->isp_name);
    373  1.10   mjacob 	} else {
    374  1.10   mjacob 		/*
    375  1.10   mjacob 		 * Force pullups on.
    376  1.10   mjacob 		 */
    377  1.10   mjacob 		sdp->isp_req_ack_active_neg = 1;
    378  1.10   mjacob 		sdp->isp_data_line_active_neg = 1;
    379  1.10   mjacob 		sdp->isp_diffmode = 0;
    380  1.10   mjacob 	}
    381  1.10   mjacob 	ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
    382   1.1      cgd 
    383  1.10   mjacob 	mbs.param[0] = MBOX_GET_INIT_SCSI_ID;
    384  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    385   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    386  1.23   mjacob 		ISP_UNLOCK(isp);
    387  1.10   mjacob 		isp_dumpregs(isp, "failed to get initiator id");
    388   1.1      cgd 		return;
    389   1.1      cgd 	}
    390  1.10   mjacob 	if (mbs.param[1] != sdp->isp_initiator_id) {
    391  1.23   mjacob 		PRINTF("%s: setting Initiator ID to %d\n", isp->isp_name,
    392  1.10   mjacob 			sdp->isp_initiator_id);
    393  1.10   mjacob 		mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
    394  1.10   mjacob 		mbs.param[1] = sdp->isp_initiator_id;
    395  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    396  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    397  1.23   mjacob 			ISP_UNLOCK(isp);
    398  1.10   mjacob 			isp_dumpregs(isp, "failed to set initiator id");
    399  1.10   mjacob 			return;
    400  1.10   mjacob 		}
    401  1.10   mjacob 	} else {
    402  1.20   mjacob 		IDPRINTF(3, ("%s: leaving Initiator ID at %d\n", isp->isp_name,
    403  1.10   mjacob 			sdp->isp_initiator_id));
    404  1.10   mjacob 	}
    405   1.1      cgd 
    406   1.1      cgd 	mbs.param[0] = MBOX_SET_RETRY_COUNT;
    407  1.10   mjacob 	mbs.param[1] = sdp->isp_retry_count;
    408  1.10   mjacob 	mbs.param[2] = sdp->isp_retry_delay;
    409  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    410   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    411  1.23   mjacob 		ISP_UNLOCK(isp);
    412  1.10   mjacob 		isp_dumpregs(isp, "failed to set retry count and delay");
    413   1.1      cgd 		return;
    414   1.1      cgd 	}
    415   1.1      cgd 
    416   1.1      cgd 	mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
    417  1.10   mjacob 	mbs.param[1] = sdp->isp_async_data_setup;
    418  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    419   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    420  1.23   mjacob 		ISP_UNLOCK(isp);
    421  1.10   mjacob 		isp_dumpregs(isp, "failed to set async data setup time");
    422   1.1      cgd 		return;
    423   1.1      cgd 	}
    424   1.1      cgd 
    425   1.1      cgd 	mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
    426  1.10   mjacob 	mbs.param[1] =	(sdp->isp_req_ack_active_neg << 4) |
    427  1.10   mjacob 			(sdp->isp_data_line_active_neg << 5);
    428  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    429   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    430  1.23   mjacob 		ISP_UNLOCK(isp);
    431  1.10   mjacob 		isp_dumpregs(isp, "failed to set active neg state");
    432   1.1      cgd 		return;
    433   1.1      cgd 	}
    434   1.1      cgd 
    435   1.1      cgd 	mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
    436  1.10   mjacob 	mbs.param[1] = sdp->isp_tag_aging;
    437  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    438   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    439  1.23   mjacob 		ISP_UNLOCK(isp);
    440  1.10   mjacob 		isp_dumpregs(isp, "failed to set tag age limit");
    441   1.1      cgd 		return;
    442   1.1      cgd 	}
    443   1.1      cgd 
    444   1.1      cgd 	mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
    445  1.10   mjacob 	mbs.param[1] = sdp->isp_selection_timeout;
    446  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    447   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    448  1.23   mjacob 		ISP_UNLOCK(isp);
    449  1.10   mjacob 		isp_dumpregs(isp, "failed to set selection timeout");
    450   1.1      cgd 		return;
    451   1.1      cgd 	}
    452   1.1      cgd 
    453  1.20   mjacob 	IDPRINTF(2, ("%s: devparm, W=wide, S=sync, T=Tag\n", isp->isp_name));
    454   1.1      cgd 	for (i = 0; i < MAX_TARGETS; i++) {
    455  1.21   mjacob 		char bz[9];
    456  1.23   mjacob 		u_int16_t cj = sdp->isp_devparam[i].sync_period;
    457  1.10   mjacob 
    458  1.10   mjacob 		if (sdp->isp_devparam[i].dev_flags & DPARM_SYNC) {
    459  1.20   mjacob 			u_int16_t x;
    460  1.23   mjacob 			if (cj == (ISP_20M_SYNCPARMS & 0xff)) {
    461  1.20   mjacob 				x = 20;
    462  1.23   mjacob 			} else if (cj == (ISP_10M_SYNCPARMS & 0xff)) {
    463  1.20   mjacob 				x = 10;
    464  1.23   mjacob 			} else if (cj == (ISP_08M_SYNCPARMS & 0xff)) {
    465  1.20   mjacob 				x = 8;
    466  1.23   mjacob 			} else if (cj == (ISP_05M_SYNCPARMS & 0xff)) {
    467  1.20   mjacob 				x = 5;
    468  1.23   mjacob 			} else if (cj == (ISP_04M_SYNCPARMS & 0xff)) {
    469  1.20   mjacob 				x = 4;
    470  1.10   mjacob 			} else {
    471  1.20   mjacob 				x = 0;
    472  1.10   mjacob 			}
    473  1.23   mjacob 			if (x)
    474  1.23   mjacob 				sprintf(bz, "%02dMHz:", x);
    475  1.23   mjacob 			else
    476  1.23   mjacob 				sprintf(bz, "?%04x:", cj);
    477  1.10   mjacob 		} else {
    478  1.20   mjacob 			sprintf(bz, "Async:");
    479  1.10   mjacob 		}
    480  1.10   mjacob 		if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE)
    481  1.21   mjacob 			bz[6] = 'W';
    482  1.10   mjacob 		else
    483  1.21   mjacob 			bz[6] = ' ';
    484  1.10   mjacob 		if (sdp->isp_devparam[i].dev_flags & DPARM_TQING)
    485  1.21   mjacob 			bz[7] = 'T';
    486  1.10   mjacob 		else
    487  1.21   mjacob 			bz[7] = ' ';
    488  1.21   mjacob 		bz[8] = 0;
    489  1.21   mjacob 		IDPRINTF(2, (" id%x:%s", i, bz));
    490  1.10   mjacob 		if (((i+1) & 0x3) == 0)
    491  1.20   mjacob 			IDPRINTF(2, ("\n"));
    492  1.10   mjacob 		if (sdp->isp_devparam[i].dev_enable == 0)
    493   1.1      cgd 			continue;
    494   1.1      cgd 
    495  1.20   mjacob 		/*
    496  1.20   mjacob 		 * It is not safe to run the 1020 in ultra mode.
    497  1.20   mjacob 		 */
    498  1.20   mjacob 		if (isp->isp_type == ISP_HA_SCSI_1020 &&
    499  1.23   mjacob 		    cj == (ISP_20M_SYNCPARMS & 0xff)) {
    500  1.23   mjacob 			PRINTF("%s: an ISP1020 set to Ultra Speed- derating.\n",
    501  1.20   mjacob 				isp->isp_name);
    502  1.20   mjacob 			sdp->isp_devparam[i].sync_offset =
    503  1.20   mjacob 				ISP_10M_SYNCPARMS >> 8;
    504  1.20   mjacob 			sdp->isp_devparam[i].sync_period =
    505  1.20   mjacob 				ISP_10M_SYNCPARMS & 0xff;
    506  1.20   mjacob 		}
    507   1.1      cgd 		mbs.param[0] = MBOX_SET_TARGET_PARAMS;
    508   1.1      cgd 		mbs.param[1] = i << 8;
    509  1.10   mjacob 		mbs.param[2] = sdp->isp_devparam[i].dev_flags << 8;
    510   1.1      cgd 		mbs.param[3] =
    511  1.10   mjacob 			(sdp->isp_devparam[i].sync_offset << 8) |
    512  1.10   mjacob 			(sdp->isp_devparam[i].sync_period);
    513  1.10   mjacob 
    514  1.23   mjacob 		IDPRINTF(3, ("\n%s: target %d flags %x offset %x period %x\n",
    515  1.10   mjacob 			     isp->isp_name, i, sdp->isp_devparam[i].dev_flags,
    516  1.10   mjacob 			     sdp->isp_devparam[i].sync_offset,
    517  1.10   mjacob 			     sdp->isp_devparam[i].sync_period));
    518  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    519   1.1      cgd 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    520  1.23   mjacob 			PRINTF("%s: failed to set parameters for target %d\n",
    521  1.10   mjacob 				isp->isp_name, i);
    522  1.23   mjacob 			PRINTF("%s: flags %x offset %x period %x\n",
    523  1.10   mjacob 				isp->isp_name, sdp->isp_devparam[i].dev_flags,
    524  1.10   mjacob 				sdp->isp_devparam[i].sync_offset,
    525  1.10   mjacob 				sdp->isp_devparam[i].sync_period);
    526  1.10   mjacob 			mbs.param[0] = MBOX_SET_TARGET_PARAMS;
    527  1.10   mjacob 			mbs.param[1] = i << 8;
    528  1.10   mjacob 			mbs.param[2] = DPARM_DEFAULT << 8;
    529  1.10   mjacob 			mbs.param[3] = ISP_10M_SYNCPARMS;
    530  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    531  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    532  1.23   mjacob 				ISP_UNLOCK(isp);
    533  1.23   mjacob 				PRINTF("%s: failed even to set defaults\n",
    534  1.10   mjacob 					isp->isp_name);
    535  1.10   mjacob 				return;
    536  1.10   mjacob 			}
    537   1.1      cgd 		}
    538   1.1      cgd 		for (l = 0; l < MAX_LUNS; l++) {
    539   1.1      cgd 			mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
    540   1.1      cgd 			mbs.param[1] = (i << 8) | l;
    541  1.10   mjacob 			mbs.param[2] = sdp->isp_max_queue_depth;
    542  1.10   mjacob 			mbs.param[3] = sdp->isp_devparam[i].exc_throttle;
    543  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    544   1.1      cgd 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    545  1.23   mjacob 				ISP_UNLOCK(isp);
    546  1.10   mjacob 				isp_dumpregs(isp, "failed to set device queue "
    547  1.10   mjacob 				       "parameters");
    548   1.1      cgd 				return;
    549   1.1      cgd 			}
    550   1.1      cgd 		}
    551   1.1      cgd 	}
    552   1.1      cgd 
    553   1.7  thorpej 	/*
    554   1.7  thorpej 	 * Set up DMA for the request and result mailboxes.
    555   1.7  thorpej 	 */
    556   1.7  thorpej 	if (ISP_MBOXDMASETUP(isp)) {
    557  1.23   mjacob 		ISP_UNLOCK(isp);
    558  1.23   mjacob 		PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
    559   1.1      cgd 		return;
    560   1.1      cgd 	}
    561  1.10   mjacob 
    562   1.1      cgd 	mbs.param[0] = MBOX_INIT_RES_QUEUE;
    563  1.23   mjacob 	mbs.param[1] = RESULT_QUEUE_LEN;
    564   1.7  thorpej 	mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16);
    565   1.7  thorpej 	mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff);
    566   1.1      cgd 	mbs.param[4] = 0;
    567   1.6   mjacob 	mbs.param[5] = 0;
    568  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    569   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    570  1.23   mjacob 		ISP_UNLOCK(isp);
    571  1.10   mjacob 		isp_dumpregs(isp, "set of response queue failed");
    572   1.1      cgd 		return;
    573   1.1      cgd 	}
    574   1.1      cgd 	isp->isp_residx = 0;
    575   1.1      cgd 
    576   1.1      cgd 	mbs.param[0] = MBOX_INIT_REQ_QUEUE;
    577  1.23   mjacob 	mbs.param[1] = RQUEST_QUEUE_LEN;
    578   1.7  thorpej 	mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16);
    579   1.7  thorpej 	mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
    580   1.1      cgd 	mbs.param[4] = 0;
    581  1.10   mjacob 	mbs.param[5] = 0;
    582  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    583   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    584  1.23   mjacob 		ISP_UNLOCK(isp);
    585  1.10   mjacob 		isp_dumpregs(isp, "set of request queue failed");
    586   1.1      cgd 		return;
    587   1.1      cgd 	}
    588   1.1      cgd 	isp->isp_reqidx = 0;
    589   1.1      cgd 
    590   1.1      cgd 	/*
    591   1.1      cgd 	 * Unfortunately, this is the only way right now for
    592   1.1      cgd 	 * forcing a sync renegotiation. If we boot off of
    593   1.1      cgd 	 * an Alpha, it's put the chip in SYNC mode, but we
    594   1.1      cgd 	 * haven't necessarily set up the parameters the
    595   1.1      cgd 	 * same, so we'll have to yank the reset line to
    596   1.1      cgd 	 * get everyone to renegotiate.
    597   1.1      cgd 	 */
    598   1.1      cgd 
    599   1.1      cgd 	mbs.param[0] = MBOX_BUS_RESET;
    600   1.1      cgd 	mbs.param[1] = 2;
    601  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    602   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    603  1.23   mjacob 		ISP_UNLOCK(isp);
    604  1.10   mjacob 		isp_dumpregs(isp, "SCSI bus reset failed");
    605   1.1      cgd 	}
    606  1.10   mjacob 	/*
    607  1.10   mjacob 	 * This is really important to have set after a bus reset.
    608  1.10   mjacob 	 */
    609   1.1      cgd 	isp->isp_sendmarker = 1;
    610  1.23   mjacob 	ISP_UNLOCK(isp);
    611   1.1      cgd 	isp->isp_state = ISP_INITSTATE;
    612   1.1      cgd }
    613   1.1      cgd 
    614  1.10   mjacob static void
    615  1.10   mjacob isp_fibre_init(isp)
    616  1.10   mjacob 	struct ispsoftc *isp;
    617  1.10   mjacob {
    618  1.10   mjacob 	fcparam *fcp;
    619  1.10   mjacob 	isp_icb_t *icbp;
    620  1.10   mjacob 	mbreg_t mbs;
    621  1.23   mjacob 	int count;
    622  1.23   mjacob 	u_int8_t lwfs;
    623  1.23   mjacob 	ISP_LOCKVAL_DECL;
    624  1.10   mjacob 
    625  1.10   mjacob 	fcp = isp->isp_param;
    626  1.10   mjacob 
    627  1.10   mjacob 	fcp->isp_retry_count = 0;
    628  1.10   mjacob 	fcp->isp_retry_delay = 1;
    629  1.10   mjacob 
    630  1.23   mjacob 	ISP_LOCK(isp);
    631  1.10   mjacob 	mbs.param[0] = MBOX_SET_RETRY_COUNT;
    632  1.10   mjacob 	mbs.param[1] = fcp->isp_retry_count;
    633  1.10   mjacob 	mbs.param[2] = fcp->isp_retry_delay;
    634  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    635  1.10   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    636  1.23   mjacob 		ISP_UNLOCK(isp);
    637  1.10   mjacob 		isp_dumpregs(isp, "failed to set retry count and delay");
    638  1.10   mjacob 		return;
    639  1.10   mjacob 	}
    640  1.10   mjacob 
    641  1.10   mjacob 	if (ISP_MBOXDMASETUP(isp)) {
    642  1.23   mjacob 		ISP_UNLOCK(isp);
    643  1.23   mjacob 		PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name);
    644  1.10   mjacob 		return;
    645  1.10   mjacob 	}
    646  1.10   mjacob 
    647  1.10   mjacob 	icbp = (isp_icb_t *) fcp->isp_scratch;
    648  1.10   mjacob 	bzero(icbp, sizeof (*icbp));
    649  1.10   mjacob #if 0
    650  1.10   mjacob 	icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
    651  1.10   mjacob 	MAKE_NODE_NAME(isp, icbp);
    652  1.23   mjacob 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
    653  1.23   mjacob 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
    654  1.10   mjacob 	icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
    655  1.10   mjacob 	icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
    656  1.10   mjacob 	icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
    657  1.10   mjacob 	icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
    658  1.10   mjacob #endif
    659  1.10   mjacob 	icbp->icb_version = 1;
    660  1.10   mjacob 	icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
    661  1.10   mjacob 	icbp->icb_maxalloc = 256;
    662  1.10   mjacob 	icbp->icb_execthrottle = 16;
    663  1.10   mjacob 	icbp->icb_retry_delay = 5;
    664  1.10   mjacob 	icbp->icb_retry_count = 0;
    665  1.10   mjacob 	MAKE_NODE_NAME(isp, icbp);
    666  1.23   mjacob 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
    667  1.23   mjacob 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
    668  1.10   mjacob 	icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
    669  1.10   mjacob 	icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
    670  1.10   mjacob 	icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
    671  1.10   mjacob 	icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
    672  1.10   mjacob 
    673  1.10   mjacob 	mbs.param[0] = MBOX_INIT_FIRMWARE;
    674  1.10   mjacob 	mbs.param[1] = 0;
    675  1.10   mjacob 	mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16);
    676  1.10   mjacob 	mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff);
    677  1.10   mjacob 	mbs.param[4] = 0;
    678  1.10   mjacob 	mbs.param[5] = 0;
    679  1.10   mjacob 	mbs.param[6] = 0;
    680  1.10   mjacob 	mbs.param[7] = 0;
    681  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    682  1.10   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    683  1.23   mjacob 		ISP_UNLOCK(isp);
    684  1.10   mjacob 		isp_dumpregs(isp, "INIT FIRMWARE failed");
    685  1.10   mjacob 		return;
    686  1.10   mjacob 	}
    687  1.10   mjacob 	isp->isp_reqidx = 0;
    688  1.10   mjacob 	isp->isp_residx = 0;
    689  1.10   mjacob 
    690  1.10   mjacob 	/*
    691  1.23   mjacob 	 * Wait up to 12 seconds for FW to go to READY state.
    692  1.23   mjacob 	 * This used to be 3 seconds, but that lost.
    693  1.10   mjacob 	 *
    694  1.10   mjacob 	 * This is all very much not right. The problem here
    695  1.10   mjacob 	 * is that the cable may not be plugged in, or there
    696  1.10   mjacob 	 * may be many many members of the loop that haven't
    697  1.10   mjacob 	 * been logged into.
    698  1.10   mjacob 	 *
    699  1.10   mjacob 	 * This model of doing things doesn't support dynamic
    700  1.10   mjacob 	 * attachment, so we just plain lose (for now).
    701  1.10   mjacob 	 */
    702  1.23   mjacob 	lwfs = FW_CONFIG_WAIT;
    703  1.23   mjacob 	for (count = 0; count < 12000; count++) {
    704  1.10   mjacob 		isp_fw_state(isp);
    705  1.23   mjacob 		if (lwfs != fcp->isp_fwstate) {
    706  1.23   mjacob 			PRINTF("%s: Firmware State %s -> %s\n", isp->isp_name,
    707  1.23   mjacob 			    fw_statename(lwfs), fw_statename(fcp->isp_fwstate));
    708  1.23   mjacob 			lwfs = fcp->isp_fwstate;
    709  1.23   mjacob 		}
    710  1.23   mjacob 		if (fcp->isp_fwstate == FW_READY) {
    711  1.10   mjacob 			break;
    712  1.23   mjacob 		}
    713  1.23   mjacob 		SYS_DELAY(1000);	/* wait one millisecond */
    714  1.10   mjacob 	}
    715  1.13   mjacob 	isp->isp_sendmarker = 1;
    716  1.10   mjacob 
    717  1.10   mjacob 	/*
    718  1.23   mjacob 	 * Get our Loop ID
    719  1.23   mjacob 	 * (if possible)
    720  1.10   mjacob 	 */
    721  1.23   mjacob 	if (fcp->isp_fwstate == FW_READY) {
    722  1.10   mjacob 		mbs.param[0] = MBOX_GET_LOOP_ID;
    723  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    724  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    725  1.10   mjacob 			isp_dumpregs(isp, "GET LOOP ID failed");
    726  1.23   mjacob 			ISP_UNLOCK(isp);
    727  1.10   mjacob 			return;
    728  1.10   mjacob 		}
    729  1.10   mjacob 		fcp->isp_loopid = mbs.param[1];
    730  1.10   mjacob 		if (fcp->isp_loopid) {
    731  1.23   mjacob 			PRINTF("%s: Loop ID 0x%x\n", isp->isp_name,
    732  1.10   mjacob 				fcp->isp_loopid);
    733  1.10   mjacob 		}
    734  1.23   mjacob 		isp->isp_state = ISP_INITSTATE;
    735  1.10   mjacob 	} else {
    736  1.23   mjacob 		PRINTF("%s: failed to go to FW READY state- will not attach\n",
    737  1.23   mjacob 		    isp->isp_name);
    738  1.23   mjacob 	}
    739  1.23   mjacob 	ISP_UNLOCK(isp);
    740   1.1      cgd }
    741   1.1      cgd 
    742   1.1      cgd /*
    743  1.23   mjacob  * Free any associated resources prior to decommissioning and
    744  1.23   mjacob  * set the card to a known state (so it doesn't wake up and kick
    745  1.23   mjacob  * us when we aren't expecting it to).
    746  1.23   mjacob  *
    747  1.23   mjacob  * Locks are held before coming here.
    748   1.1      cgd  */
    749   1.1      cgd void
    750   1.1      cgd isp_uninit(isp)
    751   1.1      cgd 	struct ispsoftc *isp;
    752   1.1      cgd {
    753  1.23   mjacob 	/*
    754  1.23   mjacob 	 * Leave with interrupts disabled.
    755  1.23   mjacob 	 */
    756  1.23   mjacob 	DISABLE_INTS(isp);
    757   1.1      cgd 
    758   1.1      cgd 	/*
    759  1.23   mjacob 	 * Stop the watchdog timer (if started).
    760   1.1      cgd 	 */
    761  1.23   mjacob 	STOP_WATCHDOG(isp_watch, isp);
    762   1.1      cgd }
    763   1.1      cgd 
    764  1.23   mjacob 
    765   1.1      cgd /*
    766  1.23   mjacob  * Start a command. Locking is assumed done in the caller.
    767   1.1      cgd  */
    768  1.23   mjacob 
    769  1.23   mjacob int32_t
    770   1.1      cgd ispscsicmd(xs)
    771  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
    772   1.1      cgd {
    773   1.1      cgd 	struct ispsoftc *isp;
    774   1.1      cgd 	u_int8_t iptr, optr;
    775  1.10   mjacob 	union {
    776  1.10   mjacob 		ispreq_t *_reqp;
    777  1.10   mjacob 		ispreqt2_t *_t2reqp;
    778  1.10   mjacob 	} _u;
    779  1.10   mjacob #define	reqp	_u._reqp
    780  1.10   mjacob #define	t2reqp	_u._t2reqp
    781  1.16   mjacob #define	UZSIZE	max(sizeof (ispreq_t), sizeof (ispreqt2_t))
    782  1.23   mjacob 	int i;
    783   1.1      cgd 
    784  1.23   mjacob 	XS_INITERR(xs);
    785  1.23   mjacob 	isp = XS_ISP(xs);
    786   1.1      cgd 
    787  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    788  1.23   mjacob 		if (XS_CDBLEN(xs) > 12) {
    789  1.23   mjacob 			PRINTF("%s: unsupported cdb length for fibre (%d)\n",
    790  1.23   mjacob 				isp->isp_name, XS_CDBLEN(xs));
    791  1.23   mjacob 			XS_SETERR(xs, HBA_BOTCH);
    792  1.23   mjacob 			return (CMD_COMPLETE);
    793  1.10   mjacob 		}
    794  1.10   mjacob 	}
    795   1.1      cgd 	optr = ISP_READ(isp, OUTMAILBOX4);
    796   1.1      cgd 	iptr = isp->isp_reqidx;
    797   1.1      cgd 
    798  1.10   mjacob 	reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
    799  1.23   mjacob 	iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
    800   1.1      cgd 	if (iptr == optr) {
    801  1.23   mjacob 		PRINTF("%s: Request Queue Overflow\n", isp->isp_name);
    802  1.23   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    803  1.23   mjacob 		return (CMD_EAGAIN);
    804   1.1      cgd 	}
    805   1.1      cgd 
    806  1.23   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    807  1.13   mjacob 		DISABLE_INTS(isp);
    808  1.23   mjacob 	}
    809  1.13   mjacob 
    810   1.1      cgd 	if (isp->isp_sendmarker) {
    811  1.10   mjacob 		ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
    812   1.1      cgd 
    813   1.1      cgd 		bzero((void *) marker, sizeof (*marker));
    814   1.1      cgd 		marker->req_header.rqs_entry_count = 1;
    815   1.1      cgd 		marker->req_header.rqs_entry_type = RQSTYPE_MARKER;
    816   1.1      cgd 		marker->req_modifier = SYNC_ALL;
    817   1.1      cgd 
    818   1.1      cgd 		isp->isp_sendmarker = 0;
    819   1.1      cgd 
    820  1.23   mjacob 		if (((iptr + 1) & (RQUEST_QUEUE_LEN - 1)) == optr) {
    821   1.1      cgd 			ISP_WRITE(isp, INMAILBOX4, iptr);
    822   1.1      cgd 			isp->isp_reqidx = iptr;
    823  1.13   mjacob 
    824  1.23   mjacob 			if (isp->isp_type & ISP_HA_FC) {
    825  1.13   mjacob 				ENABLE_INTS(isp);
    826  1.23   mjacob 			}
    827  1.23   mjacob 			PRINTF("%s: Request Queue Overflow+\n", isp->isp_name);
    828  1.23   mjacob 			XS_SETERR(xs, HBA_BOTCH);
    829  1.23   mjacob 			return (CMD_EAGAIN);
    830   1.1      cgd 		}
    831  1.10   mjacob 		reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
    832  1.23   mjacob 		iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
    833   1.1      cgd 	}
    834   1.1      cgd 
    835  1.16   mjacob 	bzero((void *) reqp, UZSIZE);
    836  1.10   mjacob 	reqp->req_header.rqs_entry_count = 1;
    837  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    838  1.10   mjacob 		reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
    839  1.10   mjacob 	} else {
    840  1.10   mjacob 		reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
    841  1.10   mjacob 	}
    842  1.10   mjacob 	reqp->req_header.rqs_flags = 0;
    843  1.10   mjacob 	reqp->req_header.rqs_seqno = isp->isp_seqno++;
    844   1.1      cgd 
    845  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
    846   1.1      cgd 		if (isp->isp_xflist[i] == NULL)
    847   1.1      cgd 			break;
    848   1.1      cgd 	}
    849  1.23   mjacob 	if (i == RQUEST_QUEUE_LEN) {
    850  1.23   mjacob 		if (isp->isp_type & ISP_HA_FC)
    851  1.23   mjacob 			ENABLE_INTS(isp);
    852  1.23   mjacob 		PRINTF("%s: ran out of xflist pointers?????\n", isp->isp_name);
    853  1.23   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    854  1.23   mjacob 		return (CMD_EAGAIN);
    855   1.1      cgd 	} else {
    856  1.10   mjacob 		/*
    857  1.10   mjacob 		 * Never have a handle that is zero, so
    858  1.10   mjacob 		 * set req_handle off by one.
    859  1.10   mjacob 		 */
    860   1.1      cgd 		isp->isp_xflist[i] = xs;
    861  1.10   mjacob 		reqp->req_handle = i+1;
    862   1.1      cgd 	}
    863   1.1      cgd 
    864  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    865  1.10   mjacob 		/*
    866  1.10   mjacob 		 * See comment in isp_intr
    867  1.10   mjacob 		 */
    868  1.23   mjacob 		XS_RESID(xs) = 0;
    869  1.10   mjacob 		/*
    870  1.16   mjacob 		 * Fibre Channel always requires some kind of tag.
    871  1.23   mjacob 		 * If we're marked as "Can't Tag", just do simple
    872  1.23   mjacob 		 * instead of ordered tags. It's pretty clear to me
    873  1.23   mjacob 		 * that we shouldn't do head of queue tagging in
    874  1.23   mjacob 		 * this case.
    875  1.10   mjacob 		 */
    876  1.23   mjacob 		if (XS_CANTAG(xs)) {
    877  1.23   mjacob 			t2reqp->req_flags = XS_KINDOF_TAG(xs);
    878  1.10   mjacob 		} else {
    879  1.23   mjacob  			t2reqp->req_flags = REQFLAG_STAG;
    880  1.10   mjacob 		}
    881  1.10   mjacob 	} else {
    882  1.23   mjacob 		sdparam *sdp = (sdparam *)isp->isp_param;
    883  1.23   mjacob 		if ((sdp->isp_devparam[XS_TGT(xs)].dev_flags & DPARM_TQING) &&
    884  1.23   mjacob 		    XS_CANTAG(xs)) {
    885  1.23   mjacob 			reqp->req_flags = XS_KINDOF_TAG(xs);
    886  1.23   mjacob 		} else {
    887  1.10   mjacob 			reqp->req_flags = 0;
    888  1.10   mjacob 		}
    889  1.10   mjacob 	}
    890  1.23   mjacob 	reqp->req_lun_trn = XS_LUN(xs);
    891  1.23   mjacob 	reqp->req_target = XS_TGT(xs);
    892  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    893  1.23   mjacob 		reqp->req_cdblen = XS_CDBLEN(xs);
    894  1.10   mjacob 	}
    895  1.23   mjacob 	bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs));
    896   1.1      cgd 
    897  1.23   mjacob 	IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
    898  1.23   mjacob 	    XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno,
    899  1.23   mjacob 	    reqp->req_cdb[0], XS_XFRLEN(xs)));
    900   1.1      cgd 
    901  1.23   mjacob 	reqp->req_time = XS_TIME(xs) / 1000;
    902  1.23   mjacob 	if (reqp->req_time == 0 && XS_TIME(xs))
    903  1.10   mjacob 		reqp->req_time = 1;
    904  1.10   mjacob 	if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) {
    905  1.13   mjacob 		if (isp->isp_type & ISP_HA_FC)
    906  1.13   mjacob 			ENABLE_INTS(isp);
    907  1.23   mjacob 		/* dmasetup sets actual error */
    908  1.23   mjacob 		return (CMD_COMPLETE);
    909   1.1      cgd 	}
    910  1.23   mjacob 	XS_SETERR(xs, HBA_NOERROR);
    911   1.1      cgd 	ISP_WRITE(isp, INMAILBOX4, iptr);
    912   1.1      cgd 	isp->isp_reqidx = iptr;
    913  1.23   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    914  1.13   mjacob 		ENABLE_INTS(isp);
    915   1.3      cgd 	}
    916  1.23   mjacob 	isp->isp_nactive++;
    917  1.23   mjacob 	return (CMD_QUEUED);
    918  1.10   mjacob #undef	reqp
    919  1.10   mjacob #undef	t2reqp
    920   1.1      cgd }
    921   1.1      cgd 
    922   1.1      cgd /*
    923  1.23   mjacob  * isp control
    924  1.23   mjacob  * Locks (ints blocked) assumed held.
    925   1.1      cgd  */
    926   1.1      cgd 
    927   1.1      cgd int
    928  1.23   mjacob isp_control(isp, ctl, arg)
    929   1.1      cgd 	struct ispsoftc *isp;
    930  1.23   mjacob 	ispctl_t ctl;
    931  1.23   mjacob 	void *arg;
    932   1.1      cgd {
    933  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
    934  1.23   mjacob 	mbreg_t mbs;
    935  1.23   mjacob 	int i;
    936   1.3      cgd 
    937  1.23   mjacob 	switch (ctl) {
    938  1.23   mjacob 	default:
    939  1.23   mjacob 		PRINTF("%s: isp_control unknown control op %x\n",
    940  1.23   mjacob 		    isp->isp_name, ctl);
    941  1.23   mjacob 		break;
    942   1.3      cgd 
    943  1.23   mjacob 	case ISPCTL_RESET_BUS:
    944  1.23   mjacob 		/*
    945  1.23   mjacob 		 * Right now, for Fibre, we'll punt on loop reset.
    946  1.23   mjacob 		 * The reason is that it takes a really long time
    947  1.23   mjacob 		 * to go through the renegotiation after a LIP,
    948  1.23   mjacob 		 * and we really have to hang out until it's done
    949  1.23   mjacob 		 * to see what's there after a LIP- until the
    950  1.23   mjacob 		 * LIP is done and the loop comes back up,
    951  1.23   mjacob 		 * commands just fail (and, yes, we could handle
    952  1.23   mjacob 		 * that a little better).
    953  1.23   mjacob 		 */
    954  1.23   mjacob 		if (isp->isp_type & ISP_HA_FC) {
    955  1.23   mjacob 			PRINTF("%s: Skipping FC resets\n", isp->isp_name);
    956   1.3      cgd 			return (0);
    957  1.23   mjacob 		}
    958  1.23   mjacob 		mbs.param[0] = MBOX_BUS_RESET;
    959  1.23   mjacob 		mbs.param[1] = 2;	/* 'delay', in seconds */
    960  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
    961  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    962  1.23   mjacob 			isp_dumpregs(isp, "isp_control SCSI bus reset failed");
    963  1.23   mjacob 			break;
    964  1.23   mjacob 		}
    965  1.23   mjacob 		/*
    966  1.23   mjacob 		 * This is really important to have set after a bus reset.
    967  1.23   mjacob 		 */
    968  1.23   mjacob 		isp->isp_sendmarker = 1;
    969  1.23   mjacob 		PRINTF("%s: Bus Reset\n", isp->isp_name);
    970  1.23   mjacob 		return (0);
    971  1.23   mjacob 
    972  1.23   mjacob         case ISPCTL_RESET_DEV:
    973  1.23   mjacob 		/*
    974  1.23   mjacob 		 * Note that under parallel SCSI, this issues a BDR message.
    975  1.23   mjacob 		 * Under FC, we could probably be using ABORT TASK SET
    976  1.23   mjacob 		 * command.
    977  1.23   mjacob 		 */
    978  1.23   mjacob 
    979  1.23   mjacob 		mbs.param[0] = MBOX_ABORT_TARGET;
    980  1.23   mjacob 		mbs.param[1] = ((long)arg) << 8;
    981  1.23   mjacob 		mbs.param[2] = 2;	/* 'delay', in seconds */
    982  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
    983  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    984  1.23   mjacob 			isp_dumpregs(isp, "SCSI Target  reset failed");
    985  1.23   mjacob 			break;
    986  1.23   mjacob 		}
    987  1.23   mjacob 		PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name,
    988  1.23   mjacob 		    (int) ((long) arg));
    989  1.23   mjacob 		isp->isp_sendmarker = 1;
    990  1.23   mjacob 		return (0);
    991  1.23   mjacob 
    992  1.23   mjacob         case ISPCTL_ABORT_CMD:
    993  1.23   mjacob 		xs = (ISP_SCSI_XFER_T *) arg;
    994  1.23   mjacob 		for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
    995  1.23   mjacob 			if (xs == isp->isp_xflist[i]) {
    996  1.23   mjacob 				break;
    997  1.23   mjacob 			}
    998  1.23   mjacob 		}
    999  1.23   mjacob 		if (i == RQUEST_QUEUE_LEN) {
   1000  1.23   mjacob 			PRINTF("%s: isp_control- cannot find command to abort "
   1001  1.23   mjacob 			    "in active list\n", isp->isp_name);
   1002  1.23   mjacob 			break;
   1003  1.23   mjacob 		}
   1004  1.23   mjacob 		mbs.param[0] = MBOX_ABORT;
   1005  1.23   mjacob 		mbs.param[1] = XS_TGT(xs) | XS_LUN(xs);
   1006  1.23   mjacob 		mbs.param[2] = (i+1) >> 16;
   1007  1.23   mjacob 		mbs.param[3] = (i+1) & 0xffff;
   1008  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
   1009  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1010  1.23   mjacob 			PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n",
   1011  1.23   mjacob 			    isp->isp_name, mbs.param[0]);
   1012  1.23   mjacob 			break;
   1013  1.23   mjacob 		}
   1014  1.23   mjacob 		PRINTF("%s: command for target %d lun %d was aborted\n",
   1015  1.23   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   1016  1.23   mjacob 		return (0);
   1017   1.1      cgd 	}
   1018  1.23   mjacob 	return (-1);
   1019   1.1      cgd }
   1020   1.1      cgd 
   1021  1.23   mjacob /*
   1022  1.23   mjacob  * Interrupt Service Routine(s).
   1023  1.23   mjacob  *
   1024  1.23   mjacob  * External (OS) framework has done the appropriate locking,
   1025  1.23   mjacob  * and the locking will be held throughout this function.
   1026  1.23   mjacob  */
   1027  1.23   mjacob 
   1028   1.1      cgd int
   1029   1.1      cgd isp_intr(arg)
   1030   1.1      cgd 	void *arg;
   1031   1.1      cgd {
   1032  1.23   mjacob 	ISP_SCSI_XFER_T *clist[RQUEST_QUEUE_LEN], *xs;
   1033   1.1      cgd 	struct ispsoftc *isp = arg;
   1034   1.1      cgd 	u_int16_t iptr, optr, isr;
   1035  1.23   mjacob 	int i, ndone = 0;
   1036   1.1      cgd 
   1037   1.1      cgd 	isr = ISP_READ(isp, BIU_ISR);
   1038  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1039  1.10   mjacob 		if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
   1040  1.10   mjacob 			if (isr) {
   1041  1.20   mjacob 				IDPRINTF(4, ("%s: isp_intr isr=%x\n",
   1042  1.10   mjacob 					     isp->isp_name, isr));
   1043  1.10   mjacob 			}
   1044  1.10   mjacob 			return (0);
   1045  1.10   mjacob 		}
   1046  1.10   mjacob 	} else {
   1047  1.10   mjacob 		if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
   1048  1.10   mjacob 			if (isr) {
   1049  1.20   mjacob 				IDPRINTF(4, ("%s: isp_intr isr=%x\n",
   1050  1.10   mjacob 					     isp->isp_name, isr));
   1051  1.10   mjacob 			}
   1052  1.10   mjacob 			return (0);
   1053   1.1      cgd 		}
   1054   1.1      cgd 	}
   1055   1.1      cgd 
   1056   1.1      cgd 	optr = isp->isp_residx;
   1057   1.1      cgd 	if (ISP_READ(isp, BIU_SEMA) & 1) {
   1058  1.23   mjacob 		u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
   1059  1.23   mjacob 		switch (mbox) {
   1060   1.1      cgd 		case ASYNC_BUS_RESET:
   1061  1.23   mjacob 			PRINTF("%s: SCSI bus reset detected\n", isp->isp_name);
   1062  1.23   mjacob 			isp->isp_sendmarker = 1;
   1063  1.23   mjacob 			break;
   1064  1.23   mjacob 		case ASYNC_SYSTEM_ERROR:
   1065  1.23   mjacob 			mbox = ISP_READ(isp, OUTMAILBOX1);
   1066  1.23   mjacob 			PRINTF("%s: Internal System Error RISC Addr %x\n",
   1067  1.23   mjacob 			    isp->isp_name, mbox);
   1068  1.23   mjacob 			break;
   1069  1.23   mjacob 		case ASYNC_RQS_XFER_ERR:
   1070  1.23   mjacob 			PRINTF("%s: Request Queue Transfer Error\n",
   1071  1.23   mjacob 			    isp->isp_name);
   1072  1.23   mjacob 			break;
   1073  1.23   mjacob 		case ASYNC_RSP_XFER_ERR:
   1074  1.23   mjacob 			PRINTF("%s: Response Queue Transfer Error\n",
   1075  1.23   mjacob 			    isp->isp_name);
   1076  1.23   mjacob 			break;
   1077  1.23   mjacob 		case ASYNC_QWAKEUP:
   1078  1.23   mjacob 			/* don't need to be chatty */
   1079  1.23   mjacob 			mbox = ISP_READ(isp, OUTMAILBOX4);
   1080  1.23   mjacob 			break;
   1081   1.1      cgd 		case ASYNC_TIMEOUT_RESET:
   1082  1.23   mjacob 			PRINTF("%s: timeout initiated SCSI bus reset\n",
   1083  1.23   mjacob 			    isp->isp_name);
   1084   1.1      cgd 			isp->isp_sendmarker = 1;
   1085   1.1      cgd 			break;
   1086  1.10   mjacob 		case ASYNC_LIP_OCCURRED:
   1087  1.23   mjacob 			PRINTF("%s: LIP occurred\n", isp->isp_name);
   1088  1.10   mjacob 			break;
   1089  1.10   mjacob 		case ASYNC_LOOP_UP:
   1090  1.23   mjacob 			PRINTF("%s: Loop UP\n", isp->isp_name);
   1091  1.10   mjacob 			break;
   1092  1.10   mjacob 		case ASYNC_LOOP_DOWN:
   1093  1.23   mjacob 			PRINTF("%s: Loop DOWN\n", isp->isp_name);
   1094  1.16   mjacob 			break;
   1095  1.16   mjacob 		case ASYNC_LOOP_RESET:
   1096  1.23   mjacob 			PRINTF("%s: Loop RESET\n", isp->isp_name);
   1097  1.10   mjacob 			break;
   1098   1.1      cgd 		default:
   1099  1.23   mjacob 			PRINTF("%s: async %x\n", isp->isp_name, mbox);
   1100   1.1      cgd 			break;
   1101   1.1      cgd 		}
   1102   1.1      cgd 		ISP_WRITE(isp, BIU_SEMA, 0);
   1103   1.1      cgd 	}
   1104   1.1      cgd 
   1105  1.10   mjacob 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   1106  1.10   mjacob 	iptr = ISP_READ(isp, OUTMAILBOX5);
   1107  1.10   mjacob 	if (optr == iptr) {
   1108  1.20   mjacob 		IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n",
   1109  1.10   mjacob 			isr, optr, iptr));
   1110  1.10   mjacob 	}
   1111  1.10   mjacob 	ENABLE_INTS(isp);
   1112  1.10   mjacob 
   1113   1.1      cgd 	while (optr != iptr) {
   1114   1.1      cgd 		ispstatusreq_t *sp;
   1115   1.1      cgd 		int buddaboom = 0;
   1116   1.1      cgd 
   1117   1.7  thorpej 		sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
   1118   1.1      cgd 
   1119  1.23   mjacob 		optr = (optr + 1) & (RESULT_QUEUE_LEN - 1);
   1120   1.1      cgd 		if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
   1121  1.23   mjacob 			PRINTF("%s: not RESPONSE in RESPONSE Queue (0x%x)\n",
   1122   1.1      cgd 				isp->isp_name, sp->req_header.rqs_entry_type);
   1123   1.1      cgd 			if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
   1124   1.1      cgd 				ISP_WRITE(isp, INMAILBOX5, optr);
   1125   1.1      cgd 				continue;
   1126   1.1      cgd 			}
   1127   1.1      cgd 			buddaboom = 1;
   1128   1.1      cgd 		}
   1129   1.1      cgd 
   1130   1.1      cgd 		if (sp->req_header.rqs_flags & 0xf) {
   1131   1.1      cgd 			if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
   1132   1.1      cgd 				ISP_WRITE(isp, INMAILBOX5, optr);
   1133   1.1      cgd 				continue;
   1134   1.1      cgd 			}
   1135  1.23   mjacob 			PRINTF("%s: rqs_flags=%x", isp->isp_name,
   1136   1.1      cgd 				sp->req_header.rqs_flags & 0xf);
   1137  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
   1138  1.23   mjacob 				PRINTF("%s: internal queues full\n",
   1139  1.23   mjacob 				    isp->isp_name);
   1140  1.23   mjacob 				/* XXXX: this command *could* get restarted */
   1141  1.23   mjacob 				buddaboom++;
   1142  1.23   mjacob 			}
   1143  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
   1144  1.23   mjacob 				PRINTF("%s: bad header\n", isp->isp_name);
   1145  1.23   mjacob 				buddaboom++;
   1146  1.23   mjacob 			}
   1147  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
   1148  1.23   mjacob 				PRINTF("%s: bad request packet\n",
   1149  1.23   mjacob 				    isp->isp_name);
   1150  1.23   mjacob 				buddaboom++;
   1151  1.23   mjacob 			}
   1152   1.1      cgd 		}
   1153  1.23   mjacob 		if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) {
   1154  1.23   mjacob 			PRINTF("%s: bad request handle %d\n", isp->isp_name,
   1155   1.1      cgd 				sp->req_handle);
   1156   1.1      cgd 			ISP_WRITE(isp, INMAILBOX5, optr);
   1157   1.1      cgd 			continue;
   1158   1.1      cgd 		}
   1159  1.23   mjacob 		xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1];
   1160   1.1      cgd 		if (xs == NULL) {
   1161  1.23   mjacob 			PRINTF("%s: NULL xs in xflist (handle %x)\n",
   1162  1.23   mjacob 			    isp->isp_name, sp->req_handle);
   1163  1.23   mjacob 			isp_dumpxflist(isp);
   1164   1.1      cgd 			ISP_WRITE(isp, INMAILBOX5, optr);
   1165   1.1      cgd 			continue;
   1166   1.1      cgd 		}
   1167  1.10   mjacob 		isp->isp_xflist[sp->req_handle - 1] = NULL;
   1168   1.1      cgd 		if (sp->req_status_flags & RQSTF_BUS_RESET) {
   1169   1.1      cgd 			isp->isp_sendmarker = 1;
   1170   1.1      cgd 		}
   1171   1.1      cgd 		if (buddaboom) {
   1172  1.23   mjacob 			XS_SETERR(xs, HBA_BOTCH);
   1173   1.1      cgd 		}
   1174  1.23   mjacob 		XS_STS(xs) = sp->req_scsi_status & 0xff;
   1175  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   1176  1.10   mjacob 			if (sp->req_state_flags & RQSF_GOT_SENSE) {
   1177  1.23   mjacob 				bcopy(sp->req_sense_data, XS_SNSP(xs),
   1178  1.23   mjacob 					XS_SNSLEN(xs));
   1179  1.23   mjacob 				XS_SNS_IS_VALID(xs);
   1180  1.10   mjacob 			}
   1181  1.10   mjacob 		} else {
   1182  1.23   mjacob 			if (XS_STS(xs) == SCSI_CHECK) {
   1183  1.23   mjacob 				XS_SNS_IS_VALID(xs);
   1184  1.23   mjacob 				bcopy(sp->req_sense_data, XS_SNSP(xs),
   1185  1.23   mjacob 					XS_SNSLEN(xs));
   1186  1.10   mjacob 				sp->req_state_flags |= RQSF_GOT_SENSE;
   1187  1.10   mjacob 			}
   1188   1.1      cgd 		}
   1189  1.23   mjacob 		if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) {
   1190  1.23   mjacob 			XS_SETERR(xs, HBA_TGTBSY);
   1191  1.10   mjacob 		}
   1192   1.1      cgd 
   1193   1.1      cgd 		if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
   1194  1.23   mjacob 			if (XS_NOERR(xs) && sp->req_completion_status)
   1195  1.23   mjacob 				isp_parse_status(isp, sp, xs);
   1196   1.1      cgd 		} else {
   1197  1.23   mjacob 			PRINTF("%s: unknown return %x\n", isp->isp_name,
   1198   1.1      cgd 				sp->req_header.rqs_entry_type);
   1199  1.23   mjacob 			if (XS_NOERR(xs))
   1200  1.23   mjacob 				XS_SETERR(xs, HBA_BOTCH);
   1201   1.1      cgd 		}
   1202  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   1203  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1204  1.10   mjacob 		} else if (sp->req_scsi_status & RQCS_RU) {
   1205  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1206  1.20   mjacob 			IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
   1207  1.23   mjacob 				XS_XFRLEN(xs), sp->req_resid));
   1208  1.10   mjacob 		}
   1209  1.23   mjacob 		if (XS_XFRLEN(xs)) {
   1210  1.10   mjacob 			ISP_DMAFREE(isp, xs, sp->req_handle - 1);
   1211   1.1      cgd 		}
   1212  1.23   mjacob 		/*
   1213  1.23   mjacob 		 * XXX: If we have a check condition, but no Sense Data,
   1214  1.23   mjacob 		 * XXX: mark it as an error (ARQ failed). We need to
   1215  1.23   mjacob 		 * XXX: to do a more distinct job because there may
   1216  1.23   mjacob 		 * XXX: cases where ARQ is disabled.
   1217  1.23   mjacob 		 */
   1218  1.23   mjacob 		if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) {
   1219  1.23   mjacob 			if (XS_NOERR(xs)) {
   1220  1.23   mjacob 				PRINTF("%s: ARQ Failure\n", isp->isp_name);
   1221  1.23   mjacob 				XS_SETERR(xs, HBA_ARQFAIL);
   1222  1.23   mjacob 			}
   1223  1.23   mjacob 		}
   1224  1.23   mjacob 		if ((isp->isp_dblev >= 5) ||
   1225  1.23   mjacob 		    (isp->isp_dblev > 2 && !XS_NOERR(xs))) {
   1226  1.23   mjacob 			PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x",
   1227  1.23   mjacob 			    isp->isp_name, XS_TGT(xs), XS_LUN(xs),
   1228  1.23   mjacob 			    sp->req_header.rqs_seqno, XS_XFRLEN(xs),
   1229  1.23   mjacob 			    XS_RESID(xs), XS_STS(xs));
   1230  1.10   mjacob 			if (sp->req_state_flags & RQSF_GOT_SENSE) {
   1231  1.23   mjacob 				PRINTF(" Skey: %x", XS_SNSKEY(xs));
   1232  1.23   mjacob 				if (!(XS_IS_SNS_VALID(xs))) {
   1233  1.23   mjacob 					PRINTF(" BUT NOT SET");
   1234  1.10   mjacob 				}
   1235   1.1      cgd 			}
   1236  1.23   mjacob 			PRINTF(" XS_ERR=0x%x\n", XS_ERR(xs));
   1237   1.1      cgd 		}
   1238  1.23   mjacob 
   1239   1.1      cgd 		ISP_WRITE(isp, INMAILBOX5, optr);
   1240  1.23   mjacob 		isp->isp_nactive--;
   1241  1.23   mjacob 		if (isp->isp_nactive < 0)
   1242  1.23   mjacob 			isp->isp_nactive = 0;
   1243  1.23   mjacob 		clist[ndone++] = xs;	/* defer completion call until later */
   1244   1.1      cgd 	}
   1245   1.1      cgd 	isp->isp_residx = optr;
   1246  1.23   mjacob 	for (i = 0; i < ndone; i++)
   1247  1.23   mjacob 		XS_CMD_DONE(clist[i]);
   1248   1.1      cgd 	return (1);
   1249   1.1      cgd }
   1250   1.1      cgd 
   1251   1.1      cgd /*
   1252   1.1      cgd  * Support routines.
   1253   1.1      cgd  */
   1254   1.1      cgd 
   1255  1.23   mjacob static void
   1256  1.10   mjacob isp_parse_status(isp, sp, xs)
   1257   1.1      cgd 	struct ispsoftc *isp;
   1258   1.1      cgd 	ispstatusreq_t *sp;
   1259  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
   1260   1.1      cgd {
   1261   1.1      cgd 	switch (sp->req_completion_status) {
   1262   1.1      cgd 	case RQCS_COMPLETE:
   1263  1.23   mjacob 		XS_SETERR(xs, HBA_NOERROR);
   1264  1.23   mjacob 		return;
   1265  1.10   mjacob 
   1266   1.1      cgd 	case RQCS_INCOMPLETE:
   1267   1.1      cgd 		if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
   1268  1.23   mjacob 			IDPRINTF(2, ("Selection Timeout\n"));
   1269  1.23   mjacob 			XS_SETERR(xs, HBA_SELTIMEOUT);
   1270  1.23   mjacob 			return;
   1271   1.1      cgd 		}
   1272  1.23   mjacob 		PRINTF("%s: incomplete, state %x\n",
   1273   1.1      cgd 			isp->isp_name, sp->req_state_flags);
   1274   1.1      cgd 		break;
   1275  1.15   mjacob 
   1276  1.15   mjacob 	case RQCS_TRANSPORT_ERROR:
   1277  1.23   mjacob 		PRINTF("%s: transport error\n", isp->isp_name);
   1278  1.15   mjacob 		isp_prtstst(sp);
   1279  1.15   mjacob 		break;
   1280  1.15   mjacob 
   1281  1.10   mjacob 	case RQCS_DATA_OVERRUN:
   1282  1.10   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   1283  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1284  1.10   mjacob 			break;
   1285  1.10   mjacob 		}
   1286  1.23   mjacob 		XS_SETERR(xs, HBA_DATAOVR);
   1287  1.23   mjacob 		return;
   1288  1.10   mjacob 
   1289   1.1      cgd 	case RQCS_DATA_UNDERRUN:
   1290  1.10   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   1291  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1292  1.23   mjacob 			/* an UNDERRUN is not a botch ??? */
   1293  1.10   mjacob 		}
   1294  1.23   mjacob 		XS_SETERR(xs, HBA_NOERROR);
   1295  1.23   mjacob 		return;
   1296  1.10   mjacob 
   1297   1.1      cgd 	case RQCS_TIMEOUT:
   1298  1.23   mjacob 		XS_SETERR(xs, HBA_CMDTIMEOUT);
   1299  1.23   mjacob 		return;
   1300  1.10   mjacob 
   1301   1.1      cgd 	case RQCS_RESET_OCCURRED:
   1302  1.23   mjacob 		PRINTF("%s: reset occurred, %d active\n", isp->isp_name,
   1303  1.23   mjacob 			isp->isp_nactive);
   1304   1.1      cgd 		isp->isp_sendmarker = 1;
   1305  1.23   mjacob 		XS_SETERR(xs, HBA_BUSRESET);
   1306  1.23   mjacob 		return;
   1307  1.10   mjacob 
   1308   1.1      cgd 	case RQCS_ABORTED:
   1309  1.23   mjacob 		PRINTF("%s: command aborted\n", isp->isp_name);
   1310   1.1      cgd 		isp->isp_sendmarker = 1;
   1311  1.23   mjacob 		XS_SETERR(xs, HBA_ABORTED);
   1312  1.23   mjacob 		return;
   1313  1.10   mjacob 
   1314  1.10   mjacob 	case RQCS_PORT_UNAVAILABLE:
   1315  1.10   mjacob 		/*
   1316  1.10   mjacob 		 * No such port on the loop. Moral equivalent of SELTIMEO
   1317  1.10   mjacob 		 */
   1318  1.23   mjacob 		XS_SETERR(xs, HBA_SELTIMEOUT);
   1319  1.23   mjacob 		return;
   1320  1.10   mjacob 
   1321  1.10   mjacob 	case RQCS_PORT_LOGGED_OUT:
   1322  1.23   mjacob 		PRINTF("%s: port logout for target %d\n",
   1323  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   1324  1.10   mjacob 		break;
   1325  1.10   mjacob 
   1326  1.10   mjacob 	case RQCS_PORT_CHANGED:
   1327  1.23   mjacob 		PRINTF("%s: port changed for target %d\n",
   1328  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   1329  1.10   mjacob 		break;
   1330  1.10   mjacob 
   1331  1.10   mjacob 	case RQCS_PORT_BUSY:
   1332  1.23   mjacob 		PRINTF("%s: port busy for target %d\n",
   1333  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   1334  1.23   mjacob 		XS_SETERR(xs, HBA_TGTBSY);
   1335  1.23   mjacob 		return;
   1336  1.10   mjacob 
   1337   1.1      cgd 	default:
   1338  1.23   mjacob 		PRINTF("%s: comp status %x\n", isp->isp_name,
   1339   1.1      cgd 		       sp->req_completion_status);
   1340   1.1      cgd 		break;
   1341   1.1      cgd 	}
   1342  1.23   mjacob 	XS_SETERR(xs, HBA_BOTCH);
   1343   1.1      cgd }
   1344   1.1      cgd 
   1345   1.1      cgd #define	HINIB(x)			((x) >> 0x4)
   1346   1.1      cgd #define	LONIB(x)			((x)  & 0xf)
   1347   1.1      cgd #define MAKNIB(a, b)			(((a) << 4) | (b))
   1348   1.1      cgd static u_int8_t mbpcnt[] = {
   1349  1.10   mjacob 	MAKNIB(1, 1),	/* 0x00: MBOX_NO_OP */
   1350  1.10   mjacob 	MAKNIB(5, 5),	/* 0x01: MBOX_LOAD_RAM */
   1351  1.10   mjacob 	MAKNIB(2, 0),	/* 0x02: MBOX_EXEC_FIRMWARE */
   1352  1.10   mjacob 	MAKNIB(5, 5),	/* 0x03: MBOX_DUMP_RAM */
   1353  1.10   mjacob 	MAKNIB(3, 3),	/* 0x04: MBOX_WRITE_RAM_WORD */
   1354  1.10   mjacob 	MAKNIB(2, 3),	/* 0x05: MBOX_READ_RAM_WORD */
   1355  1.10   mjacob 	MAKNIB(6, 6),	/* 0x06: MBOX_MAILBOX_REG_TEST */
   1356  1.10   mjacob 	MAKNIB(2, 3),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
   1357  1.10   mjacob 	MAKNIB(1, 3),	/* 0x08: MBOX_ABOUT_FIRMWARE */
   1358  1.10   mjacob 	MAKNIB(0, 0),	/* 0x09: */
   1359  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0a: */
   1360  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0b: */
   1361  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0c: */
   1362  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0d: */
   1363  1.10   mjacob 	MAKNIB(1, 2),	/* 0x0e: MBOX_CHECK_FIRMWARE */
   1364  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0f: */
   1365  1.10   mjacob 	MAKNIB(5, 5),	/* 0x10: MBOX_INIT_REQ_QUEUE */
   1366  1.10   mjacob 	MAKNIB(6, 6),	/* 0x11: MBOX_INIT_RES_QUEUE */
   1367  1.10   mjacob 	MAKNIB(4, 4),	/* 0x12: MBOX_EXECUTE_IOCB */
   1368  1.10   mjacob 	MAKNIB(2, 2),	/* 0x13: MBOX_WAKE_UP	*/
   1369  1.10   mjacob 	MAKNIB(1, 6),	/* 0x14: MBOX_STOP_FIRMWARE */
   1370  1.10   mjacob 	MAKNIB(4, 4),	/* 0x15: MBOX_ABORT */
   1371  1.10   mjacob 	MAKNIB(2, 2),	/* 0x16: MBOX_ABORT_DEVICE */
   1372  1.10   mjacob 	MAKNIB(3, 3),	/* 0x17: MBOX_ABORT_TARGET */
   1373  1.10   mjacob 	MAKNIB(2, 2),	/* 0x18: MBOX_BUS_RESET */
   1374  1.10   mjacob 	MAKNIB(2, 3),	/* 0x19: MBOX_STOP_QUEUE */
   1375  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1a: MBOX_START_QUEUE */
   1376  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1b: MBOX_SINGLE_STEP_QUEUE */
   1377  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1c: MBOX_ABORT_QUEUE */
   1378  1.10   mjacob 	MAKNIB(2, 4),	/* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
   1379  1.10   mjacob 	MAKNIB(0, 0),	/* 0x1e: */
   1380  1.10   mjacob 	MAKNIB(1, 3),	/* 0x1f: MBOX_GET_FIRMWARE_STATUS */
   1381  1.10   mjacob 	MAKNIB(1, 2),	/* 0x20: MBOX_GET_INIT_SCSI_ID */
   1382  1.10   mjacob 	MAKNIB(1, 2),	/* 0x21: MBOX_GET_SELECT_TIMEOUT */
   1383  1.10   mjacob 	MAKNIB(1, 3),	/* 0x22: MBOX_GET_RETRY_COUNT	*/
   1384  1.10   mjacob 	MAKNIB(1, 2),	/* 0x23: MBOX_GET_TAG_AGE_LIMIT */
   1385  1.10   mjacob 	MAKNIB(1, 2),	/* 0x24: MBOX_GET_CLOCK_RATE */
   1386  1.10   mjacob 	MAKNIB(1, 2),	/* 0x25: MBOX_GET_ACT_NEG_STATE */
   1387  1.10   mjacob 	MAKNIB(1, 2),	/* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
   1388  1.10   mjacob 	MAKNIB(1, 3),	/* 0x27: MBOX_GET_PCI_PARAMS */
   1389  1.10   mjacob 	MAKNIB(2, 4),	/* 0x28: MBOX_GET_TARGET_PARAMS */
   1390  1.10   mjacob 	MAKNIB(2, 4),	/* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
   1391  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2a: */
   1392  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2b: */
   1393  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2c: */
   1394  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2d: */
   1395  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2e: */
   1396  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2f: */
   1397  1.10   mjacob 	MAKNIB(2, 2),	/* 0x30: MBOX_SET_INIT_SCSI_ID */
   1398  1.10   mjacob 	MAKNIB(2, 2),	/* 0x31: MBOX_SET_SELECT_TIMEOUT */
   1399  1.10   mjacob 	MAKNIB(3, 3),	/* 0x32: MBOX_SET_RETRY_COUNT	*/
   1400  1.10   mjacob 	MAKNIB(2, 2),	/* 0x33: MBOX_SET_TAG_AGE_LIMIT */
   1401  1.10   mjacob 	MAKNIB(2, 2),	/* 0x34: MBOX_SET_CLOCK_RATE */
   1402  1.10   mjacob 	MAKNIB(2, 2),	/* 0x35: MBOX_SET_ACTIVE_NEG_STATE */
   1403  1.10   mjacob 	MAKNIB(2, 2),	/* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
   1404  1.10   mjacob 	MAKNIB(3, 3),	/* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
   1405  1.10   mjacob 	MAKNIB(4, 4),	/* 0x38: MBOX_SET_TARGET_PARAMS */
   1406  1.10   mjacob 	MAKNIB(4, 4),	/* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
   1407  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3a: */
   1408  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3b: */
   1409  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3c: */
   1410  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3d: */
   1411  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3e: */
   1412  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3f: */
   1413  1.10   mjacob 	MAKNIB(1, 2),	/* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
   1414  1.10   mjacob 	MAKNIB(6, 1),	/* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
   1415  1.10   mjacob 	MAKNIB(2, 3),	/* 0x42: MBOX_EXEC_BIOS_IOCB */
   1416  1.10   mjacob 	MAKNIB(0, 0),	/* 0x43: */
   1417  1.10   mjacob 	MAKNIB(0, 0),	/* 0x44: */
   1418  1.10   mjacob 	MAKNIB(0, 0),	/* 0x45: */
   1419  1.10   mjacob 	MAKNIB(0, 0),	/* 0x46: */
   1420  1.10   mjacob 	MAKNIB(0, 0),	/* 0x47: */
   1421  1.10   mjacob 	MAKNIB(0, 0),	/* 0x48: */
   1422  1.10   mjacob 	MAKNIB(0, 0),	/* 0x49: */
   1423  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4a: */
   1424  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4b: */
   1425  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4c: */
   1426  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4d: */
   1427  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4e: */
   1428  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4f: */
   1429  1.10   mjacob 	MAKNIB(0, 0),	/* 0x50: */
   1430  1.10   mjacob 	MAKNIB(0, 0),	/* 0x51: */
   1431  1.10   mjacob 	MAKNIB(0, 0),	/* 0x52: */
   1432  1.10   mjacob 	MAKNIB(0, 0),	/* 0x53: */
   1433  1.10   mjacob 	MAKNIB(8, 0),	/* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */
   1434  1.10   mjacob 	MAKNIB(0, 0),	/* 0x55: */
   1435  1.10   mjacob 	MAKNIB(0, 0),	/* 0x56: */
   1436  1.10   mjacob 	MAKNIB(0, 0),	/* 0x57: */
   1437  1.10   mjacob 	MAKNIB(0, 0),	/* 0x58: */
   1438  1.10   mjacob 	MAKNIB(0, 0),	/* 0x59: */
   1439  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5a: */
   1440  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5b: */
   1441  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5c: */
   1442  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5d: */
   1443  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5e: */
   1444  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5f: */
   1445  1.10   mjacob 	MAKNIB(8, 6),	/* 0x60: MBOX_INIT_FIRMWARE */
   1446  1.10   mjacob 	MAKNIB(0, 0),	/* 0x60: MBOX_GET_INIT_CONTROL_BLOCK  (FORMAT?) */
   1447  1.10   mjacob 	MAKNIB(2, 1),	/* 0x62: MBOX_INIT_LIP */
   1448  1.10   mjacob 	MAKNIB(8, 1),	/* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
   1449  1.10   mjacob 	MAKNIB(8, 1),	/* 0x64: MBOX_GET_PORT_DB */
   1450  1.10   mjacob 	MAKNIB(3, 1),	/* 0x65: MBOX_CLEAR_ACA */
   1451  1.10   mjacob 	MAKNIB(3, 1),	/* 0x66: MBOX_TARGET_RESET */
   1452  1.10   mjacob 	MAKNIB(3, 1),	/* 0x67: MBOX_CLEAR_TASK_SET */
   1453  1.10   mjacob 	MAKNIB(3, 1),	/* 0x69: MBOX_ABORT_TASK_SET */
   1454  1.13   mjacob 	MAKNIB(1, 2)	/* 0x69: MBOX_GET_FW_STATE */
   1455   1.1      cgd };
   1456   1.1      cgd #define	NMBCOM	(sizeof (mbpcnt) / sizeof (mbpcnt[0]))
   1457   1.1      cgd 
   1458  1.10   mjacob static void
   1459   1.1      cgd isp_mboxcmd(isp, mbp)
   1460   1.1      cgd 	struct ispsoftc *isp;
   1461   1.1      cgd 	mbreg_t *mbp;
   1462   1.1      cgd {
   1463   1.1      cgd 	int outparam, inparam;
   1464   1.1      cgd 	int loops;
   1465  1.10   mjacob 	u_int8_t opcode;
   1466   1.1      cgd 
   1467  1.10   mjacob 	if (mbp->param[0] == ISP2100_SET_PCI_PARAM) {
   1468  1.10   mjacob 		opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS;
   1469  1.10   mjacob 		inparam = 4;
   1470  1.10   mjacob 		outparam = 4;
   1471  1.10   mjacob 		goto command_known;
   1472  1.10   mjacob 	} else if (mbp->param[0] > NMBCOM) {
   1473  1.23   mjacob 		PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]);
   1474  1.10   mjacob 		return;
   1475   1.1      cgd 	}
   1476   1.1      cgd 
   1477  1.10   mjacob 	opcode = mbp->param[0];
   1478   1.1      cgd 	inparam = HINIB(mbpcnt[mbp->param[0]]);
   1479   1.1      cgd 	outparam =  LONIB(mbpcnt[mbp->param[0]]);
   1480  1.10   mjacob 
   1481   1.1      cgd 	if (inparam == 0 && outparam == 0) {
   1482  1.23   mjacob 		PRINTF("%s: no parameters for %x\n", isp->isp_name,
   1483   1.1      cgd 			mbp->param[0]);
   1484  1.10   mjacob 		return;
   1485   1.1      cgd 	}
   1486   1.1      cgd 
   1487  1.10   mjacob 
   1488  1.10   mjacob command_known:
   1489   1.1      cgd 	/*
   1490   1.1      cgd 	 * Make sure we can send some words..
   1491   1.1      cgd 	 */
   1492   1.1      cgd 
   1493   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   1494   1.1      cgd 	while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) {
   1495  1.23   mjacob 		SYS_DELAY(100);
   1496   1.1      cgd 		if (--loops < 0) {
   1497  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
   1498  1.10   mjacob 			return;
   1499   1.1      cgd 		}
   1500   1.1      cgd 	}
   1501   1.1      cgd 
   1502   1.1      cgd 	/*
   1503   1.1      cgd 	 * Write input parameters
   1504   1.1      cgd 	 */
   1505   1.1      cgd 	switch (inparam) {
   1506  1.10   mjacob 	case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0;
   1507  1.10   mjacob 	case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0;
   1508   1.1      cgd 	case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0;
   1509   1.1      cgd 	case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0;
   1510   1.1      cgd 	case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0;
   1511   1.1      cgd 	case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0;
   1512   1.1      cgd 	case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0;
   1513   1.1      cgd 	case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0;
   1514   1.1      cgd 	}
   1515   1.1      cgd 
   1516   1.1      cgd 	/*
   1517   1.1      cgd 	 * Clear semaphore on mailbox registers
   1518   1.1      cgd 	 */
   1519   1.1      cgd 	ISP_WRITE(isp, BIU_SEMA, 0);
   1520   1.1      cgd 
   1521   1.1      cgd 	/*
   1522   1.1      cgd 	 * Clear RISC int condition.
   1523   1.1      cgd 	 */
   1524   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   1525   1.1      cgd 
   1526   1.1      cgd 	/*
   1527   1.1      cgd 	 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
   1528   1.1      cgd 	 */
   1529   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
   1530   1.1      cgd 
   1531   1.1      cgd 	/*
   1532  1.10   mjacob 	 * Wait until RISC int is set, except 2100
   1533   1.1      cgd 	 */
   1534  1.10   mjacob 	if ((isp->isp_type & ISP_HA_FC) == 0) {
   1535  1.10   mjacob 		loops = MBOX_DELAY_COUNT;
   1536  1.10   mjacob 		while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
   1537  1.23   mjacob 			SYS_DELAY(100);
   1538  1.10   mjacob 			if (--loops < 0) {
   1539  1.23   mjacob 				PRINTF("%s: isp_mboxcmd timeout #2\n",
   1540  1.10   mjacob 				    isp->isp_name);
   1541  1.10   mjacob 				return;
   1542  1.10   mjacob 			}
   1543   1.1      cgd 		}
   1544   1.1      cgd 	}
   1545   1.1      cgd 
   1546   1.1      cgd 	/*
   1547   1.1      cgd 	 * Check to make sure that the semaphore has been set.
   1548   1.1      cgd 	 */
   1549   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   1550   1.1      cgd 	while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) {
   1551  1.23   mjacob 		SYS_DELAY(100);
   1552   1.1      cgd 		if (--loops < 0) {
   1553  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
   1554  1.10   mjacob 			return;
   1555   1.1      cgd 		}
   1556   1.1      cgd 	}
   1557   1.1      cgd 
   1558   1.1      cgd 	/*
   1559   1.1      cgd 	 * Make sure that the MBOX_BUSY has gone away
   1560   1.1      cgd 	 */
   1561   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   1562   1.1      cgd 	while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
   1563  1.23   mjacob 		SYS_DELAY(100);
   1564   1.1      cgd 		if (--loops < 0) {
   1565  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
   1566  1.10   mjacob 			return;
   1567   1.1      cgd 		}
   1568   1.1      cgd 	}
   1569   1.1      cgd 
   1570   1.1      cgd 
   1571   1.1      cgd 	/*
   1572   1.1      cgd 	 * Pick up output parameters.
   1573   1.1      cgd 	 */
   1574   1.1      cgd 	switch (outparam) {
   1575  1.10   mjacob 	case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7);
   1576  1.10   mjacob 	case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6);
   1577   1.1      cgd 	case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5);
   1578   1.1      cgd 	case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4);
   1579   1.1      cgd 	case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3);
   1580   1.1      cgd 	case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2);
   1581   1.1      cgd 	case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1);
   1582   1.1      cgd 	case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0);
   1583   1.1      cgd 	}
   1584   1.1      cgd 
   1585   1.1      cgd 	/*
   1586   1.1      cgd 	 * Clear RISC int.
   1587   1.1      cgd 	 */
   1588   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   1589   1.1      cgd 
   1590   1.1      cgd 	/*
   1591   1.1      cgd 	 * Release semaphore on mailbox registers
   1592   1.1      cgd 	 */
   1593   1.1      cgd 	ISP_WRITE(isp, BIU_SEMA, 0);
   1594  1.10   mjacob 
   1595  1.10   mjacob 	/*
   1596  1.10   mjacob 	 * Just to be chatty here...
   1597  1.10   mjacob 	 */
   1598  1.10   mjacob 	switch(mbp->param[0]) {
   1599  1.10   mjacob 	case MBOX_COMMAND_COMPLETE:
   1600  1.10   mjacob 		break;
   1601  1.10   mjacob 	case MBOX_INVALID_COMMAND:
   1602  1.10   mjacob 		/*
   1603  1.10   mjacob 		 * GET_CLOCK_RATE can fail a lot
   1604  1.10   mjacob 		 * So can a couple of other commands.
   1605  1.10   mjacob 		 */
   1606  1.20   mjacob 		if (isp->isp_dblev > 2  && opcode != MBOX_GET_CLOCK_RATE) {
   1607  1.23   mjacob 			PRINTF("%s: mbox cmd %x failed with INVALID_COMMAND\n",
   1608  1.10   mjacob 				isp->isp_name, opcode);
   1609  1.10   mjacob 		}
   1610  1.10   mjacob 		break;
   1611  1.10   mjacob 	case MBOX_HOST_INTERFACE_ERROR:
   1612  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
   1613  1.10   mjacob 			isp->isp_name, opcode);
   1614  1.10   mjacob 		break;
   1615  1.10   mjacob 	case MBOX_TEST_FAILED:
   1616  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
   1617  1.10   mjacob 			isp->isp_name, opcode);
   1618  1.10   mjacob 		break;
   1619  1.10   mjacob 	case MBOX_COMMAND_ERROR:
   1620  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
   1621  1.10   mjacob 			isp->isp_name, opcode);
   1622  1.10   mjacob 		break;
   1623  1.10   mjacob 	case MBOX_COMMAND_PARAM_ERROR:
   1624  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n",
   1625  1.10   mjacob 			isp->isp_name, opcode);
   1626  1.10   mjacob 		break;
   1627  1.10   mjacob 
   1628  1.10   mjacob 	case ASYNC_LIP_OCCURRED:
   1629  1.10   mjacob 		break;
   1630  1.10   mjacob 
   1631  1.10   mjacob 	default:
   1632  1.10   mjacob 		/*
   1633  1.10   mjacob 		 * The expected return of EXEC_FIRMWARE is zero.
   1634  1.10   mjacob 		 */
   1635  1.10   mjacob 		if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) ||
   1636  1.10   mjacob 		    (opcode != MBOX_EXEC_FIRMWARE)) {
   1637  1.23   mjacob 			PRINTF("%s: mbox cmd %x failed with error %x\n",
   1638  1.10   mjacob 				isp->isp_name, opcode, mbp->param[0]);
   1639  1.10   mjacob 		}
   1640  1.10   mjacob 		break;
   1641  1.10   mjacob 	}
   1642   1.4   mjacob }
   1643   1.4   mjacob 
   1644  1.23   mjacob void
   1645  1.23   mjacob isp_lostcmd(struct ispsoftc *isp, ISP_SCSI_XFER_T *xs)
   1646   1.4   mjacob {
   1647   1.4   mjacob 	mbreg_t mbs;
   1648  1.10   mjacob 
   1649   1.4   mjacob 	mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
   1650  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   1651   1.4   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1652  1.10   mjacob 		isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
   1653   1.4   mjacob 		return;
   1654   1.4   mjacob 	}
   1655  1.10   mjacob 	if (mbs.param[1]) {
   1656  1.23   mjacob 		PRINTF("%s: %d commands on completion queue\n",
   1657  1.10   mjacob 		       isp->isp_name, mbs.param[1]);
   1658  1.10   mjacob 	}
   1659  1.23   mjacob 	if (XS_NULL(xs))
   1660   1.4   mjacob 		return;
   1661   1.4   mjacob 
   1662   1.4   mjacob 	mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
   1663  1.23   mjacob 	mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
   1664  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   1665   1.4   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1666  1.10   mjacob 		isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS");
   1667  1.10   mjacob 		return;
   1668  1.10   mjacob 	}
   1669  1.23   mjacob 	PRINTF("%s: lost command for target %d lun %d, %d active of %d, "
   1670  1.23   mjacob 		"Queue State: %x\n", isp->isp_name, XS_TGT(xs),
   1671  1.23   mjacob 		XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]);
   1672  1.10   mjacob 
   1673  1.10   mjacob 	isp_dumpregs(isp, "lost command");
   1674  1.10   mjacob 	/*
   1675  1.10   mjacob 	 * XXX: Need to try and do something to recover.
   1676  1.10   mjacob 	 */
   1677  1.10   mjacob }
   1678  1.10   mjacob 
   1679  1.10   mjacob static void
   1680  1.10   mjacob isp_dumpregs(struct ispsoftc *isp, const char *msg)
   1681  1.10   mjacob {
   1682  1.23   mjacob 	PRINTF("%s: %s\n", isp->isp_name, msg);
   1683  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI)
   1684  1.23   mjacob 		PRINTF("    biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
   1685  1.10   mjacob 	else
   1686  1.23   mjacob 		PRINTF("    biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
   1687  1.23   mjacob 	PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
   1688  1.10   mjacob 	       ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
   1689  1.23   mjacob 	PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR));
   1690  1.10   mjacob 
   1691  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
   1692  1.10   mjacob 		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
   1693  1.23   mjacob 		PRINTF("    cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
   1694  1.10   mjacob 			ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
   1695  1.10   mjacob 			ISP_READ(isp, CDMA_FIFO_STS));
   1696  1.23   mjacob 		PRINTF("    ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
   1697  1.10   mjacob 			ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
   1698  1.10   mjacob 			ISP_READ(isp, DDMA_FIFO_STS));
   1699  1.23   mjacob 		PRINTF("    sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
   1700  1.10   mjacob 			ISP_READ(isp, SXP_INTERRUPT),
   1701  1.10   mjacob 			ISP_READ(isp, SXP_GROSS_ERR),
   1702  1.10   mjacob 			ISP_READ(isp, SXP_PINS_CONTROL));
   1703  1.10   mjacob 		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
   1704  1.10   mjacob 	}
   1705  1.10   mjacob 	ISP_DUMPREGS(isp);
   1706  1.10   mjacob }
   1707  1.10   mjacob 
   1708  1.10   mjacob static void
   1709  1.23   mjacob isp_dumpxflist(struct ispsoftc *isp)
   1710  1.23   mjacob {
   1711  1.23   mjacob 	volatile ISP_SCSI_XFER_T *xs;
   1712  1.23   mjacob 	int i, hdp;
   1713  1.23   mjacob 
   1714  1.23   mjacob 	for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) {
   1715  1.23   mjacob 		xs = isp->isp_xflist[i];
   1716  1.23   mjacob 		if (xs == NULL) {
   1717  1.23   mjacob 			continue;
   1718  1.23   mjacob 		}
   1719  1.23   mjacob 		if (hdp == 0) {
   1720  1.23   mjacob 			PRINTF("%s: active requests\n", isp->isp_name);
   1721  1.23   mjacob 			hdp++;
   1722  1.23   mjacob 		}
   1723  1.23   mjacob 		PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n",
   1724  1.23   mjacob 		    i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs));
   1725  1.23   mjacob 	}
   1726  1.23   mjacob }
   1727  1.23   mjacob 
   1728  1.23   mjacob static void
   1729  1.10   mjacob isp_fw_state(struct ispsoftc *isp)
   1730  1.10   mjacob {
   1731  1.10   mjacob 	mbreg_t mbs;
   1732  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1733  1.10   mjacob 		int once = 0;
   1734  1.10   mjacob 		fcparam *fcp = isp->isp_param;
   1735  1.10   mjacob again:
   1736  1.10   mjacob 		mbs.param[0] = MBOX_GET_FW_STATE;
   1737  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
   1738  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1739  1.10   mjacob 			if (mbs.param[0] == ASYNC_LIP_OCCURRED) {
   1740  1.10   mjacob 				if (!once++) {
   1741  1.10   mjacob 					goto again;
   1742  1.10   mjacob 				}
   1743  1.10   mjacob 			}
   1744  1.10   mjacob 			isp_dumpregs(isp, "GET FIRMWARE STATE failed");
   1745  1.10   mjacob 			return;
   1746  1.10   mjacob 		}
   1747  1.10   mjacob 		fcp->isp_fwstate = mbs.param[1];
   1748  1.10   mjacob 	}
   1749  1.10   mjacob }
   1750  1.10   mjacob 
   1751  1.10   mjacob static void
   1752  1.10   mjacob isp_setdparm(struct ispsoftc *isp)
   1753  1.10   mjacob {
   1754  1.10   mjacob 	int i;
   1755  1.10   mjacob 	mbreg_t mbs;
   1756  1.10   mjacob 	sdparam *sdp;
   1757  1.10   mjacob 
   1758  1.10   mjacob 	isp->isp_fwrev = 0;
   1759  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1760  1.10   mjacob 		/*
   1761  1.10   mjacob 		 * ROM in 2100 doesn't appear to support ABOUT_FIRMWARE
   1762  1.10   mjacob 		 */
   1763   1.4   mjacob 		return;
   1764   1.4   mjacob 	}
   1765  1.10   mjacob 
   1766  1.10   mjacob 	mbs.param[0] = MBOX_ABOUT_FIRMWARE;
   1767  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   1768  1.10   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1769  1.20   mjacob 		IDPRINTF(3, ("1st ABOUT FIRMWARE command failed"));
   1770  1.10   mjacob 	} else {
   1771  1.10   mjacob 		isp->isp_fwrev =
   1772  1.10   mjacob 			(((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
   1773  1.10   mjacob 	}
   1774  1.10   mjacob 
   1775  1.10   mjacob 
   1776  1.10   mjacob 	sdp = (sdparam *) isp->isp_param;
   1777  1.10   mjacob 	/*
   1778  1.10   mjacob 	 * Try and get old clock rate out before we hit the
   1779  1.10   mjacob 	 * chip over the head- but if and only if we don't
   1780  1.10   mjacob 	 * know our desired clock rate.
   1781  1.10   mjacob 	 */
   1782  1.10   mjacob 	if (isp->isp_mdvec->dv_clock == 0) {
   1783  1.10   mjacob 		mbs.param[0] = MBOX_GET_CLOCK_RATE;
   1784  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
   1785  1.10   mjacob 		if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
   1786  1.10   mjacob 			sdp->isp_clock = mbs.param[1];
   1787  1.23   mjacob 			PRINTF("%s: using board clock 0x%x\n",
   1788  1.10   mjacob 				isp->isp_name, sdp->isp_clock);
   1789  1.10   mjacob 		}
   1790  1.10   mjacob 	} else {
   1791  1.10   mjacob 		sdp->isp_clock = isp->isp_mdvec->dv_clock;
   1792  1.10   mjacob 	}
   1793  1.10   mjacob 
   1794  1.10   mjacob 	mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
   1795  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   1796  1.10   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1797  1.23   mjacob 		IDPRINTF(2, ("could not GET ACT NEG STATE\n"));
   1798  1.10   mjacob 		sdp->isp_req_ack_active_neg = 1;
   1799  1.10   mjacob 		sdp->isp_data_line_active_neg = 1;
   1800  1.10   mjacob 	} else {
   1801  1.10   mjacob 		sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1;
   1802  1.10   mjacob 		sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1;
   1803  1.10   mjacob 	}
   1804  1.10   mjacob 	for (i = 0; i < MAX_TARGETS; i++) {
   1805  1.10   mjacob 		mbs.param[0] = MBOX_GET_TARGET_PARAMS;
   1806  1.10   mjacob 		mbs.param[1] = i << 8;
   1807  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
   1808  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1809  1.23   mjacob 			IDPRINTF(2, ("cannot get params for target %d\n", i));
   1810  1.10   mjacob 			sdp->isp_devparam[i].sync_period =
   1811  1.10   mjacob 				ISP_10M_SYNCPARMS & 0xff;
   1812  1.10   mjacob 			sdp->isp_devparam[i].sync_offset =
   1813  1.10   mjacob 				ISP_10M_SYNCPARMS >> 8;
   1814  1.10   mjacob 			sdp->isp_devparam[i].dev_flags = DPARM_DEFAULT;
   1815  1.10   mjacob 		} else {
   1816  1.23   mjacob 			IDPRINTF(3, ("\%s: target %d - flags 0x%x, sync %x\n",
   1817  1.23   mjacob 			       isp->isp_name, i, mbs.param[2], mbs.param[3]));
   1818  1.10   mjacob 			sdp->isp_devparam[i].dev_flags = mbs.param[2] >> 8;
   1819  1.10   mjacob 			/*
   1820  1.10   mjacob 			 * The maximum period we can really see
   1821  1.10   mjacob 			 * here is 100 (decimal), or 400 ns.
   1822  1.10   mjacob 			 * For some unknown reason we sometimes
   1823  1.10   mjacob 			 * get back wildass numbers from the
   1824  1.10   mjacob 			 * boot device's paramaters.
   1825  1.10   mjacob 			 */
   1826  1.10   mjacob 			if ((mbs.param[3] & 0xff) <= 0x64) {
   1827  1.10   mjacob 				sdp->isp_devparam[i].sync_period =
   1828  1.10   mjacob 					mbs.param[3] & 0xff;
   1829  1.10   mjacob 				sdp->isp_devparam[i].sync_offset =
   1830  1.10   mjacob 					mbs.param[3] >> 8;
   1831  1.10   mjacob 			}
   1832  1.10   mjacob 		}
   1833  1.10   mjacob 	}
   1834  1.10   mjacob 
   1835  1.10   mjacob 	/*
   1836  1.10   mjacob 	 * Set Default Host Adapter Parameters
   1837  1.10   mjacob 	 * XXX: Should try and get them out of NVRAM
   1838  1.10   mjacob 	 */
   1839  1.10   mjacob 	sdp->isp_adapter_enabled = 1;
   1840  1.10   mjacob 	sdp->isp_cmd_dma_burst_enable = 1;
   1841  1.10   mjacob 	sdp->isp_data_dma_burst_enabl = 1;
   1842  1.10   mjacob 	sdp->isp_fifo_threshold = 2;
   1843  1.10   mjacob 	sdp->isp_initiator_id = 7;
   1844  1.10   mjacob 	sdp->isp_async_data_setup = 6;
   1845  1.10   mjacob 	sdp->isp_selection_timeout = 250;
   1846  1.23   mjacob 	sdp->isp_max_queue_depth = 128;
   1847  1.10   mjacob 	sdp->isp_tag_aging = 8;
   1848  1.10   mjacob 	sdp->isp_bus_reset_delay = 3;
   1849  1.10   mjacob 	sdp->isp_retry_count = 0;
   1850  1.10   mjacob 	sdp->isp_retry_delay = 1;
   1851  1.10   mjacob 
   1852  1.10   mjacob 	for (i = 0; i < MAX_TARGETS; i++) {
   1853  1.10   mjacob 		sdp->isp_devparam[i].exc_throttle = 16;
   1854  1.10   mjacob 		sdp->isp_devparam[i].dev_enable = 1;
   1855  1.10   mjacob 	}
   1856  1.10   mjacob }
   1857  1.10   mjacob 
   1858  1.10   mjacob static void
   1859  1.10   mjacob isp_phoenix(struct ispsoftc *isp)
   1860  1.10   mjacob {
   1861  1.23   mjacob 	ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs;
   1862  1.10   mjacob 	int i;
   1863  1.10   mjacob 
   1864  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   1865  1.23   mjacob 		tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i];
   1866  1.10   mjacob 	}
   1867  1.10   mjacob 	isp_reset(isp);
   1868  1.10   mjacob 	isp_init(isp);
   1869  1.10   mjacob 	isp->isp_state = ISP_RUNSTATE;
   1870  1.10   mjacob 
   1871  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   1872  1.10   mjacob 		xs = tlist[i];
   1873  1.23   mjacob 		if (XS_NULL(xs))
   1874  1.10   mjacob 			continue;
   1875  1.23   mjacob 		isp->isp_nactive--;
   1876  1.23   mjacob 		if (isp->isp_nactive < 0)
   1877  1.23   mjacob 			isp->isp_nactive = 0;
   1878  1.23   mjacob 		XS_RESID(xs) = XS_XFRLEN(xs);
   1879  1.23   mjacob 		XS_SETERR(xs, HBA_BOTCH);
   1880  1.23   mjacob 		XS_CMD_DONE(xs);
   1881  1.10   mjacob 	}
   1882  1.10   mjacob }
   1883  1.10   mjacob 
   1884  1.23   mjacob void
   1885  1.10   mjacob isp_watch(void *arg)
   1886  1.10   mjacob {
   1887  1.23   mjacob 	int i;
   1888  1.10   mjacob 	struct ispsoftc *isp = arg;
   1889  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
   1890  1.23   mjacob 	ISP_LOCKVAL_DECL;
   1891  1.10   mjacob 
   1892  1.10   mjacob 	/*
   1893  1.23   mjacob 	 * Look for completely dead commands (but not polled ones).
   1894  1.10   mjacob 	 */
   1895  1.23   mjacob 	ISP_ILOCK(isp);
   1896  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   1897  1.23   mjacob 		if ((xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]) == NULL) {
   1898  1.10   mjacob 			continue;
   1899  1.10   mjacob 		}
   1900  1.23   mjacob 		if (XS_TIME(xs) == 0) {
   1901  1.10   mjacob 			continue;
   1902  1.23   mjacob 		}
   1903  1.23   mjacob 		XS_TIME(xs) -= (WATCH_INTERVAL * 1000);
   1904  1.23   mjacob 		/*
   1905  1.23   mjacob 		 * Avoid later thinking that this
   1906  1.23   mjacob 		 * transaction is not being timed.
   1907  1.23   mjacob 		 * Then give ourselves to watchdog
   1908  1.23   mjacob 		 * periods of grace.
   1909  1.23   mjacob 		 */
   1910  1.23   mjacob 		if (XS_TIME(xs) == 0)
   1911  1.23   mjacob 			XS_TIME(xs) = 1;
   1912  1.23   mjacob 		else if (XS_TIME(xs) > -(2 * WATCH_INTERVAL * 1000)) {
   1913  1.10   mjacob 			continue;
   1914  1.10   mjacob 		}
   1915  1.23   mjacob 		if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
   1916  1.23   mjacob 			PRINTF("%s: isp_watch failed to abort command\n",
   1917  1.23   mjacob 			    isp->isp_name);
   1918  1.23   mjacob 			isp_phoenix(isp);
   1919  1.23   mjacob 			break;
   1920  1.10   mjacob 		}
   1921  1.10   mjacob 	}
   1922  1.23   mjacob 	ISP_IUNLOCK(isp);
   1923  1.23   mjacob 	RESTART_WATCHDOG(isp_watch, isp);
   1924  1.15   mjacob }
   1925  1.15   mjacob 
   1926  1.15   mjacob static void
   1927  1.15   mjacob isp_prtstst(ispstatusreq_t *sp)
   1928  1.15   mjacob {
   1929  1.23   mjacob 	PRINTF("states->");
   1930  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_BUS)
   1931  1.23   mjacob 		PRINTF("GOT_BUS ");
   1932  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_TARGET)
   1933  1.23   mjacob 		PRINTF("GOT_TGT ");
   1934  1.15   mjacob 	if (sp->req_state_flags & RQSF_SENT_CDB)
   1935  1.23   mjacob 		PRINTF("SENT_CDB ");
   1936  1.15   mjacob 	if (sp->req_state_flags & RQSF_XFRD_DATA)
   1937  1.23   mjacob 		PRINTF("XFRD_DATA ");
   1938  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_STATUS)
   1939  1.23   mjacob 		PRINTF("GOT_STS ");
   1940  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_SENSE)
   1941  1.23   mjacob 		PRINTF("GOT_SNS ");
   1942  1.15   mjacob 	if (sp->req_state_flags & RQSF_XFER_COMPLETE)
   1943  1.23   mjacob 		PRINTF("XFR_CMPLT ");
   1944  1.23   mjacob 	PRINTF("\n");
   1945  1.23   mjacob 	PRINTF("status->");
   1946  1.15   mjacob 	if (sp->req_status_flags & RQSTF_DISCONNECT)
   1947  1.23   mjacob 		PRINTF("Disconnect ");
   1948  1.15   mjacob 	if (sp->req_status_flags & RQSTF_SYNCHRONOUS)
   1949  1.23   mjacob 		PRINTF("Sync_xfr ");
   1950  1.15   mjacob 	if (sp->req_status_flags & RQSTF_PARITY_ERROR)
   1951  1.23   mjacob 		PRINTF("Parity ");
   1952  1.15   mjacob 	if (sp->req_status_flags & RQSTF_BUS_RESET)
   1953  1.23   mjacob 		PRINTF("Bus_Reset ");
   1954  1.15   mjacob 	if (sp->req_status_flags & RQSTF_DEVICE_RESET)
   1955  1.23   mjacob 		PRINTF("Device_Reset ");
   1956  1.15   mjacob 	if (sp->req_status_flags & RQSTF_ABORTED)
   1957  1.23   mjacob 		PRINTF("Aborted ");
   1958  1.15   mjacob 	if (sp->req_status_flags & RQSTF_TIMEOUT)
   1959  1.23   mjacob 		PRINTF("Timeout ");
   1960  1.15   mjacob 	if (sp->req_status_flags & RQSTF_NEGOTIATION)
   1961  1.23   mjacob 		PRINTF("Negotiation ");
   1962  1.23   mjacob 	PRINTF("\n");
   1963   1.1      cgd }
   1964