Home | History | Annotate | Line # | Download | only in ic
isp.c revision 1.29
      1  1.26   mjacob /* $NetBSD: isp.c,v 1.29 1998/12/28 19:10:43 mjacob Exp $ */
      2  1.29   mjacob /* release_12_28_98_A */
      3   1.1      cgd /*
      4  1.25   mjacob  * Machine and OS 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.29   mjacob #include "isp_linux.h"
     56  1.23   mjacob #endif
     57   1.1      cgd 
     58  1.23   mjacob /*
     59  1.23   mjacob  * General defines
     60  1.23   mjacob  */
     61   1.1      cgd 
     62  1.23   mjacob #define	MBOX_DELAY_COUNT	1000000 / 100
     63   1.1      cgd 
     64  1.23   mjacob /*
     65  1.27   mjacob  * Local static data
     66  1.27   mjacob  */
     67  1.29   mjacob #ifdef	ISP_TARGET_MODE
     68  1.29   mjacob static const char tgtiqd[36] = {
     69  1.29   mjacob 	0x03, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00,
     70  1.29   mjacob 	0x51, 0x4C, 0x4F, 0x47, 0x49, 0x43, 0x20, 0x20,
     71  1.29   mjacob #ifdef	__NetBSD__
     72  1.29   mjacob 	0x4E, 0x45, 0x54, 0x42, 0x53, 0x44, 0x20, 0x20,
     73  1.29   mjacob #else
     74  1.29   mjacob # ifdef	__FreeBSD__
     75  1.29   mjacob 	0x46, 0x52, 0x45, 0x45, 0x42, 0x52, 0x44, 0x20,
     76  1.29   mjacob # else
     77  1.29   mjacob #  ifdef linux
     78  1.29   mjacob 	0x4C, 0x49, 0x4E, 0x55, 0x58, 0x20, 0x20, 0x20,
     79  1.29   mjacob #  else
     80  1.29   mjacob #  endif
     81  1.29   mjacob # endif
     82  1.29   mjacob #endif
     83  1.29   mjacob 	0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x20, 0x20,
     84  1.29   mjacob 	0x20, 0x20, 0x20, 0x31
     85  1.29   mjacob };
     86  1.29   mjacob #endif
     87  1.27   mjacob 
     88  1.27   mjacob 
     89  1.27   mjacob /*
     90  1.25   mjacob  * Local function prototypes.
     91  1.23   mjacob  */
     92  1.28   mjacob static int isp_parse_async __P((struct ispsoftc *, int));
     93  1.25   mjacob static int isp_handle_other_response
     94  1.25   mjacob __P((struct ispsoftc *, ispstatusreq_t *, u_int8_t *));
     95  1.29   mjacob #ifdef	ISP_TARGET_MODE
     96  1.29   mjacob static int isp_modify_lun __P((struct ispsoftc *, int, int, int));
     97  1.29   mjacob static void isp_notify_ack __P((struct ispsoftc *, void *));
     98  1.29   mjacob static void isp_handle_atio __P((struct ispsoftc *, void *));
     99  1.29   mjacob static void isp_handle_atio2 __P((struct ispsoftc *, void *));
    100  1.29   mjacob static void isp_handle_ctio __P((struct ispsoftc *, void *));
    101  1.29   mjacob static void isp_handle_ctio2 __P((struct ispsoftc *, void *));
    102  1.29   mjacob #endif
    103  1.23   mjacob static void isp_parse_status
    104  1.23   mjacob __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
    105  1.10   mjacob static void isp_fibre_init __P((struct ispsoftc *));
    106  1.10   mjacob static void isp_fw_state __P((struct ispsoftc *));
    107  1.10   mjacob static void isp_dumpregs __P((struct ispsoftc *, const char *));
    108  1.23   mjacob static void isp_dumpxflist __P((struct ispsoftc *));
    109  1.15   mjacob static void isp_prtstst __P((ispstatusreq_t *));
    110  1.28   mjacob static char *isp2100_fw_statename __P((int));
    111  1.23   mjacob static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
    112   1.1      cgd 
    113  1.25   mjacob static void isp_update  __P((struct ispsoftc *));
    114  1.25   mjacob static void isp_setdfltparm __P((struct ispsoftc *));
    115  1.25   mjacob static int isp_read_nvram __P((struct ispsoftc *));
    116  1.25   mjacob static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *));
    117  1.25   mjacob 
    118   1.1      cgd /*
    119   1.1      cgd  * Reset Hardware.
    120  1.25   mjacob  *
    121  1.25   mjacob  * Hit the chip over the head, download new f/w.
    122  1.25   mjacob  *
    123  1.24   mjacob  * Locking done elsewhere.
    124   1.1      cgd  */
    125   1.1      cgd void
    126   1.1      cgd isp_reset(isp)
    127   1.1      cgd 	struct ispsoftc *isp;
    128   1.1      cgd {
    129  1.25   mjacob 	static char once = 1;
    130   1.1      cgd 	mbreg_t mbs;
    131  1.23   mjacob 	int loops, i, dodnld = 1;
    132  1.10   mjacob 	char *revname;
    133   1.1      cgd 
    134   1.1      cgd 	isp->isp_state = ISP_NILSTATE;
    135   1.4   mjacob 
    136   1.4   mjacob 	/*
    137  1.25   mjacob 	 * Basic types (SCSI, FibreChannel and PCI or SBus)
    138  1.25   mjacob 	 * have been set in the MD code. We figure out more
    139  1.25   mjacob 	 * here.
    140   1.4   mjacob 	 */
    141  1.23   mjacob 	isp->isp_dblev = DFLT_DBLEVEL;
    142  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    143  1.10   mjacob 		revname = "2100";
    144  1.10   mjacob 	} else {
    145  1.25   mjacob 		sdparam *sdp = isp->isp_param;
    146  1.25   mjacob 
    147  1.25   mjacob 		int rev = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
    148  1.25   mjacob 		switch (rev) {
    149  1.10   mjacob 		default:
    150  1.25   mjacob 			PRINTF("%s: unknown chip rev. 0x%x- assuming a 1020\n",
    151  1.25   mjacob 			    isp->isp_name, rev);
    152  1.25   mjacob 			/* FALLTHROUGH */
    153  1.10   mjacob 		case 1:
    154  1.25   mjacob 			revname = "1020";
    155  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1020;
    156  1.25   mjacob 			sdp->isp_clock = 40;
    157  1.22   mjacob 			break;
    158  1.22   mjacob 		case 2:
    159  1.25   mjacob 			/*
    160  1.25   mjacob 			 * Some 1020A chips are Ultra Capable, but don't
    161  1.25   mjacob 			 * run the clock rate up for that unless told to
    162  1.25   mjacob 			 * do so by the Ultra Capable bits being set.
    163  1.25   mjacob 			 */
    164  1.25   mjacob 			revname = "1020A";
    165  1.22   mjacob 			isp->isp_type = ISP_HA_SCSI_1020A;
    166  1.25   mjacob 			sdp->isp_clock = 40;
    167  1.10   mjacob 			break;
    168  1.10   mjacob 		case 3:
    169  1.25   mjacob 			revname = "1040";
    170  1.25   mjacob 			isp->isp_type = ISP_HA_SCSI_1040;
    171  1.25   mjacob 			sdp->isp_clock = 60;
    172  1.25   mjacob 			break;
    173  1.25   mjacob 		case 4:
    174  1.10   mjacob 			revname = "1040A";
    175  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1040A;
    176  1.25   mjacob 			sdp->isp_clock = 60;
    177  1.10   mjacob 			break;
    178  1.10   mjacob 		case 5:
    179  1.10   mjacob 			revname = "1040B";
    180  1.10   mjacob 			isp->isp_type = ISP_HA_SCSI_1040B;
    181  1.25   mjacob 			sdp->isp_clock = 60;
    182  1.10   mjacob 			break;
    183   1.8   mjacob 		}
    184  1.25   mjacob 		/*
    185  1.25   mjacob 		 * Try and figure out if we're connected to a differential bus.
    186  1.25   mjacob 		 * You have to pause the RISC processor to read SXP registers.
    187  1.25   mjacob 		 */
    188  1.25   mjacob 		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
    189  1.25   mjacob 		i = 100;
    190  1.25   mjacob 		while ((ISP_READ(isp, HCCR) & HCCR_PAUSE) == 0) {
    191  1.25   mjacob 			SYS_DELAY(20);
    192  1.25   mjacob 			if (--i == 0) {
    193  1.25   mjacob 				PRINTF("%s: unable to pause RISC processor\n",
    194  1.25   mjacob 				    isp->isp_name);
    195  1.25   mjacob 				i = -1;
    196  1.25   mjacob 				break;
    197  1.25   mjacob 			}
    198  1.25   mjacob 		}
    199  1.25   mjacob 		if (i > 0) {
    200  1.25   mjacob 			if (isp->isp_bustype != ISP_BT_SBUS) {
    201  1.25   mjacob 				ISP_SETBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP);
    202  1.25   mjacob 			}
    203  1.25   mjacob 			if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
    204  1.25   mjacob 				IDPRINTF(2, ("%s: Differential Mode Set\n",
    205  1.25   mjacob 				    isp->isp_name));
    206  1.25   mjacob 				sdp->isp_diffmode = 1;
    207  1.25   mjacob 			} else {
    208  1.25   mjacob 				sdp->isp_diffmode = 0;
    209  1.25   mjacob 			}
    210  1.25   mjacob 
    211  1.25   mjacob 			if (isp->isp_bustype != ISP_BT_SBUS) {
    212  1.25   mjacob 				ISP_CLRBITS(isp, BIU_CONF1, BIU_PCI_CONF1_SXP);
    213  1.25   mjacob 			}
    214  1.25   mjacob 
    215  1.25   mjacob 			/*
    216  1.25   mjacob 			 * Figure out whether we're ultra capable.
    217  1.25   mjacob 			 */
    218  1.25   mjacob 			i = ISP_READ(isp, RISC_PSR);
    219  1.25   mjacob 			if (isp->isp_bustype != ISP_BT_SBUS) {
    220  1.25   mjacob 				i &= RISC_PSR_PCI_ULTRA;
    221  1.25   mjacob 			} else {
    222  1.25   mjacob 				i &= RISC_PSR_SBUS_ULTRA;
    223  1.25   mjacob 			}
    224  1.25   mjacob 			if (i) {
    225  1.25   mjacob 				IDPRINTF(2, ("%s: Ultra Mode Capable\n",
    226  1.25   mjacob 				    isp->isp_name));
    227  1.25   mjacob 				sdp->isp_clock = 60;
    228  1.25   mjacob 			} else {
    229  1.25   mjacob 				sdp->isp_clock = 40;
    230  1.25   mjacob 			}
    231  1.25   mjacob 			/*
    232  1.25   mjacob 			 * Restart processor
    233  1.25   mjacob 			 */
    234  1.25   mjacob 			ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
    235  1.25   mjacob 		}
    236  1.25   mjacob 		/*
    237  1.25   mjacob 		 * Machine dependent clock (if set) overrides
    238  1.25   mjacob 		 * our generic determinations.
    239  1.25   mjacob 		 */
    240  1.25   mjacob 		if (isp->isp_mdvec->dv_clock) {
    241  1.25   mjacob 			if (isp->isp_mdvec->dv_clock < sdp->isp_clock) {
    242  1.25   mjacob 				sdp->isp_clock = isp->isp_mdvec->dv_clock;
    243  1.25   mjacob 			}
    244  1.25   mjacob 		}
    245   1.4   mjacob 	}
    246   1.8   mjacob 
    247   1.1      cgd 	/*
    248  1.10   mjacob 	 * Do MD specific pre initialization
    249   1.1      cgd 	 */
    250  1.10   mjacob 	ISP_RESET0(isp);
    251  1.25   mjacob 
    252  1.25   mjacob 	if (once == 1) {
    253  1.25   mjacob 		once = 0;
    254  1.25   mjacob 		/*
    255  1.25   mjacob 		 * Get the current running firmware revision out of the
    256  1.25   mjacob 		 * chip before we hit it over the head (if this is our
    257  1.25   mjacob 		 * first time through). Note that we store this as the
    258  1.25   mjacob 		 * 'ROM' firmware revision- which it may not be. In any
    259  1.25   mjacob 		 * case, we don't really use this yet, but we may in
    260  1.25   mjacob 		 * the future.
    261  1.25   mjacob 		 */
    262  1.25   mjacob 		mbs.param[0] = MBOX_ABOUT_FIRMWARE;
    263  1.25   mjacob 		isp_mboxcmd(isp, &mbs);
    264  1.25   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    265  1.26   mjacob 			IDPRINTF(3, ("%s: initial ABOUT FIRMWARE command "
    266  1.26   mjacob 			    "failed\n", isp->isp_name));
    267  1.25   mjacob 		} else {
    268  1.25   mjacob 			isp->isp_romfw_rev =
    269  1.25   mjacob 			    (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
    270  1.25   mjacob 		}
    271  1.25   mjacob 	}
    272  1.24   mjacob 
    273   1.1      cgd 	/*
    274  1.10   mjacob 	 * Hit the chip over the head with hammer,
    275  1.10   mjacob 	 * and give the ISP a chance to recover.
    276   1.1      cgd 	 */
    277   1.1      cgd 
    278  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    279  1.10   mjacob 		ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
    280  1.10   mjacob 		/*
    281  1.10   mjacob 		 * A slight delay...
    282  1.10   mjacob 		 */
    283  1.23   mjacob 		SYS_DELAY(100);
    284  1.10   mjacob 
    285  1.10   mjacob 		/*
    286  1.10   mjacob 		 * Clear data && control DMA engines.
    287  1.10   mjacob 		 */
    288  1.10   mjacob 		ISP_WRITE(isp, CDMA_CONTROL,
    289   1.1      cgd 		      DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
    290  1.10   mjacob 		ISP_WRITE(isp, DDMA_CONTROL,
    291   1.1      cgd 		      DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
    292  1.10   mjacob 	} else {
    293  1.10   mjacob 		ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
    294  1.10   mjacob 		/*
    295  1.10   mjacob 		 * A slight delay...
    296  1.10   mjacob 		 */
    297  1.23   mjacob 		SYS_DELAY(100);
    298  1.10   mjacob 		ISP_WRITE(isp, CDMA2100_CONTROL,
    299  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    300  1.10   mjacob 		ISP_WRITE(isp, TDMA2100_CONTROL,
    301  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    302  1.10   mjacob 		ISP_WRITE(isp, RDMA2100_CONTROL,
    303  1.10   mjacob 			DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
    304  1.10   mjacob 	}
    305  1.10   mjacob 
    306   1.1      cgd 	/*
    307   1.1      cgd 	 * Wait for ISP to be ready to go...
    308   1.1      cgd 	 */
    309   1.1      cgd 	loops = MBOX_DELAY_COUNT;
    310  1.10   mjacob 	for (;;) {
    311  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
    312  1.10   mjacob 			if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
    313  1.10   mjacob 				break;
    314  1.10   mjacob 		} else {
    315  1.10   mjacob 			if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
    316  1.10   mjacob 				break;
    317  1.10   mjacob 		}
    318  1.23   mjacob 		SYS_DELAY(100);
    319   1.1      cgd 		if (--loops < 0) {
    320  1.10   mjacob 			isp_dumpregs(isp, "chip reset timed out");
    321   1.1      cgd 			return;
    322   1.1      cgd 		}
    323   1.1      cgd 	}
    324   1.1      cgd 	/*
    325   1.1      cgd 	 * More initialization
    326   1.1      cgd 	 */
    327  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    328  1.10   mjacob 		ISP_WRITE(isp, BIU_CONF1, 0);
    329  1.10   mjacob 	} else {
    330  1.10   mjacob 		ISP_WRITE(isp, BIU2100_CSR, 0);
    331  1.25   mjacob 		/*
    332  1.25   mjacob 		 * All 2100's are 60Mhz with fast rams onboard.
    333  1.25   mjacob 		 */
    334  1.25   mjacob 		ISP_WRITE(isp, RISC_MTR2100, 0x1212);
    335  1.10   mjacob 	}
    336   1.1      cgd 
    337   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
    338  1.23   mjacob 	SYS_DELAY(100);
    339   1.1      cgd 
    340  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    341   1.1      cgd 		ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1);
    342   1.1      cgd 		if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) {
    343   1.1      cgd 			ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
    344   1.1      cgd 			ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
    345   1.1      cgd 		}
    346   1.1      cgd 	}
    347   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
    348   1.1      cgd 
    349   1.1      cgd 	/*
    350   1.1      cgd 	 * Do MD specific post initialization
    351   1.1      cgd 	 */
    352   1.1      cgd 	ISP_RESET1(isp);
    353   1.1      cgd 
    354   1.1      cgd 	/*
    355   1.1      cgd 	 * Enable interrupts
    356   1.1      cgd 	 */
    357  1.10   mjacob 	ENABLE_INTS(isp);
    358   1.1      cgd 
    359   1.1      cgd 	/*
    360   1.1      cgd 	 * Do some sanity checking.
    361   1.1      cgd 	 */
    362   1.1      cgd 	mbs.param[0] = MBOX_NO_OP;
    363  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    364   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    365  1.10   mjacob 		isp_dumpregs(isp, "NOP test failed");
    366   1.1      cgd 		return;
    367   1.1      cgd 	}
    368   1.1      cgd 
    369  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    370  1.10   mjacob 		mbs.param[0] = MBOX_MAILBOX_REG_TEST;
    371  1.10   mjacob 		mbs.param[1] = 0xdead;
    372  1.10   mjacob 		mbs.param[2] = 0xbeef;
    373  1.10   mjacob 		mbs.param[3] = 0xffff;
    374  1.10   mjacob 		mbs.param[4] = 0x1111;
    375  1.10   mjacob 		mbs.param[5] = 0xa5a5;
    376  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    377   1.1      cgd 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    378  1.10   mjacob 			isp_dumpregs(isp,
    379  1.10   mjacob 				"Mailbox Register test didn't complete");
    380  1.10   mjacob 			return;
    381  1.10   mjacob 		}
    382  1.10   mjacob 		if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
    383  1.10   mjacob 		    mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
    384  1.10   mjacob 		    mbs.param[5] != 0xa5a5) {
    385  1.10   mjacob 			isp_dumpregs(isp, "Register Test Failed");
    386   1.1      cgd 			return;
    387   1.1      cgd 		}
    388  1.10   mjacob 
    389   1.1      cgd 	}
    390   1.1      cgd 
    391   1.1      cgd 	/*
    392  1.18   mjacob 	 * Download new Firmware, unless requested not to do so.
    393  1.18   mjacob 	 * This is made slightly trickier in some cases where the
    394  1.18   mjacob 	 * firmware of the ROM revision is newer than the revision
    395  1.18   mjacob 	 * compiled into the driver. So, where we used to compare
    396  1.18   mjacob 	 * versions of our f/w and the ROM f/w, now we just see
    397  1.18   mjacob 	 * whether we have f/w at all and whether a config flag
    398  1.18   mjacob 	 * has disabled our download.
    399   1.1      cgd 	 */
    400  1.23   mjacob 	if ((isp->isp_mdvec->dv_fwlen == 0) ||
    401  1.23   mjacob 	    (isp->isp_confopts & ISP_CFG_NORELOAD)) {
    402  1.10   mjacob 		dodnld = 0;
    403  1.10   mjacob 	}
    404  1.10   mjacob 
    405  1.10   mjacob 	if (dodnld) {
    406  1.10   mjacob 		for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) {
    407  1.10   mjacob 			mbs.param[0] = MBOX_WRITE_RAM_WORD;
    408  1.10   mjacob 			mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
    409  1.10   mjacob 			mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
    410  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    411  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    412  1.10   mjacob 				isp_dumpregs(isp, "f/w download failed");
    413  1.10   mjacob 				return;
    414  1.10   mjacob 			}
    415  1.10   mjacob 		}
    416  1.10   mjacob 
    417  1.10   mjacob 		if (isp->isp_mdvec->dv_fwlen) {
    418  1.10   mjacob 			/*
    419  1.10   mjacob 			 * Verify that it downloaded correctly.
    420  1.10   mjacob 			 */
    421  1.10   mjacob 			mbs.param[0] = MBOX_VERIFY_CHECKSUM;
    422  1.10   mjacob 			mbs.param[1] = isp->isp_mdvec->dv_codeorg;
    423  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    424  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    425  1.10   mjacob 				isp_dumpregs(isp, "ram checksum failure");
    426  1.10   mjacob 				return;
    427  1.10   mjacob 			}
    428  1.10   mjacob 		}
    429  1.10   mjacob 	} else {
    430  1.20   mjacob 		IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
    431   1.1      cgd 	}
    432   1.1      cgd 
    433   1.1      cgd 	/*
    434  1.10   mjacob 	 * Now start it rolling.
    435  1.10   mjacob 	 *
    436  1.10   mjacob 	 * If we didn't actually download f/w,
    437  1.10   mjacob 	 * we still need to (re)start it.
    438   1.1      cgd 	 */
    439   1.1      cgd 
    440   1.1      cgd 	mbs.param[0] = MBOX_EXEC_FIRMWARE;
    441   1.1      cgd 	mbs.param[1] = isp->isp_mdvec->dv_codeorg;
    442  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    443   1.4   mjacob 
    444  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
    445  1.25   mjacob 		sdparam *sdp = isp->isp_param;
    446  1.10   mjacob 		/*
    447  1.25   mjacob 		 * Set CLOCK RATE, but only if asked to.
    448  1.10   mjacob 		 */
    449  1.25   mjacob 		if (sdp->isp_clock) {
    450  1.10   mjacob 			mbs.param[0] = MBOX_SET_CLOCK_RATE;
    451  1.25   mjacob 			mbs.param[1] = sdp->isp_clock;
    452  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    453  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    454  1.10   mjacob 				isp_dumpregs(isp, "failed to set CLOCKRATE");
    455  1.25   mjacob 				/* but continue */
    456  1.25   mjacob 			} else {
    457  1.25   mjacob 				IDPRINTF(3, ("%s: setting input clock to %d\n",
    458  1.25   mjacob 				    isp->isp_name, sdp->isp_clock));
    459  1.10   mjacob 			}
    460   1.4   mjacob 		}
    461   1.4   mjacob 	}
    462   1.1      cgd 	mbs.param[0] = MBOX_ABOUT_FIRMWARE;
    463  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    464   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    465  1.10   mjacob 		isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
    466   1.1      cgd 		return;
    467   1.1      cgd 	}
    468  1.23   mjacob 	PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n",
    469  1.25   mjacob 		isp->isp_name, revname, dodnld? "loaded" : "resident",
    470   1.1      cgd 		mbs.param[1], mbs.param[2]);
    471  1.25   mjacob 	isp->isp_fwrev = (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
    472  1.25   mjacob 	if (isp->isp_romfw_rev && dodnld) {
    473  1.25   mjacob 		PRINTF("%s: Last F/W revision was %d.%d\n", isp->isp_name,
    474  1.25   mjacob 		    isp->isp_romfw_rev >> 10, isp->isp_romfw_rev & 0x3ff);
    475  1.25   mjacob 	}
    476  1.10   mjacob 	isp_fw_state(isp);
    477   1.1      cgd 	isp->isp_state = ISP_RESETSTATE;
    478   1.1      cgd }
    479   1.1      cgd 
    480   1.1      cgd /*
    481   1.1      cgd  * Initialize Hardware to known state
    482  1.24   mjacob  *
    483  1.24   mjacob  * Locks are held before coming here.
    484   1.1      cgd  */
    485  1.24   mjacob 
    486   1.1      cgd void
    487   1.1      cgd isp_init(isp)
    488   1.1      cgd 	struct ispsoftc *isp;
    489   1.1      cgd {
    490  1.10   mjacob 	sdparam *sdp;
    491   1.1      cgd 	mbreg_t mbs;
    492  1.25   mjacob 	int tgt;
    493  1.25   mjacob 
    494  1.25   mjacob 	/*
    495  1.25   mjacob 	 * Must do first.
    496  1.25   mjacob 	 */
    497  1.25   mjacob 	isp_setdfltparm(isp);
    498  1.25   mjacob 
    499  1.25   mjacob 	/*
    500  1.25   mjacob 	 * If we're fibre, we have a completely different
    501  1.25   mjacob 	 * initialization method.
    502  1.25   mjacob 	 */
    503   1.1      cgd 
    504  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    505  1.10   mjacob 		isp_fibre_init(isp);
    506  1.10   mjacob 		return;
    507   1.1      cgd 	}
    508  1.10   mjacob 	sdp = isp->isp_param;
    509   1.1      cgd 
    510  1.10   mjacob 	/*
    511  1.25   mjacob 	 * Set (possibly new) Initiator ID.
    512  1.10   mjacob 	 */
    513  1.25   mjacob 	mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
    514  1.25   mjacob 	mbs.param[1] = sdp->isp_initiator_id;
    515  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    516   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    517  1.25   mjacob 		isp_dumpregs(isp, "failed to set initiator id");
    518   1.1      cgd 		return;
    519   1.1      cgd 	}
    520   1.1      cgd 
    521  1.25   mjacob 	/*
    522  1.25   mjacob 	 * Set Retry Delay and Count
    523  1.25   mjacob 	 */
    524   1.1      cgd 	mbs.param[0] = MBOX_SET_RETRY_COUNT;
    525  1.10   mjacob 	mbs.param[1] = sdp->isp_retry_count;
    526  1.10   mjacob 	mbs.param[2] = sdp->isp_retry_delay;
    527  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    528   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    529  1.10   mjacob 		isp_dumpregs(isp, "failed to set retry count and delay");
    530   1.1      cgd 		return;
    531   1.1      cgd 	}
    532   1.1      cgd 
    533  1.25   mjacob 	/*
    534  1.25   mjacob 	 * Set ASYNC DATA SETUP time. This is very important.
    535  1.25   mjacob 	 */
    536   1.1      cgd 	mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
    537  1.10   mjacob 	mbs.param[1] = sdp->isp_async_data_setup;
    538  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    539   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    540  1.10   mjacob 		isp_dumpregs(isp, "failed to set async data setup time");
    541   1.1      cgd 		return;
    542   1.1      cgd 	}
    543   1.1      cgd 
    544  1.25   mjacob 	/*
    545  1.25   mjacob 	 * Set ACTIVE Negation State.
    546  1.25   mjacob 	 */
    547   1.1      cgd 	mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
    548  1.25   mjacob 	mbs.param[1] =
    549  1.25   mjacob 	    (sdp->isp_req_ack_active_neg << 4) |
    550  1.25   mjacob 	    (sdp->isp_data_line_active_neg << 5);
    551  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    552   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    553  1.10   mjacob 		isp_dumpregs(isp, "failed to set active neg state");
    554   1.1      cgd 		return;
    555   1.1      cgd 	}
    556   1.1      cgd 
    557  1.25   mjacob 	/*
    558  1.25   mjacob 	 * Set the Tag Aging limit
    559  1.25   mjacob 	 */
    560  1.25   mjacob 
    561   1.1      cgd 	mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
    562  1.10   mjacob 	mbs.param[1] = sdp->isp_tag_aging;
    563  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    564   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    565  1.10   mjacob 		isp_dumpregs(isp, "failed to set tag age limit");
    566   1.1      cgd 		return;
    567   1.1      cgd 	}
    568   1.1      cgd 
    569  1.25   mjacob 	/*
    570  1.25   mjacob 	 * Set selection timeout.
    571  1.25   mjacob 	 */
    572  1.25   mjacob 
    573   1.1      cgd 	mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
    574  1.10   mjacob 	mbs.param[1] = sdp->isp_selection_timeout;
    575  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    576   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    577  1.10   mjacob 		isp_dumpregs(isp, "failed to set selection timeout");
    578   1.1      cgd 		return;
    579   1.1      cgd 	}
    580   1.1      cgd 
    581  1.25   mjacob 	/*
    582  1.25   mjacob 	 * Set per-target parameters to a safe minimum.
    583  1.25   mjacob 	 */
    584  1.25   mjacob 
    585  1.25   mjacob 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
    586  1.25   mjacob 		int maxlun, lun;
    587  1.10   mjacob 
    588  1.25   mjacob 		if (sdp->isp_devparam[tgt].dev_enable == 0)
    589   1.1      cgd 			continue;
    590   1.1      cgd 
    591  1.25   mjacob 		mbs.param[0] = MBOX_SET_TARGET_PARAMS;
    592  1.25   mjacob 		mbs.param[1] = tgt << 8;
    593  1.25   mjacob 		mbs.param[2] = DPARM_SAFE_DFLT;
    594  1.25   mjacob 		mbs.param[3] = 0;
    595  1.20   mjacob 		/*
    596  1.25   mjacob 		 * It is not quite clear when this changed over so that
    597  1.25   mjacob 		 * we could force narrow and async, so assume >= 7.55.
    598  1.25   mjacob 		 *
    599  1.25   mjacob 		 * Otherwise, a SCSI bus reset issued below will force
    600  1.25   mjacob 		 * the back to the narrow, async state (but see note
    601  1.25   mjacob 		 * below also). Technically we should also do without
    602  1.25   mjacob 		 * Parity.
    603  1.20   mjacob 		 */
    604  1.25   mjacob 		if (isp->isp_fwrev >= ISP_FW_REV(7, 55)) {
    605  1.25   mjacob 			mbs.param[2] |= DPARM_NARROW | DPARM_ASYNC;
    606  1.20   mjacob 		}
    607  1.25   mjacob 		sdp->isp_devparam[tgt].cur_dflags = mbs.param[2] >> 8;
    608  1.10   mjacob 
    609  1.25   mjacob 		IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n",
    610  1.25   mjacob 		    isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8,
    611  1.25   mjacob 		    mbs.param[3] & 0xff));
    612  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    613   1.1      cgd 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    614  1.25   mjacob 
    615  1.25   mjacob 			PRINTF("%s: failed to set parameters for tgt %d\n",
    616  1.25   mjacob 				isp->isp_name, tgt);
    617  1.25   mjacob 
    618  1.23   mjacob 			PRINTF("%s: flags %x offset %x period %x\n",
    619  1.25   mjacob 				isp->isp_name, sdp->isp_devparam[tgt].dev_flags,
    620  1.25   mjacob 				sdp->isp_devparam[tgt].sync_offset,
    621  1.25   mjacob 				sdp->isp_devparam[tgt].sync_period);
    622  1.25   mjacob 
    623  1.10   mjacob 			mbs.param[0] = MBOX_SET_TARGET_PARAMS;
    624  1.25   mjacob 			mbs.param[1] = tgt << 8;
    625  1.25   mjacob 			mbs.param[2] = DPARM_SAFE_DFLT;
    626  1.25   mjacob 			mbs.param[3] = 0;
    627  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    628  1.10   mjacob 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    629  1.25   mjacob 				PRINTF("%s: failed even to set defaults for "
    630  1.25   mjacob 				    "target %d\n", isp->isp_name, tgt);
    631  1.25   mjacob 				continue;
    632  1.10   mjacob 			}
    633   1.1      cgd 		}
    634  1.25   mjacob 
    635  1.25   mjacob 		maxlun = (isp->isp_fwrev >= ISP_FW_REV(7, 55))? 32 : 8;
    636  1.25   mjacob 		for (lun = 0; lun < maxlun; lun++) {
    637   1.1      cgd 			mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
    638  1.25   mjacob 			mbs.param[1] = (tgt << 8) | lun;
    639  1.10   mjacob 			mbs.param[2] = sdp->isp_max_queue_depth;
    640  1.25   mjacob 			mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
    641  1.10   mjacob 			isp_mboxcmd(isp, &mbs);
    642   1.1      cgd 			if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    643  1.25   mjacob 				PRINTF("%s: failed to set device queue "
    644  1.25   mjacob 				    "parameters for target %d, lun %d\n",
    645  1.25   mjacob 				    isp->isp_name, tgt, lun);
    646  1.25   mjacob 				break;
    647   1.1      cgd 			}
    648   1.1      cgd 		}
    649   1.1      cgd 	}
    650   1.1      cgd 
    651   1.7  thorpej 	/*
    652   1.7  thorpej 	 * Set up DMA for the request and result mailboxes.
    653   1.7  thorpej 	 */
    654  1.27   mjacob 	if (ISP_MBOXDMASETUP(isp) != 0) {
    655  1.23   mjacob 		PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
    656   1.1      cgd 		return;
    657   1.1      cgd 	}
    658  1.10   mjacob 
    659   1.1      cgd 	mbs.param[0] = MBOX_INIT_RES_QUEUE;
    660  1.23   mjacob 	mbs.param[1] = RESULT_QUEUE_LEN;
    661   1.7  thorpej 	mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16);
    662   1.7  thorpej 	mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff);
    663   1.1      cgd 	mbs.param[4] = 0;
    664   1.6   mjacob 	mbs.param[5] = 0;
    665  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    666   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    667  1.10   mjacob 		isp_dumpregs(isp, "set of response queue failed");
    668   1.1      cgd 		return;
    669   1.1      cgd 	}
    670   1.1      cgd 	isp->isp_residx = 0;
    671   1.1      cgd 
    672   1.1      cgd 	mbs.param[0] = MBOX_INIT_REQ_QUEUE;
    673  1.23   mjacob 	mbs.param[1] = RQUEST_QUEUE_LEN;
    674   1.7  thorpej 	mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16);
    675   1.7  thorpej 	mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
    676   1.1      cgd 	mbs.param[4] = 0;
    677  1.10   mjacob 	mbs.param[5] = 0;
    678  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    679   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    680  1.10   mjacob 		isp_dumpregs(isp, "set of request queue failed");
    681   1.1      cgd 		return;
    682   1.1      cgd 	}
    683  1.25   mjacob 	isp->isp_reqidx = isp->isp_reqodx = 0;
    684   1.1      cgd 
    685   1.1      cgd 	/*
    686  1.25   mjacob 	 * XXX: See whether or not for 7.55 F/W or later we
    687  1.25   mjacob 	 * XXX: can do without this, and see whether we should
    688  1.25   mjacob 	 * XXX: honor the NVRAM SCSI_RESET_DISABLE token.
    689   1.1      cgd 	 */
    690   1.1      cgd 	mbs.param[0] = MBOX_BUS_RESET;
    691  1.25   mjacob 	mbs.param[1] = 3;
    692  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
    693   1.1      cgd 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    694  1.10   mjacob 		isp_dumpregs(isp, "SCSI bus reset failed");
    695   1.1      cgd 	}
    696  1.10   mjacob 	/*
    697  1.10   mjacob 	 * This is really important to have set after a bus reset.
    698  1.10   mjacob 	 */
    699   1.1      cgd 	isp->isp_sendmarker = 1;
    700   1.1      cgd 	isp->isp_state = ISP_INITSTATE;
    701   1.1      cgd }
    702   1.1      cgd 
    703  1.24   mjacob /*
    704  1.24   mjacob  * Fibre Channel specific initialization.
    705  1.24   mjacob  *
    706  1.24   mjacob  * Locks are held before coming here.
    707  1.24   mjacob  */
    708  1.10   mjacob static void
    709  1.10   mjacob isp_fibre_init(isp)
    710  1.10   mjacob 	struct ispsoftc *isp;
    711  1.10   mjacob {
    712  1.10   mjacob 	fcparam *fcp;
    713  1.10   mjacob 	isp_icb_t *icbp;
    714  1.10   mjacob 	mbreg_t mbs;
    715  1.28   mjacob 	int count, loopid;
    716  1.23   mjacob 	u_int8_t lwfs;
    717  1.10   mjacob 
    718  1.10   mjacob 	fcp = isp->isp_param;
    719  1.10   mjacob 
    720  1.27   mjacob 	if (ISP_MBOXDMASETUP(isp) != 0) {
    721  1.23   mjacob 		PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name);
    722  1.10   mjacob 		return;
    723  1.10   mjacob 	}
    724  1.28   mjacob 	/*
    725  1.28   mjacob 	 * For systems that don't have BIOS methods for which
    726  1.28   mjacob 	 * we can easily change the NVRAM based loopid, we'll
    727  1.28   mjacob 	 * override that here. Note that when we initialize
    728  1.28   mjacob 	 * the firmware we may get back a different loopid than
    729  1.28   mjacob 	 * we asked for anyway. XXX This is probably not the
    730  1.28   mjacob 	 * best way to figure this out XXX
    731  1.28   mjacob 	 */
    732  1.28   mjacob #ifndef	__i386__
    733  1.28   mjacob 	loopid = DEFAULT_LOOPID;
    734  1.28   mjacob #else
    735  1.28   mjacob 	loopid = fcp->isp_loopid;
    736  1.28   mjacob #endif
    737  1.28   mjacob 
    738  1.10   mjacob 
    739  1.10   mjacob 	icbp = (isp_icb_t *) fcp->isp_scratch;
    740  1.10   mjacob 	bzero(icbp, sizeof (*icbp));
    741  1.25   mjacob 
    742  1.25   mjacob 	icbp->icb_version = ICB_VERSION1;
    743  1.29   mjacob #ifdef	ISP_TARGET_MODE
    744  1.29   mjacob 	fcp->isp_fwoptions = ICBOPT_TGT_ENABLE|ICBOPT_INI_TGTTYPE;
    745  1.29   mjacob #else
    746  1.27   mjacob 	fcp->isp_fwoptions = 0;
    747  1.29   mjacob #endif
    748  1.28   mjacob 	fcp->isp_fwoptions |= ICBOPT_INI_ADISC|ICBOPT_FAIRNESS;
    749  1.28   mjacob 	fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE;
    750  1.28   mjacob 	fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS;
    751  1.28   mjacob #ifdef	CHECKME
    752  1.28   mjacob 	fcp->isp_fwoptions |= ICBOPT_USE_PORTNAME;
    753  1.28   mjacob #endif
    754  1.28   mjacob #ifdef	THIS_WORKED
    755  1.28   mjacob 	/*
    756  1.28   mjacob 	 * This has unhappiness in target mode
    757  1.28   mjacob 	 */
    758  1.28   mjacob 	fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN;
    759  1.27   mjacob #endif
    760  1.27   mjacob 	icbp->icb_fwoptions = fcp->isp_fwoptions;
    761  1.25   mjacob 	icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
    762  1.25   mjacob 	if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
    763  1.25   mjacob 	    icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
    764  1.25   mjacob 		PRINTF("%s: bad frame length (%d) from NVRAM- using %d\n",
    765  1.25   mjacob 		    isp->isp_name, fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
    766  1.25   mjacob 	}
    767  1.25   mjacob 	icbp->icb_maxalloc = fcp->isp_maxalloc;
    768  1.25   mjacob 	icbp->icb_execthrottle = fcp->isp_execthrottle;
    769  1.25   mjacob 	icbp->icb_retry_delay = fcp->isp_retry_delay;
    770  1.25   mjacob 	icbp->icb_retry_count = fcp->isp_retry_count;
    771  1.28   mjacob 	icbp->icb_hardaddr = loopid;
    772  1.25   mjacob 
    773  1.25   mjacob 	MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwn);
    774  1.28   mjacob 	if (icbp->icb_fwoptions & ICBOPT_USE_PORTNAME) {
    775  1.28   mjacob 		u_int64_t portname = fcp->isp_wwn | (2LL << 56);
    776  1.28   mjacob 		MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, portname);
    777  1.28   mjacob 	}
    778  1.23   mjacob 	icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
    779  1.23   mjacob 	icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
    780  1.25   mjacob 	icbp->icb_rqstaddr[RQRSP_ADDR0015] =
    781  1.25   mjacob 	    (u_int16_t) (isp->isp_rquest_dma & 0xffff);
    782  1.25   mjacob 	icbp->icb_rqstaddr[RQRSP_ADDR1631] =
    783  1.25   mjacob 	    (u_int16_t) (isp->isp_rquest_dma >> 16);
    784  1.25   mjacob 	icbp->icb_respaddr[RQRSP_ADDR0015] =
    785  1.25   mjacob 	    (u_int16_t) (isp->isp_result_dma & 0xffff);
    786  1.25   mjacob 	icbp->icb_respaddr[RQRSP_ADDR1631] =
    787  1.25   mjacob 	    (u_int16_t) (isp->isp_result_dma >> 16);
    788  1.10   mjacob 
    789  1.27   mjacob 	for (count = 0; count < 10; count++) {
    790  1.27   mjacob 		mbs.param[0] = MBOX_INIT_FIRMWARE;
    791  1.27   mjacob 		mbs.param[1] = 0;
    792  1.27   mjacob 		mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16);
    793  1.27   mjacob 		mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff);
    794  1.27   mjacob 		mbs.param[4] = 0;
    795  1.27   mjacob 		mbs.param[5] = 0;
    796  1.27   mjacob 		mbs.param[6] = 0;
    797  1.27   mjacob 		mbs.param[7] = 0;
    798  1.27   mjacob 
    799  1.27   mjacob 		isp_mboxcmd(isp, &mbs);
    800  1.27   mjacob 
    801  1.27   mjacob 		switch (mbs.param[0]) {
    802  1.27   mjacob 		case MBOX_COMMAND_COMPLETE:
    803  1.27   mjacob 			count = 10;
    804  1.27   mjacob 			break;
    805  1.27   mjacob 		case ASYNC_LIP_OCCURRED:
    806  1.27   mjacob 		case ASYNC_LOOP_UP:
    807  1.27   mjacob 		case ASYNC_LOOP_DOWN:
    808  1.27   mjacob 		case ASYNC_LOOP_RESET:
    809  1.27   mjacob 		case ASYNC_PDB_CHANGED:
    810  1.27   mjacob 		case ASYNC_CHANGE_NOTIFY:
    811  1.27   mjacob 			if (count > 9) {
    812  1.27   mjacob 				PRINTF("%s: too many retries to get going- "
    813  1.27   mjacob 				    "giving up\n", isp->isp_name);
    814  1.27   mjacob 				return;
    815  1.27   mjacob 			}
    816  1.27   mjacob 			break;
    817  1.27   mjacob 		default:
    818  1.27   mjacob 			isp_dumpregs(isp, "INIT FIRMWARE failed");
    819  1.27   mjacob 			return;
    820  1.27   mjacob 		}
    821  1.10   mjacob 	}
    822  1.25   mjacob 	isp->isp_reqidx = isp->isp_reqodx = 0;
    823  1.10   mjacob 	isp->isp_residx = 0;
    824  1.10   mjacob 
    825  1.10   mjacob 	/*
    826  1.28   mjacob 	 * Wait up to 5 seconds for FW to go to READY state.
    827  1.10   mjacob 	 */
    828  1.23   mjacob 	lwfs = FW_CONFIG_WAIT;
    829  1.23   mjacob 	for (count = 0; count < 12000; count++) {
    830  1.10   mjacob 		isp_fw_state(isp);
    831  1.23   mjacob 		if (lwfs != fcp->isp_fwstate) {
    832  1.28   mjacob 			PRINTF("%s: Firmware State %s -> %s\n",
    833  1.28   mjacob 			    isp->isp_name, isp2100_fw_statename((int)lwfs),
    834  1.28   mjacob 			    isp2100_fw_statename((int)fcp->isp_fwstate));
    835  1.23   mjacob 			lwfs = fcp->isp_fwstate;
    836  1.23   mjacob 		}
    837  1.23   mjacob 		if (fcp->isp_fwstate == FW_READY) {
    838  1.10   mjacob 			break;
    839  1.23   mjacob 		}
    840  1.23   mjacob 		SYS_DELAY(1000);	/* wait one millisecond */
    841  1.10   mjacob 	}
    842  1.13   mjacob 	isp->isp_sendmarker = 1;
    843  1.10   mjacob 
    844  1.10   mjacob 	/*
    845  1.23   mjacob 	 * Get our Loop ID
    846  1.23   mjacob 	 * (if possible)
    847  1.10   mjacob 	 */
    848  1.23   mjacob 	if (fcp->isp_fwstate == FW_READY) {
    849  1.10   mjacob 		mbs.param[0] = MBOX_GET_LOOP_ID;
    850  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
    851  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
    852  1.10   mjacob 			isp_dumpregs(isp, "GET LOOP ID failed");
    853  1.10   mjacob 			return;
    854  1.10   mjacob 		}
    855  1.10   mjacob 		fcp->isp_loopid = mbs.param[1];
    856  1.25   mjacob 		fcp->isp_alpa = mbs.param[2];
    857  1.28   mjacob 		PRINTF("%s: Loop ID %d, ALPA 0x%x\n", isp->isp_name,
    858  1.27   mjacob 		    fcp->isp_loopid, fcp->isp_alpa);
    859  1.27   mjacob 		isp->isp_state = ISP_INITSTATE;
    860  1.29   mjacob #ifdef	ISP_TARGET_MODE
    861  1.29   mjacob 		DISABLE_INTS(isp);
    862  1.29   mjacob 		if (isp_modify_lun(isp, 0, 1, 1)) {
    863  1.29   mjacob 			PRINTF("%s: failed to enable target mode\n",
    864  1.29   mjacob 			    isp->isp_name);
    865  1.29   mjacob 		}
    866  1.29   mjacob 		ENABLE_INTS(isp);
    867  1.29   mjacob #endif
    868  1.10   mjacob 	} else {
    869  1.23   mjacob 		PRINTF("%s: failed to go to FW READY state- will not attach\n",
    870  1.23   mjacob 		    isp->isp_name);
    871  1.23   mjacob 	}
    872   1.1      cgd }
    873   1.1      cgd 
    874   1.1      cgd /*
    875  1.23   mjacob  * Start a command. Locking is assumed done in the caller.
    876   1.1      cgd  */
    877  1.23   mjacob 
    878  1.23   mjacob int32_t
    879   1.1      cgd ispscsicmd(xs)
    880  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
    881   1.1      cgd {
    882   1.1      cgd 	struct ispsoftc *isp;
    883   1.1      cgd 	u_int8_t iptr, optr;
    884  1.10   mjacob 	union {
    885  1.10   mjacob 		ispreq_t *_reqp;
    886  1.10   mjacob 		ispreqt2_t *_t2reqp;
    887  1.10   mjacob 	} _u;
    888  1.10   mjacob #define	reqp	_u._reqp
    889  1.10   mjacob #define	t2reqp	_u._t2reqp
    890  1.16   mjacob #define	UZSIZE	max(sizeof (ispreq_t), sizeof (ispreqt2_t))
    891  1.23   mjacob 	int i;
    892   1.1      cgd 
    893  1.23   mjacob 	XS_INITERR(xs);
    894  1.23   mjacob 	isp = XS_ISP(xs);
    895   1.1      cgd 
    896  1.24   mjacob 	if (isp->isp_state != ISP_RUNSTATE) {
    897  1.24   mjacob 		PRINTF("%s: adapter not ready\n", isp->isp_name);
    898  1.24   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    899  1.24   mjacob 		return (CMD_COMPLETE);
    900  1.24   mjacob 	}
    901  1.24   mjacob 
    902  1.25   mjacob 	/*
    903  1.25   mjacob 	 * We *could* do the different sequence type that has clos
    904  1.25   mjacob 	 * to the whole Queue Entry for the command,.
    905  1.25   mjacob 	 */
    906  1.25   mjacob 	if (XS_CDBLEN(xs) > ((isp->isp_type & ISP_HA_FC)? 16 : 12)) {
    907  1.25   mjacob 		PRINTF("%s: unsupported cdb length (%d)\n",
    908  1.25   mjacob 		    isp->isp_name, XS_CDBLEN(xs));
    909  1.25   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    910  1.25   mjacob 		return (CMD_COMPLETE);
    911  1.25   mjacob 	}
    912  1.25   mjacob 
    913  1.25   mjacob 	/*
    914  1.25   mjacob 	 * First check to see if any HBA or Device
    915  1.25   mjacob 	 * parameters need to be updated.
    916  1.25   mjacob 	 */
    917  1.25   mjacob 	if (isp->isp_update) {
    918  1.25   mjacob 		isp_update(isp);
    919  1.10   mjacob 	}
    920  1.25   mjacob 
    921  1.25   mjacob 	optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
    922   1.1      cgd 	iptr = isp->isp_reqidx;
    923   1.1      cgd 
    924  1.10   mjacob 	reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
    925  1.25   mjacob 	iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
    926   1.1      cgd 	if (iptr == optr) {
    927  1.27   mjacob 		IDPRINTF(2, ("%s: Request Queue Overflow\n", isp->isp_name));
    928  1.23   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    929  1.23   mjacob 		return (CMD_EAGAIN);
    930   1.1      cgd 	}
    931  1.23   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    932  1.13   mjacob 		DISABLE_INTS(isp);
    933  1.23   mjacob 	}
    934  1.13   mjacob 
    935   1.1      cgd 	if (isp->isp_sendmarker) {
    936  1.25   mjacob 		u_int8_t niptr;
    937  1.10   mjacob 		ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
    938   1.1      cgd 
    939   1.1      cgd 		bzero((void *) marker, sizeof (*marker));
    940   1.1      cgd 		marker->req_header.rqs_entry_count = 1;
    941   1.1      cgd 		marker->req_header.rqs_entry_type = RQSTYPE_MARKER;
    942   1.1      cgd 		marker->req_modifier = SYNC_ALL;
    943   1.1      cgd 
    944   1.1      cgd 		isp->isp_sendmarker = 0;
    945   1.1      cgd 
    946  1.27   mjacob 		/*
    947  1.27   mjacob 		 * Unconditionally update the input pointer anyway.
    948  1.27   mjacob 		 */
    949  1.27   mjacob 		ISP_WRITE(isp, INMAILBOX4, iptr);
    950  1.27   mjacob 		isp->isp_reqidx = iptr;
    951  1.27   mjacob 
    952  1.25   mjacob 		niptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
    953  1.25   mjacob 		if (niptr == optr) {
    954  1.23   mjacob 			if (isp->isp_type & ISP_HA_FC) {
    955  1.13   mjacob 				ENABLE_INTS(isp);
    956  1.23   mjacob 			}
    957  1.27   mjacob 			IDPRINTF(2, ("%s: Request Queue Overflow+\n",
    958  1.27   mjacob 			    isp->isp_name));
    959  1.23   mjacob 			XS_SETERR(xs, HBA_BOTCH);
    960  1.23   mjacob 			return (CMD_EAGAIN);
    961   1.1      cgd 		}
    962  1.10   mjacob 		reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
    963  1.25   mjacob 		iptr = niptr;
    964   1.1      cgd 	}
    965   1.1      cgd 
    966  1.16   mjacob 	bzero((void *) reqp, UZSIZE);
    967  1.10   mjacob 	reqp->req_header.rqs_entry_count = 1;
    968  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    969  1.10   mjacob 		reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
    970  1.10   mjacob 	} else {
    971  1.10   mjacob 		reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
    972  1.10   mjacob 	}
    973  1.10   mjacob 	reqp->req_header.rqs_flags = 0;
    974  1.10   mjacob 	reqp->req_header.rqs_seqno = isp->isp_seqno++;
    975   1.1      cgd 
    976  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
    977   1.1      cgd 		if (isp->isp_xflist[i] == NULL)
    978   1.1      cgd 			break;
    979   1.1      cgd 	}
    980  1.23   mjacob 	if (i == RQUEST_QUEUE_LEN) {
    981  1.23   mjacob 		if (isp->isp_type & ISP_HA_FC)
    982  1.23   mjacob 			ENABLE_INTS(isp);
    983  1.27   mjacob 		IDPRINTF(2, ("%s: out of xflist pointers\n", isp->isp_name));
    984  1.23   mjacob 		XS_SETERR(xs, HBA_BOTCH);
    985  1.23   mjacob 		return (CMD_EAGAIN);
    986   1.1      cgd 	} else {
    987  1.10   mjacob 		/*
    988  1.10   mjacob 		 * Never have a handle that is zero, so
    989  1.10   mjacob 		 * set req_handle off by one.
    990  1.10   mjacob 		 */
    991   1.1      cgd 		isp->isp_xflist[i] = xs;
    992  1.10   mjacob 		reqp->req_handle = i+1;
    993   1.1      cgd 	}
    994   1.1      cgd 
    995  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
    996  1.10   mjacob 		/*
    997  1.10   mjacob 		 * See comment in isp_intr
    998  1.10   mjacob 		 */
    999  1.23   mjacob 		XS_RESID(xs) = 0;
   1000  1.10   mjacob 		/*
   1001  1.16   mjacob 		 * Fibre Channel always requires some kind of tag.
   1002  1.23   mjacob 		 * If we're marked as "Can't Tag", just do simple
   1003  1.23   mjacob 		 * instead of ordered tags. It's pretty clear to me
   1004  1.23   mjacob 		 * that we shouldn't do head of queue tagging in
   1005  1.23   mjacob 		 * this case.
   1006  1.10   mjacob 		 */
   1007  1.23   mjacob 		if (XS_CANTAG(xs)) {
   1008  1.23   mjacob 			t2reqp->req_flags = XS_KINDOF_TAG(xs);
   1009  1.10   mjacob 		} else {
   1010  1.23   mjacob  			t2reqp->req_flags = REQFLAG_STAG;
   1011  1.10   mjacob 		}
   1012  1.10   mjacob 	} else {
   1013  1.23   mjacob 		sdparam *sdp = (sdparam *)isp->isp_param;
   1014  1.25   mjacob 		if ((sdp->isp_devparam[XS_TGT(xs)].cur_dflags & DPARM_TQING) &&
   1015  1.23   mjacob 		    XS_CANTAG(xs)) {
   1016  1.23   mjacob 			reqp->req_flags = XS_KINDOF_TAG(xs);
   1017  1.23   mjacob 		} else {
   1018  1.10   mjacob 			reqp->req_flags = 0;
   1019  1.10   mjacob 		}
   1020  1.10   mjacob 	}
   1021  1.23   mjacob 	reqp->req_target = XS_TGT(xs);
   1022  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
   1023  1.28   mjacob 		reqp->req_lun_trn = XS_LUN(xs);
   1024  1.23   mjacob 		reqp->req_cdblen = XS_CDBLEN(xs);
   1025  1.28   mjacob 	} else {
   1026  1.28   mjacob #ifdef	SCCLUN
   1027  1.28   mjacob 		reqp->req_scclun = XS_LUN(xs);
   1028  1.28   mjacob #else
   1029  1.28   mjacob 		reqp->req_lun_trn = XS_LUN(xs);
   1030  1.28   mjacob #endif
   1031  1.28   mjacob 
   1032  1.10   mjacob 	}
   1033  1.23   mjacob 	bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs));
   1034   1.1      cgd 
   1035  1.23   mjacob 	IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
   1036  1.23   mjacob 	    XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno,
   1037  1.23   mjacob 	    reqp->req_cdb[0], XS_XFRLEN(xs)));
   1038   1.1      cgd 
   1039  1.23   mjacob 	reqp->req_time = XS_TIME(xs) / 1000;
   1040  1.23   mjacob 	if (reqp->req_time == 0 && XS_TIME(xs))
   1041  1.10   mjacob 		reqp->req_time = 1;
   1042  1.27   mjacob 	i = ISP_DMASETUP(isp, xs, reqp, &iptr, optr);
   1043  1.27   mjacob 	if (i != CMD_QUEUED) {
   1044  1.13   mjacob 		if (isp->isp_type & ISP_HA_FC)
   1045  1.13   mjacob 			ENABLE_INTS(isp);
   1046  1.27   mjacob 		/*
   1047  1.27   mjacob 		 * dmasetup sets actual error in packet, and
   1048  1.27   mjacob 		 * return what we were given to return.
   1049  1.27   mjacob 		 */
   1050  1.27   mjacob 		return (i);
   1051   1.1      cgd 	}
   1052  1.23   mjacob 	XS_SETERR(xs, HBA_NOERROR);
   1053   1.1      cgd 	ISP_WRITE(isp, INMAILBOX4, iptr);
   1054   1.1      cgd 	isp->isp_reqidx = iptr;
   1055  1.23   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1056  1.13   mjacob 		ENABLE_INTS(isp);
   1057   1.3      cgd 	}
   1058  1.23   mjacob 	isp->isp_nactive++;
   1059  1.23   mjacob 	return (CMD_QUEUED);
   1060  1.10   mjacob #undef	reqp
   1061  1.10   mjacob #undef	t2reqp
   1062   1.1      cgd }
   1063   1.1      cgd 
   1064   1.1      cgd /*
   1065  1.23   mjacob  * isp control
   1066  1.23   mjacob  * Locks (ints blocked) assumed held.
   1067   1.1      cgd  */
   1068   1.1      cgd 
   1069   1.1      cgd int
   1070  1.23   mjacob isp_control(isp, ctl, arg)
   1071   1.1      cgd 	struct ispsoftc *isp;
   1072  1.23   mjacob 	ispctl_t ctl;
   1073  1.23   mjacob 	void *arg;
   1074   1.1      cgd {
   1075  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
   1076  1.23   mjacob 	mbreg_t mbs;
   1077  1.23   mjacob 	int i;
   1078   1.3      cgd 
   1079  1.23   mjacob 	switch (ctl) {
   1080  1.23   mjacob 	default:
   1081  1.23   mjacob 		PRINTF("%s: isp_control unknown control op %x\n",
   1082  1.23   mjacob 		    isp->isp_name, ctl);
   1083  1.23   mjacob 		break;
   1084   1.3      cgd 
   1085  1.23   mjacob 	case ISPCTL_RESET_BUS:
   1086  1.23   mjacob 		mbs.param[0] = MBOX_BUS_RESET;
   1087  1.27   mjacob 		mbs.param[1] = (isp->isp_type & ISP_HA_FC)? 5: 2;
   1088  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
   1089  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1090  1.23   mjacob 			isp_dumpregs(isp, "isp_control SCSI bus reset failed");
   1091  1.23   mjacob 			break;
   1092  1.23   mjacob 		}
   1093  1.23   mjacob 		/*
   1094  1.23   mjacob 		 * This is really important to have set after a bus reset.
   1095  1.23   mjacob 		 */
   1096  1.23   mjacob 		isp->isp_sendmarker = 1;
   1097  1.25   mjacob 		PRINTF("%s: driver initiated bus reset\n", isp->isp_name);
   1098  1.23   mjacob 		return (0);
   1099  1.23   mjacob 
   1100  1.23   mjacob         case ISPCTL_RESET_DEV:
   1101  1.23   mjacob 		/*
   1102  1.23   mjacob 		 * Note that under parallel SCSI, this issues a BDR message.
   1103  1.23   mjacob 		 * Under FC, we could probably be using ABORT TASK SET
   1104  1.23   mjacob 		 * command.
   1105  1.23   mjacob 		 */
   1106  1.23   mjacob 
   1107  1.23   mjacob 		mbs.param[0] = MBOX_ABORT_TARGET;
   1108  1.23   mjacob 		mbs.param[1] = ((long)arg) << 8;
   1109  1.23   mjacob 		mbs.param[2] = 2;	/* 'delay', in seconds */
   1110  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
   1111  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1112  1.23   mjacob 			isp_dumpregs(isp, "SCSI Target  reset failed");
   1113  1.23   mjacob 			break;
   1114  1.23   mjacob 		}
   1115  1.23   mjacob 		PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name,
   1116  1.23   mjacob 		    (int) ((long) arg));
   1117  1.23   mjacob 		isp->isp_sendmarker = 1;
   1118  1.23   mjacob 		return (0);
   1119  1.23   mjacob 
   1120  1.23   mjacob         case ISPCTL_ABORT_CMD:
   1121  1.23   mjacob 		xs = (ISP_SCSI_XFER_T *) arg;
   1122  1.23   mjacob 		for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   1123  1.23   mjacob 			if (xs == isp->isp_xflist[i]) {
   1124  1.23   mjacob 				break;
   1125  1.23   mjacob 			}
   1126  1.23   mjacob 		}
   1127  1.23   mjacob 		if (i == RQUEST_QUEUE_LEN) {
   1128  1.23   mjacob 			PRINTF("%s: isp_control- cannot find command to abort "
   1129  1.23   mjacob 			    "in active list\n", isp->isp_name);
   1130  1.23   mjacob 			break;
   1131  1.23   mjacob 		}
   1132  1.23   mjacob 		mbs.param[0] = MBOX_ABORT;
   1133  1.28   mjacob #ifdef	SCCLUN
   1134  1.28   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   1135  1.28   mjacob 			mbs.param[1] = XS_TGT(xs) << 8;
   1136  1.28   mjacob 			mbs.param[4] = 0;
   1137  1.28   mjacob 			mbs.param[5] = 0;
   1138  1.28   mjacob 			mbs.param[6] = XS_LUN(xs);
   1139  1.28   mjacob 		} else {
   1140  1.28   mjacob 			mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
   1141  1.28   mjacob 		}
   1142  1.28   mjacob #else
   1143  1.28   mjacob 		mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
   1144  1.28   mjacob #endif
   1145  1.23   mjacob 		mbs.param[2] = (i+1) >> 16;
   1146  1.23   mjacob 		mbs.param[3] = (i+1) & 0xffff;
   1147  1.23   mjacob 		isp_mboxcmd(isp, &mbs);
   1148  1.23   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   1149  1.23   mjacob 			PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n",
   1150  1.23   mjacob 			    isp->isp_name, mbs.param[0]);
   1151  1.23   mjacob 			break;
   1152  1.23   mjacob 		}
   1153  1.23   mjacob 		PRINTF("%s: command for target %d lun %d was aborted\n",
   1154  1.23   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   1155  1.23   mjacob 		return (0);
   1156  1.26   mjacob 
   1157  1.26   mjacob 	case ISPCTL_UPDATE_PARAMS:
   1158  1.26   mjacob 		isp_update(isp);
   1159  1.26   mjacob 		return(0);
   1160   1.1      cgd 	}
   1161  1.23   mjacob 	return (-1);
   1162   1.1      cgd }
   1163   1.1      cgd 
   1164  1.23   mjacob /*
   1165  1.23   mjacob  * Interrupt Service Routine(s).
   1166  1.23   mjacob  *
   1167  1.23   mjacob  * External (OS) framework has done the appropriate locking,
   1168  1.23   mjacob  * and the locking will be held throughout this function.
   1169  1.23   mjacob  */
   1170  1.23   mjacob 
   1171   1.1      cgd int
   1172   1.1      cgd isp_intr(arg)
   1173   1.1      cgd 	void *arg;
   1174   1.1      cgd {
   1175  1.25   mjacob 	ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs;
   1176   1.1      cgd 	struct ispsoftc *isp = arg;
   1177  1.25   mjacob 	u_int8_t iptr, optr;
   1178  1.25   mjacob 	u_int16_t isr;
   1179  1.23   mjacob 	int i, ndone = 0;
   1180   1.1      cgd 
   1181   1.1      cgd 	isr = ISP_READ(isp, BIU_ISR);
   1182  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1183  1.10   mjacob 		if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
   1184  1.10   mjacob 			if (isr) {
   1185  1.20   mjacob 				IDPRINTF(4, ("%s: isp_intr isr=%x\n",
   1186  1.10   mjacob 					     isp->isp_name, isr));
   1187  1.10   mjacob 			}
   1188  1.10   mjacob 			return (0);
   1189  1.10   mjacob 		}
   1190  1.10   mjacob 	} else {
   1191  1.10   mjacob 		if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
   1192  1.10   mjacob 			if (isr) {
   1193  1.20   mjacob 				IDPRINTF(4, ("%s: isp_intr isr=%x\n",
   1194  1.10   mjacob 					     isp->isp_name, isr));
   1195  1.10   mjacob 			}
   1196  1.10   mjacob 			return (0);
   1197   1.1      cgd 		}
   1198   1.1      cgd 	}
   1199   1.1      cgd 
   1200   1.1      cgd 	if (ISP_READ(isp, BIU_SEMA) & 1) {
   1201  1.23   mjacob 		u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
   1202  1.28   mjacob 		if (isp_parse_async(isp, (int) mbox))
   1203  1.24   mjacob 			return (1);
   1204   1.1      cgd 		ISP_WRITE(isp, BIU_SEMA, 0);
   1205   1.1      cgd 	}
   1206   1.1      cgd 
   1207  1.10   mjacob 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   1208  1.25   mjacob 
   1209  1.24   mjacob 	optr = isp->isp_residx;
   1210  1.10   mjacob 	iptr = ISP_READ(isp, OUTMAILBOX5);
   1211  1.24   mjacob 
   1212  1.10   mjacob 	if (optr == iptr) {
   1213  1.20   mjacob 		IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n",
   1214  1.25   mjacob 		    isr, optr, iptr));
   1215  1.10   mjacob 	}
   1216  1.10   mjacob 	ENABLE_INTS(isp);
   1217  1.10   mjacob 
   1218   1.1      cgd 	while (optr != iptr) {
   1219   1.1      cgd 		ispstatusreq_t *sp;
   1220  1.25   mjacob 		u_int8_t oop;
   1221   1.1      cgd 		int buddaboom = 0;
   1222   1.1      cgd 
   1223   1.7  thorpej 		sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
   1224  1.25   mjacob 		oop = optr;
   1225  1.25   mjacob 		optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN);
   1226   1.1      cgd 
   1227   1.1      cgd 		if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
   1228  1.25   mjacob 			if (isp_handle_other_response(isp, sp, &optr) == 0) {
   1229  1.25   mjacob 				ISP_WRITE(isp, INMAILBOX5, optr);
   1230  1.25   mjacob 				continue;
   1231  1.25   mjacob 			}
   1232  1.25   mjacob 			/*
   1233  1.25   mjacob 			 * It really has to be a bounced request just copied
   1234  1.25   mjacob 			 * from the request queue to the response queue.
   1235  1.25   mjacob 			 */
   1236  1.25   mjacob 
   1237   1.1      cgd 			if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
   1238   1.1      cgd 				ISP_WRITE(isp, INMAILBOX5, optr);
   1239   1.1      cgd 				continue;
   1240   1.1      cgd 			}
   1241  1.25   mjacob 			PRINTF("%s: not RESPONSE in RESPONSE Queue "
   1242  1.25   mjacob 			    "(type 0x%x) @ idx %d (next %d)\n", isp->isp_name,
   1243  1.25   mjacob 			    sp->req_header.rqs_entry_type, oop, optr);
   1244   1.1      cgd 			buddaboom = 1;
   1245   1.1      cgd 		}
   1246   1.1      cgd 
   1247   1.1      cgd 		if (sp->req_header.rqs_flags & 0xf) {
   1248   1.1      cgd 			if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
   1249   1.1      cgd 				ISP_WRITE(isp, INMAILBOX5, optr);
   1250   1.1      cgd 				continue;
   1251   1.1      cgd 			}
   1252  1.23   mjacob 			PRINTF("%s: rqs_flags=%x", isp->isp_name,
   1253   1.1      cgd 				sp->req_header.rqs_flags & 0xf);
   1254  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
   1255  1.23   mjacob 				PRINTF("%s: internal queues full\n",
   1256  1.23   mjacob 				    isp->isp_name);
   1257  1.23   mjacob 				/* XXXX: this command *could* get restarted */
   1258  1.23   mjacob 				buddaboom++;
   1259  1.23   mjacob 			}
   1260  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
   1261  1.23   mjacob 				PRINTF("%s: bad header\n", isp->isp_name);
   1262  1.23   mjacob 				buddaboom++;
   1263  1.23   mjacob 			}
   1264  1.23   mjacob 			if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
   1265  1.23   mjacob 				PRINTF("%s: bad request packet\n",
   1266  1.23   mjacob 				    isp->isp_name);
   1267  1.23   mjacob 				buddaboom++;
   1268  1.23   mjacob 			}
   1269   1.1      cgd 		}
   1270  1.23   mjacob 		if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) {
   1271  1.23   mjacob 			PRINTF("%s: bad request handle %d\n", isp->isp_name,
   1272   1.1      cgd 				sp->req_handle);
   1273   1.1      cgd 			ISP_WRITE(isp, INMAILBOX5, optr);
   1274   1.1      cgd 			continue;
   1275   1.1      cgd 		}
   1276  1.23   mjacob 		xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1];
   1277   1.1      cgd 		if (xs == NULL) {
   1278  1.23   mjacob 			PRINTF("%s: NULL xs in xflist (handle %x)\n",
   1279  1.23   mjacob 			    isp->isp_name, sp->req_handle);
   1280  1.23   mjacob 			isp_dumpxflist(isp);
   1281   1.1      cgd 			ISP_WRITE(isp, INMAILBOX5, optr);
   1282   1.1      cgd 			continue;
   1283   1.1      cgd 		}
   1284  1.10   mjacob 		isp->isp_xflist[sp->req_handle - 1] = NULL;
   1285   1.1      cgd 		if (sp->req_status_flags & RQSTF_BUS_RESET) {
   1286   1.1      cgd 			isp->isp_sendmarker = 1;
   1287   1.1      cgd 		}
   1288   1.1      cgd 		if (buddaboom) {
   1289  1.23   mjacob 			XS_SETERR(xs, HBA_BOTCH);
   1290   1.1      cgd 		}
   1291  1.23   mjacob 		XS_STS(xs) = sp->req_scsi_status & 0xff;
   1292  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   1293  1.10   mjacob 			if (sp->req_state_flags & RQSF_GOT_SENSE) {
   1294  1.23   mjacob 				bcopy(sp->req_sense_data, XS_SNSP(xs),
   1295  1.23   mjacob 					XS_SNSLEN(xs));
   1296  1.23   mjacob 				XS_SNS_IS_VALID(xs);
   1297  1.10   mjacob 			}
   1298  1.10   mjacob 		} else {
   1299  1.23   mjacob 			if (XS_STS(xs) == SCSI_CHECK) {
   1300  1.23   mjacob 				XS_SNS_IS_VALID(xs);
   1301  1.23   mjacob 				bcopy(sp->req_sense_data, XS_SNSP(xs),
   1302  1.23   mjacob 					XS_SNSLEN(xs));
   1303  1.10   mjacob 				sp->req_state_flags |= RQSF_GOT_SENSE;
   1304  1.10   mjacob 			}
   1305   1.1      cgd 		}
   1306  1.23   mjacob 		if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) {
   1307  1.23   mjacob 			XS_SETERR(xs, HBA_TGTBSY);
   1308  1.10   mjacob 		}
   1309   1.1      cgd 
   1310   1.1      cgd 		if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
   1311  1.25   mjacob 			if (XS_NOERR(xs)) {
   1312  1.25   mjacob 			    if (sp->req_completion_status != RQCS_COMPLETE) {
   1313  1.23   mjacob 				isp_parse_status(isp, sp, xs);
   1314  1.25   mjacob 			    } else {
   1315  1.25   mjacob 				XS_SETERR(xs, HBA_NOERROR);
   1316  1.25   mjacob 			    }
   1317  1.25   mjacob 			}
   1318   1.1      cgd 		} else {
   1319  1.23   mjacob 			PRINTF("%s: unknown return %x\n", isp->isp_name,
   1320   1.1      cgd 				sp->req_header.rqs_entry_type);
   1321  1.23   mjacob 			if (XS_NOERR(xs))
   1322  1.23   mjacob 				XS_SETERR(xs, HBA_BOTCH);
   1323   1.1      cgd 		}
   1324  1.10   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   1325  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1326  1.10   mjacob 		} else if (sp->req_scsi_status & RQCS_RU) {
   1327  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   1328  1.20   mjacob 			IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
   1329  1.23   mjacob 				XS_XFRLEN(xs), sp->req_resid));
   1330  1.10   mjacob 		}
   1331  1.23   mjacob 		if (XS_XFRLEN(xs)) {
   1332  1.10   mjacob 			ISP_DMAFREE(isp, xs, sp->req_handle - 1);
   1333   1.1      cgd 		}
   1334  1.23   mjacob 		/*
   1335  1.23   mjacob 		 * XXX: If we have a check condition, but no Sense Data,
   1336  1.23   mjacob 		 * XXX: mark it as an error (ARQ failed). We need to
   1337  1.23   mjacob 		 * XXX: to do a more distinct job because there may
   1338  1.23   mjacob 		 * XXX: cases where ARQ is disabled.
   1339  1.23   mjacob 		 */
   1340  1.23   mjacob 		if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) {
   1341  1.23   mjacob 			if (XS_NOERR(xs)) {
   1342  1.28   mjacob 				PRINTF("%s: ARQ failure for target %d lun %d\n",
   1343  1.28   mjacob 				    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   1344  1.23   mjacob 				XS_SETERR(xs, HBA_ARQFAIL);
   1345  1.23   mjacob 			}
   1346  1.23   mjacob 		}
   1347  1.23   mjacob 		if ((isp->isp_dblev >= 5) ||
   1348  1.23   mjacob 		    (isp->isp_dblev > 2 && !XS_NOERR(xs))) {
   1349  1.23   mjacob 			PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x",
   1350  1.23   mjacob 			    isp->isp_name, XS_TGT(xs), XS_LUN(xs),
   1351  1.23   mjacob 			    sp->req_header.rqs_seqno, XS_XFRLEN(xs),
   1352  1.23   mjacob 			    XS_RESID(xs), XS_STS(xs));
   1353  1.10   mjacob 			if (sp->req_state_flags & RQSF_GOT_SENSE) {
   1354  1.23   mjacob 				PRINTF(" Skey: %x", XS_SNSKEY(xs));
   1355  1.23   mjacob 				if (!(XS_IS_SNS_VALID(xs))) {
   1356  1.23   mjacob 					PRINTF(" BUT NOT SET");
   1357  1.10   mjacob 				}
   1358   1.1      cgd 			}
   1359  1.27   mjacob 			PRINTF(" XS_ERR=0x%x\n", (unsigned int) XS_ERR(xs));
   1360   1.1      cgd 		}
   1361  1.23   mjacob 
   1362   1.1      cgd 		ISP_WRITE(isp, INMAILBOX5, optr);
   1363  1.28   mjacob 		if (isp->isp_nactive > 0)
   1364  1.28   mjacob 		    isp->isp_nactive--;
   1365  1.25   mjacob 		complist[ndone++] = xs;	/* defer completion call until later */
   1366   1.1      cgd 	}
   1367  1.27   mjacob 	/*
   1368  1.27   mjacob 	 * If we completed any commands, then it's valid to find out
   1369  1.27   mjacob 	 * what the outpointer is.
   1370  1.27   mjacob 	 */
   1371  1.27   mjacob 	if (ndone) {
   1372  1.27   mjacob 	 	isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
   1373  1.27   mjacob 	}
   1374   1.1      cgd 	isp->isp_residx = optr;
   1375  1.25   mjacob 	for (i = 0; i < ndone; i++) {
   1376  1.25   mjacob 		xs = complist[i];
   1377  1.25   mjacob 		if (xs) {
   1378  1.25   mjacob 			XS_CMD_DONE(xs);
   1379  1.25   mjacob 		}
   1380  1.25   mjacob 	}
   1381   1.1      cgd 	return (1);
   1382   1.1      cgd }
   1383   1.1      cgd 
   1384   1.1      cgd /*
   1385   1.1      cgd  * Support routines.
   1386   1.1      cgd  */
   1387   1.1      cgd 
   1388  1.25   mjacob static int
   1389  1.25   mjacob isp_parse_async(isp, mbox)
   1390  1.25   mjacob 	struct ispsoftc *isp;
   1391  1.28   mjacob 	int mbox;
   1392  1.25   mjacob {
   1393  1.25   mjacob 	switch (mbox) {
   1394  1.25   mjacob 	case ASYNC_BUS_RESET:
   1395  1.25   mjacob 		PRINTF("%s: SCSI bus reset detected\n", isp->isp_name);
   1396  1.25   mjacob 		isp->isp_sendmarker = 1;
   1397  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1398  1.29   mjacob 		isp_notify_ack(isp, NULL);
   1399  1.29   mjacob #endif
   1400  1.25   mjacob 		break;
   1401  1.25   mjacob 
   1402  1.25   mjacob 	case ASYNC_SYSTEM_ERROR:
   1403  1.25   mjacob 		mbox = ISP_READ(isp, OUTMAILBOX1);
   1404  1.25   mjacob 		PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n",
   1405  1.25   mjacob 		    isp->isp_name, mbox);
   1406  1.25   mjacob 		isp_restart(isp);
   1407  1.25   mjacob 		/* no point continuing after this */
   1408  1.25   mjacob 		return (1);
   1409  1.25   mjacob 
   1410  1.25   mjacob 	case ASYNC_RQS_XFER_ERR:
   1411  1.25   mjacob 		PRINTF("%s: Request Queue Transfer Error\n", isp->isp_name);
   1412  1.25   mjacob 		break;
   1413  1.25   mjacob 
   1414  1.25   mjacob 	case ASYNC_RSP_XFER_ERR:
   1415  1.25   mjacob 		PRINTF("%s: Response Queue Transfer Error\n", isp->isp_name);
   1416  1.25   mjacob 		break;
   1417  1.25   mjacob 
   1418  1.25   mjacob 	case ASYNC_QWAKEUP:
   1419  1.25   mjacob 		/* don't need to be chatty */
   1420  1.25   mjacob 		mbox = ISP_READ(isp, OUTMAILBOX4);
   1421  1.25   mjacob 		break;
   1422  1.25   mjacob 
   1423  1.25   mjacob 	case ASYNC_TIMEOUT_RESET:
   1424  1.25   mjacob 		PRINTF("%s: timeout initiated SCSI bus reset\n", isp->isp_name);
   1425  1.25   mjacob 		isp->isp_sendmarker = 1;
   1426  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1427  1.29   mjacob 		isp_notify_ack(isp, NULL);
   1428  1.29   mjacob #endif
   1429  1.25   mjacob 		break;
   1430  1.25   mjacob 
   1431  1.28   mjacob 	case ASYNC_DEVICE_RESET:
   1432  1.28   mjacob 		PRINTF("%s: device reset\n", isp->isp_name);
   1433  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1434  1.29   mjacob 		isp_notify_ack(isp, NULL);
   1435  1.29   mjacob #endif
   1436  1.25   mjacob 		break;
   1437  1.25   mjacob 
   1438  1.25   mjacob 	case ASYNC_EXTMSG_UNDERRUN:
   1439  1.25   mjacob 		PRINTF("%s: extended message underrun\n", isp->isp_name);
   1440  1.25   mjacob 		break;
   1441  1.25   mjacob 
   1442  1.25   mjacob 	case ASYNC_SCAM_INT:
   1443  1.25   mjacob 		PRINTF("%s: SCAM interrupt\n", isp->isp_name);
   1444  1.25   mjacob 		break;
   1445  1.25   mjacob 
   1446  1.25   mjacob 	case ASYNC_HUNG_SCSI:
   1447  1.25   mjacob 		PRINTF("%s: stalled SCSI Bus after DATA Overrun\n",
   1448  1.25   mjacob 		    isp->isp_name);
   1449  1.25   mjacob 		/* XXX: Need to issue SCSI reset at this point */
   1450  1.25   mjacob 		break;
   1451  1.25   mjacob 
   1452  1.25   mjacob 	case ASYNC_KILLED_BUS:
   1453  1.25   mjacob 		PRINTF("%s: SCSI Bus reset after DATA Overrun\n",
   1454  1.25   mjacob 		    isp->isp_name);
   1455  1.25   mjacob 		break;
   1456  1.25   mjacob 
   1457  1.25   mjacob 	case ASYNC_BUS_TRANSIT:
   1458  1.25   mjacob 		PRINTF("%s: LBD->HVD Transition 0x%x\n",
   1459  1.25   mjacob 		    isp->isp_name, ISP_READ(isp, OUTMAILBOX1));
   1460  1.25   mjacob 		break;
   1461  1.25   mjacob 
   1462  1.25   mjacob 	case ASYNC_CMD_CMPLT:
   1463  1.25   mjacob 		PRINTF("%s: fast post completion\n", isp->isp_name);
   1464  1.25   mjacob #if	0
   1465  1.25   mjacob 		fast_post_handle = (ISP_READ(isp, OUTMAILBOX1) << 16) |
   1466  1.25   mjacob 		    ISP_READ(isp, OUTMAILBOX2);
   1467  1.25   mjacob #endif
   1468  1.25   mjacob 		break;
   1469  1.25   mjacob 
   1470  1.25   mjacob 	case ASYNC_CTIO_DONE:
   1471  1.28   mjacob 		/* Should only occur when Fast Posting Set for 2100s */
   1472  1.25   mjacob 		PRINTF("%s: CTIO done\n", isp->isp_name);
   1473  1.25   mjacob 		break;
   1474  1.25   mjacob 
   1475  1.25   mjacob 	case ASYNC_LIP_OCCURRED:
   1476  1.25   mjacob 		PRINTF("%s: LIP occurred\n", isp->isp_name);
   1477  1.25   mjacob 		break;
   1478  1.25   mjacob 
   1479  1.25   mjacob 	case ASYNC_LOOP_UP:
   1480  1.25   mjacob 		PRINTF("%s: Loop UP\n", isp->isp_name);
   1481  1.25   mjacob 		break;
   1482  1.25   mjacob 
   1483  1.25   mjacob 	case ASYNC_LOOP_DOWN:
   1484  1.25   mjacob 		PRINTF("%s: Loop DOWN\n", isp->isp_name);
   1485  1.25   mjacob 		break;
   1486  1.25   mjacob 
   1487  1.25   mjacob 	case ASYNC_LOOP_RESET:
   1488  1.25   mjacob 		PRINTF("%s: Loop RESET\n", isp->isp_name);
   1489  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1490  1.29   mjacob 		isp_notify_ack(isp, NULL);
   1491  1.29   mjacob #endif
   1492  1.25   mjacob 		break;
   1493  1.25   mjacob 
   1494  1.25   mjacob 	case ASYNC_PDB_CHANGED:
   1495  1.25   mjacob 		PRINTF("%s: Port Database Changed\n", isp->isp_name);
   1496  1.25   mjacob 		break;
   1497  1.25   mjacob 
   1498  1.25   mjacob 	case ASYNC_CHANGE_NOTIFY:
   1499  1.25   mjacob 		PRINTF("%s: Name Server Database Changed\n", isp->isp_name);
   1500  1.25   mjacob 		break;
   1501  1.25   mjacob 
   1502  1.25   mjacob 	default:
   1503  1.25   mjacob 		PRINTF("%s: async %x\n", isp->isp_name, mbox);
   1504  1.25   mjacob 		break;
   1505  1.25   mjacob 	}
   1506  1.25   mjacob 	return (0);
   1507  1.25   mjacob }
   1508  1.25   mjacob 
   1509  1.25   mjacob static int
   1510  1.25   mjacob isp_handle_other_response(isp, sp, optrp)
   1511  1.25   mjacob 	struct ispsoftc *isp;
   1512  1.25   mjacob 	ispstatusreq_t *sp;
   1513  1.25   mjacob 	u_int8_t *optrp;
   1514  1.25   mjacob {
   1515  1.27   mjacob 	u_int8_t iptr, optr;
   1516  1.27   mjacob 	int reqsize = 0;
   1517  1.27   mjacob 	void *ireqp = NULL;
   1518  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1519  1.29   mjacob 	union {
   1520  1.29   mjacob 		at_entry_t	*atio;
   1521  1.29   mjacob 		at2_entry_t	*at2io;
   1522  1.29   mjacob 		ct_entry_t	*ctio;
   1523  1.29   mjacob 		ct2_entry_t	*ct2io;
   1524  1.29   mjacob 		lun_entry_t	*lunen;
   1525  1.29   mjacob 		in_entry_t	*inot;
   1526  1.29   mjacob 		in_fcentry_t	*inot_fc;
   1527  1.29   mjacob 		na_entry_t	*nack;
   1528  1.29   mjacob 		na_fcentry_t	*nack_fc;
   1529  1.29   mjacob 		void            *voidp;
   1530  1.29   mjacob #define	atio	un.atio
   1531  1.29   mjacob #define	at2io	un.at2io
   1532  1.29   mjacob #define	ctio	un.ctio
   1533  1.29   mjacob #define	ct2io	un.ct2io
   1534  1.29   mjacob #define	lunen	un.lunen
   1535  1.29   mjacob #define	inot	un.inot
   1536  1.29   mjacob #define	inot_fc	un.inot_fc
   1537  1.29   mjacob #define	nack	un.nack
   1538  1.29   mjacob #define	nack_fc	un.nack_fc
   1539  1.29   mjacob 	} un;
   1540  1.29   mjacob 
   1541  1.29   mjacob 	un.voidp = sp;
   1542  1.29   mjacob #endif
   1543  1.27   mjacob 
   1544  1.28   mjacob 
   1545  1.25   mjacob 	switch (sp->req_header.rqs_entry_type) {
   1546  1.27   mjacob 	case RQSTYPE_REQUEST:
   1547  1.27   mjacob 		return (-1);
   1548  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1549  1.29   mjacob 	case RQSTYPE_NOTIFY_ACK:
   1550  1.29   mjacob 	{
   1551  1.29   mjacob 		static const char *f =
   1552  1.29   mjacob 			"%s: Notify Ack Status 0x%x Sequence Id 0x%x\n"
   1553  1.29   mjacob 		/*
   1554  1.29   mjacob 		 * The ISP is acknowleding our ack of an Immediate Notify.
   1555  1.29   mjacob 		 */
   1556  1.29   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   1557  1.29   mjacob 			PRINTF(f, isp->isp_name,
   1558  1.29   mjacob 			    nack_fc->na-status, nack_fc->na_seqid);
   1559  1.29   mjacob 		} else {
   1560  1.29   mjacob 			PRINTF(f, isp->isp_name,
   1561  1.29   mjacob 			    nack->na_status, nack->na_seqid);
   1562  1.29   mjacob 		}
   1563  1.29   mjacob 		break;
   1564  1.29   mjacob 	}
   1565  1.29   mjacob 	case RQSTYPE_NOTIFY:
   1566  1.29   mjacob 	{
   1567  1.29   mjacob 		u_int16_t seqid, status;
   1568  1.29   mjacob 
   1569  1.29   mjacob 		/*
   1570  1.29   mjacob 		 * Either the ISP received a SCSI message it cannot handle
   1571  1.29   mjacob 		 * or some other out of band condition (e.g., Port Logout)
   1572  1.29   mjacob 		 * or it is returning an Immediate Notify entry we sent.
   1573  1.29   mjacob 		 */
   1574  1.29   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   1575  1.29   mjacob 			status = inot_fc->status;
   1576  1.29   mjacob 			seqid = inot_fc->in_seqid;
   1577  1.29   mjacob 		} else {
   1578  1.29   mjacob 			status = inot->status;
   1579  1.29   mjacob 			seqid = inot->seqid & 0xff;
   1580  1.29   mjacob 		}
   1581  1.29   mjacob 		PRINTF("%s: Immediate Notify Status 0x%x Sequence Id 0x%x\n",
   1582  1.29   mjacob 		    isp->isp_name, status, seqid);
   1583  1.29   mjacob 
   1584  1.29   mjacob 		switch (status) {
   1585  1.29   mjacob 		case IN_MSG_RECEIVED:
   1586  1.29   mjacob 		case IN_IDE_RECEIVED:
   1587  1.29   mjacob 			ptisp_got_msg(ptp, &inot);
   1588  1.29   mjacob 			break;
   1589  1.29   mjacob 		case IN_RSRC_UNAVAIL:
   1590  1.29   mjacob                         PRINTF("%s: Firmware out of ATIOs\n", isp->isp_name);
   1591  1.29   mjacob                         break;
   1592  1.29   mjacob                 case IN_ABORT_TASK:
   1593  1.29   mjacob 			PRINTF("%s: Abort Task iid %d rx_id 0x%x\n",
   1594  1.29   mjacob 			    inot_fc->in_iid, seqid);
   1595  1.29   mjacob                         break;
   1596  1.29   mjacob                 case IN_PORT_LOGOUT:
   1597  1.29   mjacob 			PRINTF("%s: Port Logout for Initiator %d\n",
   1598  1.29   mjacob 			    isp->isp_name, inot_fc->in_iid);
   1599  1.29   mjacob                         break;
   1600  1.29   mjacob                 default:
   1601  1.29   mjacob 			PRINTF("%s: bad status (0x%x) in Immediate Notify\n",
   1602  1.29   mjacob                             isp->isp_name, status);
   1603  1.29   mjacob                         break;
   1604  1.29   mjacob 
   1605  1.29   mjacob 		}
   1606  1.29   mjacob 		isp_notify_ack(isp, un.voidp);
   1607  1.29   mjacob 		reqsize = 0;
   1608  1.29   mjacob 		break;
   1609  1.29   mjacob 	}
   1610  1.29   mjacob 	case RQSTYPE_ENABLE_LUN:
   1611  1.29   mjacob 	case RQSTYPE_MODIFY_LUN:
   1612  1.29   mjacob 		if (lunen->req_status != 1) {
   1613  1.29   mjacob 		    PRINTF("%s: ENABLE/MODIFY LUN returned status 0x%x\n",
   1614  1.29   mjacob 			isp->isp_name, lunen->req_status);
   1615  1.29   mjacob 		}
   1616  1.29   mjacob 		break;
   1617  1.29   mjacob 	case RQSTYPE_ATIO2:
   1618  1.29   mjacob 	{
   1619  1.29   mjacob 		fcparam *fcp = isp->isp_param;
   1620  1.29   mjacob 		ispctiot2_t local, *ct2 = NULL;
   1621  1.29   mjacob 		ispatiot2_t *at2 = (ispatiot2_t *) sp;
   1622  1.29   mjacob 		int s, lun;
   1623  1.29   mjacob 
   1624  1.29   mjacob #ifdef	SCCLUN
   1625  1.29   mjacob 		lun = at2->req_scclun;
   1626  1.29   mjacob #else
   1627  1.29   mjacob 		lun = at2->req_lun;
   1628  1.29   mjacob #endif
   1629  1.29   mjacob 		PRINTF("%s: atio2 loopid %d for lun %d rxid 0x%x flags0x%x "
   1630  1.29   mjacob 		    "tflags0x%x ecodes0x%x rqstatus0x%x\n", isp->isp_name,
   1631  1.29   mjacob 		    at2->req_initiator, lun, at2->req_rxid,
   1632  1.29   mjacob 		    at2->req_flags, at2->req_taskflags, at2->req_execodes,
   1633  1.29   mjacob 		    at2->req_status);
   1634  1.29   mjacob 
   1635  1.29   mjacob 		switch (at2->req_status & ~ATIO_SENSEVALID) {
   1636  1.29   mjacob 		case ATIO_PATH_INVALID:
   1637  1.29   mjacob 			PRINTF("%s: ATIO2 Path Invalid\n", isp->isp_name);
   1638  1.29   mjacob 			break;
   1639  1.29   mjacob 		case ATIO_NOCAP:
   1640  1.29   mjacob 			PRINTF("%s: ATIO2 No Cap\n", isp->isp_name);
   1641  1.29   mjacob 			break;
   1642  1.29   mjacob 		case ATIO_BDR_MSG:
   1643  1.29   mjacob 			PRINTF("%s: ATIO2 BDR Received\n", isp->isp_name);
   1644  1.29   mjacob 			break;
   1645  1.29   mjacob 		case ATIO_CDB_RECEIVED:
   1646  1.29   mjacob 			ct2 = &local;
   1647  1.29   mjacob 			break;
   1648  1.29   mjacob 		default:
   1649  1.29   mjacob 			PRINTF("%s: unknown req_status 0x%x\n", isp->isp_name,
   1650  1.29   mjacob 			    at2->req_status);
   1651  1.29   mjacob 			break;
   1652  1.29   mjacob 		}
   1653  1.29   mjacob 		if (ct2 == NULL) {
   1654  1.29   mjacob 			/*
   1655  1.29   mjacob 			 * Just do an ACCEPT on this fellow.
   1656  1.29   mjacob 			 */
   1657  1.29   mjacob 			at2->req_header.rqs_entry_type = RQSTYPE_ATIO2;
   1658  1.29   mjacob 			at2->req_header.rqs_flags = 0;
   1659  1.29   mjacob 			at2->req_flags = 1;
   1660  1.29   mjacob 			ireqp = at2;
   1661  1.29   mjacob 			reqsize = sizeof (*at2);
   1662  1.29   mjacob 			break;
   1663  1.29   mjacob 		}
   1664  1.29   mjacob 		PRINTF("%s: datalen %d cdb0=0x%x\n", isp->isp_name,
   1665  1.29   mjacob 		    at2->req_datalen, at2->req_cdb[0]);
   1666  1.29   mjacob 		bzero ((void *) ct2, sizeof (*ct2));
   1667  1.29   mjacob 		ct2->req_header.rqs_entry_type = RQSTYPE_CTIO2;
   1668  1.29   mjacob 		ct2->req_header.rqs_entry_count = 1;
   1669  1.29   mjacob 		ct2->req_header.rqs_flags = 0;
   1670  1.29   mjacob 		ct2->req_header.rqs_seqno = isp->isp_seqno++;
   1671  1.29   mjacob 		ct2->req_handle = (at2->req_initiator << 16) | lun;
   1672  1.29   mjacob #ifndef	SCCLUN
   1673  1.29   mjacob 		ct2->req_lun = lun;
   1674  1.29   mjacob #endif
   1675  1.29   mjacob 		ct2->req_initiator = at2->req_initiator;
   1676  1.29   mjacob 		ct2->req_rxid = at2->req_rxid;
   1677  1.29   mjacob 
   1678  1.29   mjacob 		ct2->req_flags = CTIO_SEND_STATUS;
   1679  1.29   mjacob 		switch (at2->req_cdb[0]) {
   1680  1.29   mjacob 		case 0x0:		/* TUR */
   1681  1.29   mjacob 			ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE0;
   1682  1.29   mjacob 			ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID;
   1683  1.29   mjacob 			break;
   1684  1.29   mjacob 
   1685  1.29   mjacob 		case 0x3:		/* REQUEST SENSE */
   1686  1.29   mjacob 		case 0x12:		/* INQUIRE */
   1687  1.29   mjacob 			ct2->req_flags |= CTIO_SEND_DATA | CTIO2_SMODE0;
   1688  1.29   mjacob 			ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID;
   1689  1.29   mjacob 			ct2->req_seg_count = 1;
   1690  1.29   mjacob 			if (at2->req_cdb[0] == 0x12) {
   1691  1.29   mjacob 				s = sizeof(tgtiqd);
   1692  1.29   mjacob 				bcopy((void *)tgtiqd, fcp->isp_scratch, s);
   1693  1.29   mjacob 			} else {
   1694  1.29   mjacob 				s = at2->req_datalen;
   1695  1.29   mjacob 				bzero(fcp->isp_scratch, s);
   1696  1.29   mjacob 			}
   1697  1.29   mjacob 			ct2->req_m.mode0.req_dataseg[0].ds_base =
   1698  1.29   mjacob 			    fcp->isp_scdma;
   1699  1.29   mjacob 			ct2->req_m.mode0.req_dataseg[0].ds_count = s;
   1700  1.29   mjacob 			ct2->req_m.mode0.req_datalen = s;
   1701  1.29   mjacob #if	1
   1702  1.29   mjacob 			if (at2->req_datalen < s) {
   1703  1.29   mjacob 				ct2->req_m.mode1.req_scsi_status |=
   1704  1.29   mjacob 				    CTIO2_RESP_VALID|CTIO2_RSPOVERUN;
   1705  1.29   mjacob 			} else if (at2->req_datalen > s) {
   1706  1.29   mjacob 				ct2->req_m.mode1.req_scsi_status |=
   1707  1.29   mjacob 				    CTIO2_RESP_VALID|CTIO2_RSPUNDERUN;
   1708  1.29   mjacob 			}
   1709  1.29   mjacob #endif
   1710  1.29   mjacob 			break;
   1711  1.29   mjacob 
   1712  1.29   mjacob 		default:		/* ALL OTHERS */
   1713  1.29   mjacob 			ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE1;
   1714  1.29   mjacob 			ct2->req_m.mode1.req_scsi_status = 0;
   1715  1.29   mjacob #if	1
   1716  1.29   mjacob 			if (at2->req_datalen) {
   1717  1.29   mjacob 				ct2->req_m.mode1.req_scsi_status |=
   1718  1.29   mjacob 				    CTIO2_RSPUNDERUN;
   1719  1.29   mjacob #if	BYTE_ORDER == BIG_ENDIAN
   1720  1.29   mjacob 				ct2->req_resid[1] = at2->req_datalen & 0xff;
   1721  1.29   mjacob 				ct2->req_resid[0] =
   1722  1.29   mjacob 					(at2->req_datalen >> 8) & 0xff;
   1723  1.29   mjacob 				ct2->req_resid[3] =
   1724  1.29   mjacob 					(at2->req_datalen >> 16) & 0xff;
   1725  1.29   mjacob 				ct2->req_resid[2] =
   1726  1.29   mjacob 					(at2->req_datalen >> 24) & 0xff;
   1727  1.29   mjacob #else
   1728  1.29   mjacob 				ct2->req_resid[0] = at2->req_datalen & 0xff;
   1729  1.29   mjacob 				ct2->req_resid[1] =
   1730  1.29   mjacob 					(at2->req_datalen >> 8) & 0xff;
   1731  1.29   mjacob 				ct2->req_resid[2] =
   1732  1.29   mjacob 					(at2->req_datalen >> 16) & 0xff;
   1733  1.29   mjacob 				ct2->req_resid[3] =
   1734  1.29   mjacob 					(at2->req_datalen >> 24) & 0xff;
   1735  1.29   mjacob #endif
   1736  1.29   mjacob 			}
   1737  1.29   mjacob #endif
   1738  1.29   mjacob 			if ((at2->req_status & ATIO_SENSEVALID) == 0) {
   1739  1.29   mjacob 				ct2->req_m.mode1.req_sense_len = 18;
   1740  1.29   mjacob 				ct2->req_m.mode1.req_scsi_status |= 2;
   1741  1.29   mjacob 				ct2->req_m.mode1.req_response[0] = 0x70;
   1742  1.29   mjacob 				ct2->req_m.mode1.req_response[2] = 0x2;
   1743  1.29   mjacob 			} else {
   1744  1.29   mjacob 				ct2->req_m.mode1.req_sense_len = 18;
   1745  1.29   mjacob 				ct2->req_m.mode1.req_scsi_status |=
   1746  1.29   mjacob 				    at2->req_scsi_status;
   1747  1.29   mjacob 				bcopy((void *)at2->req_sense,
   1748  1.29   mjacob 				    (void *)ct2->req_m.mode1.req_response,
   1749  1.29   mjacob 				    sizeof (at2->req_sense));
   1750  1.29   mjacob 			}
   1751  1.29   mjacob 			break;
   1752  1.29   mjacob 		}
   1753  1.29   mjacob 		reqsize = sizeof (*ct2);
   1754  1.29   mjacob 		ireqp = ct2;
   1755  1.29   mjacob 		break;
   1756  1.29   mjacob 	}
   1757  1.29   mjacob 	case RQSTYPE_CTIO2:
   1758  1.29   mjacob 	{
   1759  1.29   mjacob 		ispatiot2_t *at2;
   1760  1.29   mjacob 		ispctiot2_t *ct2 = (ispctiot2_t *) sp;
   1761  1.29   mjacob 		PRINTF("%s: CTIO2 returned status 0x%x\n", isp->isp_name,
   1762  1.29   mjacob 		    ct2->req_status);
   1763  1.29   mjacob 		/*
   1764  1.29   mjacob 	 	 * Return the ATIO to the board.
   1765  1.29   mjacob 		 */
   1766  1.29   mjacob 		at2 = (ispatiot2_t *) sp;
   1767  1.29   mjacob 		at2->req_header.rqs_entry_type = RQSTYPE_ATIO2;
   1768  1.29   mjacob 		at2->req_header.rqs_entry_count = 1;
   1769  1.29   mjacob 		at2->req_header.rqs_flags = 0;
   1770  1.29   mjacob 		at2->req_header.rqs_seqno = isp->isp_seqno++;
   1771  1.29   mjacob 		at2->req_status = 1;
   1772  1.29   mjacob 		reqsize = sizeof (*at2);
   1773  1.29   mjacob 		ireqp = at2;
   1774  1.29   mjacob 		break;
   1775  1.29   mjacob 	}
   1776  1.29   mjacob #undef	atio
   1777  1.29   mjacob #undef	at2io
   1778  1.29   mjacob #undef	ctio
   1779  1.29   mjacob #undef	ct2io
   1780  1.29   mjacob #undef	lunen
   1781  1.29   mjacob #undef	inot
   1782  1.29   mjacob #undef	inot_fc
   1783  1.29   mjacob #undef	nack
   1784  1.29   mjacob #undef	nack_fc
   1785  1.29   mjacob #endif
   1786  1.25   mjacob 	default:
   1787  1.25   mjacob 		PRINTF("%s: other response type %x\n", isp->isp_name,
   1788  1.25   mjacob 		    sp->req_header.rqs_entry_type);
   1789  1.25   mjacob 		break;
   1790  1.25   mjacob 	}
   1791  1.27   mjacob 	if (reqsize) {
   1792  1.27   mjacob 		void *reqp;
   1793  1.27   mjacob 		optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
   1794  1.27   mjacob 		iptr = isp->isp_reqidx;
   1795  1.27   mjacob 		reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
   1796  1.27   mjacob 		iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
   1797  1.27   mjacob 		if (iptr == optr) {
   1798  1.27   mjacob 			PRINTF("%s: Request Queue Overflow other response\n",
   1799  1.27   mjacob 			    isp->isp_name);
   1800  1.27   mjacob 		} else {
   1801  1.27   mjacob 			bcopy(ireqp, reqp, reqsize);
   1802  1.27   mjacob 			ISP_WRITE(isp, INMAILBOX4, iptr);
   1803  1.27   mjacob 			isp->isp_reqidx = iptr;
   1804  1.27   mjacob 		}
   1805  1.27   mjacob 	}
   1806  1.25   mjacob 	return (0);
   1807  1.25   mjacob }
   1808  1.25   mjacob 
   1809  1.29   mjacob #ifdef	ISP_TARGET_MODE
   1810  1.29   mjacob 
   1811  1.29   mjacob static void isp_tmd_newcmd_dflt __P((void *, tmd_cmd_t *));
   1812  1.29   mjacob static void isp_tmd_event_dflt __P((void *, int));
   1813  1.29   mjacob static void isp_tmd_notify_dflt __P((void *, tmd_notify_t *));
   1814  1.29   mjacob 
   1815  1.29   mjacob static void isp_tgt_data_xfer __P ((tmd_cmd_t *));
   1816  1.29   mjacob static void isp_tgt_endcmd __P ((tmd_cmd_t *, u_int8_t));
   1817  1.29   mjacob static void isp_tgt_done __P ((tmd_cmd_t *));
   1818  1.29   mjacob 
   1819  1.29   mjacob static void
   1820  1.29   mjacob isp_tmd_newcmd_dflt(arg0, cmdp)
   1821  1.29   mjacob 	void *arg0;
   1822  1.29   mjacob 	tmd_cmd_t *cmdp;
   1823  1.29   mjacob {
   1824  1.29   mjacob }
   1825  1.29   mjacob 
   1826  1.29   mjacob static void
   1827  1.29   mjacob isp_tmd_event_dflt(arg0, event)
   1828  1.29   mjacob 	void *arg0;
   1829  1.29   mjacob 	int event;
   1830  1.29   mjacob {
   1831  1.29   mjacob }
   1832  1.29   mjacob 
   1833  1.29   mjacob static void
   1834  1.29   mjacob isp_tmd_notify_dflt(arg0, npt)
   1835  1.29   mjacob 	void *arg0;
   1836  1.29   mjacob 	tmd_notify_t *npt;
   1837  1.29   mjacob {
   1838  1.29   mjacob }
   1839  1.29   mjacob 
   1840  1.29   mjacob /*
   1841  1.29   mjacob  * Locks held, and ints disabled (if FC).
   1842  1.29   mjacob  *
   1843  1.29   mjacob  * XXX: SETUP ONLY FOR INITIAL ENABLING RIGHT NOW
   1844  1.29   mjacob  */
   1845  1.29   mjacob static int
   1846  1.29   mjacob isp_modify_lun(isp, lun, icnt, ccnt)
   1847  1.29   mjacob 	struct ispsoftc *isp;
   1848  1.29   mjacob 	int lun;	/* logical unit to enable, modify, or disable */
   1849  1.29   mjacob 	int icnt;	/* immediate notify count */
   1850  1.29   mjacob 	int ccnt;	/* command count */
   1851  1.29   mjacob {
   1852  1.29   mjacob 	isplun_t *ip = NULL;
   1853  1.29   mjacob 	u_int8_t iptr, optr;
   1854  1.29   mjacob 
   1855  1.29   mjacob 	optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
   1856  1.29   mjacob 	iptr = isp->isp_reqidx;
   1857  1.29   mjacob 	ip = (isplun_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
   1858  1.29   mjacob 	iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
   1859  1.29   mjacob 	if (iptr == optr) {
   1860  1.29   mjacob 		PRINTF("%s: Request Queue Overflow in isp_modify_lun\n",
   1861  1.29   mjacob 		    isp->isp_name);
   1862  1.29   mjacob 		return (-1);
   1863  1.29   mjacob 	}
   1864  1.29   mjacob 
   1865  1.29   mjacob 	bzero((void *) ip, sizeof (*ip));
   1866  1.29   mjacob 	ip->req_header.rqs_entry_type = RQSTYPE_ENABLE_LUN;
   1867  1.29   mjacob 	ip->req_header.rqs_entry_count = 1;
   1868  1.29   mjacob 	ip->req_header.rqs_seqno = isp->isp_seqno++;
   1869  1.29   mjacob 	ip->req_handle = RQSTYPE_ENABLE_LUN;
   1870  1.29   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
   1871  1.29   mjacob 		ip->req_lun = lun;
   1872  1.29   mjacob 	}
   1873  1.29   mjacob 	ip->req_cmdcount = ccnt;
   1874  1.29   mjacob 	ip->req_imcount = icnt;
   1875  1.29   mjacob 	ip->req_timeout = 0;	/* default 30 seconds */
   1876  1.29   mjacob 	ISP_WRITE(isp, INMAILBOX4, iptr);
   1877  1.29   mjacob 	isp->isp_reqidx = iptr;
   1878  1.29   mjacob 	return (0);
   1879  1.29   mjacob }
   1880  1.29   mjacob 
   1881  1.29   mjacob static void
   1882  1.29   mjacob isp_notify_ack(isp, ptrp)
   1883  1.29   mjacob 	struct ispsoftc *isp;
   1884  1.29   mjacob 	void *ptrp;
   1885  1.29   mjacob {
   1886  1.29   mjacob 	void *reqp;
   1887  1.29   mjacob 	u_int8_t iptr, optr;
   1888  1.29   mjacob 	union {
   1889  1.29   mjacob 		na_fcentry_t _naf;
   1890  1.29   mjacob 		na_entry_t _nas;
   1891  1.29   mjacob 	} un;
   1892  1.29   mjacob 
   1893  1.29   mjacob 	bzero((caddr_t)&un, sizeof (un));
   1894  1.29   mjacob 	un._nas.na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
   1895  1.29   mjacob 	un._nas.na_header.rqs_entry_count = 1;
   1896  1.29   mjacob 
   1897  1.29   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   1898  1.29   mjacob 		na_fcentry_t *na = &un._nas;
   1899  1.29   mjacob 		if (ptrp) {
   1900  1.29   mjacob 			in_fcentry_t *inp = ptrp;
   1901  1.29   mjacob 			na->na_iid = inp->in_iid;
   1902  1.29   mjacob 			na->na_lun = inp->in_lun;
   1903  1.29   mjacob 			na->na_task_flags = inp->in_task_flags;
   1904  1.29   mjacob 			na->na_seqid = inp->in_seqid;
   1905  1.29   mjacob 			na->na_status = inp->in_status;
   1906  1.29   mjacob 		} else {
   1907  1.29   mjacob 			na->na_flags = NAFC_RST_CLRD;
   1908  1.29   mjacob 		}
   1909  1.29   mjacob 	} else {
   1910  1.29   mjacob 		na_entry_t *na = &un._nas;
   1911  1.29   mjacob 		if (ptrp) {
   1912  1.29   mjacob 			in_entry_t *inp = ptrp;
   1913  1.29   mjacob 			na->na_iid = inp->in_iid;
   1914  1.29   mjacob 			na->na_lun = inp->in_lun;
   1915  1.29   mjacob 			na->na_tgt = inp->in_tgt;
   1916  1.29   mjacob 			na->na_seqid = inp->in_seqid;
   1917  1.29   mjacob 		} else {
   1918  1.29   mjacob 			na->na_flags = NA_RST_CLRD;
   1919  1.29   mjacob 		}
   1920  1.29   mjacob 	}
   1921  1.29   mjacob 	optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4);
   1922  1.29   mjacob 	iptr = isp->isp_reqidx;
   1923  1.29   mjacob 	reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
   1924  1.29   mjacob 	iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN);
   1925  1.29   mjacob 	if (iptr == optr) {
   1926  1.29   mjacob 		PRINTF("%s: Request Queue Overflow For isp_notify_ack\n",
   1927  1.29   mjacob 		    isp->isp_name);
   1928  1.29   mjacob 	} else {
   1929  1.29   mjacob 		bcopy(ireqp, reqp, sizeof (un));
   1930  1.29   mjacob 		ISP_WRITE(isp, INMAILBOX4, iptr);
   1931  1.29   mjacob 		isp->isp_reqidx = iptr;
   1932  1.29   mjacob 	}
   1933  1.29   mjacob }
   1934  1.29   mjacob 
   1935  1.29   mjacob /*
   1936  1.29   mjacob  * These are dummy stubs for now until the outside framework is plugged in.
   1937  1.29   mjacob  */
   1938  1.29   mjacob 
   1939  1.29   mjacob static void
   1940  1.29   mjacob isp_handle_atio (isp, aep)
   1941  1.29   mjacob 	struct ispsoftc *isp;
   1942  1.29   mjacob 	at_entry_t *aep;
   1943  1.29   mjacob {
   1944  1.29   mjacob 	int status, connected;
   1945  1.29   mjacob 	tmd_cmd_t local, *cdp = &local;
   1946  1.29   mjacob 
   1947  1.29   mjacob 	/*
   1948  1.29   mjacob 	 * Get the ATIO status and see if we're still connected.
   1949  1.29   mjacob 	 */
   1950  1.29   mjacob 	status = aep->at_status;
   1951  1.29   mjacob 	connected = ((aep->at_flags & AT_NODISC) != 0);
   1952  1.29   mjacob 
   1953  1.29   mjacob 	PRINTF("%s: ATIO status=0x%x, connected=%d\n", isp->isp_name,
   1954  1.29   mjacob 	    status, connected);
   1955  1.29   mjacob 
   1956  1.29   mjacob 	/*
   1957  1.29   mjacob 	 * The firmware status (except for the SenseValid bit) indicates
   1958  1.29   mjacob 	 * why this ATIO was sent to us.
   1959  1.29   mjacob 	 * If SenseValid is set, the firware has recommended Sense Data.
   1960  1.29   mjacob 	 * If the Disconnects Disabled bit is set in the flags field,
   1961  1.29   mjacob 	 * we're still connected on the SCSI bus - i.e. the initiator
   1962  1.29   mjacob 	 * did not set DiscPriv in the identify message. We don't care
   1963  1.29   mjacob 	 * about this so it's ignored.
   1964  1.29   mjacob 	 */
   1965  1.29   mjacob 	switch(status & ~TGTSVALID) {
   1966  1.29   mjacob 	case AT_PATH_INVALID:
   1967  1.29   mjacob 		/*
   1968  1.29   mjacob 		 * ATIO rejected by the firmware due to disabled lun.
   1969  1.29   mjacob 		 */
   1970  1.29   mjacob 		PRINTF("%s: Firmware rejected ATIO for disabled lun %d\n",
   1971  1.29   mjacob 		    isp->isp_name, aep->at_lun);
   1972  1.29   mjacob 		break;
   1973  1.29   mjacob 
   1974  1.29   mjacob 	case AT_PHASE_ERROR:
   1975  1.29   mjacob 		/*
   1976  1.29   mjacob 		 * Bus Pase Sequence error.
   1977  1.29   mjacob 		 *
   1978  1.29   mjacob 		 * The firmware should have filled in the correct
   1979  1.29   mjacob 		 * sense data.
   1980  1.29   mjacob 		 */
   1981  1.29   mjacob 
   1982  1.29   mjacob 
   1983  1.29   mjacob 		if (status & TGTSVALID) {
   1984  1.29   mjacob 			bcopy((caddr_t) aep->at_sense,
   1985  1.29   mjacob 			    (caddr_t) &cdp->cd_sensedata,
   1986  1.29   mjacob 			    sizeof (cdp->cd_sensedata));
   1987  1.29   mjacob 			PRINTF("%s: Bus Phase Sequence error key 0x%x\n",
   1988  1.29   mjacob 			    isp->isp_name, cdp->cd_sensedata[2] & 0xf);
   1989  1.29   mjacob 		} else {
   1990  1.29   mjacob 			PRINTF("%s: Bus Phase Sequence With No Sense\n",
   1991  1.29   mjacob 			    isp->isp_name);
   1992  1.29   mjacob 		}
   1993  1.29   mjacob 		(*isp->isp_tmd_newcmd)(isp, cdp);
   1994  1.29   mjacob 		break;
   1995  1.29   mjacob 
   1996  1.29   mjacob 	case AT_NOCAP:
   1997  1.29   mjacob 		/*
   1998  1.29   mjacob 		 * Requested Capability not available
   1999  1.29   mjacob 		 * We sent an ATIO that overflowed the firmware's
   2000  1.29   mjacob 		 * command resource count.
   2001  1.29   mjacob 		 */
   2002  1.29   mjacob 		PRINTF("%s: Firmware rejected ATIO, command count overflow\n",
   2003  1.29   mjacob 		    isp->isp_name);
   2004  1.29   mjacob 		break;
   2005  1.29   mjacob 
   2006  1.29   mjacob 	case AT_BDR_MSG:
   2007  1.29   mjacob 		/*
   2008  1.29   mjacob 		 * If we send an ATIO to the firmware to increment
   2009  1.29   mjacob 		 * its command resource count, and the firmware is
   2010  1.29   mjacob 		 * recovering from a Bus Device Reset, it returns
   2011  1.29   mjacob 		 * the ATIO with this status.
   2012  1.29   mjacob 		 */
   2013  1.29   mjacob 		PRINTF("%s: ATIO returned with BDR received\n", isp->isp_name);
   2014  1.29   mjacob 		break;
   2015  1.29   mjacob 
   2016  1.29   mjacob 	case AT_CDB:
   2017  1.29   mjacob 		/*
   2018  1.29   mjacob 		 * New CDB
   2019  1.29   mjacob 		 */
   2020  1.29   mjacob 		cdp->cd_hba = isp;
   2021  1.29   mjacob 		cdp->cd_iid = aep->at_iid;
   2022  1.29   mjacob 		cdp->cd_tgt = aep->at_tgt;
   2023  1.29   mjacob 		cdp->cd_lun = aep->at_lun;
   2024  1.29   mjacob 		cdp->cd_tagtype = aep->at_tag_type;
   2025  1.29   mjacob 		cdp->cd_tagval = aep->at_tag_val;
   2026  1.29   mjacob 		bcopy(aep->at_cdb, cdp->cd_cdb, 16);
   2027  1.29   mjacob 		PRINTF("%s: CDB 0x%x itl %d/%d/%d\n", isp->isp_name,
   2028  1.29   mjacob 		    cdp->cd_cdb[0], cdp->cd_iid, cdp->cd_tgt, cdp->cd_lun);
   2029  1.29   mjacob 		(*isp->isp_tmd_newcmd)(isp, cdp);
   2030  1.29   mjacob 		break;
   2031  1.29   mjacob 
   2032  1.29   mjacob 	default:
   2033  1.29   mjacob 		PRINTF("%s: Unknown status (0x%x) in ATIO\n",
   2034  1.29   mjacob 		    isp->isp_name, status);
   2035  1.29   mjacob 		cdp->cd_hba = isp;
   2036  1.29   mjacob 		cdp->cd_iid = aep->at_iid;
   2037  1.29   mjacob 		cdp->cd_tgt = aep->at_tgt;
   2038  1.29   mjacob 		cdp->cd_lun = aep->at_lun;
   2039  1.29   mjacob 		cdp->cd_tagtype = aep->at_tag_type;
   2040  1.29   mjacob 		cdp->cd_tagval = aep->at_tag_val;
   2041  1.29   mjacob 		isp_tgtcmd_done(cdp);
   2042  1.29   mjacob 		break;
   2043  1.29   mjacob 	}
   2044  1.29   mjacob }
   2045  1.29   mjacob 
   2046  1.29   mjacob static void
   2047  1.29   mjacob isp_handle_atio2(isp, aep)
   2048  1.29   mjacob 	struct ispsoftc *isp;
   2049  1.29   mjacob 	at2_entry_t *aep;
   2050  1.29   mjacob {
   2051  1.29   mjacob 	int status;
   2052  1.29   mjacob 	tmd_cmd_t local, *cdp = &local;
   2053  1.29   mjacob 
   2054  1.29   mjacob 	/*
   2055  1.29   mjacob 	 * Get the ATIO2 status.
   2056  1.29   mjacob 	 */
   2057  1.29   mjacob 	status = aep->at_status;
   2058  1.29   mjacob 	PRINTD("%s: ATIO2 status=0x%x\n", status);
   2059  1.29   mjacob 
   2060  1.29   mjacob 	/*
   2061  1.29   mjacob 	 * The firmware status (except for the SenseValid bit) indicates
   2062  1.29   mjacob 	 * why this ATIO was sent to us.
   2063  1.29   mjacob 	 * If SenseValid is set, the firware has recommended Sense Data.
   2064  1.29   mjacob 	 */
   2065  1.29   mjacob 	switch(status & ~TGTSVALID) {
   2066  1.29   mjacob 	case AT_PATH_INVALID:
   2067  1.29   mjacob 		/*
   2068  1.29   mjacob 		 * ATIO rejected by the firmware due to disabled lun.
   2069  1.29   mjacob 		 */
   2070  1.29   mjacob 		PRINTF("%s: Firmware rejected ATIO2 for disabled lun %d\n",
   2071  1.29   mjacob 		    isp->isp_name, aep->at_lun);
   2072  1.29   mjacob 		break;
   2073  1.29   mjacob 
   2074  1.29   mjacob 	case AT_NOCAP:
   2075  1.29   mjacob 		/*
   2076  1.29   mjacob 		 * Requested Capability not available
   2077  1.29   mjacob 		 * We sent an ATIO that overflowed the firmware's
   2078  1.29   mjacob 		 * command resource count.
   2079  1.29   mjacob 		 */
   2080  1.29   mjacob 		PRINTF("%s: Firmware rejected ATIO2, command count overflow\n",
   2081  1.29   mjacob 		    isp->isp_name);
   2082  1.29   mjacob 		break;
   2083  1.29   mjacob 
   2084  1.29   mjacob 	case AT_BDR_MSG:
   2085  1.29   mjacob 		/*
   2086  1.29   mjacob 		 * If we send an ATIO to the firmware to increment
   2087  1.29   mjacob 		 * its command resource count, and the firmware is
   2088  1.29   mjacob 		 * recovering from a Bus Device Reset, it returns
   2089  1.29   mjacob 		 * the ATIO with this status.
   2090  1.29   mjacob 		 */
   2091  1.29   mjacob 		PRINTF("%s: ATIO2 returned with BDR rcvd\n", isp->isp_name);
   2092  1.29   mjacob 		break;
   2093  1.29   mjacob 
   2094  1.29   mjacob 	case AT_CDB:
   2095  1.29   mjacob 		/*
   2096  1.29   mjacob 		 * New CDB
   2097  1.29   mjacob 		 */
   2098  1.29   mjacob 		cdp->cd_hba = isp;
   2099  1.29   mjacob 		cdp->cd_iid = aep->at_iid;
   2100  1.29   mjacob 		cdp->cd_tgt = 0;
   2101  1.29   mjacob 		cdp->cd_lun = aep->at_lun;
   2102  1.29   mjacob 		bcopy(aep->at_cdb, cdp->cd_cdb, 16);
   2103  1.29   mjacob 		cdp->cd_rxid = aep->at_rxid;
   2104  1.29   mjacob 		cdp->cp_origdlen = aep->at_datalen;
   2105  1.29   mjacob 		cdp->cp_totbytes = 0;
   2106  1.29   mjacob 		PRINTF("%s: CDB 0x%x rx_id 0x%x itl %d/%d/%d dlen %d\n",
   2107  1.29   mjacob 		    isp->isp_name, cdp->cd_cdb[0], cdp->cd_tagval, cdp->cd_iid,
   2108  1.29   mjacob 		    cdp->cd_tgt, cdp->cd_lun, aep->at_datalen);
   2109  1.29   mjacob 		(*isp->isp_tmd_newcmd)(isp, cdp);
   2110  1.29   mjacob 		break;
   2111  1.29   mjacob 
   2112  1.29   mjacob 	default:
   2113  1.29   mjacob 		PRINTF("%s: Unknown status (0x%x) in ATIO2\n",
   2114  1.29   mjacob 		    isp->isp_name, status);
   2115  1.29   mjacob 		cdp->cd_hba = isp;
   2116  1.29   mjacob 		cdp->cd_iid = aep->at_iid;
   2117  1.29   mjacob 		cdp->cd_tgt = aep->at_tgt;
   2118  1.29   mjacob 		cdp->cd_lun = aep->at_lun;
   2119  1.29   mjacob 		cdp->cp_rxid = aep->at_rxid;
   2120  1.29   mjacob 		isp_tgtcmd_done(cdp);
   2121  1.29   mjacob 		break;
   2122  1.29   mjacob 	}
   2123  1.29   mjacob }
   2124  1.29   mjacob 
   2125  1.29   mjacob static void
   2126  1.29   mjacob isp_handle_ctio(isp, cep)
   2127  1.29   mjacob 	struct ispsoftc *isp;
   2128  1.29   mjacob 	ct_entry_t *aep;
   2129  1.29   mjacob {
   2130  1.29   mjacob }
   2131  1.29   mjacob 
   2132  1.29   mjacob static void
   2133  1.29   mjacob isp_handle_ctio2(isp, cep)
   2134  1.29   mjacob 	struct ispsoftc *isp;
   2135  1.29   mjacob 	at2_entry_t *aep;
   2136  1.29   mjacob {
   2137  1.29   mjacob }
   2138  1.29   mjacob #endif
   2139  1.25   mjacob 
   2140  1.23   mjacob static void
   2141  1.10   mjacob isp_parse_status(isp, sp, xs)
   2142   1.1      cgd 	struct ispsoftc *isp;
   2143   1.1      cgd 	ispstatusreq_t *sp;
   2144  1.23   mjacob 	ISP_SCSI_XFER_T *xs;
   2145   1.1      cgd {
   2146   1.1      cgd 	switch (sp->req_completion_status) {
   2147   1.1      cgd 	case RQCS_COMPLETE:
   2148  1.23   mjacob 		XS_SETERR(xs, HBA_NOERROR);
   2149  1.23   mjacob 		return;
   2150  1.10   mjacob 
   2151   1.1      cgd 	case RQCS_INCOMPLETE:
   2152   1.1      cgd 		if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
   2153  1.27   mjacob 			IDPRINTF(3, ("%s: Selection Timeout for target %d\n",
   2154  1.27   mjacob 			    isp->isp_name, XS_TGT(xs)));
   2155  1.23   mjacob 			XS_SETERR(xs, HBA_SELTIMEOUT);
   2156  1.23   mjacob 			return;
   2157   1.1      cgd 		}
   2158  1.25   mjacob 		PRINTF("%s: command incomplete for target %d lun %d, state "
   2159  1.25   mjacob 		    "0x%x\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs),
   2160  1.25   mjacob 		    sp->req_state_flags);
   2161  1.25   mjacob 		break;
   2162  1.25   mjacob 
   2163  1.25   mjacob 	case RQCS_DMA_ERROR:
   2164  1.25   mjacob 		PRINTF("%s: DMA error for command on target %d, lun %d\n",
   2165  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2166   1.1      cgd 		break;
   2167  1.15   mjacob 
   2168  1.15   mjacob 	case RQCS_TRANSPORT_ERROR:
   2169  1.23   mjacob 		PRINTF("%s: transport error\n", isp->isp_name);
   2170  1.15   mjacob 		isp_prtstst(sp);
   2171  1.15   mjacob 		break;
   2172  1.15   mjacob 
   2173  1.25   mjacob 	case RQCS_RESET_OCCURRED:
   2174  1.25   mjacob 		IDPRINTF(2, ("%s: bus reset destroyed command for target %d "
   2175  1.25   mjacob 		    "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)));
   2176  1.25   mjacob 		isp->isp_sendmarker = 1;
   2177  1.25   mjacob 		XS_SETERR(xs, HBA_BUSRESET);
   2178  1.25   mjacob 		return;
   2179  1.25   mjacob 
   2180  1.25   mjacob 	case RQCS_ABORTED:
   2181  1.25   mjacob 		PRINTF("%s: command aborted for target %d lun %d\n",
   2182  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2183  1.25   mjacob 		isp->isp_sendmarker = 1;
   2184  1.25   mjacob 		XS_SETERR(xs, HBA_ABORTED);
   2185  1.25   mjacob 		return;
   2186  1.25   mjacob 
   2187  1.25   mjacob 	case RQCS_TIMEOUT:
   2188  1.25   mjacob 		IDPRINTF(2, ("%s: command timed out for target %d lun %d\n",
   2189  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs)));
   2190  1.25   mjacob 		XS_SETERR(xs, HBA_CMDTIMEOUT);
   2191  1.25   mjacob 		return;
   2192  1.25   mjacob 
   2193  1.10   mjacob 	case RQCS_DATA_OVERRUN:
   2194  1.10   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   2195  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   2196  1.10   mjacob 			break;
   2197  1.10   mjacob 		}
   2198  1.23   mjacob 		XS_SETERR(xs, HBA_DATAOVR);
   2199  1.23   mjacob 		return;
   2200  1.10   mjacob 
   2201  1.25   mjacob 	case RQCS_COMMAND_OVERRUN:
   2202  1.25   mjacob 		PRINTF("%s: command overrun for command on target %d, lun %d\n",
   2203  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2204  1.25   mjacob 		break;
   2205  1.25   mjacob 
   2206  1.25   mjacob 	case RQCS_STATUS_OVERRUN:
   2207  1.25   mjacob 		PRINTF("%s: status overrun for command on target %d, lun %d\n",
   2208  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2209  1.25   mjacob 		break;
   2210  1.25   mjacob 
   2211  1.25   mjacob 	case RQCS_BAD_MESSAGE:
   2212  1.25   mjacob 		PRINTF("%s: message not COMMAND COMPLETE after status on "
   2213  1.25   mjacob 		    "target %d, lun %d\n", isp->isp_name, XS_TGT(xs),
   2214  1.25   mjacob 		    XS_LUN(xs));
   2215  1.25   mjacob 		break;
   2216  1.25   mjacob 
   2217  1.25   mjacob 	case RQCS_NO_MESSAGE_OUT:
   2218  1.25   mjacob 		PRINTF("%s: No MESSAGE OUT phase after selection on "
   2219  1.25   mjacob 		    "target %d, lun %d\n", isp->isp_name, XS_TGT(xs),
   2220  1.25   mjacob 		    XS_LUN(xs));
   2221  1.25   mjacob 		break;
   2222  1.25   mjacob 
   2223  1.25   mjacob 	case RQCS_EXT_ID_FAILED:
   2224  1.25   mjacob 		PRINTF("%s: EXTENDED IDENTIFY failed on target %d, lun %d\n",
   2225  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2226  1.25   mjacob 		break;
   2227  1.25   mjacob 
   2228  1.25   mjacob 	case RQCS_IDE_MSG_FAILED:
   2229  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected INITIATOR DETECTED "
   2230  1.25   mjacob 		    "ERROR message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2231  1.25   mjacob 		break;
   2232  1.25   mjacob 
   2233  1.25   mjacob 	case RQCS_ABORT_MSG_FAILED:
   2234  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected ABORT message\n",
   2235  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2236  1.25   mjacob 		break;
   2237  1.25   mjacob 
   2238  1.25   mjacob 	case RQCS_REJECT_MSG_FAILED:
   2239  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected MESSAGE REJECT message\n",
   2240  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2241  1.25   mjacob 		break;
   2242  1.25   mjacob 
   2243  1.25   mjacob 	case RQCS_NOP_MSG_FAILED:
   2244  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected NOP message\n",
   2245  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2246  1.25   mjacob 		break;
   2247  1.25   mjacob 
   2248  1.25   mjacob 	case RQCS_PARITY_ERROR_MSG_FAILED:
   2249  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected MESSAGE PARITY ERROR "
   2250  1.25   mjacob 		    "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2251  1.25   mjacob 		break;
   2252  1.25   mjacob 
   2253  1.25   mjacob 	case RQCS_DEVICE_RESET_MSG_FAILED:
   2254  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected BUS DEVICE RESET "
   2255  1.25   mjacob 		    "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2256  1.25   mjacob 		break;
   2257  1.25   mjacob 
   2258  1.25   mjacob 	case RQCS_ID_MSG_FAILED:
   2259  1.25   mjacob 		PRINTF("%s: target %d lun %d rejected IDENTIFY "
   2260  1.25   mjacob 		    "message\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2261  1.25   mjacob 		break;
   2262  1.25   mjacob 
   2263  1.25   mjacob 	case RQCS_UNEXP_BUS_FREE:
   2264  1.28   mjacob 		PRINTF("%s: target %d lun %d had an unexpected bus free\n",
   2265  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2266  1.25   mjacob 		break;
   2267  1.25   mjacob 
   2268   1.1      cgd 	case RQCS_DATA_UNDERRUN:
   2269  1.10   mjacob 		if (isp->isp_type & ISP_HA_FC) {
   2270  1.23   mjacob 			XS_RESID(xs) = sp->req_resid;
   2271  1.23   mjacob 			/* an UNDERRUN is not a botch ??? */
   2272  1.10   mjacob 		}
   2273  1.23   mjacob 		XS_SETERR(xs, HBA_NOERROR);
   2274  1.23   mjacob 		return;
   2275  1.10   mjacob 
   2276  1.25   mjacob 	case RQCS_XACT_ERR1:
   2277  1.25   mjacob 		PRINTF("%s: HBA attempted queued transaction with disconnect "
   2278  1.25   mjacob 		    "not set for target %d lun %d\n", isp->isp_name, XS_TGT(xs),
   2279  1.25   mjacob 		    XS_LUN(xs));
   2280  1.25   mjacob 		break;
   2281  1.25   mjacob 
   2282  1.25   mjacob 	case RQCS_XACT_ERR2:
   2283  1.25   mjacob 		PRINTF("%s: HBA attempted queued transaction to target "
   2284  1.25   mjacob 		    "routine %d on target %d\n", isp->isp_name, XS_LUN(xs),
   2285  1.25   mjacob 		    XS_TGT(xs));
   2286  1.25   mjacob 		break;
   2287  1.25   mjacob 
   2288  1.25   mjacob 	case RQCS_XACT_ERR3:
   2289  1.25   mjacob 		PRINTF("%s: HBA attempted queued transaction for target %d lun "
   2290  1.25   mjacob 		    "%d when queueing disabled\n", isp->isp_name, XS_TGT(xs),
   2291  1.25   mjacob 		    XS_LUN(xs));
   2292  1.25   mjacob 		break;
   2293  1.25   mjacob 
   2294  1.25   mjacob 	case RQCS_BAD_ENTRY:
   2295  1.25   mjacob 		PRINTF("%s: invalid IOCB entry type detected\n", isp->isp_name);
   2296  1.25   mjacob 		break;
   2297  1.25   mjacob 
   2298  1.25   mjacob 	case RQCS_QUEUE_FULL:
   2299  1.27   mjacob 		PRINTF("%s: internal queues full for target %d lun %d\n",
   2300  1.27   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2301  1.25   mjacob 		break;
   2302  1.25   mjacob 
   2303  1.25   mjacob 	case RQCS_PHASE_SKIPPED:
   2304  1.25   mjacob 		PRINTF("%s: SCSI phase skipped (e.g., COMMAND COMPLETE w/o "
   2305  1.25   mjacob 		    "STATUS phase) for target %d lun %d\n", isp->isp_name,
   2306  1.25   mjacob 		    XS_TGT(xs), XS_LUN(xs));
   2307  1.25   mjacob 		break;
   2308  1.25   mjacob 
   2309  1.25   mjacob 	case RQCS_ARQS_FAILED:
   2310  1.25   mjacob 		PRINTF("%s: Auto Request Sense failed for target %d lun %d\n",
   2311  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2312  1.25   mjacob 		XS_SETERR(xs, HBA_ARQFAIL);
   2313  1.23   mjacob 		return;
   2314  1.10   mjacob 
   2315  1.25   mjacob 	case RQCS_WIDE_FAILED:
   2316  1.25   mjacob 		PRINTF("%s: Wide Negotiation failed for target %d lun %d\n",
   2317  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2318  1.25   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   2319  1.25   mjacob 			sdparam *sdp = isp->isp_param;
   2320  1.25   mjacob 			isp->isp_update = 1;
   2321  1.25   mjacob 			sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
   2322  1.25   mjacob 			sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE;
   2323  1.25   mjacob 		}
   2324  1.25   mjacob 		XS_SETERR(xs, HBA_NOERROR);
   2325  1.23   mjacob 		return;
   2326  1.10   mjacob 
   2327  1.25   mjacob 	case RQCS_SYNCXFER_FAILED:
   2328  1.25   mjacob 		PRINTF("%s: SDTR Message failed for target %d lun %d\n",
   2329  1.25   mjacob 		    isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2330  1.25   mjacob 		if (isp->isp_type & ISP_HA_SCSI) {
   2331  1.25   mjacob 			sdparam *sdp = isp->isp_param;
   2332  1.25   mjacob 			isp->isp_update = 1;
   2333  1.25   mjacob 			sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
   2334  1.25   mjacob 			sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC;
   2335  1.25   mjacob 		}
   2336  1.25   mjacob 		break;
   2337  1.25   mjacob 
   2338  1.25   mjacob 	case RQCS_LVD_BUSERR:
   2339  1.25   mjacob 		PRINTF("%s: Bad LVD Bus condition while talking to target %d "
   2340  1.25   mjacob 		    "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs));
   2341  1.25   mjacob 		break;
   2342  1.10   mjacob 
   2343  1.10   mjacob 	case RQCS_PORT_UNAVAILABLE:
   2344  1.10   mjacob 		/*
   2345  1.10   mjacob 		 * No such port on the loop. Moral equivalent of SELTIMEO
   2346  1.10   mjacob 		 */
   2347  1.27   mjacob 		IDPRINTF(3, ("%s: Port Unavailable for target %d\n",
   2348  1.27   mjacob 		    isp->isp_name, XS_TGT(xs)));
   2349  1.23   mjacob 		XS_SETERR(xs, HBA_SELTIMEOUT);
   2350  1.23   mjacob 		return;
   2351  1.10   mjacob 
   2352  1.10   mjacob 	case RQCS_PORT_LOGGED_OUT:
   2353  1.27   mjacob 		/*
   2354  1.27   mjacob 		 * It was there (maybe)- treat as a selection timeout.
   2355  1.27   mjacob 		 */
   2356  1.23   mjacob 		PRINTF("%s: port logout for target %d\n",
   2357  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   2358  1.27   mjacob 		XS_SETERR(xs, HBA_SELTIMEOUT);
   2359  1.27   mjacob 		return;
   2360  1.10   mjacob 
   2361  1.10   mjacob 	case RQCS_PORT_CHANGED:
   2362  1.23   mjacob 		PRINTF("%s: port changed for target %d\n",
   2363  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   2364  1.10   mjacob 		break;
   2365  1.10   mjacob 
   2366  1.10   mjacob 	case RQCS_PORT_BUSY:
   2367  1.23   mjacob 		PRINTF("%s: port busy for target %d\n",
   2368  1.23   mjacob 			isp->isp_name, XS_TGT(xs));
   2369  1.23   mjacob 		XS_SETERR(xs, HBA_TGTBSY);
   2370  1.23   mjacob 		return;
   2371  1.10   mjacob 
   2372   1.1      cgd 	default:
   2373  1.23   mjacob 		PRINTF("%s: comp status %x\n", isp->isp_name,
   2374   1.1      cgd 		       sp->req_completion_status);
   2375   1.1      cgd 		break;
   2376   1.1      cgd 	}
   2377  1.23   mjacob 	XS_SETERR(xs, HBA_BOTCH);
   2378   1.1      cgd }
   2379   1.1      cgd 
   2380   1.1      cgd #define	HINIB(x)			((x) >> 0x4)
   2381   1.1      cgd #define	LONIB(x)			((x)  & 0xf)
   2382   1.1      cgd #define MAKNIB(a, b)			(((a) << 4) | (b))
   2383   1.1      cgd static u_int8_t mbpcnt[] = {
   2384  1.10   mjacob 	MAKNIB(1, 1),	/* 0x00: MBOX_NO_OP */
   2385  1.10   mjacob 	MAKNIB(5, 5),	/* 0x01: MBOX_LOAD_RAM */
   2386  1.10   mjacob 	MAKNIB(2, 0),	/* 0x02: MBOX_EXEC_FIRMWARE */
   2387  1.10   mjacob 	MAKNIB(5, 5),	/* 0x03: MBOX_DUMP_RAM */
   2388  1.10   mjacob 	MAKNIB(3, 3),	/* 0x04: MBOX_WRITE_RAM_WORD */
   2389  1.10   mjacob 	MAKNIB(2, 3),	/* 0x05: MBOX_READ_RAM_WORD */
   2390  1.10   mjacob 	MAKNIB(6, 6),	/* 0x06: MBOX_MAILBOX_REG_TEST */
   2391  1.10   mjacob 	MAKNIB(2, 3),	/* 0x07: MBOX_VERIFY_CHECKSUM	*/
   2392  1.10   mjacob 	MAKNIB(1, 3),	/* 0x08: MBOX_ABOUT_FIRMWARE */
   2393  1.10   mjacob 	MAKNIB(0, 0),	/* 0x09: */
   2394  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0a: */
   2395  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0b: */
   2396  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0c: */
   2397  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0d: */
   2398  1.10   mjacob 	MAKNIB(1, 2),	/* 0x0e: MBOX_CHECK_FIRMWARE */
   2399  1.10   mjacob 	MAKNIB(0, 0),	/* 0x0f: */
   2400  1.10   mjacob 	MAKNIB(5, 5),	/* 0x10: MBOX_INIT_REQ_QUEUE */
   2401  1.10   mjacob 	MAKNIB(6, 6),	/* 0x11: MBOX_INIT_RES_QUEUE */
   2402  1.10   mjacob 	MAKNIB(4, 4),	/* 0x12: MBOX_EXECUTE_IOCB */
   2403  1.10   mjacob 	MAKNIB(2, 2),	/* 0x13: MBOX_WAKE_UP	*/
   2404  1.10   mjacob 	MAKNIB(1, 6),	/* 0x14: MBOX_STOP_FIRMWARE */
   2405  1.10   mjacob 	MAKNIB(4, 4),	/* 0x15: MBOX_ABORT */
   2406  1.10   mjacob 	MAKNIB(2, 2),	/* 0x16: MBOX_ABORT_DEVICE */
   2407  1.10   mjacob 	MAKNIB(3, 3),	/* 0x17: MBOX_ABORT_TARGET */
   2408  1.10   mjacob 	MAKNIB(2, 2),	/* 0x18: MBOX_BUS_RESET */
   2409  1.10   mjacob 	MAKNIB(2, 3),	/* 0x19: MBOX_STOP_QUEUE */
   2410  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1a: MBOX_START_QUEUE */
   2411  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1b: MBOX_SINGLE_STEP_QUEUE */
   2412  1.10   mjacob 	MAKNIB(2, 3),	/* 0x1c: MBOX_ABORT_QUEUE */
   2413  1.10   mjacob 	MAKNIB(2, 4),	/* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
   2414  1.10   mjacob 	MAKNIB(0, 0),	/* 0x1e: */
   2415  1.10   mjacob 	MAKNIB(1, 3),	/* 0x1f: MBOX_GET_FIRMWARE_STATUS */
   2416  1.27   mjacob 	MAKNIB(1, 3),	/* 0x20: MBOX_GET_INIT_SCSI_ID, MBOX_GET_LOOP_ID */
   2417  1.10   mjacob 	MAKNIB(1, 2),	/* 0x21: MBOX_GET_SELECT_TIMEOUT */
   2418  1.10   mjacob 	MAKNIB(1, 3),	/* 0x22: MBOX_GET_RETRY_COUNT	*/
   2419  1.10   mjacob 	MAKNIB(1, 2),	/* 0x23: MBOX_GET_TAG_AGE_LIMIT */
   2420  1.10   mjacob 	MAKNIB(1, 2),	/* 0x24: MBOX_GET_CLOCK_RATE */
   2421  1.10   mjacob 	MAKNIB(1, 2),	/* 0x25: MBOX_GET_ACT_NEG_STATE */
   2422  1.10   mjacob 	MAKNIB(1, 2),	/* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
   2423  1.10   mjacob 	MAKNIB(1, 3),	/* 0x27: MBOX_GET_PCI_PARAMS */
   2424  1.10   mjacob 	MAKNIB(2, 4),	/* 0x28: MBOX_GET_TARGET_PARAMS */
   2425  1.10   mjacob 	MAKNIB(2, 4),	/* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
   2426  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2a: */
   2427  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2b: */
   2428  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2c: */
   2429  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2d: */
   2430  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2e: */
   2431  1.10   mjacob 	MAKNIB(0, 0),	/* 0x2f: */
   2432  1.10   mjacob 	MAKNIB(2, 2),	/* 0x30: MBOX_SET_INIT_SCSI_ID */
   2433  1.10   mjacob 	MAKNIB(2, 2),	/* 0x31: MBOX_SET_SELECT_TIMEOUT */
   2434  1.10   mjacob 	MAKNIB(3, 3),	/* 0x32: MBOX_SET_RETRY_COUNT	*/
   2435  1.10   mjacob 	MAKNIB(2, 2),	/* 0x33: MBOX_SET_TAG_AGE_LIMIT */
   2436  1.10   mjacob 	MAKNIB(2, 2),	/* 0x34: MBOX_SET_CLOCK_RATE */
   2437  1.10   mjacob 	MAKNIB(2, 2),	/* 0x35: MBOX_SET_ACTIVE_NEG_STATE */
   2438  1.10   mjacob 	MAKNIB(2, 2),	/* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
   2439  1.10   mjacob 	MAKNIB(3, 3),	/* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
   2440  1.10   mjacob 	MAKNIB(4, 4),	/* 0x38: MBOX_SET_TARGET_PARAMS */
   2441  1.10   mjacob 	MAKNIB(4, 4),	/* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
   2442  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3a: */
   2443  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3b: */
   2444  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3c: */
   2445  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3d: */
   2446  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3e: */
   2447  1.10   mjacob 	MAKNIB(0, 0),	/* 0x3f: */
   2448  1.10   mjacob 	MAKNIB(1, 2),	/* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
   2449  1.10   mjacob 	MAKNIB(6, 1),	/* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
   2450  1.10   mjacob 	MAKNIB(2, 3),	/* 0x42: MBOX_EXEC_BIOS_IOCB */
   2451  1.10   mjacob 	MAKNIB(0, 0),	/* 0x43: */
   2452  1.10   mjacob 	MAKNIB(0, 0),	/* 0x44: */
   2453  1.10   mjacob 	MAKNIB(0, 0),	/* 0x45: */
   2454  1.10   mjacob 	MAKNIB(0, 0),	/* 0x46: */
   2455  1.10   mjacob 	MAKNIB(0, 0),	/* 0x47: */
   2456  1.10   mjacob 	MAKNIB(0, 0),	/* 0x48: */
   2457  1.10   mjacob 	MAKNIB(0, 0),	/* 0x49: */
   2458  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4a: */
   2459  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4b: */
   2460  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4c: */
   2461  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4d: */
   2462  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4e: */
   2463  1.10   mjacob 	MAKNIB(0, 0),	/* 0x4f: */
   2464  1.10   mjacob 	MAKNIB(0, 0),	/* 0x50: */
   2465  1.10   mjacob 	MAKNIB(0, 0),	/* 0x51: */
   2466  1.10   mjacob 	MAKNIB(0, 0),	/* 0x52: */
   2467  1.10   mjacob 	MAKNIB(0, 0),	/* 0x53: */
   2468  1.10   mjacob 	MAKNIB(8, 0),	/* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */
   2469  1.10   mjacob 	MAKNIB(0, 0),	/* 0x55: */
   2470  1.10   mjacob 	MAKNIB(0, 0),	/* 0x56: */
   2471  1.10   mjacob 	MAKNIB(0, 0),	/* 0x57: */
   2472  1.10   mjacob 	MAKNIB(0, 0),	/* 0x58: */
   2473  1.10   mjacob 	MAKNIB(0, 0),	/* 0x59: */
   2474  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5a: */
   2475  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5b: */
   2476  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5c: */
   2477  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5d: */
   2478  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5e: */
   2479  1.10   mjacob 	MAKNIB(0, 0),	/* 0x5f: */
   2480  1.10   mjacob 	MAKNIB(8, 6),	/* 0x60: MBOX_INIT_FIRMWARE */
   2481  1.10   mjacob 	MAKNIB(0, 0),	/* 0x60: MBOX_GET_INIT_CONTROL_BLOCK  (FORMAT?) */
   2482  1.10   mjacob 	MAKNIB(2, 1),	/* 0x62: MBOX_INIT_LIP */
   2483  1.10   mjacob 	MAKNIB(8, 1),	/* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
   2484  1.10   mjacob 	MAKNIB(8, 1),	/* 0x64: MBOX_GET_PORT_DB */
   2485  1.10   mjacob 	MAKNIB(3, 1),	/* 0x65: MBOX_CLEAR_ACA */
   2486  1.10   mjacob 	MAKNIB(3, 1),	/* 0x66: MBOX_TARGET_RESET */
   2487  1.10   mjacob 	MAKNIB(3, 1),	/* 0x67: MBOX_CLEAR_TASK_SET */
   2488  1.10   mjacob 	MAKNIB(3, 1),	/* 0x69: MBOX_ABORT_TASK_SET */
   2489  1.13   mjacob 	MAKNIB(1, 2)	/* 0x69: MBOX_GET_FW_STATE */
   2490   1.1      cgd };
   2491   1.1      cgd #define	NMBCOM	(sizeof (mbpcnt) / sizeof (mbpcnt[0]))
   2492   1.1      cgd 
   2493  1.10   mjacob static void
   2494   1.1      cgd isp_mboxcmd(isp, mbp)
   2495   1.1      cgd 	struct ispsoftc *isp;
   2496   1.1      cgd 	mbreg_t *mbp;
   2497   1.1      cgd {
   2498   1.1      cgd 	int outparam, inparam;
   2499  1.24   mjacob 	int loops, dld = 0;
   2500  1.10   mjacob 	u_int8_t opcode;
   2501   1.1      cgd 
   2502  1.10   mjacob 	if (mbp->param[0] == ISP2100_SET_PCI_PARAM) {
   2503  1.10   mjacob 		opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS;
   2504  1.10   mjacob 		inparam = 4;
   2505  1.10   mjacob 		outparam = 4;
   2506  1.10   mjacob 		goto command_known;
   2507  1.10   mjacob 	} else if (mbp->param[0] > NMBCOM) {
   2508  1.23   mjacob 		PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]);
   2509  1.10   mjacob 		return;
   2510   1.1      cgd 	}
   2511   1.1      cgd 
   2512  1.10   mjacob 	opcode = mbp->param[0];
   2513   1.1      cgd 	inparam = HINIB(mbpcnt[mbp->param[0]]);
   2514   1.1      cgd 	outparam =  LONIB(mbpcnt[mbp->param[0]]);
   2515  1.10   mjacob 
   2516   1.1      cgd 	if (inparam == 0 && outparam == 0) {
   2517  1.23   mjacob 		PRINTF("%s: no parameters for %x\n", isp->isp_name,
   2518   1.1      cgd 			mbp->param[0]);
   2519  1.10   mjacob 		return;
   2520   1.1      cgd 	}
   2521   1.1      cgd 
   2522  1.10   mjacob 
   2523  1.28   mjacob 	/*
   2524  1.28   mjacob 	 * Check for variants
   2525  1.28   mjacob 	 */
   2526  1.28   mjacob #ifdef	SCCLUN
   2527  1.28   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   2528  1.28   mjacob 		switch (mbp->param[0]) {
   2529  1.28   mjacob 		case MBOX_ABORT:
   2530  1.28   mjacob 			inparam = 7;
   2531  1.28   mjacob 			break;
   2532  1.28   mjacob 		case MBOX_ABORT_DEVICE:
   2533  1.28   mjacob 		case MBOX_START_QUEUE:
   2534  1.28   mjacob 		case MBOX_STOP_QUEUE:
   2535  1.28   mjacob 		case MBOX_SINGLE_STEP_QUEUE:
   2536  1.28   mjacob 		case MBOX_ABORT_QUEUE:
   2537  1.28   mjacob 		case MBOX_GET_DEV_QUEUE_STATUS:
   2538  1.28   mjacob 			inparam = 3;
   2539  1.28   mjacob 			break;
   2540  1.28   mjacob 		default:
   2541  1.28   mjacob 			break;
   2542  1.28   mjacob 		}
   2543  1.28   mjacob 	}
   2544  1.28   mjacob #endif
   2545  1.28   mjacob 
   2546  1.10   mjacob command_known:
   2547  1.24   mjacob 
   2548   1.1      cgd 	/*
   2549   1.1      cgd 	 * Make sure we can send some words..
   2550   1.1      cgd 	 */
   2551   1.1      cgd 
   2552   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   2553   1.1      cgd 	while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) {
   2554  1.23   mjacob 		SYS_DELAY(100);
   2555   1.1      cgd 		if (--loops < 0) {
   2556  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
   2557  1.24   mjacob 			if (dld++) {
   2558  1.24   mjacob 				return;
   2559  1.24   mjacob 			}
   2560  1.24   mjacob 			PRINTF("%s: but we'll try again, isr=%x\n",
   2561  1.24   mjacob 			    isp->isp_name, ISP_READ(isp, BIU_ISR));
   2562  1.24   mjacob 			if (ISP_READ(isp, BIU_SEMA) & 1) {
   2563  1.24   mjacob 				u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
   2564  1.28   mjacob 				if (isp_parse_async(isp, (int) mbox))
   2565  1.25   mjacob 					return;
   2566  1.24   mjacob 				ISP_WRITE(isp, BIU_SEMA, 0);
   2567  1.24   mjacob 			}
   2568  1.24   mjacob 			ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   2569  1.24   mjacob 			goto command_known;
   2570   1.1      cgd 		}
   2571   1.1      cgd 	}
   2572   1.1      cgd 
   2573   1.1      cgd 	/*
   2574   1.1      cgd 	 * Write input parameters
   2575   1.1      cgd 	 */
   2576   1.1      cgd 	switch (inparam) {
   2577  1.10   mjacob 	case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0;
   2578  1.10   mjacob 	case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0;
   2579   1.1      cgd 	case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0;
   2580   1.1      cgd 	case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0;
   2581   1.1      cgd 	case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0;
   2582   1.1      cgd 	case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0;
   2583   1.1      cgd 	case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0;
   2584   1.1      cgd 	case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0;
   2585   1.1      cgd 	}
   2586   1.1      cgd 
   2587   1.1      cgd 	/*
   2588   1.1      cgd 	 * Clear semaphore on mailbox registers
   2589   1.1      cgd 	 */
   2590   1.1      cgd 	ISP_WRITE(isp, BIU_SEMA, 0);
   2591   1.1      cgd 
   2592   1.1      cgd 	/*
   2593   1.1      cgd 	 * Clear RISC int condition.
   2594   1.1      cgd 	 */
   2595   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   2596   1.1      cgd 
   2597   1.1      cgd 	/*
   2598   1.1      cgd 	 * Set Host Interrupt condition so that RISC will pick up mailbox regs.
   2599   1.1      cgd 	 */
   2600   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
   2601   1.1      cgd 
   2602   1.1      cgd 	/*
   2603  1.10   mjacob 	 * Wait until RISC int is set, except 2100
   2604   1.1      cgd 	 */
   2605  1.10   mjacob 	if ((isp->isp_type & ISP_HA_FC) == 0) {
   2606  1.10   mjacob 		loops = MBOX_DELAY_COUNT;
   2607  1.10   mjacob 		while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
   2608  1.23   mjacob 			SYS_DELAY(100);
   2609  1.10   mjacob 			if (--loops < 0) {
   2610  1.23   mjacob 				PRINTF("%s: isp_mboxcmd timeout #2\n",
   2611  1.10   mjacob 				    isp->isp_name);
   2612  1.10   mjacob 				return;
   2613  1.10   mjacob 			}
   2614   1.1      cgd 		}
   2615   1.1      cgd 	}
   2616   1.1      cgd 
   2617   1.1      cgd 	/*
   2618   1.1      cgd 	 * Check to make sure that the semaphore has been set.
   2619   1.1      cgd 	 */
   2620   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   2621   1.1      cgd 	while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) {
   2622  1.23   mjacob 		SYS_DELAY(100);
   2623   1.1      cgd 		if (--loops < 0) {
   2624  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
   2625  1.10   mjacob 			return;
   2626   1.1      cgd 		}
   2627   1.1      cgd 	}
   2628   1.1      cgd 
   2629   1.1      cgd 	/*
   2630   1.1      cgd 	 * Make sure that the MBOX_BUSY has gone away
   2631   1.1      cgd 	 */
   2632   1.1      cgd 	loops = MBOX_DELAY_COUNT;
   2633   1.1      cgd 	while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
   2634  1.23   mjacob 		SYS_DELAY(100);
   2635   1.1      cgd 		if (--loops < 0) {
   2636  1.23   mjacob 			PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
   2637  1.10   mjacob 			return;
   2638   1.1      cgd 		}
   2639   1.1      cgd 	}
   2640   1.1      cgd 
   2641   1.1      cgd 
   2642   1.1      cgd 	/*
   2643   1.1      cgd 	 * Pick up output parameters.
   2644   1.1      cgd 	 */
   2645   1.1      cgd 	switch (outparam) {
   2646  1.10   mjacob 	case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7);
   2647  1.10   mjacob 	case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6);
   2648   1.1      cgd 	case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5);
   2649   1.1      cgd 	case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4);
   2650   1.1      cgd 	case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3);
   2651   1.1      cgd 	case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2);
   2652   1.1      cgd 	case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1);
   2653   1.1      cgd 	case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0);
   2654   1.1      cgd 	}
   2655   1.1      cgd 
   2656   1.1      cgd 	/*
   2657   1.1      cgd 	 * Clear RISC int.
   2658   1.1      cgd 	 */
   2659   1.1      cgd 	ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
   2660   1.1      cgd 
   2661   1.1      cgd 	/*
   2662   1.1      cgd 	 * Release semaphore on mailbox registers
   2663   1.1      cgd 	 */
   2664   1.1      cgd 	ISP_WRITE(isp, BIU_SEMA, 0);
   2665  1.10   mjacob 
   2666  1.10   mjacob 	/*
   2667  1.10   mjacob 	 * Just to be chatty here...
   2668  1.10   mjacob 	 */
   2669  1.10   mjacob 	switch(mbp->param[0]) {
   2670  1.10   mjacob 	case MBOX_COMMAND_COMPLETE:
   2671  1.10   mjacob 		break;
   2672  1.10   mjacob 	case MBOX_INVALID_COMMAND:
   2673  1.25   mjacob 		IDPRINTF(2, ("%s: mbox cmd %x failed with INVALID_COMMAND\n",
   2674  1.25   mjacob 		    isp->isp_name, opcode));
   2675  1.10   mjacob 		break;
   2676  1.10   mjacob 	case MBOX_HOST_INTERFACE_ERROR:
   2677  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
   2678  1.25   mjacob 		    isp->isp_name, opcode);
   2679  1.10   mjacob 		break;
   2680  1.10   mjacob 	case MBOX_TEST_FAILED:
   2681  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
   2682  1.25   mjacob 		    isp->isp_name, opcode);
   2683  1.10   mjacob 		break;
   2684  1.10   mjacob 	case MBOX_COMMAND_ERROR:
   2685  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
   2686  1.25   mjacob 		    isp->isp_name, opcode);
   2687  1.10   mjacob 		break;
   2688  1.10   mjacob 	case MBOX_COMMAND_PARAM_ERROR:
   2689  1.23   mjacob 		PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n",
   2690  1.25   mjacob 		    isp->isp_name, opcode);
   2691  1.10   mjacob 		break;
   2692  1.10   mjacob 
   2693  1.28   mjacob 	/*
   2694  1.28   mjacob 	 * Be silent about these...
   2695  1.28   mjacob 	 */
   2696  1.28   mjacob 
   2697  1.25   mjacob 	case ASYNC_LOOP_UP:
   2698  1.10   mjacob 	case ASYNC_LIP_OCCURRED:
   2699  1.28   mjacob 	case ASYNC_PDB_CHANGED:
   2700  1.10   mjacob 		break;
   2701  1.10   mjacob 
   2702  1.10   mjacob 	default:
   2703  1.10   mjacob 		/*
   2704  1.10   mjacob 		 * The expected return of EXEC_FIRMWARE is zero.
   2705  1.10   mjacob 		 */
   2706  1.10   mjacob 		if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) ||
   2707  1.10   mjacob 		    (opcode != MBOX_EXEC_FIRMWARE)) {
   2708  1.23   mjacob 			PRINTF("%s: mbox cmd %x failed with error %x\n",
   2709  1.10   mjacob 				isp->isp_name, opcode, mbp->param[0]);
   2710  1.10   mjacob 		}
   2711  1.10   mjacob 		break;
   2712  1.10   mjacob 	}
   2713   1.4   mjacob }
   2714   1.4   mjacob 
   2715  1.23   mjacob void
   2716  1.25   mjacob isp_lostcmd(isp, xs)
   2717  1.25   mjacob 	struct ispsoftc *isp;
   2718  1.25   mjacob 	ISP_SCSI_XFER_T *xs;
   2719   1.4   mjacob {
   2720   1.4   mjacob 	mbreg_t mbs;
   2721  1.10   mjacob 
   2722   1.4   mjacob 	mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
   2723  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   2724   1.4   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2725  1.10   mjacob 		isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
   2726   1.4   mjacob 		return;
   2727   1.4   mjacob 	}
   2728  1.10   mjacob 	if (mbs.param[1]) {
   2729  1.23   mjacob 		PRINTF("%s: %d commands on completion queue\n",
   2730  1.10   mjacob 		       isp->isp_name, mbs.param[1]);
   2731  1.10   mjacob 	}
   2732  1.23   mjacob 	if (XS_NULL(xs))
   2733   1.4   mjacob 		return;
   2734   1.4   mjacob 
   2735   1.4   mjacob 	mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
   2736  1.25   mjacob 	mbs.param[1] = (XS_TGT(xs) << 8) | XS_LUN(xs);
   2737  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   2738   1.4   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2739  1.10   mjacob 		isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS");
   2740  1.10   mjacob 		return;
   2741  1.10   mjacob 	}
   2742  1.23   mjacob 	PRINTF("%s: lost command for target %d lun %d, %d active of %d, "
   2743  1.23   mjacob 		"Queue State: %x\n", isp->isp_name, XS_TGT(xs),
   2744  1.23   mjacob 		XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]);
   2745  1.10   mjacob 
   2746  1.10   mjacob 	isp_dumpregs(isp, "lost command");
   2747  1.10   mjacob 	/*
   2748  1.10   mjacob 	 * XXX: Need to try and do something to recover.
   2749  1.10   mjacob 	 */
   2750  1.10   mjacob }
   2751  1.10   mjacob 
   2752  1.10   mjacob static void
   2753  1.25   mjacob isp_dumpregs(isp, msg)
   2754  1.25   mjacob 	struct ispsoftc *isp;
   2755  1.25   mjacob 	const char *msg;
   2756  1.10   mjacob {
   2757  1.23   mjacob 	PRINTF("%s: %s\n", isp->isp_name, msg);
   2758  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI)
   2759  1.23   mjacob 		PRINTF("    biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
   2760  1.10   mjacob 	else
   2761  1.23   mjacob 		PRINTF("    biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
   2762  1.23   mjacob 	PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
   2763  1.10   mjacob 	       ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
   2764  1.23   mjacob 	PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR));
   2765  1.10   mjacob 
   2766  1.10   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
   2767  1.10   mjacob 		ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
   2768  1.23   mjacob 		PRINTF("    cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
   2769  1.10   mjacob 			ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
   2770  1.10   mjacob 			ISP_READ(isp, CDMA_FIFO_STS));
   2771  1.23   mjacob 		PRINTF("    ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
   2772  1.10   mjacob 			ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
   2773  1.10   mjacob 			ISP_READ(isp, DDMA_FIFO_STS));
   2774  1.23   mjacob 		PRINTF("    sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
   2775  1.10   mjacob 			ISP_READ(isp, SXP_INTERRUPT),
   2776  1.10   mjacob 			ISP_READ(isp, SXP_GROSS_ERR),
   2777  1.10   mjacob 			ISP_READ(isp, SXP_PINS_CONTROL));
   2778  1.10   mjacob 		ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
   2779  1.10   mjacob 	}
   2780  1.10   mjacob 	ISP_DUMPREGS(isp);
   2781  1.10   mjacob }
   2782  1.10   mjacob 
   2783  1.10   mjacob static void
   2784  1.25   mjacob isp_dumpxflist(isp)
   2785  1.25   mjacob 	struct ispsoftc *isp;
   2786  1.23   mjacob {
   2787  1.23   mjacob 	volatile ISP_SCSI_XFER_T *xs;
   2788  1.23   mjacob 	int i, hdp;
   2789  1.23   mjacob 
   2790  1.23   mjacob 	for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) {
   2791  1.23   mjacob 		xs = isp->isp_xflist[i];
   2792  1.23   mjacob 		if (xs == NULL) {
   2793  1.23   mjacob 			continue;
   2794  1.23   mjacob 		}
   2795  1.23   mjacob 		if (hdp == 0) {
   2796  1.23   mjacob 			PRINTF("%s: active requests\n", isp->isp_name);
   2797  1.23   mjacob 			hdp++;
   2798  1.23   mjacob 		}
   2799  1.23   mjacob 		PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n",
   2800  1.23   mjacob 		    i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs));
   2801  1.23   mjacob 	}
   2802  1.23   mjacob }
   2803  1.23   mjacob 
   2804  1.23   mjacob static void
   2805  1.25   mjacob isp_fw_state(isp)
   2806  1.25   mjacob 	struct ispsoftc *isp;
   2807  1.10   mjacob {
   2808  1.10   mjacob 	mbreg_t mbs;
   2809  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   2810  1.10   mjacob 		int once = 0;
   2811  1.10   mjacob 		fcparam *fcp = isp->isp_param;
   2812  1.10   mjacob again:
   2813  1.10   mjacob 		mbs.param[0] = MBOX_GET_FW_STATE;
   2814  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
   2815  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2816  1.25   mjacob 			if (mbs.param[0] == ASYNC_LIP_OCCURRED ||
   2817  1.28   mjacob 			    mbs.param[0] == ASYNC_PDB_CHANGED ||
   2818  1.25   mjacob 			    mbs.param[0] == ASYNC_LOOP_UP) {
   2819  1.25   mjacob 				if (once++ < 2) {
   2820  1.10   mjacob 					goto again;
   2821  1.10   mjacob 				}
   2822  1.10   mjacob 			}
   2823  1.10   mjacob 			isp_dumpregs(isp, "GET FIRMWARE STATE failed");
   2824  1.10   mjacob 			return;
   2825  1.10   mjacob 		}
   2826  1.10   mjacob 		fcp->isp_fwstate = mbs.param[1];
   2827  1.10   mjacob 	}
   2828  1.10   mjacob }
   2829  1.10   mjacob 
   2830  1.10   mjacob static void
   2831  1.25   mjacob isp_update(isp)
   2832  1.25   mjacob 	struct ispsoftc *isp;
   2833  1.10   mjacob {
   2834  1.25   mjacob 	int tgt;
   2835  1.10   mjacob 	mbreg_t mbs;
   2836  1.10   mjacob 	sdparam *sdp;
   2837  1.10   mjacob 
   2838  1.25   mjacob 	isp->isp_update = 0;
   2839  1.25   mjacob 
   2840  1.10   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   2841   1.4   mjacob 		return;
   2842   1.4   mjacob 	}
   2843  1.10   mjacob 
   2844  1.25   mjacob 	sdp = isp->isp_param;
   2845  1.25   mjacob 	for (tgt = 0; tgt < MAX_TARGETS; tgt++) {
   2846  1.25   mjacob 		if (sdp->isp_devparam[tgt].dev_enable == 0) {
   2847  1.25   mjacob 			continue;
   2848  1.25   mjacob 		}
   2849  1.25   mjacob 		if (sdp->isp_devparam[tgt].dev_update == 0) {
   2850  1.25   mjacob 			continue;
   2851  1.25   mjacob 		}
   2852  1.25   mjacob 
   2853  1.25   mjacob 		mbs.param[0] = MBOX_SET_TARGET_PARAMS;
   2854  1.25   mjacob 		mbs.param[1] = tgt << 8;
   2855  1.25   mjacob 		mbs.param[2] = sdp->isp_devparam[tgt].dev_flags;
   2856  1.25   mjacob 		mbs.param[3] =
   2857  1.25   mjacob 			(sdp->isp_devparam[tgt].sync_offset << 8) |
   2858  1.25   mjacob 			(sdp->isp_devparam[tgt].sync_period);
   2859  1.25   mjacob 
   2860  1.25   mjacob 		IDPRINTF(3, ("\n%s: tgt %d cflags %x offset %x period %x\n",
   2861  1.25   mjacob 		    isp->isp_name, tgt, mbs.param[2], mbs.param[3] >> 8,
   2862  1.25   mjacob 		    mbs.param[3] & 0xff));
   2863  1.25   mjacob 
   2864  1.25   mjacob 		isp_mboxcmd(isp, &mbs);
   2865  1.25   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2866  1.25   mjacob 			PRINTF("%s: failed to change SCSI parameters for "
   2867  1.25   mjacob 			    "target %d\n", isp->isp_name, tgt);
   2868  1.25   mjacob 		} else {
   2869  1.25   mjacob 			char *wt;
   2870  1.25   mjacob 			int x, flags;
   2871  1.25   mjacob 
   2872  1.25   mjacob 			flags = sdp->isp_devparam[tgt].cur_dflags =
   2873  1.25   mjacob 			    sdp->isp_devparam[tgt].dev_flags;
   2874  1.25   mjacob 
   2875  1.25   mjacob 			x = sdp->isp_devparam[tgt].sync_period & 0xff;
   2876  1.25   mjacob 			if (flags & DPARM_SYNC) {
   2877  1.25   mjacob 				if (x == (ISP_20M_SYNCPARMS & 0xff)) {
   2878  1.25   mjacob 					x = 20;
   2879  1.25   mjacob 				} else if (x == (ISP_10M_SYNCPARMS & 0xff)) {
   2880  1.25   mjacob 					x = 10;
   2881  1.25   mjacob 				} else if (x == (ISP_08M_SYNCPARMS & 0xff)) {
   2882  1.25   mjacob 					x = 8;
   2883  1.25   mjacob 				} else if (x == (ISP_05M_SYNCPARMS & 0xff)) {
   2884  1.25   mjacob 					x = 5;
   2885  1.25   mjacob 				} else if (x == (ISP_04M_SYNCPARMS & 0xff)) {
   2886  1.25   mjacob 					x = 4;
   2887  1.25   mjacob 				} else {
   2888  1.25   mjacob 					x = 0;
   2889  1.25   mjacob 				}
   2890  1.25   mjacob 			} else {
   2891  1.25   mjacob 				x = 0;
   2892  1.25   mjacob 			}
   2893  1.25   mjacob 			switch (flags & (DPARM_WIDE|DPARM_TQING)) {
   2894  1.25   mjacob 			case DPARM_WIDE:
   2895  1.25   mjacob 				wt = ", 16 bit wide\n";
   2896  1.25   mjacob 				break;
   2897  1.25   mjacob 			case DPARM_TQING:
   2898  1.25   mjacob 				wt = ", Tagged Queueing Enabled\n";
   2899  1.25   mjacob 				break;
   2900  1.25   mjacob 			case DPARM_WIDE|DPARM_TQING:
   2901  1.25   mjacob 				wt = ", 16 bit wide, Tagged Queueing Enabled\n";
   2902  1.25   mjacob 				break;
   2903  1.25   mjacob 
   2904  1.25   mjacob 			default:
   2905  1.25   mjacob 				wt = "\n";
   2906  1.25   mjacob 				break;
   2907  1.25   mjacob 			}
   2908  1.25   mjacob 			if (x) {
   2909  1.26   mjacob 				IDPRINTF(3, ("%s: Target %d maximum Sync Mode "
   2910  1.25   mjacob 				    "at %dMHz%s", isp->isp_name, tgt, x, wt));
   2911  1.25   mjacob 			} else {
   2912  1.26   mjacob 				IDPRINTF(3, ("%s: Target %d Async Mode%s",
   2913  1.25   mjacob 				    isp->isp_name, tgt, wt));
   2914  1.25   mjacob 			}
   2915  1.25   mjacob 		}
   2916  1.25   mjacob 		sdp->isp_devparam[tgt].dev_update = 0;
   2917  1.10   mjacob 	}
   2918  1.25   mjacob }
   2919  1.10   mjacob 
   2920  1.25   mjacob static void
   2921  1.25   mjacob isp_setdfltparm(isp)
   2922  1.25   mjacob 	struct ispsoftc *isp;
   2923  1.25   mjacob {
   2924  1.25   mjacob 	int i, use_nvram;
   2925  1.25   mjacob 	mbreg_t mbs;
   2926  1.25   mjacob 	sdparam *sdp;
   2927  1.10   mjacob 
   2928  1.10   mjacob 	/*
   2929  1.25   mjacob 	 * Been there, done that, got the T-shirt...
   2930  1.10   mjacob 	 */
   2931  1.25   mjacob 	if (isp->isp_gotdparms) {
   2932  1.25   mjacob 		IDPRINTF(3, ("%s: already have dparms\n", isp->isp_name));
   2933  1.25   mjacob 		return;
   2934  1.25   mjacob 	}
   2935  1.25   mjacob 	isp->isp_gotdparms = 1;
   2936  1.25   mjacob 
   2937  1.25   mjacob 	use_nvram = (isp_read_nvram(isp) == 0);
   2938  1.25   mjacob 	if (use_nvram) {
   2939  1.25   mjacob 		return;
   2940  1.25   mjacob 	}
   2941  1.25   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   2942  1.25   mjacob 		fcparam *fcp = (fcparam *) isp->isp_param;
   2943  1.25   mjacob 		fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN;
   2944  1.25   mjacob 		fcp->isp_maxalloc = 256;
   2945  1.25   mjacob 		fcp->isp_execthrottle = 16;
   2946  1.25   mjacob 		fcp->isp_retry_delay = 5;
   2947  1.25   mjacob 		fcp->isp_retry_count = 0;
   2948  1.25   mjacob 		/*
   2949  1.25   mjacob 		 * It would be nice to fake up a WWN in case we don't
   2950  1.25   mjacob 		 * get one out of NVRAM. Solaris does this for SOCAL
   2951  1.25   mjacob 		 * cards that don't have SBus properties- it sets up
   2952  1.25   mjacob 		 * a WWN based upon the system MAC Address.
   2953  1.25   mjacob 		 */
   2954  1.25   mjacob 		fcp->isp_wwn = 0;
   2955  1.25   mjacob 		return;
   2956  1.10   mjacob 	}
   2957  1.10   mjacob 
   2958  1.25   mjacob 	sdp = (sdparam *) isp->isp_param;
   2959  1.10   mjacob 	mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
   2960  1.10   mjacob 	isp_mboxcmd(isp, &mbs);
   2961  1.10   mjacob 	if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2962  1.23   mjacob 		IDPRINTF(2, ("could not GET ACT NEG STATE\n"));
   2963  1.10   mjacob 		sdp->isp_req_ack_active_neg = 1;
   2964  1.10   mjacob 		sdp->isp_data_line_active_neg = 1;
   2965  1.10   mjacob 	} else {
   2966  1.10   mjacob 		sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1;
   2967  1.10   mjacob 		sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1;
   2968  1.10   mjacob 	}
   2969  1.10   mjacob 	for (i = 0; i < MAX_TARGETS; i++) {
   2970  1.25   mjacob 
   2971  1.10   mjacob 		mbs.param[0] = MBOX_GET_TARGET_PARAMS;
   2972  1.10   mjacob 		mbs.param[1] = i << 8;
   2973  1.10   mjacob 		isp_mboxcmd(isp, &mbs);
   2974  1.10   mjacob 		if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
   2975  1.25   mjacob 			PRINTF("%s: can't get SCSI parameters for target %d\n",
   2976  1.25   mjacob 			    isp->isp_name, i);
   2977  1.25   mjacob 			sdp->isp_devparam[i].sync_period = 0;
   2978  1.25   mjacob 			sdp->isp_devparam[i].sync_offset = 0;
   2979  1.25   mjacob 			sdp->isp_devparam[i].dev_flags = DPARM_SAFE_DFLT;
   2980  1.25   mjacob 			continue;
   2981  1.25   mjacob 		}
   2982  1.25   mjacob 		sdp->isp_devparam[i].dev_flags = mbs.param[2];
   2983  1.25   mjacob 
   2984  1.25   mjacob 		/*
   2985  1.25   mjacob 		 * The maximum period we can really see
   2986  1.25   mjacob 		 * here is 100 (decimal), or 400 ns.
   2987  1.25   mjacob 		 * For some unknown reason we sometimes
   2988  1.25   mjacob 		 * get back wildass numbers from the
   2989  1.25   mjacob 		 * boot device's parameters.
   2990  1.25   mjacob 		 *
   2991  1.25   mjacob 		 * XXX: Hmm- this may be based on a different
   2992  1.25   mjacob 		 * XXX: clock rate.
   2993  1.25   mjacob 		 */
   2994  1.25   mjacob 		if ((mbs.param[3] & 0xff) <= 0x64) {
   2995  1.25   mjacob 			sdp->isp_devparam[i].sync_period = mbs.param[3] & 0xff;
   2996  1.25   mjacob 			sdp->isp_devparam[i].sync_offset = mbs.param[3] >> 8;
   2997  1.25   mjacob 		}
   2998  1.25   mjacob 
   2999  1.25   mjacob 		/*
   3000  1.25   mjacob 		 * It is not safe to run Ultra Mode with a clock < 60.
   3001  1.25   mjacob 		 */
   3002  1.25   mjacob 		if (((sdp->isp_clock && sdp->isp_clock < 60) ||
   3003  1.25   mjacob 		    (isp->isp_type < ISP_HA_SCSI_1020A)) &&
   3004  1.25   mjacob 		    (sdp->isp_devparam[i].sync_period ==
   3005  1.25   mjacob 		    (ISP_20M_SYNCPARMS & 0xff))) {
   3006  1.25   mjacob 			sdp->isp_devparam[i].sync_offset =
   3007  1.25   mjacob 				ISP_10M_SYNCPARMS >> 8;
   3008  1.10   mjacob 			sdp->isp_devparam[i].sync_period =
   3009  1.10   mjacob 				ISP_10M_SYNCPARMS & 0xff;
   3010  1.10   mjacob 		}
   3011  1.25   mjacob 
   3012  1.10   mjacob 	}
   3013  1.10   mjacob 
   3014  1.10   mjacob 	/*
   3015  1.10   mjacob 	 * Set Default Host Adapter Parameters
   3016  1.10   mjacob 	 */
   3017  1.10   mjacob 	sdp->isp_cmd_dma_burst_enable = 1;
   3018  1.10   mjacob 	sdp->isp_data_dma_burst_enabl = 1;
   3019  1.25   mjacob 	sdp->isp_fifo_threshold = 0;
   3020  1.10   mjacob 	sdp->isp_initiator_id = 7;
   3021  1.25   mjacob 	if (isp->isp_type >= ISP_HA_SCSI_1040) {
   3022  1.25   mjacob 		sdp->isp_async_data_setup = 9;
   3023  1.25   mjacob 	} else {
   3024  1.25   mjacob 		sdp->isp_async_data_setup = 6;
   3025  1.25   mjacob 	}
   3026  1.10   mjacob 	sdp->isp_selection_timeout = 250;
   3027  1.23   mjacob 	sdp->isp_max_queue_depth = 128;
   3028  1.10   mjacob 	sdp->isp_tag_aging = 8;
   3029  1.10   mjacob 	sdp->isp_bus_reset_delay = 3;
   3030  1.10   mjacob 	sdp->isp_retry_count = 0;
   3031  1.10   mjacob 	sdp->isp_retry_delay = 1;
   3032  1.10   mjacob 
   3033  1.10   mjacob 	for (i = 0; i < MAX_TARGETS; i++) {
   3034  1.10   mjacob 		sdp->isp_devparam[i].exc_throttle = 16;
   3035  1.10   mjacob 		sdp->isp_devparam[i].dev_enable = 1;
   3036  1.10   mjacob 	}
   3037  1.10   mjacob }
   3038  1.10   mjacob 
   3039  1.24   mjacob /*
   3040  1.24   mjacob  * Re-initialize the ISP and complete all orphaned commands
   3041  1.24   mjacob  * with a 'botched' notice.
   3042  1.24   mjacob  *
   3043  1.24   mjacob  * Locks held prior to coming here.
   3044  1.24   mjacob  */
   3045  1.24   mjacob 
   3046  1.24   mjacob void
   3047  1.25   mjacob isp_restart(isp)
   3048  1.25   mjacob 	struct ispsoftc *isp;
   3049  1.10   mjacob {
   3050  1.23   mjacob 	ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs;
   3051  1.10   mjacob 	int i;
   3052  1.10   mjacob 
   3053  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   3054  1.23   mjacob 		tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i];
   3055  1.27   mjacob 		isp->isp_xflist[i] = NULL;
   3056  1.10   mjacob 	}
   3057  1.10   mjacob 	isp_reset(isp);
   3058  1.24   mjacob 	if (isp->isp_state == ISP_RESETSTATE) {
   3059  1.24   mjacob 		isp_init(isp);
   3060  1.24   mjacob 		if (isp->isp_state == ISP_INITSTATE) {
   3061  1.24   mjacob 			isp->isp_state = ISP_RUNSTATE;
   3062  1.24   mjacob 		}
   3063  1.24   mjacob 	}
   3064  1.24   mjacob 	if (isp->isp_state != ISP_RUNSTATE) {
   3065  1.24   mjacob 		PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name);
   3066  1.24   mjacob 	}
   3067  1.10   mjacob 
   3068  1.23   mjacob 	for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
   3069  1.10   mjacob 		xs = tlist[i];
   3070  1.27   mjacob 		if (XS_NULL(xs)) {
   3071  1.10   mjacob 			continue;
   3072  1.27   mjacob 		}
   3073  1.28   mjacob 		if (isp->isp_nactive > 0)
   3074  1.28   mjacob 		    isp->isp_nactive--;
   3075  1.23   mjacob 		XS_RESID(xs) = XS_XFRLEN(xs);
   3076  1.27   mjacob 		XS_SETERR(xs, HBA_BUSRESET);
   3077  1.23   mjacob 		XS_CMD_DONE(xs);
   3078  1.10   mjacob 	}
   3079  1.15   mjacob }
   3080  1.15   mjacob 
   3081  1.28   mjacob /*
   3082  1.28   mjacob  * Miscellaneous debug statements.
   3083  1.28   mjacob  */
   3084  1.15   mjacob static void
   3085  1.25   mjacob isp_prtstst(sp)
   3086  1.25   mjacob 	ispstatusreq_t *sp;
   3087  1.15   mjacob {
   3088  1.23   mjacob 	PRINTF("states->");
   3089  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_BUS)
   3090  1.23   mjacob 		PRINTF("GOT_BUS ");
   3091  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_TARGET)
   3092  1.23   mjacob 		PRINTF("GOT_TGT ");
   3093  1.15   mjacob 	if (sp->req_state_flags & RQSF_SENT_CDB)
   3094  1.23   mjacob 		PRINTF("SENT_CDB ");
   3095  1.15   mjacob 	if (sp->req_state_flags & RQSF_XFRD_DATA)
   3096  1.23   mjacob 		PRINTF("XFRD_DATA ");
   3097  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_STATUS)
   3098  1.23   mjacob 		PRINTF("GOT_STS ");
   3099  1.15   mjacob 	if (sp->req_state_flags & RQSF_GOT_SENSE)
   3100  1.23   mjacob 		PRINTF("GOT_SNS ");
   3101  1.15   mjacob 	if (sp->req_state_flags & RQSF_XFER_COMPLETE)
   3102  1.23   mjacob 		PRINTF("XFR_CMPLT ");
   3103  1.23   mjacob 	PRINTF("\n");
   3104  1.23   mjacob 	PRINTF("status->");
   3105  1.15   mjacob 	if (sp->req_status_flags & RQSTF_DISCONNECT)
   3106  1.23   mjacob 		PRINTF("Disconnect ");
   3107  1.15   mjacob 	if (sp->req_status_flags & RQSTF_SYNCHRONOUS)
   3108  1.23   mjacob 		PRINTF("Sync_xfr ");
   3109  1.15   mjacob 	if (sp->req_status_flags & RQSTF_PARITY_ERROR)
   3110  1.23   mjacob 		PRINTF("Parity ");
   3111  1.15   mjacob 	if (sp->req_status_flags & RQSTF_BUS_RESET)
   3112  1.23   mjacob 		PRINTF("Bus_Reset ");
   3113  1.15   mjacob 	if (sp->req_status_flags & RQSTF_DEVICE_RESET)
   3114  1.23   mjacob 		PRINTF("Device_Reset ");
   3115  1.15   mjacob 	if (sp->req_status_flags & RQSTF_ABORTED)
   3116  1.23   mjacob 		PRINTF("Aborted ");
   3117  1.15   mjacob 	if (sp->req_status_flags & RQSTF_TIMEOUT)
   3118  1.23   mjacob 		PRINTF("Timeout ");
   3119  1.15   mjacob 	if (sp->req_status_flags & RQSTF_NEGOTIATION)
   3120  1.23   mjacob 		PRINTF("Negotiation ");
   3121  1.23   mjacob 	PRINTF("\n");
   3122  1.25   mjacob }
   3123  1.25   mjacob 
   3124  1.28   mjacob static char *
   3125  1.28   mjacob isp2100_fw_statename(state)
   3126  1.28   mjacob 	int state;
   3127  1.28   mjacob {
   3128  1.28   mjacob 	switch(state) {
   3129  1.28   mjacob 	case FW_CONFIG_WAIT:	return "Config Wait";
   3130  1.28   mjacob 	case FW_WAIT_AL_PA:	return "Waiting for AL/PA";
   3131  1.28   mjacob 	case FW_WAIT_LOGIN:	return "Wait Login";
   3132  1.28   mjacob 	case FW_READY:		return "Ready";
   3133  1.28   mjacob 	case FW_LOSS_OF_SYNC:	return "Loss Of Sync";
   3134  1.28   mjacob 	case FW_ERROR:		return "Error";
   3135  1.28   mjacob 	case FW_REINIT:		return "Re-Init";
   3136  1.28   mjacob 	case FW_NON_PART:	return "Nonparticipating";
   3137  1.28   mjacob 	default:		return "eh?";
   3138  1.28   mjacob 	}
   3139  1.28   mjacob }
   3140  1.28   mjacob 
   3141  1.25   mjacob /*
   3142  1.25   mjacob  * NVRAM Routines
   3143  1.25   mjacob  */
   3144  1.25   mjacob 
   3145  1.25   mjacob static int
   3146  1.25   mjacob isp_read_nvram(isp)
   3147  1.25   mjacob 	struct ispsoftc *isp;
   3148  1.25   mjacob {
   3149  1.25   mjacob 	int i, amt;
   3150  1.25   mjacob 	u_int8_t csum, minversion;
   3151  1.25   mjacob 	union {
   3152  1.25   mjacob 		u_int8_t _x[ISP2100_NVRAM_SIZE];
   3153  1.25   mjacob 		u_int16_t _s[ISP2100_NVRAM_SIZE>>1];
   3154  1.25   mjacob 	} _n;
   3155  1.25   mjacob #define	nvram_data	_n._x
   3156  1.25   mjacob #define	nvram_words	_n._s
   3157  1.25   mjacob 
   3158  1.25   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   3159  1.25   mjacob 		amt = ISP2100_NVRAM_SIZE;
   3160  1.25   mjacob 		minversion = 1;
   3161  1.25   mjacob 	} else {
   3162  1.25   mjacob 		amt = ISP_NVRAM_SIZE;
   3163  1.25   mjacob 		minversion = 2;
   3164  1.25   mjacob 	}
   3165  1.25   mjacob 
   3166  1.25   mjacob 	/*
   3167  1.25   mjacob 	 * Just read the first two words first to see if we have a valid
   3168  1.25   mjacob 	 * NVRAM to continue reading the rest with.
   3169  1.25   mjacob 	 */
   3170  1.25   mjacob 	for (i = 0; i < 2; i++) {
   3171  1.25   mjacob 		isp_rdnvram_word(isp, i, &nvram_words[i]);
   3172  1.25   mjacob 	}
   3173  1.25   mjacob 	if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
   3174  1.25   mjacob 	    nvram_data[2] != 'P') {
   3175  1.25   mjacob 		if (isp->isp_bustype != ISP_BT_SBUS) {
   3176  1.25   mjacob 			PRINTF("%s: invalid NVRAM header\n", isp->isp_name);
   3177  1.25   mjacob 		}
   3178  1.25   mjacob 		return (-1);
   3179  1.25   mjacob 	}
   3180  1.25   mjacob 	for (i = 2; i < amt>>1; i++) {
   3181  1.25   mjacob 		isp_rdnvram_word(isp, i, &nvram_words[i]);
   3182  1.25   mjacob 	}
   3183  1.25   mjacob 	for (csum = 0, i = 0; i < amt; i++) {
   3184  1.25   mjacob 		csum += nvram_data[i];
   3185  1.25   mjacob 	}
   3186  1.25   mjacob 	if (csum != 0) {
   3187  1.25   mjacob 		PRINTF("%s: invalid NVRAM checksum\n", isp->isp_name);
   3188  1.25   mjacob 		return (-1);
   3189  1.25   mjacob 	}
   3190  1.25   mjacob 	if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
   3191  1.25   mjacob 		PRINTF("%s: version %d NVRAM not understood\n", isp->isp_name,
   3192  1.25   mjacob 		    ISP_NVRAM_VERSION(nvram_data));
   3193  1.25   mjacob 		return (-1);
   3194  1.25   mjacob 	}
   3195  1.25   mjacob 
   3196  1.25   mjacob 	if (isp->isp_type & ISP_HA_SCSI) {
   3197  1.25   mjacob 		sdparam *sdp = (sdparam *) isp->isp_param;
   3198  1.25   mjacob 
   3199  1.25   mjacob 		/* XXX CHECK THIS FOR SANITY XXX */
   3200  1.25   mjacob 		sdp->isp_fifo_threshold =
   3201  1.25   mjacob 			ISP_NVRAM_FIFO_THRESHOLD(nvram_data);
   3202  1.25   mjacob 
   3203  1.25   mjacob 		sdp->isp_initiator_id =
   3204  1.25   mjacob 			ISP_NVRAM_INITIATOR_ID(nvram_data);
   3205  1.25   mjacob 
   3206  1.25   mjacob 		sdp->isp_bus_reset_delay =
   3207  1.25   mjacob 			ISP_NVRAM_BUS_RESET_DELAY(nvram_data);
   3208  1.25   mjacob 
   3209  1.25   mjacob 		sdp->isp_retry_count =
   3210  1.25   mjacob 			ISP_NVRAM_BUS_RETRY_COUNT(nvram_data);
   3211  1.25   mjacob 
   3212  1.25   mjacob 		sdp->isp_retry_delay =
   3213  1.25   mjacob 			ISP_NVRAM_BUS_RETRY_DELAY(nvram_data);
   3214  1.25   mjacob 
   3215  1.25   mjacob 		sdp->isp_async_data_setup =
   3216  1.25   mjacob 			ISP_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data);
   3217  1.25   mjacob 
   3218  1.25   mjacob 		if (isp->isp_type >= ISP_HA_SCSI_1040) {
   3219  1.25   mjacob 			if (sdp->isp_async_data_setup < 9) {
   3220  1.25   mjacob 				sdp->isp_async_data_setup = 9;
   3221  1.25   mjacob 			}
   3222  1.25   mjacob 		} else {
   3223  1.25   mjacob 			if (sdp->isp_async_data_setup != 6) {
   3224  1.25   mjacob 				sdp->isp_async_data_setup = 6;
   3225  1.25   mjacob 			}
   3226  1.25   mjacob 		}
   3227  1.25   mjacob 
   3228  1.25   mjacob 		sdp->isp_req_ack_active_neg =
   3229  1.25   mjacob 			ISP_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data);
   3230  1.25   mjacob 
   3231  1.25   mjacob 		sdp->isp_data_line_active_neg =
   3232  1.25   mjacob 			ISP_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data);
   3233  1.25   mjacob 
   3234  1.25   mjacob 		sdp->isp_data_dma_burst_enabl =
   3235  1.25   mjacob 			ISP_NVRAM_DATA_DMA_BURST_ENABLE(nvram_data);
   3236  1.25   mjacob 
   3237  1.25   mjacob 		sdp->isp_cmd_dma_burst_enable =
   3238  1.25   mjacob 			ISP_NVRAM_CMD_DMA_BURST_ENABLE(nvram_data);
   3239  1.25   mjacob 
   3240  1.25   mjacob 		sdp->isp_tag_aging =
   3241  1.25   mjacob 			ISP_NVRAM_TAG_AGE_LIMIT(nvram_data);
   3242  1.25   mjacob 
   3243  1.25   mjacob 		/* XXX ISP_NVRAM_FIFO_THRESHOLD_128 XXX */
   3244  1.25   mjacob 
   3245  1.25   mjacob 		sdp->isp_selection_timeout =
   3246  1.25   mjacob 			ISP_NVRAM_SELECTION_TIMEOUT(nvram_data);
   3247  1.25   mjacob 
   3248  1.25   mjacob 		sdp->isp_max_queue_depth =
   3249  1.25   mjacob 			ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
   3250  1.25   mjacob 
   3251  1.25   mjacob 		sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
   3252  1.25   mjacob 
   3253  1.25   mjacob 		for (i = 0; i < 16; i++) {
   3254  1.25   mjacob 			sdp->isp_devparam[i].dev_enable =
   3255  1.25   mjacob 				ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i);
   3256  1.25   mjacob 			sdp->isp_devparam[i].exc_throttle =
   3257  1.25   mjacob 				ISP_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i);
   3258  1.25   mjacob 			sdp->isp_devparam[i].sync_offset =
   3259  1.25   mjacob 				ISP_NVRAM_TGT_SYNC_OFFSET(nvram_data, i);
   3260  1.25   mjacob 			sdp->isp_devparam[i].sync_period =
   3261  1.25   mjacob 				ISP_NVRAM_TGT_SYNC_PERIOD(nvram_data, i);
   3262  1.25   mjacob 
   3263  1.25   mjacob 			if (isp->isp_type < ISP_HA_SCSI_1040) {
   3264  1.25   mjacob 				/*
   3265  1.25   mjacob 				 * If we're not ultra, we can't possibly
   3266  1.25   mjacob 				 * be a shorter period than this.
   3267  1.25   mjacob 				 */
   3268  1.25   mjacob 				if (sdp->isp_devparam[i].sync_period < 0x19) {
   3269  1.25   mjacob 					sdp->isp_devparam[i].sync_period =
   3270  1.25   mjacob 					    0x19;
   3271  1.25   mjacob 				}
   3272  1.25   mjacob 				if (sdp->isp_devparam[i].sync_offset > 0xc) {
   3273  1.25   mjacob 					sdp->isp_devparam[i].sync_offset =
   3274  1.25   mjacob 					    0x0c;
   3275  1.25   mjacob 				}
   3276  1.25   mjacob 			} else {
   3277  1.25   mjacob 				if (sdp->isp_devparam[i].sync_offset > 0x8) {
   3278  1.25   mjacob 					sdp->isp_devparam[i].sync_offset = 0x8;
   3279  1.25   mjacob 				}
   3280  1.25   mjacob 			}
   3281  1.25   mjacob 
   3282  1.25   mjacob 			sdp->isp_devparam[i].dev_flags = 0;
   3283  1.25   mjacob 
   3284  1.25   mjacob 			if (ISP_NVRAM_TGT_RENEG(nvram_data, i))
   3285  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
   3286  1.25   mjacob 			if (ISP_NVRAM_TGT_QFRZ(nvram_data, i)) {
   3287  1.25   mjacob 				PRINTF("%s: not supporting QFRZ option for "
   3288  1.25   mjacob 				    "target %d\n", isp->isp_name, i);
   3289  1.25   mjacob 			}
   3290  1.25   mjacob 			sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
   3291  1.25   mjacob 			if (ISP_NVRAM_TGT_ARQ(nvram_data, i) == 0) {
   3292  1.25   mjacob 				PRINTF("%s: not disabling ARQ option for "
   3293  1.25   mjacob 				    "target %d\n", isp->isp_name, i);
   3294  1.25   mjacob 			}
   3295  1.25   mjacob 			if (ISP_NVRAM_TGT_TQING(nvram_data, i))
   3296  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
   3297  1.25   mjacob 			if (ISP_NVRAM_TGT_SYNC(nvram_data, i))
   3298  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_SYNC;
   3299  1.25   mjacob 			if (ISP_NVRAM_TGT_WIDE(nvram_data, i))
   3300  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_WIDE;
   3301  1.25   mjacob 			if (ISP_NVRAM_TGT_PARITY(nvram_data, i))
   3302  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_PARITY;
   3303  1.25   mjacob 			if (ISP_NVRAM_TGT_DISC(nvram_data, i))
   3304  1.25   mjacob 				sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
   3305  1.25   mjacob 		}
   3306  1.25   mjacob 	} else {
   3307  1.25   mjacob 		fcparam *fcp = (fcparam *) isp->isp_param;
   3308  1.25   mjacob 		union {
   3309  1.25   mjacob 			struct {
   3310  1.25   mjacob #if	BYTE_ORDER == BIG_ENDIAN
   3311  1.25   mjacob 				u_int32_t hi32;
   3312  1.25   mjacob 				u_int32_t lo32;
   3313  1.25   mjacob #else
   3314  1.25   mjacob 				u_int32_t lo32;
   3315  1.25   mjacob 				u_int32_t hi32;
   3316  1.25   mjacob #endif
   3317  1.25   mjacob 			} wds;
   3318  1.25   mjacob 			u_int64_t full64;
   3319  1.25   mjacob 		} wwnstore;
   3320  1.25   mjacob 
   3321  1.25   mjacob 		wwnstore.full64 = ISP2100_NVRAM_NODE_NAME(nvram_data);
   3322  1.25   mjacob 		PRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name,
   3323  1.25   mjacob 		    wwnstore.wds.hi32, wwnstore.wds.lo32);
   3324  1.25   mjacob 		fcp->isp_wwn = wwnstore.full64;
   3325  1.25   mjacob 		wwnstore.full64 = ISP2100_NVRAM_BOOT_NODE_NAME(nvram_data);
   3326  1.25   mjacob 		if (wwnstore.full64 != 0) {
   3327  1.28   mjacob 			PRINTF("%s: BOOT DEVICE WWN 0x%08x%08x\n",
   3328  1.28   mjacob 			    isp->isp_name, wwnstore.wds.hi32,
   3329  1.28   mjacob 			    wwnstore.wds.lo32);
   3330  1.25   mjacob 		}
   3331  1.25   mjacob 		fcp->isp_maxalloc =
   3332  1.25   mjacob 			ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
   3333  1.25   mjacob 		fcp->isp_maxfrmlen =
   3334  1.25   mjacob 			ISP2100_NVRAM_MAXFRAMELENGTH(nvram_data);
   3335  1.25   mjacob 		fcp->isp_retry_delay =
   3336  1.25   mjacob 			ISP2100_NVRAM_RETRY_DELAY(nvram_data);
   3337  1.25   mjacob 		fcp->isp_retry_count =
   3338  1.25   mjacob 			ISP2100_NVRAM_RETRY_COUNT(nvram_data);
   3339  1.25   mjacob 		fcp->isp_loopid =
   3340  1.25   mjacob 			ISP2100_NVRAM_HARDLOOPID(nvram_data);
   3341  1.25   mjacob 		fcp->isp_execthrottle =
   3342  1.25   mjacob 			ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
   3343  1.25   mjacob 	}
   3344  1.25   mjacob 	return (0);
   3345  1.25   mjacob }
   3346  1.25   mjacob 
   3347  1.25   mjacob static void
   3348  1.25   mjacob isp_rdnvram_word(isp, wo, rp)
   3349  1.25   mjacob 	struct ispsoftc *isp;
   3350  1.25   mjacob 	int wo;
   3351  1.25   mjacob 	u_int16_t *rp;
   3352  1.25   mjacob {
   3353  1.25   mjacob 	int i, cbits;
   3354  1.25   mjacob 	u_int16_t bit, rqst;
   3355  1.25   mjacob 
   3356  1.25   mjacob 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
   3357  1.25   mjacob 	SYS_DELAY(2);
   3358  1.25   mjacob 	ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
   3359  1.25   mjacob 	SYS_DELAY(2);
   3360  1.25   mjacob 
   3361  1.25   mjacob 	if (isp->isp_type & ISP_HA_FC) {
   3362  1.25   mjacob 		wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
   3363  1.25   mjacob 		rqst = (ISP_NVRAM_READ << 8) | wo;
   3364  1.25   mjacob 		cbits = 10;
   3365  1.25   mjacob 	} else {
   3366  1.25   mjacob 		wo &= ((ISP_NVRAM_SIZE >> 1) - 1);
   3367  1.25   mjacob 		rqst = (ISP_NVRAM_READ << 6) | wo;
   3368  1.25   mjacob 		cbits = 8;
   3369  1.25   mjacob 	}
   3370  1.25   mjacob 
   3371  1.25   mjacob 	/*
   3372  1.25   mjacob 	 * Clock the word select request out...
   3373  1.25   mjacob 	 */
   3374  1.25   mjacob 	for (i = cbits; i >= 0; i--) {
   3375  1.25   mjacob 		if ((rqst >> i) & 1) {
   3376  1.25   mjacob 			bit = BIU_NVRAM_SELECT | BIU_NVRAM_DATAOUT;
   3377  1.25   mjacob 		} else {
   3378  1.25   mjacob 			bit = BIU_NVRAM_SELECT;
   3379  1.25   mjacob 		}
   3380  1.25   mjacob 		ISP_WRITE(isp, BIU_NVRAM, bit);
   3381  1.25   mjacob 		SYS_DELAY(2);
   3382  1.25   mjacob 		ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
   3383  1.25   mjacob 		SYS_DELAY(2);
   3384  1.25   mjacob 		ISP_WRITE(isp, BIU_NVRAM, bit);
   3385  1.25   mjacob 		SYS_DELAY(2);
   3386  1.25   mjacob 	}
   3387  1.25   mjacob 	/*
   3388  1.25   mjacob 	 * Now read the result back in (bits come back in MSB format).
   3389  1.25   mjacob 	 */
   3390  1.25   mjacob 	*rp = 0;
   3391  1.25   mjacob 	for (i = 0; i < 16; i++) {
   3392  1.25   mjacob 		u_int16_t rv;
   3393  1.25   mjacob 		*rp <<= 1;
   3394  1.25   mjacob 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
   3395  1.25   mjacob 		SYS_DELAY(2);
   3396  1.25   mjacob 		rv = ISP_READ(isp, BIU_NVRAM);
   3397  1.25   mjacob 		if (rv & BIU_NVRAM_DATAIN) {
   3398  1.25   mjacob 			*rp |= 1;
   3399  1.25   mjacob 		}
   3400  1.25   mjacob 		SYS_DELAY(2);
   3401  1.25   mjacob 		ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
   3402  1.25   mjacob 		SYS_DELAY(2);
   3403  1.25   mjacob 	}
   3404  1.25   mjacob 	ISP_WRITE(isp, BIU_NVRAM, 0);
   3405  1.25   mjacob 	SYS_DELAY(2);
   3406  1.25   mjacob #if	BYTE_ORDER == BIG_ENDIAN
   3407  1.25   mjacob 	*rp = ((*rp >> 8) | ((*rp & 0xff) << 8));
   3408  1.25   mjacob #endif
   3409   1.1      cgd }
   3410