summaryrefslogtreecommitdiffstats
path: root/sys/dev/isp
diff options
context:
space:
mode:
authormjacob <mjacob@FreeBSD.org>2000-08-01 06:51:05 +0000
committermjacob <mjacob@FreeBSD.org>2000-08-01 06:51:05 +0000
commit8836b07cf61f646cb73dffc7a84b7f862268e3a1 (patch)
tree3091bfe7e549dd30ec8d0d84e294cd9a9a0e4129 /sys/dev/isp
parent4b4777407a50f3cf96be2addda75d92b862a174b (diff)
downloadFreeBSD-src-8836b07cf61f646cb73dffc7a84b7f862268e3a1.zip
FreeBSD-src-8836b07cf61f646cb73dffc7a84b7f862268e3a1.tar.gz
Major whacking for core version 2.0. A major motivator for 2.0 and these
changes is that there's now a Solaris port of this driver, so some things in the core version had to change (not much, but some). In order, from the top.....: A lot of error strings are gathered in one place at the head of the file. This caused me to rewrite them to look consistent (with respect to things like 'Port 0x%' and 'Target %d' and 'Loop ID 0x%x'. The major mailbox function, isp_mboxcmd, now takes a third argument, which is a mask that selectively says whether mailbox command failures will be logged. This will substantially reduce a lot of spurious noise from the driver. At the first run through isp_reset we used to try and get the current running firmware's revision by issuing a mailbox command. This would invariably fail on alpha's with anything but a Qlogic 1040 since SRM doesn't *start* the f/w on these cards. Instead, we now see whether we're sitting ROM state before trying to get a running BIOS loaded f/w version. All CFGPRINTF/PRINTF/IDPRINTF macros have been replaced with calls to isp_prt. There are seperate print levels that can be independently set (see ispvar.h), which include debugging, etc. All SYS_DELAY macros are now USEC_DELAY macros. RQUEST_QUEUE_LEN and RESULT_QUEUE_LEN now take ispsoftc as a parameter- the Fibre Channel cards and the Ultra2/Ultra3 cards can have 16 bit request queue entry indices, so we can make a 1024 entry index for them instead of the 256 entries we've had until now. A major change it to fix isp_fclink_test to actually only wait the delay of time specified in the microsecond argument being passed. The problem has always been that a call to isp_mboxcmd to get he current firmware state takes an unknown (sometimes long) amount of time- this is if the firmware is busy doing PLOGIs while we ask it what's up. So, up until now, the usdelay argument has been a joke. The net effect has been that if you boot without being plugged into a good loop or into a switch, you hang. Massively annonying, and hard to fix because the actual time delta was impossible to know from just guessing. Now, using the new GET_NANOTIME macros, a precise and measured amount of USEC_DELAY calls are done so that only the specified usecdelay is allowed to pass. This means that if the initial startup of the firmware if followed by a call from isp_freebsd.c:isp_attach to isp_control(isp, ISP_FCLINK_TEST, &tdelay) where tdelay is 2 * 1000000, no more than two seconds will actually elapse before we leave concluding that the cable is unhooked. Jeez. About time.... Change the ispscsicmd entry point to isp_start, and the XS_CMD_DONE macro to a call to the platform supplied isp_done (sane naming). Limit our size of request queue completions we'll look at at interrupt time. Since we've increased the size of the Request Queue (and the size of the Response Queue proportionally), let's not create an interrupt stack overflow by having to keep a max completion list (forw links are not an option because this is common code with some platforms that don't have link space in their XS_T structures). A limit of 32 is not unreasonable- I doubt there'd be even this many request queue completions at a time- remember, most boards now use fast posting for normal command completion instead of filling out response queue entries. In the isp_mboxcmd cleanup, also create an array of command names so that "ABOUT FIRMWARE" can be printed instead of "CMD #8". Remove the isp_lostcmd function- it's been deprecated for a while. Remove isp_dumpregs- the ISP_DUMPREGS goes to the specific bus register dump fucntion. Various other cleanups.
Diffstat (limited to 'sys/dev/isp')
-rw-r--r--sys/dev/isp/isp.c1918
1 files changed, 980 insertions, 938 deletions
diff --git a/sys/dev/isp/isp.c b/sys/dev/isp/isp.c
index 4ee5d47..891527c 100644
--- a/sys/dev/isp/isp.c
+++ b/sys/dev/isp/isp.c
@@ -54,6 +54,9 @@
#ifdef __linux__
#include "isp_linux.h"
#endif
+#ifdef __svr4__
+#include "isp_solaris.h"
+#endif
/*
* General defines
@@ -64,7 +67,44 @@
/*
* Local static data
*/
-
+static char *warnlun =
+ "WARNING- cannot determine Expanded LUN capability- limiting to one LUN";
+static char *portshift =
+ "Target %d Loop ID 0x%x (Port 0x%x) => Loop 0x%x (Port 0x%x)";
+static char *portdup =
+ "Target %d duplicates Target %d- killing off both";
+static char *retained =
+ "Retaining Loop ID 0x%x for Target %d (Port 0x%x)";
+#ifdef ISP2100_FABRIC
+static char *lretained =
+ "Retained login of Target %d (Loop ID 0x%x) Port 0x%x";
+static char *plogout =
+ "Logging out Target %d at Loop ID 0x%x (Port 0x%x)";
+static char *plogierr =
+ "Command Error in PLOGI for Port 0x%x (0x%x)";
+static char *nopdb =
+ "Could not get PDB for Device @ Port 0x%x";
+static char *pdbmfail1 =
+ "PDB Loop ID info for Device @ Port 0x%x does not match up (0x%x)";
+static char *pdbmfail2 =
+ "PDB Port info for Device @ Port 0x%x does not match up (0x%x)";
+static char *ldumped =
+ "Target %d (Loop ID 0x%x) Port 0x%x dumped after login info mismatch";
+#endif
+static char *notresp =
+ "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d)";
+static char *xact1 =
+ "HBA attempted queued transaction with disconnect not set for %d.%d.%d";
+static char *xact2 =
+ "HBA attempted queued transaction to target routine %d on target %d bus %d";
+static char *xact3 =
+ "HBA attempted queued cmd for %d.%d.%d when queueing disabled";
+static char *pskip =
+ "SCSI phase skipped for target %d.%d.%d";
+static char *topology =
+ "Loop ID %d, AL_PA 0x%x, Port ID 0x%x, Loop State 0x%x, Topology '%s'";
+static char *finmsg =
+ "(%d.%d.%d): FIN dl%d resid%d STS 0x%x SKEY %c XS_ERR=0x%x";
/*
* Local function prototypes.
*/
@@ -72,7 +112,7 @@ static int isp_parse_async __P((struct ispsoftc *, int));
static int isp_handle_other_response
__P((struct ispsoftc *, ispstatusreq_t *, u_int16_t *));
static void isp_parse_status
-__P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *));
+__P((struct ispsoftc *, ispstatusreq_t *, XS_T *));
static void isp_fastpost_complete __P((struct ispsoftc *, u_int32_t));
static void isp_scsi_init __P((struct ispsoftc *));
static void isp_scsi_channel_init __P((struct ispsoftc *, int));
@@ -81,14 +121,14 @@ static void isp_mark_getpdb_all __P((struct ispsoftc *));
static int isp_getpdb __P((struct ispsoftc *, int, isp_pdb_t *));
static u_int64_t isp_get_portname __P((struct ispsoftc *, int, int));
static int isp_fclink_test __P((struct ispsoftc *, int));
+static char *isp2100_fw_statename __P((int));
static int isp_same_lportdb __P((struct lportdb *, struct lportdb *));
static int isp_pdb_sync __P((struct ispsoftc *, int));
#ifdef ISP2100_FABRIC
static int isp_scan_fabric __P((struct ispsoftc *));
#endif
static void isp_fw_state __P((struct ispsoftc *));
-static void isp_dumpregs __P((struct ispsoftc *, const char *));
-static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *));
+static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *, int));
static void isp_update __P((struct ispsoftc *));
static void isp_update_bus __P((struct ispsoftc *, int));
@@ -100,7 +140,6 @@ static void isp_parse_nvram_1080 __P((struct ispsoftc *, int, u_int8_t *));
static void isp_parse_nvram_12160 __P((struct ispsoftc *, int, u_int8_t *));
static void isp_parse_nvram_2100 __P((struct ispsoftc *, u_int8_t *));
-
/*
* Reset Hardware.
*
@@ -118,16 +157,14 @@ isp_reset(isp)
isp->isp_state = ISP_NILSTATE;
+
/*
* Basic types (SCSI, FibreChannel and PCI or SBus)
* have been set in the MD code. We figure out more
* here.
- */
- isp->isp_dblev = DFLT_DBLEVEL;
-
- /*
+ *
* After we've fired this chip up, zero out the conf1 register
- * for SCSI adapters and other settings for the 2100.
+ * for SCSI adapters and do other settings for the 2100.
*/
/*
@@ -140,19 +177,27 @@ isp_reset(isp)
*/
if ((touched = isp->isp_touched) == 0) {
/*
- * Just in case it was paused...
- */
- ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
- mbs.param[0] = MBOX_ABOUT_FIRMWARE;
- isp_mboxcmd(isp, &mbs);
- /*
- * If this fails, it probably means we're running
- * an old prom, if anything at all...
+ * First see whether or not we're sitting in the ISP PROM.
+ * If we've just been reset, we'll have the string "ISP "
+ * spread through outgoing mailbox registers 1-3.
*/
- if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
- isp->isp_romfw_rev[0] = mbs.param[1];
- isp->isp_romfw_rev[1] = mbs.param[2];
- isp->isp_romfw_rev[2] = mbs.param[3];
+ if (ISP_READ(isp, OUTMAILBOX1) != 0x4953 ||
+ ISP_READ(isp, OUTMAILBOX2) != 0x5020 ||
+ ISP_READ(isp, OUTMAILBOX3) != 0x2020) {
+ /*
+ * Just in case it was paused...
+ */
+ ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
+ mbs.param[0] = MBOX_ABOUT_FIRMWARE;
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
+ /*
+ * This *shouldn't* fail.....
+ */
+ if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
+ isp->isp_romfw_rev[0] = mbs.param[1];
+ isp->isp_romfw_rev[1] = mbs.param[2];
+ isp->isp_romfw_rev[2] = mbs.param[3];
+ }
}
isp->isp_touched = 1;
}
@@ -187,7 +232,7 @@ isp_reset(isp)
* XXX: Should probably do some bus sensing.
*/
} else if (IS_ULTRA2(isp)) {
- static char *m = "%s: bus %d is in %s Mode\n";
+ static char *m = "bus %d is in %s Mode";
u_int16_t l;
sdparam *sdp = isp->isp_param;
@@ -206,19 +251,19 @@ isp_reset(isp)
switch (l) {
case ISP1080_LVD_MODE:
sdp->isp_lvdmode = 1;
- CFGPRINTF(m, isp->isp_name, 0, "LVD");
+ isp_prt(isp, ISP_LOGCONFIG, m, 0, "LVD");
break;
case ISP1080_HVD_MODE:
sdp->isp_diffmode = 1;
- CFGPRINTF(m, isp->isp_name, 0, "Differential");
+ isp_prt(isp, ISP_LOGCONFIG, m, 0, "Differential");
break;
case ISP1080_SE_MODE:
sdp->isp_ultramode = 1;
- CFGPRINTF(m, isp->isp_name, 0, "Single-Ended");
+ isp_prt(isp, ISP_LOGCONFIG, m, 0, "Single-Ended");
break;
default:
- CFGPRINTF("%s: unknown mode on bus %d (0x%x)\n",
- isp->isp_name, 0, l);
+ isp_prt(isp, ISP_LOGERR,
+ "unknown mode on bus %d (0x%x)", 0, l);
break;
}
@@ -229,19 +274,21 @@ isp_reset(isp)
switch(l) {
case ISP1080_LVD_MODE:
sdp->isp_lvdmode = 1;
- CFGPRINTF(m, isp->isp_name, 1, "LVD");
+ isp_prt(isp, ISP_LOGCONFIG, m, 1, "LVD");
break;
case ISP1080_HVD_MODE:
sdp->isp_diffmode = 1;
- CFGPRINTF(m, isp->isp_name, 1, "Differential");
+ isp_prt(isp, ISP_LOGCONFIG,
+ m, 1, "Differential");
break;
case ISP1080_SE_MODE:
sdp->isp_ultramode = 1;
- CFGPRINTF(m, isp->isp_name, 1, "Single-Ended");
+ isp_prt(isp, ISP_LOGCONFIG,
+ m, 1, "Single-Ended");
break;
default:
- CFGPRINTF("%s: unknown mode on bus %d (0x%x)\n",
- isp->isp_name, 1, l);
+ isp_prt(isp, ISP_LOGERR,
+ "unknown mode on bus %d (0x%x)", 1, l);
break;
}
}
@@ -250,8 +297,7 @@ isp_reset(isp)
i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK;
switch (i) {
default:
- PRINTF("%s: unknown chip rev. 0x%x- assuming a 1020\n",
- isp->isp_name, i);
+ isp_prt(isp, ISP_LOGALL, "Unknown Chip Type 0x%x", i);
/* FALLTHROUGH */
case 1:
revname = "1020";
@@ -294,7 +340,7 @@ isp_reset(isp)
* and/or differential mode.
*/
if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_MODE) {
- CFGPRINTF("%s: Differential Mode\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGCONFIG, "Differential Mode");
sdp->isp_diffmode = 1;
} else {
sdp->isp_diffmode = 0;
@@ -306,7 +352,7 @@ isp_reset(isp)
i &= RISC_PSR_PCI_ULTRA;
}
if (i != 0) {
- CFGPRINTF("%s: Ultra Mode Capable\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGCONFIG, "Ultra Mode Capable");
sdp->isp_ultramode = 1;
/*
* If we're in Ultra Mode, we have to be 60Mhz clock-
@@ -349,15 +395,7 @@ again:
/*
* A slight delay...
*/
- SYS_DELAY(100);
-
-#if 0
- PRINTF("%s: mbox0-5: 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
- isp->isp_name, ISP_READ(isp, OUTMAILBOX0),
- ISP_READ(isp, OUTMAILBOX1), ISP_READ(isp, OUTMAILBOX2),
- ISP_READ(isp, OUTMAILBOX3), ISP_READ(isp, OUTMAILBOX4),
- ISP_READ(isp, OUTMAILBOX5));
-#endif
+ USEC_DELAY(100);
/*
* Clear data && control DMA engines.
@@ -373,7 +411,7 @@ again:
/*
* A slight delay...
*/
- SYS_DELAY(100);
+ USEC_DELAY(100);
/*
* Clear data && control DMA engines.
@@ -398,9 +436,9 @@ again:
if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET))
break;
}
- SYS_DELAY(100);
+ USEC_DELAY(100);
if (--loops < 0) {
- isp_dumpregs(isp, "chip reset timed out");
+ ISP_DUMPREGS(isp, "chip reset timed out");
return;
}
}
@@ -420,7 +458,7 @@ again:
* Reset RISC Processor
*/
ISP_WRITE(isp, HCCR, HCCR_CMD_RESET);
- SYS_DELAY(100);
+ USEC_DELAY(100);
/*
* Establish some initial burst rate stuff.
@@ -472,10 +510,10 @@ again:
*/
loops = MBOX_DELAY_COUNT;
while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
- SYS_DELAY(100);
+ USEC_DELAY(100);
if (--loops < 0) {
- PRINTF("%s: MBOX_BUSY never cleared on reset\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGERR,
+ "MBOX_BUSY never cleared on reset");
return;
}
}
@@ -490,9 +528,8 @@ again:
* Do some sanity checking.
*/
mbs.param[0] = MBOX_NO_OP;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- isp_dumpregs(isp, "NOP test failed");
return;
}
@@ -503,16 +540,17 @@ again:
mbs.param[3] = 0xffff;
mbs.param[4] = 0x1111;
mbs.param[5] = 0xa5a5;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- 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");
+ isp_prt(isp, ISP_LOGERR,
+ "Register Test Failed (0x%x 0x%x 0x%x 0x%x 0x%x)",
+ mbs.param[1], mbs.param[2], mbs.param[3],
+ mbs.param[4], mbs.param[5]);
return;
}
@@ -533,17 +571,15 @@ again:
}
if (dodnld) {
- u_int16_t fwlen = isp->isp_mdvec->dv_fwlen;
- if (fwlen == 0)
- fwlen = isp->isp_mdvec->dv_ispfw[3]; /* usually here */
+ u_int16_t fwlen = isp->isp_mdvec->dv_ispfw[3];
for (i = 0; i < fwlen; i++) {
mbs.param[0] = MBOX_WRITE_RAM_WORD;
- mbs.param[1] = isp->isp_mdvec->dv_codeorg + i;
+ mbs.param[1] = ISP_CODE_ORG + i;
mbs.param[2] = isp->isp_mdvec->dv_ispfw[i];
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: F/W download failed at word %d\n",
- isp->isp_name, i);
+ isp_prt(isp, ISP_LOGERR,
+ "F/W download failed at word %d", i);
dodnld = 0;
goto again;
}
@@ -553,14 +589,14 @@ again:
* Verify that it downloaded correctly.
*/
mbs.param[0] = MBOX_VERIFY_CHECKSUM;
- mbs.param[1] = isp->isp_mdvec->dv_codeorg;
- isp_mboxcmd(isp, &mbs);
+ mbs.param[1] = ISP_CODE_ORG;
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- isp_dumpregs(isp, "ram checksum failure");
+ isp_prt(isp, ISP_LOGERR, "Ram Checksum Failure");
return;
}
} else {
- IDPRINTF(3, ("%s: skipping f/w download\n", isp->isp_name));
+ isp_prt(isp, ISP_LOGDEBUG2, "skipping f/w download");
}
/*
@@ -571,13 +607,10 @@ again:
*/
mbs.param[0] = MBOX_EXEC_FIRMWARE;
- if (isp->isp_mdvec->dv_codeorg)
- mbs.param[1] = isp->isp_mdvec->dv_codeorg;
- else
- mbs.param[1] = 0x1000;
- isp_mboxcmd(isp, &mbs);
+ mbs.param[1] = ISP_CODE_ORG;
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
/* give it a chance to start */
- SYS_DELAY(500);
+ USEC_DELAY(500);
if (IS_SCSI(isp)) {
/*
@@ -586,26 +619,24 @@ again:
if (isp->isp_clock) {
mbs.param[0] = MBOX_SET_CLOCK_RATE;
mbs.param[1] = isp->isp_clock;
- isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("failed to set clockrate (0x%x)\n",
- mbs.param[0]);
- /* but continue */
- }
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
+ /* we will try not to care if this fails */
}
}
+
mbs.param[0] = MBOX_ABOUT_FIRMWARE;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("could not get f/w started (0x%x)\n", mbs.param[0]);
return;
}
- CFGPRINTF("%s: Board Revision %s, %s F/W Revision %d.%d.%d\n",
- isp->isp_name, revname, dodnld? "loaded" : "resident",
- mbs.param[1], mbs.param[2], mbs.param[3]);
+ isp_prt(isp, ISP_LOGCONFIG,
+ "Board Revision %s, %s F/W Revision %d.%d.%d", revname,
+ dodnld? "loaded" : "resident", mbs.param[1], mbs.param[2],
+ mbs.param[3]);
if (IS_FC(isp)) {
if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) {
- CFGPRINTF("%s: in 64-Bit PCI slot\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGCONFIG,
+ "Installed in 64-Bit PCI slot");
}
}
@@ -614,27 +645,26 @@ again:
isp->isp_fwrev[2] = mbs.param[3];
if (isp->isp_romfw_rev[0] || isp->isp_romfw_rev[1] ||
isp->isp_romfw_rev[2]) {
- CFGPRINTF("%s: Last F/W revision was %d.%d.%d\n", isp->isp_name,
+ isp_prt(isp, ISP_LOGCONFIG, "Last F/W revision was %d.%d.%d",
isp->isp_romfw_rev[0], isp->isp_romfw_rev[1],
isp->isp_romfw_rev[2]);
}
mbs.param[0] = MBOX_GET_FIRMWARE_STATUS;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: could not GET FIRMWARE STATUS\n", isp->isp_name);
return;
}
isp->isp_maxcmds = mbs.param[2];
- CFGPRINTF("%s: %d max I/O commands supported\n",
- isp->isp_name, mbs.param[2]);
+ isp_prt(isp, ISP_LOGINFO,
+ "%d max I/O commands supported", mbs.param[2]);
isp_fw_state(isp);
/*
* Set up DMA for the request and result mailboxes.
*/
if (ISP_MBOXDMASETUP(isp) != 0) {
- PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "Cannot setup DMA");
return;
}
isp->isp_state = ISP_RESETSTATE;
@@ -671,9 +701,7 @@ again:
if (IS_SCSI(isp)) {
isp->isp_maxluns = 8;
} else {
- PRINTF("%s: WARNING- cannot determine Expanded "
- "LUN capability- limiting to one LUN\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGALL, warnlun);
isp->isp_maxluns = 1;
}
}
@@ -697,7 +725,6 @@ isp_init(isp)
if (IS_DUALBUS(isp)) {
isp_setdfltparm(isp, 1);
}
-
if (IS_FC(isp)) {
isp_fibre_init(isp);
} else {
@@ -737,10 +764,8 @@ isp_scsi_init(isp)
mbs.param[6] = sdp_chan1->isp_retry_count;
mbs.param[7] = sdp_chan1->isp_retry_delay;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set retry count and retry delay\n",
- isp->isp_name);
return;
}
@@ -750,10 +775,8 @@ isp_scsi_init(isp)
mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME;
mbs.param[1] = sdp_chan0->isp_async_data_setup;
mbs.param[2] = sdp_chan1->isp_async_data_setup;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set asynchronous data setup time\n",
- isp->isp_name);
return;
}
@@ -768,10 +791,10 @@ isp_scsi_init(isp)
(sdp_chan1->isp_req_ack_active_neg << 4) |
(sdp_chan1->isp_data_line_active_neg << 5);
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set active negation state "
- "(%d,%d),(%d,%d)\n", isp->isp_name,
+ isp_prt(isp, ISP_LOGERR,
+ "failed to set active negation state (%d,%d), (%d,%d)",
sdp_chan0->isp_req_ack_active_neg,
sdp_chan0->isp_data_line_active_neg,
sdp_chan1->isp_req_ack_active_neg,
@@ -787,11 +810,10 @@ isp_scsi_init(isp)
mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT;
mbs.param[1] = sdp_chan0->isp_tag_aging;
mbs.param[2] = sdp_chan1->isp_tag_aging;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set tag age limit (%d,%d)\n",
- isp->isp_name, sdp_chan0->isp_tag_aging,
- sdp_chan1->isp_tag_aging);
+ isp_prt(isp, ISP_LOGERR, "failed to set tag age limit (%d,%d)",
+ sdp_chan0->isp_tag_aging, sdp_chan1->isp_tag_aging);
return;
}
@@ -801,9 +823,8 @@ isp_scsi_init(isp)
mbs.param[0] = MBOX_SET_SELECT_TIMEOUT;
mbs.param[1] = sdp_chan0->isp_selection_timeout;
mbs.param[2] = sdp_chan1->isp_selection_timeout;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set selection timeout\n", isp->isp_name);
return;
}
@@ -817,27 +838,25 @@ isp_scsi_init(isp)
*/
mbs.param[0] = MBOX_INIT_RES_QUEUE;
- mbs.param[1] = RESULT_QUEUE_LEN;
+ mbs.param[1] = RESULT_QUEUE_LEN(isp);
mbs.param[2] = DMA_MSW(isp->isp_result_dma);
mbs.param[3] = DMA_LSW(isp->isp_result_dma);
mbs.param[4] = 0;
mbs.param[5] = 0;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: set of response queue failed\n", isp->isp_name);
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] = DMA_MSW(isp->isp_rquest_dma);
mbs.param[3] = DMA_LSW(isp->isp_rquest_dma);
mbs.param[4] = 0;
mbs.param[5] = 0;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: set of request queue failed\n", isp->isp_name);
return;
}
isp->isp_reqidx = isp->isp_reqodx = 0;
@@ -859,13 +878,10 @@ isp_scsi_init(isp)
mbs.param[1] |= FW_FEATURE_FAST_POST;
if (mbs.param[1] != 0) {
u_int16_t sfeat = mbs.param[1];
- isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: cannot enable FW features (0x%x)\n",
- isp->isp_name, sfeat);
- } else {
- CFGPRINTF("%s: enabled FW features (0x%x)\n",
- isp->isp_name, sfeat);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
+ if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
+ isp_prt(isp, ISP_LOGINFO,
+ "Enabled FW features (0x%x)", sfeat);
}
}
@@ -892,10 +908,8 @@ isp_scsi_channel_init(isp, channel)
*/
mbs.param[0] = MBOX_SET_INIT_SCSI_ID;
mbs.param[1] = (channel << 7) | sdp->isp_initiator_id;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: cannot set initiator id on bus %d to %d\n",
- isp->isp_name, channel, sdp->isp_initiator_id);
return;
}
@@ -907,8 +921,6 @@ isp_scsi_channel_init(isp, channel)
u_int16_t sdf;
if (sdp->isp_devparam[tgt].dev_enable == 0) {
- IDPRINTF(2, ("%s: skipping target %d bus %d settings\n",
- isp->isp_name, tgt, channel));
continue;
}
@@ -939,7 +951,7 @@ isp_scsi_channel_init(isp, channel)
mbs.param[3] =
(sdp->isp_devparam[tgt].sync_offset << 8) |
(sdp->isp_devparam[tgt].sync_period);
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
sdf = DPARM_SAFE_DFLT;
mbs.param[0] = MBOX_SET_TARGET_PARAMS;
@@ -948,10 +960,8 @@ isp_scsi_channel_init(isp, channel)
mbs.param[3] =
(sdp->isp_devparam[tgt].sync_offset << 8) |
(sdp->isp_devparam[tgt].sync_period);
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed even to set defaults for "
- "target %d\n", isp->isp_name, tgt);
continue;
}
}
@@ -964,7 +974,7 @@ isp_scsi_channel_init(isp, channel)
*/
mbs.param[0] = MBOX_GET_TARGET_PARAMS;
mbs.param[1] = (tgt << 8) | (channel << 15);
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
/*
* Urrr.... We'll set cur_dflags to DPARM_SAFE_DFLT so
@@ -976,8 +986,9 @@ isp_scsi_channel_init(isp, channel)
sdp->isp_devparam[tgt].cur_offset = mbs.param[3] >> 8;
sdp->isp_devparam[tgt].cur_period = mbs.param[3] & 0xff;
}
- IDPRINTF(3, ("%s: set flags 0x%x got 0x%x back for target %d\n",
- isp->isp_name, sdf, mbs.param[2], tgt));
+ isp_prt(isp, ISP_LOGTDEBUG0,
+ "set flags 0x%x got 0x%x back for target %d",
+ sdf, mbs.param[2], tgt);
#else
/*
@@ -993,16 +1004,13 @@ isp_scsi_channel_init(isp, channel)
* seen yet.
*/
sdp->isp_devparam[tgt].cur_dflags &= ~DPARM_TQING;
- for (lun = 0; lun < isp->isp_maxluns; lun++) {
+ for (lun = 0; lun < (int) isp->isp_maxluns; lun++) {
mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS;
mbs.param[1] = (channel << 15) | (tgt << 8) | lun;
mbs.param[2] = sdp->isp_max_queue_depth;
mbs.param[3] = sdp->isp_devparam[tgt].exc_throttle;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to set device queue "
- "parameters for target %d, lun %d\n",
- isp->isp_name, tgt, lun);
break;
}
}
@@ -1025,20 +1033,7 @@ isp_fibre_init(isp)
fcp = isp->isp_param;
- /*
- * For systems that don't have BIOS methods for which
- * we can easily change the NVRAM based loopid, we'll
- * override that here. Note that when we initialize
- * the firmware we may get back a different loopid than
- * we asked for anyway. XXX This is probably not the
- * best way to figure this out XXX
- */
-#ifndef __i386__
loopid = DEFAULT_LOOPID(isp);
-#else
- loopid = fcp->isp_loopid;
-#endif
-
icbp = (isp_icb_t *) fcp->isp_scratch;
MEMZERO(icbp, sizeof (*icbp));
@@ -1080,20 +1075,22 @@ isp_fibre_init(isp)
icbp->icb_maxfrmlen = fcp->isp_maxfrmlen;
if (icbp->icb_maxfrmlen < ICB_MIN_FRMLEN ||
icbp->icb_maxfrmlen > ICB_MAX_FRMLEN) {
- PRINTF("%s: bad frame length (%d) from NVRAM- using %d\n",
- isp->isp_name, fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
+ isp_prt(isp, ISP_LOGERR,
+ "bad frame length (%d) from NVRAM- using %d",
+ fcp->isp_maxfrmlen, ICB_DFLT_FRMLEN);
icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN;
}
icbp->icb_maxalloc = fcp->isp_maxalloc;
if (icbp->icb_maxalloc < 1) {
- PRINTF("%s: bad maximum allocation (%d)- using 16\n",
- isp->isp_name, fcp->isp_maxalloc);
+ isp_prt(isp, ISP_LOGERR,
+ "bad maximum allocation (%d)- using 16", fcp->isp_maxalloc);
icbp->icb_maxalloc = 16;
}
icbp->icb_execthrottle = fcp->isp_execthrottle;
if (icbp->icb_execthrottle < 1) {
- PRINTF("%s: bad execution throttle of %d- using 16\n",
- isp->isp_name, fcp->isp_execthrottle);
+ isp_prt(isp, ISP_LOGERR,
+ "bad execution throttle of %d- using 16",
+ fcp->isp_execthrottle);
icbp->icb_execthrottle = ICB_DFLT_THROTTLE;
}
icbp->icb_retry_delay = fcp->isp_retry_delay;
@@ -1119,8 +1116,8 @@ isp_fibre_init(isp)
} else {
fcp->isp_fwoptions &= ~(ICBOPT_USE_PORTNAME|ICBOPT_FULL_LOGIN);
}
- icbp->icb_rqstqlen = RQUEST_QUEUE_LEN;
- icbp->icb_rsltqlen = RESULT_QUEUE_LEN;
+ icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp);
+ icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp);
icbp->icb_rqstaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_rquest_dma);
icbp->icb_rqstaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_rquest_dma);
icbp->icb_respaddr[RQRSP_ADDR0015] = DMA_LSW(isp->isp_result_dma);
@@ -1134,29 +1131,18 @@ isp_fibre_init(isp)
fcp->isp_fwstate = FW_CONFIG_WAIT;
fcp->isp_loopstate = LOOP_NIL;
- MemoryBarrier();
- for (;;) {
- mbs.param[0] = MBOX_INIT_FIRMWARE;
- mbs.param[1] = 0;
- mbs.param[2] = DMA_MSW(fcp->isp_scdma);
- mbs.param[3] = DMA_LSW(fcp->isp_scdma);
- 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) {
- PRINTF("%s: INIT FIRMWARE failed (code 0x%x)\n",
- isp->isp_name, mbs.param[0]);
- if (mbs.param[0] & 0x8000) {
- SYS_DELAY(1000);
- continue;
- }
- return;
- }
- break;
+ mbs.param[0] = MBOX_INIT_FIRMWARE;
+ mbs.param[1] = 0;
+ mbs.param[2] = DMA_MSW(fcp->isp_scdma);
+ mbs.param[3] = DMA_LSW(fcp->isp_scdma);
+ mbs.param[4] = 0;
+ mbs.param[5] = 0;
+ mbs.param[6] = 0;
+ mbs.param[7] = 0;
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
+ if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
+ return;
}
-
isp->isp_reqidx = isp->isp_reqodx = 0;
isp->isp_residx = 0;
isp->isp_sendmarker = 1;
@@ -1207,26 +1193,12 @@ isp_getpdb(isp, id, pdbp)
*/
mbs.param[6] = 0;
mbs.param[7] = 0;
- isp_mboxcmd(isp, &mbs);
- switch (mbs.param[0]) {
- case MBOX_COMMAND_COMPLETE:
- MemoryBarrier();
+ isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
+ if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
ISP_UNSWIZZLE_AND_COPY_PDBP(isp, pdbp, fcp->isp_scratch);
- break;
- case MBOX_HOST_INTERFACE_ERROR:
- PRINTF("%s: DMA error getting port database\n", isp->isp_name);
- return (-1);
- case MBOX_COMMAND_PARAM_ERROR:
- /* Not Logged In */
- IDPRINTF(3, ("%s: Param Error on Get Port Database for id %d\n",
- isp->isp_name, id));
- return (-1);
- default:
- PRINTF("%s: error 0x%x getting port database for ID %d\n",
- isp->isp_name, mbs.param[0], id);
- return (-1);
+ return (0);
}
- return (0);
+ return (-1);
}
static u_int64_t
@@ -1242,7 +1214,7 @@ isp_get_portname(isp, loopid, nodename)
mbs.param[1] = loopid << 8;
if (nodename)
mbs.param[1] |= 1;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_PARAM_ERROR);
if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
wwn =
(((u_int64_t)(mbs.param[2] & 0xff)) << 56) |
@@ -1262,9 +1234,9 @@ isp_get_portname(isp, loopid, nodename)
*/
static int
-isp_fclink_test(isp, waitdelay)
+isp_fclink_test(isp, usdelay)
struct ispsoftc *isp;
- int waitdelay;
+ int usdelay;
{
static char *toponames[] = {
"Private Loop",
@@ -1283,21 +1255,68 @@ isp_fclink_test(isp, waitdelay)
fcp = isp->isp_param;
/*
+ * XXX: Here is where we would start a 'loop dead' timeout
+ */
+
+ /*
* Wait up to N microseconds for F/W to go to a ready state.
*/
lwfs = FW_CONFIG_WAIT;
- for (count = 0; count < waitdelay; count += 100) {
+ count = 0;
+ while (count < usdelay) {
+ u_int64_t enano;
+ u_int32_t wrk;
+ NANOTIME_T hra, hrb;
+
+ GET_NANOTIME(&hra);
isp_fw_state(isp);
if (lwfs != fcp->isp_fwstate) {
- PRINTF("%s: Firmware State %s -> %s\n",
- isp->isp_name, isp2100_fw_statename((int)lwfs),
+ isp_prt(isp, ISP_LOGINFO, "Firmware State <%s->%s>",
+ isp2100_fw_statename((int)lwfs),
isp2100_fw_statename((int)fcp->isp_fwstate));
lwfs = fcp->isp_fwstate;
}
if (fcp->isp_fwstate == FW_READY) {
break;
}
- SYS_DELAY(100); /* wait 100 microseconds */
+ GET_NANOTIME(&hrb);
+
+ /*
+ * Get the elapsed time in nanoseconds.
+ * Always guaranteed to be non-zero.
+ */
+ enano = NANOTIME_SUB(&hrb, &hra);
+
+ /*
+ * If the elapsed time is less than 1 millisecond,
+ * delay a period of time up to that millisecond of
+ * waiting.
+ */
+ isp_prt(isp, ISP_LOGDEBUG3, "usec%d: 0x%lx->0x%lx enano %u",
+ count, GET_NANOSEC(&hra), GET_NANOSEC(&hrb), enano);
+
+ /*
+ * This peculiar code is an attempt to try and avoid
+ * invoking u_int64_t math support functions for some
+ * platforms where linkage is a problem.
+ */
+ if (enano < (1000 * 1000)) {
+ count += 1000;
+ enano = (1000 * 1000) - enano;
+ while (enano > (u_int64_t) 4000000000U) {
+ USEC_DELAY(4000000);
+ enano -= (u_int64_t) 4000000000U;
+ }
+ wrk = enano;
+ USEC_DELAY(wrk/1000);
+ } else {
+ while (enano > (u_int64_t) 4000000000U) {
+ count += 4000000;
+ enano -= (u_int64_t) 4000000000U;
+ }
+ wrk = enano;
+ count += (wrk / 1000);
+ }
}
/*
@@ -1311,9 +1330,8 @@ isp_fclink_test(isp, waitdelay)
* Get our Loop ID (if possible). We really need to have it.
*/
mbs.param[0] = MBOX_GET_LOOP_ID;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: GET LOOP ID failed\n", isp->isp_name);
return (-1);
}
fcp->isp_loopid = mbs.param[1];
@@ -1381,17 +1399,28 @@ isp_fclink_test(isp, waitdelay)
fcp->portdb[FL_PORT_ID].valid = 0;
}
- CFGPRINTF("%s: Loop ID %d, AL_PA 0x%x, Port ID 0x%x Loop State "
- "0x%x topology '%s'\n", isp->isp_name, fcp->isp_loopid,
- fcp->isp_alpa, fcp->isp_portid, fcp->isp_loopstate,
- toponames[fcp->isp_topo]);
+ isp_prt(isp, ISP_LOGINFO, topology, fcp->isp_loopid, fcp->isp_alpa,
+ fcp->isp_portid, fcp->isp_loopstate, toponames[fcp->isp_topo]);
return (0);
}
-/*
- * Compare two local port db entities and return 1 if they're the same, else 0.
- */
+static char *
+isp2100_fw_statename(state)
+ int state;
+{
+ switch(state) {
+ case FW_CONFIG_WAIT: return "Config Wait";
+ case FW_WAIT_AL_PA: return "Waiting for AL_PA";
+ case FW_WAIT_LOGIN: return "Wait Login";
+ case FW_READY: return "Ready";
+ case FW_LOSS_OF_SYNC: return "Loss Of Sync";
+ case FW_ERROR: return "Error";
+ case FW_REINIT: return "Re-Init";
+ case FW_NON_PART: return "Nonparticipating";
+ default: return "?????";
+ }
+}
static int
isp_same_lportdb(a, b)
@@ -1502,8 +1531,8 @@ isp_pdb_sync(isp, target)
if (lim++ < FL_PORT_ID) {
continue;
}
- PRINTF("%s: giving up on synchronizing the port "
- "database\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN,
+ "giving up on synchronizing the port database");
return (-1);
}
@@ -1607,9 +1636,8 @@ isp_pdb_sync(isp, target)
* just change the actual loop ID we'd use.
*/
if (fcp->portdb[i].loopid != loopid) {
- PRINTF("%s: Target ID %d Loop 0x%x (Port 0x%x) "
- "=> Loop 0x%x (Port 0x%x) \n",
- isp->isp_name, i, fcp->portdb[i].loopid,
+ isp_prt(isp, ISP_LOGINFO, portshift, i,
+ fcp->portdb[i].loopid,
fcp->portdb[i].portid, loopid,
tport[loopid].portid);
}
@@ -1627,9 +1655,7 @@ isp_pdb_sync(isp, target)
fcp->portdb[j].port_wwn) {
continue;
}
- PRINTF("%s: Target ID %d Duplicates Target ID "
- "%d- killing off both\n",
- isp->isp_name, j, i);
+ isp_prt(isp, ISP_LOGWARN, portdup, j, i);
/*
* Invalidate the 'old' *and* 'new' ones.
* This is really harsh and not quite right,
@@ -1662,7 +1688,7 @@ isp_pdb_sync(isp, target)
}
/* "Cannot Happen" */
if (lim == FL_PORT_ID) {
- PRINTF("%s: remap overflow?\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN, "Remap Overflow");
continue;
}
i = lim;
@@ -1758,10 +1784,9 @@ isp_pdb_sync(isp, target)
nwwnn == lp->node_wwn && nwwpn == lp->port_wwn &&
lp->roles == nrole) {
lp->loggedin = lp->valid = 1;
- IDPRINTF(1, ("%s: retained login of Target %d "
- "(Loop 0x%x) Port ID 0x%x\n",
- isp->isp_name, (int) (lp - fcp->portdb),
- (int) lp->loopid, lp->portid));
+ isp_prt(isp, ISP_LOGINFO, lretained,
+ (int) (lp - fcp->portdb),
+ (int) lp->loopid, lp->portid);
continue;
}
}
@@ -1774,11 +1799,10 @@ isp_pdb_sync(isp, target)
mbs.param[1] = lp->loopid << 8;
mbs.param[2] = 0;
mbs.param[3] = 0;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
lp->loggedin = 0;
- IDPRINTF(1, ("%s: Logging out target %d at Loop ID %d "
- "(port id 0x%x)\n", isp->isp_name,
- (int) (lp - fcp->portdb), lp->loopid, lp->portid));
+ isp_prt(isp, ISP_LOGINFO, plogout,
+ (int) (lp - fcp->portdb), lp->loopid, lp->portid);
}
/*
@@ -1795,7 +1819,8 @@ isp_pdb_sync(isp, target)
/* only issue a PLOGI if not logged in */
mbs.param[1] |= 0x1;
}
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL & ~(MBOX_LOOP_ID_USED |
+ MBOX_PORT_ID_USED | MBOX_COMMAND_ERROR));
switch (mbs.param[0]) {
case MBOX_LOOP_ID_USED:
/*
@@ -1811,11 +1836,9 @@ isp_pdb_sync(isp, target)
*/
if (mbs.param[1] != 0) {
loopid = mbs.param[1];
- IDPRINTF(1, ("%s: Retaining loopid 0x%x"
- " for Target %d (port id 0x%x)\n",
- isp->isp_name, loopid,
- (int) (lp - fcp->portdb),
- lp->portid));
+ isp_prt(isp, ISP_LOGINFO, retained,
+ loopid, (int) (lp - fcp->portdb),
+ lp->portid);
} else {
loopid = MAX_FC_TARG;
break;
@@ -1826,9 +1849,8 @@ isp_pdb_sync(isp, target)
lp->loopid = loopid;
break;
case MBOX_COMMAND_ERROR:
- PRINTF("%s: command error in PLOGI for port "
- " 0x%x (0x%x)\n", isp->isp_name, portid,
- mbs.param[1]);
+ isp_prt(isp, ISP_LOGINFO, plogierr,
+ portid, mbs.param[1]);
/* FALLTHROUGH */
case MBOX_ALL_IDS_USED: /* We're outta IDs */
default:
@@ -1850,22 +1872,19 @@ isp_pdb_sync(isp, target)
* Make sure we can get the approriate port information.
*/
if (isp_getpdb(isp, lp->loopid, &pdb) != 0) {
- PRINTF("%s: could not get PDB for device@port 0x%x\n",
- isp->isp_name, lp->portid);
+ isp_prt(isp, ISP_LOGWARN, nopdb, lp->portid);
goto dump_em;
}
if (pdb.pdb_loopid != lp->loopid) {
- PRINTF("%s: PDB loopid info for device@port 0x%x does "
- "not match up (0x%x)\n", isp->isp_name, lp->portid,
- pdb.pdb_loopid);
+ isp_prt(isp, ISP_LOGWARN, pdbmfail1,
+ lp->portid, pdb.pdb_loopid);
goto dump_em;
}
if (lp->portid != (u_int32_t) BITS2WORD(pdb.pdb_portid_bits)) {
- PRINTF("%s: PDB port info for device@port 0x%x does "
- "not match up (0x%x)\n", isp->isp_name, lp->portid,
- BITS2WORD(pdb.pdb_portid_bits));
+ isp_prt(isp, ISP_LOGWARN, pdbmfail2,
+ lp->portid, BITS2WORD(pdb.pdb_portid_bits));
goto dump_em;
}
@@ -1900,19 +1919,19 @@ isp_pdb_sync(isp, target)
}
dump_em:
lp->valid = 0;
- PRINTF("%s: Target %d (Loop 0x%x) Port ID 0x%x dumped after "
- "login\n", isp->isp_name, loopid, lp->loopid, lp->portid);
+ isp_prt(isp, ISP_LOGINFO,
+ ldumped, loopid, lp->loopid, lp->portid);
mbs.param[0] = MBOX_FABRIC_LOGOUT;
mbs.param[1] = lp->loopid << 8;
mbs.param[2] = 0;
mbs.param[3] = 0;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGNONE);
}
#endif
/*
* If we get here, we've for sure seen not only a valid loop
* but know what is or isn't on it, so mark this for usage
- * in ispscsicmd.
+ * in isp_start.
*/
fcp->loop_seen_once = 1;
return (0);
@@ -1952,11 +1971,8 @@ isp_scan_fabric(isp)
mbs.param[3] = DMA_LSW(fcp->isp_scdma);
mbs.param[6] = 0;
mbs.param[7] = 0;
- MemoryBarrier();
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- IDPRINTF(1, ("%s: SNS failed (0x%x)\n", isp->isp_name,
- mbs.param[0]));
return (-1);
}
ISP_UNSWIZZLE_SNS_RSP(isp, resp, SNS_GAN_RESP_SIZE >> 1);
@@ -1983,9 +1999,9 @@ isp_scan_fabric(isp)
* Start a command. Locking is assumed done in the caller.
*/
-int32_t
-ispscsicmd(xs)
- ISP_SCSI_XFER_T *xs;
+int
+isp_start(xs)
+ XS_T *xs;
{
struct ispsoftc *isp;
u_int16_t iptr, optr;
@@ -2002,7 +2018,7 @@ ispscsicmd(xs)
isp = XS_ISP(xs);
if (isp->isp_state != ISP_RUNSTATE) {
- PRINTF("%s: adapter not ready\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "Adapter not at RUNSTATE");
XS_SETERR(xs, HBA_BOTCH);
return (CMD_COMPLETE);
}
@@ -2015,8 +2031,9 @@ ispscsicmd(xs)
*/
if (XS_CDBLEN(xs) > (IS_FC(isp)? 16 : 44) || XS_CDBLEN(xs) == 0) {
- PRINTF("%s: unsupported cdb length (%d, CDB[0]=0x%x)\n",
- isp->isp_name, XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
+ isp_prt(isp, ISP_LOGERR,
+ "unsupported cdb length (%d, CDB[0]=0x%x)",
+ XS_CDBLEN(xs), XS_CDBP(xs)[0] & 0xff);
XS_SETERR(xs, HBA_BOTCH);
return (CMD_COMPLETE);
}
@@ -2066,7 +2083,10 @@ ispscsicmd(xs)
* until later.
*/
if (fcp->isp_fwstate != FW_READY) {
- if (isp_fclink_test(isp, FC_FW_READY_DELAY)) {
+ /*
+ * Give ourselves at most a 250ms delay.
+ */
+ if (isp_fclink_test(isp, 250000)) {
XS_SETERR(xs, HBA_SELTIMEOUT);
if (fcp->loop_seen_once) {
return (CMD_RQLATER);
@@ -2107,6 +2127,11 @@ ispscsicmd(xs)
}
/*
+ * XXX: Here's were we would cancel any loop_dead flag
+ * XXX: also cancel in dead_loop timeout that's running
+ */
+
+ /*
* Now check whether we should even think about pursuing this.
*/
lp = &fcp->portdb[target];
@@ -2115,8 +2140,8 @@ ispscsicmd(xs)
return (CMD_COMPLETE);
}
if ((lp->roles & (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT)) == 0) {
- IDPRINTF(3, ("%s: target %d is not a target\n",
- isp->isp_name, target));
+ isp_prt(isp, ISP_LOGDEBUG2,
+ "Target %d does not have target service", target);
XS_SETERR(xs, HBA_SELTIMEOUT);
return (CMD_COMPLETE);
}
@@ -2135,7 +2160,7 @@ ispscsicmd(xs)
}
if (isp_getrqentry(isp, &iptr, &optr, (void **) &reqp)) {
- IDPRINTF(2, ("%s: Request Queue Overflow\n", isp->isp_name));
+ isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
@@ -2160,12 +2185,11 @@ ispscsicmd(xs)
reqp->req_modifier = SYNC_ALL;
reqp->req_target = i << 7; /* insert bus number */
ISP_SWIZZLE_REQUEST(isp, reqp);
- MemoryBarrier();
ISP_ADD_REQUEST(isp, iptr);
if (isp_getrqentry(isp, &iptr, &optr, (void **)&reqp)) {
- IDPRINTF(2, ("%s: Request Queue Overflow+\n",
- isp->isp_name));
+ isp_prt(isp, ISP_LOGDEBUG0,
+ "Request Queue Overflow+");
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
@@ -2195,8 +2219,8 @@ ispscsicmd(xs)
* The Qlogic drivers seem be happy not to use a tag,
* but this breaks for some devices (IBM drives).
*/
- if (XS_CANTAG(xs)) {
- t2reqp->req_flags = XS_KINDOF_TAG(xs);
+ if (XS_TAG_P(xs)) {
+ t2reqp->req_flags = XS_TAG_TYPE(xs);
} else {
if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */
t2reqp->req_flags = REQFLAG_HTAG;
@@ -2206,8 +2230,8 @@ ispscsicmd(xs)
} else {
sdparam *sdp = (sdparam *)isp->isp_param;
if ((sdp->isp_devparam[target].cur_dflags & DPARM_TQING) &&
- XS_CANTAG(xs)) {
- reqp->req_flags = XS_KINDOF_TAG(xs);
+ XS_TAG_P(xs)) {
+ reqp->req_flags = XS_TAG_TYPE(xs);
}
}
reqp->req_target = target | (XS_CHANNEL(xs) << 7);
@@ -2234,7 +2258,7 @@ ispscsicmd(xs)
reqp->req_time = 5;
}
if (isp_save_xs(isp, xs, &reqp->req_handle)) {
- IDPRINTF(2, ("%s: out of xflist pointers\n", isp->isp_name));
+ isp_prt(isp, ISP_LOGDEBUG1, "out of xflist pointers");
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
@@ -2252,10 +2276,9 @@ ispscsicmd(xs)
return (i);
}
XS_SETERR(xs, HBA_NOERROR);
- IDPRINTF(5, ("%s(%d.%d.%d): START cmd 0x%x datalen %d\n",
- isp->isp_name, XS_CHANNEL(xs), target, XS_LUN(xs),
- reqp->req_cdb[0], XS_XFRLEN(xs)));
- MemoryBarrier();
+ isp_prt(isp, ISP_LOGDEBUG2,
+ "START cmd for %d.%d.%d cmd 0x%x datalen %d",
+ XS_CHANNEL(xs), target, XS_LUN(xs), XS_CDBP(xs)[0], XS_XFRLEN(xs));
ISP_ADD_REQUEST(isp, iptr);
isp->isp_nactive++;
if (isp->isp_sendmarker)
@@ -2276,15 +2299,14 @@ isp_control(isp, ctl, arg)
ispctl_t ctl;
void *arg;
{
- ISP_SCSI_XFER_T *xs;
+ XS_T *xs;
mbreg_t mbs;
int bus, tgt;
u_int32_t handle;
switch (ctl) {
default:
- PRINTF("%s: isp_control unknown control op %x\n",
- isp->isp_name, ctl);
+ isp_prt(isp, ISP_LOGERR, "Unknown Control Opcode 0x%x", ctl);
break;
case ISPCTL_RESET_BUS:
@@ -2306,13 +2328,12 @@ isp_control(isp, ctl, arg)
bus = 0;
}
isp->isp_sendmarker |= (1 << bus);
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- isp_dumpregs(isp, "isp_control SCSI bus reset failed");
break;
}
- CFGPRINTF("%s: driver initiated bus reset of bus %d\n",
- isp->isp_name, bus);
+ isp_prt(isp, ISP_LOGINFO,
+ "driver initiated bus reset of bus %d", bus);
return (0);
case ISPCTL_RESET_DEV:
@@ -2321,24 +2342,22 @@ isp_control(isp, ctl, arg)
mbs.param[0] = MBOX_ABORT_TARGET;
mbs.param[1] = (tgt << 8) | (bus << 15);
mbs.param[2] = 3; /* 'delay', in seconds */
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: isp_control MBOX_RESET_DEV failure (code "
- "%x)\n", isp->isp_name, mbs.param[0]);
break;
}
- PRINTF("%s: Target %d on Bus %d Reset Succeeded\n",
- isp->isp_name, tgt, bus);
+ isp_prt(isp, ISP_LOGINFO,
+ "Target %d on Bus %d Reset Succeeded", tgt, bus);
isp->isp_sendmarker |= (1 << bus);
return (0);
case ISPCTL_ABORT_CMD:
- xs = (ISP_SCSI_XFER_T *) arg;
+ xs = (XS_T *) arg;
tgt = XS_TGT(xs);
handle = isp_find_handle(isp, xs);
if (handle == 0) {
- PRINTF("%s: isp_control- cannot find command to abort "
- "in active list\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN,
+ "cannot find handle for command to abort");
break;
}
bus = XS_CHANNEL(xs);
@@ -2358,21 +2377,11 @@ isp_control(isp, ctl, arg)
}
mbs.param[3] = handle >> 16;
mbs.param[2] = handle & 0xffff;
- isp_mboxcmd(isp, &mbs);
- switch (mbs.param[0]) {
- case MBOX_COMMAND_COMPLETE:
- IDPRINTF(1,
- ("%s: command (handle 0x%x) for %d.%d.%d aborted\n",
- isp->isp_name, handle, bus, tgt, XS_LUN(xs)));
- /* FALLTHROUGH */
- case MBOX_COMMAND_ERROR:
- break;
- default:
- PRINTF("%s: command (handle 0x%x) abort failed (%x)\n",
- isp->isp_name, handle, mbs.param[0]);
- break;
+ isp_mboxcmd(isp, &mbs, MBLOGALL & ~MBOX_COMMAND_ERROR);
+ if (mbs.param[0] == MBOX_COMMAND_COMPLETE) {
+ return (0);
}
- return (0);
+ break;
case ISPCTL_UPDATE_PARAMS:
isp_update(isp);
@@ -2380,7 +2389,8 @@ isp_control(isp, ctl, arg)
case ISPCTL_FCLINK_TEST:
if (IS_FC(isp)) {
- return (isp_fclink_test(isp, FC_FW_READY_DELAY));
+ int usdelay = (arg)? *((int *) arg) : 250000;
+ return (isp_fclink_test(isp, usdelay));
}
break;
@@ -2396,11 +2406,8 @@ isp_control(isp, ctl, arg)
int ena = *(int *)arg;
mbs.param[0] = MBOX_ENABLE_TARGET_MODE;
mbs.param[1] = (ena)? ENABLE_TARGET_FLAG : 0;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: cannot %sable target mode (0x%x)\n",
- isp->isp_name, ena? "en" : "dis",
- mbs.param[0]);
break;
}
}
@@ -2417,12 +2424,18 @@ isp_control(isp, ctl, arg)
* and the locking will be held throughout this function.
*/
+/*
+ * Limit our stack depth by sticking with the max likely number
+ * of completions on a request queue at any one time.
+ */
+#define MAX_REQUESTQ_COMPLETIONS 32
+
int
isp_intr(arg)
void *arg;
{
- ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs;
struct ispsoftc *isp = arg;
+ XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
u_int16_t iptr, optr, isr, sema, junk;
int i, nlooked = 0, ndone = 0;
@@ -2433,8 +2446,8 @@ isp_intr(arg)
junk = ISP_READ(isp, BIU_ISR);
} while (isr != junk && ++i < 1000);
if (isr != junk) {
- PRINTF("%s: isr unsteady (%x, %x)\n",
- isp->isp_name, isr, junk);
+ isp_prt(isp, ISP_LOGWARN,
+ "isr unsteady (%x, %x)", isr, junk);
}
i = 0;
do {
@@ -2442,14 +2455,14 @@ isp_intr(arg)
junk = ISP_READ(isp, BIU_SEMA);
} while (sema != junk && ++i < 1000);
if (sema != junk) {
- PRINTF("%s: sema unsteady (%x, %x)\n",
- isp->isp_name, sema, junk);
+ isp_prt(isp, ISP_LOGWARN,
+ "sema unsteady (%x, %x)", sema, junk);
}
} else {
isr = ISP_READ(isp, BIU_ISR);
sema = ISP_READ(isp, BIU_SEMA);
}
- IDPRINTF(5, ("%s: isp_intr isr %x sem %x\n", isp->isp_name, isr, sema));
+ isp_prt(isp, ISP_LOGDEBUG3, "isp_intr isr %x sem %x", isr, sema);
isr &= INT_PENDING_MASK(isp);
sema &= BIU_SEMA_LOCK;
if (isr == 0 && sema == 0) {
@@ -2466,8 +2479,8 @@ isp_intr(arg)
junk = ISP_READ(isp, OUTMAILBOX0);;
} while (junk != mbox && ++i < 1000);
if (mbox != junk) {
- PRINTF("%s: mailbox0 unsteady (%x, %x)\n",
- isp->isp_name, mbox, junk);
+ isp_prt(isp, ISP_LOGWARN,
+ "mailbox0 unsteady (%x, %x)", mbox, junk);
ISP_WRITE(isp, BIU_SEMA, 0);
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
return (1);
@@ -2488,13 +2501,13 @@ isp_intr(arg)
}
MBOX_NOTIFY_COMPLETE(isp);
} else {
- PRINTF("%s: Command Mbox 0x%x\n",
- isp->isp_name, mbox);
+ isp_prt(isp, ISP_LOGWARN,
+ "Mbox Command Async (0x%x) with no waiters",
+ mbox);
}
} else {
u_int32_t fhandle = isp_parse_async(isp, (int) mbox);
- IDPRINTF(4, ("%s: Async Mbox 0x%x\n",
- isp->isp_name, mbox));
+ isp_prt(isp, ISP_LOGDEBUG2, "Async Mbox 0x%x", mbox);
if (fhandle > 0) {
isp_fastpost_complete(isp, fhandle);
}
@@ -2510,8 +2523,8 @@ isp_intr(arg)
* We can't be getting this now.
*/
if (isp->isp_state != ISP_RUNSTATE) {
- PRINTF("%s: interrupt (isr=%x, sema=%x) when not ready\n",
- isp->isp_name, isr, sema);
+ isp_prt(isp, ISP_LOGWARN,
+ "interrupt (isr=%x, sema=%x) when not ready", isr, sema);
ISP_WRITE(isp, INMAILBOX5, ISP_READ(isp, OUTMAILBOX5));
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
ISP_WRITE(isp, BIU_SEMA, 0);
@@ -2532,8 +2545,8 @@ isp_intr(arg)
if (iptr != junk) {
ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
- PRINTF("%s: mailbox5 unsteady (%x, %x)\n",
- isp->isp_name, iptr, junk);
+ isp_prt(isp, ISP_LOGWARN,
+ "mailbox5 unsteady (%x, %x)", iptr, junk);
return (1);
}
} else {
@@ -2555,8 +2568,9 @@ isp_intr(arg)
* effects), but that didn't stop this from occurring.
*/
junk = ISP_READ(isp, BIU_ISR);
- IDPRINTF(2, ("%s: null intr- isr %x (%x) iptr %x optr %x\n",
- isp->isp_name, isr, junk, iptr, optr));
+ isp_prt(isp, ISP_LOGDEBUG2,
+ "bogus intr- isr %x (%x) iptr %x optr %x",
+ isr, junk, iptr, optr);
}
while (optr != iptr) {
@@ -2566,15 +2580,14 @@ isp_intr(arg)
sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
oop = optr;
- optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN);
+ optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
nlooked++;
- MemoryBarrier();
/*
* Do any appropriate unswizzling of what the Qlogic f/w has
* written into memory so it makes sense to us. This is a
- * per-platform thing.
+ * per-platform thing. Also includes any memory barriers.
*/
- ISP_UNSWIZZLE_RESPONSE(isp, sp);
+ ISP_UNSWIZZLE_RESPONSE(isp, sp, oop);
if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) {
if (isp_handle_other_response(isp, sp, &optr) == 0) {
continue;
@@ -2585,9 +2598,7 @@ isp_intr(arg)
* not, something bad has happened.
*/
if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) {
- PRINTF("%s: not RESPONSE in RESPONSE Queue "
- "(type 0x%x) @ idx %d (next %d)\n",
- isp->isp_name,
+ isp_prt(isp, ISP_LOGERR, notresp,
sp->req_header.rqs_entry_type, oop, optr);
continue;
}
@@ -2598,44 +2609,45 @@ isp_intr(arg)
#define _RQS_OFLAGS \
~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET)
if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
- IDPRINTF(4, ("%s: continuation segment\n",
- isp->isp_name));
+ isp_prt(isp, ISP_LOGWARN,
+ "continuation segment");
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
- IDPRINTF(2, ("%s: internal queues full\n",
- isp->isp_name));
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "internal queues full");
/*
* We'll synthesize a QUEUE FULL message below.
*/
}
if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
- PRINTF("%s: bad header\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "bad header flag");
buddaboom++;
}
if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
- PRINTF("%s: bad request packet\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "bad request packet");
buddaboom++;
}
if (sp->req_header.rqs_flags & _RQS_OFLAGS) {
- PRINTF("%s: unknown flags in response (0x%x)\n",
- isp->isp_name, sp->req_header.rqs_flags);
+ isp_prt(isp, ISP_LOGERR,
+ "unknown flags (0x%x) in response",
+ sp->req_header.rqs_flags);
buddaboom++;
}
#undef _RQS_OFLAGS
}
if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) {
- PRINTF("%s: bad request handle %d\n", isp->isp_name,
- sp->req_handle);
+ isp_prt(isp, ISP_LOGERR,
+ "bad request handle %d", sp->req_handle);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
xs = isp_find_xs(isp, sp->req_handle);
if (xs == NULL) {
- PRINTF("%s: NULL xs in xflist (handle 0x%x)\n",
- isp->isp_name, sp->req_handle);
+ isp_prt(isp, ISP_LOGERR,
+ "cannot find handle 0x%x in xflist",
+ sp->req_handle);
ISP_WRITE(isp, INMAILBOX5, optr);
continue;
}
@@ -2646,12 +2658,10 @@ isp_intr(arg)
if (buddaboom) {
XS_SETERR(xs, HBA_BOTCH);
}
- XS_STS(xs) = sp->req_scsi_status & 0xff;
+ *XS_STSP(xs) = sp->req_scsi_status & 0xff;
if (IS_SCSI(isp)) {
if (sp->req_state_flags & RQSF_GOT_SENSE) {
- MEMCPY(XS_SNSP(xs), sp->req_sense_data,
- XS_SNSLEN(xs));
- XS_SNS_IS_VALID(xs);
+ XS_SAVE_SENSE(xs, sp);
}
/*
* A new synchronous rate was negotiated for this
@@ -2666,72 +2676,72 @@ isp_intr(arg)
}
} else {
if (sp->req_scsi_status & RQCS_SV) {
- int amt = min(XS_SNSLEN(xs), sp->req_sense_len);
- MEMCPY(XS_SNSP(xs), sp->req_sense_data, amt);
- XS_SNS_IS_VALID(xs);
+ XS_SAVE_SENSE(xs, sp);
+ /* force that we 'got' sense */
sp->req_state_flags |= RQSF_GOT_SENSE;
- } else if (XS_STS(xs) == SCSI_CHECK) {
- IDPRINTF(2,
- ("%s: check condition with no sense data\n",
- isp->isp_name));
}
}
- 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)) {
- if (sp->req_completion_status != RQCS_COMPLETE) {
- isp_parse_status(isp, sp, xs);
- } else {
- XS_SETERR(xs, HBA_NOERROR);
- }
+ XS_SET_STATE_STAT(isp, xs, sp);
+ isp_parse_status(isp, sp, xs);
+ if ((XS_NOERR(xs) || XS_ERR(xs) == HBA_NOERROR) &&
+ (*XS_STSP(xs) == SCSI_BUSY)) {
+ XS_SETERR(xs, HBA_TGTBSY);
}
} else if (sp->req_header.rqs_entry_type == RQSTYPE_REQUEST) {
if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
/*
* Force Queue Full status.
*/
- XS_STS(xs) = SCSI_QFULL;
+ *XS_STSP(xs) = SCSI_QFULL;
XS_SETERR(xs, HBA_NOERROR);
} else if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BOTCH);
}
} else {
- PRINTF("%s: unhandled respose queue type 0x%x\n",
- isp->isp_name, sp->req_header.rqs_entry_type);
+ isp_prt(isp, ISP_LOGWARN,
+ "unhandled respose queue type 0x%x",
+ sp->req_header.rqs_entry_type);
if (XS_NOERR(xs)) {
XS_SETERR(xs, HBA_BOTCH);
}
}
if (IS_SCSI(isp)) {
XS_RESID(xs) = sp->req_resid;
- } else if (sp->req_scsi_status & RQCS_RU) {
+ } else if (sp->req_scsi_status & RQCS_RV) {
XS_RESID(xs) = sp->req_resid;
- IDPRINTF(4, ("%s: cnt %d rsd %d\n", isp->isp_name,
- XS_XFRLEN(xs), sp->req_resid));
+ isp_prt(isp, ISP_LOGDEBUG2, "cnt %d rsd %d",
+ XS_XFRLEN(xs), sp->req_resid);
}
if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, sp->req_handle);
}
- if ((isp->isp_dblev >= 5) ||
- (isp->isp_dblev > 2 && !XS_NOERR(xs))) {
- PRINTF("%s(%d.%d): FIN dl%d resid%d STS %x",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs),
- XS_XFRLEN(xs), XS_RESID(xs), XS_STS(xs));
+ if (((isp->isp_dblev & (ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
+ ((isp->isp_dblev & ISP_LOGDEBUG1) && !XS_NOERR(xs))) {
+ char skey;
if (sp->req_state_flags & RQSF_GOT_SENSE) {
- PRINTF(" Skey: %x", XS_SNSKEY(xs));
- if (!(XS_IS_SNS_VALID(xs))) {
- PRINTF(" BUT NOT SET");
- }
+ skey = XS_SNSKEY(xs) & 0xf;
+ if (skey < 10)
+ skey += '0';
+ else
+ skey += 'a';
+ } else if (*XS_STSP(xs) == SCSI_CHECK) {
+ skey = '?';
+ } else {
+ skey = '.';
}
- PRINTF(" XS_ERR=0x%x\n", (unsigned int) XS_ERR(xs));
+ isp_prt(isp, ISP_LOGALL, finmsg, XS_CHANNEL(xs),
+ XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs), XS_RESID(xs),
+ *XS_STSP(xs), skey, XS_ERR(xs));
}
if (isp->isp_nactive > 0)
isp->isp_nactive--;
complist[ndone++] = xs; /* defer completion call until later */
+ if (ndone == MAX_REQUESTQ_COMPLETIONS) {
+ break;
+ }
}
/*
@@ -2748,7 +2758,7 @@ isp_intr(arg)
for (i = 0; i < ndone; i++) {
xs = complist[i];
if (xs) {
- XS_CMD_DONE(xs);
+ isp_done(xs);
}
}
return (1);
@@ -2784,18 +2794,18 @@ isp_parse_async(isp, mbox)
break;
case ASYNC_SYSTEM_ERROR:
mbox = ISP_READ(isp, OUTMAILBOX1);
- PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n",
- isp->isp_name, mbox);
- isp_restart(isp);
+ isp_prt(isp, ISP_LOGERR,
+ "Internal FW Error @ RISC Addr 0x%x", mbox);
+ isp_reinit(isp);
/* no point continuing after this */
return (-1);
case ASYNC_RQS_XFER_ERR:
- PRINTF("%s: Request Queue Transfer Error\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "Request Queue Transfer Error");
break;
case ASYNC_RSP_XFER_ERR:
- PRINTF("%s: Response Queue Transfer Error\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "Response Queue Transfer Error");
break;
case ASYNC_QWAKEUP:
@@ -2808,8 +2818,8 @@ isp_parse_async(isp, mbox)
break;
case ASYNC_TIMEOUT_RESET:
- PRINTF("%s: timeout initiated SCSI bus reset of bus %d\n",
- isp->isp_name, bus);
+ isp_prt(isp, ISP_LOGWARN,
+ "timeout initiated SCSI bus reset of bus %d\n", bus);
isp->isp_sendmarker |= (1 << bus);
#ifdef ISP_TARGET_MODE
isp_target_async(isp, bus, mbox);
@@ -2817,7 +2827,7 @@ isp_parse_async(isp, mbox)
break;
case ASYNC_DEVICE_RESET:
- PRINTF("%s: device reset on bus %d\n", isp->isp_name, bus);
+ isp_prt(isp, ISP_LOGINFO, "device reset on bus %d", bus);
isp->isp_sendmarker |= (1 << bus);
#ifdef ISP_TARGET_MODE
isp_target_async(isp, bus, mbox);
@@ -2825,50 +2835,49 @@ isp_parse_async(isp, mbox)
break;
case ASYNC_EXTMSG_UNDERRUN:
- PRINTF("%s: extended message underrun\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN, "extended message underrun");
break;
case ASYNC_SCAM_INT:
- PRINTF("%s: SCAM interrupt\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "SCAM interrupt");
break;
case ASYNC_HUNG_SCSI:
- PRINTF("%s: stalled SCSI Bus after DATA Overrun\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGERR,
+ "stalled SCSI Bus after DATA Overrun");
/* XXX: Need to issue SCSI reset at this point */
break;
case ASYNC_KILLED_BUS:
- PRINTF("%s: SCSI Bus reset after DATA Overrun\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "SCSI Bus reset after DATA Overrun");
break;
case ASYNC_BUS_TRANSIT:
mbox = ISP_READ(isp, OUTMAILBOX2);
switch (mbox & 0x1c00) {
case SXP_PINS_LVD_MODE:
- PRINTF("%s: Transition to LVD mode\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "Transition to LVD mode");
((sdparam *)isp->isp_param)->isp_diffmode = 0;
((sdparam *)isp->isp_param)->isp_ultramode = 0;
((sdparam *)isp->isp_param)->isp_lvdmode = 1;
break;
case SXP_PINS_HVD_MODE:
- PRINTF("%s: Transition to Differential mode\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO,
+ "Transition to Differential mode");
((sdparam *)isp->isp_param)->isp_diffmode = 1;
((sdparam *)isp->isp_param)->isp_ultramode = 0;
((sdparam *)isp->isp_param)->isp_lvdmode = 0;
break;
case SXP_PINS_SE_MODE:
- PRINTF("%s: Transition to Single Ended mode\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO,
+ "Transition to Single Ended mode");
((sdparam *)isp->isp_param)->isp_diffmode = 0;
((sdparam *)isp->isp_param)->isp_ultramode = 1;
((sdparam *)isp->isp_param)->isp_lvdmode = 0;
break;
default:
- PRINTF("%s: Transition to unknown mode 0x%x\n",
- isp->isp_name, mbox);
+ isp_prt(isp, ISP_LOGWARN,
+ "Transition to Unknown Mode 0x%x", mbox);
break;
}
/*
@@ -2881,13 +2890,13 @@ isp_parse_async(isp, mbox)
case ASYNC_CMD_CMPLT:
fast_post_handle = (ISP_READ(isp, OUTMAILBOX2) << 16) |
ISP_READ(isp, OUTMAILBOX1);
- IDPRINTF(4, ("%s: fast post completion of %u\n", isp->isp_name,
- fast_post_handle));
+ isp_prt(isp, ISP_LOGDEBUG3, "fast post completion of %u",
+ fast_post_handle);
break;
case ASYNC_CTIO_DONE:
/* Should only occur when Fast Posting Set for 2100s */
- PRINTF("%s: CTIO done\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGDEBUG3, "Fast Posting CTIO done");
break;
case ASYNC_LIP_OCCURRED:
@@ -2897,7 +2906,7 @@ isp_parse_async(isp, mbox)
((fcparam *) isp->isp_param)->isp_loopstate = LOOP_LIP_RCVD;
isp->isp_sendmarker = 1;
isp_mark_getpdb_all(isp);
- IDPRINTF(1, ("%s: LIP occurred\n", isp->isp_name));
+ isp_prt(isp, ISP_LOGINFO, "LIP occurred");
#ifdef ISP_TARGET_MODE
isp_target_async(isp, bus, mbox);
#endif
@@ -2930,7 +2939,7 @@ isp_parse_async(isp, mbox)
((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT;
((fcparam *) isp->isp_param)->isp_loopstate = LOOP_NIL;
isp_mark_getpdb_all(isp);
- PRINTF("%s: Loop RESET\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "Loop RESET");
#ifdef ISP_TARGET_MODE
isp_target_async(isp, bus, mbox);
#endif
@@ -2940,7 +2949,7 @@ isp_parse_async(isp, mbox)
isp->isp_sendmarker = 1;
((fcparam *) isp->isp_param)->isp_loopstate = LOOP_PDB_RCVD;
isp_mark_getpdb_all(isp);
- IDPRINTF(1, ("%s: Port Database Changed\n", isp->isp_name));
+ isp_prt(isp, ISP_LOGINFO, "Port Database Changed");
break;
case ASYNC_CHANGE_NOTIFY:
@@ -2964,38 +2973,36 @@ isp_parse_async(isp, mbox)
#ifdef ISP_TARGET_MODE
isp_target_async(isp, bus, mbox);
#endif
- PRINTF("%s: Point-to-Point mode\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "Point-to-Point mode");
break;
case ASYNC_CONNMODE:
mbox = ISP_READ(isp, OUTMAILBOX1);
switch (mbox) {
case ISP_CONN_LOOP:
- PRINTF("%s: Point-to-Point -> Loop mode\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "Point-to-Point->Loop mode");
break;
case ISP_CONN_PTP:
- PRINTF("%s: Loop -> Point-to-Point mode\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGINFO, "Loop->Point-to-Point mode");
break;
case ISP_CONN_BADLIP:
- PRINTF("%s: Point-to-Point -> Loop mode (1)\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN,
+ "Point-to-Point->Loop mode (1)");
break;
case ISP_CONN_FATAL:
- PRINTF("%s: FATAL CONNECTION ERROR\n", isp->isp_name);
- isp_restart(isp);
+ isp_prt(isp, ISP_LOGERR, "FATAL CONNECTION ERROR");
+ isp_reinit(isp);
/* no point continuing after this */
return (-1);
case ISP_CONN_LOOPBACK:
- PRINTF("%s: Looped Back in Point-to-Point mode\n",
- isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN,
+ "Looped Back in Point-to-Point mode");
}
break;
default:
- PRINTF("%s: unknown async code 0x%x\n", isp->isp_name, mbox);
+ isp_prt(isp, ISP_LOGWARN, "Unknown Async Code 0x%x", mbox);
break;
}
return (fast_post_handle);
@@ -3027,11 +3034,12 @@ isp_handle_other_response(isp, sp, optrp)
#ifdef ISP_TARGET_MODE
return (isp_target_notify(isp, sp, optrp));
#else
+ optrp = optrp;
/* FALLTHROUGH */
#endif
case RQSTYPE_REQUEST:
default:
- PRINTF("%s: unhandled response type 0x%x\n", isp->isp_name,
+ isp_prt(isp, ISP_LOGWARN, "Unhandled Response Type 0x%x",
sp->req_header.rqs_entry_type);
return (-1);
}
@@ -3041,55 +3049,117 @@ static void
isp_parse_status(isp, sp, xs)
struct ispsoftc *isp;
ispstatusreq_t *sp;
- ISP_SCSI_XFER_T *xs;
+ XS_T *xs;
{
- switch (sp->req_completion_status) {
+ switch (sp->req_completion_status & 0xff) {
case RQCS_COMPLETE:
- XS_SETERR(xs, HBA_NOERROR);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_NOERROR);
+ }
return;
case RQCS_INCOMPLETE:
if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
- IDPRINTF(3, ("%s: Selection Timeout for %d.%d.%d\n",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs),
- XS_CHANNEL(xs)));
- XS_SETERR(xs, HBA_SELTIMEOUT);
+ isp_prt(isp, ISP_LOGDEBUG0,
+ "Selection Timeout for %d.%d.%d",
+ XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_SELTIMEOUT);
+ }
return;
}
- PRINTF("%s: command incomplete for %d.%d.%d, state 0x%x\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
+ isp_prt(isp, ISP_LOGERR,
+ "command incomplete for %d.%d.%d, state 0x%x",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs),
sp->req_state_flags);
break;
case RQCS_DMA_ERROR:
- PRINTF("%s: DMA error for command on %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "DMA error for command on %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_TRANSPORT_ERROR:
- PRINTF("%s: transport error for %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
- isp_prtstst(sp);
+ {
+ char buf[172];
+ buf[0] = 0;
+ STRNCAT(buf, "states=>", sizeof buf);
+ if (sp->req_state_flags & RQSF_GOT_BUS) {
+ STRNCAT(buf, " GOT_BUS", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_GOT_TARGET) {
+ STRNCAT(buf, " GOT_TGT", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_SENT_CDB) {
+ STRNCAT(buf, " SENT_CDB", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_XFRD_DATA) {
+ STRNCAT(buf, " XFRD_DATA", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_GOT_STATUS) {
+ STRNCAT(buf, " GOT_STS", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_GOT_SENSE) {
+ STRNCAT(buf, " GOT_SNS", sizeof buf);
+ }
+ if (sp->req_state_flags & RQSF_XFER_COMPLETE) {
+ STRNCAT(buf, " XFR_CMPLT", sizeof buf);
+ }
+ STRNCAT(buf, "\nstatus=>", sizeof buf);
+ if (sp->req_status_flags & RQSTF_DISCONNECT) {
+ STRNCAT(buf, " Disconnect", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_SYNCHRONOUS) {
+ STRNCAT(buf, " Sync_xfr", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_PARITY_ERROR) {
+ STRNCAT(buf, " Parity", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_BUS_RESET) {
+ STRNCAT(buf, " Bus_Reset", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_DEVICE_RESET) {
+ STRNCAT(buf, " Device_Reset", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_ABORTED) {
+ STRNCAT(buf, " Aborted", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_TIMEOUT) {
+ STRNCAT(buf, " Timeout", sizeof buf);
+ }
+ if (sp->req_status_flags & RQSTF_NEGOTIATION) {
+ STRNCAT(buf, " Negotiation", sizeof buf);
+ }
+ isp_prt(isp, ISP_LOGERR, "%s", buf);
+ isp_prt(isp, ISP_LOGERR, "transport error for %d.%d.%d:\n%s",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), buf);
break;
-
+ }
case RQCS_RESET_OCCURRED:
- IDPRINTF(1, ("%s: bus reset destroyed command for %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)));
+ isp_prt(isp, ISP_LOGWARN,
+ "bus reset destroyed command for %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
- XS_SETERR(xs, HBA_BUSRESET);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_BUSRESET);
+ }
return;
case RQCS_ABORTED:
- PRINTF("%s: command aborted for %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "command aborted for %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
isp->isp_sendmarker |= (1 << XS_CHANNEL(xs));
- XS_SETERR(xs, HBA_ABORTED);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_ABORTED);
+ }
return;
case RQCS_TIMEOUT:
- IDPRINTF(2, ("%s: command timed out for %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs)));
- XS_SETERR(xs, HBA_CMDTIMEOUT);
+ isp_prt(isp, ISP_LOGWARN, "command timed out for %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_CMDTIMEOUT);
+ }
return;
case RQCS_DATA_OVERRUN:
@@ -3097,133 +3167,145 @@ isp_parse_status(isp, sp, xs)
XS_RESID(xs) = sp->req_resid;
break;
}
- PRINTF("%s: data overrun for command on %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
- XS_SETERR(xs, HBA_DATAOVR);
+ isp_prt(isp, ISP_LOGERR, "data overrun for command on %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_DATAOVR);
+ }
return;
case RQCS_COMMAND_OVERRUN:
- PRINTF("%s: command overrun for command on %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "command overrun for command on %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_STATUS_OVERRUN:
- PRINTF("%s: status overrun for command on %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "status overrun for command on %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_BAD_MESSAGE:
- PRINTF("%s: msg not COMMAND COMPLETE after status %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "msg not COMMAND COMPLETE after status %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_NO_MESSAGE_OUT:
- PRINTF("%s: No MESSAGE OUT phase after selection on %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "No MESSAGE OUT phase after selection on %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_EXT_ID_FAILED:
- PRINTF("%s: EXTENDED IDENTIFY failed %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "EXTENDED IDENTIFY failed %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_IDE_MSG_FAILED:
- PRINTF("%s: INITIATOR DETECTED ERROR rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "INITIATOR DETECTED ERROR rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_ABORT_MSG_FAILED:
- PRINTF("%s: ABORT OPERATION rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "ABORT OPERATION rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_REJECT_MSG_FAILED:
- PRINTF("%s: MESSAGE REJECT rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "MESSAGE REJECT rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_NOP_MSG_FAILED:
- PRINTF("%s: NOP rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "NOP rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_PARITY_ERROR_MSG_FAILED:
- PRINTF("%s: MESSAGE PARITY ERROR rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "MESSAGE PARITY ERROR rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_DEVICE_RESET_MSG_FAILED:
- PRINTF("%s: BUS DEVICE RESET rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGWARN,
+ "BUS DEVICE RESET rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_ID_MSG_FAILED:
- PRINTF("%s: IDENTIFY rejected by %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "IDENTIFY rejected by %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_UNEXP_BUS_FREE:
- PRINTF("%s: %d.%d.%d had an unexpected bus free\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR, "%d.%d.%d had an unexpected bus free",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_DATA_UNDERRUN:
if (IS_FC(isp)) {
XS_RESID(xs) = sp->req_resid;
}
- XS_SETERR(xs, HBA_NOERROR);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_NOERROR);
+ }
return;
case RQCS_XACT_ERR1:
- PRINTF("%s: HBA attempted queued transaction with disconnect "
- "not set for %d.%d.%d\n", isp->isp_name, XS_CHANNEL(xs),
+ isp_prt(isp, ISP_LOGERR, xact1, XS_CHANNEL(xs),
XS_TGT(xs), XS_LUN(xs));
break;
case RQCS_XACT_ERR2:
- PRINTF("%s: HBA attempted queued transaction to target "
- "routine %d on target %d, bus %d\n", isp->isp_name,
+ isp_prt(isp, ISP_LOGERR, xact2,
XS_LUN(xs), XS_TGT(xs), XS_CHANNEL(xs));
break;
case RQCS_XACT_ERR3:
- PRINTF("%s: HBA attempted queued transaction for target %d lun "
- "%d on bus %d when queueing disabled\n", isp->isp_name,
- XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ isp_prt(isp, ISP_LOGERR, xact3, XS_TGT(xs),
+ XS_LUN(xs), XS_CHANNEL(xs));
break;
case RQCS_BAD_ENTRY:
- PRINTF("%s: invalid IOCB entry type detected\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
break;
case RQCS_QUEUE_FULL:
- IDPRINTF(3, ("%s: internal queues full for target %d lun %d "
- "bus %d, status 0x%x\n", isp->isp_name, XS_TGT(xs),
- XS_LUN(xs), XS_CHANNEL(xs), XS_STS(xs)));
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "internal queues full for %d.%d.%d status 0x%x", XS_TGT(xs),
+ XS_LUN(xs), XS_CHANNEL(xs), *XS_STSP(xs));
/*
* If QFULL or some other status byte is set, then this
* isn't an error, per se.
*/
- if (XS_STS(xs) != 0) {
+ if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
XS_SETERR(xs, HBA_NOERROR);
return;
}
break;
case RQCS_PHASE_SKIPPED:
- PRINTF("%s: SCSI phase skipped (e.g., COMMAND COMPLETE w/o "
- "STATUS phase) for target %d lun %d bus %d\n",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ isp_prt(isp, ISP_LOGERR, pskip,
+ XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
break;
case RQCS_ARQS_FAILED:
- PRINTF("%s: Auto Request Sense failed for %d.%d.%d\n",
- isp->isp_name, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "Auto Request Sense failed for %d.%d.%d",
+ XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_ARQFAIL);
+ }
return;
case RQCS_WIDE_FAILED:
- PRINTF("%s: Wide Negotiation failed for %d.%d.%d\n",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "Wide Negotiation failed for %d.%d.%d",
+ XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
if (IS_SCSI(isp)) {
sdparam *sdp = isp->isp_param;
sdp += XS_CHANNEL(xs);
@@ -3231,12 +3313,15 @@ isp_parse_status(isp, sp, xs)
sdp->isp_devparam[XS_TGT(xs)].dev_update = 1;
isp->isp_update |= (1 << XS_CHANNEL(xs));
}
- XS_SETERR(xs, HBA_NOERROR);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_NOERROR);
+ }
return;
case RQCS_SYNCXFER_FAILED:
- PRINTF("%s: SDTR Message failed for target %d.%d.%d\n",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "SDTR Message failed for target %d.%d.%d",
+ XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
if (IS_SCSI(isp)) {
sdparam *sdp = isp->isp_param;
sdp += XS_CHANNEL(xs);
@@ -3247,46 +3332,57 @@ isp_parse_status(isp, sp, xs)
break;
case RQCS_LVD_BUSERR:
- PRINTF("%s: Bad LVD condition while talking to %d.%d.%d\n",
- isp->isp_name, XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
+ isp_prt(isp, ISP_LOGERR,
+ "Bad LVD condition while talking to %d.%d.%d",
+ XS_TGT(xs), XS_LUN(xs), XS_CHANNEL(xs));
break;
case RQCS_PORT_UNAVAILABLE:
/*
* No such port on the loop. Moral equivalent of SELTIMEO
*/
- IDPRINTF(3, ("%s: Port Unavailable for target %d\n",
- isp->isp_name, XS_TGT(xs)));
- XS_SETERR(xs, HBA_SELTIMEOUT);
+ isp_prt(isp, ISP_LOGINFO,
+ "Port Unavailable for target %d", XS_TGT(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_SELTIMEOUT);
+ }
return;
case RQCS_PORT_LOGGED_OUT:
/*
* It was there (maybe)- treat as a selection timeout.
*/
- IDPRINTF(2, ("%s: port logout for target %d\n",
- isp->isp_name, XS_TGT(xs)));
- XS_SETERR(xs, HBA_SELTIMEOUT);
+ isp_prt(isp, ISP_LOGINFO,
+ "port logout for target %d", XS_TGT(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_SELTIMEOUT);
+ }
return;
case RQCS_PORT_CHANGED:
- PRINTF("%s: port changed for target %d\n",
- isp->isp_name, XS_TGT(xs));
- XS_SETERR(xs, HBA_SELTIMEOUT);
+ isp_prt(isp, ISP_LOGWARN,
+ "port changed for target %d", XS_TGT(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_SELTIMEOUT);
+ }
return;
case RQCS_PORT_BUSY:
- PRINTF("%s: port busy for target %d\n",
- isp->isp_name, XS_TGT(xs));
- XS_SETERR(xs, HBA_TGTBSY);
+ isp_prt(isp, ISP_LOGWARN,
+ "port busy for target %d", XS_TGT(xs));
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_TGTBSY);
+ }
return;
default:
- PRINTF("%s: completion status 0x%x\n",
- isp->isp_name, sp->req_completion_status);
+ isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
+ sp->req_completion_status);
break;
}
- XS_SETERR(xs, HBA_BOTCH);
+ if (XS_NOERR(xs)) {
+ XS_SETERR(xs, HBA_BOTCH);
+ }
}
static void
@@ -3294,15 +3390,15 @@ isp_fastpost_complete(isp, fph)
struct ispsoftc *isp;
u_int32_t fph;
{
- ISP_SCSI_XFER_T *xs;
+ XS_T *xs;
if (fph < 1) {
return;
}
xs = isp_find_xs(isp, fph);
if (xs == NULL) {
- PRINTF("%s: command for fast posting handle 0x%x not found\n",
- isp->isp_name, fph);
+ isp_prt(isp, ISP_LOGWARN,
+ "Command for fast post handle 0x%x not found", fph);
return;
}
isp_destroy_handle(isp, fph);
@@ -3312,12 +3408,13 @@ isp_fastpost_complete(isp, fph)
* we must believe that SCSI status is zero and
* that all data transferred.
*/
+ XS_SET_STATE_STAT(isp, xs, NULL);
XS_RESID(xs) = 0;
- XS_STS(xs) = 0;
+ *XS_STSP(xs) = SCSI_GOOD;
if (XS_XFRLEN(xs)) {
ISP_DMAFREE(isp, xs, fph);
}
- XS_CMD_DONE(xs);
+ isp_done(xs);
if (isp->isp_nactive)
isp->isp_nactive--;
}
@@ -3422,6 +3519,105 @@ static u_int16_t mbpscsi[] = {
ISPOPMAP(0x01, 0x01) /* 0x5d: GET NOST DATA */
};
+#ifndef ISP_STRIPEED
+static char *scsi_mbcmd_names[] = {
+ "NO-OP",
+ "LOAD RAM",
+ "EXEC FIRMWARE",
+ "DUMP RAM",
+ "WRITE RAM WORD",
+ "READ RAM WORD",
+ "MAILBOX REG TEST",
+ "VERIFY CHECKSUM",
+ "ABOUT FIRMWARE",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "CHECK FIRMWARE",
+ NULL,
+ "INIT REQUEST QUEUE",
+ "INIT RESULT QUEUE",
+ "EXECUTE IOCB",
+ "WAKE UP",
+ "STOP FIRMWARE",
+ "ABORT",
+ "ABORT DEVICE",
+ "ABORT TARGET",
+ "BUS RESET",
+ "STOP QUEUE",
+ "START QUEUE",
+ "SINGLE STEP QUEUE",
+ "ABORT QUEUE",
+ "GET DEV QUEUE STATUS",
+ NULL,
+ "GET FIRMWARE STATUS",
+ "GET INIT SCSI ID",
+ "GET SELECT TIMEOUT",
+ "GET RETRY COUNT",
+ "GET TAG AGE LIMIT",
+ "GET CLOCK RATE",
+ "GET ACT NEG STATE",
+ "GET ASYNC DATA SETUP TIME",
+ "GET PCI PARAMS",
+ "GET TARGET PARAMS",
+ "GET DEV QUEUE PARAMS",
+ "GET RESET DELAY PARAMS",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "SET INIT SCSI ID",
+ "SET SELECT TIMEOUT",
+ "SET RETRY COUNT",
+ "SET TAG AGE LIMIT",
+ "SET CLOCK RATE",
+ "SET ACT NEG STATE",
+ "SET ASYNC DATA SETUP TIME",
+ "SET PCI CONTROL PARAMS",
+ "SET TARGET PARAMS",
+ "SET DEV QUEUE PARAMS",
+ "SET RESET DELAY PARAMS",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "RETURN BIOS BLOCK ADDR",
+ "WRITE FOUR RAM WORDS",
+ "EXEC BIOS IOCB",
+ NULL,
+ NULL,
+ "SET SYSTEM PARAMETER",
+ "GET SYSTEM PARAMETER",
+ NULL,
+ "GET SCAM CONFIGURATION",
+ "SET SCAM CONFIGURATION",
+ "SET FIRMWARE FEATURES",
+ "GET FIRMWARE FEATURES",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "LOAD RAM A64",
+ "DUMP RAM A64",
+ "INITIALIZE REQUEST QUEUE A64",
+ "INITIALIZE RESPONSE QUEUE A64",
+ "EXECUTE IOCB A64",
+ "ENABLE TARGET MODE",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "SET DATA OVERRUN RECOVERY MODE",
+ "GET DATA OVERRUN RECOVERY MODE",
+ "SET HOST DATA",
+ "GET NOST DATA",
+};
+#endif
+
static u_int16_t mbpfc[] = {
ISPOPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
ISPOPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
@@ -3552,11 +3748,145 @@ static u_int16_t mbpfc[] = {
ISPOPMAP(0x07, 0x01) /* 0x7e: Lun RESET */
};
+#ifndef ISP_STRIPPED
+static char *fc_mbcmd_names[] = {
+ "NO-OP",
+ "LOAD RAM",
+ "EXEC FIRMWARE",
+ "DUMP RAM",
+ "WRITE RAM WORD",
+ "READ RAM WORD",
+ "MAILBOX REG TEST",
+ "VERIFY CHECKSUM",
+ "ABOUT FIRMWARE",
+ "LOAD RAM",
+ "DUMP RAM",
+ NULL,
+ NULL,
+ NULL,
+ "CHECK FIRMWARE",
+ NULL,
+ "INIT REQUEST QUEUE",
+ "INIT RESULT QUEUE",
+ "EXECUTE IOCB",
+ "WAKE UP",
+ "STOP FIRMWARE",
+ "ABORT",
+ "ABORT DEVICE",
+ "ABORT TARGET",
+ "BUS RESET",
+ "STOP QUEUE",
+ "START QUEUE",
+ "SINGLE STEP QUEUE",
+ "ABORT QUEUE",
+ "GET DEV QUEUE STATUS",
+ NULL,
+ "GET FIRMWARE STATUS",
+ "GET LOOP ID",
+ NULL,
+ "GET RETRY COUNT",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "GET FIRMWARE OPTIONS",
+ "GET PORT QUEUE PARAMS",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "SET RETRY COUNT",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "SET FIRMWARE OPTIONS",
+ "SET PORT QUEUE PARAMS",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "LOOP PORT BYPASS",
+ "LOOP PORT ENABLE",
+ "GET RESOURCE COUNTS",
+ "REQUEST NON PARTICIPATING MODE",
+ NULL,
+ NULL,
+ NULL,
+ "GET PORT DATABASE,, ENHANCED",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "EXECUTE IOCB A64",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "INIT FIRMWARE",
+ NULL,
+ "INIT LIP",
+ "GET FC-AL POSITION MAP",
+ "GET PORT DATABASE",
+ "CLEAR ACA",
+ "TARGET RESET",
+ "CLEAR TASK SET",
+ "ABORT TASK SET",
+ "GET FW STATE",
+ "GET PORT NAME",
+ "GET LINK STATUS",
+ "INIT LIP RESET",
+ NULL,
+ "SEND SNS",
+ "FABRIC LOGIN",
+ "SEND CHANGE REQUEST",
+ "FABRIC LOGOUT",
+ "INIT LIP LOGIN",
+ NULL,
+ "LOGIN LOOP PORT",
+ "GET PORT/NODE NAME LIST",
+ "SET VENDOR ID",
+ "INITIALIZE IP MAILBOX",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "Get ID List",
+ "SEND LFA",
+ "Lun RESET"
+};
+#endif
+
static void
-isp_mboxcmd(isp, mbp)
+isp_mboxcmd(isp, mbp, logmask)
struct ispsoftc *isp;
mbreg_t *mbp;
+ int logmask;
{
+ char *cname, *xname, tname[16], mname[16];
unsigned int lim, ibits, obits, box, opcode;
u_int16_t *mcp;
@@ -3570,7 +3900,7 @@ isp_mboxcmd(isp, mbp)
if ((opcode = mbp->param[0]) >= lim) {
mbp->param[0] = MBOX_INVALID_COMMAND;
- PRINTF("%s: unknown command 0x%x\n", isp->isp_name, opcode);
+ isp_prt(isp, ISP_LOGERR, "Unknown Command 0x%x", opcode);
return;
}
@@ -3579,11 +3909,15 @@ isp_mboxcmd(isp, mbp)
if (ibits == 0 && obits == 0) {
mbp->param[0] = MBOX_COMMAND_PARAM_ERROR;
- PRINTF("%s: no parameters for opcode 0x%x\n", isp->isp_name,
- opcode);
+ isp_prt(isp, ISP_LOGERR, "no parameters for 0x%x", opcode);
return;
}
+ /*
+ * Get exclusive usage of mailbox registers.
+ */
+ MBOX_ACQUIRE(isp);
+
for (box = 0; box < MAX_MAILBOX; box++) {
if (ibits & (1 << box)) {
ISP_WRITE(isp, MBOX_OFF(box), mbp->param[box]);
@@ -3604,7 +3938,7 @@ isp_mboxcmd(isp, mbp)
/*
* Give the f/w a chance to pick this up.
*/
- SYS_DELAY(250);
+ USEC_DELAY(250);
/*
@@ -3621,180 +3955,84 @@ isp_mboxcmd(isp, mbp)
}
}
+ MBOX_RELEASE(isp);
+
+ if (logmask == 0 || opcode == MBOX_EXEC_FIRMWARE) {
+ return;
+ }
+#ifdef ISP_STRIPPED
+ cname = NULL;
+#else
+ cname = (IS_FC(isp))? fc_mbcmd_names[opcode] : scsi_mbcmd_names[opcode];
+#endif
+ if (cname == NULL) {
+ SNPRINTF(cname, sizeof tname, "opcode %x", opcode);
+ }
+
/*
* Just to be chatty here...
*/
+ xname = NULL;
switch (mbp->param[0]) {
case MBOX_COMMAND_COMPLETE:
break;
case MBOX_INVALID_COMMAND:
- IDPRINTF(2, ("%s: mbox cmd %x failed with INVALID_COMMAND\n",
- isp->isp_name, opcode));
+ if (logmask & MBLOGMASK(MBOX_COMMAND_COMPLETE))
+ xname = "INVALID COMMAND";
break;
case MBOX_HOST_INTERFACE_ERROR:
- PRINTF("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n",
- isp->isp_name, opcode);
+ if (logmask & MBLOGMASK(MBOX_HOST_INTERFACE_ERROR))
+ xname = "HOST INTERFACE ERROR";
break;
case MBOX_TEST_FAILED:
- PRINTF("%s: mbox cmd %x failed with TEST_FAILED\n",
- isp->isp_name, opcode);
+ if (logmask & MBLOGMASK(MBOX_TEST_FAILED))
+ xname = "TEST FAILED";
break;
case MBOX_COMMAND_ERROR:
- if (opcode != MBOX_ABOUT_FIRMWARE)
- PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n",
- isp->isp_name, opcode);
+ if (logmask & MBLOGMASK(MBOX_COMMAND_ERROR))
+ xname = "COMMAND ERROR";
break;
case MBOX_COMMAND_PARAM_ERROR:
- switch (opcode) {
- case MBOX_GET_PORT_DB:
- case MBOX_GET_PORT_NAME:
- case MBOX_GET_DEV_QUEUE_PARAMS:
- break;
- default:
- PRINTF("%s: mbox cmd %x failed with "
- "COMMAND_PARAM_ERROR\n", isp->isp_name, opcode);
- }
+ if (logmask & MBLOGMASK(MBOX_COMMAND_PARAM_ERROR))
+ xname = "COMMAND PARAMETER ERROR";
break;
-
case MBOX_LOOP_ID_USED:
+ if (logmask & MBLOGMASK(MBOX_LOOP_ID_USED))
+ xname = "LOOP ID ALREADY IN USE";
+ break;
case MBOX_PORT_ID_USED:
+ if (logmask & MBLOGMASK(MBOX_PORT_ID_USED))
+ xname = "PORT ID ALREADY IN USE";
+ break;
case MBOX_ALL_IDS_USED:
+ if (logmask & MBLOGMASK(MBOX_ALL_IDS_USED))
+ xname = "ALL LOOP IDS IN USE";
+ break;
+ case 0: /* special case */
+ xname = "TIMEOUT";
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]);
- }
+ SNPRINTF(mname, sizeof mname, "error 0x%x", mbp->param[0]);
+ xname = mname;
break;
}
-}
-
-void
-isp_lostcmd(isp, xs)
- 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); /* XXX: WHICH BUS? */
- 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(isp, msg)
- struct ispsoftc *isp;
- const char *msg;
-{
- PRINTF("%s: %s\n", isp->isp_name, msg);
- if (IS_SCSI(isp))
- 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 (IS_SCSI(isp)) {
- 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_CTRL));
- ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
- }
- PRINTF(" mbox regs: %x %x %x %x %x\n",
- ISP_READ(isp, OUTMAILBOX0), ISP_READ(isp, OUTMAILBOX1),
- ISP_READ(isp, OUTMAILBOX2), ISP_READ(isp, OUTMAILBOX3),
- ISP_READ(isp, OUTMAILBOX4));
- ISP_DUMPREGS(isp);
+ if (xname)
+ isp_prt(isp, ISP_LOGALL, "Mailbox Command '%s' failed (%s)",
+ cname, xname);
}
static void
isp_fw_state(isp)
struct ispsoftc *isp;
{
- mbreg_t mbs;
if (IS_FC(isp)) {
- int once = 0;
+ mbreg_t mbs;
fcparam *fcp = isp->isp_param;
-again:
+
mbs.param[0] = MBOX_GET_FW_STATE;
- isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- IDPRINTF(1, ("%s: isp_fw_state 0x%x\n", isp->isp_name,
- mbs.param[0]));
- switch (mbs.param[0]) {
- case ASYNC_PDB_CHANGED:
- if (once++ < 10) {
- goto again;
- }
- fcp->isp_fwstate = FW_CONFIG_WAIT;
- fcp->isp_loopstate = LOOP_PDB_RCVD;
- goto again;
- case ASYNC_LIP_OCCURRED:
- fcp->isp_lipseq = mbs.param[1];
- /* FALLTHROUGH */
- case ASYNC_LOOP_UP:
- fcp->isp_fwstate = FW_CONFIG_WAIT;
- fcp->isp_loopstate = LOOP_LIP_RCVD;
- if (once++ < 10) {
- goto again;
- }
- break;
- case ASYNC_LOOP_RESET:
- case ASYNC_LOOP_DOWN:
- fcp->isp_fwstate = FW_CONFIG_WAIT;
- fcp->isp_loopstate = LOOP_NIL;
- /* FALLTHROUGH */
- case ASYNC_CHANGE_NOTIFY:
- if (once++ < 10) {
- goto again;
- }
- break;
- }
- PRINTF("%s: GET FIRMWARE STATE failed (0x%x)\n",
- isp->isp_name, mbs.param[0]);
- return;
- }
- fcp->isp_fwstate = mbs.param[1];
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
+ if (mbs.param[0] == MBOX_COMMAND_COMPLETE)
+ fcp->isp_fwstate = mbs.param[1];
}
}
@@ -3833,8 +4071,8 @@ isp_update_bus(isp, bus)
int get;
if (sdp->isp_devparam[tgt].dev_enable == 0) {
- IDPRINTF(2, ("%s: skipping target %d bus %d update\n",
- isp->isp_name, tgt, bus));
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "skipping target %d bus %d update", tgt, bus);
continue;
}
@@ -3873,10 +4111,10 @@ isp_update_bus(isp, bus)
sdp->isp_devparam[tgt].cur_dflags |=
(sdp->isp_devparam[tgt].dev_flags & DPARM_TQING);
sdp->isp_devparam[tgt].dev_refresh = 1;
- IDPRINTF(3, ("%s: bus %d set tgt %d flags 0x%x off 0x%x"
- " period 0x%x\n", isp->isp_name, bus, tgt,
- mbs.param[2], mbs.param[3] >> 8,
- mbs.param[3] & 0xff));
+ isp_prt(isp, ISP_LOGDEBUG2,
+ "bus %d set tgt %d flags 0x%x off 0x%x period 0x%x",
+ bus, tgt, mbs.param[2], mbs.param[3] >> 8,
+ mbs.param[3] & 0xff);
get = 0;
} else if (sdp->isp_devparam[tgt].dev_refresh) {
mbs.param[0] = MBOX_GET_TARGET_PARAMS;
@@ -3886,13 +4124,7 @@ isp_update_bus(isp, bus)
continue;
}
mbs.param[1] = (bus << 15) | (tgt << 8) ;
- isp_mboxcmd(isp, &mbs);
- if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
- PRINTF("%s: failed to %cet SCSI parameters for "
- "target %d\n", isp->isp_name, (get)? 'g' : 's',
- tgt);
- continue;
- }
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (get == 0) {
isp->isp_sendmarker |= (1 << bus);
continue;
@@ -3931,21 +4163,17 @@ isp_setdfltparm(isp, channel)
fcp->isp_retry_count = ICB_DFLT_RCOUNT;
/* Platform specific.... */
fcp->isp_loopid = DEFAULT_LOOPID(isp);
- fcp->isp_nodewwn = DEFAULT_WWN(isp);
- if ((fcp->isp_nodewwn >> 60) == 2) {
- fcp->isp_nodewwn &= ~((u_int64_t) 0xfff << 48);
- fcp->isp_portwwn = fcp->isp_nodewwn |
- (((u_int64_t)(isp->isp_unit+1)) << 48);
- } else {
- fcp->isp_portwwn = fcp->isp_nodewwn;
- }
+ fcp->isp_nodewwn = DEFAULT_NODEWWN(isp);
+ fcp->isp_portwwn = DEFAULT_PORTWWN(isp);
+
/*
* Now try and read NVRAM
*/
if ((isp->isp_confopts & (ISP_CFG_NONVRAM|ISP_CFG_OWNWWN)) ||
(isp_read_nvram(isp))) {
- PRINTF("%s: Node WWN 0x%08x%08x, Port WWN 0x%08x%08x\n",
- isp->isp_name, (u_int32_t) (fcp->isp_nodewwn >> 32),
+ isp_prt(isp, ISP_LOGINFO,
+ "Node WWN 0x%08x%08x, Port WWN 0x%08x%08x",
+ (u_int32_t) (fcp->isp_nodewwn >> 32),
(u_int32_t) (fcp->isp_nodewwn & 0xffffffff),
(u_int32_t) (fcp->isp_portwwn >> 32),
(u_int32_t) (fcp->isp_portwwn & 0xffffffff));
@@ -3981,9 +4209,8 @@ isp_setdfltparm(isp, channel)
*/
if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) {
mbs.param[0] = MBOX_GET_ACT_NEG_STATE;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
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 {
@@ -3997,10 +4224,12 @@ isp_setdfltparm(isp, channel)
sdp->isp_data_line_active_neg = 1;
}
- IDPRINTF(3, ("%s: defaulting bus %d REQ/ACK Active Negation is %d\n",
- isp->isp_name, channel, sdp->isp_req_ack_active_neg));
- IDPRINTF(3, ("%s: defaulting bus %d DATA Active Negation is %d\n",
- isp->isp_name, channel, sdp->isp_data_line_active_neg));
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "defaulting bus %d REQ/ACK Active Negation is %d",
+ channel, sdp->isp_req_ack_active_neg);
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "defaulting bus %d DATA Active Negation is %d",
+ channel, sdp->isp_data_line_active_neg);
/*
* The trick here is to establish a default for the default (honk!)
@@ -4047,7 +4276,7 @@ isp_setdfltparm(isp, channel)
mbs.param[0] = MBOX_GET_TARGET_PARAMS;
mbs.param[1] = tgt << 8;
- isp_mboxcmd(isp, &mbs);
+ isp_mboxcmd(isp, &mbs, MBLOGALL);
if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
continue;
}
@@ -4083,11 +4312,11 @@ isp_setdfltparm(isp, channel)
ISP_10M_SYNCPARMS & 0xff;
}
}
- IDPRINTF(3, ("%s: bus %d tgt %d flags %x offset %x period %x\n",
- isp->isp_name, channel, tgt,
- sdp->isp_devparam[tgt].dev_flags,
+ isp_prt(isp, ISP_LOGDEBUG1,
+ "bus %d tgt %d flags %x offset %x period %x",
+ channel, tgt, sdp->isp_devparam[tgt].dev_flags,
sdp->isp_devparam[tgt].sync_offset,
- sdp->isp_devparam[tgt].sync_period));
+ sdp->isp_devparam[tgt].sync_period);
}
/*
@@ -4096,15 +4325,14 @@ isp_setdfltparm(isp, channel)
sdp->isp_cmd_dma_burst_enable = 1;
sdp->isp_data_dma_burst_enabl = 1;
sdp->isp_fifo_threshold = 0;
- sdp->isp_initiator_id = 7;
- /* XXXX This is probably based upon clock XXXX */
+ sdp->isp_initiator_id = DEFAULT_IID(isp);
if (isp->isp_type >= ISP_HA_SCSI_1040) {
sdp->isp_async_data_setup = 9;
} else {
sdp->isp_async_data_setup = 6;
}
sdp->isp_selection_timeout = 250;
- sdp->isp_max_queue_depth = MAXISPREQUEST;
+ sdp->isp_max_queue_depth = MAXISPREQUEST(isp);
sdp->isp_tag_aging = 8;
sdp->isp_bus_reset_delay = 3;
sdp->isp_retry_count = 2;
@@ -4125,10 +4353,10 @@ isp_setdfltparm(isp, channel)
*/
void
-isp_restart(isp)
+isp_reinit(isp)
struct ispsoftc *isp;
{
- ISP_SCSI_XFER_T *xs;
+ XS_T *xs;
u_int32_t handle;
isp_reset(isp);
@@ -4139,11 +4367,11 @@ isp_restart(isp)
}
}
if (isp->isp_state != ISP_RUNSTATE) {
- PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGERR, "isp_reinit cannot restart ISP");
}
isp->isp_nactive = 0;
- for (handle = 1; handle <= (int) isp->isp_maxcmds; handle++) {
+ for (handle = 1; (int) handle <= isp->isp_maxcmds; handle++) {
xs = isp_find_xs(isp, handle);
if (xs == NULL) {
continue;
@@ -4156,7 +4384,7 @@ isp_restart(isp)
XS_RESID(xs) = 0;
}
XS_SETERR(xs, HBA_BUSRESET);
- XS_CMD_DONE(xs);
+ isp_done(xs);
}
}
@@ -4197,9 +4425,9 @@ isp_read_nvram(isp)
if (nvram_data[0] != 'I' || nvram_data[1] != 'S' ||
nvram_data[2] != 'P') {
if (isp->isp_bustype != ISP_BT_SBUS) {
- PRINTF("%s: invalid NVRAM header (%x,%x,%x,%x)\n",
- isp->isp_name, nvram_data[0], nvram_data[1],
- nvram_data[2], nvram_data[3]);
+ isp_prt(isp, ISP_LOGWARN, "invalid NVRAM header");
+ isp_prt(isp, ISP_LOGDEBUG0, "%x %x %x",
+ nvram_data[0], nvram_data[1], nvram_data[2]);
}
return (-1);
}
@@ -4210,11 +4438,11 @@ isp_read_nvram(isp)
csum += nvram_data[i];
}
if (csum != 0) {
- PRINTF("%s: invalid NVRAM checksum\n", isp->isp_name);
+ isp_prt(isp, ISP_LOGWARN, "invalid NVRAM checksum");
return (-1);
}
if (ISP_NVRAM_VERSION(nvram_data) < minversion) {
- PRINTF("%s: version %d NVRAM not understood\n", isp->isp_name,
+ isp_prt(isp, ISP_LOGWARN, "version %d NVRAM not understood",
ISP_NVRAM_VERSION(nvram_data));
return (-1);
}
@@ -4232,7 +4460,6 @@ isp_read_nvram(isp)
} else {
isp_parse_nvram_2100(isp, nvram_data);
}
- IDPRINTF(3, ("%s: NVRAM is valid\n", isp->isp_name));
return (0);
#undef nvram_data
#undef nvram_words
@@ -4248,9 +4475,9 @@ isp_rdnvram_word(isp, wo, rp)
u_int16_t bit, rqst;
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
- SYS_DELAY(2);
+ USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
- SYS_DELAY(2);
+ USEC_DELAY(2);
if (IS_FC(isp)) {
wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1);
@@ -4276,11 +4503,11 @@ isp_rdnvram_word(isp, wo, rp)
bit = BIU_NVRAM_SELECT;
}
ISP_WRITE(isp, BIU_NVRAM, bit);
- SYS_DELAY(2);
+ USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, bit | BIU_NVRAM_CLOCK);
- SYS_DELAY(2);
+ USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, bit);
- SYS_DELAY(2);
+ USEC_DELAY(2);
}
/*
* Now read the result back in (bits come back in MSB format).
@@ -4290,20 +4517,18 @@ isp_rdnvram_word(isp, wo, rp)
u_int16_t rv;
*rp <<= 1;
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK);
- SYS_DELAY(2);
+ USEC_DELAY(2);
rv = ISP_READ(isp, BIU_NVRAM);
if (rv & BIU_NVRAM_DATAIN) {
*rp |= 1;
}
- SYS_DELAY(2);
+ USEC_DELAY(2);
ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT);
- SYS_DELAY(2);
+ USEC_DELAY(2);
}
ISP_WRITE(isp, BIU_NVRAM, 0);
- SYS_DELAY(2);
-#if BYTE_ORDER == BIG_ENDIAN
- *rp = ((*rp >> 8) | ((*rp & 0xff) << 8));
-#endif
+ USEC_DELAY(2);
+ ISP_SWIZZLE_NVRAM_WORD(isp, rp);
}
static void
@@ -4312,8 +4537,6 @@ isp_parse_nvram_1020(isp, nvram_data)
u_int8_t *nvram_data;
{
int i;
- static char *tru = "true";
- static char *not = "false";
sdparam *sdp = (sdparam *) isp->isp_param;
sdp->isp_fifo_threshold =
@@ -4367,35 +4590,6 @@ isp_parse_nvram_1020(isp, nvram_data)
ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data);
isp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data);
- if (isp->isp_dblev > 2) {
- PRINTF("%s: NVRAM values:\n", isp->isp_name);
- PRINTF(" Fifo Threshold = 0x%x\n",
- sdp->isp_fifo_threshold);
- PRINTF(" Bus Reset Delay = %d\n",
- sdp->isp_bus_reset_delay);
- PRINTF(" Retry Count = %d\n",
- sdp->isp_retry_count);
- PRINTF(" Retry Delay = %d\n",
- sdp->isp_retry_delay);
- PRINTF(" Tag Age Limit = %d\n",
- sdp->isp_tag_aging);
- PRINTF(" Selection Timeout = %d\n",
- sdp->isp_selection_timeout);
- PRINTF(" Max Queue Depth = %d\n",
- sdp->isp_max_queue_depth);
- PRINTF(" Async Data Setup = 0x%x\n",
- sdp->isp_async_data_setup);
- PRINTF(" REQ/ACK Active Negation = %s\n",
- sdp->isp_req_ack_active_neg? tru : not);
- PRINTF(" Data Line Active Negation = %s\n",
- sdp->isp_data_line_active_neg? tru : not);
- PRINTF(" Data DMA Burst Enable = %s\n",
- sdp->isp_data_dma_burst_enabl? tru : not);
- PRINTF(" Cmd DMA Burst Enable = %s\n",
- sdp->isp_cmd_dma_burst_enable? tru : not);
- PRINTF(" Fast MTTR = %s\n",
- isp->isp_fast_mttr? tru : not);
- }
for (i = 0; i < MAX_TARGETS; i++) {
sdp->isp_devparam[i].dev_enable =
ISP_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i);
@@ -4412,12 +4606,10 @@ isp_parse_nvram_1020(isp, nvram_data)
* be a shorter period than this.
*/
if (sdp->isp_devparam[i].sync_period < 0x19) {
- sdp->isp_devparam[i].sync_period =
- 0x19;
+ sdp->isp_devparam[i].sync_period = 0x19;
}
if (sdp->isp_devparam[i].sync_offset > 0xc) {
- sdp->isp_devparam[i].sync_offset =
- 0x0c;
+ sdp->isp_devparam[i].sync_offset = 0x0c;
}
} else {
if (sdp->isp_devparam[i].sync_offset > 0x8) {
@@ -4427,15 +4619,7 @@ isp_parse_nvram_1020(isp, nvram_data)
sdp->isp_devparam[i].dev_flags = 0;
if (ISP_NVRAM_TGT_RENEG(nvram_data, i))
sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
- if (ISP_NVRAM_TGT_QFRZ(nvram_data, i)) {
- PRINTF("%s: not supporting QFRZ option for "
- "target %d\n", isp->isp_name, i);
- }
sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
- if (ISP_NVRAM_TGT_ARQ(nvram_data, i) == 0) {
- PRINTF("%s: not disabling ARQ option for "
- "target %d\n", isp->isp_name, i);
- }
if (ISP_NVRAM_TGT_TQING(nvram_data, i))
sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
if (ISP_NVRAM_TGT_SYNC(nvram_data, i))
@@ -4447,15 +4631,6 @@ isp_parse_nvram_1020(isp, nvram_data)
if (ISP_NVRAM_TGT_DISC(nvram_data, i))
sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
sdp->isp_devparam[i].cur_dflags = 0; /* we don't know */
- if (isp->isp_dblev > 2) {
- PRINTF(" Target %d: Enabled %d Throttle %d "
- "Offset %d Period %d Flags 0x%x\n", i,
- sdp->isp_devparam[i].dev_enable,
- sdp->isp_devparam[i].exc_throttle,
- sdp->isp_devparam[i].sync_offset,
- sdp->isp_devparam[i].sync_period,
- sdp->isp_devparam[i].dev_flags);
- }
}
}
@@ -4465,8 +4640,6 @@ isp_parse_nvram_1080(isp, bus, nvram_data)
int bus;
u_int8_t *nvram_data;
{
- static char *tru = "true";
- static char *not = "false";
int i;
sdparam *sdp = (sdparam *) isp->isp_param;
sdp += bus;
@@ -4510,34 +4683,6 @@ isp_parse_nvram_1080(isp, bus, nvram_data)
sdp->isp_max_queue_depth =
ISP1080_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
- if (isp->isp_dblev >= 3) {
- PRINTF("%s: ISP1080 bus %d NVRAM values:\n",
- isp->isp_name, bus);
- PRINTF(" Initiator ID = %d\n",
- sdp->isp_initiator_id);
- PRINTF(" Fifo Threshold = 0x%x\n",
- sdp->isp_fifo_threshold);
- PRINTF(" Bus Reset Delay = %d\n",
- sdp->isp_bus_reset_delay);
- PRINTF(" Retry Count = %d\n",
- sdp->isp_retry_count);
- PRINTF(" Retry Delay = %d\n",
- sdp->isp_retry_delay);
- PRINTF(" Tag Age Limit = %d\n",
- sdp->isp_tag_aging);
- PRINTF(" Selection Timeout = %d\n",
- sdp->isp_selection_timeout);
- PRINTF(" Max Queue Depth = %d\n",
- sdp->isp_max_queue_depth);
- PRINTF(" Async Data Setup = 0x%x\n",
- sdp->isp_async_data_setup);
- PRINTF(" REQ/ACK Active Negation = %s\n",
- sdp->isp_req_ack_active_neg? tru : not);
- PRINTF(" Data Line Active Negation = %s\n",
- sdp->isp_data_line_active_neg? tru : not);
- PRINTF(" Cmd DMA Burst Enable = %s\n",
- sdp->isp_cmd_dma_burst_enable? tru : not);
- }
for (i = 0; i < MAX_TARGETS; i++) {
sdp->isp_devparam[i].dev_enable =
ISP1080_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus);
@@ -4550,17 +4695,7 @@ isp_parse_nvram_1080(isp, bus, nvram_data)
sdp->isp_devparam[i].dev_flags = 0;
if (ISP1080_NVRAM_TGT_RENEG(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
- if (ISP1080_NVRAM_TGT_QFRZ(nvram_data, i, bus)) {
- PRINTF("%s: not supporting QFRZ option "
- "for target %d bus %d\n",
- isp->isp_name, i, bus);
- }
sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
- if (ISP1080_NVRAM_TGT_ARQ(nvram_data, i, bus) == 0) {
- PRINTF("%s: not disabling ARQ option "
- "for target %d bus %d\n",
- isp->isp_name, i, bus);
- }
if (ISP1080_NVRAM_TGT_TQING(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
if (ISP1080_NVRAM_TGT_SYNC(nvram_data, i, bus))
@@ -4572,16 +4707,6 @@ isp_parse_nvram_1080(isp, bus, nvram_data)
if (ISP1080_NVRAM_TGT_DISC(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
sdp->isp_devparam[i].cur_dflags = 0;
- if (isp->isp_dblev >= 3) {
- PRINTF(" Target %d: Ena %d Throttle "
- "%d Offset %d Period %d Flags "
- "0x%x\n", i,
- sdp->isp_devparam[i].dev_enable,
- sdp->isp_devparam[i].exc_throttle,
- sdp->isp_devparam[i].sync_offset,
- sdp->isp_devparam[i].sync_period,
- sdp->isp_devparam[i].dev_flags);
- }
}
}
@@ -4591,8 +4716,6 @@ isp_parse_nvram_12160(isp, bus, nvram_data)
int bus;
u_int8_t *nvram_data;
{
- static char *tru = "true";
- static char *not = "false";
sdparam *sdp = (sdparam *) isp->isp_param;
int i;
@@ -4637,35 +4760,6 @@ isp_parse_nvram_12160(isp, bus, nvram_data)
sdp->isp_max_queue_depth =
ISP12160_NVRAM_MAX_QUEUE_DEPTH(nvram_data, bus);
- if (isp->isp_dblev >= 3) {
- PRINTF("%s: ISP12160 bus %d NVRAM values:\n",
- isp->isp_name, bus);
- PRINTF(" Initiator ID = %d\n",
- sdp->isp_initiator_id);
- PRINTF(" Fifo Threshold = 0x%x\n",
- sdp->isp_fifo_threshold);
- PRINTF(" Bus Reset Delay = %d\n",
- sdp->isp_bus_reset_delay);
- PRINTF(" Retry Count = %d\n",
- sdp->isp_retry_count);
- PRINTF(" Retry Delay = %d\n",
- sdp->isp_retry_delay);
- PRINTF(" Tag Age Limit = %d\n",
- sdp->isp_tag_aging);
- PRINTF(" Selection Timeout = %d\n",
- sdp->isp_selection_timeout);
- PRINTF(" Max Queue Depth = %d\n",
- sdp->isp_max_queue_depth);
- PRINTF(" Async Data Setup = 0x%x\n",
- sdp->isp_async_data_setup);
- PRINTF(" REQ/ACK Active Negation = %s\n",
- sdp->isp_req_ack_active_neg? tru : not);
- PRINTF(" Data Line Active Negation = %s\n",
- sdp->isp_data_line_active_neg? tru : not);
- PRINTF(" Cmd DMA Burst Enable = %s\n",
- sdp->isp_cmd_dma_burst_enable? tru : not);
- }
-
for (i = 0; i < MAX_TARGETS; i++) {
sdp->isp_devparam[i].dev_enable =
ISP12160_NVRAM_TGT_DEVICE_ENABLE(nvram_data, i, bus);
@@ -4678,15 +4772,7 @@ isp_parse_nvram_12160(isp, bus, nvram_data)
sdp->isp_devparam[i].dev_flags = 0;
if (ISP12160_NVRAM_TGT_RENEG(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_RENEG;
- if (ISP12160_NVRAM_TGT_QFRZ(nvram_data, i, bus)) {
- PRINTF("%s: not supporting QFRZ option "
- "for target %d bus %d\n", isp->isp_name, i, bus);
- }
sdp->isp_devparam[i].dev_flags |= DPARM_ARQ;
- if (ISP12160_NVRAM_TGT_ARQ(nvram_data, i, bus) == 0) {
- PRINTF("%s: not disabling ARQ option "
- "for target %d bus %d\n", isp->isp_name, i, bus);
- }
if (ISP12160_NVRAM_TGT_TQING(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_TQING;
if (ISP12160_NVRAM_TGT_SYNC(nvram_data, i, bus))
@@ -4698,15 +4784,6 @@ isp_parse_nvram_12160(isp, bus, nvram_data)
if (ISP12160_NVRAM_TGT_DISC(nvram_data, i, bus))
sdp->isp_devparam[i].dev_flags |= DPARM_DISC;
sdp->isp_devparam[i].cur_dflags = 0;
- if (isp->isp_dblev >= 3) {
- PRINTF(" Target %d: Ena %d Throttle %d Offset %d "
- "Period %d Flags 0x%x\n", i,
- sdp->isp_devparam[i].dev_enable,
- sdp->isp_devparam[i].exc_throttle,
- sdp->isp_devparam[i].sync_offset,
- sdp->isp_devparam[i].sync_period,
- sdp->isp_devparam[i].dev_flags);
- }
}
}
@@ -4716,55 +4793,39 @@ isp_parse_nvram_2100(isp, nvram_data)
u_int8_t *nvram_data;
{
fcparam *fcp = (fcparam *) isp->isp_param;
- union {
- struct {
-#if BYTE_ORDER == BIG_ENDIAN
- u_int32_t hi32;
- u_int32_t lo32;
-#else
- u_int32_t lo32;
- u_int32_t hi32;
-#endif
- } wd;
- u_int64_t full64;
- } wwnstore;
+ u_int64_t wwn;
/*
* There is supposed to be WWNN storage as distinct
* from WWPN storage in NVRAM, but it doesn't appear
- * to be used sanely.
+ * to be used sanely across all cards.
*/
- wwnstore.full64 = ISP2100_NVRAM_PORT_NAME(nvram_data);
- if (wwnstore.full64 != 0LL) {
- switch ((int) (wwnstore.full64 >> 60)) {
+ wwn = ISP2100_NVRAM_PORT_NAME(nvram_data);
+ if (wwn != 0LL) {
+ switch ((int) (wwn >> 60)) {
case 0:
/*
- * Broken cards with nothing in the top nibble.
- * Pah.
+ * Broken PTI cards with nothing in the top nibble. Pah.
*/
- wwnstore.full64 |= (2LL << 60);
+ wwn |= (2LL << 60);
/* FALLTHROUGH */
case 2:
- fcp->isp_portwwn = wwnstore.full64;
- fcp->isp_nodewwn = wwnstore.full64;
+ fcp->isp_nodewwn = wwn;
fcp->isp_nodewwn &= ~((0xfffLL) << 48);
- if (fcp->isp_nodewwn == fcp->isp_portwwn) {
- fcp->isp_portwwn |=
- (((u_int64_t)(isp->isp_unit+1)) << 48);
- }
+ fcp->isp_portwwn =
+ PORT_FROM_NODE_WWN(isp, fcp->isp_nodewwn);
break;
default:
- fcp->isp_portwwn = wwnstore.full64;
- fcp->isp_nodewwn = wwnstore.full64;
+ fcp->isp_portwwn = fcp->isp_nodewwn = wwn;
}
}
- CFGPRINTF("%s: Node WWN 0x%08x%08x, Port WWN 0x%08x%08x\n",
- isp->isp_name, (u_int32_t) (fcp->isp_nodewwn >> 32),
- (u_int32_t) (fcp->isp_nodewwn & 0xffffffff),
+ isp_prt(isp, ISP_LOGCONFIG, "NVRAM Derived Node WWN 0x%08x%08x",
+ (u_int32_t) (fcp->isp_nodewwn >> 32),
+ (u_int32_t) (fcp->isp_nodewwn & 0xffffffff));
+ isp_prt(isp, ISP_LOGCONFIG, "NVRAM Derived Port WWN 0x%08x%08x",
(u_int32_t) (fcp->isp_portwwn >> 32),
(u_int32_t) (fcp->isp_portwwn & 0xffffffff));
-
fcp->isp_maxalloc =
ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data);
fcp->isp_maxfrmlen =
@@ -4778,23 +4839,4 @@ isp_parse_nvram_2100(isp, nvram_data)
fcp->isp_execthrottle =
ISP2100_NVRAM_EXECUTION_THROTTLE(nvram_data);
fcp->isp_fwoptions = ISP2100_NVRAM_OPTIONS(nvram_data);
- if (isp->isp_dblev > 2) {
- PRINTF("%s: NVRAM values:\n", isp->isp_name);
- PRINTF(" Max IOCB Allocation = %d\n",
- fcp->isp_maxalloc);
- PRINTF(" Max Frame Length = %d\n",
- fcp->isp_maxfrmlen);
- PRINTF(" Execution Throttle = %d\n",
- fcp->isp_execthrottle);
- PRINTF(" Retry Count = %d\n",
- fcp->isp_retry_count);
- PRINTF(" Retry Delay = %d\n",
- fcp->isp_retry_delay);
- PRINTF(" Hard Loop ID = %d\n",
- fcp->isp_loopid);
- PRINTF(" Options = 0x%x\n",
- fcp->isp_fwoptions);
- PRINTF(" HBA Options = 0x%x\n",
- ISP2100_NVRAM_HBA_OPTIONS(nvram_data));
- }
}
OpenPOWER on IntegriCloud