diff options
Diffstat (limited to 'sys/dev/ic/isp.c')
| -rw-r--r-- | sys/dev/ic/isp.c | 3009 |
1 files changed, 1715 insertions, 1294 deletions
diff --git a/sys/dev/ic/isp.c b/sys/dev/ic/isp.c index 2100541eb23..11c53052150 100644 --- a/sys/dev/ic/isp.c +++ b/sys/dev/ic/isp.c @@ -1,10 +1,9 @@ -/* $OpenBSD: isp.c,v 1.7 1999/03/26 00:34:59 mjacob Exp $ */ -/* release_03_25_99 */ +/* $OpenBSD: isp.c,v 1.8 1999/11/22 12:50:52 mjacob Exp $ */ /* * Machine and OS Independent (well, as best as possible) * code for the Qlogic ISP SCSI adapters. * - * Copyright (c) 1997, 1998 by Matthew Jacob + * Copyright (c) 1997, 1998, 1999 by Matthew Jacob * NASA/Ames Research Center * All rights reserved. * @@ -65,67 +64,42 @@ /* * Local static data */ -#ifdef ISP_TARGET_MODE -static const char tgtiqd[36] = { - 0x03, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, - 0x51, 0x4C, 0x4F, 0x47, 0x49, 0x43, 0x20, 0x20, -#ifdef __NetBSD__ - 0x4E, 0x45, 0x54, 0x42, 0x53, 0x44, 0x20, 0x20, -#else -# ifdef __FreeBSD__ - 0x46, 0x52, 0x45, 0x45, 0x42, 0x52, 0x44, 0x20, -# else -# ifdef __OpenBSD__ - 0x4F, 0x50, 0x45, 0x4E, 0x42, 0x52, 0x44, 0x20, -# else -# ifdef linux - 0x4C, 0x49, 0x4E, 0x55, 0x58, 0x20, 0x20, 0x20, -# else -# endif -# endif -# endif -#endif - 0x54, 0x41, 0x52, 0x47, 0x45, 0x54, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x31 -}; -#endif - /* * Local function prototypes. */ static int isp_parse_async __P((struct ispsoftc *, int)); static int isp_handle_other_response -__P((struct ispsoftc *, ispstatusreq_t *, u_int8_t *)); -#ifdef ISP_TARGET_MODE -static int isp_modify_lun __P((struct ispsoftc *, int, int, int)); -static void isp_notify_ack __P((struct ispsoftc *, void *)); -static void isp_handle_atio __P((struct ispsoftc *, void *)); -static void isp_handle_atio2 __P((struct ispsoftc *, void *)); -static void isp_handle_ctio __P((struct ispsoftc *, void *)); -static void isp_handle_ctio2 __P((struct ispsoftc *, void *)); -#endif +__P((struct ispsoftc *, ispstatusreq_t *, u_int16_t *)); static void isp_parse_status __P((struct ispsoftc *, ispstatusreq_t *, ISP_SCSI_XFER_T *)); -static void isp_fastpost_complete __P((struct ispsoftc *, int)); +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)); static void isp_fibre_init __P((struct ispsoftc *)); 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 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_dumpxflist __P((struct ispsoftc *)); static void isp_mboxcmd __P((struct ispsoftc *, mbreg_t *)); -static void isp_update __P((struct ispsoftc *)); -static void isp_setdfltparm __P((struct ispsoftc *)); +static void isp_update __P((struct ispsoftc *)); +static void isp_update_bus __P((struct ispsoftc *, int)); +static void isp_setdfltparm __P((struct ispsoftc *, int)); static int isp_read_nvram __P((struct ispsoftc *)); static void isp_rdnvram_word __P((struct ispsoftc *, int, u_int16_t *)); /* * Reset Hardware. * - * Hit the chip over the head, download new f/w and set it running. + * Hit the chip over the head, download new f/w if available and set it running. * * Locking done elsewhere. */ @@ -159,38 +133,52 @@ isp_reset(isp) * case, we don't really use this yet, but we may in * the future. */ - if (isp->isp_used == 0) { + if (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 (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - /* - * If this fails, it probably means we're running - * an old prom, if anything at all... - */ - isp->isp_romfw_rev = 0; - } else { - isp->isp_romfw_rev = - (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2]; + /* + * If this fails, it probably means we're running + * an old prom, if anything at all... + */ + 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_used = 1; + isp->isp_touched = 1; } + DISABLE_INTS(isp); + /* - * Put it into PAUSE mode. + * Put the board into PAUSE mode. */ ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE); if (IS_FC(isp)) { - revname = "2100"; + revname = "2X00"; + switch (isp->isp_type) { + case ISP_HA_FC_2100: + revname[1] = '1'; + break; + case ISP_HA_FC_2200: + revname[1] = '2'; + break; + default: + break; + } + } else if (IS_12X0(isp)) { + revname = "12X0"; + isp->isp_clock = 60; } else if (IS_1080(isp)) { u_int16_t l; sdparam *sdp = isp->isp_param; revname = "1080"; - sdp->isp_clock = 100; + isp->isp_clock = 100; l = ISP_READ(isp, SXP_PINS_DIFF) & ISP1080_MODE_MASK; switch (l) { case ISP1080_LVD_MODE: @@ -225,7 +213,7 @@ isp_reset(isp) case 1: revname = "1020"; isp->isp_type = ISP_HA_SCSI_1020; - sdp->isp_clock = 40; + isp->isp_clock = 40; break; case 2: /* @@ -235,23 +223,28 @@ isp_reset(isp) */ revname = "1020A"; isp->isp_type = ISP_HA_SCSI_1020A; - sdp->isp_clock = 40; + isp->isp_clock = 40; break; case 3: revname = "1040"; isp->isp_type = ISP_HA_SCSI_1040; - sdp->isp_clock = 60; + isp->isp_clock = 60; break; case 4: revname = "1040A"; isp->isp_type = ISP_HA_SCSI_1040A; - sdp->isp_clock = 60; + isp->isp_clock = 60; break; case 5: revname = "1040B"; isp->isp_type = ISP_HA_SCSI_1040B; - sdp->isp_clock = 60; + isp->isp_clock = 60; break; + case 6: + revname = "1040C(?)"; + isp->isp_type = ISP_HA_SCSI_1040C; + isp->isp_clock = 60; + break; } /* * Now, while we're at it, gather info about ultra @@ -276,7 +269,7 @@ isp_reset(isp) * If we're in Ultra Mode, we have to be 60Mhz clock- * even for the SBus version. */ - sdp->isp_clock = 60; + isp->isp_clock = 60; } else { sdp->isp_ultramode = 0; /* @@ -289,8 +282,8 @@ isp_reset(isp) * our generic determinations. */ if (isp->isp_mdvec->dv_clock) { - if (isp->isp_mdvec->dv_clock < sdp->isp_clock) { - sdp->isp_clock = isp->isp_mdvec->dv_clock; + if (isp->isp_mdvec->dv_clock < isp->isp_clock) { + isp->isp_clock = isp->isp_mdvec->dv_clock; } } @@ -355,7 +348,7 @@ again: */ loops = MBOX_DELAY_COUNT; for (;;) { - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { if (!(ISP_READ(isp, BIU_ICR) & BIU_ICR_SOFT_RESET)) break; } else { @@ -432,11 +425,6 @@ again: ISP_RESET1(isp); /* - * Enable interrupts - */ - ENABLE_INTS(isp); - - /* * Wait for everything to finish firing up... */ loops = MBOX_DELAY_COUNT; @@ -465,7 +453,7 @@ again: return; } - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { mbs.param[0] = MBOX_MAILBOX_REG_TEST; mbs.param[1] = 0xdead; mbs.param[2] = 0xbeef; @@ -496,13 +484,16 @@ again: * whether we have f/w at all and whether a config flag * has disabled our download. */ - if ((isp->isp_mdvec->dv_fwlen == 0) || + if ((isp->isp_mdvec->dv_ispfw == NULL) || (isp->isp_confopts & ISP_CFG_NORELOAD)) { dodnld = 0; } - if (dodnld && isp->isp_mdvec->dv_fwlen) { - for (i = 0; i < isp->isp_mdvec->dv_fwlen; i++) { + if (dodnld) { + u_int16_t fwlen = isp->isp_mdvec->dv_fwlen; + if (fwlen == 0) + fwlen = isp->isp_mdvec->dv_ispfw[3]; /* usually here */ + for (i = 0; i < 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]; @@ -543,44 +534,64 @@ again: mbs.param[1] = 0x1000; isp_mboxcmd(isp, &mbs); - if (isp->isp_type & ISP_HA_SCSI) { - sdparam *sdp = isp->isp_param; + if (IS_SCSI(isp)) { /* * Set CLOCK RATE, but only if asked to. */ - if (sdp->isp_clock) { + if (isp->isp_clock) { mbs.param[0] = MBOX_SET_CLOCK_RATE; - mbs.param[1] = sdp->isp_clock; + mbs.param[1] = isp->isp_clock; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set CLOCKRATE"); + PRINTF("failed to set clockrate (0x%x)\n", + mbs.param[0]); /* but continue */ - } else { - IDPRINTF(3, ("%s: setting input clock to %d\n", - isp->isp_name, sdp->isp_clock)); } } } mbs.param[0] = MBOX_ABOUT_FIRMWARE; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "ABOUT FIRMWARE command failed"); + PRINTF("could not get f/w started (0x%x)\n", mbs.param[0]); return; } - PRINTF("%s: Board Revision %s, %s F/W Revision %d.%d\n", - isp->isp_name, revname, dodnld? "loaded" : "resident", - mbs.param[1], mbs.param[2]); + 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]); if (IS_FC(isp)) { if (ISP_READ(isp, BIU2100_CSR) & BIU2100_PCI64) { - PRINTF("%s: in 64-Bit PCI slot\n", isp->isp_name); + CFGPRINTF("%s: in 64-Bit PCI slot\n", isp->isp_name); } } - isp->isp_fwrev = (((u_int16_t) mbs.param[1]) << 10) + mbs.param[2]; - if (isp->isp_romfw_rev && dodnld) { - PRINTF("%s: Last F/W revision was %d.%d\n", isp->isp_name, - isp->isp_romfw_rev >> 10, isp->isp_romfw_rev & 0x3ff); + + isp->isp_fwrev[0] = mbs.param[1]; + isp->isp_fwrev[1] = mbs.param[2]; + 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->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); + 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_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); + return; + } isp->isp_state = ISP_RESETSTATE; } @@ -594,108 +605,208 @@ void isp_init(isp) struct ispsoftc *isp; { - sdparam *sdp; - mbreg_t mbs; - int tgt; - - /* - * Must do first. - */ - isp_setdfltparm(isp); - /* - * Set up DMA for the request and result mailboxes. + * Must do this first to get defaults established. */ - if (ISP_MBOXDMASETUP(isp) != 0) { - PRINTF("%s: can't setup dma mailboxes\n", isp->isp_name); - return; + isp_setdfltparm(isp, 0); + if (IS_12X0(isp)) { + isp_setdfltparm(isp, 1); } - /* - * If we're fibre, we have a completely different - * initialization method. - */ if (IS_FC(isp)) { isp_fibre_init(isp); - return; + } else { + isp_scsi_init(isp); } - sdp = isp->isp_param; +} + +static void +isp_scsi_init(isp) + struct ispsoftc *isp; +{ + sdparam *sdp_chan0, *sdp_chan1; + mbreg_t mbs; + + sdp_chan0 = isp->isp_param; + sdp_chan1 = sdp_chan0; + if (IS_12X0(isp)) { + sdp_chan1++; + } + + /* First do overall per-card settings. */ /* * If we have fast memory timing enabled, turn it on. */ - if (sdp->isp_fast_mttr) { + if (isp->isp_fast_mttr) { ISP_WRITE(isp, RISC_MTR, 0x1313); } /* - * Set (possibly new) Initiator ID. + * Set Retry Delay and Count. + * You set both channels at the same time. */ - mbs.param[0] = MBOX_SET_INIT_SCSI_ID; - mbs.param[1] = sdp->isp_initiator_id; + mbs.param[0] = MBOX_SET_RETRY_COUNT; + mbs.param[1] = sdp_chan0->isp_retry_count; + mbs.param[2] = sdp_chan0->isp_retry_delay; + mbs.param[6] = sdp_chan1->isp_retry_count; + mbs.param[7] = sdp_chan1->isp_retry_delay; + isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set initiator id"); + PRINTF("%s: failed to set retry count and retry delay\n", + isp->isp_name); return; } /* - * Set Retry Delay and Count + * Set ASYNC DATA SETUP time. This is very important. */ - mbs.param[0] = MBOX_SET_RETRY_COUNT; - mbs.param[1] = sdp->isp_retry_count; - mbs.param[2] = sdp->isp_retry_delay; + 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); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set retry count and delay"); + PRINTF("%s: failed to set asynchronous data setup time\n", + isp->isp_name); return; } /* - * Set ASYNC DATA SETUP time. This is very important. + * Set ACTIVE Negation State. */ - mbs.param[0] = MBOX_SET_ASYNC_DATA_SETUP_TIME; - mbs.param[1] = sdp->isp_async_data_setup; + mbs.param[0] = MBOX_SET_ACT_NEG_STATE; + mbs.param[1] = + (sdp_chan0->isp_req_ack_active_neg << 4) | + (sdp_chan0->isp_data_line_active_neg << 5); + mbs.param[2] = + (sdp_chan1->isp_req_ack_active_neg << 4) | + (sdp_chan1->isp_data_line_active_neg << 5); + + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + PRINTF("%s: failed to set active negation state " + "(%d,%d),(%d,%d)\n", isp->isp_name, + sdp_chan0->isp_req_ack_active_neg, + sdp_chan0->isp_data_line_active_neg, + sdp_chan1->isp_req_ack_active_neg, + sdp_chan1->isp_data_line_active_neg); + /* + * But don't return. + */ + } + + /* + * Set the Tag Aging limit + */ + 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); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set async data setup time"); + PRINTF("%s: failed to set tag age limit (%d,%d)\n", + isp->isp_name, sdp_chan0->isp_tag_aging, + sdp_chan1->isp_tag_aging); return; } /* - * Set ACTIVE Negation State. + * Set selection timeout. */ - mbs.param[0] = MBOX_SET_ACTIVE_NEG_STATE; - mbs.param[1] = - (sdp->isp_req_ack_active_neg << 4) | - (sdp->isp_data_line_active_neg << 5); + 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); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set active neg state"); + PRINTF("%s: failed to set selection timeout\n", isp->isp_name); return; } + /* now do per-channel settings */ + isp_scsi_channel_init(isp, 0); + if (IS_12X0(isp)) + isp_scsi_channel_init(isp, 1); + /* - * Set the Tag Aging limit + * Now enable request/response queues */ - mbs.param[0] = MBOX_SET_TAG_AGE_LIMIT; - mbs.param[1] = sdp->isp_tag_aging; + mbs.param[0] = MBOX_INIT_RES_QUEUE; + mbs.param[1] = RESULT_QUEUE_LEN; + 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); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set tag age limit"); + 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[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); + 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; /* - * Set selection timeout. + * Turn on Fast Posting, LVD transitions */ - mbs.param[0] = MBOX_SET_SELECT_TIMEOUT; - mbs.param[1] = sdp->isp_selection_timeout; + if (IS_1080(isp) || + ISP_FW_REVX(isp->isp_fwrev) >= ISP_FW_REV(7, 55, 0)) { + mbs.param[0] = MBOX_SET_FW_FEATURES; +#ifndef ISP_NO_FASTPOST_SCSI + mbs.param[1] |= FW_FEATURE_FAST_POST; +#else + mbs.param[1] = 0; +#endif + if (IS_1080(isp)) + mbs.param[1] |= FW_FEATURE_LVD_NOTIFY; + if (mbs.param[1] != 0) { + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + PRINTF("%s: unable enable FW features\n", + isp->isp_name); + } + } + } + + /* + * Let the outer layers decide whether to issue a SCSI bus reset. + */ + isp->isp_state = ISP_INITSTATE; +} + +static void +isp_scsi_channel_init(isp, channel) + struct ispsoftc *isp; + int channel; +{ + sdparam *sdp; + mbreg_t mbs; + int tgt; + + sdp = isp->isp_param; + sdp += channel; + + /* + * Set (possibly new) Initiator ID. + */ + mbs.param[0] = MBOX_SET_INIT_SCSI_ID; + mbs.param[1] = (channel << 7) | sdp->isp_initiator_id; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "failed to set selection timeout"); + PRINTF("%s: cannot set initiator id on bus %d to %d\n", + isp->isp_name, channel, sdp->isp_initiator_id); return; } @@ -706,19 +817,31 @@ isp_init(isp) int maxlun, lun; u_int16_t sdf; - if (sdp->isp_devparam[tgt].dev_enable == 0) + if (sdp->isp_devparam[tgt].dev_enable == 0) { + IDPRINTF(1, ("%s: skipping target %d bus %d settings\n", + isp->isp_name, tgt, channel)); continue; + } - sdf = DPARM_SAFE_DFLT; /* - * It is not quite clear when this changed over so that - * we could force narrow and async, so assume >= 7.55. + * If we're in LVD mode, then we pretty much should + * only disable tagged queuing. */ - if (isp->isp_fwrev >= ISP_FW_REV(7, 55)) { - sdf |= DPARM_NARROW | DPARM_ASYNC; + if (IS_1080(isp) && sdp->isp_lvdmode) { + sdf = DPARM_DEFAULT & ~DPARM_TQING; + } else { + sdf = DPARM_SAFE_DFLT; + /* + * It is not quite clear when this changed over so that + * we could force narrow and async, so assume >= 7.55. + */ + if (ISP_FW_REVX(isp->isp_fwrev) >= + ISP_FW_REV(7, 55, 0)) { + sdf |= DPARM_NARROW | DPARM_ASYNC; + } } mbs.param[0] = MBOX_SET_TARGET_PARAMS; - mbs.param[1] = tgt << 8; + mbs.param[1] = (tgt << 8) | (channel << 15); mbs.param[2] = sdf; mbs.param[3] = (sdp->isp_devparam[tgt].sync_offset << 8) | @@ -727,7 +850,7 @@ isp_init(isp) if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { sdf = DPARM_SAFE_DFLT; mbs.param[0] = MBOX_SET_TARGET_PARAMS; - mbs.param[1] = tgt << 8; + mbs.param[1] = (tgt << 8) | (channel << 15); mbs.param[2] = sdf; mbs.param[3] = (sdp->isp_devparam[tgt].sync_offset << 8) | @@ -739,6 +862,8 @@ isp_init(isp) continue; } } + +#if 0 /* * We don't update dev_flags with what we've set * because that's not the ultimate goal setting. @@ -746,7 +871,7 @@ isp_init(isp) * cur_dflags by getting target parameters. */ mbs.param[0] = MBOX_GET_TARGET_PARAMS; - mbs.param[1] = (tgt << 8); + mbs.param[1] = (tgt << 8) | (channel << 15); isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { /* @@ -759,6 +884,15 @@ isp_init(isp) 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)); +#else + /* + * We don't update any information because we need to run + * at least one command per target to cause a new state + * to be latched. + */ +#endif /* * Ensure that we don't believe tagged queuing is enabled yet. * It turns out that sometimes the ISP just ignores our @@ -766,11 +900,13 @@ isp_init(isp) * seen yet. */ sdp->isp_devparam[tgt].cur_dflags &= ~DPARM_TQING; - - maxlun = (isp->isp_fwrev >= ISP_FW_REV(7, 55))? 32 : 8; + if (ISP_FW_REVX(isp->isp_fwrev) >= ISP_FW_REV(7, 55, 0)) + maxlun = 32; + else + maxlun = 8; for (lun = 0; lun < maxlun; lun++) { mbs.param[0] = MBOX_SET_DEV_QUEUE_PARAMS; - mbs.param[1] = (tgt << 8) | lun; + 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); @@ -781,81 +917,7 @@ isp_init(isp) break; } } - /* - * And mark this as an unannounced device - */ - sdp->isp_devparam[tgt].dev_announced = 0; - } - - mbs.param[0] = MBOX_INIT_RES_QUEUE; - mbs.param[1] = RESULT_QUEUE_LEN; - mbs.param[2] = (u_int16_t) (isp->isp_result_dma >> 16); - mbs.param[3] = (u_int16_t) (isp->isp_result_dma & 0xffff); - mbs.param[4] = 0; - mbs.param[5] = 0; - isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "set of response queue failed"); - return; } - isp->isp_residx = 0; - - mbs.param[0] = MBOX_INIT_REQ_QUEUE; - mbs.param[1] = RQUEST_QUEUE_LEN; - mbs.param[2] = (u_int16_t) (isp->isp_rquest_dma >> 16); - mbs.param[3] = (u_int16_t) (isp->isp_rquest_dma & 0xffff); - mbs.param[4] = 0; - mbs.param[5] = 0; - isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "set of request queue failed"); - return; - } - isp->isp_reqidx = isp->isp_reqodx = 0; - - /* - * Turn on Fast Posting, LVD transitions - */ - - if (IS_1080(isp) || isp->isp_fwrev >= ISP_FW_REV(7, 55)) { - mbs.param[0] = MBOX_SET_FW_FEATURES; -#ifndef ISP_NO_FASTPOST_SCSI - mbs.param[1] |= FW_FEATURE_FAST_POST; -#else - mbs.param[1] = 0; -#endif - if (IS_1080(isp)) - mbs.param[1] |= FW_FEATURE_LVD_NOTIFY; - if (mbs.param[1] != 0) { - isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - PRINTF("%s: unable enable FW features\n", - isp->isp_name); - } - } - } - - /* - * Let the outer layers decide whether to issue a SCSI bus reset. - */ -#if 0 - /* - * XXX: See whether or not for 7.55 F/W or later we - * XXX: can do without this, and see whether we should - * XXX: honor the NVRAM SCSI_RESET_DISABLE token. - */ - mbs.param[0] = MBOX_BUS_RESET; - mbs.param[1] = 3; - isp_mboxcmd(isp, &mbs); - if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "SCSI bus reset failed"); - } - /* - * This is really important to have set after a bus reset. - */ - isp->isp_sendmarker = 1; -#endif - isp->isp_state = ISP_INITSTATE; } /* @@ -870,7 +932,7 @@ isp_fibre_init(isp) fcparam *fcp; isp_icb_t *icbp; mbreg_t mbs; - int count, loopid; + int loopid; fcp = isp->isp_param; @@ -883,42 +945,48 @@ isp_fibre_init(isp) * best way to figure this out XXX */ #ifndef __i386__ - loopid = DEFAULT_LOOPID; + loopid = DEFAULT_LOOPID(isp); #else loopid = fcp->isp_loopid; #endif -#if defined(ISP2100_FABRIC) && defined(ISP2100_SCCLUN) - PRINTF("%s: Fabric Support, Expanded Lun Support\n", isp->isp_name); -#endif -#if defined(ISP2100_FABRIC) && !defined(ISP2100_SCCLUN) - PRINTF("%s: Fabric Support\n", isp->isp_name); -#endif -#if !defined(ISP2100_FABRIC) && defined(ISP2100_SCCLUN) - PRINTF("%s: Expanded Lun Support\n", isp->isp_name); -#endif - icbp = (isp_icb_t *) fcp->isp_scratch; MEMZERO(icbp, sizeof (*icbp)); icbp->icb_version = ICB_VERSION1; #ifdef ISP_TARGET_MODE - fcp->isp_fwoptions = ICBOPT_TGT_ENABLE|ICBOPT_INI_TGTTYPE; + fcp->isp_fwoptions = ICBOPT_TGT_ENABLE; #else fcp->isp_fwoptions = 0; #endif - fcp->isp_fwoptions |= ICBOPT_INI_ADISC|ICBOPT_FAIRNESS; + + fcp->isp_fwoptions |= ICBOPT_FAIRNESS; + /* + * If this is a 2100 < revision 5, we have to turn off FAIRNESS. + */ + if ((isp->isp_type == ISP_HA_FC_2100) && isp->isp_revision < 5) { + fcp->isp_fwoptions &= ~ICBOPT_FAIRNESS; + } fcp->isp_fwoptions |= ICBOPT_PDBCHANGE_AE; fcp->isp_fwoptions |= ICBOPT_HARD_ADDRESS; + /* + * We have to use FULL LOGIN even though it resets the loop too much + * because otherwise port database entries don't get updated after + * a LIP- this is a known f/w bug. + */ + if (ISP_FW_REVX(isp->isp_fwrev) < ISP_FW_REV(1, 17, 0)) { + fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN; + } #ifndef ISP_NO_FASTPOST_FC fcp->isp_fwoptions |= ICBOPT_FAST_POST; #endif -#ifdef CHECKME - fcp->isp_fwoptions |= ICBOPT_USE_PORTNAME; -#endif -#ifdef ISP2100_FABRIC - fcp->isp_fwoptions |= ICBOPT_FULL_LOGIN; -#endif + if (isp->isp_confopts & ISP_CFG_FULL_DUPLEX) + fcp->isp_fwoptions |= ICBOPT_FULL_DUPLEX; + + /* + * We don't set ICBOPT_PORTNAME because we want our + * Node Name && Port Names to be distinct. + */ icbp->icb_fwoptions = fcp->isp_fwoptions; icbp->icb_maxfrmlen = fcp->isp_maxfrmlen; @@ -926,65 +994,87 @@ isp_fibre_init(isp) 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); + 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); + 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); + icbp->icb_execthrottle = ICB_DFLT_THROTTLE; + } icbp->icb_retry_delay = fcp->isp_retry_delay; icbp->icb_retry_count = fcp->isp_retry_count; icbp->icb_hardaddr = loopid; + icbp->icb_logintime = 30; /* 30 second login timeout */ - MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwn); - if (icbp->icb_fwoptions & ICBOPT_USE_PORTNAME) { - u_int64_t portname = fcp->isp_wwn | (2LL << 56); - MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, portname); + if (fcp->isp_nodewwn) { + u_int64_t pn; + MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_nodewwn); + if (fcp->isp_portwwn) { + pn = fcp->isp_portwwn; + } else { + pn = fcp->isp_nodewwn | + (((u_int64_t)(isp->isp_unit+1)) << 56); + } + /* + * If the top nibble is 2, we can construct a port name + * from the node name by setting a nonzero instance in + * bits 56..59. Otherwise, we need to make it identical + * to Node name... + */ + if ((fcp->isp_nodewwn >> 60) == 2) { + MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, pn); + } else { + MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, + fcp->isp_nodewwn); + } + } else { + fcp->isp_fwoptions &= ~(ICBOPT_USE_PORTNAME|ICBOPT_FULL_LOGIN); } icbp->icb_rqstqlen = RQUEST_QUEUE_LEN; icbp->icb_rsltqlen = RESULT_QUEUE_LEN; - icbp->icb_rqstaddr[RQRSP_ADDR0015] = - (u_int16_t) (isp->isp_rquest_dma & 0xffff); - icbp->icb_rqstaddr[RQRSP_ADDR1631] = - (u_int16_t) (isp->isp_rquest_dma >> 16); - icbp->icb_respaddr[RQRSP_ADDR0015] = - (u_int16_t) (isp->isp_result_dma & 0xffff); - icbp->icb_respaddr[RQRSP_ADDR1631] = - (u_int16_t) (isp->isp_result_dma >> 16); - MemoryBarrier(); + 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); + icbp->icb_respaddr[RQRSP_ADDR1631] = DMA_MSW(isp->isp_result_dma); + ISP_SWIZZLE_ICB(isp, icbp); + + /* + * Do this *before* initializing the firmware. + */ + isp_mark_getpdb_all(isp); + fcp->isp_fwstate = FW_CONFIG_WAIT; + fcp->isp_loopstate = LOOP_NIL; - for (count = 0; count < 10; count++) { + MemoryBarrier(); + for (;;) { 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[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); - - switch (mbs.param[0]) { - case MBOX_COMMAND_COMPLETE: - count = 10; - break; - case ASYNC_PDB_CHANGED: - isp_mark_getpdb_all(isp); - /* FALL THROUGH */ - case ASYNC_LIP_OCCURRED: - case ASYNC_LOOP_UP: - case ASYNC_LOOP_DOWN: - case ASYNC_LOOP_RESET: - case ASYNC_CHANGE_NOTIFY: - if (count > 9) { - PRINTF("%s: too many retries to get going- " - "giving up\n", isp->isp_name); - return; + 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; } - break; - default: - isp_dumpregs(isp, "INIT FIRMWARE failed"); return; } + break; } + isp->isp_reqidx = isp->isp_reqodx = 0; isp->isp_residx = 0; isp->isp_sendmarker = 1; @@ -993,15 +1083,6 @@ isp_fibre_init(isp) * Whatever happens, we're now committed to being here. */ isp->isp_state = ISP_INITSTATE; - fcp->isp_fwstate = FW_CONFIG_WAIT; - - isp_mark_getpdb_all(isp); - -#ifdef ISP_TARGET_MODE - if (isp_modify_lun(isp, 0, 1, 1)) { - PRINTF("%s: failed to enable target mode\n", isp->isp_name); - } -#endif } /* @@ -1015,10 +1096,10 @@ static void isp_mark_getpdb_all(isp) struct ispsoftc *isp; { - isp_pdb_t *p; fcparam *fcp = (fcparam *) isp->isp_param; - for (p = &fcp->isp_pdb[0]; p < &fcp->isp_pdb[MAX_FC_TARG]; p++) { - p->pdb_options = INVALID_PDB_OPTIONS; + int i; + for (i = 0; i < MAX_FC_TARG; i++) { + fcp->portdb[i].valid = 0; } } @@ -1030,10 +1111,11 @@ isp_getpdb(isp, id, pdbp) { fcparam *fcp = (fcparam *) isp->isp_param; mbreg_t mbs; + mbs.param[0] = MBOX_GET_PORT_DB; mbs.param[1] = id << 8; - mbs.param[2] = (u_int16_t) (fcp->isp_scdma >> 16); - mbs.param[3] = (u_int16_t) (fcp->isp_scdma & 0xffff); + mbs.param[2] = DMA_MSW(fcp->isp_scdma); + mbs.param[3] = DMA_LSW(fcp->isp_scdma); /* * Unneeded. For the 2100, except for initializing f/w, registers * 4/5 have to not be written to. @@ -1047,15 +1129,15 @@ isp_getpdb(isp, id, pdbp) switch (mbs.param[0]) { case MBOX_COMMAND_COMPLETE: MemoryBarrier(); - MEMCPY(pdbp, fcp->isp_scratch, sizeof (isp_pdb_t)); + 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: Comand Param Error on Get Port Database\n", - isp->isp_name)); + 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", @@ -1065,6 +1147,34 @@ isp_getpdb(isp, id, pdbp) return (0); } +static u_int64_t +isp_get_portname(isp, loopid, nodename) + struct ispsoftc *isp; + int loopid; + int nodename; +{ + u_int64_t wwn = 0; + mbreg_t mbs; + + mbs.param[0] = MBOX_GET_PORT_NAME; + mbs.param[1] = loopid << 8; + if (nodename) + mbs.param[1] |= 1; + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] == MBOX_COMMAND_COMPLETE) { + wwn = + (((u_int64_t)(mbs.param[2] & 0xff)) << 56) | + (((u_int64_t)(mbs.param[2] >> 8)) << 48) | + (((u_int64_t)(mbs.param[3] & 0xff)) << 40) | + (((u_int64_t)(mbs.param[3] >> 8)) << 32) | + (((u_int64_t)(mbs.param[6] & 0xff)) << 24) | + (((u_int64_t)(mbs.param[6] >> 8)) << 16) | + (((u_int64_t)(mbs.param[7] & 0xff)) << 8) | + (((u_int64_t)(mbs.param[7] >> 8))); + } + return (wwn); +} + /* * Make sure we have good FC link and know our Loop ID. */ @@ -1074,11 +1184,20 @@ isp_fclink_test(isp, waitdelay) struct ispsoftc *isp; int waitdelay; { + static char *toponames[] = { + "Private Loop", + "FL Port", + "N-Port to N-Port", + "F Port" + }; + char *tname; mbreg_t mbs; - int count; + int count, topo = -1; u_int8_t lwfs; fcparam *fcp; - +#if defined(ISP2100_FABRIC) + isp_pdb_t pdb; +#endif fcp = isp->isp_param; /* @@ -1116,14 +1235,544 @@ isp_fclink_test(isp, waitdelay) return (-1); } fcp->isp_loopid = mbs.param[1]; + if (isp->isp_type == ISP_HA_FC_2200) { + if (ISP_FW_REVX(isp->isp_fwrev) >= ISP_FW_REV(2, 0, 14)) { + topo = (int) mbs.param[6]; + } + } else if (isp->isp_type == ISP_HA_FC_2100) { + if (ISP_FW_REVX(isp->isp_fwrev) >= ISP_FW_REV(1, 17, 26)) { + topo = (int) mbs.param[6]; + } + } + if (topo < 0 || topo > 3) + tname = "unknown"; + else + tname = toponames[topo]; + + /* + * If we're not on a fabric, the low 8 bits will be our AL_PA. + * If we're on a fabric, the low 8 bits will still be our AL_PA. + */ fcp->isp_alpa = mbs.param[2]; - PRINTF("%s: Loop ID %d, ALPA 0x%x\n", isp->isp_name, - fcp->isp_loopid, fcp->isp_alpa); +#if defined(ISP2100_FABRIC) + fcp->isp_onfabric = 0; + if (isp_getpdb(isp, FL_PORT_ID, &pdb) == 0) { + fcp->isp_portid = mbs.param[2] | (((int)mbs.param[3]) << 16); + fcp->isp_onfabric = 1; + 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, tname); + + /* + * Make sure we're logged out of all fabric devices. + */ + for (count = FC_SNS_ID+1; count < MAX_FC_TARG; count++) { + struct lportdb *lp = &fcp->portdb[count]; + if (lp->valid == 0 || lp->fabdev == 0) + continue; + PRINTF("%s: logging out target %d at Loop ID %d " + "(port id 0x%x)\n", isp->isp_name, count, + 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); + } + } else +#endif + CFGPRINTF("%s: Loop ID %d, ALPA 0x%x Loop State 0x%x topology %s\n", + isp->isp_name, fcp->isp_loopid, fcp->isp_alpa, fcp->isp_loopstate, + tname); + fcp->loop_seen_once = 1; return (0); +} + +/* + * Compare two local port db entities and return 1 if they're the same, else 0. + */ + +static int +isp_same_lportdb(a, b) + struct lportdb *a, *b; +{ + /* + * We decide two lports are the same if they have non-zero and + * identical port WWNs and identical loop IDs. + */ + if (a->port_wwn == 0 || a->port_wwn != b->port_wwn || + a->loopid != b->loopid) { + return (0); + } else { + return (1); + } } /* + * Synchronize our soft copy of the port database with what the f/w thinks + * (with a view toward possibly for a specific target....) + */ + +static int +isp_pdb_sync(isp, target) + struct ispsoftc *isp; + int target; +{ + struct lportdb *lp, *tport; + fcparam *fcp = isp->isp_param; + isp_pdb_t pdb; + int loopid, lim; + +#ifdef ISP2100_FABRIC + /* + * XXX: If we do this *after* building up our local port database, + * XXX: the commands simply don't work. + */ + /* + * (Re)discover all fabric devices + */ + if (fcp->isp_onfabric) + (void) isp_scan_fabric(isp); +#endif + + + /* + * Run through the local loop ports and get port database info + * for each loop ID. + * + * There's a somewhat unexplained situation where the f/w passes back + * the wrong database entity- if that happens, just restart (up to + * FL_PORT_ID times). + */ + tport = fcp->tport; + /* + * make sure the temp port database is clean... + */ + MEMZERO((void *) tport, sizeof (tport)); + for (lim = loopid = 0; loopid < FL_PORT_ID; loopid++) { + lp = &tport[loopid]; + lp->node_wwn = isp_get_portname(isp, loopid, 1); + if (lp->node_wwn == 0) + continue; + lp->port_wwn = isp_get_portname(isp, loopid, 0); + if (lp->port_wwn == 0) { + lp->node_wwn = 0; + continue; + } + + /* + * Get an entry.... + */ + if (isp_getpdb(isp, loopid, &pdb) != 0) { + continue; + } + + /* + * If the returned database element doesn't match what we + * asked for, restart the process entirely (up to a point...). + */ + if (pdb.pdb_loopid != loopid) { + IDPRINTF(1, ("%s: wankage (%d != %d)\n", + isp->isp_name, pdb.pdb_loopid, loopid)); + loopid = 0; + if (lim++ < FL_PORT_ID) { + continue; + } + PRINTF("%s: giving up on synchronizing the port " + "database\n", isp->isp_name); + return (-1); + } + + /* + * Save the pertinent info locally. + */ + lp->node_wwn = + (((u_int64_t)pdb.pdb_nodename[0]) << 56) | + (((u_int64_t)pdb.pdb_nodename[1]) << 48) | + (((u_int64_t)pdb.pdb_nodename[2]) << 40) | + (((u_int64_t)pdb.pdb_nodename[3]) << 32) | + (((u_int64_t)pdb.pdb_nodename[4]) << 24) | + (((u_int64_t)pdb.pdb_nodename[5]) << 16) | + (((u_int64_t)pdb.pdb_nodename[6]) << 8) | + (((u_int64_t)pdb.pdb_nodename[7])); + lp->port_wwn = + (((u_int64_t)pdb.pdb_portname[0]) << 56) | + (((u_int64_t)pdb.pdb_portname[1]) << 48) | + (((u_int64_t)pdb.pdb_portname[2]) << 40) | + (((u_int64_t)pdb.pdb_portname[3]) << 32) | + (((u_int64_t)pdb.pdb_portname[4]) << 24) | + (((u_int64_t)pdb.pdb_portname[5]) << 16) | + (((u_int64_t)pdb.pdb_portname[6]) << 8) | + (((u_int64_t)pdb.pdb_portname[7])); + lp->roles = + (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; + lp->portid = BITS2WORD(pdb.pdb_portid_bits); + lp->loopid = pdb.pdb_loopid; + /* + * Do a quick check to see whether this matches the saved port + * database for the same loopid. We do this here to save + * searching later (if possible). Note that this fails over + * time as things shuffle on the loop- we get the current + * loop state (where loop id as an index matches loop id in + * use) and then compare it to our saved database which + * never shifts. + */ + if (isp_same_lportdb(lp, &fcp->portdb[target])) { + lp->valid = 1; + } + } + + /* + * If we get this far, we've settled our differences with the f/w + * and we can say that the loop state is ready. + */ + fcp->isp_loopstate = LOOP_READY; + + /* + * Mark all of the permanent local loop database entries as invalid. + */ + for (loopid = 0; loopid < FL_PORT_ID; loopid++) { + fcp->portdb[loopid].valid = 0; + } + + /* + * Now merge our local copy of the port database into our saved copy. + * Notify the outer layers of new devices arriving. + */ + for (loopid = 0; loopid < FL_PORT_ID; loopid++) { + int i; + + /* + * If we don't have a non-zero Port WWN, we're not here. + */ + if (tport[loopid].port_wwn == 0) { + continue; + } + + /* + * If we've already marked our tmp copy as valid, + * this means that we've decided that it's the + * same as our saved data base. This didn't include + * the 'valid' marking so we have set that here. + */ + if (tport[loopid].valid) { + fcp->portdb[loopid].valid = 1; + continue; + } + + /* + * For the purposes of deciding whether this is the + * 'same' device or not, we only search for an identical + * Port WWN. Node WWNs may or may not be the same as + * the Port WWN, and there may be multiple different + * Port WWNs with the same Node WWN. It would be chaos + * to have multiple identical Port WWNs, so we don't + * allow that. + */ + + for (i = 0; i < FL_PORT_ID; i++) { + int j; + if (fcp->portdb[i].port_wwn == 0) + continue; + if (fcp->portdb[i].port_wwn != tport[loopid].port_wwn) + continue; + /* + * We found this WWN elsewhere- it's changed + * loopids then. We don't change it's actual + * position in our cached port database- we + * 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, + fcp->portdb[i].portid, loopid, + tport[loopid].portid); + } + fcp->portdb[i].portid = tport[loopid].portid; + fcp->portdb[i].loopid = loopid; + fcp->portdb[i].valid = 1; + /* + * XXX: Should we also propagate roles in case they + * XXX: changed? + */ + + /* + * Now make sure this Port WWN doesn't exist elsewhere + * in the port database. + */ + for (j = i+1; j < FL_PORT_ID; j++) { + if (fcp->portdb[i].port_wwn != + fcp->portdb[j].port_wwn) { + continue; + } + PRINTF("%s: Target ID %d Duplicates Target ID " + "%d- killing off both\n", + isp->isp_name, j, i); + /* + * Invalidate the 'old' *and* 'new' ones. + * This is really harsh and not quite right, + * but if this happens, we really don't know + * who is what at this point. + */ + fcp->portdb[i].valid = 0; + fcp->portdb[j].valid = 0; + } + break; + } + + /* + * If we didn't traverse the entire port database, + * then we found (and remapped) an existing entry. + * No need to notify anyone- go for the next one. + */ + if (i < FL_PORT_ID) { + continue; + } + + /* + * We've not found this Port WWN anywhere. It's a new entry. + * See if we can leave it where it is (with target == loopid). + */ + if (fcp->portdb[loopid].port_wwn != 0) { + for (lim = 0; lim < FL_PORT_ID; lim++) { + if (fcp->portdb[lim].port_wwn == 0) + break; + } + /* "Cannot Happen" */ + if (lim == FL_PORT_ID) { + PRINTF("%s: remap overflow?\n", isp->isp_name); + continue; + } + i = lim; + } else { + i = loopid; + } + + /* + * NB: The actual loopid we use here is loopid- we may + * in fact be at a completely different index (target). + */ + fcp->portdb[i].loopid = loopid; + fcp->portdb[i].port_wwn = tport[loopid].port_wwn; + fcp->portdb[i].node_wwn = tport[loopid].node_wwn; + fcp->portdb[i].roles = tport[loopid].roles; + fcp->portdb[i].portid = tport[loopid].portid; + fcp->portdb[i].valid = 1; + + /* + * Tell the outside world we've arrived. + */ + (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &i); + } + + /* + * Now find all previously used targets that are now invalid and + * notify the outer layers that they're gone. + */ + for (lp = fcp->portdb; lp < &fcp->portdb[FL_PORT_ID]; lp++) { + if (lp->valid || lp->port_wwn == 0) + continue; + + /* + * Tell the outside world we've gone away. + */ + loopid = lp - fcp->portdb; + (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &loopid); + MEMZERO((void *) lp, sizeof (*lp)); + } + +#ifdef ISP2100_FABRIC + /* + * Now log in any fabric devices + */ + for (lp = &fcp->portdb[FC_SNS_ID+1]; + lp < &fcp->portdb[MAX_FC_TARG]; lp++) { + mbreg_t mbs; + + /* + * Nothing here? + */ + if (lp->port_wwn == 0) + continue; + /* + * Don't try to log into yourself. + */ + if (lp->portid == fcp->isp_portid) + continue; + + /* + * Force a logout. + */ + lp->loopid = loopid = lp - fcp->portdb; + mbs.param[0] = MBOX_FABRIC_LOGOUT; + mbs.param[1] = lp->loopid << 8; + mbs.param[2] = 0; + mbs.param[3] = 0; + isp_mboxcmd(isp, &mbs); + + /* + * And log in.... + */ + mbs.param[0] = MBOX_FABRIC_LOGIN; + mbs.param[1] = lp->loopid << 8; + mbs.param[2] = lp->portid >> 16; + mbs.param[3] = lp->portid & 0xffff; + isp_mboxcmd(isp, &mbs); + switch (mbs.param[0]) { + case MBOX_COMMAND_COMPLETE: + break; + case MBOX_COMMAND_ERROR: + switch (mbs.param[1]) { + case 1: + PRINTF("%s: no loop\n", isp->isp_name); + break; + case 2: + PRINTF("%s: IOCB buffer could not be alloced\n", + isp->isp_name); + break; + case 3: + PRINTF("%s: could not alloc xchange resource\n", + isp->isp_name); + break; + case 4: + PRINTF("%s: ELS timeout\n", isp->isp_name); + break; + case 5: + PRINTF("%s: no fabric port\n", isp->isp_name); + break; + case 6: + PRINTF("%s: remote device cannot be a target\n", + isp->isp_name); + break; + default: + break; + } + continue; + default: + continue; + } + + lp->valid = 1; + lp->fabdev = 1; + if (isp_getpdb(isp, loopid, &pdb) != 0) { + /* + * Be kind... + */ + lp->roles = (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT); + PRINTF("%s: Faked PortID 0x%x into LoopID %d\n", + isp->isp_name, lp->portid, lp->loopid); + continue; + } + if (pdb.pdb_loopid != lp->loopid) { + lp->roles = (SVC3_TGT_ROLE >> SVC3_ROLE_SHIFT); + PRINTF("%s: Wanked PortID 0x%x to LoopID %d\n", + isp->isp_name, lp->portid, lp->loopid); + continue; + } + lp->roles = + (pdb.pdb_prli_svc3 & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT; + lp->portid = BITS2WORD(pdb.pdb_portid_bits); + lp->loopid = loopid; + lp->node_wwn = + (((u_int64_t)pdb.pdb_nodename[0]) << 56) | + (((u_int64_t)pdb.pdb_nodename[1]) << 48) | + (((u_int64_t)pdb.pdb_nodename[2]) << 40) | + (((u_int64_t)pdb.pdb_nodename[3]) << 32) | + (((u_int64_t)pdb.pdb_nodename[4]) << 24) | + (((u_int64_t)pdb.pdb_nodename[5]) << 16) | + (((u_int64_t)pdb.pdb_nodename[6]) << 8) | + (((u_int64_t)pdb.pdb_nodename[7])); + lp->port_wwn = + (((u_int64_t)pdb.pdb_portname[0]) << 56) | + (((u_int64_t)pdb.pdb_portname[1]) << 48) | + (((u_int64_t)pdb.pdb_portname[2]) << 40) | + (((u_int64_t)pdb.pdb_portname[3]) << 32) | + (((u_int64_t)pdb.pdb_portname[4]) << 24) | + (((u_int64_t)pdb.pdb_portname[5]) << 16) | + (((u_int64_t)pdb.pdb_portname[6]) << 8) | + (((u_int64_t)pdb.pdb_portname[7])); + /* + * Check to make sure this all makes sense. + */ + if (lp->node_wwn && lp->port_wwn) { + (void) isp_async(isp, ISPASYNC_PDB_CHANGED, &loopid); + continue; + } + lp->fabdev = lp->valid = 0; + PRINTF("%s: Target %d (Loop 0x%x) Port ID 0x%x lost its WWN\n", + isp->isp_name, 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); + } +#endif + return (0); +} + +#ifdef ISP2100_FABRIC +static int +isp_scan_fabric(isp) + struct ispsoftc *isp; +{ + fcparam *fcp = isp->isp_param; + u_int32_t portid, first_nz_portid; + sns_screq_t *reqp; + sns_scrsp_t *resp; + mbreg_t mbs; + int hicap; + + reqp = (sns_screq_t *) fcp->isp_scratch; + resp = (sns_scrsp_t *) (&((char *)fcp->isp_scratch)[0x100]); + first_nz_portid = portid = fcp->isp_portid; + + for (hicap = 0; hicap < 1024; hicap++) { + MEMZERO((void *) reqp, SNS_GAN_REQ_SIZE); + reqp->snscb_rblen = SNS_GAN_RESP_SIZE >> 1; + reqp->snscb_addr[RQRSP_ADDR0015] = + DMA_LSW(fcp->isp_scdma + 0x100); + reqp->snscb_addr[RQRSP_ADDR1631] = + DMA_MSW(fcp->isp_scdma + 0x100); + reqp->snscb_sblen = 6; + reqp->snscb_data[0] = SNS_GAN; + reqp->snscb_data[4] = portid & 0xffff; + reqp->snscb_data[5] = (portid >> 16) & 0xff; + ISP_SWIZZLE_SNS_REQ(isp, reqp); + mbs.param[0] = MBOX_SEND_SNS; + mbs.param[1] = SNS_GAN_REQ_SIZE >> 1; + mbs.param[2] = DMA_MSW(fcp->isp_scdma); + mbs.param[3] = DMA_LSW(fcp->isp_scdma); + mbs.param[6] = 0; + mbs.param[7] = 0; + MemoryBarrier(); + isp_mboxcmd(isp, &mbs); + if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { + return (-1); + } + ISP_UNSWIZZLE_SNS_RSP(isp, resp, SNS_GAN_RESP_SIZE >> 1); + portid = (((u_int32_t) resp->snscb_port_id[0]) << 16) | + (((u_int32_t) resp->snscb_port_id[1]) << 8) | + (((u_int32_t) resp->snscb_port_id[2])); + if (isp_async(isp, ISPASYNC_FABRIC_DEV, resp)) { + return (-1); + } + if (first_nz_portid == 0 && portid) { + first_nz_portid = portid; + } + if (first_nz_portid == portid) { + return (0); + } + } + /* + * We either have a broken name server or a huge fabric if we get here. + */ + return (0); +} +#endif +/* * Start a command. Locking is assumed done in the caller. */ @@ -1132,7 +1781,7 @@ ispscsicmd(xs) ISP_SCSI_XFER_T *xs; { struct ispsoftc *isp; - u_int8_t iptr, optr; + u_int16_t iptr, optr; union { ispreq_t *_reqp; ispreqt2_t *_t2reqp; @@ -1140,7 +1789,7 @@ ispscsicmd(xs) #define reqp _u._reqp #define t2reqp _u._t2reqp #define UZSIZE max(sizeof (ispreq_t), sizeof (ispreqt2_t)) - int i, rqidx; + int target, i; XS_INITERR(xs); isp = XS_ISP(xs); @@ -1156,9 +1805,9 @@ ispscsicmd(xs) * to the whole Queue Entry for the command... */ - if (XS_CDBLEN(xs) > ((isp->isp_type & ISP_HA_FC)? 16 : 12)) { - PRINTF("%s: unsupported cdb length (%d)\n", - isp->isp_name, XS_CDBLEN(xs)); + if (XS_CDBLEN(xs) > (IS_FC(isp) ? 16 : 12) || 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]); XS_SETERR(xs, HBA_BOTCH); return (CMD_COMPLETE); } @@ -1167,104 +1816,146 @@ ispscsicmd(xs) * Check to see whether we have good firmware state still or * need to refresh our port database for this target. */ + target = XS_TGT(xs); if (IS_FC(isp)) { fcparam *fcp = isp->isp_param; - isp_pdb_t *pdbp = &fcp->isp_pdb[XS_TGT(xs)]; - + struct lportdb *lp; +#if defined(ISP2100_FABRIC) + if (target >= FL_PORT_ID) { + /* + * If we're not on a Fabric, we can't have a target + * above FL_PORT_ID-1. If we're on a fabric, we + * can't have a target less than FC_SNS_ID+1. + */ + if (fcp->isp_onfabric == 0 || target <= FC_SNS_ID) { + XS_SETERR(xs, HBA_SELTIMEOUT); + return (CMD_COMPLETE); + } + } +#endif /* - * Check for f/w being in ready state. Well, okay, - * our cached copy of it... + * Check for f/w being in ready state. If the f/w + * isn't in ready state, then we don't know our + * loop ID and the f/w hasn't completed logging + * into all targets on the loop. If this is the + * case, then bounce the command. We pretend this is + * a SELECTION TIMEOUT error if we've never gone to + * FW_READY state at all- in this case we may not + * be hooked to a loop at all and we shouldn't hang + * the machine for this. Otherwise, defer this command + * until later. */ if (fcp->isp_fwstate != FW_READY) { if (isp_fclink_test(isp, FC_FW_READY_DELAY)) { XS_SETERR(xs, HBA_SELTIMEOUT); - return (CMD_COMPLETE); + if (fcp->loop_seen_once) { + return (CMD_RQLATER); + } else { + return (CMD_COMPLETE); + } } } + + /* + * If our loop state is such that we haven't yet received + * a "Port Database Changed" notification (after a LIP or + * a Loop Reset or firmware initialization), then defer + * sending commands for a little while. + */ + if (fcp->isp_loopstate < LOOP_PDB_RCVD) { + XS_SETERR(xs, HBA_SELTIMEOUT); + return (CMD_RQLATER); + } + /* - * Refresh our port database if needed. + * If our loop state is now such that we've just now + * received a Port Database Change notification, then + * we have to go off and (re)synchronize our port + * database. */ - if (pdbp->pdb_options == INVALID_PDB_OPTIONS) { - if (isp_getpdb(isp, XS_TGT(xs), pdbp) == 0) { - isp_async(isp, ISPASYNC_PDB_CHANGE_COMPLETE, - (void *) (long) XS_TGT(xs)); + if (fcp->isp_loopstate == LOOP_PDB_RCVD) { + if (isp_pdb_sync(isp, target)) { + XS_SETERR(xs, HBA_SELTIMEOUT); + return (CMD_COMPLETE); } } + + /* + * Now check whether we should even think about pursuing this. + */ + lp = &fcp->portdb[target]; + if (lp->valid == 0) { + XS_SETERR(xs, HBA_SELTIMEOUT); + 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)); + XS_SETERR(xs, HBA_SELTIMEOUT); + return (CMD_COMPLETE); + } + /* + * Now turn target into what the actual loop ID is. + */ + target = lp->loopid; } /* * Next check to see if any HBA or Device * parameters need to be updated. */ - if (isp->isp_update) { + if (isp->isp_update != 0) { isp_update(isp); } - optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); - iptr = isp->isp_reqidx; - - reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); - if (iptr == optr) { - IDPRINTF(2, ("%s: Request Queue Overflow\n", isp->isp_name)); + if (isp_getrqentry(isp, &iptr, &optr, (void **) &reqp)) { + IDPRINTF(1, ("%s: Request Queue Overflow\n", isp->isp_name)); XS_SETERR(xs, HBA_BOTCH); return (CMD_EAGAIN); } + /* + * Now see if we need to synchronize the ISP with respect to anything. + * We do dual duty here (cough) for synchronizing for busses other + * than which we got here to send a command to. + */ if (isp->isp_sendmarker) { - u_int8_t niptr; - ispmarkreq_t *marker = (ispmarkreq_t *) reqp; - - MEMZERO((void *) marker, sizeof (*marker)); - marker->req_header.rqs_entry_count = 1; - marker->req_header.rqs_entry_type = RQSTYPE_MARKER; - marker->req_modifier = SYNC_ALL; - + u_int8_t n = (IS_12X0(isp)? 2: 1); /* - * Unconditionally update the input pointer anyway. + * Check ports to send markers for... */ - ISP_WRITE(isp, INMAILBOX4, iptr); - isp->isp_reqidx = iptr; - - niptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); - if (niptr == optr) { - IDPRINTF(2, ("%s: Request Queue Overflow+\n", - isp->isp_name)); - XS_SETERR(xs, HBA_BOTCH); - return (CMD_EAGAIN); + for (i = 0; i < n; i++) { + if ((isp->isp_sendmarker & (1 << i)) == 0) { + continue; + } + MEMZERO((void *) reqp, sizeof (*reqp)); + reqp->req_header.rqs_entry_count = 1; + reqp->req_header.rqs_entry_type = RQSTYPE_MARKER; + 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(1, ("%s: Request Queue Overflow+\n", + isp->isp_name)); + XS_SETERR(xs, HBA_BOTCH); + return (CMD_EAGAIN); + } } - reqp = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = niptr; } MEMZERO((void *) reqp, UZSIZE); reqp->req_header.rqs_entry_count = 1; - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS; } else { reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST; } reqp->req_header.rqs_flags = 0; - reqp->req_header.rqs_seqno = isp->isp_seqno++; - - for (rqidx = 0; rqidx < RQUEST_QUEUE_LEN; rqidx++) { - if (isp->isp_xflist[rqidx] == NULL) - break; - } - if (rqidx == RQUEST_QUEUE_LEN) { - IDPRINTF(2, ("%s: out of xflist pointers\n", isp->isp_name)); - XS_SETERR(xs, HBA_BOTCH); - return (CMD_EAGAIN); - } else { - /* - * Never have a handle that is zero, so - * set req_handle off by one. - */ - isp->isp_xflist[rqidx] = xs; - reqp->req_handle = rqidx+1; - } - - if (isp->isp_type & ISP_HA_FC) { + reqp->req_header.rqs_seqno = 0; + if (IS_FC(isp)) { /* * See comment in isp_intr */ @@ -1272,59 +1963,60 @@ ispscsicmd(xs) /* * Fibre Channel always requires some kind of tag. - * If we're marked as "Can't Tag", just do simple - * instead of ordered tags. It's pretty clear to me - * that we shouldn't do head of queue tagging in - * this case. + * 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); } else { - t2reqp->req_flags = REQFLAG_STAG; + if (XS_CDBP(xs)[0] == 0x3) /* REQUEST SENSE */ + t2reqp->req_flags = REQFLAG_HTAG; + else + t2reqp->req_flags = REQFLAG_OTAG; } } else { sdparam *sdp = (sdparam *)isp->isp_param; - if ((sdp->isp_devparam[XS_TGT(xs)].cur_dflags & DPARM_TQING) && + if ((sdp->isp_devparam[target].cur_dflags & DPARM_TQING) && XS_CANTAG(xs)) { reqp->req_flags = XS_KINDOF_TAG(xs); - } else { - reqp->req_flags = 0; } } - reqp->req_target = XS_TGT(xs); - if (isp->isp_type & ISP_HA_SCSI) { + reqp->req_target = target | (XS_CHANNEL(xs) << 7); + if (IS_SCSI(isp)) { reqp->req_lun_trn = XS_LUN(xs); reqp->req_cdblen = XS_CDBLEN(xs); } else { #ifdef ISP2100_SCCLUN - reqp->req_scclun = XS_LUN(xs); + t2reqp->req_scclun = XS_LUN(xs); #else - reqp->req_lun_trn = XS_LUN(xs); + t2reqp->req_lun_trn = XS_LUN(xs); #endif - } MEMCPY(reqp->req_cdb, XS_CDBP(xs), XS_CDBLEN(xs)); - IDPRINTF(5, ("%s(%d.%d): START%d cmd 0x%x datalen %d\n", isp->isp_name, - XS_TGT(xs), XS_LUN(xs), reqp->req_header.rqs_seqno, - reqp->req_cdb[0], XS_XFRLEN(xs))); - reqp->req_time = XS_TIME(xs) / 1000; if (reqp->req_time == 0 && XS_TIME(xs)) reqp->req_time = 1; /* * Always give a bit more leeway to commands after a bus reset. + * XXX: DOES NOT DISTINGUISH WHICH PORT MAY HAVE BEEN SYNCED */ - if (isp->isp_sendmarker && reqp->req_time < 5) + if (isp->isp_sendmarker && reqp->req_time < 5) { reqp->req_time = 5; - + } + if (isp_save_xs(isp, xs, &reqp->req_handle)) { + IDPRINTF(2, ("%s: out of xflist pointers\n", isp->isp_name)); + XS_SETERR(xs, HBA_BOTCH); + return (CMD_EAGAIN); + } + /* + * Set up DMA and/or do any bus swizzling of the request entry + * so that the Qlogic F/W understands what is being asked of it. + */ i = ISP_DMASETUP(isp, xs, reqp, &iptr, optr); if (i != CMD_QUEUED) { - /* - * Take memory of it away... - */ - isp->isp_xflist[rqidx] = NULL; + isp_destroy_handle(isp, reqp->req_handle); /* * dmasetup sets actual error in packet, and * return what we were given to return. @@ -1332,9 +2024,11 @@ 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_WRITE(isp, INMAILBOX4, iptr); - isp->isp_reqidx = iptr; + ISP_ADD_REQUEST(isp, iptr); isp->isp_nactive++; if (isp->isp_sendmarker) isp->isp_sendmarker = 0; @@ -1356,7 +2050,8 @@ isp_control(isp, ctl, arg) { ISP_SCSI_XFER_T *xs; mbreg_t mbs; - int i; + int bus, tgt; + u_int32_t handle; switch (ctl) { default: @@ -1366,74 +2061,73 @@ isp_control(isp, ctl, arg) case ISPCTL_RESET_BUS: /* - * This is really important to have set after a bus reset. - */ - isp->isp_sendmarker = 1; - - /* * Issue a bus reset. */ mbs.param[0] = MBOX_BUS_RESET; - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { mbs.param[1] = ((sdparam *) isp->isp_param)->isp_bus_reset_delay; if (mbs.param[1] < 2) mbs.param[1] = 2; + bus = *((int *) arg); + mbs.param[2] = bus; } else { - /* - * Unparameterized. - */ - mbs.param[1] = 5; + mbs.param[1] = 10; + mbs.param[2] = 0; + bus = 0; } + isp->isp_sendmarker = 1 << bus; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { isp_dumpregs(isp, "isp_control SCSI bus reset failed"); break; } - PRINTF("%s: driver initiated bus reset\n", isp->isp_name); + PRINTF("%s: driver initiated bus reset of bus %d\n", + isp->isp_name, bus); return (0); case ISPCTL_RESET_DEV: + tgt = (*((int *) arg)) & 0xffff; + bus = (*((int *) arg)) >> 16; mbs.param[0] = MBOX_ABORT_TARGET; - mbs.param[1] = ((long)arg) << 8; + mbs.param[1] = (tgt << 8) | (bus << 15); mbs.param[2] = 3; /* 'delay', in seconds */ isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { - isp_dumpregs(isp, "Target Reset Failed"); + PRINTF("%s: isp_control MBOX_RESET_DEV failure (code " + "%x)\n", isp->isp_name, mbs.param[0]); break; } - PRINTF("%s: Target %d Reset Succeeded\n", isp->isp_name, - (int) ((long) arg)); - isp->isp_sendmarker = 1; + PRINTF("%s: Target %d on Bus %d Reset Succeeded\n", + isp->isp_name, tgt, bus); + isp->isp_sendmarker = 1 << bus; return (0); case ISPCTL_ABORT_CMD: xs = (ISP_SCSI_XFER_T *) arg; - for (i = 0; i < RQUEST_QUEUE_LEN; i++) { - if (xs == isp->isp_xflist[i]) { - break; - } - } - if (i == RQUEST_QUEUE_LEN) { + 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); break; } + bus = XS_CHANNEL(xs); mbs.param[0] = MBOX_ABORT; + if (IS_FC(isp)) { #ifdef ISP2100_SCCLUN - if (isp->isp_type & ISP_HA_FC) { mbs.param[1] = XS_TGT(xs) << 8; mbs.param[4] = 0; mbs.param[5] = 0; mbs.param[6] = XS_LUN(xs); - } else { - mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs); - } #else - mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs); + mbs.param[1] = XS_TGT(xs) << 8 | XS_LUN(xs); #endif - mbs.param[2] = (i+1) >> 16; - mbs.param[3] = (i+1) & 0xffff; + } else { + mbs.param[1] = + (bus << 15) | (XS_TGT(xs) << 8) | XS_LUN(xs); + } + mbs.param[2] = handle >> 16; + mbs.param[3] = handle & 0xffff; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { PRINTF("%s: isp_control MBOX_ABORT failure (code %x)\n", @@ -1450,6 +2144,13 @@ isp_control(isp, ctl, arg) case ISPCTL_FCLINK_TEST: return (isp_fclink_test(isp, FC_FW_READY_DELAY)); +#ifdef ISP_TARGET_MODE + case ISPCTL_ENABLE_LUN: + return (isp_modify_lun, 1, arg)); + + case ISPCTL_MODIFY_LUN: + return (isp_modify_lun, 0, arg)); +#endif } return (-1); } @@ -1467,73 +2168,70 @@ isp_intr(arg) { ISP_SCSI_XFER_T *complist[RESULT_QUEUE_LEN], *xs; struct ispsoftc *isp = arg; - u_int8_t iptr, optr; - u_int16_t isr; + u_int16_t iptr, optr; + u_int16_t isr, isrb, sema; int i, nlooked = 0, ndone = 0; - isr = ISP_READ(isp, BIU_ISR); - if (isp->isp_type & ISP_HA_FC) { - if (isr == 0 || (isr & BIU2100_ISR_RISC_INT) == 0) { - if (isr) { - IDPRINTF(4, ("%s: isp_intr isr=%x\n", - isp->isp_name, isr)); - } - return (0); - } - } else { - if (isr == 0 || (isr & BIU_ISR_RISC_INT) == 0) { - if (isr) { - IDPRINTF(4, ("%s: isp_intr isr=%x\n", - isp->isp_name, isr)); - } - return (0); - } + /* + * Well, if we've disabled interrupts, we may get a case where + * isr isn't set, but sema is. In any case, debounce isr reads. + */ + do { + isr = ISP_READ(isp, BIU_ISR); + isrb = ISP_READ(isp, BIU_ISR); + } while (isr != isrb); + sema = ISP_READ(isp, BIU_SEMA) & 0x1; + IDPRINTF(5, ("%s: isp_intr isr %x sem %x\n", isp->isp_name, isr, sema)); + if (isr == 0) { + return (0); + } + if (!INT_PENDING(isp, isr)) { + IDPRINTF(4, ("%s: isp_intr isr=%x\n", isp->isp_name, isr)); + return (0); + } + if (isp->isp_state != ISP_RUNSTATE) { + IDPRINTF(3, ("%s: interrupt (isr=%x,sema=%x) when not ready\n", + isp->isp_name, 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); + ENABLE_INTS(isp); + return (1); } - if (ISP_READ(isp, BIU_SEMA) & 1) { + if (sema) { u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); if (mbox & 0x4000) { - IDPRINTF(3, ("%s: isp_intr sees 0x%x\n", + IDPRINTF(3, ("%s: Command Mbox 0x%x\n", isp->isp_name, mbox)); - ISP_WRITE(isp, BIU_SEMA, 0); } else { u_int32_t fhandle = isp_parse_async(isp, (int) mbox); - ISP_WRITE(isp, BIU_SEMA, 0); - if (fhandle < 0) { - return (1); - } else if (fhandle > 0) { - xs = (void *)isp->isp_xflist[fhandle - 1]; - isp->isp_xflist[fhandle - 1] = NULL; - /* - * Since we don't have a result queue entry - * item, we must believe that SCSI status is - * zero and that all data transferred. - */ - XS_RESID(xs) = 0; - XS_STS(xs) = 0; - if (XS_XFRLEN(xs)) { - ISP_DMAFREE(isp, xs, fhandle - 1); - } - if (isp->isp_nactive > 0) - isp->isp_nactive--; - complist[ndone++] = xs; + IDPRINTF(3, ("%s: Async Mbox 0x%x\n", + isp->isp_name, mbox)); + if (fhandle > 0) { + isp_fastpost_complete(isp, fhandle); } } + ISP_WRITE(isp, BIU_SEMA, 0); + ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); + ENABLE_INTS(isp); + return (1); } - ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); + /* + * You *must* read OUTMAILBOX5 prior to clearing the RISC interrupt. + */ optr = isp->isp_residx; iptr = ISP_READ(isp, OUTMAILBOX5); - + ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); if (optr == iptr) { IDPRINTF(4, ("why intr? isr %x iptr %x optr %x\n", isr, optr, iptr)); } - ENABLE_INTS(isp); while (optr != iptr) { ispstatusreq_t *sp; - u_int8_t oop; + u_int16_t oop; int buddaboom = 0; sp = (ispstatusreq_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr); @@ -1541,6 +2239,11 @@ isp_intr(arg) optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN); nlooked++; MemoryBarrier(); + /* + * Do any appropriate unswizzling of what the Qlogic f/w has + * written into memory so it makes sense to us. + */ + ISP_UNSWIZZLE_RESPONSE(isp, sp); if (sp->req_header.rqs_entry_type != RQSTYPE_RESPONSE) { if (isp_handle_other_response(isp, sp, &optr) == 0) { ISP_WRITE(isp, INMAILBOX5, optr); @@ -1548,31 +2251,35 @@ isp_intr(arg) } /* * It really has to be a bounced request just copied - * from the request queue to the response queue. + * from the request queue to the response queue. If + * not, something bad has happened. */ - if (sp->req_header.rqs_entry_type != RQSTYPE_REQUEST) { ISP_WRITE(isp, INMAILBOX5, optr); + PRINTF("%s: not RESPONSE in RESPONSE Queue " + "(type 0x%x) @ idx %d (next %d)\n", + isp->isp_name, + sp->req_header.rqs_entry_type, oop, optr); continue; } - PRINTF("%s: not RESPONSE in RESPONSE Queue " - "(type 0x%x) @ idx %d (next %d)\n", isp->isp_name, - sp->req_header.rqs_entry_type, oop, optr); buddaboom = 1; } if (sp->req_header.rqs_flags & 0xf) { +#define _RQS_OFLAGS \ + ~(RQSFLAG_CONTINUATION|RQSFLAG_FULL|RQSFLAG_BADHEADER|RQSFLAG_BADPACKET) if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) { + IDPRINTF(3, ("%s: continuation segment\n", + isp->isp_name)); ISP_WRITE(isp, INMAILBOX5, optr); continue; } - PRINTF("%s: rqs_flags=%x", isp->isp_name, - sp->req_header.rqs_flags & 0xf); if (sp->req_header.rqs_flags & RQSFLAG_FULL) { - PRINTF("%s: internal queues full\n", - isp->isp_name); - /* XXXX: this command *could* get restarted */ - buddaboom++; + IDPRINTF(2, ("%s: internal queues full\n", + isp->isp_name)); + /* + * We'll synthesize a QUEUE FULL message below. + */ } if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) { PRINTF("%s: bad header\n", isp->isp_name); @@ -1583,30 +2290,35 @@ isp_intr(arg) isp->isp_name); 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); + buddaboom++; + } +#undef _RQS_OFLAGS } - if (sp->req_handle > RQUEST_QUEUE_LEN || sp->req_handle < 1) { + if (sp->req_handle > isp->isp_maxcmds || sp->req_handle < 1) { PRINTF("%s: bad request handle %d\n", isp->isp_name, - sp->req_handle); + sp->req_handle); ISP_WRITE(isp, INMAILBOX5, optr); continue; } - xs = (void *) isp->isp_xflist[sp->req_handle - 1]; + xs = isp_find_xs(isp, sp->req_handle); if (xs == NULL) { - PRINTF("%s: NULL xs in xflist (handle %x)\n", + PRINTF("%s: NULL xs in xflist (handle 0x%x)\n", isp->isp_name, sp->req_handle); - isp_dumpxflist(isp); ISP_WRITE(isp, INMAILBOX5, optr); continue; } - isp->isp_xflist[sp->req_handle - 1] = NULL; + isp_destroy_handle(isp, sp->req_handle); if (sp->req_status_flags & RQSTF_BUS_RESET) { - isp->isp_sendmarker = 1; + isp->isp_sendmarker |= (1 << XS_CHANNEL(xs)); } if (buddaboom) { XS_SETERR(xs, HBA_BOTCH); } XS_STS(xs) = sp->req_scsi_status & 0xff; - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { if (sp->req_state_flags & RQSF_GOT_SENSE) { MEMCPY(XS_SNSP(xs), sp->req_sense_data, XS_SNSLEN(xs)); @@ -1619,8 +2331,9 @@ isp_intr(arg) */ if (sp->req_status_flags & RQSTF_NEGOTIATION) { sdparam *sdp = isp->isp_param; - isp->isp_update = 1; + sdp += XS_CHANNEL(xs); sdp->isp_devparam[XS_TGT(xs)].dev_refresh = 1; + isp->isp_update |= (1 << XS_CHANNEL(xs)); } } else { if (XS_STS(xs) == SCSI_CHECK) { @@ -1642,14 +2355,24 @@ isp_intr(arg) XS_SETERR(xs, HBA_NOERROR); } } + } 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_SETERR(xs, HBA_NOERROR); + } else if (XS_NOERR(xs)) { + XS_SETERR(xs, HBA_BOTCH); + } } else { - PRINTF("%s: unknown return %x\n", isp->isp_name, - sp->req_header.rqs_entry_type); + PRINTF("%s: unhandled respose queue type 0x%x\n", + isp->isp_name, sp->req_header.rqs_entry_type); if (XS_NOERR(xs)) { XS_SETERR(xs, HBA_BOTCH); } } - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { XS_RESID(xs) = sp->req_resid; } else if (sp->req_scsi_status & RQCS_RU) { XS_RESID(xs) = sp->req_resid; @@ -1657,7 +2380,7 @@ isp_intr(arg) XS_XFRLEN(xs), sp->req_resid)); } if (XS_XFRLEN(xs)) { - ISP_DMAFREE(isp, xs, sp->req_handle - 1); + ISP_DMAFREE(isp, xs, sp->req_handle); } /* * XXX: If we have a check condition, but no Sense Data, @@ -1674,10 +2397,9 @@ isp_intr(arg) } if ((isp->isp_dblev >= 5) || (isp->isp_dblev > 2 && !XS_NOERR(xs))) { - PRINTF("%s(%d.%d): FIN%d dl%d resid%d STS %x", + PRINTF("%s(%d.%d): FIN dl%d resid%d STS %x", isp->isp_name, XS_TGT(xs), XS_LUN(xs), - sp->req_header.rqs_seqno, XS_XFRLEN(xs), - XS_RESID(xs), XS_STS(xs)); + XS_XFRLEN(xs), XS_RESID(xs), XS_STS(xs)); if (sp->req_state_flags & RQSF_GOT_SENSE) { PRINTF(" Skey: %x", XS_SNSKEY(xs)); if (!(XS_IS_SNS_VALID(xs))) { @@ -1708,6 +2430,7 @@ isp_intr(arg) XS_CMD_DONE(xs); } } + ENABLE_INTS(isp); return (1); } @@ -1720,19 +2443,30 @@ isp_parse_async(isp, mbox) struct ispsoftc *isp; int mbox; { + int bus; u_int32_t fast_post_handle = 0; + /* + * It is not documented anywhere that bus is always in OUTMAILBOX6 + * for dual bus cards- and we don't have the h/w to prove it either, + * So we'll just assume...... + */ + if (IS_1080(isp) || IS_12X0(isp)) { + bus = ISP_READ(isp, OUTMAILBOX6); + } else { + bus = 0; + } + switch (mbox) { case MBOX_COMMAND_COMPLETE: /* sometimes these show up */ break; case ASYNC_BUS_RESET: - isp_async(isp, ISPASYNC_BUS_RESET, NULL); - isp->isp_sendmarker = 1; + isp->isp_sendmarker = (1 << bus); #ifdef ISP_TARGET_MODE - isp_notify_ack(isp, NULL); + isp_target_async(isp, bus, ASYNC_BUS_RESET); #endif + isp_async(isp, ISPASYNC_BUS_RESET, &bus); break; - case ASYNC_SYSTEM_ERROR: mbox = ISP_READ(isp, OUTMAILBOX1); PRINTF("%s: Internal FW Error @ RISC Addr 0x%x\n", @@ -1750,23 +2484,28 @@ isp_parse_async(isp, mbox) break; case ASYNC_QWAKEUP: - /* don't need to be chatty */ + /* + * We've just been notified that the Queue has woken up. + * We don't need to be chatty about this- just unlatch things + * and move on. + */ mbox = ISP_READ(isp, OUTMAILBOX4); break; case ASYNC_TIMEOUT_RESET: - PRINTF("%s: timeout initiated SCSI bus reset\n", isp->isp_name); - isp->isp_sendmarker = 1; + PRINTF("%s: timeout initiated SCSI bus reset of bus %d\n", + isp->isp_name, bus); + isp->isp_sendmarker = (1 << bus); #ifdef ISP_TARGET_MODE - isp_notify_ack(isp, NULL); + isp_target_async(isp, bus, ASYNC_TIMEOUT_RESET); #endif break; case ASYNC_DEVICE_RESET: - isp->isp_sendmarker = 1; - PRINTF("%s: device reset\n", isp->isp_name); + PRINTF("%s: device reset on bus %d\n", isp->isp_name, bus); + isp->isp_sendmarker = 1 << bus; #ifdef ISP_TARGET_MODE - isp_notify_ack(isp, NULL); + isp_target_async(isp, bus, ASYNC_DEVICE_RESET); #endif break; @@ -1820,7 +2559,8 @@ isp_parse_async(isp, mbox) /* * XXX: Set up to renegotiate again! */ - isp->isp_sendmarker = 1; + /* Can only be for a 1080... */ + isp->isp_sendmarker = (1 << bus); break; case ASYNC_CMD_CMPLT: @@ -1836,34 +2576,56 @@ isp_parse_async(isp, mbox) break; case ASYNC_LIP_OCCURRED: + ((fcparam *) isp->isp_param)->isp_lipseq = + ISP_READ(isp, OUTMAILBOX1); + ((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_LIP_RCVD; isp->isp_sendmarker = 1; - PRINTF("%s: LIP occurred\n", isp->isp_name); + isp_mark_getpdb_all(isp); + IDPRINTF(1, ("%s: LIP occurred\n", isp->isp_name)); break; case ASYNC_LOOP_UP: isp->isp_sendmarker = 1; + ((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_LIP_RCVD; + isp_mark_getpdb_all(isp); isp_async(isp, ISPASYNC_LOOP_UP, NULL); break; case ASYNC_LOOP_DOWN: + isp->isp_sendmarker = 1; + ((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_NIL; + isp_mark_getpdb_all(isp); isp_async(isp, ISPASYNC_LOOP_DOWN, NULL); break; case ASYNC_LOOP_RESET: - isp->isp_sendmarker = 1; + isp->isp_sendmarker = 1 << bus; + ((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); #ifdef ISP_TARGET_MODE - isp_notify_ack(isp, NULL); + isp_target_async(isp, bus, ASYNC_LOOP_RESET); #endif break; case ASYNC_PDB_CHANGED: isp->isp_sendmarker = 1; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_PDB_RCVD; isp_mark_getpdb_all(isp); - PRINTF("%s: Port Database Changed\n", isp->isp_name); + IDPRINTF(2, ("%s: Port Database Changed\n", isp->isp_name)); break; case ASYNC_CHANGE_NOTIFY: + isp_mark_getpdb_all(isp); + /* + * Not correct, but it will force us to rescan the loop. + */ + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_PDB_RCVD; + isp_async(isp, ISPASYNC_CHANGE_NOTIFY, NULL); break; default: @@ -1873,635 +2635,42 @@ isp_parse_async(isp, mbox) return (fast_post_handle); } +/* + * Handle other response entries. A pointer to the request queue output + * index is here in case we want to eat several entries at once, although + * this is not used currently. + */ + static int isp_handle_other_response(isp, sp, optrp) struct ispsoftc *isp; ispstatusreq_t *sp; - u_int8_t *optrp; + u_int16_t *optrp; { - u_int8_t iptr, optr; - int reqsize = 0; - void *ireqp = NULL; -#ifdef ISP_TARGET_MODE - union { - at_entry_t *atio; - at2_entry_t *at2io; - ct_entry_t *ctio; - ct2_entry_t *ct2io; - lun_entry_t *lunen; - in_entry_t *inot; - in_fcentry_t *inot_fc; - na_entry_t *nack; - na_fcentry_t *nack_fc; - void *voidp; -#define atio un.atio -#define at2io un.at2io -#define ctio un.ctio -#define ct2io un.ct2io -#define lunen un.lunen -#define inot un.inot -#define inot_fc un.inot_fc -#define nack un.nack -#define nack_fc un.nack_fc - } un; - - un.voidp = sp; -#endif - - switch (sp->req_header.rqs_entry_type) { - case RQSTYPE_REQUEST: - return (-1); -#ifdef ISP_TARGET_MODE - case RQSTYPE_NOTIFY_ACK: - { - static const char *f = - "%s: Notify Ack Status 0x%x Sequence Id 0x%x\n" - /* - * The ISP is acknowleding our ack of an Immediate Notify. - */ - if (isp->isp_type & ISP_HA_FC) { - PRINTF(f, isp->isp_name, - nack_fc->na-status, nack_fc->na_seqid); - } else { - PRINTF(f, isp->isp_name, - nack->na_status, nack->na_seqid); - } - break; - } - case RQSTYPE_NOTIFY: - { - u_int16_t seqid, status; - - /* - * Either the ISP received a SCSI message it cannot handle - * or some other out of band condition (e.g., Port Logout) - * or it is returning an Immediate Notify entry we sent. - */ - if (isp->isp_type & ISP_HA_FC) { - status = inot_fc->status; - seqid = inot_fc->in_seqid; - } else { - status = inot->status; - seqid = inot->seqid & 0xff; - } - PRINTF("%s: Immediate Notify Status 0x%x Sequence Id 0x%x\n", - isp->isp_name, status, seqid); - - switch (status) { - case IN_MSG_RECEIVED: - case IN_IDE_RECEIVED: - ptisp_got_msg(ptp, &inot); - break; - case IN_RSRC_UNAVAIL: - PRINTF("%s: Firmware out of ATIOs\n", isp->isp_name); - break; - case IN_ABORT_TASK: - PRINTF("%s: Abort Task iid %d rx_id 0x%x\n", - inot_fc->in_iid, seqid); - break; - case IN_PORT_LOGOUT: - PRINTF("%s: Port Logout for Initiator %d\n", - isp->isp_name, inot_fc->in_iid); - break; - default: - PRINTF("%s: bad status (0x%x) in Immediate Notify\n", - isp->isp_name, status); - break; - - } - isp_notify_ack(isp, un.voidp); - reqsize = 0; - break; - } + case RQSTYPE_ATIO: + case RQSTYPE_CTIO0: case RQSTYPE_ENABLE_LUN: case RQSTYPE_MODIFY_LUN: - if (lunen->req_status != 1) { - PRINTF("%s: ENABLE/MODIFY LUN returned status 0x%x\n", - isp->isp_name, lunen->req_status); - } - break; + case RQSTYPE_NOTIFY: + case RQSTYPE_NOTIFY_ACK: + case RQSTYPE_CTIO1: case RQSTYPE_ATIO2: - { - fcparam *fcp = isp->isp_param; - ispctiot2_t local, *ct2 = NULL; - ispatiot2_t *at2 = (ispatiot2_t *) sp; - int s, lun; - -#ifdef ISP2100_SCCLUN - lun = at2->req_scclun; -#else - lun = at2->req_lun; -#endif - PRINTF("%s: atio2 loopid %d for lun %d rxid 0x%x flags0x%x " - "tflags0x%x ecodes0x%x rqstatus0x%x\n", isp->isp_name, - at2->req_initiator, lun, at2->req_rxid, - at2->req_flags, at2->req_taskflags, at2->req_execodes, - at2->req_status); - - switch (at2->req_status & ~ATIO_SENSEVALID) { - case ATIO_PATH_INVALID: - PRINTF("%s: ATIO2 Path Invalid\n", isp->isp_name); - break; - case ATIO_NOCAP: - PRINTF("%s: ATIO2 No Cap\n", isp->isp_name); - break; - case ATIO_BDR_MSG: - PRINTF("%s: ATIO2 BDR Received\n", isp->isp_name); - break; - case ATIO_CDB_RECEIVED: - ct2 = &local; - break; - default: - PRINTF("%s: unknown req_status 0x%x\n", isp->isp_name, - at2->req_status); - break; - } - if (ct2 == NULL) { - /* - * Just do an ACCEPT on this fellow. - */ - at2->req_header.rqs_entry_type = RQSTYPE_ATIO2; - at2->req_header.rqs_flags = 0; - at2->req_flags = 1; - ireqp = at2; - reqsize = sizeof (*at2); - break; - } - PRINTF("%s: datalen %d cdb0=0x%x\n", isp->isp_name, - at2->req_datalen, at2->req_cdb[0]); - MEMZERO((void *) ct2, sizeof (*ct2)); - ct2->req_header.rqs_entry_type = RQSTYPE_CTIO2; - ct2->req_header.rqs_entry_count = 1; - ct2->req_header.rqs_flags = 0; - ct2->req_header.rqs_seqno = isp->isp_seqno++; - ct2->req_handle = (at2->req_initiator << 16) | lun; -#ifndef ISP2100_SCCLUN - ct2->req_lun = lun; -#endif - ct2->req_initiator = at2->req_initiator; - ct2->req_rxid = at2->req_rxid; - - ct2->req_flags = CTIO_SEND_STATUS; - switch (at2->req_cdb[0]) { - case 0x0: /* TUR */ - ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE0; - ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID; - break; - - case 0x3: /* REQUEST SENSE */ - case 0x12: /* INQUIRE */ - ct2->req_flags |= CTIO_SEND_DATA | CTIO2_SMODE0; - ct2->req_m.mode0.req_scsi_status = CTIO2_STATUS_VALID; - ct2->req_seg_count = 1; - if (at2->req_cdb[0] == 0x12) { - s = sizeof (tgtiqd); - MEMCPY(fcp->isp_scratch, tgtiqd, s); - } else { - s = at2->req_datalen; - MEMZERO(fcp->isp_scratch, s); - } - ct2->req_m.mode0.req_dataseg[0].ds_base = - fcp->isp_scdma; - ct2->req_m.mode0.req_dataseg[0].ds_count = s; - ct2->req_m.mode0.req_datalen = s; -#if 1 - if (at2->req_datalen < s) { - ct2->req_m.mode1.req_scsi_status |= - CTIO2_RESP_VALID|CTIO2_RSPOVERUN; - } else if (at2->req_datalen > s) { - ct2->req_m.mode1.req_scsi_status |= - CTIO2_RESP_VALID|CTIO2_RSPUNDERUN; - } -#endif - break; - - default: /* ALL OTHERS */ - ct2->req_flags |= CTIO_NODATA | CTIO2_SMODE1; - ct2->req_m.mode1.req_scsi_status = 0; -#if 1 - if (at2->req_datalen) { - ct2->req_m.mode1.req_scsi_status |= - CTIO2_RSPUNDERUN; -#if BYTE_ORDER == BIG_ENDIAN - ct2->req_resid[1] = at2->req_datalen & 0xff; - ct2->req_resid[0] = - (at2->req_datalen >> 8) & 0xff; - ct2->req_resid[3] = - (at2->req_datalen >> 16) & 0xff; - ct2->req_resid[2] = - (at2->req_datalen >> 24) & 0xff; -#else - ct2->req_resid[0] = at2->req_datalen & 0xff; - ct2->req_resid[1] = - (at2->req_datalen >> 8) & 0xff; - ct2->req_resid[2] = - (at2->req_datalen >> 16) & 0xff; - ct2->req_resid[3] = - (at2->req_datalen >> 24) & 0xff; -#endif - } -#endif - if ((at2->req_status & ATIO_SENSEVALID) == 0) { - ct2->req_m.mode1.req_sense_len = 18; - ct2->req_m.mode1.req_scsi_status |= 2; - ct2->req_m.mode1.req_response[0] = 0x70; - ct2->req_m.mode1.req_response[2] = 0x2; - } else { - ct2->req_m.mode1.req_sense_len = 18; - ct2->req_m.mode1.req_scsi_status |= - at2->req_scsi_status; - MEMCPY(ct2->req_m.mode1.req_response, - at2->req_sense, sizeof (at2->req_sense)); - } - break; - } - reqsize = sizeof (*ct2); - ireqp = ct2; - break; - } case RQSTYPE_CTIO2: - { - ispatiot2_t *at2; - ispctiot2_t *ct2 = (ispctiot2_t *) sp; - PRINTF("%s: CTIO2 returned status 0x%x\n", isp->isp_name, - ct2->req_status); - /* - * Return the ATIO to the board. - */ - at2 = (ispatiot2_t *) sp; - at2->req_header.rqs_entry_type = RQSTYPE_ATIO2; - at2->req_header.rqs_entry_count = 1; - at2->req_header.rqs_flags = 0; - at2->req_header.rqs_seqno = isp->isp_seqno++; - at2->req_status = 1; - reqsize = sizeof (*at2); - ireqp = at2; - break; - } -#undef atio -#undef at2io -#undef ctio -#undef ct2io -#undef lunen -#undef inot -#undef inot_fc -#undef nack -#undef nack_fc + case RQSTYPE_CTIO3: +#ifdef ISP_TARGET_MODE + return (isp_target_entry(isp, sp)); +#else + /* FALLTHROUGH */ #endif + case RQSTYPE_REQUEST: default: - PRINTF("%s: other response type %x\n", isp->isp_name, + PRINTF("%s: unhandled response type 0x%x\n", isp->isp_name, sp->req_header.rqs_entry_type); - break; - } - if (reqsize) { - void *reqp; - optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); - iptr = isp->isp_reqidx; - reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); - if (iptr == optr) { - PRINTF("%s: Request Queue Overflow other response\n", - isp->isp_name); - } else { - MEMCPY(reqp, ireqp, reqsize); - ISP_WRITE(isp, INMAILBOX4, iptr); - isp->isp_reqidx = iptr; - } - } - return (0); -} - -#ifdef ISP_TARGET_MODE - -static void isp_tmd_newcmd_dflt __P((void *, tmd_cmd_t *)); -static void isp_tmd_event_dflt __P((void *, int)); -static void isp_tmd_notify_dflt __P((void *, tmd_notify_t *)); - -static void isp_tgt_data_xfer __P ((tmd_cmd_t *)); -static void isp_tgt_endcmd __P ((tmd_cmd_t *, u_int8_t)); -static void isp_tgt_done __P ((tmd_cmd_t *)); - -static void -isp_tmd_newcmd_dflt(arg0, cmdp) - void *arg0; - tmd_cmd_t *cmdp; -{ -} - -static void -isp_tmd_event_dflt(arg0, event) - void *arg0; - int event; -{ -} - -static void -isp_tmd_notify_dflt(arg0, npt) - void *arg0; - tmd_notify_t *npt; -{ -} - -/* - * Locks held, and ints disabled (if FC). - * - * XXX: SETUP ONLY FOR INITIAL ENABLING RIGHT NOW - */ -static int -isp_modify_lun(isp, lun, icnt, ccnt) - struct ispsoftc *isp; - int lun; /* logical unit to enable, modify, or disable */ - int icnt; /* immediate notify count */ - int ccnt; /* command count */ -{ - isplun_t *ip = NULL; - u_int8_t iptr, optr; - - optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); - iptr = isp->isp_reqidx; - ip = (isplun_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); - if (iptr == optr) { - PRINTF("%s: Request Queue Overflow in isp_modify_lun\n", - isp->isp_name); return (-1); } - - MEMZERO((void *) ip, sizeof (*ip)); - ip->req_header.rqs_entry_type = RQSTYPE_ENABLE_LUN; - ip->req_header.rqs_entry_count = 1; - ip->req_header.rqs_seqno = isp->isp_seqno++; - ip->req_handle = RQSTYPE_ENABLE_LUN; - if (isp->isp_type & ISP_HA_SCSI) { - ip->req_lun = lun; - } - ip->req_cmdcount = ccnt; - ip->req_imcount = icnt; - ip->req_timeout = 0; /* default 30 seconds */ - ISP_WRITE(isp, INMAILBOX4, iptr); - isp->isp_reqidx = iptr; - return (0); -} - -static void -isp_notify_ack(isp, ptrp) - struct ispsoftc *isp; - void *ptrp; -{ - void *reqp; - u_int8_t iptr, optr; - union { - na_fcentry_t _naf; - na_entry_t _nas; - } un; - - MEMZERO((caddr_t)&un, sizeof (un)); - un._nas.na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK; - un._nas.na_header.rqs_entry_count = 1; - - if (isp->isp_type & ISP_HA_FC) { - na_fcentry_t *na = &un._nas; - if (ptrp) { - in_fcentry_t *inp = ptrp; - na->na_iid = inp->in_iid; - na->na_lun = inp->in_lun; - na->na_task_flags = inp->in_task_flags; - na->na_seqid = inp->in_seqid; - na->na_status = inp->in_status; - } else { - na->na_flags = NAFC_RST_CLRD; - } - } else { - na_entry_t *na = &un._nas; - if (ptrp) { - in_entry_t *inp = ptrp; - na->na_iid = inp->in_iid; - na->na_lun = inp->in_lun; - na->na_tgt = inp->in_tgt; - na->na_seqid = inp->in_seqid; - } else { - na->na_flags = NA_RST_CLRD; - } - } - optr = isp->isp_reqodx = ISP_READ(isp, OUTMAILBOX4); - iptr = isp->isp_reqidx; - reqp = (void *) ISP_QUEUE_ENTRY(isp->isp_rquest, iptr); - iptr = ISP_NXT_QENTRY(iptr, RQUEST_QUEUE_LEN); - if (iptr == optr) { - PRINTF("%s: Request Queue Overflow For isp_notify_ack\n", - isp->isp_name); - } else { - MEMCPY(reqp, ireqp, sizeof (un)); - ISP_WRITE(isp, INMAILBOX4, iptr); - isp->isp_reqidx = iptr; - } } -/* - * These are dummy stubs for now until the outside framework is plugged in. - */ - -static void -isp_handle_atio (isp, aep) - struct ispsoftc *isp; - at_entry_t *aep; -{ - int status, connected; - tmd_cmd_t local, *cdp = &local; - - /* - * Get the ATIO status and see if we're still connected. - */ - status = aep->at_status; - connected = ((aep->at_flags & AT_NODISC) != 0); - - PRINTF("%s: ATIO status=0x%x, connected=%d\n", isp->isp_name, - status, connected); - - /* - * The firmware status (except for the SenseValid bit) indicates - * why this ATIO was sent to us. - * If SenseValid is set, the firware has recommended Sense Data. - * If the Disconnects Disabled bit is set in the flags field, - * we're still connected on the SCSI bus - i.e. the initiator - * did not set DiscPriv in the identify message. We don't care - * about this so it's ignored. - */ - switch (status & ~TGTSVALID) { - case AT_PATH_INVALID: - /* - * ATIO rejected by the firmware due to disabled lun. - */ - PRINTF("%s: Firmware rejected ATIO for disabled lun %d\n", - isp->isp_name, aep->at_lun); - break; - - case AT_PHASE_ERROR: - /* - * Bus Pase Sequence error. - * - * The firmware should have filled in the correct - * sense data. - */ - - - if (status & TGTSVALID) { - MEMCPY(&cdp->cd_sensedata, aep->at_sense, - sizeof (cdp->cd_sensedata)); - PRINTF("%s: Bus Phase Sequence error key 0x%x\n", - isp->isp_name, cdp->cd_sensedata[2] & 0xf); - } else { - PRINTF("%s: Bus Phase Sequence With No Sense\n", - isp->isp_name); - } - (*isp->isp_tmd_newcmd)(isp, cdp); - break; - - case AT_NOCAP: - /* - * Requested Capability not available - * We sent an ATIO that overflowed the firmware's - * command resource count. - */ - PRINTF("%s: Firmware rejected ATIO, command count overflow\n", - isp->isp_name); - break; - - case AT_BDR_MSG: - /* - * If we send an ATIO to the firmware to increment - * its command resource count, and the firmware is - * recovering from a Bus Device Reset, it returns - * the ATIO with this status. - */ - PRINTF("%s: ATIO returned with BDR received\n", isp->isp_name); - break; - - case AT_CDB: - /* - * New CDB - */ - cdp->cd_hba = isp; - cdp->cd_iid = aep->at_iid; - cdp->cd_tgt = aep->at_tgt; - cdp->cd_lun = aep->at_lun; - cdp->cd_tagtype = aep->at_tag_type; - cdp->cd_tagval = aep->at_tag_val; - MEMCPY(cdp->cd_cdb, aep->at_cdb, 16); - PRINTF("%s: CDB 0x%x itl %d/%d/%d\n", isp->isp_name, - cdp->cd_cdb[0], cdp->cd_iid, cdp->cd_tgt, cdp->cd_lun); - (*isp->isp_tmd_newcmd)(isp, cdp); - break; - - default: - PRINTF("%s: Unknown status (0x%x) in ATIO\n", - isp->isp_name, status); - cdp->cd_hba = isp; - cdp->cd_iid = aep->at_iid; - cdp->cd_tgt = aep->at_tgt; - cdp->cd_lun = aep->at_lun; - cdp->cd_tagtype = aep->at_tag_type; - cdp->cd_tagval = aep->at_tag_val; - isp_tgtcmd_done(cdp); - break; - } -} - -static void -isp_handle_atio2(isp, aep) - struct ispsoftc *isp; - at2_entry_t *aep; -{ - int status; - tmd_cmd_t local, *cdp = &local; - - /* - * Get the ATIO2 status. - */ - status = aep->at_status; - PRINTD("%s: ATIO2 status=0x%x\n", status); - - /* - * The firmware status (except for the SenseValid bit) indicates - * why this ATIO was sent to us. - * If SenseValid is set, the firware has recommended Sense Data. - */ - switch (status & ~TGTSVALID) { - case AT_PATH_INVALID: - /* - * ATIO rejected by the firmware due to disabled lun. - */ - PRINTF("%s: Firmware rejected ATIO2 for disabled lun %d\n", - isp->isp_name, aep->at_lun); - break; - - case AT_NOCAP: - /* - * Requested Capability not available - * We sent an ATIO that overflowed the firmware's - * command resource count. - */ - PRINTF("%s: Firmware rejected ATIO2, command count overflow\n", - isp->isp_name); - break; - - case AT_BDR_MSG: - /* - * If we send an ATIO to the firmware to increment - * its command resource count, and the firmware is - * recovering from a Bus Device Reset, it returns - * the ATIO with this status. - */ - PRINTF("%s: ATIO2 returned with BDR rcvd\n", isp->isp_name); - break; - - case AT_CDB: - /* - * New CDB - */ - cdp->cd_hba = isp; - cdp->cd_iid = aep->at_iid; - cdp->cd_tgt = 0; - cdp->cd_lun = aep->at_lun; - MEMCPY(cdp->cd_cdb, aep->at_cdb, 16); - cdp->cd_rxid = aep->at_rxid; - cdp->cp_origdlen = aep->at_datalen; - cdp->cp_totbytes = 0; - PRINTF("%s: CDB 0x%x rx_id 0x%x itl %d/%d/%d dlen %d\n", - isp->isp_name, cdp->cd_cdb[0], cdp->cd_tagval, cdp->cd_iid, - cdp->cd_tgt, cdp->cd_lun, aep->at_datalen); - (*isp->isp_tmd_newcmd)(isp, cdp); - break; - - default: - PRINTF("%s: Unknown status (0x%x) in ATIO2\n", - isp->isp_name, status); - cdp->cd_hba = isp; - cdp->cd_iid = aep->at_iid; - cdp->cd_tgt = aep->at_tgt; - cdp->cd_lun = aep->at_lun; - cdp->cp_rxid = aep->at_rxid; - isp_tgtcmd_done(cdp); - break; - } -} - -static void -isp_handle_ctio(isp, cep) - struct ispsoftc *isp; - ct_entry_t *aep; -{ -} - -static void -isp_handle_ctio2(isp, cep) - struct ispsoftc *isp; - at2_entry_t *aep; -{ -} -#endif - static void isp_parse_status(isp, sp, xs) struct ispsoftc *isp; @@ -2538,14 +2707,20 @@ isp_parse_status(isp, sp, xs) case RQCS_RESET_OCCURRED: IDPRINTF(2, ("%s: bus reset destroyed command for target %d " "lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs))); - isp->isp_sendmarker = 1; + /* + * XXX: Get port number for bus + */ + isp->isp_sendmarker = 3; XS_SETERR(xs, HBA_BUSRESET); return; case RQCS_ABORTED: PRINTF("%s: command aborted for target %d lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); - isp->isp_sendmarker = 1; + /* + * XXX: Get port number for bus + */ + isp->isp_sendmarker = 3; XS_SETERR(xs, HBA_ABORTED); return; @@ -2556,7 +2731,7 @@ isp_parse_status(isp, sp, xs) return; case RQCS_DATA_OVERRUN: - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { XS_RESID(xs) = sp->req_resid; break; } @@ -2631,7 +2806,7 @@ isp_parse_status(isp, sp, xs) break; case RQCS_DATA_UNDERRUN: - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { XS_RESID(xs) = sp->req_resid; /* an UNDERRUN is not a botch ??? */ } @@ -2661,9 +2836,9 @@ isp_parse_status(isp, sp, xs) break; case RQCS_QUEUE_FULL: - PRINTF("%s: internal queues full for target %d lun %d " + IDPRINTF(3, ("%s: internal queues full for target %d lun %d " "status 0x%x\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs), - XS_STS(xs)); + XS_STS(xs))); /* * If QFULL or some other status byte is set, then this * isn't an error, per se. @@ -2689,11 +2864,12 @@ isp_parse_status(isp, sp, xs) case RQCS_WIDE_FAILED: PRINTF("%s: Wide Negotiation failed for target %d lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { sdparam *sdp = isp->isp_param; - isp->isp_update = 1; + sdp += XS_CHANNEL(xs); sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_WIDE; sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; + isp->isp_update = XS_CHANNEL(xs)+1; } XS_SETERR(xs, HBA_NOERROR); return; @@ -2701,11 +2877,12 @@ isp_parse_status(isp, sp, xs) case RQCS_SYNCXFER_FAILED: PRINTF("%s: SDTR Message failed for target %d lun %d\n", isp->isp_name, XS_TGT(xs), XS_LUN(xs)); - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_SCSI(isp)) { sdparam *sdp = isp->isp_param; - isp->isp_update = 1; + sdp += XS_CHANNEL(xs); sdp->isp_devparam[XS_TGT(xs)].dev_flags &= ~DPARM_SYNC; sdp->isp_devparam[XS_TGT(xs)].dev_update = 1; + isp->isp_update = XS_CHANNEL(xs)+1; } break; @@ -2727,8 +2904,8 @@ isp_parse_status(isp, sp, xs) /* * It was there (maybe)- treat as a selection timeout. */ - PRINTF("%s: port logout for target %d\n", - isp->isp_name, XS_TGT(xs)); + IDPRINTF(2, ("%s: port logout for target %d\n", + isp->isp_name, XS_TGT(xs))); XS_SETERR(xs, HBA_SELTIMEOUT); return; @@ -2754,19 +2931,21 @@ isp_parse_status(isp, sp, xs) static void isp_fastpost_complete(isp, fph) struct ispsoftc *isp; - int fph; + u_int32_t fph; { ISP_SCSI_XFER_T *xs; - if (fph < 1) + if (fph < 1) { return; - xs = (ISP_SCSI_XFER_T *) isp->isp_xflist[fph - 1]; - isp->isp_xflist[fph - 1] = NULL; + } + xs = isp_find_xs(isp, fph); if (xs == NULL) { - PRINTF("%s: fast posting handle 0x%x not found\n", - isp->isp_name, fph - 1); + PRINTF("%s: command for fast posting handle 0x%x not found\n", + isp->isp_name, fph); return; } + isp_destroy_handle(isp, fph); + /* * Since we don't have a result queue entry item, * we must believe that SCSI status is zero and @@ -2775,9 +2954,11 @@ isp_fastpost_complete(isp, fph) XS_RESID(xs) = 0; XS_STS(xs) = 0; if (XS_XFRLEN(xs)) { - ISP_DMAFREE(isp, xs, fph - 1); + ISP_DMAFREE(isp, xs, fph); } XS_CMD_DONE(xs); + if (isp->isp_nactive) + isp->isp_nactive--; } #define HINIB(x) ((x) >> 0x4) @@ -2792,7 +2973,7 @@ static u_int8_t mbpcnt[] = { 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(1, 4), /* 0x08: MBOX_ABOUT_FIRMWARE */ MAKNIB(0, 0), /* 0x09: */ MAKNIB(0, 0), /* 0x0a: */ MAKNIB(0, 0), /* 0x0b: */ @@ -2816,8 +2997,8 @@ static u_int8_t mbpcnt[] = { MAKNIB(2, 4), /* 0x1d: MBOX_GET_DEV_QUEUE_STATUS */ MAKNIB(0, 0), /* 0x1e: */ MAKNIB(1, 3), /* 0x1f: MBOX_GET_FIRMWARE_STATUS */ - MAKNIB(1, 3), /* 0x20: MBOX_GET_INIT_SCSI_ID, MBOX_GET_LOOP_ID */ - MAKNIB(1, 2), /* 0x21: MBOX_GET_SELECT_TIMEOUT */ + MAKNIB(1, 4), /* 0x20: MBOX_GET_INIT_SCSI_ID, MBOX_GET_LOOP_ID */ + MAKNIB(1, 3), /* 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 */ @@ -2826,23 +3007,23 @@ static u_int8_t mbpcnt[] = { 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(1, 2), /* 0x2a: MBOX_GET_RESET_DELAY_PARAMS */ 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(2, 3), /* 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), /* 0x35: MBOX_SET_ACT_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(1, 2), /* 0x3a: MBOX_SET_RESET_DELAY_PARAMS */ MAKNIB(0, 0), /* 0x3b: */ MAKNIB(0, 0), /* 0x3c: */ MAKNIB(0, 0), /* 0x3d: */ @@ -2881,7 +3062,7 @@ static u_int8_t mbpcnt[] = { MAKNIB(0, 0), /* 0x5e: */ MAKNIB(0, 0), /* 0x5f: */ MAKNIB(8, 6), /* 0x60: MBOX_INIT_FIRMWARE */ - MAKNIB(0, 0), /* 0x60: MBOX_GET_INIT_CONTROL_BLOCK (FORMAT?) */ + MAKNIB(0, 0), /* 0x61: */ 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 */ @@ -2894,10 +3075,10 @@ static u_int8_t mbpcnt[] = { MAKNIB(8, 1), /* 0x6b: MBOX_GET_LINK_STATUS */ MAKNIB(4, 4), /* 0x6c: MBOX_INIT_LIP_RESET */ MAKNIB(0, 0), /* 0x6d: */ - MAKNIB(0, 0), /* 0x6e: */ - MAKNIB(0, 0), /* 0x6f: */ - MAKNIB(0, 0), /* 0x70: */ - MAKNIB(0, 0), /* 0x71: */ + MAKNIB(8, 2), /* 0x6e: MBOX_SEND_SNS */ + MAKNIB(4, 3), /* 0x6f: MBOX_FABRIC_LOGIN */ + MAKNIB(2, 1), /* 0x70: MBOX_SEND_CHANGE_REQUEST */ + MAKNIB(2, 1), /* 0x71: MBOX_FABRIC_LOGOUT */ MAKNIB(4, 1) /* 0x72: MBOX_INIT_LIP_LOGIN */ }; #define NMBCOM (sizeof (mbpcnt) / sizeof (mbpcnt[0])) @@ -2936,7 +3117,7 @@ isp_mboxcmd(isp, mbp) * Check for variants */ #ifdef ISP2100_SCCLUN - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { switch (mbp->param[0]) { case MBOX_ABORT: inparam = 7; @@ -2949,6 +3130,9 @@ isp_mboxcmd(isp, mbp) case MBOX_GET_DEV_QUEUE_STATUS: inparam = 3; break; + case MBOX_BUS_RESET: + inparam = 2; + break; default: break; } @@ -2963,13 +3147,18 @@ command_known: ISP_WRITE(isp, BIU_SEMA, 1); /* - * Make sure we can send some words. Check to see id there's - * an async mbox event pending. + * Qlogic Errata for the ISP2100 says that there is a necessary + * debounce between between writing the semaphore register + * and reading a mailbox register. I believe we're okay here. + */ + + /* + * Make sure we can send some words. + * Check to see if there's an async mbox event pending. */ loops = MBOX_DELAY_COUNT; while ((ISP_READ(isp, HCCR) & HCCR_HOST_INT) != 0) { - SYS_DELAY(100); if (ISP_READ(isp, BIU_SEMA) & 1) { int fph; u_int16_t mbox = ISP_READ(isp, OUTMAILBOX0); @@ -2978,6 +3167,8 @@ command_known: */ if (mbox & 0x8000) { fph = isp_parse_async(isp, (int) mbox); + IDPRINTF(5, ("%s: line %d, fph %d\n", + isp->isp_name, __LINE__, fph)); ISP_WRITE(isp, BIU_SEMA, 0); ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); if (fph < 0) { @@ -2994,13 +3185,16 @@ command_known: * just clear HOST INTERRUPT, so we'll just silently * eat this here. */ - if (mbox == MBOX_COMMAND_COMPLETE) { + if (mbox & 0x4000) { + IDPRINTF(5, ("%s: line %d, mbox 0x%x\n", + isp->isp_name, __LINE__, mbox)); ISP_WRITE(isp, BIU_SEMA, 0); ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT); SYS_DELAY(100); goto command_known; } } + SYS_DELAY(100); if (--loops < 0) { if (dld++ > 10) { PRINTF("%s: isp_mboxcmd could not get command " @@ -3014,23 +3208,31 @@ command_known: } /* - * If we're a 1080 or a 1240, make sure that for a couple of commands - * the port parameter is set. This is sort of a temporary solution - * to do it here rather than every place a mailbox command is formed. + * Write input parameters. + * + * Special case some of the setups for the dual port SCSI cards. + * XXX Eventually will be fixed by converting register write/read + * XXX counts to bitmasks. */ - if (IS_1080(isp) || IS_12X0(isp)) { - switch (mbp->param[0]) { - case MBOX_BUS_RESET: - mbp->param[2] = isp->isp_port; + if (IS_12X0(isp)) { + switch (opcode) { + case MBOX_GET_RETRY_COUNT: + case MBOX_SET_RETRY_COUNT: + ISP_WRITE(isp, INMAILBOX7, mbp->param[7]); + mbp->param[7] = 0; + ISP_WRITE(isp, INMAILBOX6, mbp->param[6]); + mbp->param[6] = 0; break; - default: + case MBOX_SET_ASYNC_DATA_SETUP_TIME: + case MBOX_SET_ACT_NEG_STATE: + case MBOX_SET_TAG_AGE_LIMIT: + case MBOX_SET_SELECT_TIMEOUT: + ISP_WRITE(isp, INMAILBOX2, mbp->param[2]); + mbp->param[2] = 0; break; } } - /* - * 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; @@ -3063,7 +3265,6 @@ command_known: */ ISP_WRITE(isp, BIU_SEMA, 0); - ENABLE_INTS(isp); /* * Set Host Interrupt condition so that RISC will pick up mailbox regs. */ @@ -3135,8 +3336,29 @@ command_known: } /* - * Pick up output parameters. + * Pick up output parameters. Special case some of the readbacks + * for the dual port SCSI cards. */ + if (IS_12X0(isp)) { + switch (opcode) { + case MBOX_GET_RETRY_COUNT: + case MBOX_SET_RETRY_COUNT: + mbp->param[7] = ISP_READ(isp, OUTMAILBOX7); + mbp->param[6] = ISP_READ(isp, OUTMAILBOX6); + break; + case MBOX_GET_TAG_AGE_LIMIT: + case MBOX_SET_TAG_AGE_LIMIT: + case MBOX_GET_ACT_NEG_STATE: + case MBOX_SET_ACT_NEG_STATE: + case MBOX_SET_ASYNC_DATA_SETUP_TIME: + case MBOX_GET_ASYNC_DATA_SETUP_TIME: + case MBOX_GET_RESET_DELAY_PARAMS: + case MBOX_SET_RESET_DELAY_PARAMS: + mbp->param[2] = ISP_READ(isp, OUTMAILBOX2); + break; + } + } + switch (outparam) { case 8: mbp->param[7] = ISP_READ(isp, OUTMAILBOX7); case 7: mbp->param[6] = ISP_READ(isp, OUTMAILBOX6); @@ -3177,8 +3399,9 @@ command_known: isp->isp_name, opcode); break; case MBOX_COMMAND_ERROR: - PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n", - isp->isp_name, opcode); + if (opcode != MBOX_ABOUT_FIRMWARE) + PRINTF("%s: mbox cmd %x failed with COMMAND_ERROR\n", + isp->isp_name, opcode); break; case MBOX_COMMAND_PARAM_ERROR: switch (opcode) { @@ -3195,16 +3418,25 @@ command_known: /* * Be silent about these... */ + case ASYNC_PDB_CHANGED: + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_PDB_RCVD; + break; case ASYNC_LIP_OCCURRED: + ((fcparam *) isp->isp_param)->isp_lipseq = mbp->param[1]; + /* FALLTHROUGH */ case ASYNC_LOOP_UP: + ((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_LIP_RCVD; + break; + case ASYNC_LOOP_DOWN: case ASYNC_LOOP_RESET: + ((fcparam *) isp->isp_param)->isp_fwstate = FW_CONFIG_WAIT; + ((fcparam *) isp->isp_param)->isp_loopstate = LOOP_NIL; + /* FALLTHROUGH */ case ASYNC_CHANGE_NOTIFY: break; - case ASYNC_PDB_CHANGED: - isp_mark_getpdb_all(isp); - break; default: /* @@ -3240,7 +3472,7 @@ isp_lostcmd(isp, xs) return; mbs.param[0] = MBOX_GET_DEV_QUEUE_STATUS; - mbs.param[1] = (XS_TGT(xs) << 8) | XS_LUN(xs); + 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"); @@ -3262,7 +3494,7 @@ isp_dumpregs(isp, msg) const char *msg; { PRINTF("%s: %s\n", isp->isp_name, msg); - if (isp->isp_type & ISP_HA_SCSI) + if (IS_SCSI(isp)) PRINTF(" biu_conf1=%x", ISP_READ(isp, BIU_CONF1)); else PRINTF(" biu_csr=%x", ISP_READ(isp, BIU2100_CSR)); @@ -3271,7 +3503,7 @@ isp_dumpregs(isp, msg) PRINTF("risc_hccr=%x\n", ISP_READ(isp, HCCR)); - if (isp->isp_type & ISP_HA_SCSI) { + 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), @@ -3293,53 +3525,50 @@ isp_dumpregs(isp, msg) } static void -isp_dumpxflist(isp) - struct ispsoftc *isp; -{ - volatile ISP_SCSI_XFER_T *xs; - int i, hdp; - - for (hdp = i = 0; i < RQUEST_QUEUE_LEN; i++) { - xs = isp->isp_xflist[i]; - if (xs == NULL) { - continue; - } - if (hdp == 0) { - PRINTF("%s: active requests\n", isp->isp_name); - hdp++; - } - PRINTF(" Active Handle %d: tgt %d lun %d dlen %d\n", - i+1, XS_TGT(xs), XS_LUN(xs), XS_XFRLEN(xs)); - } -} - -static void isp_fw_state(isp) struct ispsoftc *isp; { mbreg_t mbs; - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { 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) { + IDPRINTF(1, ("%s: isp_fw_state 0x%x\n", isp->isp_name, + mbs.param[0])); switch (mbs.param[0]) { case ASYNC_PDB_CHANGED: - isp_mark_getpdb_all(isp); - /* FALL THROUGH */ + 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: - case ASYNC_LOOP_DOWN: + 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++ < 2) { + if (once++ < 10) { goto again; } break; } - isp_dumpregs(isp, "GET FIRMWARE STATE failed"); + PRINTF("%s: GET FIRMWARE STATE failed (0x%x)\n", + isp->isp_name, mbs.param[0]); return; } fcp->isp_fwstate = mbs.param[1]; @@ -3350,22 +3579,39 @@ static void isp_update(isp) struct ispsoftc *isp; { + int bus; + + for (bus = 0; isp->isp_update != 0; bus++) { + if (isp->isp_update & (1 << bus)) { + isp_update_bus(isp, bus); + isp->isp_update ^= (1 << bus); + } + } +} + +static void +isp_update_bus(isp, bus) + struct ispsoftc *isp; + int bus; +{ int tgt; mbreg_t mbs; sdparam *sdp; - isp->isp_update = 0; - - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { return; } sdp = isp->isp_param; + sdp += bus; + for (tgt = 0; tgt < MAX_TARGETS; tgt++) { - u_int16_t flags, period, offset, changed; + u_int16_t flags, period, offset; int get; if (sdp->isp_devparam[tgt].dev_enable == 0) { + IDPRINTF(1, ("%s: skipping target %d bus %d update\n", + isp->isp_name, tgt, bus)); continue; } @@ -3378,6 +3624,13 @@ isp_update(isp) if (sdp->isp_devparam[tgt].dev_update) { mbs.param[0] = MBOX_SET_TARGET_PARAMS; mbs.param[2] = sdp->isp_devparam[tgt].dev_flags; + /* + * Insist that PARITY must be enabled if SYNC + * is enabled. + */ + if (mbs.param[2] & DPARM_SYNC) { + mbs.param[2] |= DPARM_PARITY; + } mbs.param[3] = (sdp->isp_devparam[tgt].sync_offset << 8) | (sdp->isp_devparam[tgt].sync_period); @@ -3396,6 +3649,11 @@ isp_update(isp) sdp->isp_devparam[tgt].cur_dflags &= ~DPARM_TQING; 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)); get = 0; } else if (sdp->isp_devparam[tgt].dev_refresh) { mbs.param[0] = MBOX_GET_TARGET_PARAMS; @@ -3404,7 +3662,7 @@ isp_update(isp) } else { continue; } - mbs.param[1] = tgt << 8; + 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 " @@ -3412,55 +3670,69 @@ isp_update(isp) tgt); continue; } - if (get == 0) { - /* - * XXX: Need a SYNC_TARGET for efficiency... - */ - isp->isp_sendmarker = 1; + isp->isp_sendmarker |= (1 << bus); continue; } flags = mbs.param[2]; period = mbs.param[3] & 0xff; offset = mbs.param[3] >> 8; - if (sdp->isp_devparam[tgt].cur_dflags != flags || - sdp->isp_devparam[tgt].cur_period != period || - sdp->isp_devparam[tgt].cur_offset != offset) { - IDPRINTF(3, ("%s: tgt %d flags 0x%x period %d " - "off %d\n", isp->isp_name, tgt, flags, - period, offset)); - changed = 1; - } else { - changed = 0; - } sdp->isp_devparam[tgt].cur_dflags = flags; sdp->isp_devparam[tgt].cur_period = period; sdp->isp_devparam[tgt].cur_offset = offset; - if (sdp->isp_devparam[tgt].dev_announced == 0 || changed) { - if (isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &tgt)) - sdp->isp_devparam[tgt].dev_announced = 0; - else - sdp->isp_devparam[tgt].dev_announced = 1; - } + get = (bus << 16) | tgt; + (void) isp_async(isp, ISPASYNC_NEW_TGT_PARAMS, &get); } } static void -isp_setdfltparm(isp) +isp_setdfltparm(isp, channel) struct ispsoftc *isp; + int channel; { int tgt; mbreg_t mbs; - sdparam *sdp; + sdparam *sdp, *sdp_chan0, *sdp_chan1; + + if (IS_FC(isp)) { + fcparam *fcp = (fcparam *) isp->isp_param; + fcp += channel; + if (fcp->isp_gotdparms) { + return; + } + fcp->isp_gotdparms = 1; + fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN; + fcp->isp_maxalloc = ICB_DFLT_ALLOC; + fcp->isp_execthrottle = ICB_DFLT_THROTTLE; + fcp->isp_retry_delay = ICB_DFLT_RDELAY; + fcp->isp_retry_count = ICB_DFLT_RCOUNT; + /* Platform specific.... */ + fcp->isp_loopid = DEFAULT_LOOPID(isp); + fcp->isp_nodewwn = DEFAULT_WWN(isp); + fcp->isp_portwwn = 0; + /* + * Now try and read NVRAM + */ + if ((isp->isp_confopts & (ISP_CFG_NONVRAM|ISP_CFG_OWNWWN)) || + (isp_read_nvram(isp))) { + PRINTF("%s: using Node WWN 0x%08x%08x\n", + isp->isp_name, (u_int32_t)(fcp->isp_nodewwn >> 32), + (u_int32_t)(fcp->isp_nodewwn & 0xffffffff)); + } + return; + } + + sdp_chan0 = (sdparam *) isp->isp_param; + sdp_chan1 = sdp_chan0 + 1; + sdp = sdp_chan0 + channel; /* * Been there, done that, got the T-shirt... */ - if (isp->isp_gotdparms) { - IDPRINTF(3, ("%s: already have dparms\n", isp->isp_name)); + if (sdp->isp_gotdparms) { return; } - isp->isp_gotdparms = 1; + sdp->isp_gotdparms = 1; /* * If we've not been told to avoid reading NVRAM, try and read it. @@ -3468,39 +3740,34 @@ isp_setdfltparm(isp) * tell us the right thing to do. Otherwise, establish some reasonable * defaults. */ - if ((isp->isp_confopts & ISP_CFG_NONVRAM) == 0) { if (isp_read_nvram(isp) == 0) { return; } } - if (IS_FC(isp)) { - fcparam *fcp = (fcparam *) isp->isp_param; - fcp->isp_maxfrmlen = ICB_DFLT_FRMLEN; - fcp->isp_maxalloc = 256; - fcp->isp_execthrottle = 16; - fcp->isp_retry_delay = 5; - fcp->isp_retry_count = 0; - /* - * It would be nice to fake up a WWN in case we don't - * get one out of NVRAM. Solaris does this for SOCAL - * cards that don't have SBus properties- it sets up - * a WWN based upon the system MAC Address. - */ - fcp->isp_wwn = 0; - return; - } - sdp = (sdparam *) isp->isp_param; + /* + * Now try and see whether we have specific values for them. + */ mbs.param[0] = MBOX_GET_ACT_NEG_STATE; isp_mboxcmd(isp, &mbs); if (mbs.param[0] != MBOX_COMMAND_COMPLETE) { IDPRINTF(2, ("could not GET ACT NEG STATE\n")); - sdp->isp_req_ack_active_neg = 1; - sdp->isp_data_line_active_neg = 1; + sdp_chan0->isp_req_ack_active_neg = 1; + sdp_chan0->isp_data_line_active_neg = 1; + if (IS_12X0(isp)) { + sdp_chan1->isp_req_ack_active_neg = 1; + sdp_chan1->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; + sdp_chan0->isp_req_ack_active_neg = (mbs.param[1] >> 4) & 0x1; + sdp_chan0->isp_data_line_active_neg = (mbs.param[1] >> 5) & 0x1; + if (IS_12X0(isp)) { + sdp_chan1->isp_req_ack_active_neg = + (mbs.param[2] >> 4) & 0x1; + sdp_chan1->isp_data_line_active_neg = + (mbs.param[2] >> 5) & 0x1; + } } /* @@ -3515,7 +3782,7 @@ isp_setdfltparm(isp) sdp->isp_devparam[tgt].dev_flags = DPARM_DEFAULT; sdp->isp_devparam[tgt].cur_dflags = 0; if (isp->isp_type < ISP_HA_SCSI_1040 || - (sdp->isp_clock && sdp->isp_clock < 60)) { + (isp->isp_clock && isp->isp_clock < 60)) { sdp->isp_devparam[tgt].sync_offset = ISP_10M_SYNCPARMS >> 8; sdp->isp_devparam[tgt].sync_period = @@ -3568,7 +3835,7 @@ isp_setdfltparm(isp) /* * It is not safe to run Ultra Mode with a clock < 60. */ - if (((sdp->isp_clock && sdp->isp_clock < 60) || + if (((isp->isp_clock && isp->isp_clock < 60) || (isp->isp_type < ISP_HA_SCSI_1020A)) && (sdp->isp_devparam[tgt].sync_period <= (ISP_20M_SYNCPARMS & 0xff))) { @@ -3580,23 +3847,24 @@ isp_setdfltparm(isp) } /* - * Set Default Host Adapter Parameters + * Establish default some more default parameters. */ 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 */ 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 = 128; + sdp->isp_max_queue_depth = MAXISPREQUEST; sdp->isp_tag_aging = 8; sdp->isp_bus_reset_delay = 3; - sdp->isp_retry_count = 0; - sdp->isp_retry_delay = 1; + sdp->isp_retry_count = 2; + sdp->isp_retry_delay = 2; for (tgt = 0; tgt < MAX_TARGETS; tgt++) { sdp->isp_devparam[tgt].exc_throttle = 16; @@ -3606,7 +3874,8 @@ isp_setdfltparm(isp) /* * Re-initialize the ISP and complete all orphaned commands - * with a 'botched' notice. + * with a 'botched' notice. The reset/init routines should + * not disturb an already active list of commands. * * Locks held prior to coming here. */ @@ -3615,13 +3884,12 @@ void isp_restart(isp) struct ispsoftc *isp; { - ISP_SCSI_XFER_T *tlist[RQUEST_QUEUE_LEN], *xs; - int i; + ISP_SCSI_XFER_T *xs; + u_int32_t handle; - for (i = 0; i < RQUEST_QUEUE_LEN; i++) { - tlist[i] = (ISP_SCSI_XFER_T *) isp->isp_xflist[i]; - isp->isp_xflist[i] = NULL; - } +#if 0 + isp->isp_gotdparms = 0; +#endif isp_reset(isp); if (isp->isp_state == ISP_RESETSTATE) { isp_init(isp); @@ -3632,15 +3900,20 @@ isp_restart(isp) if (isp->isp_state != ISP_RUNSTATE) { PRINTF("%s: isp_restart cannot restart ISP\n", isp->isp_name); } + isp->isp_nactive = 0; - for (i = 0; i < RQUEST_QUEUE_LEN; i++) { - xs = tlist[i]; - if (XS_NULL(xs)) { + for (handle = 1; handle <= (int) isp->isp_maxcmds; handle++) { + xs = isp_find_xs(isp, handle); + if (xs == NULL) { continue; } - if (isp->isp_nactive > 0) - isp->isp_nactive--; - XS_RESID(xs) = XS_XFRLEN(xs); + isp_destroy_handle(isp, handle); + if (XS_XFRLEN(xs)) { + ISP_DMAFREE(isp, xs, handle); + XS_RESID(xs) = XS_XFRLEN(xs); + } else { + XS_RESID(xs) = 0; + } XS_SETERR(xs, HBA_BUSRESET); XS_CMD_DONE(xs); } @@ -3654,6 +3927,8 @@ static int isp_read_nvram(isp) struct ispsoftc *isp; { + static char *tru = "true"; + static char *not = "false"; int i, amt; u_int8_t csum, minversion; union { @@ -3666,6 +3941,9 @@ isp_read_nvram(isp) if (IS_FC(isp)) { amt = ISP2100_NVRAM_SIZE; minversion = 1; + } else if (IS_1080(isp) || IS_12X0(isp)) { + amt = ISP1080_NVRAM_SIZE; + minversion = 0; } else { amt = ISP_NVRAM_SIZE; minversion = 2; @@ -3681,7 +3959,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\n", isp->isp_name); + 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]); } return (-1); } @@ -3701,7 +3981,124 @@ isp_read_nvram(isp) return (-1); } - if (isp->isp_type & ISP_HA_SCSI) { + if (IS_1080(isp) || IS_12X0(isp)) { + int bus; + sdparam *sdp = (sdparam *) isp->isp_param; + for (bus = 0; bus < (IS_1080(isp)? 1 : 2); bus++, sdp++) { + sdp->isp_fifo_threshold = + ISP1080_NVRAM_FIFO_THRESHOLD(nvram_data); + + sdp->isp_initiator_id = + ISP1080_NVRAM_INITIATOR_ID(nvram_data, bus); + + sdp->isp_bus_reset_delay = + ISP1080_NVRAM_BUS_RESET_DELAY(nvram_data, bus); + + sdp->isp_retry_count = + ISP1080_NVRAM_BUS_RETRY_COUNT(nvram_data, bus); + + sdp->isp_retry_delay = + ISP1080_NVRAM_BUS_RETRY_DELAY(nvram_data, bus); + + sdp->isp_async_data_setup = + ISP1080_NVRAM_ASYNC_DATA_SETUP_TIME(nvram_data, + bus); + + sdp->isp_req_ack_active_neg = + ISP1080_NVRAM_REQ_ACK_ACTIVE_NEGATION(nvram_data, + bus); + + sdp->isp_data_line_active_neg = + ISP1080_NVRAM_DATA_LINE_ACTIVE_NEGATION(nvram_data, + bus); + + sdp->isp_data_dma_burst_enabl = + ISP1080_NVRAM_BURST_ENABLE(nvram_data); + + sdp->isp_cmd_dma_burst_enable = + ISP1080_NVRAM_BURST_ENABLE(nvram_data); + + sdp->isp_selection_timeout = + ISP1080_NVRAM_SELECTION_TIMEOUT(nvram_data, bus); + + 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); + sdp->isp_devparam[i].exc_throttle = + ISP1080_NVRAM_TGT_EXEC_THROTTLE(nvram_data, i, bus); + sdp->isp_devparam[i].sync_offset = + ISP1080_NVRAM_TGT_SYNC_OFFSET(nvram_data, i, bus); + sdp->isp_devparam[i].sync_period = + ISP1080_NVRAM_TGT_SYNC_PERIOD(nvram_data, i, bus); + 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)) + sdp->isp_devparam[i].dev_flags |= DPARM_SYNC; + if (ISP1080_NVRAM_TGT_WIDE(nvram_data, i, bus)) + sdp->isp_devparam[i].dev_flags |= DPARM_WIDE; + if (ISP1080_NVRAM_TGT_PARITY(nvram_data, i, bus)) + sdp->isp_devparam[i].dev_flags |= DPARM_PARITY; + 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); + } + } + } + } else if (IS_SCSI(isp)) { sdparam *sdp = (sdparam *) isp->isp_param; sdp->isp_fifo_threshold = @@ -3754,10 +4151,8 @@ isp_read_nvram(isp) sdp->isp_max_queue_depth = ISP_NVRAM_MAX_QUEUE_DEPTH(nvram_data); - sdp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); + isp->isp_fast_mttr = ISP_NVRAM_FAST_MTTR_ENABLE(nvram_data); if (isp->isp_dblev > 2) { - static char *true = "true"; - static char *false = "false"; PRINTF("%s: NVRAM values:\n", isp->isp_name); PRINTF(" Fifo Threshold = 0x%x\n", sdp->isp_fifo_threshold); @@ -3776,15 +4171,15 @@ isp_read_nvram(isp) 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? true : false); + sdp->isp_req_ack_active_neg? tru : not); PRINTF(" Data Line Active Negation = %s\n", - sdp->isp_data_line_active_neg? true : false); + sdp->isp_data_line_active_neg? tru : not); PRINTF(" Data DMA Burst Enable = %s\n", - sdp->isp_data_dma_burst_enabl? true : false); + sdp->isp_data_dma_burst_enabl? tru : not); PRINTF(" Cmd DMA Burst Enable = %s\n", - sdp->isp_cmd_dma_burst_enable? true : false); + sdp->isp_cmd_dma_burst_enable? tru : not); PRINTF(" Fast MTTR = %s\n", - sdp->isp_fast_mttr? true : false); + isp->isp_fast_mttr? tru : not); } for (i = 0; i < MAX_TARGETS; i++) { sdp->isp_devparam[i].dev_enable = @@ -3858,19 +4253,41 @@ isp_read_nvram(isp) u_int32_t lo32; u_int32_t hi32; #endif - } wds; + } wd; u_int64_t full64; } wwnstore; wwnstore.full64 = ISP2100_NVRAM_NODE_NAME(nvram_data); - PRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name, - wwnstore.wds.hi32, wwnstore.wds.lo32); - fcp->isp_wwn = wwnstore.full64; + /* + * Broken PTI cards with nothing in the top nibble. Pah. + */ + if ((wwnstore.wd.hi32 >> 28) == 0) { + wwnstore.wd.hi32 |= (2 << 28); + CFGPRINTF("%s: (corrected) Adapter WWN 0x%08x%08x\n", + isp->isp_name, wwnstore.wd.hi32, wwnstore.wd.lo32); + } else { + CFGPRINTF("%s: Adapter WWN 0x%08x%08x\n", isp->isp_name, + wwnstore.wd.hi32, wwnstore.wd.lo32); + } + fcp->isp_nodewwn = wwnstore.full64; + + /* + * If the Node WWN has 2 in the top nibble, we can + * authoritatively construct a Port WWN by adding + * our unit number (plus one to make it nonzero) and + * putting it into bits 59..56. If the top nibble isn't + * 2, then we just set them identically. + */ + if ((fcp->isp_nodewwn >> 60) == 2) { + fcp->isp_portwwn = fcp->isp_nodewwn | + (((u_int64_t)(isp->isp_unit+1)) << 56); + } else { + fcp->isp_portwwn = fcp->isp_nodewwn; + } wwnstore.full64 = ISP2100_NVRAM_BOOT_NODE_NAME(nvram_data); if (wwnstore.full64 != 0) { PRINTF("%s: BOOT DEVICE WWN 0x%08x%08x\n", - isp->isp_name, wwnstore.wds.hi32, - wwnstore.wds.lo32); + isp->isp_name, wwnstore.wd.hi32, wwnstore.wd.lo32); } fcp->isp_maxalloc = ISP2100_NVRAM_MAXIOCBALLOCATION(nvram_data); @@ -3923,10 +4340,14 @@ isp_rdnvram_word(isp, wo, rp) ISP_WRITE(isp, BIU_NVRAM, BIU_NVRAM_SELECT|BIU_NVRAM_CLOCK); SYS_DELAY(2); - if (isp->isp_type & ISP_HA_FC) { + if (IS_FC(isp)) { wo &= ((ISP2100_NVRAM_SIZE >> 1) - 1); rqst = (ISP_NVRAM_READ << 8) | wo; cbits = 10; + } else if (IS_1080(isp) || IS_12X0(isp)) { + wo &= ((ISP1080_NVRAM_SIZE >> 1) - 1); + rqst = (ISP_NVRAM_READ << 8) | wo; + cbits = 10; } else { wo &= ((ISP_NVRAM_SIZE >> 1) - 1); rqst = (ISP_NVRAM_READ << 6) | wo; |