summaryrefslogtreecommitdiff
path: root/sys/dev
diff options
context:
space:
mode:
authormjacob <mjacob@NetBSD.org>1997-08-16 00:22:11 +0000
committermjacob <mjacob@NetBSD.org>1997-08-16 00:22:11 +0000
commit14a7730c16abd067cea5d5ce32cefd27717c5e98 (patch)
tree67448588afbfe00c95d462d0b273f34c96e0c5c4 /sys/dev
parent7540ed1699d2aae9fa16e41f05959b104d2adc0e (diff)
*Major* differences to support the Qlogic 2100 (Fibre Channel PCI), as well
as being able to do microdifferentiation of the ISP SCSI chip; a couple of bug fixes, and the beginnings of some watchdog support.
Diffstat (limited to 'sys/dev')
-rw-r--r--sys/dev/ic/isp.c1568
1 files changed, 1194 insertions, 374 deletions
diff --git a/sys/dev/ic/isp.c b/sys/dev/ic/isp.c
index c837a2d68a7..c221c2a7433 100644
--- a/sys/dev/ic/isp.c
+++ b/sys/dev/ic/isp.c
@@ -1,4 +1,4 @@
-/* $NetBSD: isp.c,v 1.9 1997/07/28 18:56:36 mjacob Exp $ */
+/* $NetBSD: isp.c,v 1.10 1997/08/16 00:22:11 mjacob Exp $ */
/*
* Machine Independent (well, as best as possible)
@@ -76,7 +76,7 @@ struct cfdriver isp_cd = {
static void ispminphys __P((struct buf *));
static int32_t ispscsicmd __P((struct scsi_xfer *xs));
-static int isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
+static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
static struct scsi_adapter isp_switch = {
ispscsicmd, ispminphys, 0, 0
@@ -84,96 +84,142 @@ static struct scsi_adapter isp_switch = {
static struct scsi_device isp_dev = { NULL, NULL, NULL, NULL };
-static int isp_poll __P((struct ispsoftc *, struct scsi_xfer *, int));
-static int isp_parse_status __P((struct ispsoftc *, ispstatusreq_t *));
-static void isp_lostcmd __P((struct ispsoftc *, struct scsi_xfer *));
+#define IDPRINTF(lev, x) if (isp->isp_dblev >= lev) printf x
+static int isp_poll __P((struct ispsoftc *, struct scsi_xfer *, int));
+static int isp_parse_status
+__P((struct ispsoftc *, ispstatusreq_t *, struct scsi_xfer *));
+static void isp_lostcmd
+__P((struct ispsoftc *, struct scsi_xfer *, ispreq_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_setdparm __P((struct ispsoftc *));
+
+#define WATCHI (30 * hz)
+static void isp_watch __P((void *));
/*
* Reset Hardware.
- *
- * Only looks at sc_dev.dv_xname, sc_iot and sc_ioh fields.
*/
void
isp_reset(isp)
struct ispsoftc *isp;
{
mbreg_t mbs;
- int loops, i;
- u_int8_t clock;
+ int loops, i, cf_flags, dodnld = 1;
+ char *revname;
+
+ revname = "(unknown)";
isp->isp_state = ISP_NILSTATE;
- /*
- * Do MD specific pre initialization
- */
- ISP_RESET0(isp);
+ cf_flags = isp->isp_dev.dv_cfdata->cf_flags;
/*
- * 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.
+ * Basic types have been set in the MD code.
+ * See if we can't figure out more here.
*/
- clock = isp->isp_mdvec->dv_clock;
- if (clock == 0) {
- mbs.param[0] = MBOX_GET_CLOCK_RATE;
- (void) isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
- clock = mbs.param[1];
- printf("%s: using board clock 0x%x\n",
- isp->isp_name, clock);
- } else {
- clock = 0;
+ if (isp->isp_type & ISP_HA_FC) {
+ isp->isp_dblev = 2;
+ revname = "2100";
+ } else {
+ isp->isp_dblev = 1;
+ i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
+ switch (i) {
+ default:
+ printf("%s: unknown ISP type %x\n", isp->isp_name, i);
+ break;
+ case 1:
+ revname = "1020";
+ isp->isp_type = ISP_HA_SCSI_1020;
+ 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;
}
}
/*
- * Hit the chip over the head with hammer.
+ * Do MD specific pre initialization
*/
+ ISP_RESET0(isp);
+ isp_setdparm(isp);
- ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
/*
- * Give the ISP a chance to recover...
+ * Hit the chip over the head with hammer,
+ * and give the ISP a chance to recover.
*/
- delay(100);
- /*
- * Clear data && control DMA engines.
- */
- ISP_WRITE(isp, CDMA_CONTROL,
+ if (isp->isp_type & ISP_HA_SCSI) {
+ ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET);
+ /*
+ * A slight delay...
+ */
+ 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,
+ 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...
+ */
+ 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;
- while ((ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET) != 0) {
+ 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;
+ }
delay(100);
if (--loops < 0) {
- printf("%s: chip reset timed out\n", isp->isp_name);
+ isp_dumpregs(isp, "chip reset timed out");
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, BIU_CONF1, 0);
ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
delay(100);
- if (isp->isp_mdvec->dv_conf1) {
+ 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);
}
- } else {
- ISP_WRITE(isp, BIU_CONF1, 0);
}
-
-#if 0
- ISP_WRITE(isp, RISC_MTR, 0x1212); /* FM */
-#endif
ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */
/*
@@ -184,115 +230,113 @@ isp_reset(isp)
/*
* Enable interrupts
*/
- ISP_WRITE(isp, BIU_ICR,
- BIU_ICR_ENABLE_RISC_INT | BIU_ICR_ENABLE_ALL_INTS);
+ ENABLE_INTS(isp);
/*
* Do some sanity checking.
*/
-
mbs.param[0] = MBOX_NO_OP;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: NOP test failed\n", isp->isp_name);
- return;
- }
-
- 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;
- (void) isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: Mailbox Register test didn't complete\n",
- isp->isp_name);
- return;
- }
- i = 0;
- if (mbs.param[1] != 0xdead) {
- printf("%s: Register Test Failed @reg %d (got %x)\n",
- isp->isp_name, 1, mbs.param[1]);
- i++;
- }
- if (mbs.param[2] != 0xbeef) {
- printf("%s: Register Test Failed @reg %d (got %x)\n",
- isp->isp_name, 2, mbs.param[2]);
- i++;
- }
- if (mbs.param[3] != 0xffff) {
- printf("%s: Register Test Failed @reg %d (got %x)\n",
- isp->isp_name, 3, mbs.param[3]);
- i++;
- }
- if (mbs.param[4] != 0x1111) {
- printf("%s: Register Test Failed @reg %d (got %x)\n",
- isp->isp_name, 4, mbs.param[4]);
- i++;
- }
- if (mbs.param[5] != 0xa5a5) {
- printf("%s: Register Test Failed @reg %d (got %x)\n",
- isp->isp_name, 5, mbs.param[5]);
- i++;
- }
- if (i) {
+ isp_dumpregs(isp, "NOP test failed");
return;
}
- /*
- * Download new Firmware
- */
- 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];
- (void) isp_mboxcmd(isp, &mbs);
+ 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) {
- printf("%s: f/w download failed\n", isp->isp_name);
+ isp_dumpregs(isp,
+ "Mailbox Register test didn't complete");
+ 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");
return;
}
+
}
/*
- * Verify that it downloaded correctly.
+ * Download new Firmware, unless requested not to
+ * or not appropriate to do so.
*/
- mbs.param[0] = MBOX_VERIFY_CHECKSUM;
- mbs.param[1] = isp->isp_mdvec->dv_codeorg;
- (void) isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: ram checksum failure\n", isp->isp_name);
- return;
+ if ((isp->isp_fwrev >= isp->isp_mdvec->dv_fwrev) ||
+ (cf_flags & 0x80) != 0) {
+ 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");
+
+ 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");
+ return;
+ }
+ }
+ } else {
+ IDPRINTF(2, ("%s: skipping f/w download\n", isp->isp_name));
}
/*
- * Now start it rolling...
+ * 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;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
- /*
- * Set CLOCK RATE
- */
- if (clock) {
- mbs.param[0] = MBOX_SET_CLOCK_RATE;
- mbs.param[1] = clock;
- (void) isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: failed to set CLOCKRATE\n", isp->isp_name);
- return;
+ 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");
+ return;
+ }
}
}
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: ABOUT FIRMWARE command failed\n", isp->isp_name);
+ isp_dumpregs(isp, "ABOUT FIRMWARE command failed");
return;
}
- printf("%s: F/W Revision %d.%d\n", isp->isp_name,
+ 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;
}
@@ -303,166 +347,232 @@ void
isp_init(isp)
struct ispsoftc *isp;
{
+ sdparam *sdp;
mbreg_t mbs;
int s, i, l;
- /*
- * Set Default Host Adapter Parameters
- * XXX: Should try and get them out of NVRAM
- */
-
- isp->isp_adapter_enabled = 1;
- isp->isp_req_ack_active_neg = 1;
- isp->isp_data_line_active_neg = 1;
- isp->isp_cmd_dma_burst_enable = 1;
- isp->isp_data_dma_burst_enabl = 1;
- isp->isp_fifo_threshold = 2;
- isp->isp_initiator_id = 7;
- isp->isp_async_data_setup = 6;
- isp->isp_selection_timeout = 250;
- isp->isp_max_queue_depth = 256;
- isp->isp_tag_aging = 8;
- isp->isp_bus_reset_delay = 3;
- isp->isp_retry_count = 0;
- isp->isp_retry_delay = 1;
- for (i = 0; i < MAX_TARGETS; i++) {
- isp->isp_devparam[i].dev_flags = DPARM_DEFAULT;
- isp->isp_devparam[i].exc_throttle = 16;
- isp->isp_devparam[i].sync_period = 25;
- isp->isp_devparam[i].sync_offset = 12;
- isp->isp_devparam[i].dev_enable = 1;
+ 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.
+ */
s = splbio();
+ 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_SET_INIT_SCSI_ID;
- mbs.param[1] = isp->isp_initiator_id;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[0] = MBOX_GET_INIT_SCSI_ID;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: failed to set initiator id\n", isp->isp_name);
+ 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) {
+ (void) splx(s);
+ isp_dumpregs(isp, "failed to set initiator id");
+ return;
+ }
+ } else {
+ IDPRINTF(2, ("%s: leaving Initiator ID at %d\n", isp->isp_name,
+ sdp->isp_initiator_id));
+ }
mbs.param[0] = MBOX_SET_RETRY_COUNT;
- mbs.param[1] = isp->isp_retry_count;
- mbs.param[2] = isp->isp_retry_delay;
- (void) isp_mboxcmd(isp, &mbs);
+ 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) {
(void) splx(s);
- printf("%s: failed to set retry count and delay\n",
- isp->isp_name);
+ isp_dumpregs(isp, "failed to set retry count and delay");
return;
}
mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
- mbs.param[1] = isp->isp_async_data_setup;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[1] = sdp->isp_async_data_setup;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: failed to set async data setup time\n",
- isp->isp_name);
+ isp_dumpregs(isp, "failed to set async data setup time");
return;
}
mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE;
- mbs.param[1] =
- (isp->isp_req_ack_active_neg << 4) |
- (isp->isp_data_line_active_neg << 5);
- (void) isp_mboxcmd(isp, &mbs);
+ 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) {
(void) splx(s);
- printf("%s: failed to set active negation state\n",
- isp->isp_name);
+ isp_dumpregs(isp, "failed to set active neg state");
return;
}
-
mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
- mbs.param[1] = isp->isp_tag_aging;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[1] = sdp->isp_tag_aging;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: failed to set tag age limit\n", isp->isp_name);
+ isp_dumpregs(isp, "failed to set tag age limit");
return;
}
mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
- mbs.param[1] = isp->isp_selection_timeout;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[1] = sdp->isp_selection_timeout;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: failed to set selection timeout\n", isp->isp_name);
+ isp_dumpregs(isp, "failed to set selection timeout");
return;
}
+#ifdef 0
+ printf("%s: device parameters, W=wide, S=sync, T=TagEnable\n",
+ isp->isp_name);
+#endif
+
for (i = 0; i < MAX_TARGETS; i++) {
- if (isp->isp_devparam[i].dev_enable == 0)
+#ifdef 0
+ char bz[8];
+
+ if (sdp->isp_devparam[i].dev_flags & DPARM_SYNC) {
+ u_int16_t cj = (sdp->isp_devparam[i].sync_offset << 8) |
+ (sdp->isp_devparam[i].sync_period);
+ if (cj == ISP_20M_SYNCPARMS) {
+ cj = 20;
+ } else if (ISP_10M_SYNCPARMS) {
+ cj = 20;
+ } else if (ISP_08M_SYNCPARMS) {
+ cj = 20;
+ } else if (ISP_05M_SYNCPARMS) {
+ cj = 20;
+ } else if (ISP_04M_SYNCPARMS) {
+ cj = 20;
+ } else {
+ cj = 0;
+ }
+ if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE)
+ cj <<= 1;
+ sprintf(bz, "%02dMBs", cj);
+ } else {
+ sprintf(bz, "Async");
+ }
+ if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE)
+ bz[5] = 'W';
+ else
+ bz[5] = ' ';
+ if (sdp->isp_devparam[i].dev_flags & DPARM_TQING)
+ bz[6] = 'T';
+ else
+ bz[6] = ' ';
+ bz[7] = 0;
+ printf(" Tgt%x:%s", i, bz);
+ if (((i+1) & 0x3) == 0)
+ printf("\n");
+#endif
+ if (sdp->isp_devparam[i].dev_enable == 0)
continue;
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
mbs.param[1] = i << 8;
- mbs.param[2] = isp->isp_devparam[i].dev_flags << 8;
+ mbs.param[2] = sdp->isp_devparam[i].dev_flags << 8;
mbs.param[3] =
- (isp->isp_devparam[i].sync_offset << 8) |
- (isp->isp_devparam[i].sync_period);
- (void) isp_mboxcmd(isp, &mbs);
+ (sdp->isp_devparam[i].sync_offset << 8) |
+ (sdp->isp_devparam[i].sync_period);
+
+ IDPRINTF(5, ("%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) {
- (void) splx(s);
- printf("%s: failed to set target parameters\n",
- isp->isp_name);
- return;
+ 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) {
+ (void) splx(s);
+ 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] = isp->isp_max_queue_depth;
- mbs.param[3] = isp->isp_devparam[i].exc_throttle;
- (void) isp_mboxcmd(isp, &mbs);
+ 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) {
(void) splx(s);
- printf("%s: failed to set device queue "
- "parameters\n", isp->isp_name);
+ isp_dumpregs(isp, "failed to set device queue "
+ "parameters");
return;
}
}
}
-
/*
* Set up DMA for the request and result mailboxes.
*/
if (ISP_MBOXDMASETUP(isp)) {
(void) splx(s);
- printf("%s: can't setup DMA for mailboxes\n", isp->isp_name);
+ 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[1] = RESULT_QUEUE_LEN(isp);
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;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: set of response queue failed\n", isp->isp_name);
+ 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[1] = RQUEST_QUEUE_LEN(isp);
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;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[5] = 0;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: set of request queue failed\n", isp->isp_name);
+ isp_dumpregs(isp, "set of request queue failed");
return;
}
isp->isp_reqidx = 0;
@@ -476,19 +586,119 @@ isp_init(isp)
* get everyone to renegotiate.
*/
-
mbs.param[0] = MBOX_BUS_RESET;
mbs.param[1] = 2;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
(void) splx(s);
- printf("%s: SCSI bus reset failed\n", isp->isp_name);
+ isp_dumpregs(isp, "SCSI bus reset failed");
}
+ /*
+ * This is really important to have set after a bus reset.
+ */
isp->isp_sendmarker = 1;
(void) splx(s);
isp->isp_state = ISP_INITSTATE;
}
+static void
+isp_fibre_init(isp)
+ struct ispsoftc *isp;
+{
+ fcparam *fcp;
+ isp_icb_t *icbp;
+ mbreg_t mbs;
+ int s, count;
+
+ fcp = isp->isp_param;
+
+ fcp->isp_retry_count = 0;
+ fcp->isp_retry_delay = 1;
+
+ s = splbio();
+ 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) {
+ (void) splx(s);
+ isp_dumpregs(isp, "failed to set retry count and delay");
+ return;
+ }
+
+ if (ISP_MBOXDMASETUP(isp)) {
+ (void) splx(s);
+ 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(isp);
+ icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
+ 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(isp);
+ icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
+ 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) {
+ (void) splx(s);
+ isp_dumpregs(isp, "INIT FIRMWARE failed");
+ return;
+ }
+ isp->isp_reqidx = 0;
+ isp->isp_residx = 0;
+
+ /*
+ * Wait up to 3 seconds for FW to go to READY state.
+ *
+ * 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).
+ */
+ for (count = 0; count < 3000; count++) {
+ isp_fw_state(isp);
+ if (fcp->isp_fwstate == FW_READY)
+ break;
+ delay(1000); /* wait one millisecond */
+ }
+
+isp->isp_sendmarker = 1;
+
+ (void) splx(s);
+ isp->isp_state = ISP_INITSTATE;
+}
+
/*
* Complete attachment of Hardware, include subdevices.
*/
@@ -496,14 +706,53 @@ void
isp_attach(isp)
struct ispsoftc *isp;
{
+ /*
+ * Start the watchdog timer.
+ */
+ timeout(isp_watch, isp, WATCHI);
+
+ /*
+ * And complete initialization
+ */
isp->isp_state = ISP_RUNSTATE;
isp->isp_link.channel = SCSI_CHANNEL_ONLY_ONE;
isp->isp_link.adapter_softc = isp;
- isp->isp_link.adapter_target = isp->isp_initiator_id;
- isp->isp_link.adapter = &isp_switch;
isp->isp_link.device = &isp_dev;
- isp->isp_link.openings = RQUEST_QUEUE_LEN / (MAX_TARGETS - 1);
- isp->isp_link.max_target = MAX_TARGETS-1;
+ isp->isp_link.adapter = &isp_switch;
+
+ if (isp->isp_type & ISP_HA_FC) {
+ fcparam *fcp = isp->isp_param;
+ mbreg_t mbs;
+ int s;
+
+ isp->isp_link.max_target = MAX_FC_TARG-1;
+#if 0
+ isp->isp_link.openings = RQUEST_QUEUE_LEN(isp)/(MAX_FC_TARG-1);
+#else
+ isp->isp_link.openings = 8;
+#endif
+ s = splbio();
+ mbs.param[0] = MBOX_GET_LOOP_ID;
+ isp_mboxcmd(isp, &mbs);
+ (void) splx(s);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ isp_dumpregs(isp, "GET LOOP ID failed");
+ 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_link.adapter_target = 0xff;
+ } else {
+ isp->isp_link.openings = RQUEST_QUEUE_LEN(isp)/(MAX_TARGETS-1);
+ isp->isp_link.max_target = MAX_TARGETS-1;
+ isp->isp_link.adapter_target =
+ ((sdparam *)isp->isp_param)->isp_initiator_id;
+ }
+ if (isp->isp_link.openings < 2)
+ isp->isp_link.openings = 2;
config_found((void *)isp, &isp->isp_link, scsiprint);
}
@@ -515,10 +764,15 @@ void
isp_uninit(isp)
struct ispsoftc *isp;
{
+ untimeout(isp_watch, isp);
}
/*
* minphys our xfers
+ *
+ * Unfortunately, the buffer pointer describes the target device- not the
+ * adapter device, so we can't use the pointer to find out what kind of
+ * adapter we are and adjust accordingly.
*/
static void
@@ -529,7 +783,7 @@ ispminphys(bp)
* XX: Only the 1020 has a 24 bit limit.
*/
if (bp->b_bcount >= (1 << 24)) {
- bp->b_bcount = (1 << 24) - 1;
+ bp->b_bcount = (1 << 24);
}
minphys(bp);
}
@@ -543,16 +797,37 @@ ispscsicmd(xs)
{
struct ispsoftc *isp;
u_int8_t iptr, optr;
- ispreq_t *req;
+ union {
+ ispreq_t *_reqp;
+ ispreqt2_t *_t2reqp;
+ } _u;
+#define reqp _u._reqp
+#define t2reqp _u._t2reqp
int s, i;
isp = xs->sc_link->adapter_softc;
+ if (isp->isp_type & ISP_HA_FC) {
+#if 0
+ printf("%s: not doing FC now\n", isp->isp_name);
+ xs->error = XS_SELTIMEOUT;
+ xs->flags |= ITSDONE;
+ return (COMPLETE);
+#endif
+ if (xs->cmdlen > 12) {
+ printf("%s: unsupported cdb for fibre (%d)\n",
+ isp->isp_name, xs->cmdlen);
+ xs->error = XS_DRIVER_STUFFUP;
+ return (COMPLETE);
+ }
+if (isp->isp_type & ISP_HA_FC)
+ DISABLE_INTS(isp);
+ }
optr = ISP_READ(isp, OUTMAILBOX4);
iptr = isp->isp_reqidx;
- req = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
- iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
+ reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
+ iptr = (iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1);
if (iptr == optr) {
printf("%s: Request Queue Overflow\n", isp->isp_name);
xs->error = XS_DRIVER_STUFFUP;
@@ -560,8 +835,10 @@ ispscsicmd(xs)
}
s = splbio();
+if (isp->isp_type & ISP_HA_FC)
+ DISABLE_INTS(isp);
if (isp->isp_sendmarker) {
- ipsmarkreq_t *marker = (ipsmarkreq_t *) req;
+ ispmarkreq_t *marker = (ispmarkreq_t *) reqp;
bzero((void *) marker, sizeof (*marker));
marker->req_header.rqs_entry_count = 1;
@@ -570,52 +847,83 @@ ispscsicmd(xs)
isp->isp_sendmarker = 0;
- if (((iptr + 1) & (RQUEST_QUEUE_LEN - 1)) == optr) {
+ if (((iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1)) == optr) {
ISP_WRITE(isp, INMAILBOX4, iptr);
isp->isp_reqidx = iptr;
+if (isp->isp_type & ISP_HA_FC)
+ ENABLE_INTS(isp);
(void) splx(s);
printf("%s: Request Queue Overflow+\n", isp->isp_name);
xs->error = XS_DRIVER_STUFFUP;
return (TRY_AGAIN_LATER);
}
- req = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
- iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1);
+ reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr);
+ iptr = (iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1);
}
+ bzero((void *) reqp, sizeof (_u));
+ 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++;
- bzero((void *) req, sizeof (*req));
- req->req_header.rqs_entry_count = 1;
- req->req_header.rqs_entry_type = RQSTYPE_REQUEST;
- req->req_header.rqs_flags = 0;
- req->req_header.rqs_seqno = isp->isp_seqno++;
-
- for (i = 0; i < RQUEST_QUEUE_LEN; i++) {
+ for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) {
if (isp->isp_xflist[i] == NULL)
break;
}
- if (i == RQUEST_QUEUE_LEN) {
+ if (i == RQUEST_QUEUE_LEN(isp)) {
panic("%s: ran out of xflist pointers\n", isp->isp_name);
/* NOTREACHED */
} else {
+ /*
+ * Never have a handle that is zero, so
+ * set req_handle off by one.
+ */
isp->isp_xflist[i] = xs;
- req->req_handle = i;
+ reqp->req_handle = i+1;
}
- req->req_flags = 0;
- req->req_lun_trn = xs->sc_link->lun;
- req->req_target = xs->sc_link->target;
- req->req_cdblen = xs->cmdlen;
- bcopy((void *)xs->cmd, req->req_cdb, xs->cmdlen);
+ if (isp->isp_type & ISP_HA_FC) {
+ /*
+ * See comment in isp_intr
+ */
+ xs->resid = 0;
+ /*
+ * The QL2100 always requires some kind of tag.
+ */
+ if (xs->flags & SCSI_POLL) {
+ t2reqp->req_flags = REQFLAG_STAG;
+ } else {
+ t2reqp->req_flags = REQFLAG_OTAG;
+ }
+ } else {
+ if (xs->flags & SCSI_POLL) {
+ reqp->req_flags = 0;
+ } else {
+ reqp->req_flags = REQFLAG_OTAG;
+ }
+ }
+ reqp->req_lun_trn = xs->sc_link->lun;
+ reqp->req_target = xs->sc_link->target;
+ if (isp->isp_type & ISP_HA_SCSI) {
+ reqp->req_cdblen = xs->cmdlen;
+ }
+ bcopy((void *)xs->cmd, reqp->req_cdb, xs->cmdlen);
-#if 0
- printf("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
+ IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name,
xs->sc_link->target, xs->sc_link->lun,
- req->req_header.rqs_seqno, *(u_char *) xs->cmd, xs->datalen);
-#endif
-
- req->req_time = xs->timeout / 1000;
- req->req_seg_count = 0;
- if (ISP_DMASETUP(isp, xs, req, &iptr, optr)) {
+ reqp->req_header.rqs_seqno, *(u_char *) xs->cmd, xs->datalen));
+
+ reqp->req_time = xs->timeout / 1000;
+ if (reqp->req_time == 0 && xs->timeout)
+ reqp->req_time = 1;
+ if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) {
+if (isp->isp_type & ISP_HA_FC)
+ ENABLE_INTS(isp);
(void) splx(s);
xs->error = XS_DRIVER_STUFFUP;
return (COMPLETE);
@@ -623,6 +931,8 @@ ispscsicmd(xs)
xs->error = 0;
ISP_WRITE(isp, INMAILBOX4, iptr);
isp->isp_reqidx = iptr;
+if (isp->isp_type & ISP_HA_FC)
+ ENABLE_INTS(isp);
(void) splx(s);
if ((xs->flags & SCSI_POLL) == 0) {
return (SUCCESSFULLY_QUEUED);
@@ -643,11 +953,13 @@ ispscsicmd(xs)
* something bad happened.
*/
if ((xs->flags & ITSDONE) == 0 && xs->error == XS_NOERROR) {
- isp_lostcmd(isp, xs);
+ isp_lostcmd(isp, xs, reqp);
xs->error = XS_DRIVER_STUFFUP;
}
}
return (COMPLETE);
+#undef reqp
+#undef t2reqp
}
/*
@@ -683,21 +995,25 @@ isp_intr(arg)
u_int16_t iptr, optr, isr;
isr = ISP_READ(isp, BIU_ISR);
- if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) {
-#if 0
- if (isr) {
- printf("%s: isp_intr isr=%x\n", isp->isp_name, isr);
+ if (isp->isp_type & ISP_HA_FC) {
+ if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) {
+ if (isr) {
+ IDPRINTF(3, ("%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(3, ("%s: isp_intr isr=%x\n",
+ isp->isp_name, isr));
+ }
+ return (0);
}
-#endif
- return (0);
}
optr = isp->isp_residx;
- iptr = ISP_READ(isp, OUTMAILBOX5);
- ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
- ISP_WRITE(isp, BIU_ICR,
- BIU_ICR_ENABLE_RISC_INT | BIU_ICR_ENABLE_ALL_INTS);
-
if (ISP_READ(isp, BIU_SEMA) & 1) {
u_int16_t mbox0 = ISP_READ(isp, OUTMAILBOX0);
switch (mbox0) {
@@ -706,27 +1022,37 @@ isp_intr(arg)
printf("%s: bus or timeout 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;
default:
printf("%s: async %x\n", isp->isp_name, mbox0);
break;
}
ISP_WRITE(isp, BIU_SEMA, 0);
-#if 0
- } else {
- if (optr == iptr) {
- printf("why'd we interrupt? isr %x iptr %x optr %x\n",
- isr, optr, iptr);
- }
-#endif
}
+ ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
+ iptr = ISP_READ(isp, OUTMAILBOX5);
+ if (optr == iptr) {
+ IDPRINTF(3, ("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);
+ optr = (optr + 1) & (RESULT_QUEUE_LEN(isp)-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);
@@ -745,61 +1071,78 @@ isp_intr(arg)
printf("%s: rqs_flags=%x\n", isp->isp_name,
sp->req_header.rqs_flags & 0xf);
}
- if (sp->req_handle >= RQUEST_QUEUE_LEN) {
+ if (sp->req_handle > RQUEST_QUEUE_LEN(isp) ||
+ sp->req_handle < 1) {
printf("%s: bad request handle %d\n", isp->isp_name,
sp->req_handle);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
- xs = (struct scsi_xfer *) isp->isp_xflist[sp->req_handle];
+ xs = (struct scsi_xfer *) isp->isp_xflist[sp->req_handle - 1];
if (xs == NULL) {
printf("%s: NULL xs in xflist\n", isp->isp_name);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
- isp->isp_xflist[sp->req_handle] = NULL;
+ isp->isp_xflist[sp->req_handle - 1] = NULL;
if (sp->req_status_flags & RQSTF_BUS_RESET) {
isp->isp_sendmarker = 1;
}
if (buddaboom) {
xs->error = XS_DRIVER_STUFFUP;
}
- if (sp->req_state_flags & RQSF_GOT_SENSE) {
- bcopy(sp->req_sense_data, &xs->sense,
- sizeof (xs->sense));
- xs->error = XS_SENSE;
+ xs->status = 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->sense,
+ sizeof (xs->sense));
+ xs->error = XS_SENSE;
+ }
+ } else {
+ if (xs->status == SCSI_CHECK) {
+ xs->error = XS_SENSE;
+ bcopy(sp->req_sense_data, &xs->sense,
+ sizeof (xs->sense));
+ sp->req_state_flags |= RQSF_GOT_SENSE;
+ }
}
- xs->status = sp->req_scsi_status;
- if (xs->error == 0 && xs->status == SCSI_BUSY)
+ if (xs->error == 0 && xs->status == SCSI_BUSY) {
xs->error = XS_BUSY;
+ }
if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) {
- if (xs->error == 0)
- xs->error = isp_parse_status(isp, sp);
+ if (xs->error == 0 && sp->req_completion_status)
+ xs->error = isp_parse_status(isp, sp, xs);
} else {
printf("%s: unknown return %x\n", isp->isp_name,
sp->req_header.rqs_entry_type);
if (xs->error == 0)
xs->error = XS_DRIVER_STUFFUP;
}
- xs->resid = sp->req_resid;
+ if (isp->isp_type & ISP_HA_SCSI) {
+ xs->resid = sp->req_resid;
+ } else if (sp->req_scsi_status & RQCS_RU) {
+ xs->resid = sp->req_resid;
+ IDPRINTF(3, ("%s: cnt %d rsd %d\n", isp->isp_name,
+ xs->datalen, sp->req_resid));
+ }
xs->flags |= ITSDONE;
if (xs->datalen) {
- ISP_DMAFREE(isp, xs, sp->req_handle);
+ ISP_DMAFREE(isp, xs, sp->req_handle - 1);
}
-#if 0
- printf("%s(%d.%d): FINISH%d cmd 0x%x resid %d STS %x",
- isp->isp_name, xs->sc_link->target, xs->sc_link->lun,
- sp->req_header.rqs_seqno, *(u_char *) xs->cmd,
- xs->resid, xs->status);
- if (sp->req_state_flags & RQSF_GOT_SENSE) {
- printf(" Skey: %x", xs->sense.flags);
- if (xs->error != XS_SENSE) {
- printf(" BUT NOT SET");
+ if (isp->isp_dblev >= 5) {
+ printf("%s(%d.%d): FINISH%d cmd 0x%x resid %d STS %x",
+ isp->isp_name, xs->sc_link->target,
+ xs->sc_link->lun, sp->req_header.rqs_seqno,
+ *(u_char *) xs->cmd, xs->resid, xs->status);
+ if (sp->req_state_flags & RQSF_GOT_SENSE) {
+ printf(" Skey: %x", xs->sense.flags);
+ if (xs->error != XS_SENSE) {
+ printf(" BUT NOT SET");
+ }
}
+ printf(" xs->error %d\n", xs->error);
}
- printf(" xs->error %d\n", xs->error);
-#endif
ISP_WRITE(isp, INMAILBOX5, optr);
scsi_done(xs);
}
@@ -812,14 +1155,16 @@ isp_intr(arg)
*/
static int
-isp_parse_status(isp, sp)
+isp_parse_status(isp, sp, xs)
struct ispsoftc *isp;
ispstatusreq_t *sp;
+ struct scsi_xfer *xs;
{
switch (sp->req_completion_status) {
case RQCS_COMPLETE:
return (XS_NOERROR);
break;
+
case RQCS_INCOMPLETE:
if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
return (XS_SELTIMEOUT);
@@ -827,18 +1172,54 @@ isp_parse_status(isp, sp)
printf("%s: incomplete, state %x\n",
isp->isp_name, sp->req_state_flags);
break;
+ case RQCS_DATA_OVERRUN:
+ if (isp->isp_type & ISP_HA_FC) {
+ xs->resid = sp->req_resid;
+ break;
+ }
+ return (XS_NOERROR);
+
case RQCS_DATA_UNDERRUN:
+ if (isp->isp_type & ISP_HA_FC) {
+ xs->resid = sp->req_resid;
+ break;
+ }
return (XS_NOERROR);
+
case RQCS_TIMEOUT:
return (XS_TIMEOUT);
+
case RQCS_RESET_OCCURRED:
printf("%s: reset occurred\n", isp->isp_name);
isp->isp_sendmarker = 1;
break;
+
case RQCS_ABORTED:
printf("%s: command aborted\n", isp->isp_name);
isp->isp_sendmarker = 1;
break;
+
+ case RQCS_PORT_UNAVAILABLE:
+ /*
+ * No such port on the loop. Moral equivalent of SELTIMEO
+ */
+ return (XS_SELTIMEOUT);
+
+ case RQCS_PORT_LOGGED_OUT:
+ printf("%s: port logout for target %d\n",
+ isp->isp_name, xs->sc_link->target);
+ break;
+
+ case RQCS_PORT_CHANGED:
+ printf("%s: port changed for target %d\n",
+ isp->isp_name, xs->sc_link->target);
+ break;
+
+ case RQCS_PORT_BUSY:
+ printf("%s: port busy for target %d\n",
+ isp->isp_name, xs->sc_link->target);
+ return (XS_BUSY);
+
default:
printf("%s: comp status %x\n", isp->isp_name,
sp->req_completion_status);
@@ -851,97 +1232,194 @@ isp_parse_status(isp, sp)
#define LONIB(x) ((x) & 0xf)
#define MAKNIB(a, b) (((a) << 4) | (b))
static u_int8_t mbpcnt[] = {
- MAKNIB(1, 1), /* MBOX_NO_OP */
- MAKNIB(5, 5), /* MBOX_LOAD_RAM */
- MAKNIB(2, 0), /* MBOX_EXEC_FIRMWARE */
- MAKNIB(5, 5), /* MBOX_DUMP_RAM */
- MAKNIB(3, 3), /* MBOX_WRITE_RAM_WORD */
- MAKNIB(2, 3), /* MBOX_READ_RAM_WORD */
- MAKNIB(6, 6), /* MBOX_MAILBOX_REG_TEST */
- MAKNIB(2, 3), /* MBOX_VERIFY_CHECKSUM */
- MAKNIB(1, 3), /* MBOX_ABOUT_FIRMWARE */
- MAKNIB(0, 0), /* 0x0009 */
- MAKNIB(0, 0), /* 0x000a */
- MAKNIB(0, 0), /* 0x000b */
- MAKNIB(0, 0), /* 0x000c */
- MAKNIB(0, 0), /* 0x000d */
- MAKNIB(1, 2), /* MBOX_CHECK_FIRMWARE */
- MAKNIB(0, 0), /* 0x000f */
- MAKNIB(5, 5), /* MBOX_INIT_REQ_QUEUE */
- MAKNIB(6, 6), /* MBOX_INIT_RES_QUEUE */
- MAKNIB(4, 4), /* MBOX_EXECUTE_IOCB */
- MAKNIB(2, 2), /* MBOX_WAKE_UP */
- MAKNIB(1, 6), /* MBOX_STOP_FIRMWARE */
- MAKNIB(4, 4), /* MBOX_ABORT */
- MAKNIB(2, 2), /* MBOX_ABORT_DEVICE */
- MAKNIB(3, 3), /* MBOX_ABORT_TARGET */
- MAKNIB(2, 2), /* MBOX_BUS_RESET */
- MAKNIB(2, 3), /* MBOX_STOP_QUEUE */
- MAKNIB(2, 3), /* MBOX_START_QUEUE */
- MAKNIB(2, 3), /* MBOX_SINGLE_STEP_QUEUE */
- MAKNIB(2, 3), /* MBOX_ABORT_QUEUE */
- MAKNIB(2, 4), /* MBOX_GET_DEV_QUEUE_STATUS */
- MAKNIB(0, 0), /* 0x001e */
- MAKNIB(1, 3), /* MBOX_GET_FIRMWARE_STATUS */
- MAKNIB(1, 2), /* MBOX_GET_INIT_SCSI_ID */
- MAKNIB(1, 2), /* MBOX_GET_SELECT_TIMEOUT */
- MAKNIB(1, 3), /* MBOX_GET_RETRY_COUNT */
- MAKNIB(1, 2), /* MBOX_GET_TAG_AGE_LIMIT */
- MAKNIB(1, 2), /* MBOX_GET_CLOCK_RATE */
- MAKNIB(1, 2), /* MBOX_GET_ACT_NEG_STATE */
- MAKNIB(1, 2), /* MBOX_GET_ASYNC_DATA_SETUP_TIME */
- MAKNIB(1, 3), /* MBOX_GET_PCI_PARAMS */
- MAKNIB(2, 4), /* MBOX_GET_TARGET_PARAMS */
- MAKNIB(2, 4), /* MBOX_GET_DEV_QUEUE_PARAMS */
- MAKNIB(0, 0), /* 0x002a */
- MAKNIB(0, 0), /* 0x002b */
- MAKNIB(0, 0), /* 0x002c */
- MAKNIB(0, 0), /* 0x002d */
- MAKNIB(0, 0), /* 0x002e */
- MAKNIB(0, 0), /* 0x002f */
- MAKNIB(2, 2), /* MBOX_SET_INIT_SCSI_ID */
- MAKNIB(2, 2), /* MBOX_SET_SELECT_TIMEOUT */
- MAKNIB(3, 3), /* MBOX_SET_RETRY_COUNT */
- MAKNIB(2, 2), /* MBOX_SET_TAG_AGE_LIMIT */
- MAKNIB(2, 2), /* MBOX_SET_CLOCK_RATE */
- MAKNIB(2, 2), /* MBOX_SET_ACTIVE_NEG_STATE */
- MAKNIB(2, 2), /* MBOX_SET_ASYNC_DATA_SETUP_TIME */
- MAKNIB(3, 3), /* MBOX_SET_PCI_CONTROL_PARAMS */
- MAKNIB(4, 4), /* MBOX_SET_TARGET_PARAMS */
- MAKNIB(4, 4), /* MBOX_SET_DEV_QUEUE_PARAMS */
- MAKNIB(0, 0), /* 0x003a */
- MAKNIB(0, 0), /* 0x003b */
- MAKNIB(0, 0), /* 0x003c */
- MAKNIB(0, 0), /* 0x003d */
- MAKNIB(0, 0), /* 0x003e */
- MAKNIB(0, 0), /* 0x003f */
- MAKNIB(1, 2), /* MBOX_RETURN_BIOS_BLOCK_ADDR */
- MAKNIB(6, 1), /* MBOX_WRITE_FOUR_RAM_WORDS */
- MAKNIB(2, 3) /* MBOX_EXEC_BIOS_IOCB */
+ 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: */
+#ifdef USE_SUN_FW
+ 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 */
+#else
+ MAKNIB(0, 0), /* 0x60: */
+ MAKNIB(0, 0), /* 0x61: */
+ MAKNIB(0, 0), /* 0x62: */
+ MAKNIB(0, 0), /* 0x63: */
+ MAKNIB(0, 0), /* 0x64: */
+ MAKNIB(0, 0), /* 0x65: */
+ MAKNIB(0, 0), /* 0x66: */
+ MAKNIB(0, 0), /* 0x67: */
+ MAKNIB(0, 0), /* 0x68: */
+#endif
+ MAKNIB(1, 2), /* 0x69: MBOX_GET_FIRMWARE_STATE */
+ MAKNIB(0, 0), /* 0x6a: */
+ MAKNIB(0, 0), /* 0x6b: */
+ MAKNIB(0, 0), /* 0x6c: */
+ MAKNIB(0, 0), /* 0x6d: */
+ MAKNIB(0, 0), /* 0x6e: */
+ MAKNIB(0, 0), /* 0x6f: */
+ MAKNIB(0, 0), /* 0x70: */
+ MAKNIB(0, 0), /* 0x71: */
+ MAKNIB(0, 0), /* 0x72: */
+ MAKNIB(0, 0), /* 0x73: */
+ MAKNIB(0, 0), /* 0x74: */
+ MAKNIB(0, 0), /* 0x75: */
+ MAKNIB(0, 0), /* 0x76: */
+ MAKNIB(0, 0), /* 0x77: */
+ MAKNIB(0, 0), /* 0x78: */
+ MAKNIB(0, 0), /* 0x79: */
+ MAKNIB(0, 0), /* 0x7a: */
+ MAKNIB(0, 0), /* 0x7b: */
+ MAKNIB(0, 0), /* 0x7c: */
+ MAKNIB(0, 0), /* 0x7d: */
+ MAKNIB(0, 0), /* 0x7e: */
+#ifdef USE_SUN_FW
+ MAKNIB(0, 0) /* 0x7f: */
+#else
+ MAKNIB(0, 0), /* 0x7f: */
+ MAKNIB(8, 6), /* 0x80: MBOX_INIT_FIRMWARE */
+ MAKNIB(2, 1), /* 0x81: MBOX_INIT_LIP */
+ MAKNIB(8, 1), /* 0x82: MBOX_GET_FC_AL_POSITION_MAP */
+ MAKNIB(8, 1), /* 0x83: MBOX_GET_PORT_DB */
+ MAKNIB(2, 1), /* 0x84: MBOX_QCTRL */
+ MAKNIB(2, 1), /* 0x85: MBOX_PCTRL */
+ MAKNIB(3, 1), /* 0x86: MBOX_CLEAR_ACA */
+ MAKNIB(3, 1), /* 0x87: MBOX_TARGET_RESET */
+ MAKNIB(3, 1), /* 0x88: MBOX_CLEAR_TASK_SET */
+ MAKNIB(3, 1) /* 0x89: MBOX_ABORT_TASK_SET */
+#endif
};
#define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0]))
-static int
+static void
isp_mboxcmd(isp, mbp)
struct ispsoftc *isp;
mbreg_t *mbp;
{
int outparam, inparam;
int loops;
-
- if (mbp->param[0] > NMBCOM) {
+ 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 (-1);
+ 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 (-1);
+ return;
}
+
+command_known:
/*
* Make sure we can send some words..
*/
@@ -951,7 +1429,7 @@ isp_mboxcmd(isp, mbp)
delay(100);
if (--loops < 0) {
printf("%s: isp_mboxcmd timeout #1\n", isp->isp_name);
- return (-1);
+ return;
}
}
@@ -959,6 +1437,8 @@ isp_mboxcmd(isp, mbp)
* 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;
@@ -983,14 +1463,17 @@ isp_mboxcmd(isp, mbp)
ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT);
/*
- * Wait until RISC int is set
+ * Wait until RISC int is set, except 2100
*/
- loops = MBOX_DELAY_COUNT;
- while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
- delay(100);
- if (--loops < 0) {
- printf("%s: isp_mboxcmd timeout #2\n", isp->isp_name);
- return (-1);
+ if ((isp->isp_type & ISP_HA_FC) == 0) {
+ loops = MBOX_DELAY_COUNT;
+ while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) {
+ delay(100);
+ if (--loops < 0) {
+ printf("%s: isp_mboxcmd timeout #2\n",
+ isp->isp_name);
+ return;
+ }
}
}
@@ -1002,7 +1485,7 @@ isp_mboxcmd(isp, mbp)
delay(100);
if (--loops < 0) {
printf("%s: isp_mboxcmd timeout #3\n", isp->isp_name);
- return (-1);
+ return;
}
}
@@ -1014,7 +1497,7 @@ isp_mboxcmd(isp, mbp)
delay(100);
if (--loops < 0) {
printf("%s: isp_mboxcmd timeout #4\n", isp->isp_name);
- return (-1);
+ return;
}
}
@@ -1023,6 +1506,8 @@ isp_mboxcmd(isp, mbp)
* 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);
@@ -1040,33 +1525,368 @@ isp_mboxcmd(isp, mbp)
* Release semaphore on mailbox registers
*/
ISP_WRITE(isp, BIU_SEMA, 0);
- return (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 > 1 && 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;
+ }
}
static void
-isp_lostcmd(struct ispsoftc *isp, struct scsi_xfer *xs)
+isp_lostcmd(struct ispsoftc *isp, struct scsi_xfer *xs, ispreq_t *req)
{
mbreg_t mbs;
- mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
- (void) isp_mboxcmd(isp, &mbs);
+ mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: couldn't GET FIRMWARE STATUS\n", isp->isp_name);
+ isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS");
return;
}
- printf("%s: lost command, %d commands active of total %d\n",
- isp->isp_name, mbs.param[1], mbs.param[2]);
+ if (mbs.param[1]) {
+ printf("%s: %d commands on completion queue\n",
+ isp->isp_name, mbs.param[1]);
+ }
if (xs == NULL || xs->sc_link == NULL)
return;
mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS;
mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun;
- (void) isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- printf("%s: couldn't GET DEVICE STATUS\n", isp->isp_name);
+ 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->sc_link->target,
+ xs->sc_link->lun, mbs.param[2], mbs.param[3], mbs.param[1]);
+
+ isp_dumpregs(isp, "lost command");
+ /*
+ * XXX: Need to try and do something to recover.
+ */
+#if 0
+ mbs.param[0] = MBOX_STOP_QUEUE;
+ mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ isp_dumpregs(isp, "couldn't stop device queue");
+ return;
+ }
+ printf("%s: tgt %d lun %d, state %x\n", isp->isp_name,
+ xs->sc_link->target, xs->sc_link->lun, mbs.param[2] & 0xff);
+
+ /*
+ * If Queue Aborted, need to do a SendMarker
+ */
+ if (mbs.param[1] & 0x1)
+ isp->isp_sendmarker = 1;
+ if (req == NULL)
+ return;
+
+ isp->isp_sendmarker = 1;
+
+ mbs.param[0] = MBOX_ABORT;
+ mbs.param[1] = (xs->sc_link->target << 8) | xs->sc_link->lun;
+ mbs.param[2] = (req->req_handle - 1) >> 16;
+ mbs.param[3] = (req->req_handle - 1) & 0xffff;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ printf("%s: couldn't abort command\n", isp->isp_name );
+ mbs.param[0] = MBOX_ABORT_DEVICE;
+ mbs.param[1] = (xs->sc_link->target << 8) | xs->sc_link->lun;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ printf("%s: couldn't abort device\n", isp->isp_name );
+ } else {
+ if (isp_poll(isp, xs, xs->timeout)) {
+ isp_lostcmd(isp, xs, NULL);
+ }
+ }
+ } else {
+ if (isp_poll(isp, xs, xs->timeout)) {
+ isp_lostcmd(isp, xs, NULL);
+ }
+ }
+ mbs.param[0] = MBOX_START_QUEUE;
+ mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ isp_dumpregs(isp, "couldn't start device queue");
+ }
+#endif
+}
+
+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("\tbiu_conf1=%x", ISP_READ(isp, BIU_CONF1));
+ else
+ printf("\tbiu_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("\tcdma_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("\tddma_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("\tsxp_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_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;
}
- printf("%s: lost command, target %d lun %d, State: %x\n",
- isp->isp_name, mbs.param[1] >> 8, mbs.param[1] & 0x7,
- mbs.param[2] & 0xff);
+
+ mbs.param[0] = MBOX_ABOUT_FIRMWARE;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ IDPRINTF(2, ("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(5, ("could not GET ACT NEG STATE"));
+ 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(5, ("cannot get params for target %d", 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 {
+#if 0
+ printf("%s: target %d - flags 0x%x, sync %x\n",
+ isp->isp_name, i, mbs.param[2], mbs.param[3]);
+#endif
+ 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 = 256;
+ 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)
+{
+ struct scsi_xfer *tlist[MAXISPREQUEST], *xs;
+ int i;
+
+ for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) {
+ tlist[i] = (struct scsi_xfer *) isp->isp_xflist[i];
+ }
+ isp_reset(isp);
+ isp_init(isp);
+ isp->isp_state = ISP_RUNSTATE;
+
+ for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) {
+ xs = tlist[i];
+ if (xs == NULL)
+ continue;
+ xs->resid = xs->datalen;
+ xs->error = XS_DRIVER_STUFFUP;
+ xs->flags |= ITSDONE;
+ scsi_done(xs);
+ }
+}
+
+static void
+isp_watch(void *arg)
+{
+ int s, i;
+ struct ispsoftc *isp = arg;
+ struct scsi_xfer *xs;
+
+ /*
+ * Look for completely dead commands (but not polled ones)
+ */
+ s = splbio();
+ for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) {
+ if ((xs = (struct scsi_xfer *) isp->isp_xflist[i]) == NULL) {
+ continue;
+ }
+ if (xs->flags & SCSI_POLL)
+ continue;
+ if (xs->timeout == 0) {
+ continue;
+ }
+ xs->timeout -= (WATCHI * 1000);
+ if (xs->timeout > -(2 * WATCHI * 1000)) {
+ continue;
+ }
+ printf("%s: commands really timed out!\n", isp->isp_name);
+
+ isp_phoenix(isp);
+#if not
+ {
+ mbreg_t mbs;
+ mbs.param[0] = MBOX_BUS_RESET;
+ mbs.param[1] = 0;
+ isp_mboxcmd(isp, &mbs);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ printf("%s: bus reset failed\n", isp->isp_name);
+ isp_phoenix(isp);
+ }
+ isp->isp_sendmarker = 1;
+ }
+#endif
+ break;
+ }
+ (void) splx(s);
+ timeout(isp_watch, arg, WATCHI);
}