diff options
| author | mjacob <mjacob@NetBSD.org> | 1997-08-16 00:22:11 +0000 |
|---|---|---|
| committer | mjacob <mjacob@NetBSD.org> | 1997-08-16 00:22:11 +0000 |
| commit | 14a7730c16abd067cea5d5ce32cefd27717c5e98 (patch) | |
| tree | 67448588afbfe00c95d462d0b273f34c96e0c5c4 /sys/dev | |
| parent | 7540ed1699d2aae9fa16e41f05959b104d2adc0e (diff) | |
*Major* differences to support the Qlogic 2100 (Fibre Channel PCI), as well
as being able to do microdifferentiation of the ISP SCSI chip; a couple of
bug fixes, and the beginnings of some watchdog support.
Diffstat (limited to 'sys/dev')
| -rw-r--r-- | sys/dev/ic/isp.c | 1568 |
1 files changed, 1194 insertions, 374 deletions
diff --git a/sys/dev/ic/isp.c b/sys/dev/ic/isp.c index c837a2d68a7..c221c2a7433 100644 --- a/sys/dev/ic/isp.c +++ b/sys/dev/ic/isp.c @@ -1,4 +1,4 @@ -/* $NetBSD: isp.c,v 1.9 1997/07/28 18:56:36 mjacob Exp $ */ +/* $NetBSD: isp.c,v 1.10 1997/08/16 00:22:11 mjacob Exp $ */ /* * Machine Independent (well, as best as possible) @@ -76,7 +76,7 @@ struct cfdriver isp_cd = { static void ispminphys __P((struct buf *)); static int32_t ispscsicmd __P((struct scsi_xfer *xs)); -static int isp_mboxcmd __P((struct ispsoftc *, mbreg_t *)); +static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *)); static struct scsi_adapter isp_switch = { ispscsicmd, ispminphys, 0, 0 @@ -84,96 +84,142 @@ static struct scsi_adapter isp_switch = { static struct scsi_device isp_dev = { NULL, NULL, NULL, NULL }; -static int isp_poll __P((struct ispsoftc *, struct scsi_xfer *, int)); -static int isp_parse_status __P((struct ispsoftc *, ispstatusreq_t *)); -static void isp_lostcmd __P((struct ispsoftc *, struct scsi_xfer *)); +#define IDPRINTF(lev, x) if (isp->isp_dblev >= lev) printf x +static int isp_poll __P((struct ispsoftc *, struct scsi_xfer *, int)); +static int isp_parse_status +__P((struct ispsoftc *, ispstatusreq_t *, struct scsi_xfer *)); +static void isp_lostcmd +__P((struct ispsoftc *, struct scsi_xfer *, ispreq_t *)); +static void isp_fibre_init __P((struct ispsoftc *)); +static void isp_fw_state __P((struct ispsoftc *)); +static void isp_dumpregs __P((struct ispsoftc *, const char *)); +static void isp_setdparm __P((struct ispsoftc *)); + +#define WATCHI (30 * hz) +static void isp_watch __P((void *)); /* * Reset Hardware. - * - * Only looks at sc_dev.dv_xname, sc_iot and sc_ioh fields. */ void isp_reset(isp) struct ispsoftc *isp; { mbreg_t mbs; - int loops, i; - u_int8_t clock; + int loops, i, cf_flags, dodnld = 1; + char *revname; + + revname = "(unknown)"; isp->isp_state = ISP_NILSTATE; - /* - * Do MD specific pre initialization - */ - ISP_RESET0(isp); + cf_flags = isp->isp_dev.dv_cfdata->cf_flags; /* - * Try and get old clock rate out before we hit the - * chip over the head- but if and only if we don't - * know our desired clock rate. + * Basic types have been set in the MD code. + * See if we can't figure out more here. */ - clock = isp->isp_mdvec->dv_clock; - if (clock == 0) { - mbs.param[0] = MBOX_GET_CLOCK_RATE; - (void) isp_mboxcmd(isp, &mbs); - if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { - clock = mbs.param[1]; - printf("%s: using board clock 0x%x\n", - isp->isp_name, clock); - } else { - clock = 0; + if (isp->isp_type & ISP_HA_FC) { + isp->isp_dblev = 2; + revname = "2100"; + } else { + isp->isp_dblev = 1; + i = ISP_READ(isp, BIU_CONF0) & BIU_CONF0_HW_MASK; + switch (i) { + default: + printf("%s: unknown ISP type %x\n", isp->isp_name, i); + break; + case 1: + revname = "1020"; + isp->isp_type = ISP_HA_SCSI_1020; + break; + case 3: + revname = "1040A"; + isp->isp_type = ISP_HA_SCSI_1040A; + break; + case 5: + revname = "1040B"; + isp->isp_type = ISP_HA_SCSI_1040B; + break; } } /* - * Hit the chip over the head with hammer. + * Do MD specific pre initialization */ + ISP_RESET0(isp); + isp_setdparm(isp); - ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET); /* - * Give the ISP a chance to recover... + * Hit the chip over the head with hammer, + * and give the ISP a chance to recover. */ - delay(100); - /* - * Clear data && control DMA engines. - */ - ISP_WRITE(isp, CDMA_CONTROL, + if (isp->isp_type & ISP_HA_SCSI) { + ISP_WRITE(isp, BIU_ICR, BIU_ICR_SOFT_RESET); + /* + * A slight delay... + */ + delay(100); + + /* + * Clear data && control DMA engines. + */ + ISP_WRITE(isp, CDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); - ISP_WRITE(isp, DDMA_CONTROL, + ISP_WRITE(isp, DDMA_CONTROL, DMA_CNTRL_CLEAR_CHAN | DMA_CNTRL_RESET_INT); + } else { + ISP_WRITE(isp, BIU2100_CSR, BIU2100_SOFT_RESET); + /* + * A slight delay... + */ + delay(100); + ISP_WRITE(isp, CDMA2100_CONTROL, + DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); + ISP_WRITE(isp, TDMA2100_CONTROL, + DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); + ISP_WRITE(isp, RDMA2100_CONTROL, + DMA_CNTRL2100_CLEAR_CHAN | DMA_CNTRL2100_RESET_INT); + } + /* * Wait for ISP to be ready to go... */ loops = MBOX_DELAY_COUNT; - while ((ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET) != 0) { + for (;;) { + if (isp->isp_type & ISP_HA_SCSI) { + if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) + break; + } else { + if (!(ISP_READ(isp, BIU2100_CSR) & BIU2100_SOFT_RESET)) + break; + } delay(100); if (--loops < 0) { - printf("%s: chip reset timed out\n", isp->isp_name); + isp_dumpregs(isp, "chip reset timed out"); return; } } /* * More initialization */ + if (isp->isp_type & ISP_HA_SCSI) { + ISP_WRITE(isp, BIU_CONF1, 0); + } else { + ISP_WRITE(isp, BIU2100_CSR, 0); + ISP_WRITE(isp, RISC_MTR2100, 0x1212); /* FM */ + } - ISP_WRITE(isp, BIU_CONF1, 0); ISP_WRITE(isp, HCCR, HCCR_CMD_RESET); delay(100); - if (isp->isp_mdvec->dv_conf1) { + if (isp->isp_type & ISP_HA_SCSI) { ISP_SETBITS(isp, BIU_CONF1, isp->isp_mdvec->dv_conf1); if (isp->isp_mdvec->dv_conf1 & BIU_BURST_ENABLE) { ISP_SETBITS(isp, CDMA_CONF, DMA_ENABLE_BURST); ISP_SETBITS(isp, DDMA_CONF, DMA_ENABLE_BURST); } - } else { - ISP_WRITE(isp, BIU_CONF1, 0); } - -#if 0 - ISP_WRITE(isp, RISC_MTR, 0x1212); /* FM */ -#endif ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */ /* @@ -184,115 +230,113 @@ isp_reset(isp) /* * Enable interrupts */ - ISP_WRITE(isp, BIU_ICR, - BIU_ICR_ENABLE_RISC_INT | BIU_ICR_ENABLE_ALL_INTS); + ENABLE_INTS(isp); /* * Do some sanity checking. */ - mbs.param[0] = MBOX_NO_OP; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: NOP test failed\n", isp->isp_name); - return; - } - - mbs.param[0] = MBOX_MAILBOX_REG_TEST; - mbs.param[1] = 0xdead; - mbs.param[2] = 0xbeef; - mbs.param[3] = 0xffff; - mbs.param[4] = 0x1111; - mbs.param[5] = 0xa5a5; - (void) isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: Mailbox Register test didn't complete\n", - isp->isp_name); - return; - } - i = 0; - if (mbs.param[1] != 0xdead) { - printf("%s: Register Test Failed @reg %d (got %x)\n", - isp->isp_name, 1, mbs.param[1]); - i++; - } - if (mbs.param[2] != 0xbeef) { - printf("%s: Register Test Failed @reg %d (got %x)\n", - isp->isp_name, 2, mbs.param[2]); - i++; - } - if (mbs.param[3] != 0xffff) { - printf("%s: Register Test Failed @reg %d (got %x)\n", - isp->isp_name, 3, mbs.param[3]); - i++; - } - if (mbs.param[4] != 0x1111) { - printf("%s: Register Test Failed @reg %d (got %x)\n", - isp->isp_name, 4, mbs.param[4]); - i++; - } - if (mbs.param[5] != 0xa5a5) { - printf("%s: Register Test Failed @reg %d (got %x)\n", - isp->isp_name, 5, mbs.param[5]); - i++; - } - if (i) { + isp_dumpregs(isp, "NOP test failed"); return; } - /* - * Download new Firmware - */ - for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) { - mbs.param[0] = MBOX_WRITE_RAM_WORD; - mbs.param[1] = isp->isp_mdvec->dv_codeorg + i; - mbs.param[2] = isp->isp_mdvec->dv_ispfw[i]; - (void) isp_mboxcmd(isp, &mbs); + if (isp->isp_type & ISP_HA_SCSI) { + mbs.param[0] = MBOX_MAILBOX_REG_TEST; + mbs.param[1] = 0xdead; + mbs.param[2] = 0xbeef; + mbs.param[3] = 0xffff; + mbs.param[4] = 0x1111; + mbs.param[5] = 0xa5a5; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: f/w download failed\n", isp->isp_name); + isp_dumpregs(isp, + "Mailbox Register test didn't complete"); + return; + } + if (mbs.param[1] != 0xdead || mbs.param[2] != 0xbeef || + mbs.param[3] != 0xffff || mbs.param[4] != 0x1111 || + mbs.param[5] != 0xa5a5) { + isp_dumpregs(isp, "Register Test Failed"); return; } + } /* - * Verify that it downloaded correctly. + * Download new Firmware, unless requested not to + * or not appropriate to do so. */ - mbs.param[0] = MBOX_VERIFY_CHECKSUM; - mbs.param[1] = isp->isp_mdvec->dv_codeorg; - (void) isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: ram checksum failure\n", isp->isp_name); - return; + if ((isp->isp_fwrev >= isp->isp_mdvec->dv_fwrev) || + (cf_flags & 0x80) != 0) { + dodnld = 0; + } + + if (dodnld) { + for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) { + mbs.param[0] = MBOX_WRITE_RAM_WORD; + mbs.param[1] = isp->isp_mdvec->dv_codeorg + i; + mbs.param[2] = isp->isp_mdvec->dv_ispfw[i]; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "f/w download failed"); + + return; + } + } + + if (isp->isp_mdvec->dv_fwlen) { + /* + * Verify that it downloaded correctly. + */ + mbs.param[0] = MBOX_VERIFY_CHECKSUM; + mbs.param[1] = isp->isp_mdvec->dv_codeorg; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "ram checksum failure"); + return; + } + } + } else { + IDPRINTF(2, ("%s: skipping f/w download\n", isp->isp_name)); } /* - * Now start it rolling... + * Now start it rolling. + * + * If we didn't actually download f/w, + * we still need to (re)start it. */ mbs.param[0] = MBOX_EXEC_FIRMWARE; mbs.param[1] = isp->isp_mdvec->dv_codeorg; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); - /* - * Set CLOCK RATE - */ - if (clock) { - mbs.param[0] = MBOX_SET_CLOCK_RATE; - mbs.param[1] = clock; - (void) isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: failed to set CLOCKRATE\n", isp->isp_name); - return; + if (isp->isp_type & ISP_HA_SCSI) { + /* + * Set CLOCK RATE + */ + if (((sdparam *)isp->isp_param)->isp_clock) { + mbs.param[0] = MBOX_SET_CLOCK_RATE; + mbs.param[1] = ((sdparam *)isp->isp_param)->isp_clock; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "failed to set CLOCKRATE"); + return; + } } } mbs.param[0] = MBOX_ABOUT_FIRMWARE; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: ABOUT FIRMWARE command failed\n", isp->isp_name); + isp_dumpregs(isp, "ABOUT FIRMWARE command failed"); return; } - printf("%s: F/W Revision %d.%d\n", isp->isp_name, + printf("%s: Board Revision %s, %s F/W Revision %d.%d\n", + isp->isp_name, revname, dodnld? "loaded" : "ROM", mbs.param[1], mbs.param[2]); + isp_fw_state(isp); isp->isp_state = ISP_RESETSTATE; } @@ -303,166 +347,232 @@ void isp_init(isp) struct ispsoftc *isp; { + sdparam *sdp; mbreg_t mbs; int s, i, l; - /* - * Set Default Host Adapter Parameters - * XXX: Should try and get them out of NVRAM - */ - - isp->isp_adapter_enabled = 1; - isp->isp_req_ack_active_neg = 1; - isp->isp_data_line_active_neg = 1; - isp->isp_cmd_dma_burst_enable = 1; - isp->isp_data_dma_burst_enabl = 1; - isp->isp_fifo_threshold = 2; - isp->isp_initiator_id = 7; - isp->isp_async_data_setup = 6; - isp->isp_selection_timeout = 250; - isp->isp_max_queue_depth = 256; - isp->isp_tag_aging = 8; - isp->isp_bus_reset_delay = 3; - isp->isp_retry_count = 0; - isp->isp_retry_delay = 1; - for (i = 0; i < MAX_TARGETS; i++) { - isp->isp_devparam[i].dev_flags = DPARM_DEFAULT; - isp->isp_devparam[i].exc_throttle = 16; - isp->isp_devparam[i].sync_period = 25; - isp->isp_devparam[i].sync_offset = 12; - isp->isp_devparam[i].dev_enable = 1; + if (isp->isp_type & ISP_HA_FC) { + isp_fibre_init(isp); + return; } + sdp = isp->isp_param; + /* + * Try and figure out if we're connected to a differential bus. + * You have to pause the RISC processor to read SXP registers. + */ s = splbio(); + ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); + if (ISP_READ(isp, SXP_PINS_DIFF) & SXP_PINS_DIFF_SENSE) { + sdp->isp_diffmode = 1; + printf("%s: Differential Mode\n", isp->isp_name); + } else { + /* + * Force pullups on. + */ + sdp->isp_req_ack_active_neg = 1; + sdp->isp_data_line_active_neg = 1; + sdp->isp_diffmode = 0; + } + ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); /* release paused processor */ - mbs.param[0] = MBOX_SET_INIT_SCSI_ID; - mbs.param[1] = isp->isp_initiator_id; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[0] = MBOX_GET_INIT_SCSI_ID; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set initiator id\n", isp->isp_name); + isp_dumpregs(isp, "failed to get initiator id"); return; } + if (mbs.param[1] != sdp->isp_initiator_id) { + printf("%s: setting Initiator ID to %d\n", isp->isp_name, + sdp->isp_initiator_id); + mbs.param[0] = MBOX_SET_INIT_SCSI_ID; + mbs.param[1] = sdp->isp_initiator_id; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + (void) splx(s); + isp_dumpregs(isp, "failed to set initiator id"); + return; + } + } else { + IDPRINTF(2, ("%s: leaving Initiator ID at %d\n", isp->isp_name, + sdp->isp_initiator_id)); + } mbs.param[0] = MBOX_SET_RETRY_COUNT; - mbs.param[1] = isp->isp_retry_count; - mbs.param[2] = isp->isp_retry_delay; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[1] = sdp->isp_retry_count; + mbs.param[2] = sdp->isp_retry_delay; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set retry count and delay\n", - isp->isp_name); + isp_dumpregs(isp, "failed to set retry count and delay"); return; } mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME; - mbs.param[1] = isp->isp_async_data_setup; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[1] = sdp->isp_async_data_setup; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set async data setup time\n", - isp->isp_name); + isp_dumpregs(isp, "failed to set async data setup time"); return; } mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE; - mbs.param[1] = - (isp->isp_req_ack_active_neg << 4) | - (isp->isp_data_line_active_neg << 5); - (void) isp_mboxcmd(isp, &mbs); + mbs.param[1] = (sdp->isp_req_ack_active_neg << 4) | + (sdp->isp_data_line_active_neg << 5); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set active negation state\n", - isp->isp_name); + isp_dumpregs(isp, "failed to set active neg state"); return; } - mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT; - mbs.param[1] = isp->isp_tag_aging; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[1] = sdp->isp_tag_aging; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set tag age limit\n", isp->isp_name); + isp_dumpregs(isp, "failed to set tag age limit"); return; } mbs.param[0] = MBOX_SET_SELECT_TIMEOUT; - mbs.param[1] = isp->isp_selection_timeout; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[1] = sdp->isp_selection_timeout; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set selection timeout\n", isp->isp_name); + isp_dumpregs(isp, "failed to set selection timeout"); return; } +#ifdef 0 + printf("%s: device parameters, W=wide, S=sync, T=TagEnable\n", + isp->isp_name); +#endif + for (i = 0; i < MAX_TARGETS; i++) { - if (isp->isp_devparam[i].dev_enable == 0) +#ifdef 0 + char bz[8]; + + if (sdp->isp_devparam[i].dev_flags & DPARM_SYNC) { + u_int16_t cj = (sdp->isp_devparam[i].sync_offset << 8) | + (sdp->isp_devparam[i].sync_period); + if (cj == ISP_20M_SYNCPARMS) { + cj = 20; + } else if (ISP_10M_SYNCPARMS) { + cj = 20; + } else if (ISP_08M_SYNCPARMS) { + cj = 20; + } else if (ISP_05M_SYNCPARMS) { + cj = 20; + } else if (ISP_04M_SYNCPARMS) { + cj = 20; + } else { + cj = 0; + } + if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE) + cj <<= 1; + sprintf(bz, "%02dMBs", cj); + } else { + sprintf(bz, "Async"); + } + if (sdp->isp_devparam[i].dev_flags & DPARM_WIDE) + bz[5] = 'W'; + else + bz[5] = ' '; + if (sdp->isp_devparam[i].dev_flags & DPARM_TQING) + bz[6] = 'T'; + else + bz[6] = ' '; + bz[7] = 0; + printf(" Tgt%x:%s", i, bz); + if (((i+1) & 0x3) == 0) + printf("\n"); +#endif + if (sdp->isp_devparam[i].dev_enable == 0) continue; mbs.param[0] = MBOX_SET_TARGET_PARAMS; mbs.param[1] = i << 8; - mbs.param[2] = isp->isp_devparam[i].dev_flags << 8; + mbs.param[2] = sdp->isp_devparam[i].dev_flags << 8; mbs.param[3] = - (isp->isp_devparam[i].sync_offset << 8) | - (isp->isp_devparam[i].sync_period); - (void) isp_mboxcmd(isp, &mbs); + (sdp->isp_devparam[i].sync_offset << 8) | + (sdp->isp_devparam[i].sync_period); + + IDPRINTF(5, ("%s: target %d flags %x offset %x period %x\n", + isp->isp_name, i, sdp->isp_devparam[i].dev_flags, + sdp->isp_devparam[i].sync_offset, + sdp->isp_devparam[i].sync_period)); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - (void) splx(s); - printf("%s: failed to set target parameters\n", - isp->isp_name); - return; + printf("%s: failed to set parameters for target %d\n", + isp->isp_name, i); + printf("%s: flags %x offset %x period %x\n", + isp->isp_name, sdp->isp_devparam[i].dev_flags, + sdp->isp_devparam[i].sync_offset, + sdp->isp_devparam[i].sync_period); + mbs.param[0] = MBOX_SET_TARGET_PARAMS; + mbs.param[1] = i << 8; + mbs.param[2] = DPARM_DEFAULT << 8; + mbs.param[3] = ISP_10M_SYNCPARMS; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + (void) splx(s); + printf("%s: failed even to set defaults\n", + isp->isp_name); + return; + } } - for (l = 0; l < MAX_LUNS; l++) { mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS; mbs.param[1] = (i << 8) | l; - mbs.param[2] = isp->isp_max_queue_depth; - mbs.param[3] = isp->isp_devparam[i].exc_throttle; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[2] = sdp->isp_max_queue_depth; + mbs.param[3] = sdp->isp_devparam[i].exc_throttle; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: failed to set device queue " - "parameters\n", isp->isp_name); + isp_dumpregs(isp, "failed to set device queue " + "parameters"); return; } } } - /* * Set up DMA for the request and result mailboxes. */ if (ISP_MBOXDMASETUP(isp)) { (void) splx(s); - printf("%s: can't setup DMA for mailboxes\n", isp->isp_name); + printf("%s: can't setup dma mailboxes\n", isp->isp_name); return; } - + mbs.param[0] = MBOX_INIT_RES_QUEUE; - mbs.param[1] = RESULT_QUEUE_LEN; + mbs.param[1] = RESULT_QUEUE_LEN(isp); mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16); mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff); mbs.param[4] = 0; mbs.param[5] = 0; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: set of response queue failed\n", isp->isp_name); + isp_dumpregs(isp, "set of response queue failed"); return; } isp->isp_residx = 0; mbs.param[0] = MBOX_INIT_REQ_QUEUE; - mbs.param[1] = RQUEST_QUEUE_LEN; + mbs.param[1] = RQUEST_QUEUE_LEN(isp); mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16); mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff); mbs.param[4] = 0; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[5] = 0; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: set of request queue failed\n", isp->isp_name); + isp_dumpregs(isp, "set of request queue failed"); return; } isp->isp_reqidx = 0; @@ -476,19 +586,119 @@ isp_init(isp) * get everyone to renegotiate. */ - mbs.param[0] = MBOX_BUS_RESET; mbs.param[1] = 2; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { (void) splx(s); - printf("%s: SCSI bus reset failed\n", isp->isp_name); + isp_dumpregs(isp, "SCSI bus reset failed"); } + /* + * This is really important to have set after a bus reset. + */ isp->isp_sendmarker = 1; (void) splx(s); isp->isp_state = ISP_INITSTATE; } +static void +isp_fibre_init(isp) + struct ispsoftc *isp; +{ + fcparam *fcp; + isp_icb_t *icbp; + mbreg_t mbs; + int s, count; + + fcp = isp->isp_param; + + fcp->isp_retry_count = 0; + fcp->isp_retry_delay = 1; + + s = splbio(); + mbs.param[0] = MBOX_SET_RETRY_COUNT; + mbs.param[1] = fcp->isp_retry_count; + mbs.param[2] = fcp->isp_retry_delay; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + (void) splx(s); + isp_dumpregs(isp, "failed to set retry count and delay"); + return; + } + + if (ISP_MBOXDMASETUP(isp)) { + (void) splx(s); + printf("%s: can't setup DMA for mailboxes\n", isp->isp_name); + return; + } + + icbp = (isp_icb_t *) fcp->isp_scratch; + bzero(icbp, sizeof (*icbp)); +#if 0 + icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN; + MAKE_NODE_NAME(isp, icbp); + icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp); + icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp); + icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff); + icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16); + icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff); + icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16); +#endif + icbp->icb_version = 1; + icbp->icb_maxfrmlen = ICB_DFLT_FRMLEN; + icbp->icb_maxalloc = 256; + icbp->icb_execthrottle = 16; + icbp->icb_retry_delay = 5; + icbp->icb_retry_count = 0; + MAKE_NODE_NAME(isp, icbp); + icbp->icb_rqstqlen = RQUEST_QUEUE_LEN(isp); + icbp->icb_rsltqlen = RESULT_QUEUE_LEN(isp); + icbp->icb_rqstaddr[0] = (u_int16_t) (isp->isp_rquest_dma & 0xffff); + icbp->icb_rqstaddr[1] = (u_int16_t) (isp->isp_rquest_dma >> 16); + icbp->icb_respaddr[0] = (u_int16_t) (isp->isp_result_dma & 0xffff); + icbp->icb_respaddr[1] = (u_int16_t) (isp->isp_result_dma >> 16); + + mbs.param[0] = MBOX_INIT_FIRMWARE; + mbs.param[1] = 0; + mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16); + mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff); + mbs.param[4] = 0; + mbs.param[5] = 0; + mbs.param[6] = 0; + mbs.param[7] = 0; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + (void) splx(s); + isp_dumpregs(isp, "INIT FIRMWARE failed"); + return; + } + isp->isp_reqidx = 0; + isp->isp_residx = 0; + + /* + * Wait up to 3 seconds for FW to go to READY state. + * + * This is all very much not right. The problem here + * is that the cable may not be plugged in, or there + * may be many many members of the loop that haven't + * been logged into. + * + * This model of doing things doesn't support dynamic + * attachment, so we just plain lose (for now). + */ + for (count = 0; count < 3000; count++) { + isp_fw_state(isp); + if (fcp->isp_fwstate == FW_READY) + break; + delay(1000); /* wait one millisecond */ + } + +isp->isp_sendmarker = 1; + + (void) splx(s); + isp->isp_state = ISP_INITSTATE; +} + /* * Complete attachment of Hardware, include subdevices. */ @@ -496,14 +706,53 @@ void isp_attach(isp) struct ispsoftc *isp; { + /* + * Start the watchdog timer. + */ + timeout(isp_watch, isp, WATCHI); + + /* + * And complete initialization + */ isp->isp_state = ISP_RUNSTATE; isp->isp_link.channel = SCSI_CHANNEL_ONLY_ONE; isp->isp_link.adapter_softc = isp; - isp->isp_link.adapter_target = isp->isp_initiator_id; - isp->isp_link.adapter = &isp_switch; isp->isp_link.device = &isp_dev; - isp->isp_link.openings = RQUEST_QUEUE_LEN / (MAX_TARGETS - 1); - isp->isp_link.max_target = MAX_TARGETS-1; + isp->isp_link.adapter = &isp_switch; + + if (isp->isp_type & ISP_HA_FC) { + fcparam *fcp = isp->isp_param; + mbreg_t mbs; + int s; + + isp->isp_link.max_target = MAX_FC_TARG-1; +#if 0 + isp->isp_link.openings = RQUEST_QUEUE_LEN(isp)/(MAX_FC_TARG-1); +#else + isp->isp_link.openings = 8; +#endif + s = splbio(); + mbs.param[0] = MBOX_GET_LOOP_ID; + isp_mboxcmd(isp, &mbs); + (void) splx(s); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "GET LOOP ID failed"); + return; + } + fcp->isp_loopid = mbs.param[1]; + if (fcp->isp_loopid) { + printf("%s: Loop ID 0x%x\n", isp->isp_name, + fcp->isp_loopid); + } + isp->isp_link.adapter_target = 0xff; + } else { + isp->isp_link.openings = RQUEST_QUEUE_LEN(isp)/(MAX_TARGETS-1); + isp->isp_link.max_target = MAX_TARGETS-1; + isp->isp_link.adapter_target = + ((sdparam *)isp->isp_param)->isp_initiator_id; + } + if (isp->isp_link.openings < 2) + isp->isp_link.openings = 2; config_found((void *)isp, &isp->isp_link, scsiprint); } @@ -515,10 +764,15 @@ void isp_uninit(isp) struct ispsoftc *isp; { + untimeout(isp_watch, isp); } /* * minphys our xfers + * + * Unfortunately, the buffer pointer describes the target device- not the + * adapter device, so we can't use the pointer to find out what kind of + * adapter we are and adjust accordingly. */ static void @@ -529,7 +783,7 @@ ispminphys(bp) * XX: Only the 1020 has a 24 bit limit. */ if (bp->b_bcount >= (1 << 24)) { - bp->b_bcount = (1 << 24) - 1; + bp->b_bcount = (1 << 24); } minphys(bp); } @@ -543,16 +797,37 @@ ispscsicmd(xs) { struct ispsoftc *isp; u_int8_t iptr, optr; - ispreq_t *req; + union { + ispreq_t *_reqp; + ispreqt2_t *_t2reqp; + } _u; +#define reqp _u._reqp +#define t2reqp _u._t2reqp int s, i; isp = xs->sc_link->adapter_softc; + if (isp->isp_type & ISP_HA_FC) { +#if 0 + printf("%s: not doing FC now\n", isp->isp_name); + xs->error = XS_SELTIMEOUT; + xs->flags |= ITSDONE; + return (COMPLETE); +#endif + if (xs->cmdlen > 12) { + printf("%s: unsupported cdb for fibre (%d)\n", + isp->isp_name, xs->cmdlen); + xs->error = XS_DRIVER_STUFFUP; + return (COMPLETE); + } +if (isp->isp_type & ISP_HA_FC) + DISABLE_INTS(isp); + } optr = ISP_READ(isp, OUTMAILBOX4); iptr = isp->isp_reqidx; - req = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1); + reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); + iptr = (iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1); if (iptr == optr) { printf("%s: Request Queue Overflow\n", isp->isp_name); xs->error = XS_DRIVER_STUFFUP; @@ -560,8 +835,10 @@ ispscsicmd(xs) } s = splbio(); +if (isp->isp_type & ISP_HA_FC) + DISABLE_INTS(isp); if (isp->isp_sendmarker) { - ipsmarkreq_t *marker = (ipsmarkreq_t *) req; + ispmarkreq_t *marker = (ispmarkreq_t *) reqp; bzero((void *) marker, sizeof (*marker)); marker->req_header.rqs_entry_count = 1; @@ -570,52 +847,83 @@ ispscsicmd(xs) isp->isp_sendmarker = 0; - if (((iptr + 1) & (RQUEST_QUEUE_LEN - 1)) == optr) { + if (((iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1)) == optr) { ISP_WRITE(isp, INMAILBOX4, iptr); isp->isp_reqidx = iptr; +if (isp->isp_type & ISP_HA_FC) + ENABLE_INTS(isp); (void) splx(s); printf("%s: Request Queue Overflow+\n", isp->isp_name); xs->error = XS_DRIVER_STUFFUP; return (TRY_AGAIN_LATER); } - req = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = (iptr + 1) & (RQUEST_QUEUE_LEN - 1); + reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); + iptr = (iptr + 1) & (RQUEST_QUEUE_LEN(isp) - 1); } + bzero((void *) reqp, sizeof (_u)); + reqp->req_header.rqs_entry_count = 1; + if (isp->isp_type & ISP_HA_FC) { + reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS; + } else { + reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST; + } + reqp->req_header.rqs_flags = 0; + reqp->req_header.rqs_seqno = isp->isp_seqno++; - bzero((void *) req, sizeof (*req)); - req->req_header.rqs_entry_count = 1; - req->req_header.rqs_entry_type = RQSTYPE_REQUEST; - req->req_header.rqs_flags = 0; - req->req_header.rqs_seqno = isp->isp_seqno++; - - for (i = 0; i < RQUEST_QUEUE_LEN; i++) { + for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) { if (isp->isp_xflist[i] == NULL) break; } - if (i == RQUEST_QUEUE_LEN) { + if (i == RQUEST_QUEUE_LEN(isp)) { panic("%s: ran out of xflist pointers\n", isp->isp_name); /* NOTREACHED */ } else { + /* + * Never have a handle that is zero, so + * set req_handle off by one. + */ isp->isp_xflist[i] = xs; - req->req_handle = i; + reqp->req_handle = i+1; } - req->req_flags = 0; - req->req_lun_trn = xs->sc_link->lun; - req->req_target = xs->sc_link->target; - req->req_cdblen = xs->cmdlen; - bcopy((void *)xs->cmd, req->req_cdb, xs->cmdlen); + if (isp->isp_type & ISP_HA_FC) { + /* + * See comment in isp_intr + */ + xs->resid = 0; + /* + * The QL2100 always requires some kind of tag. + */ + if (xs->flags & SCSI_POLL) { + t2reqp->req_flags = REQFLAG_STAG; + } else { + t2reqp->req_flags = REQFLAG_OTAG; + } + } else { + if (xs->flags & SCSI_POLL) { + reqp->req_flags = 0; + } else { + reqp->req_flags = REQFLAG_OTAG; + } + } + reqp->req_lun_trn = xs->sc_link->lun; + reqp->req_target = xs->sc_link->target; + if (isp->isp_type & ISP_HA_SCSI) { + reqp->req_cdblen = xs->cmdlen; + } + bcopy((void *)xs->cmd, reqp->req_cdb, xs->cmdlen); -#if 0 - printf("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name, + IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name, xs->sc_link->target, xs->sc_link->lun, - req->req_header.rqs_seqno, *(u_char *) xs->cmd, xs->datalen); -#endif - - req->req_time = xs->timeout / 1000; - req->req_seg_count = 0; - if (ISP_DMASETUP(isp, xs, req, &iptr, optr)) { + reqp->req_header.rqs_seqno, *(u_char *) xs->cmd, xs->datalen)); + + reqp->req_time = xs->timeout / 1000; + if (reqp->req_time == 0 && xs->timeout) + reqp->req_time = 1; + if (ISP_DMASETUP(isp, xs, reqp, &iptr, optr)) { +if (isp->isp_type & ISP_HA_FC) + ENABLE_INTS(isp); (void) splx(s); xs->error = XS_DRIVER_STUFFUP; return (COMPLETE); @@ -623,6 +931,8 @@ ispscsicmd(xs) xs->error = 0; ISP_WRITE(isp, INMAILBOX4, iptr); isp->isp_reqidx = iptr; +if (isp->isp_type & ISP_HA_FC) + ENABLE_INTS(isp); (void) splx(s); if ((xs->flags & SCSI_POLL) == 0) { return (SUCCESSFULLY_QUEUED); @@ -643,11 +953,13 @@ ispscsicmd(xs) * something bad happened. */ if ((xs->flags & ITSDONE) == 0 && xs->error == XS_NOERROR) { - isp_lostcmd(isp, xs); + isp_lostcmd(isp, xs, reqp); xs->error = XS_DRIVER_STUFFUP; } } return (COMPLETE); +#undef reqp +#undef t2reqp } /* @@ -683,21 +995,25 @@ isp_intr(arg) u_int16_t iptr, optr, isr; isr = ISP_READ(isp, BIU_ISR); - if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) { -#if 0 - if (isr) { - printf("%s: isp_intr isr=%x\n", isp->isp_name, isr); + if (isp->isp_type & ISP_HA_FC) { + if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) { + if (isr) { + IDPRINTF(3, ("%s: isp_intr isr=%x\n", + isp->isp_name, isr)); + } + return (0); + } + } else { + if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) { + if (isr) { + IDPRINTF(3, ("%s: isp_intr isr=%x\n", + isp->isp_name, isr)); + } + return (0); } -#endif - return (0); } optr = isp->isp_residx; - iptr = ISP_READ(isp, OUTMAILBOX5); - ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); - ISP_WRITE(isp, BIU_ICR, - BIU_ICR_ENABLE_RISC_INT | BIU_ICR_ENABLE_ALL_INTS); - if (ISP_READ(isp, BIU_SEMA) & 1) { u_int16_t mbox0 = ISP_READ(isp, OUTMAILBOX0); switch (mbox0) { @@ -706,27 +1022,37 @@ isp_intr(arg) printf("%s: bus or timeout reset\n", isp->isp_name); isp->isp_sendmarker = 1; break; + case ASYNC_LIP_OCCURRED: + printf("%s: LIP occurred\n", isp->isp_name); + break; + case ASYNC_LOOP_UP: + printf("%s: Loop UP\n", isp->isp_name); + break; + case ASYNC_LOOP_DOWN: + printf("%s: Loop DOWN\n", isp->isp_name); + break; default: printf("%s: async %x\n", isp->isp_name, mbox0); break; } ISP_WRITE(isp, BIU_SEMA, 0); -#if 0 - } else { - if (optr == iptr) { - printf("why'd we interrupt? isr %x iptr %x optr %x\n", - isr, optr, iptr); - } -#endif } + ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); + iptr = ISP_READ(isp, OUTMAILBOX5); + if (optr == iptr) { + IDPRINTF(3, ("why intr? isr %x iptr %x optr %x\n", + isr, optr, iptr)); + } + ENABLE_INTS(isp); + while (optr != iptr) { ispstatusreq_t *sp; int buddaboom = 0; sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); - optr = (optr + 1) & (RESULT_QUEUE_LEN-1); + optr = (optr + 1) & (RESULT_QUEUE_LEN(isp)-1); if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { printf("%s: not RESPONSE in RESPONSE Queue (0x%x)\n", isp->isp_name, sp->req_header.rqs_entry_type); @@ -745,61 +1071,78 @@ isp_intr(arg) printf("%s: rqs_flags=%x\n", isp->isp_name, sp->req_header.rqs_flags & 0xf); } - if (sp->req_handle >= RQUEST_QUEUE_LEN) { + if (sp->req_handle > RQUEST_QUEUE_LEN(isp) || + sp->req_handle < 1) { printf("%s: bad request handle %d\n", isp->isp_name, sp->req_handle); ISP_WRITE(isp, INMAILBOX5, optr); continue; } - xs = (struct scsi_xfer *) isp->isp_xflist[sp->req_handle]; + xs = (struct scsi_xfer *) isp->isp_xflist[sp->req_handle - 1]; if (xs == NULL) { printf("%s: NULL xs in xflist\n", isp->isp_name); ISP_WRITE(isp, INMAILBOX5, optr); continue; } - isp->isp_xflist[sp->req_handle] = NULL; + isp->isp_xflist[sp->req_handle - 1] = NULL; if (sp->req_status_flags & RQSTF_BUS_RESET) { isp->isp_sendmarker = 1; } if (buddaboom) { xs->error = XS_DRIVER_STUFFUP; } - if (sp->req_state_flags & RQSF_GOT_SENSE) { - bcopy(sp->req_sense_data, &xs->sense, - sizeof (xs->sense)); - xs->error = XS_SENSE; + xs->status = sp->req_scsi_status & 0xff; + if (isp->isp_type & ISP_HA_SCSI) { + if (sp->req_state_flags & RQSF_GOT_SENSE) { + bcopy(sp->req_sense_data, &xs->sense, + sizeof (xs->sense)); + xs->error = XS_SENSE; + } + } else { + if (xs->status == SCSI_CHECK) { + xs->error = XS_SENSE; + bcopy(sp->req_sense_data, &xs->sense, + sizeof (xs->sense)); + sp->req_state_flags |= RQSF_GOT_SENSE; + } } - xs->status = sp->req_scsi_status; - if (xs->error == 0 && xs->status == SCSI_BUSY) + if (xs->error == 0 && xs->status == SCSI_BUSY) { xs->error = XS_BUSY; + } if (sp->req_header.rqs_entry_type == RQSTYPE_RESPONSE) { - if (xs->error == 0) - xs->error = isp_parse_status(isp, sp); + if (xs->error == 0 && sp->req_completion_status) + xs->error = isp_parse_status(isp, sp, xs); } else { printf("%s: unknown return %x\n", isp->isp_name, sp->req_header.rqs_entry_type); if (xs->error == 0) xs->error = XS_DRIVER_STUFFUP; } - xs->resid = sp->req_resid; + if (isp->isp_type & ISP_HA_SCSI) { + xs->resid = sp->req_resid; + } else if (sp->req_scsi_status & RQCS_RU) { + xs->resid = sp->req_resid; + IDPRINTF(3, ("%s: cnt %d rsd %d\n", isp->isp_name, + xs->datalen, sp->req_resid)); + } xs->flags |= ITSDONE; if (xs->datalen) { - ISP_DMAFREE(isp, xs, sp->req_handle); + ISP_DMAFREE(isp, xs, sp->req_handle - 1); } -#if 0 - printf("%s(%d.%d): FINISH%d cmd 0x%x resid %d STS %x", - isp->isp_name, xs->sc_link->target, xs->sc_link->lun, - sp->req_header.rqs_seqno, *(u_char *) xs->cmd, - xs->resid, xs->status); - if (sp->req_state_flags & RQSF_GOT_SENSE) { - printf(" Skey: %x", xs->sense.flags); - if (xs->error != XS_SENSE) { - printf(" BUT NOT SET"); + if (isp->isp_dblev >= 5) { + printf("%s(%d.%d): FINISH%d cmd 0x%x resid %d STS %x", + isp->isp_name, xs->sc_link->target, + xs->sc_link->lun, sp->req_header.rqs_seqno, + *(u_char *) xs->cmd, xs->resid, xs->status); + if (sp->req_state_flags & RQSF_GOT_SENSE) { + printf(" Skey: %x", xs->sense.flags); + if (xs->error != XS_SENSE) { + printf(" BUT NOT SET"); + } } + printf(" xs->error %d\n", xs->error); } - printf(" xs->error %d\n", xs->error); -#endif ISP_WRITE(isp, INMAILBOX5, optr); scsi_done(xs); } @@ -812,14 +1155,16 @@ isp_intr(arg) */ static int -isp_parse_status(isp, sp) +isp_parse_status(isp, sp, xs) struct ispsoftc *isp; ispstatusreq_t *sp; + struct scsi_xfer *xs; { switch (sp->req_completion_status) { case RQCS_COMPLETE: return (XS_NOERROR); break; + case RQCS_INCOMPLETE: if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) { return (XS_SELTIMEOUT); @@ -827,18 +1172,54 @@ isp_parse_status(isp, sp) printf("%s: incomplete, state %x\n", isp->isp_name, sp->req_state_flags); break; + case RQCS_DATA_OVERRUN: + if (isp->isp_type & ISP_HA_FC) { + xs->resid = sp->req_resid; + break; + } + return (XS_NOERROR); + case RQCS_DATA_UNDERRUN: + if (isp->isp_type & ISP_HA_FC) { + xs->resid = sp->req_resid; + break; + } return (XS_NOERROR); + case RQCS_TIMEOUT: return (XS_TIMEOUT); + case RQCS_RESET_OCCURRED: printf("%s: reset occurred\n", isp->isp_name); isp->isp_sendmarker = 1; break; + case RQCS_ABORTED: printf("%s: command aborted\n", isp->isp_name); isp->isp_sendmarker = 1; break; + + case RQCS_PORT_UNAVAILABLE: + /* + * No such port on the loop. Moral equivalent of SELTIMEO + */ + return (XS_SELTIMEOUT); + + case RQCS_PORT_LOGGED_OUT: + printf("%s: port logout for target %d\n", + isp->isp_name, xs->sc_link->target); + break; + + case RQCS_PORT_CHANGED: + printf("%s: port changed for target %d\n", + isp->isp_name, xs->sc_link->target); + break; + + case RQCS_PORT_BUSY: + printf("%s: port busy for target %d\n", + isp->isp_name, xs->sc_link->target); + return (XS_BUSY); + default: printf("%s: comp status %x\n", isp->isp_name, sp->req_completion_status); @@ -851,97 +1232,194 @@ isp_parse_status(isp, sp) #define LONIB(x) ((x) & 0xf) #define MAKNIB(a, b) (((a) << 4) | (b)) static u_int8_t mbpcnt[] = { - MAKNIB(1, 1), /* MBOX_NO_OP */ - MAKNIB(5, 5), /* MBOX_LOAD_RAM */ - MAKNIB(2, 0), /* MBOX_EXEC_FIRMWARE */ - MAKNIB(5, 5), /* MBOX_DUMP_RAM */ - MAKNIB(3, 3), /* MBOX_WRITE_RAM_WORD */ - MAKNIB(2, 3), /* MBOX_READ_RAM_WORD */ - MAKNIB(6, 6), /* MBOX_MAILBOX_REG_TEST */ - MAKNIB(2, 3), /* MBOX_VERIFY_CHECKSUM */ - MAKNIB(1, 3), /* MBOX_ABOUT_FIRMWARE */ - MAKNIB(0, 0), /* 0x0009 */ - MAKNIB(0, 0), /* 0x000a */ - MAKNIB(0, 0), /* 0x000b */ - MAKNIB(0, 0), /* 0x000c */ - MAKNIB(0, 0), /* 0x000d */ - MAKNIB(1, 2), /* MBOX_CHECK_FIRMWARE */ - MAKNIB(0, 0), /* 0x000f */ - MAKNIB(5, 5), /* MBOX_INIT_REQ_QUEUE */ - MAKNIB(6, 6), /* MBOX_INIT_RES_QUEUE */ - MAKNIB(4, 4), /* MBOX_EXECUTE_IOCB */ - MAKNIB(2, 2), /* MBOX_WAKE_UP */ - MAKNIB(1, 6), /* MBOX_STOP_FIRMWARE */ - MAKNIB(4, 4), /* MBOX_ABORT */ - MAKNIB(2, 2), /* MBOX_ABORT_DEVICE */ - MAKNIB(3, 3), /* MBOX_ABORT_TARGET */ - MAKNIB(2, 2), /* MBOX_BUS_RESET */ - MAKNIB(2, 3), /* MBOX_STOP_QUEUE */ - MAKNIB(2, 3), /* MBOX_START_QUEUE */ - MAKNIB(2, 3), /* MBOX_SINGLE_STEP_QUEUE */ - MAKNIB(2, 3), /* MBOX_ABORT_QUEUE */ - MAKNIB(2, 4), /* MBOX_GET_DEV_QUEUE_STATUS */ - MAKNIB(0, 0), /* 0x001e */ - MAKNIB(1, 3), /* MBOX_GET_FIRMWARE_STATUS */ - MAKNIB(1, 2), /* MBOX_GET_INIT_SCSI_ID */ - MAKNIB(1, 2), /* MBOX_GET_SELECT_TIMEOUT */ - MAKNIB(1, 3), /* MBOX_GET_RETRY_COUNT */ - MAKNIB(1, 2), /* MBOX_GET_TAG_AGE_LIMIT */ - MAKNIB(1, 2), /* MBOX_GET_CLOCK_RATE */ - MAKNIB(1, 2), /* MBOX_GET_ACT_NEG_STATE */ - MAKNIB(1, 2), /* MBOX_GET_ASYNC_DATA_SETUP_TIME */ - MAKNIB(1, 3), /* MBOX_GET_PCI_PARAMS */ - MAKNIB(2, 4), /* MBOX_GET_TARGET_PARAMS */ - MAKNIB(2, 4), /* MBOX_GET_DEV_QUEUE_PARAMS */ - MAKNIB(0, 0), /* 0x002a */ - MAKNIB(0, 0), /* 0x002b */ - MAKNIB(0, 0), /* 0x002c */ - MAKNIB(0, 0), /* 0x002d */ - MAKNIB(0, 0), /* 0x002e */ - MAKNIB(0, 0), /* 0x002f */ - MAKNIB(2, 2), /* MBOX_SET_INIT_SCSI_ID */ - MAKNIB(2, 2), /* MBOX_SET_SELECT_TIMEOUT */ - MAKNIB(3, 3), /* MBOX_SET_RETRY_COUNT */ - MAKNIB(2, 2), /* MBOX_SET_TAG_AGE_LIMIT */ - MAKNIB(2, 2), /* MBOX_SET_CLOCK_RATE */ - MAKNIB(2, 2), /* MBOX_SET_ACTIVE_NEG_STATE */ - MAKNIB(2, 2), /* MBOX_SET_ASYNC_DATA_SETUP_TIME */ - MAKNIB(3, 3), /* MBOX_SET_PCI_CONTROL_PARAMS */ - MAKNIB(4, 4), /* MBOX_SET_TARGET_PARAMS */ - MAKNIB(4, 4), /* MBOX_SET_DEV_QUEUE_PARAMS */ - MAKNIB(0, 0), /* 0x003a */ - MAKNIB(0, 0), /* 0x003b */ - MAKNIB(0, 0), /* 0x003c */ - MAKNIB(0, 0), /* 0x003d */ - MAKNIB(0, 0), /* 0x003e */ - MAKNIB(0, 0), /* 0x003f */ - MAKNIB(1, 2), /* MBOX_RETURN_BIOS_BLOCK_ADDR */ - MAKNIB(6, 1), /* MBOX_WRITE_FOUR_RAM_WORDS */ - MAKNIB(2, 3) /* MBOX_EXEC_BIOS_IOCB */ + MAKNIB(1, 1), /* 0x00: MBOX_NO_OP */ + MAKNIB(5, 5), /* 0x01: MBOX_LOAD_RAM */ + MAKNIB(2, 0), /* 0x02: MBOX_EXEC_FIRMWARE */ + MAKNIB(5, 5), /* 0x03: MBOX_DUMP_RAM */ + MAKNIB(3, 3), /* 0x04: MBOX_WRITE_RAM_WORD */ + MAKNIB(2, 3), /* 0x05: MBOX_READ_RAM_WORD */ + MAKNIB(6, 6), /* 0x06: MBOX_MAILBOX_REG_TEST */ + MAKNIB(2, 3), /* 0x07: MBOX_VERIFY_CHECKSUM */ + MAKNIB(1, 3), /* 0x08: MBOX_ABOUT_FIRMWARE */ + MAKNIB(0, 0), /* 0x09: */ + MAKNIB(0, 0), /* 0x0a: */ + MAKNIB(0, 0), /* 0x0b: */ + MAKNIB(0, 0), /* 0x0c: */ + MAKNIB(0, 0), /* 0x0d: */ + MAKNIB(1, 2), /* 0x0e: MBOX_CHECK_FIRMWARE */ + MAKNIB(0, 0), /* 0x0f: */ + MAKNIB(5, 5), /* 0x10: MBOX_INIT_REQ_QUEUE */ + MAKNIB(6, 6), /* 0x11: MBOX_INIT_RES_QUEUE */ + MAKNIB(4, 4), /* 0x12: MBOX_EXECUTE_IOCB */ + MAKNIB(2, 2), /* 0x13: MBOX_WAKE_UP */ + MAKNIB(1, 6), /* 0x14: MBOX_STOP_FIRMWARE */ + MAKNIB(4, 4), /* 0x15: MBOX_ABORT */ + MAKNIB(2, 2), /* 0x16: MBOX_ABORT_DEVICE */ + MAKNIB(3, 3), /* 0x17: MBOX_ABORT_TARGET */ + MAKNIB(2, 2), /* 0x18: MBOX_BUS_RESET */ + MAKNIB(2, 3), /* 0x19: MBOX_STOP_QUEUE */ + MAKNIB(2, 3), /* 0x1a: MBOX_START_QUEUE */ + MAKNIB(2, 3), /* 0x1b: MBOX_SINGLE_STEP_QUEUE */ + MAKNIB(2, 3), /* 0x1c: MBOX_ABORT_QUEUE */ + MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ + MAKNIB(0, 0), /* 0x1e: */ + MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ + MAKNIB(1, 2), /* 0x20: MBOX_GET_INIT_SCSI_ID */ + MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ + MAKNIB(1, 3), /* 0x22: MBOX_GET_RETRY_COUNT */ + MAKNIB(1, 2), /* 0x23: MBOX_GET_TAG_AGE_LIMIT */ + MAKNIB(1, 2), /* 0x24: MBOX_GET_CLOCK_RATE */ + MAKNIB(1, 2), /* 0x25: MBOX_GET_ACT_NEG_STATE */ + MAKNIB(1, 2), /* 0x26: MBOX_GET_ASYNC_DATA_SETUP_TIME */ + MAKNIB(1, 3), /* 0x27: MBOX_GET_PCI_PARAMS */ + MAKNIB(2, 4), /* 0x28: MBOX_GET_TARGET_PARAMS */ + MAKNIB(2, 4), /* 0x29: MBOX_GET_DEV_QUEUE_PARAMS */ + MAKNIB(0, 0), /* 0x2a: */ + MAKNIB(0, 0), /* 0x2b: */ + MAKNIB(0, 0), /* 0x2c: */ + MAKNIB(0, 0), /* 0x2d: */ + MAKNIB(0, 0), /* 0x2e: */ + MAKNIB(0, 0), /* 0x2f: */ + MAKNIB(2, 2), /* 0x30: MBOX_SET_INIT_SCSI_ID */ + MAKNIB(2, 2), /* 0x31: MBOX_SET_SELECT_TIMEOUT */ + MAKNIB(3, 3), /* 0x32: MBOX_SET_RETRY_COUNT */ + MAKNIB(2, 2), /* 0x33: MBOX_SET_TAG_AGE_LIMIT */ + MAKNIB(2, 2), /* 0x34: MBOX_SET_CLOCK_RATE */ + MAKNIB(2, 2), /* 0x35: MBOX_SET_ACTIVE_NEG_STATE */ + MAKNIB(2, 2), /* 0x36: MBOX_SET_ASYNC_DATA_SETUP_TIME */ + MAKNIB(3, 3), /* 0x37: MBOX_SET_PCI_CONTROL_PARAMS */ + MAKNIB(4, 4), /* 0x38: MBOX_SET_TARGET_PARAMS */ + MAKNIB(4, 4), /* 0x39: MBOX_SET_DEV_QUEUE_PARAMS */ + MAKNIB(0, 0), /* 0x3a: */ + MAKNIB(0, 0), /* 0x3b: */ + MAKNIB(0, 0), /* 0x3c: */ + MAKNIB(0, 0), /* 0x3d: */ + MAKNIB(0, 0), /* 0x3e: */ + MAKNIB(0, 0), /* 0x3f: */ + MAKNIB(1, 2), /* 0x40: MBOX_RETURN_BIOS_BLOCK_ADDR */ + MAKNIB(6, 1), /* 0x41: MBOX_WRITE_FOUR_RAM_WORDS */ + MAKNIB(2, 3), /* 0x42: MBOX_EXEC_BIOS_IOCB */ + MAKNIB(0, 0), /* 0x43: */ + MAKNIB(0, 0), /* 0x44: */ + MAKNIB(0, 0), /* 0x45: */ + MAKNIB(0, 0), /* 0x46: */ + MAKNIB(0, 0), /* 0x47: */ + MAKNIB(0, 0), /* 0x48: */ + MAKNIB(0, 0), /* 0x49: */ + MAKNIB(0, 0), /* 0x4a: */ + MAKNIB(0, 0), /* 0x4b: */ + MAKNIB(0, 0), /* 0x4c: */ + MAKNIB(0, 0), /* 0x4d: */ + MAKNIB(0, 0), /* 0x4e: */ + MAKNIB(0, 0), /* 0x4f: */ + MAKNIB(0, 0), /* 0x50: */ + MAKNIB(0, 0), /* 0x51: */ + MAKNIB(0, 0), /* 0x52: */ + MAKNIB(0, 0), /* 0x53: */ + MAKNIB(8, 0), /* 0x54: MBOX_EXEC_COMMAND_IOCB_A64 */ + MAKNIB(0, 0), /* 0x55: */ + MAKNIB(0, 0), /* 0x56: */ + MAKNIB(0, 0), /* 0x57: */ + MAKNIB(0, 0), /* 0x58: */ + MAKNIB(0, 0), /* 0x59: */ + MAKNIB(0, 0), /* 0x5a: */ + MAKNIB(0, 0), /* 0x5b: */ + MAKNIB(0, 0), /* 0x5c: */ + MAKNIB(0, 0), /* 0x5d: */ + MAKNIB(0, 0), /* 0x5e: */ + MAKNIB(0, 0), /* 0x5f: */ +#ifdef USE_SUN_FW + MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */ + MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */ + MAKNIB(2, 1), /* 0x62: MBOX_INIT_LIP */ + MAKNIB(8, 1), /* 0x63: MBOX_GET_FC_AL_POSITION_MAP */ + MAKNIB(8, 1), /* 0x64: MBOX_GET_PORT_DB */ + MAKNIB(3, 1), /* 0x65: MBOX_CLEAR_ACA */ + MAKNIB(3, 1), /* 0x66: MBOX_TARGET_RESET */ + MAKNIB(3, 1), /* 0x67: MBOX_CLEAR_TASK_SET */ + MAKNIB(3, 1), /* 0x69: MBOX_ABORT_TASK_SET */ +#else + MAKNIB(0, 0), /* 0x60: */ + MAKNIB(0, 0), /* 0x61: */ + MAKNIB(0, 0), /* 0x62: */ + MAKNIB(0, 0), /* 0x63: */ + MAKNIB(0, 0), /* 0x64: */ + MAKNIB(0, 0), /* 0x65: */ + MAKNIB(0, 0), /* 0x66: */ + MAKNIB(0, 0), /* 0x67: */ + MAKNIB(0, 0), /* 0x68: */ +#endif + MAKNIB(1, 2), /* 0x69: MBOX_GET_FIRMWARE_STATE */ + MAKNIB(0, 0), /* 0x6a: */ + MAKNIB(0, 0), /* 0x6b: */ + MAKNIB(0, 0), /* 0x6c: */ + MAKNIB(0, 0), /* 0x6d: */ + MAKNIB(0, 0), /* 0x6e: */ + MAKNIB(0, 0), /* 0x6f: */ + MAKNIB(0, 0), /* 0x70: */ + MAKNIB(0, 0), /* 0x71: */ + MAKNIB(0, 0), /* 0x72: */ + MAKNIB(0, 0), /* 0x73: */ + MAKNIB(0, 0), /* 0x74: */ + MAKNIB(0, 0), /* 0x75: */ + MAKNIB(0, 0), /* 0x76: */ + MAKNIB(0, 0), /* 0x77: */ + MAKNIB(0, 0), /* 0x78: */ + MAKNIB(0, 0), /* 0x79: */ + MAKNIB(0, 0), /* 0x7a: */ + MAKNIB(0, 0), /* 0x7b: */ + MAKNIB(0, 0), /* 0x7c: */ + MAKNIB(0, 0), /* 0x7d: */ + MAKNIB(0, 0), /* 0x7e: */ +#ifdef USE_SUN_FW + MAKNIB(0, 0) /* 0x7f: */ +#else + MAKNIB(0, 0), /* 0x7f: */ + MAKNIB(8, 6), /* 0x80: MBOX_INIT_FIRMWARE */ + MAKNIB(2, 1), /* 0x81: MBOX_INIT_LIP */ + MAKNIB(8, 1), /* 0x82: MBOX_GET_FC_AL_POSITION_MAP */ + MAKNIB(8, 1), /* 0x83: MBOX_GET_PORT_DB */ + MAKNIB(2, 1), /* 0x84: MBOX_QCTRL */ + MAKNIB(2, 1), /* 0x85: MBOX_PCTRL */ + MAKNIB(3, 1), /* 0x86: MBOX_CLEAR_ACA */ + MAKNIB(3, 1), /* 0x87: MBOX_TARGET_RESET */ + MAKNIB(3, 1), /* 0x88: MBOX_CLEAR_TASK_SET */ + MAKNIB(3, 1) /* 0x89: MBOX_ABORT_TASK_SET */ +#endif }; #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0])) -static int +static void isp_mboxcmd(isp, mbp) struct ispsoftc *isp; mbreg_t *mbp; { int outparam, inparam; int loops; - - if (mbp->param[0] > NMBCOM) { + u_int8_t opcode; + + if (mbp->param[0] == ISP2100_SET_PCI_PARAM) { + opcode = mbp->param[0] = MBOX_SET_PCI_PARAMETERS; + inparam = 4; + outparam = 4; + goto command_known; + } else if (mbp->param[0] > NMBCOM) { printf("%s: bad command %x\n", isp->isp_name, mbp->param[0]); - return (-1); + return; } + opcode = mbp->param[0]; inparam = HINIB(mbpcnt[mbp->param[0]]); outparam = LONIB(mbpcnt[mbp->param[0]]); + if (inparam == 0 && outparam == 0) { printf("%s: no parameters for %x\n", isp->isp_name, mbp->param[0]); - return (-1); + return; } + +command_known: /* * Make sure we can send some words.. */ @@ -951,7 +1429,7 @@ isp_mboxcmd(isp, mbp) delay(100); if (--loops < 0) { printf("%s: isp_mboxcmd timeout #1\n", isp->isp_name); - return (-1); + return; } } @@ -959,6 +1437,8 @@ isp_mboxcmd(isp, mbp) * Write input parameters */ switch (inparam) { + case 8: ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); mbp->param[7] = 0; + case 7: ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); mbp->param[6] = 0; case 6: ISP_WRITE(isp, INMAILBOX5, mbp->param[5]); mbp->param[5] = 0; case 5: ISP_WRITE(isp, INMAILBOX4, mbp->param[4]); mbp->param[4] = 0; case 4: ISP_WRITE(isp, INMAILBOX3, mbp->param[3]); mbp->param[3] = 0; @@ -983,14 +1463,17 @@ isp_mboxcmd(isp, mbp) ISP_WRITE(isp, HCCR, HCCR_CMD_SET_HOST_INT); /* - * Wait until RISC int is set + * Wait until RISC int is set, except 2100 */ - loops = MBOX_DELAY_COUNT; - while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) { - delay(100); - if (--loops < 0) { - printf("%s: isp_mboxcmd timeout #2\n", isp->isp_name); - return (-1); + if ((isp->isp_type & ISP_HA_FC) == 0) { + loops = MBOX_DELAY_COUNT; + while ((ISP_READ(isp, BIU_ISR) & BIU_ISR_RISC_INT) == 0) { + delay(100); + if (--loops < 0) { + printf("%s: isp_mboxcmd timeout #2\n", + isp->isp_name); + return; + } } } @@ -1002,7 +1485,7 @@ isp_mboxcmd(isp, mbp) delay(100); if (--loops < 0) { printf("%s: isp_mboxcmd timeout #3\n", isp->isp_name); - return (-1); + return; } } @@ -1014,7 +1497,7 @@ isp_mboxcmd(isp, mbp) delay(100); if (--loops < 0) { printf("%s: isp_mboxcmd timeout #4\n", isp->isp_name); - return (-1); + return; } } @@ -1023,6 +1506,8 @@ isp_mboxcmd(isp, mbp) * Pick up output parameters. */ switch (outparam) { + case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7); + case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6); case 6: mbp->param[5] = ISP_READ(isp, OUTMAILBOX5); case 5: mbp->param[4] = ISP_READ(isp, OUTMAILBOX4); case 4: mbp->param[3] = ISP_READ(isp, OUTMAILBOX3); @@ -1040,33 +1525,368 @@ isp_mboxcmd(isp, mbp) * Release semaphore on mailbox registers */ ISP_WRITE(isp, BIU_SEMA, 0); - return (0); + + /* + * Just to be chatty here... + */ + switch(mbp->param[0]) { + case MBOX_COMMAND_COMPLETE: + break; + case MBOX_INVALID_COMMAND: + /* + * GET_CLOCK_RATE can fail a lot + * So can a couple of other commands. + */ + if (isp->isp_dblev > 1 && opcode != MBOX_GET_CLOCK_RATE) { + printf("%s: mbox cmd %x failed with INVALID_COMMAND\n", + isp->isp_name, opcode); + } + break; + case MBOX_HOST_INTERFACE_ERROR: + printf("%s: mbox cmd %x failed with HOST_INTERFACE_ERROR\n", + isp->isp_name, opcode); + break; + case MBOX_TEST_FAILED: + printf("%s: mbox cmd %x failed with TEST_FAILED\n", + isp->isp_name, opcode); + break; + case MBOX_COMMAND_ERROR: + printf("%s: mbox cmd %x failed with COMMAND_ERROR\n", + isp->isp_name, opcode); + break; + case MBOX_COMMAND_PARAM_ERROR: + printf("%s: mbox cmd %x failed with COMMAND_PARAM_ERROR\n", + isp->isp_name, opcode); + break; + + case ASYNC_LIP_OCCURRED: + break; + + default: + /* + * The expected return of EXEC_FIRMWARE is zero. + */ + if ((opcode == MBOX_EXEC_FIRMWARE && mbp->param[0] != 0) || + (opcode != MBOX_EXEC_FIRMWARE)) { + printf("%s: mbox cmd %x failed with error %x\n", + isp->isp_name, opcode, mbp->param[0]); + } + break; + } } static void -isp_lostcmd(struct ispsoftc *isp, struct scsi_xfer *xs) +isp_lostcmd(struct ispsoftc *isp, struct scsi_xfer *xs, ispreq_t *req) { mbreg_t mbs; - mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; - (void) isp_mboxcmd(isp, &mbs); + mbs.param[0] = MBOX_GET_FIRMWARE_STATUS; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: couldn't GET FIRMWARE STATUS\n", isp->isp_name); + isp_dumpregs(isp, "couldn't GET FIRMWARE STATUS"); return; } - printf("%s: lost command, %d commands active of total %d\n", - isp->isp_name, mbs.param[1], mbs.param[2]); + if (mbs.param[1]) { + printf("%s: %d commands on completion queue\n", + isp->isp_name, mbs.param[1]); + } if (xs == NULL || xs->sc_link == NULL) return; mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS; mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun; - (void) isp_mboxcmd(isp, &mbs); + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - printf("%s: couldn't GET DEVICE STATUS\n", isp->isp_name); + isp_dumpregs(isp, "couldn't GET DEVICE QUEUE STATUS"); + return; + } + printf("%s: lost command for target %d lun %d, %d active of %d, " + "Queue State: %x\n", isp->isp_name, xs->sc_link->target, + xs->sc_link->lun, mbs.param[2], mbs.param[3], mbs.param[1]); + + isp_dumpregs(isp, "lost command"); + /* + * XXX: Need to try and do something to recover. + */ +#if 0 + mbs.param[0] = MBOX_STOP_QUEUE; + mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "couldn't stop device queue"); + return; + } + printf("%s: tgt %d lun %d, state %x\n", isp->isp_name, + xs->sc_link->target, xs->sc_link->lun, mbs.param[2] & 0xff); + + /* + * If Queue Aborted, need to do a SendMarker + */ + if (mbs.param[1] & 0x1) + isp->isp_sendmarker = 1; + if (req == NULL) + return; + + isp->isp_sendmarker = 1; + + mbs.param[0] = MBOX_ABORT; + mbs.param[1] = (xs->sc_link->target << 8) | xs->sc_link->lun; + mbs.param[2] = (req->req_handle - 1) >> 16; + mbs.param[3] = (req->req_handle - 1) & 0xffff; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + printf("%s: couldn't abort command\n", isp->isp_name ); + mbs.param[0] = MBOX_ABORT_DEVICE; + mbs.param[1] = (xs->sc_link->target << 8) | xs->sc_link->lun; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + printf("%s: couldn't abort device\n", isp->isp_name ); + } else { + if (isp_poll(isp, xs, xs->timeout)) { + isp_lostcmd(isp, xs, NULL); + } + } + } else { + if (isp_poll(isp, xs, xs->timeout)) { + isp_lostcmd(isp, xs, NULL); + } + } + mbs.param[0] = MBOX_START_QUEUE; + mbs.param[1] = xs->sc_link->target << 8 | xs->sc_link->lun; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + isp_dumpregs(isp, "couldn't start device queue"); + } +#endif +} + +static void +isp_dumpregs(struct ispsoftc *isp, const char *msg) +{ + printf("%s: %s\n", isp->isp_name, msg); + if (isp->isp_type & ISP_HA_SCSI) + printf("\tbiu_conf1=%x", ISP_READ(isp, BIU_CONF1)); + else + printf("\tbiu_csr=%x", ISP_READ(isp, BIU2100_CSR)); + printf(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR), + ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA)); + printf("risc_hccr=%x\n", ISP_READ(isp, HCCR)); + + if (isp->isp_type & ISP_HA_SCSI) { + ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); + printf("\tcdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n", + ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS), + ISP_READ(isp, CDMA_FIFO_STS)); + printf("\tddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n", + ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS), + ISP_READ(isp, DDMA_FIFO_STS)); + printf("\tsxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n", + ISP_READ(isp, SXP_INTERRUPT), + ISP_READ(isp, SXP_GROSS_ERR), + ISP_READ(isp, SXP_PINS_CONTROL)); + ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE); + } + ISP_DUMPREGS(isp); +} + +static void +isp_fw_state(struct ispsoftc *isp) +{ + mbreg_t mbs; + if (isp->isp_type & ISP_HA_FC) { + int once = 0; + fcparam *fcp = isp->isp_param; +again: + mbs.param[0] = MBOX_GET_FW_STATE; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + if (mbs.param[0] == ASYNC_LIP_OCCURRED) { + if (!once++) { + goto again; + } + } + isp_dumpregs(isp, "GET FIRMWARE STATE failed"); + return; + } + fcp->isp_fwstate = mbs.param[1]; + } +} + +static void +isp_setdparm(struct ispsoftc *isp) +{ + int i; + mbreg_t mbs; + sdparam *sdp; + + isp->isp_fwrev = 0; + if (isp->isp_type & ISP_HA_FC) { + /* + * ROM in 2100 doesn't appear to support ABOUT_FIRMWARE + */ return; } - printf("%s: lost command, target %d lun %d, State: %x\n", - isp->isp_name, mbs.param[1] >> 8, mbs.param[1] & 0x7, - mbs.param[2] & 0xff); + + mbs.param[0] = MBOX_ABOUT_FIRMWARE; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + IDPRINTF(2, ("1st ABOUT FIRMWARE command failed")); + } else { + isp->isp_fwrev = + (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2]; + } + + + sdp = (sdparam *) isp->isp_param; + /* + * Try and get old clock rate out before we hit the + * chip over the head- but if and only if we don't + * know our desired clock rate. + */ + if (isp->isp_mdvec->dv_clock == 0) { + mbs.param[0] = MBOX_GET_CLOCK_RATE; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { + sdp->isp_clock = mbs.param[1]; + printf("%s: using board clock 0x%x\n", + isp->isp_name, sdp->isp_clock); + } + } else { + sdp->isp_clock = isp->isp_mdvec->dv_clock; + } + + mbs.param[0] = MBOX_GET_ACT_NEG_STATE; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + IDPRINTF(5, ("could not GET ACT NEG STATE")); + sdp->isp_req_ack_active_neg = 1; + sdp->isp_data_line_active_neg = 1; + } else { + sdp->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1; + sdp->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1; + } + for (i = 0; i < MAX_TARGETS; i++) { + mbs.param[0] = MBOX_GET_TARGET_PARAMS; + mbs.param[1] = i << 8; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + IDPRINTF(5, ("cannot get params for target %d", i)); + sdp->isp_devparam[i].sync_period = + ISP_10M_SYNCPARMS & 0xff; + sdp->isp_devparam[i].sync_offset = + ISP_10M_SYNCPARMS >> 8; + sdp->isp_devparam[i].dev_flags = DPARM_DEFAULT; + } else { +#if 0 + printf("%s: target %d - flags 0x%x, sync %x\n", + isp->isp_name, i, mbs.param[2], mbs.param[3]); +#endif + sdp->isp_devparam[i].dev_flags = mbs.param[2] >> 8; + /* + * The maximum period we can really see + * here is 100 (decimal), or 400 ns. + * For some unknown reason we sometimes + * get back wildass numbers from the + * boot device's paramaters. + */ + if ((mbs.param[3] & 0xff) <= 0x64) { + sdp->isp_devparam[i].sync_period = + mbs.param[3] & 0xff; + sdp->isp_devparam[i].sync_offset = + mbs.param[3] >> 8; + } + } + } + + /* + * Set Default Host Adapter Parameters + * XXX: Should try and get them out of NVRAM + */ + sdp->isp_adapter_enabled = 1; + sdp->isp_cmd_dma_burst_enable = 1; + sdp->isp_data_dma_burst_enabl = 1; + sdp->isp_fifo_threshold = 2; + sdp->isp_initiator_id = 7; + sdp->isp_async_data_setup = 6; + sdp->isp_selection_timeout = 250; + sdp->isp_max_queue_depth = 256; + sdp->isp_tag_aging = 8; + sdp->isp_bus_reset_delay = 3; + sdp->isp_retry_count = 0; + sdp->isp_retry_delay = 1; + + for (i = 0; i < MAX_TARGETS; i++) { + sdp->isp_devparam[i].exc_throttle = 16; + sdp->isp_devparam[i].dev_enable = 1; + } +} + +static void +isp_phoenix(struct ispsoftc *isp) +{ + struct scsi_xfer *tlist[MAXISPREQUEST], *xs; + int i; + + for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) { + tlist[i] = (struct scsi_xfer *) isp->isp_xflist[i]; + } + isp_reset(isp); + isp_init(isp); + isp->isp_state = ISP_RUNSTATE; + + for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) { + xs = tlist[i]; + if (xs == NULL) + continue; + xs->resid = xs->datalen; + xs->error = XS_DRIVER_STUFFUP; + xs->flags |= ITSDONE; + scsi_done(xs); + } +} + +static void +isp_watch(void *arg) +{ + int s, i; + struct ispsoftc *isp = arg; + struct scsi_xfer *xs; + + /* + * Look for completely dead commands (but not polled ones) + */ + s = splbio(); + for (i = 0; i < RQUEST_QUEUE_LEN(isp); i++) { + if ((xs = (struct scsi_xfer *) isp->isp_xflist[i]) == NULL) { + continue; + } + if (xs->flags & SCSI_POLL) + continue; + if (xs->timeout == 0) { + continue; + } + xs->timeout -= (WATCHI * 1000); + if (xs->timeout > -(2 * WATCHI * 1000)) { + continue; + } + printf("%s: commands really timed out!\n", isp->isp_name); + + isp_phoenix(isp); +#if not + { + mbreg_t mbs; + mbs.param[0] = MBOX_BUS_RESET; + mbs.param[1] = 0; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + printf("%s: bus reset failed\n", isp->isp_name); + isp_phoenix(isp); + } + isp->isp_sendmarker = 1; + } +#endif + break; + } + (void) splx(s); + timeout(isp_watch, arg, WATCHI); } |
