Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/ic/isp.c

1964 lines
51 KiB
C
Raw Blame History

/* $NetBSD: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
/* $Id: isp.c,v 1.23 1998/07/15 19:50:16 mjacob Exp $ */
/*
* Machine Independent (well, as best as possible)
* code for the Qlogic ISP SCSI adapters.
*
*---------------------------------------
* Copyright (c) 1997, 1998 by Matthew Jacob
* NASA/Ames Research Center
* All rights reserved.
*---------------------------------------
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice immediately at the beginning of the file, without modification,
* this list of conditions, and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* Inspiration and ideas about this driver are from Erik Moe's Linux driver
* (qlogicisp.c) and Dave Miller's SBus version of same (qlogicisp.c). Some
* ideas dredged from the Solaris driver.
*/
/*
* Include header file appropriate for platform we're building on.
*/
#ifdef __NetBSD__
#include <dev/ic/isp_netbsd.h>
#endif
#ifdef __FreeBSD__
#include <dev/isp/isp_freebsd.h>
#endif
#ifdef __linux__
#include <isp_linux.h>
#endif
/*
* General defines
*/
#define MBOX_DELAY_COUNT 1000000 / 100
/*
* Function prototypes.
*/
static void isp_parse_status
__P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
static void isp_fibre_init __P((struct ispsoftc *));
static void isp_fw_state __P((struct ispsoftc *));
static void isp_dumpregs __P((struct ispsoftc *, const char *));
static void isp_dumpxflist __P((struct ispsoftc *));
static void isp_setdparm __P((struct ispsoftc *));
static void isp_prtstst __P((ispstatusreq_t *));
static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
/*
* Reset Hardware.
*/
void
isp_reset(isp)
struct ispsoftc *isp;
{
mbreg_t mbs;
int loops, i, dodnld = 1;
char *revname;
ISP_LOCKVAL_DECL;
isp->isp_state = ISP_NILSTATE;
/*
* Basic types have been set in the MD code.
* See if we can't figure out more here.
*/
isp->isp_dblev = DFLT_DBLEVEL;
if (isp->isp_type & ISP_HA_FC) {
revname = "2100";
} else {
i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
switch (i) {
default:
PRINTF("%s: unknown ISP type %x- assuming 1020\n",
isp->isp_name, i);
isp->isp_type = ISP_HA_SCSI_1020;
revname = "10X0";
break;
case 1:
revname = "1020";
isp->isp_type = ISP_HA_SCSI_1020;
break;
case 2:
revname = "1020A";
isp->isp_type = ISP_HA_SCSI_1020A;
break;
case 3:
revname = "1040A";
isp->isp_type = ISP_HA_SCSI_1040A;
break;
case 5:
revname = "1040B";
isp->isp_type = ISP_HA_SCSI_1040B;
break;
}
}
/*
* Do MD specific pre initialization
*/
ISP_LOCK(isp);
ISP_RESET0(isp);
isp_setdparm(isp); /*
* XXX- need to get rid of thie call
* XXX- prior to a reset. We need
* XXX- to get this now only to try
* XXX- and read the clock settings.
* XXX- typically for SBus only.
*/
/*
* Hit the chip over the head with hammer,
* and give the ISP a chance to recover.
*/
if (isp->isp_type & ISP_HA_SCSI) {
ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
/*
* A slight delay...
*/
SYS_DELAY(100);
/*
* Clear data && control DMA engines.
*/
ISP_WRITE(isp, CDMA_CONTROL,
DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
ISP_WRITE(isp, DDMA_CONTROL,
DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT);
} else {
ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET);
/*
* A slight delay...
*/
SYS_DELAY(100);
ISP_WRITE(isp, CDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
ISP_WRITE(isp, TDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
ISP_WRITE(isp, RDMA2100_CONTROL,
DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT);
}
/*
* Wait for ISP to be ready to go...
*/
loops = MBOX_DELAY_COUNT;
for (;;) {
if (isp->isp_type & ISP_HA_SCSI) {
if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET))
break;
} else {
if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
break;
}
SYS_DELAY(100);
if (--loops < 0) {
isp_dumpregs(isp, "chip reset timed out");
ISP_UNLOCK(isp);
return;
}
}
/*
* More initialization
*/
if (isp->isp_type & ISP_HA_SCSI) {
ISP_WRITE(isp, BIU_CONF1, 0);
} else {
ISP_WRITE(isp, BIU2100_CSR, 0);
ISP_WRITE(isp, RISC_MTR2100, 0x1212); /* FM */
}
ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
SYS_DELAY(100);
if (isp->isp_type & ISP_HA_SCSI) {
ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1);
if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) {
ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST);
ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST);
}
}
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
/*
* Do MD specific post initialization
*/
ISP_RESET1(isp);
/*
* Enable interrupts
*/
ENABLE_INTS(isp);
/*
* Do some sanity checking.
*/
mbs.param[0] = MBOX_NO_OP;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "NOP test failed");
ISP_UNLOCK(isp);
return;
}
if (isp->isp_type & ISP_HA_SCSI) {
mbs.param[0] = MBOX_MAILBOX_REG_TEST;
mbs.param[1] = 0xdead;
mbs.param[2] = 0xbeef;
mbs.param[3] = 0xffff;
mbs.param[4] = 0x1111;
mbs.param[5] = 0xa5a5;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp,
"Mailbox Register test didn't complete");
ISP_UNLOCK(isp);
return;
}
if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef ||
mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 ||
mbs.param[5] != 0xa5a5) {
isp_dumpregs(isp, "Register Test Failed");
ISP_UNLOCK(isp);
return;
}
}
/*
* Download new Firmware, unless requested not to do so.
* This is made slightly trickier in some cases where the
* firmware of the ROM revision is newer than the revision
* compiled into the driver. So, where we used to compare
* versions of our f/w and the ROM f/w, now we just see
* whether we have f/w at all and whether a config flag
* has disabled our download.
*/
if ((isp->isp_mdvec->dv_fwlen == 0) ||
(isp->isp_confopts & ISP_CFG_NORELOAD)) {
dodnld = 0;
}
if (dodnld) {
for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) {
mbs.param[0] = MBOX_WRITE_RAM_WORD;
mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "f/w download failed");
ISP_UNLOCK(isp);
return;
}
}
if (isp->isp_mdvec->dv_fwlen) {
/*
* Verify that it downloaded correctly.
*/
mbs.param[0] = MBOX_VERIFY_CHECKSUM;
mbs.param[1] = isp->isp_mdvec->dv_codeorg;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "ram checksum failure");
ISP_UNLOCK(isp);
return;
}
}
} else {
IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
}
/*
* Now start it rolling.
*
* If we didn't actually download f/w,
* we still need to (re)start it.
*/
mbs.param[0] = MBOX_EXEC_FIRMWARE;
mbs.param[1] = isp->isp_mdvec->dv_codeorg;
isp_mboxcmd(isp, &mbs);
if (isp->isp_type & ISP_HA_SCSI) {
/*
* Set CLOCK RATE
*/
if (((sdparam *)isp->isp_param)->isp_clock) {
mbs.param[0] = MBOX_SET_CLOCK_RATE;
mbs.param[1] = ((sdparam *)isp->isp_param)->isp_clock;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "failed to set CLOCKRATE");
ISP_UNLOCK(isp);
return;
}
}
}
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
ISP_UNLOCK(isp);
return;
}
PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n",
isp->isp_name, revname, dodnld? "loaded" : "ROM",
mbs.param[1], mbs.param[2]);
isp_fw_state(isp);
isp->isp_state = ISP_RESETSTATE;
ISP_UNLOCK(isp);
}
/*
* Initialize Hardware to known state
*/
void
isp_init(isp)
struct ispsoftc *isp;
{
sdparam *sdp;
mbreg_t mbs;
int i, l;
ISP_LOCKVAL_DECL;
if (isp->isp_type & ISP_HA_FC) {
isp_fibre_init(isp);
return;
}
sdp = isp->isp_param;
/*
* Try and figure out if we're connected to a differential bus.
* You have to pause the RISC processor to read SXP registers.
*
* This, by the way, is likely broken in that it should be
* getting this info from NVRAM settings too.
*/
ISP_LOCK(isp);
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_SENSE) {
sdp->isp_diffmode = 1;
PRINTF("%s: Differential Mode\n", isp->isp_name);
} else {
/*
* Force pullups on.
*/
sdp->isp_req_ack_active_neg = 1;
sdp->isp_data_line_active_neg = 1;
sdp->isp_diffmode = 0;
}
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
mbs.param[0] = MBOX_GET_INIT_SCSI_ID;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to get initiator id");
return;
}
if (mbs.param[1] != sdp->isp_initiator_id) {
PRINTF("%s: setting Initiator ID to %d\n", isp->isp_name,
sdp->isp_initiator_id);
mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
mbs.param[1] = sdp->isp_initiator_id;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set initiator id");
return;
}
} else {
IDPRINTF(3, ("%s: leaving Initiator ID at %d\n", isp->isp_name,
sdp->isp_initiator_id));
}
mbs.param[0] = MBOX_SET_RETRY_COUNT;
mbs.param[1] = sdp->isp_retry_count;
mbs.param[2] = sdp->isp_retry_delay;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set retry count and delay");
return;
}
mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
mbs.param[1] = sdp->isp_async_data_setup;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set async data setup time");
return;
}
mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
mbs.param[1] = (sdp->isp_req_ack_active_neg << 4) |
(sdp->isp_data_line_active_neg << 5);
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set active neg state");
return;
}
mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
mbs.param[1] = sdp->isp_tag_aging;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set tag age limit");
return;
}
mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
mbs.param[1] = sdp->isp_selection_timeout;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set selection timeout");
return;
}
IDPRINTF(2, ("%s: devparm, W=wide, S=sync, T=Tag\n", isp->isp_name));
for (i = 0; i < MAX_TARGETS; i++) {
char bz[9];
u_int16_t cj = sdp->isp_devparam[i].sync_period;
if (sdp->isp_devparam[i].dev_flags & DPARM_SYNC) {
u_int16_t x;
if (cj == (ISP_20M_SYNCPARMS & 0xff)) {
x = 20;
} else if (cj == (ISP_10M_SYNCPARMS & 0xff)) {
x = 10;
} else if (cj == (ISP_08M_SYNCPARMS & 0xff)) {
x = 8;
} else if (cj == (ISP_05M_SYNCPARMS & 0xff)) {
x = 5;
} else if (cj == (ISP_04M_SYNCPARMS & 0xff)) {
x = 4;
} else {
x = 0;
}
if (x)
sprintf(bz, "%02dMHz:", x);
else
sprintf(bz, "?%04x:", cj);
} else {
sprintf(bz, "Async:");
}
if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE)
bz[6] = 'W';
else
bz[6] = ' ';
if (sdp->isp_devparam[i].dev_flags & DPARM_TQING)
bz[7] = 'T';
else
bz[7] = ' ';
bz[8] = 0;
IDPRINTF(2, (" id%x:%s", i, bz));
if (((i+1) & 0x3) == 0)
IDPRINTF(2, ("\n"));
if (sdp->isp_devparam[i].dev_enable == 0)
continue;
/*
* It is not safe to run the 1020 in ultra mode.
*/
if (isp->isp_type == ISP_HA_SCSI_1020 &&
cj == (ISP_20M_SYNCPARMS & 0xff)) {
PRINTF("%s: an ISP1020 set to Ultra Speed- derating.\n",
isp->isp_name);
sdp->isp_devparam[i].sync_offset =
ISP_10M_SYNCPARMS >> 8;
sdp->isp_devparam[i].sync_period =
ISP_10M_SYNCPARMS & 0xff;
}
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
mbs.param[1] = i << 8;
mbs.param[2] = sdp->isp_devparam[i].dev_flags << 8;
mbs.param[3] =
(sdp->isp_devparam[i].sync_offset << 8) |
(sdp->isp_devparam[i].sync_period);
IDPRINTF(3, ("\n%s: target %d flags %x offset %x period %x\n",
isp->isp_name, i, sdp->isp_devparam[i].dev_flags,
sdp->isp_devparam[i].sync_offset,
sdp->isp_devparam[i].sync_period));
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
PRINTF("%s: failed to set parameters for target %d\n",
isp->isp_name, i);
PRINTF("%s: flags %x offset %x period %x\n",
isp->isp_name, sdp->isp_devparam[i].dev_flags,
sdp->isp_devparam[i].sync_offset,
sdp->isp_devparam[i].sync_period);
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
mbs.param[1] = i << 8;
mbs.param[2] = DPARM_DEFAULT << 8;
mbs.param[3] = ISP_10M_SYNCPARMS;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
PRINTF("%s: failed even to set defaults\n",
isp->isp_name);
return;
}
}
for (l = 0; l < MAX_LUNS; l++) {
mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
mbs.param[1] = (i << 8) | l;
mbs.param[2] = sdp->isp_max_queue_depth;
mbs.param[3] = sdp->isp_devparam[i].exc_throttle;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set device queue "
"parameters");
return;
}
}
}
/*
* Set up DMA for the request and result mailboxes.
*/
if (ISP_MBOXDMASETUP(isp)) {
ISP_UNLOCK(isp);
PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
return;
}
mbs.param[0] = MBOX_INIT_RES_QUEUE;
mbs.param[1] = RESULT_QUEUE_LEN;
mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16);
mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff);
mbs.param[4] = 0;
mbs.param[5] = 0;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "set of response queue failed");
return;
}
isp->isp_residx = 0;
mbs.param[0] = MBOX_INIT_REQ_QUEUE;
mbs.param[1] = RQUEST_QUEUE_LEN;
mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16);
mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
mbs.param[4] = 0;
mbs.param[5] = 0;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "set of request queue failed");
return;
}
isp->isp_reqidx = 0;
/*
* Unfortunately, this is the only way right now for
* forcing a sync renegotiation. If we boot off of
* an Alpha, it's put the chip in SYNC mode, but we
* haven't necessarily set up the parameters the
* same, so we'll have to yank the reset line to
* get everyone to renegotiate.
*/
mbs.param[0] = MBOX_BUS_RESET;
mbs.param[1] = 2;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "SCSI bus reset failed");
}
/*
* This is really important to have set after a bus reset.
*/
isp->isp_sendmarker = 1;
ISP_UNLOCK(isp);
isp->isp_state = ISP_INITSTATE;
}
static void
isp_fibre_init(isp)
struct ispsoftc *isp;
{
fcparam *fcp;
isp_icb_t *icbp;
mbreg_t mbs;
int count;
u_int8_t lwfs;
ISP_LOCKVAL_DECL;
fcp = isp->isp_param;
fcp->isp_retry_count = 0;
fcp->isp_retry_delay = 1;
ISP_LOCK(isp);
mbs.param[0] = MBOX_SET_RETRY_COUNT;
mbs.param[1] = fcp->isp_retry_count;
mbs.param[2] = fcp->isp_retry_delay;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "failed to set retry count and delay");
return;
}
if (ISP_MBOXDMASETUP(isp)) {
ISP_UNLOCK(isp);
PRINTF("%s: can't setup DMA for mailboxes\n", isp->isp_name);
return;
}
icbp = (isp_icb_t *) fcp->isp_scratch;
bzero(icbp, sizeof (*icbp));
#if 0
icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
MAKE_NODE_NAME(isp, icbp);
icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
#endif
icbp->icb_version = 1;
icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
icbp->icb_maxalloc = 256;
icbp->icb_execthrottle = 16;
icbp->icb_retry_delay = 5;
icbp->icb_retry_count = 0;
MAKE_NODE_NAME(isp, icbp);
icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff);
icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16);
icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff);
icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16);
mbs.param[0] = MBOX_INIT_FIRMWARE;
mbs.param[1] = 0;
mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16);
mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff);
mbs.param[4] = 0;
mbs.param[5] = 0;
mbs.param[6] = 0;
mbs.param[7] = 0;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
ISP_UNLOCK(isp);
isp_dumpregs(isp, "INIT FIRMWARE failed");
return;
}
isp->isp_reqidx = 0;
isp->isp_residx = 0;
/*
* Wait up to 12 seconds for FW to go to READY state.
* This used to be 3 seconds, but that lost.
*
* This is all very much not right. The problem here
* is that the cable may not be plugged in, or there
* may be many many members of the loop that haven't
* been logged into.
*
* This model of doing things doesn't support dynamic
* attachment, so we just plain lose (for now).
*/
lwfs = FW_CONFIG_WAIT;
for (count = 0; count < 12000; count++) {
isp_fw_state(isp);
if (lwfs != fcp->isp_fwstate) {
PRINTF("%s: Firmware State %s -> %s\n", isp->isp_name,
fw_statename(lwfs), fw_statename(fcp->isp_fwstate));
lwfs = fcp->isp_fwstate;
}
if (fcp->isp_fwstate == FW_READY) {
break;
}
SYS_DELAY(1000); /* wait one millisecond */
}
isp->isp_sendmarker = 1;
/*
* Get our Loop ID
* (if possible)
*/
if (fcp->isp_fwstate == FW_READY) {
mbs.param[0] = MBOX_GET_LOOP_ID;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "GET LOOP ID failed");
ISP_UNLOCK(isp);
return;
}
fcp->isp_loopid = mbs.param[1];
if (fcp->isp_loopid) {
PRINTF("%s: Loop ID 0x%x\n", isp->isp_name,
fcp->isp_loopid);
}
isp->isp_state = ISP_INITSTATE;
} else {
PRINTF("%s: failed to go to FW READY state- will not attach\n",
isp->isp_name);
}
ISP_UNLOCK(isp);
}
/*
* Free any associated resources prior to decommissioning and
* set the card to a known state (so it doesn't wake up and kick
* us when we aren't expecting it to).
*
* Locks are held before coming here.
*/
void
isp_uninit(isp)
struct ispsoftc *isp;
{
/*
* Leave with interrupts disabled.
*/
DISABLE_INTS(isp);
/*
* Stop the watchdog timer (if started).
*/
STOP_WATCHDOG(isp_watch, isp);
}
/*
* Start a command. Locking is assumed done in the caller.
*/
int32_t
ispscsicmd(xs)
ISP_SCSI_XFER_T *xs;
{
struct ispsoftc *isp;
u_int8_t iptr, optr;
union {
ispreq_t *_reqp;
ispreqt2_t *_t2reqp;
} _u;
#define reqp _u._reqp
#define t2reqp _u._t2reqp
#define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t))
int i;
XS_INITERR(xs);
isp = XS_ISP(xs);
if (isp->isp_type & ISP_HA_FC) {
if (XS_CDBLEN(xs) > 12) {
PRINTF("%s: unsupported cdb length for fibre (%d)\n",
isp->isp_name, XS_CDBLEN(xs));
XS_SETERR(xs, HBA_BOTCH);
return (CMD_COMPLETE);
}
}
optr = ISP_READ(isp, OUTMAILBOX4);
iptr = isp->isp_reqidx;
reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
if (iptr == optr) {
PRINTF("%s: Request Queue Overflow\n", isp->isp_name);
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
if (isp->isp_type & ISP_HA_FC) {
DISABLE_INTS(isp);
}
if (isp->isp_sendmarker) {
ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
bzero((void *) marker, sizeof (*marker));
marker->req_header.rqs_entry_count = 1;
marker->req_header.rqs_entry_type = RQSTYPE_MARKER;
marker->req_modifier = SYNC_ALL;
isp->isp_sendmarker = 0;
if (((iptr + 1) & (RQUEST_QUEUE_LEN - 1)) == optr) {
ISP_WRITE(isp, INMAILBOX4, iptr);
isp->isp_reqidx = iptr;
if (isp->isp_type & ISP_HA_FC) {
ENABLE_INTS(isp);
}
PRINTF("%s: Request Queue Overflow+\n", isp->isp_name);
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
}
bzero((void *) reqp, UZSIZE);
reqp->req_header.rqs_entry_count = 1;
if (isp->isp_type & ISP_HA_FC) {
reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
} else {
reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
}
reqp->req_header.rqs_flags = 0;
reqp->req_header.rqs_seqno = isp->isp_seqno++;
for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
if (isp->isp_xflist[i] == NULL)
break;
}
if (i == RQUEST_QUEUE_LEN) {
if (isp->isp_type & ISP_HA_FC)
ENABLE_INTS(isp);
PRINTF("%s: ran out of xflist pointers?????\n", isp->isp_name);
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
} else {
/*
* Never have a handle that is zero, so
* set req_handle off by one.
*/
isp->isp_xflist[i] = xs;
reqp->req_handle = i+1;
}
if (isp->isp_type & ISP_HA_FC) {
/*
* See comment in isp_intr
*/
XS_RESID(xs) = 0;
/*
* Fibre Channel always requires some kind of tag.
* If we're marked as "Can't Tag", just do simple
* instead of ordered tags. It's pretty clear to me
* that we shouldn't do head of queue tagging in
* this case.
*/
if (XS_CANTAG(xs)) {
t2reqp->req_flags = XS_KINDOF_TAG(xs);
} else {
t2reqp->req_flags = REQFLAG_STAG;
}
} else {
sdparam *sdp = (sdparam *)isp->isp_param;
if ((sdp->isp_devparam[XS_TGT(xs)].dev_flags & DPARM_TQING) &&
XS_CANTAG(xs)) {
reqp->req_flags = XS_KINDOF_TAG(xs);
} else {
reqp->req_flags = 0;
}
}
reqp->req_lun_trn = XS_LUN(xs);
reqp->req_target = XS_TGT(xs);
if (isp->isp_type & ISP_HA_SCSI) {
reqp->req_cdblen = XS_CDBLEN(xs);
}
bcopy((void *)XS_CDBP(xs), reqp->req_cdb, XS_CDBLEN(xs));
IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno,
reqp->req_cdb[0], XS_XFRLEN(xs)));
reqp->req_time = XS_TIME(xs) / 1000;
if (reqp->req_time == 0 && XS_TIME(xs))
reqp->req_time = 1;
if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) {
if (isp->isp_type & ISP_HA_FC)
ENABLE_INTS(isp);
/* dmasetup sets actual error */
return (CMD_COMPLETE);
}
XS_SETERR(xs, HBA_NOERROR);
ISP_WRITE(isp, INMAILBOX4, iptr);
isp->isp_reqidx = iptr;
if (isp->isp_type & ISP_HA_FC) {
ENABLE_INTS(isp);
}
isp->isp_nactive++;
return (CMD_QUEUED);
#undef reqp
#undef t2reqp
}
/*
* isp control
* Locks (ints blocked) assumed held.
*/
int
isp_control(isp, ctl, arg)
struct ispsoftc *isp;
ispctl_t ctl;
void *arg;
{
ISP_SCSI_XFER_T *xs;
mbreg_t mbs;
int i;
switch (ctl) {
default:
PRINTF("%s: isp_control unknown control op %x\n",
isp->isp_name, ctl);
break;
case ISPCTL_RESET_BUS:
/*
* Right now, for Fibre, we'll punt on loop reset.
* The reason is that it takes a really long time
* to go through the renegotiation after a LIP,
* and we really have to hang out until it's done
* to see what's there after a LIP- until the
* LIP is done and the loop comes back up,
* commands just fail (and, yes, we could handle
* that a little better).
*/
if (isp->isp_type & ISP_HA_FC) {
PRINTF("%s: Skipping FC resets\n", isp->isp_name);
return (0);
}
mbs.param[0] = MBOX_BUS_RESET;
mbs.param[1] = 2; /* 'delay', in seconds */
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "isp_control SCSI bus reset failed");
break;
}
/*
* This is really important to have set after a bus reset.
*/
isp->isp_sendmarker = 1;
PRINTF("%s: Bus Reset\n", isp->isp_name);
return (0);
case ISPCTL_RESET_DEV:
/*
* Note that under parallel SCSI, this issues a BDR message.
* Under FC, we could probably be using ABORT TASK SET
* command.
*/
mbs.param[0] = MBOX_ABORT_TARGET;
mbs.param[1] = ((long)arg) << 8;
mbs.param[2] = 2; /* 'delay', in seconds */
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "SCSI Target reset failed");
break;
}
PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name,
(int) ((long) arg));
isp->isp_sendmarker = 1;
return (0);
case ISPCTL_ABORT_CMD:
xs = (ISP_SCSI_XFER_T *) arg;
for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
if (xs == isp->isp_xflist[i]) {
break;
}
}
if (i == RQUEST_QUEUE_LEN) {
PRINTF("%s: isp_control- cannot find command to abort "
"in active list\n", isp->isp_name);
break;
}
mbs.param[0] = MBOX_ABORT;
mbs.param[1] = XS_TGT(xs) | XS_LUN(xs);
mbs.param[2] = (i+1) >> 16;
mbs.param[3] = (i+1) & 0xffff;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n",
isp->isp_name, mbs.param[0]);
break;
}
PRINTF("%s: command for target %d lun %d was aborted\n",
isp->isp_name, XS_TGT(xs), XS_LUN(xs));
return (0);
}
return (-1);
}
/*
* Interrupt Service Routine(s).
*
* External (OS) framework has done the appropriate locking,
* and the locking will be held throughout this function.
*/
int
isp_intr(arg)
void *arg;
{
ISP_SCSI_XFER_T *clist[RQUEST_QUEUE_LEN], *xs;
struct ispsoftc *isp = arg;
u_int16_t iptr, optr, isr;
int i, ndone = 0;
isr = ISP_READ(isp, BIU_ISR);
if (isp->isp_type & ISP_HA_FC) {
if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
if (isr) {
IDPRINTF(4, ("%s: isp_intr isr=%x\n",
isp->isp_name, isr));
}
return (0);
}
} else {
if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
if (isr) {
IDPRINTF(4, ("%s: isp_intr isr=%x\n",
isp->isp_name, isr));
}
return (0);
}
}
optr = isp->isp_residx;
if (ISP_READ(isp, BIU_SEMA) & 1) {
u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0);
switch (mbox) {
case ASYNC_BUS_RESET:
PRINTF("%s: SCSI bus reset detected\n", isp->isp_name);
isp->isp_sendmarker = 1;
break;
case ASYNC_SYSTEM_ERROR:
mbox = ISP_READ(isp, OUTMAILBOX1);
PRINTF("%s: Internal System Error RISC Addr %x\n",
isp->isp_name, mbox);
break;
case ASYNC_RQS_XFER_ERR:
PRINTF("%s: Request Queue Transfer Error\n",
isp->isp_name);
break;
case ASYNC_RSP_XFER_ERR:
PRINTF("%s: Response Queue Transfer Error\n",
isp->isp_name);
break;
case ASYNC_QWAKEUP:
/* don't need to be chatty */
mbox = ISP_READ(isp, OUTMAILBOX4);
break;
case ASYNC_TIMEOUT_RESET:
PRINTF("%s: timeout initiated SCSI bus reset\n",
isp->isp_name);
isp->isp_sendmarker = 1;
break;
case ASYNC_LIP_OCCURRED:
PRINTF("%s: LIP occurred\n", isp->isp_name);
break;
case ASYNC_LOOP_UP:
PRINTF("%s: Loop UP\n", isp->isp_name);
break;
case ASYNC_LOOP_DOWN:
PRINTF("%s: Loop DOWN\n", isp->isp_name);
break;
case ASYNC_LOOP_RESET:
PRINTF("%s: Loop RESET\n", isp->isp_name);
break;
default:
PRINTF("%s: async %x\n", isp->isp_name, mbox);
break;
}
ISP_WRITE(isp, BIU_SEMA, 0);
}
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
iptr = ISP_READ(isp, OUTMAILBOX5);
if (optr == iptr) {
IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n",
isr, optr, iptr));
}
ENABLE_INTS(isp);
while (optr != iptr) {
ispstatusreq_t *sp;
int buddaboom = 0;
sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
optr = (optr + 1) & (RESULT_QUEUE_LEN - 1);
if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
PRINTF("%s: not RESPONSE in RESPONSE Queue (0x%x)\n",
isp->isp_name, sp->req_header.rqs_entry_type);
if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
buddaboom = 1;
}
if (sp->req_header.rqs_flags & 0xf) {
if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
PRINTF("%s: rqs_flags=%x", isp->isp_name,
sp->req_header.rqs_flags & 0xf);
if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
PRINTF("%s: internal queues full\n",
isp->isp_name);
/* XXXX: this command *could* get restarted */
buddaboom++;
}
if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
PRINTF("%s: bad header\n", isp->isp_name);
buddaboom++;
}
if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
PRINTF("%s: bad request packet\n",
isp->isp_name);
buddaboom++;
}
}
if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) {
PRINTF("%s: bad request handle %d\n", isp->isp_name,
sp->req_handle);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[sp->req_handle - 1];
if (xs == NULL) {
PRINTF("%s: NULL xs in xflist (handle %x)\n",
isp->isp_name, sp->req_handle);
isp_dumpxflist(isp);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
isp->isp_xflist[sp->req_handle - 1] = NULL;
if (sp->req_status_flags & RQSTF_BUS_RESET) {
isp->isp_sendmarker = 1;
}
if (buddaboom) {
XS_SETERR(xs, HBA_BOTCH);
}
XS_STS(xs) = sp->req_scsi_status & 0xff;
if (isp->isp_type & ISP_HA_SCSI) {
if (sp->req_state_flags & RQSF_GOT_SENSE) {
bcopy(sp->req_sense_data, XS_SNSP(xs),
XS_SNSLEN(xs));
XS_SNS_IS_VALID(xs);
}
} else {
if (XS_STS(xs) == SCSI_CHECK) {
XS_SNS_IS_VALID(xs);
bcopy(sp->req_sense_data, XS_SNSP(xs),
XS_SNSLEN(xs));
sp->req_state_flags |= RQSF_GOT_SENSE;
}
}
if (XS_NOERR(xs) && XS_STS(xs) == SCSI_BUSY) {
XS_SETERR(xs, HBA_TGTBSY);
}
if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
if (XS_NOERR(xs) && sp->req_completion_status)
isp_parse_status(isp, sp, xs);
} else {
PRINTF("%s: unknown return %x\n", isp->isp_name,
sp->req_header.rqs_entry_type);
if (XS_NOERR(xs))
XS_SETERR(xs, HBA_BOTCH);
}
if (isp->isp_type & ISP_HA_SCSI) {
XS_RESID(xs) = sp->req_resid;
} else if (sp->req_scsi_status & RQCS_RU) {
XS_RESID(xs) = sp->req_resid;
IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
XS_XFRLEN(xs), sp->req_resid));
}
if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, sp->req_handle - 1);
}
/*
* XXX: If we have a check condition, but no Sense Data,
* XXX: mark it as an error (ARQ failed). We need to
* XXX: to do a more distinct job because there may
* XXX: cases where ARQ is disabled.
*/
if (XS_STS(xs) == SCSI_CHECK && !(XS_IS_SNS_VALID(xs))) {
if (XS_NOERR(xs)) {
PRINTF("%s: ARQ Failure\n", isp->isp_name);
XS_SETERR(xs, HBA_ARQFAIL);
}
}
if ((isp->isp_dblev >= 5) ||
(isp->isp_dblev > 2 && !XS_NOERR(xs))) {
PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x",
isp->isp_name, XS_TGT(xs), XS_LUN(xs),
sp->req_header.rqs_seqno, XS_XFRLEN(xs),
XS_RESID(xs), XS_STS(xs));
if (sp->req_state_flags & RQSF_GOT_SENSE) {
PRINTF(" Skey: %x", XS_SNSKEY(xs));
if (!(XS_IS_SNS_VALID(xs))) {
PRINTF(" BUT NOT SET");
}
}
PRINTF(" XS_ERR=0x%x\n", XS_ERR(xs));
}
ISP_WRITE(isp, INMAILBOX5, optr);
isp->isp_nactive--;
if (isp->isp_nactive < 0)
isp->isp_nactive = 0;
clist[ndone++] = xs; /* defer completion call until later */
}
isp->isp_residx = optr;
for (i = 0; i < ndone; i++)
XS_CMD_DONE(clist[i]);
return (1);
}
/*
* Support routines.
*/
static void
isp_parse_status(isp, sp, xs)
struct ispsoftc *isp;
ispstatusreq_t *sp;
ISP_SCSI_XFER_T *xs;
{
switch (sp->req_completion_status) {
case RQCS_COMPLETE:
XS_SETERR(xs, HBA_NOERROR);
return;
case RQCS_INCOMPLETE:
if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
IDPRINTF(2, ("Selection Timeout\n"));
XS_SETERR(xs, HBA_SELTIMEOUT);
return;
}
PRINTF("%s: incomplete, state %x\n",
isp->isp_name, sp->req_state_flags);
break;
case RQCS_TRANSPORT_ERROR:
PRINTF("%s: transport error\n", isp->isp_name);
isp_prtstst(sp);
break;
case RQCS_DATA_OVERRUN:
if (isp->isp_type & ISP_HA_FC) {
XS_RESID(xs) = sp->req_resid;
break;
}
XS_SETERR(xs, HBA_DATAOVR);
return;
case RQCS_DATA_UNDERRUN:
if (isp->isp_type & ISP_HA_FC) {
XS_RESID(xs) = sp->req_resid;
/* an UNDERRUN is not a botch ??? */
}
XS_SETERR(xs, HBA_NOERROR);
return;
case RQCS_TIMEOUT:
XS_SETERR(xs, HBA_CMDTIMEOUT);
return;
case RQCS_RESET_OCCURRED:
PRINTF("%s: reset occurred, %d active\n", isp->isp_name,
isp->isp_nactive);
isp->isp_sendmarker = 1;
XS_SETERR(xs, HBA_BUSRESET);
return;
case RQCS_ABORTED:
PRINTF("%s: command aborted\n", isp->isp_name);
isp->isp_sendmarker = 1;
XS_SETERR(xs, HBA_ABORTED);
return;
case RQCS_PORT_UNAVAILABLE:
/*
* No such port on the loop. Moral equivalent of SELTIMEO
*/
XS_SETERR(xs, HBA_SELTIMEOUT);
return;
case RQCS_PORT_LOGGED_OUT:
PRINTF("%s: port logout for target %d\n",
isp->isp_name, XS_TGT(xs));
break;
case RQCS_PORT_CHANGED:
PRINTF("%s: port changed for target %d\n",
isp->isp_name, XS_TGT(xs));
break;
case RQCS_PORT_BUSY:
PRINTF("%s: port busy for target %d\n",
isp->isp_name, XS_TGT(xs));
XS_SETERR(xs, HBA_TGTBSY);
return;
default:
PRINTF("%s: comp status %x\n", isp->isp_name,
sp->req_completion_status);
break;
}
XS_SETERR(xs, HBA_BOTCH);
}
#define HINIB(x) ((x) >> 0x4)
#define LONIB(x) ((x) & 0xf)
#define MAKNIB(a, b) (((a) << 4) | (b))
static u_int8_t mbpcnt[] = {
MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */
MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */
MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */
MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */
MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */
MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */
MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */
MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */
MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */
MAKNIB(0, 0), /* 0x09: */
MAKNIB(0, 0), /* 0x0a: */
MAKNIB(0, 0), /* 0x0b: */
MAKNIB(0, 0), /* 0x0c: */
MAKNIB(0, 0), /* 0x0d: */
MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */
MAKNIB(0, 0), /* 0x0f: */
MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */
MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */
MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */
MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */
MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */
MAKNIB(4, 4), /* 0x15: MBOX_ABORT */
MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */
MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */
MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */
MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */
MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */
MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */
MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */
MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */
MAKNIB(0, 0), /* 0x1e: */
MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */
MAKNIB(1, 2), /* 0x20: MBOX_GET_INIT_SCSI_ID */
MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */
MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */
MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */
MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */
MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */
MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */
MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */
MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */
MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */
MAKNIB(0, 0), /* 0x2a: */
MAKNIB(0, 0), /* 0x2b: */
MAKNIB(0, 0), /* 0x2c: */
MAKNIB(0, 0), /* 0x2d: */
MAKNIB(0, 0), /* 0x2e: */
MAKNIB(0, 0), /* 0x2f: */
MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */
MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */
MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */
MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */
MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */
MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */
MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */
MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */
MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */
MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */
MAKNIB(0, 0), /* 0x3a: */
MAKNIB(0, 0), /* 0x3b: */
MAKNIB(0, 0), /* 0x3c: */
MAKNIB(0, 0), /* 0x3d: */
MAKNIB(0, 0), /* 0x3e: */
MAKNIB(0, 0), /* 0x3f: */
MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */
MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */
MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */
MAKNIB(0, 0), /* 0x43: */
MAKNIB(0, 0), /* 0x44: */
MAKNIB(0, 0), /* 0x45: */
MAKNIB(0, 0), /* 0x46: */
MAKNIB(0, 0), /* 0x47: */
MAKNIB(0, 0), /* 0x48: */
MAKNIB(0, 0), /* 0x49: */
MAKNIB(0, 0), /* 0x4a: */
MAKNIB(0, 0), /* 0x4b: */
MAKNIB(0, 0), /* 0x4c: */
MAKNIB(0, 0), /* 0x4d: */
MAKNIB(0, 0), /* 0x4e: */
MAKNIB(0, 0), /* 0x4f: */
MAKNIB(0, 0), /* 0x50: */
MAKNIB(0, 0), /* 0x51: */
MAKNIB(0, 0), /* 0x52: */
MAKNIB(0, 0), /* 0x53: */
MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */
MAKNIB(0, 0), /* 0x55: */
MAKNIB(0, 0), /* 0x56: */
MAKNIB(0, 0), /* 0x57: */
MAKNIB(0, 0), /* 0x58: */
MAKNIB(0, 0), /* 0x59: */
MAKNIB(0, 0), /* 0x5a: */
MAKNIB(0, 0), /* 0x5b: */
MAKNIB(0, 0), /* 0x5c: */
MAKNIB(0, 0), /* 0x5d: */
MAKNIB(0, 0), /* 0x5e: */
MAKNIB(0, 0), /* 0x5f: */
MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */
MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */
MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */
MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */
MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */
MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */
MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */
MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */
MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */
MAKNIB(1, 2) /* 0x69: MBOX_GET_FW_STATE */
};
#define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0]))
static void
isp_mboxcmd(isp, mbp)
struct ispsoftc *isp;
mbreg_t *mbp;
{
int outparam, inparam;
int loops;
u_int8_t opcode;
if (mbp->param[0] == ISP2100_SET_PCI_PARAM) {
opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS;
inparam = 4;
outparam = 4;
goto command_known;
} else if (mbp->param[0] > NMBCOM) {
PRINTF("%s: bad command %x\n", isp->isp_name, mbp->param[0]);
return;
}
opcode = mbp->param[0];
inparam = HINIB(mbpcnt[mbp->param[0]]);
outparam = LONIB(mbpcnt[mbp->param[0]]);
if (inparam == 0 && outparam == 0) {
PRINTF("%s: no parameters for %x\n", isp->isp_name,
mbp->param[0]);
return;
}
command_known:
/*
* Make sure we can send some words..
*/
loops = MBOX_DELAY_COUNT;
while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) {
SYS_DELAY(100);
if (--loops < 0) {
PRINTF("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
return;
}
}
/*
* Write input parameters
*/
switch (inparam) {
case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0;
case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0;
case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0;
case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0;
case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0;
case 3: ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); mbp->param[2] = 0;
case 2: ISP_WRITE(isp, INMAILBOX1, mbp->param[1]); mbp->param[1] = 0;
case 1: ISP_WRITE(isp, INMAILBOX0, mbp->param[0]); mbp->param[0] = 0;
}
/*
* Clear semaphore on mailbox registers
*/
ISP_WRITE(isp, BIU_SEMA, 0);
/*
* Clear RISC int condition.
*/
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
/*
* Set Host Interrupt condition so that RISC will pick up mailbox regs.
*/
ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
/*
* Wait until RISC int is set, except 2100
*/
if ((isp->isp_type & ISP_HA_FC) == 0) {
loops = MBOX_DELAY_COUNT;
while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
SYS_DELAY(100);
if (--loops < 0) {
PRINTF("%s: isp_mboxcmd timeout #2\n",
isp->isp_name);
return;
}
}
}
/*
* Check to make sure that the semaphore has been set.
*/
loops = MBOX_DELAY_COUNT;
while ((ISP_READ(isp, BIU_SEMA) & 1) == 0) {
SYS_DELAY(100);
if (--loops < 0) {
PRINTF("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
return;
}
}
/*
* Make sure that the MBOX_BUSY has gone away
*/
loops = MBOX_DELAY_COUNT;
while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
SYS_DELAY(100);
if (--loops < 0) {
PRINTF("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
return;
}
}
/*
* Pick up output parameters.
*/
switch (outparam) {
case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7);
case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6);
case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5);
case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4);
case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3);
case 3: mbp->param[2] = ISP_READ(isp, OUTMAILBOX2);
case 2: mbp->param[1] = ISP_READ(isp, OUTMAILBOX1);
case 1: mbp->param[0] = ISP_READ(isp, OUTMAILBOX0);
}
/*
* Clear RISC int.
*/
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
/*
* Release semaphore on mailbox registers
*/
ISP_WRITE(isp, BIU_SEMA, 0);
/*
* Just to be chatty here...
*/
switch(mbp->param[0]) {
case MBOX_COMMAND_COMPLETE:
break;
case MBOX_INVALID_COMMAND:
/*
* GET_CLOCK_RATE can fail a lot
* So can a couple of other commands.
*/
if (isp->isp_dblev > 2 && opcode != MBOX_GET_CLOCK_RATE) {
PRINTF("%s: mbox cmd %x failed with INVALID_COMMAND\n",
isp->isp_name, opcode);
}
break;
case MBOX_HOST_INTERFACE_ERROR:
PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
isp->isp_name, opcode);
break;
case MBOX_TEST_FAILED:
PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
isp->isp_name, opcode);
break;
case MBOX_COMMAND_ERROR:
PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
isp->isp_name, opcode);
break;
case MBOX_COMMAND_PARAM_ERROR:
PRINTF("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n",
isp->isp_name, opcode);
break;
case ASYNC_LIP_OCCURRED:
break;
default:
/*
* The expected return of EXEC_FIRMWARE is zero.
*/
if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) ||
(opcode != MBOX_EXEC_FIRMWARE)) {
PRINTF("%s: mbox cmd %x failed with error %x\n",
isp->isp_name, opcode, mbp->param[0]);
}
break;
}
}
void
isp_lostcmd(struct ispsoftc *isp, ISP_SCSI_XFER_T *xs)
{
mbreg_t mbs;
mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
return;
}
if (mbs.param[1]) {
PRINTF("%s: %d commands on completion queue\n",
isp->isp_name, mbs.param[1]);
}
if (XS_NULL(xs))
return;
mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs);
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS");
return;
}
PRINTF("%s: lost command for target %d lun %d, %d active of %d, "
"Queue State: %x\n", isp->isp_name, XS_TGT(xs),
XS_LUN(xs), mbs.param[2], mbs.param[3], mbs.param[1]);
isp_dumpregs(isp, "lost command");
/*
* XXX: Need to try and do something to recover.
*/
}
static void
isp_dumpregs(struct ispsoftc *isp, const char *msg)
{
PRINTF("%s: %s\n", isp->isp_name, msg);
if (isp->isp_type & ISP_HA_SCSI)
PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
else
PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
PRINTF(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR));
if (isp->isp_type & ISP_HA_SCSI) {
ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
PRINTF(" cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
ISP_READ(isp, CDMA_FIFO_STS));
PRINTF(" ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
ISP_READ(isp, DDMA_FIFO_STS));
PRINTF(" sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
ISP_READ(isp, SXP_INTERRUPT),
ISP_READ(isp, SXP_GROSS_ERR),
ISP_READ(isp, SXP_PINS_CONTROL));
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
}
ISP_DUMPREGS(isp);
}
static void
isp_dumpxflist(struct ispsoftc *isp)
{
volatile ISP_SCSI_XFER_T *xs;
int i, hdp;
for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) {
xs = isp->isp_xflist[i];
if (xs == NULL) {
continue;
}
if (hdp == 0) {
PRINTF("%s: active requests\n", isp->isp_name);
hdp++;
}
PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n",
i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs));
}
}
static void
isp_fw_state(struct ispsoftc *isp)
{
mbreg_t mbs;
if (isp->isp_type & ISP_HA_FC) {
int once = 0;
fcparam *fcp = isp->isp_param;
again:
mbs.param[0] = MBOX_GET_FW_STATE;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
if (mbs.param[0] == ASYNC_LIP_OCCURRED) {
if (!once++) {
goto again;
}
}
isp_dumpregs(isp, "GET FIRMWARE STATE failed");
return;
}
fcp->isp_fwstate = mbs.param[1];
}
}
static void
isp_setdparm(struct ispsoftc *isp)
{
int i;
mbreg_t mbs;
sdparam *sdp;
isp->isp_fwrev = 0;
if (isp->isp_type & ISP_HA_FC) {
/*
* ROM in 2100 doesn't appear to support ABOUT_FIRMWARE
*/
return;
}
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
IDPRINTF(3, ("1st ABOUT FIRMWARE command failed"));
} else {
isp->isp_fwrev =
(((u_int16_t) mbs.param[1]) << 10) + mbs.param[2];
}
sdp = (sdparam *) isp->isp_param;
/*
* Try and get old clock rate out before we hit the
* chip over the head- but if and only if we don't
* know our desired clock rate.
*/
if (isp->isp_mdvec->dv_clock == 0) {
mbs.param[0] = MBOX_GET_CLOCK_RATE;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
sdp->isp_clock = mbs.param[1];
PRINTF("%s: using board clock 0x%x\n",
isp->isp_name, sdp->isp_clock);
}
} else {
sdp->isp_clock = isp->isp_mdvec->dv_clock;
}
mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
IDPRINTF(2, ("could not GET ACT NEG STATE\n"));
sdp->isp_req_ack_active_neg = 1;
sdp->isp_data_line_active_neg = 1;
} else {
sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1;
sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1;
}
for (i = 0; i < MAX_TARGETS; i++) {
mbs.param[0] = MBOX_GET_TARGET_PARAMS;
mbs.param[1] = i << 8;
isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
IDPRINTF(2, ("cannot get params for target %d\n", i));
sdp->isp_devparam[i].sync_period =
ISP_10M_SYNCPARMS & 0xff;
sdp->isp_devparam[i].sync_offset =
ISP_10M_SYNCPARMS >> 8;
sdp->isp_devparam[i].dev_flags = DPARM_DEFAULT;
} else {
IDPRINTF(3, ("\%s: target %d - flags 0x%x, sync %x\n",
isp->isp_name, i, mbs.param[2], mbs.param[3]));
sdp->isp_devparam[i].dev_flags = mbs.param[2] >> 8;
/*
* The maximum period we can really see
* here is 100 (decimal), or 400 ns.
* For some unknown reason we sometimes
* get back wildass numbers from the
* boot device's paramaters.
*/
if ((mbs.param[3] & 0xff) <= 0x64) {
sdp->isp_devparam[i].sync_period =
mbs.param[3] & 0xff;
sdp->isp_devparam[i].sync_offset =
mbs.param[3] >> 8;
}
}
}
/*
* Set Default Host Adapter Parameters
* XXX: Should try and get them out of NVRAM
*/
sdp->isp_adapter_enabled = 1;
sdp->isp_cmd_dma_burst_enable = 1;
sdp->isp_data_dma_burst_enabl = 1;
sdp->isp_fifo_threshold = 2;
sdp->isp_initiator_id = 7;
sdp->isp_async_data_setup = 6;
sdp->isp_selection_timeout = 250;
sdp->isp_max_queue_depth = 128;
sdp->isp_tag_aging = 8;
sdp->isp_bus_reset_delay = 3;
sdp->isp_retry_count = 0;
sdp->isp_retry_delay = 1;
for (i = 0; i < MAX_TARGETS; i++) {
sdp->isp_devparam[i].exc_throttle = 16;
sdp->isp_devparam[i].dev_enable = 1;
}
}
static void
isp_phoenix(struct ispsoftc *isp)
{
ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs;
int i;
for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i];
}
isp_reset(isp);
isp_init(isp);
isp->isp_state = ISP_RUNSTATE;
for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
xs = tlist[i];
if (XS_NULL(xs))
continue;
isp->isp_nactive--;
if (isp->isp_nactive < 0)
isp->isp_nactive = 0;
XS_RESID(xs) = XS_XFRLEN(xs);
XS_SETERR(xs, HBA_BOTCH);
XS_CMD_DONE(xs);
}
}
void
isp_watch(void *arg)
{
int i;
struct ispsoftc *isp = arg;
ISP_SCSI_XFER_T *xs;
ISP_LOCKVAL_DECL;
/*
* Look for completely dead commands (but not polled ones).
*/
ISP_ILOCK(isp);
for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
if ((xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]) == NULL) {
continue;
}
if (XS_TIME(xs) == 0) {
continue;
}
XS_TIME(xs) -= (WATCH_INTERVAL * 1000);
/*
* Avoid later thinking that this
* transaction is not being timed.
* Then give ourselves to watchdog
* periods of grace.
*/
if (XS_TIME(xs) == 0)
XS_TIME(xs) = 1;
else if (XS_TIME(xs) > -(2 * WATCH_INTERVAL * 1000)) {
continue;
}
if (isp_control(isp, ISPCTL_ABORT_CMD, xs)) {
PRINTF("%s: isp_watch failed to abort command\n",
isp->isp_name);
isp_phoenix(isp);
break;
}
}
ISP_IUNLOCK(isp);
RESTART_WATCHDOG(isp_watch, isp);
}
static void
isp_prtstst(ispstatusreq_t *sp)
{
PRINTF("states->");
if (sp->req_state_flags & RQSF_GOT_BUS)
PRINTF("GOT_BUS ");
if (sp->req_state_flags & RQSF_GOT_TARGET)
PRINTF("GOT_TGT ");
if (sp->req_state_flags & RQSF_SENT_CDB)
PRINTF("SENT_CDB ");
if (sp->req_state_flags & RQSF_XFRD_DATA)
PRINTF("XFRD_DATA ");
if (sp->req_state_flags & RQSF_GOT_STATUS)
PRINTF("GOT_STS ");
if (sp->req_state_flags & RQSF_GOT_SENSE)
PRINTF("GOT_SNS ");
if (sp->req_state_flags & RQSF_XFER_COMPLETE)
PRINTF("XFR_CMPLT ");
PRINTF("\n");
PRINTF("status->");
if (sp->req_status_flags & RQSTF_DISCONNECT)
PRINTF("Disconnect ");
if (sp->req_status_flags & RQSTF_SYNCHRONOUS)
PRINTF("Sync_xfr ");
if (sp->req_status_flags & RQSTF_PARITY_ERROR)
PRINTF("Parity ");
if (sp->req_status_flags & RQSTF_BUS_RESET)
PRINTF("Bus_Reset ");
if (sp->req_status_flags & RQSTF_DEVICE_RESET)
PRINTF("Device_Reset ");
if (sp->req_status_flags & RQSTF_ABORTED)
PRINTF("Aborted ");
if (sp->req_status_flags & RQSTF_TIMEOUT)
PRINTF("Timeout ");
if (sp->req_status_flags & RQSTF_NEGOTIATION)
PRINTF("Negotiation ");
PRINTF("\n");
}
Reference in New Issue View Git Blame Copy Permalink