778128e3f9
Submitted by: The FreeBSD(98) Development Team Obtained from: NetBSD/pc98 based on NetBSD 1.2
1623 lines
34 KiB
C
1623 lines
34 KiB
C
/* $NetBSD$ */
|
|
/*
|
|
* [NetBSD for NEC PC98 series]
|
|
* Copyright (c) 1994, 1995, 1996 NetBSD/pc98 porting staff.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
/*
|
|
* Copyright (c) 1994, 1995, 1996 Naofumi HONDA. All rights reserved.
|
|
*/
|
|
|
|
#ifdef __NetBSD__
|
|
#include <dev/isa/bs/bsif.h>
|
|
#endif
|
|
#ifdef __FreeBSD__
|
|
#include <i386/isa/bs/bsif.h>
|
|
#endif
|
|
|
|
/*****************************************************************
|
|
* Inline phase funcs
|
|
*****************************************************************/
|
|
/* static inline declare */
|
|
static BS_INLINE struct targ_info *bs_reselect __P((struct bs_softc *));
|
|
static BS_INLINE void bs_sat_continue __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
static BS_INLINE struct targ_info *bs_selected __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
static BS_INLINE u_int8_t bs_read_1byte __P((struct bs_softc *));
|
|
static BS_INLINE void bs_write_1byte __P((struct bs_softc *, u_int8_t));
|
|
static BS_INLINE void bs_commandout __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
static BS_INLINE void bs_status_check __P((struct bs_softc *, struct targ_info *));
|
|
static BS_INLINE void bs_msgin __P((struct bs_softc *, struct targ_info *));
|
|
static BS_INLINE void bs_msgout __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
static BS_INLINE void bs_disconnect_phase __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
static void bs_phase_error __P((struct targ_info *, struct ccb *));
|
|
static int bs_scsi_cmd_poll_internal __P((struct targ_info *));
|
|
static int bs_xfer __P((struct bs_softc *, char *, int));
|
|
static void bs_io_xfer __P((struct targ_info *));
|
|
static void bs_quick_abort __P((struct targ_info *, u_int));
|
|
static void bs_msgin_error __P((struct targ_info *, u_int));
|
|
static void bs_msgin_ext __P((struct targ_info *));
|
|
static void bs_msg_reject __P((struct targ_info *));
|
|
static void bshoststart __P((struct bs_softc *, struct targ_info *));
|
|
|
|
/*****************************************************************
|
|
* Julian scsi interface
|
|
*****************************************************************/
|
|
XSBS_INT32T
|
|
bs_scsi_cmd(xs)
|
|
struct scsi_xfer *xs;
|
|
{
|
|
struct bs_softc *bsc = (struct bs_softc *) xs->sc_link->adapter_softc;
|
|
int s, target = (u_int) (xs->sc_link->target);
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
u_int flags = xs->flags;
|
|
|
|
if (xs->bp == NULL && (bsc->sc_openf & (1 << target)) == 0)
|
|
{
|
|
s = splbio();
|
|
xs->error = XS_DRIVER_STUFFUP;
|
|
xs->flags |= XSBS_ITSDONE;
|
|
scsi_done(xs);
|
|
splx(s);
|
|
return COMPLETE;
|
|
}
|
|
|
|
ti = bsc->sc_ti[target];
|
|
if ((cb = bs_get_ccb(flags & XSBS_SCSI_NOSLEEP)) == NULL)
|
|
return TRY_AGAIN_LATER;
|
|
|
|
/* make up ccb! */
|
|
cb->xs = xs;
|
|
cb->lun = xs->sc_link->lun;
|
|
cb->cmd = (u_int8_t *) xs->cmd;
|
|
cb->cmdlen = (int) xs->cmdlen;
|
|
cb->data = (u_int8_t *) xs->data;
|
|
cb->datalen = (int) xs->datalen;
|
|
cb->rcnt = 0;
|
|
cb->msgoutlen = 0;
|
|
cb->flags = (flags & XSBS_SCSI_POLL) ? BSFORCEIOPOLL : 0;
|
|
bs_targ_flags(ti, cb);
|
|
cb->tcmax = (xs->timeout >> 10);
|
|
if (cb->tcmax < BS_DEFAULT_TIMEOUT_SECOND)
|
|
cb->tcmax = BS_DEFAULT_TIMEOUT_SECOND;
|
|
|
|
#ifdef BS_ADDRESS_CHECK
|
|
/* XXX:
|
|
* Sanity check, however this is critical!
|
|
* NetBSD 1.0: WRONG
|
|
* NetBSD 1.1: OK
|
|
* FreeBSD: WRONG
|
|
*/
|
|
if ((caddr_t) cb->data < (caddr_t) KERNBASE)
|
|
{
|
|
u_int8_t *altbp;
|
|
|
|
altbp = (u_int8_t *) malloc(cb->datalen, M_DEVBUF, M_NOWAIT);
|
|
if (altbp == NULL)
|
|
{
|
|
bs_free_ccb(cb);
|
|
return TRY_AGAIN_LATER;
|
|
}
|
|
|
|
if (flags & SCSI_DATA_OUT)
|
|
bcopy(cb->data, altbp, cb->datalen);
|
|
else
|
|
bzero(altbp, cb->datalen);
|
|
|
|
cb->data = (u_int8_t *) altbp;
|
|
cb->flags |= BSALTBUF;
|
|
}
|
|
#endif /* BS_ADDRESS_CHECK */
|
|
|
|
s = splbio();
|
|
|
|
TAILQ_INSERT_TAIL(&ti->ti_ctab, cb, ccb_chain)
|
|
|
|
if (ti->ti_phase == FREE)
|
|
{
|
|
if (ti->ti_state == BS_TARG_START)
|
|
{
|
|
if ((flags & XSBS_SCSI_POLL) == 0)
|
|
bs_start_syncmsg(ti, NULL, BS_SYNCMSG_ASSERT);
|
|
}
|
|
bscmdstart(ti, BSCMDSTART);
|
|
}
|
|
|
|
if ((flags & XSBS_SCSI_POLL) == 0)
|
|
{
|
|
splx(s);
|
|
return SUCCESSFULLY_QUEUED;
|
|
}
|
|
|
|
bs_scsi_cmd_poll(ti, cb);
|
|
splx(s);
|
|
|
|
return COMPLETE;
|
|
}
|
|
|
|
/**************************************************
|
|
* ### NEXUS START and TERMINATE ###
|
|
**************************************************/
|
|
/*
|
|
* FLAGS : BSCMDRESTART restart in case of error.
|
|
*/
|
|
int
|
|
bscmdstart(ti, flags)
|
|
struct targ_info *ti;
|
|
int flags;
|
|
{
|
|
struct ccb *cb;
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
|
|
if ((cb = ti->ti_ctab.tqh_first) == NULL)
|
|
{
|
|
if (bsc->sc_nexus == NULL)
|
|
bshoststart(bsc, NULL);
|
|
return 0;
|
|
}
|
|
|
|
ti->ti_lun = cb->lun;
|
|
ti->ti_error = 0;
|
|
ti->ti_scsp.data = cb->data;
|
|
ti->ti_scsp.datalen = cb->datalen;
|
|
ti->ti_scsp.seglen = 0;
|
|
if (cb->rcnt)
|
|
cb->flags &= ~(BSSAT | BSLINK);
|
|
ti->ti_flags &= ~BSCFLAGSMASK;
|
|
ti->ti_flags |= cb->flags & BSCFLAGSMASK;
|
|
cb->tc = cb->tcmax;
|
|
|
|
/* GO GO */
|
|
if (ti->ti_phase == FREE)
|
|
{
|
|
if (bsc->sc_nexus == NULL)
|
|
bshoststart(bsc, ti);
|
|
else
|
|
{
|
|
if (flags & BSCMDRESTART)
|
|
bs_hostque_head(bsc, ti);
|
|
else
|
|
bs_hostque_tail(bsc, ti);
|
|
BS_SETUP_PHASE(HOSTQUEUE)
|
|
}
|
|
}
|
|
else if (bsc->sc_nexus == NULL)
|
|
bshoststart(bsc, NULL);
|
|
|
|
return 1;
|
|
}
|
|
|
|
struct ccb *
|
|
bscmddone(ti)
|
|
struct targ_info *ti;
|
|
{
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
struct ccb *cb = ti->ti_ctab.tqh_first;
|
|
struct scsi_xfer *xs;
|
|
int error;
|
|
|
|
if (ti->ti_state == BS_TARG_SYNCH)
|
|
{
|
|
if (bs_analyze_syncmsg(ti, cb))
|
|
return cb;
|
|
}
|
|
|
|
if (bsc->sc_p.datalen != 0)
|
|
ti->ti_error |= BSDMAABNORMAL;
|
|
|
|
cb->error = ti->ti_error;
|
|
|
|
do
|
|
{
|
|
xs = cb->xs;
|
|
error = XS_NOERROR;
|
|
|
|
if (cb->flags & (BSITSDONE | BSSENSECCB | BSCASTAT))
|
|
{
|
|
if (cb->flags & BSSENSECCB)
|
|
{
|
|
cb->error &= ~BSDMAABNORMAL;
|
|
if (cb->error == 0)
|
|
ti->ti_flags |= BSCASTAT;
|
|
|
|
ti->ti_flags |= BSERROROK;
|
|
}
|
|
else if (cb->flags & BSCASTAT)
|
|
{
|
|
if (ti->ti_flags & BSCASTAT)
|
|
{
|
|
ti->ti_flags &= ~BSCASTAT;
|
|
error = XS_SENSE;
|
|
if (xs)
|
|
xs->sense = ti->sense;
|
|
}
|
|
else
|
|
error = XS_DRIVER_STUFFUP;
|
|
|
|
ti->ti_flags |= BSERROROK;
|
|
} else
|
|
bs_panic(bsc, "internal error");
|
|
}
|
|
|
|
while (cb->error)
|
|
{
|
|
if (ti->ti_flags & BSERROROK)
|
|
break;
|
|
|
|
if (cb->rcnt >= bsc->sc_retry || (cb->error & BSFATALIO))
|
|
{
|
|
if (cb->error & (BSSELTIMEOUT | BSTIMEOUT))
|
|
error = XS_TIMEOUT;
|
|
else if (cb->error & BSTARGETBUSY)
|
|
error = XS_BUSY;
|
|
else
|
|
error = XS_DRIVER_STUFFUP;
|
|
break;
|
|
}
|
|
|
|
if (cb->error & BSREQSENSE)
|
|
{
|
|
/* must clear the target's sense state */
|
|
cb->rcnt++;
|
|
cb->flags |= (BSITSDONE | BSCASTAT);
|
|
cb->error &= ~BSREQSENSE;
|
|
return bs_request_sense(ti);
|
|
}
|
|
|
|
/* XXX: compat with upper driver */
|
|
if ((cb->error & BSDMAABNORMAL) &&
|
|
BSHW_CMD_CHECK(cb, BSERROROK))
|
|
{
|
|
cb->error &= ~BSDMAABNORMAL;
|
|
continue;
|
|
}
|
|
|
|
if ((xs && xs->bp) || (cb->error & BSSELTIMEOUT) == 0)
|
|
bs_debug_print(bsc, ti);
|
|
|
|
cb->rcnt++;
|
|
return cb;
|
|
}
|
|
|
|
#ifdef BS_DIAG
|
|
cb->flags |= BSITSDONE;
|
|
#endif /* BS_DIAG */
|
|
if (bsc->sc_poll)
|
|
{
|
|
bsc->sc_flags |= BSJOBDONE;
|
|
if (bsc->sc_outccb == cb)
|
|
bsc->sc_flags |= BSPOLLDONE;
|
|
}
|
|
|
|
TAILQ_REMOVE(&ti->ti_ctab, cb, ccb_chain)
|
|
|
|
if (xs)
|
|
{
|
|
#ifdef BS_ADDRESS_CHECK
|
|
if (cb->flags & BSALTBUF)
|
|
{
|
|
if (xs->flags & SCSI_DATA_IN)
|
|
bcopy(cb->data, xs->data, cb->datalen);
|
|
free(cb->data, M_DEVBUF);
|
|
}
|
|
#endif /* BS_ADDRESS_CHECK */
|
|
|
|
if ((xs->error = error) == XS_NOERROR)
|
|
xs->resid = 0;
|
|
xs->flags |= XSBS_ITSDONE;
|
|
scsi_done(xs);
|
|
}
|
|
|
|
bs_free_ccb(cb);
|
|
cb = ti->ti_ctab.tqh_first;
|
|
|
|
}
|
|
while (cb != NULL && (cb->flags & BSITSDONE) != 0);
|
|
|
|
/* complete */
|
|
return NULL;
|
|
}
|
|
|
|
/**************************************************
|
|
* ### PHASE FUNCTIONS ###
|
|
**************************************************/
|
|
/**************************************************
|
|
* <SELECTION PHASE>
|
|
**************************************************/
|
|
static void
|
|
bshoststart(bsc, ti)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
{
|
|
struct ccb *cb;
|
|
int s;
|
|
|
|
if (bsc->sc_flags & BSINACTIVE)
|
|
return;
|
|
|
|
again:
|
|
if (ti == NULL)
|
|
{
|
|
if ((ti = bsc->sc_sttab.tqh_first) == NULL)
|
|
return;
|
|
bs_hostque_delete(bsc, ti);
|
|
}
|
|
|
|
if ((cb = ti->ti_ctab.tqh_first) == NULL)
|
|
{
|
|
bs_printf(ti, "bshoststart", "Warning: No ccb");
|
|
BS_SETUP_PHASE(FREE);
|
|
ti = NULL;
|
|
goto again;
|
|
}
|
|
|
|
#ifdef BS_DIAG
|
|
if (cb->flags & BSITSDONE)
|
|
bs_panic(bsc, "bshoststart: already done");
|
|
|
|
if (bsc->sc_nexus || (ti->ti_flags & BSNEXUS))
|
|
{
|
|
char *s = ((ti->ti_flags & BSNEXUS) ?
|
|
"nexus already established" : "scsi board busy");
|
|
|
|
bs_debug_print(bsc, ti);
|
|
bs_printf(ti, "bshoststart", s);
|
|
}
|
|
#endif /* BS_DIAG */
|
|
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select++;
|
|
#endif /* BS_STATICS */
|
|
|
|
if (ti->ti_cfgflags & BS_SCSI_WAIT)
|
|
{
|
|
struct targ_info *tmpti;
|
|
|
|
for (tmpti = bsc->sc_titab.tqh_first; tmpti;
|
|
tmpti = tmpti->ti_tchain.tqe_next)
|
|
if (tmpti->ti_phase >= DISCONNECTED)
|
|
goto retry;
|
|
}
|
|
|
|
/* start selection */
|
|
ti->ti_status = ST_UNK;
|
|
if (bs_check_sat(ti))
|
|
{
|
|
if ((bshw_get_auxstat(bsc) & STR_BUSY) == 0)
|
|
{
|
|
BS_LOAD_SDP
|
|
bshw_set_dst_id(bsc, ti->ti_id, ti->ti_lun);
|
|
bshw_setup_ctrl_reg(bsc, ti->ti_cfgflags);
|
|
bshw_cmd_pass(bsc, 0);
|
|
bshw_set_sync_reg(bsc, ti->ti_sync);
|
|
bshw_issue_satcmd(bsc, cb, bs_check_link(ti, cb));
|
|
if (bs_check_smit(ti) || bsc->sc_p.datalen <= 0)
|
|
bshw_set_count(bsc, 0);
|
|
else
|
|
bs_dma_xfer(ti, BSHW_CMD_CHECK(cb, BSREAD));
|
|
|
|
s = splhigh();
|
|
if ((bshw_get_auxstat(bsc) & STR_BUSY) == 0)
|
|
{
|
|
/* XXX:
|
|
* Reload a lun again here.
|
|
*/
|
|
bshw_set_lun(bsc, ti->ti_lun);
|
|
bshw_start_sat(bsc, bs_check_disc(ti));
|
|
if ((bshw_get_auxstat(bsc) & STR_LCI) == 0)
|
|
{
|
|
splx(s);
|
|
BS_HOST_START
|
|
BS_SELECTION_START
|
|
BS_SETUP_PHASE(SATSEL);
|
|
ti->ti_omsgoutlen = 0;
|
|
ti->ti_msgout = bs_identify_msg(ti);
|
|
#ifdef BS_DIAG
|
|
ti->ti_flags |= BSNEXUS;
|
|
#endif /* BS_DIAG */
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_win++;
|
|
#endif /* BS_STATICS */
|
|
return;
|
|
}
|
|
}
|
|
splx(s);
|
|
|
|
if (bs_check_smit(ti) == 0)
|
|
bshw_dmaabort(bsc, ti);
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_miss_in_assert++;
|
|
#endif /* BS_STATICS */
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s = splhigh();
|
|
if ((bshw_get_auxstat(bsc) & STR_BUSY) == 0)
|
|
{
|
|
bshw_set_dst_id(bsc, ti->ti_id, ti->ti_lun);
|
|
bshw_setup_ctrl_reg(bsc, ti->ti_cfgflags);
|
|
bshw_set_sync_reg(bsc, ti->ti_sync);
|
|
bshw_assert_select(bsc);
|
|
|
|
if ((bshw_get_auxstat(bsc) & STR_LCI) == 0)
|
|
{
|
|
splx(s);
|
|
BS_HOST_START
|
|
BS_SELECTION_START
|
|
BS_SETUP_PHASE(SELECTASSERT);
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_win++;
|
|
#endif /* BS_STATICS */
|
|
return;
|
|
}
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_miss_in_assert++;
|
|
#endif /* BS_STATICS */
|
|
}
|
|
splx(s);
|
|
}
|
|
|
|
/* RETRY LATER */
|
|
retry:
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_miss++;
|
|
#endif /* BS_STATICS */
|
|
bs_hostque_head(bsc, ti);
|
|
BS_SETUP_PHASE(HOSTQUEUE)
|
|
}
|
|
|
|
static BS_INLINE struct targ_info *
|
|
bs_selected(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
|
|
if (bsc->sc_busstat != BSR_SELECTED)
|
|
{
|
|
bs_phase_error(ti, cb);
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef BS_DIAG
|
|
if (bsc->sc_selwait != ti)
|
|
panic("%s selection internal error\n", bsc->sc_dvname);
|
|
|
|
ti->ti_flags |= BSNEXUS;
|
|
#endif /* BS_DIAG */
|
|
|
|
/* clear select wait state */
|
|
BS_SETUP_PHASE(SELECTED);
|
|
BS_SELECTION_TERMINATE;
|
|
BS_LOAD_SDP
|
|
return ti;
|
|
}
|
|
|
|
/**************************************************
|
|
* <RESELECTION>
|
|
**************************************************/
|
|
static BS_INLINE struct targ_info *
|
|
bs_reselect(bsc)
|
|
struct bs_softc *bsc;
|
|
{
|
|
u_int target;
|
|
struct targ_info *ti;
|
|
|
|
/* check collision */
|
|
if ((ti = bsc->sc_selwait) != NULL)
|
|
{
|
|
if (ti->ti_phase == SATSEL)
|
|
{
|
|
#ifdef BS_DIAG
|
|
ti->ti_flags &= ~BSNEXUS;
|
|
#endif /* BS_DIAG */
|
|
ti->ti_msgout = 0;
|
|
if (bs_check_smit(ti) == 0)
|
|
bshw_dmaabort(bsc, ti);
|
|
}
|
|
bs_hostque_head(bsc, ti);
|
|
BS_SELECTION_TERMINATE
|
|
BS_SETUP_PHASE(HOSTQUEUE)
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].select_miss_by_reselect++;
|
|
bs_statics[ti->ti_id].select_miss++;
|
|
#endif /* BS_STATICS */
|
|
}
|
|
|
|
/* who are you ? */
|
|
target = bshw_get_src_id(bsc);
|
|
if ((ti = bsc->sc_ti[target]) == NULL)
|
|
{
|
|
bs_debug_print_all(bsc);
|
|
printf("reselect: miss reselect. target(%d)\n", target);
|
|
bs_reset_nexus(bsc);
|
|
return NULL;
|
|
}
|
|
|
|
/* confirm nexus */
|
|
BS_HOST_START
|
|
bshw_setup_ctrl_reg(bsc, ti->ti_cfgflags);
|
|
if (ti->ti_ctab.tqh_first == NULL || ti->ti_phase != DISCONNECTED)
|
|
{
|
|
bs_printf(ti, "reselect", "phase mismatch");
|
|
BS_SETUP_PHASE(UNDEF)
|
|
bs_force_abort(ti);
|
|
bs_hostque_delete(bsc, ti);
|
|
}
|
|
else
|
|
bsc->sc_dtgnum --;
|
|
|
|
/* recover host */
|
|
bshw_set_dst_id(bsc, ti->ti_id, ti->ti_lun);
|
|
bshw_set_sync_reg(bsc, ti->ti_sync);
|
|
BS_RESTORE_SDP
|
|
BS_SETUP_PHASE(RESELECTED)
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].reselect++;
|
|
#endif /* BS_STATICS */
|
|
return ti;
|
|
}
|
|
|
|
static BS_INLINE void
|
|
bs_sat_continue(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
|
|
BS_SETUP_PHASE(SATRESEL);
|
|
bshw_set_dst_id(bsc, ti->ti_id, ti->ti_lun);
|
|
bshw_cmd_pass(bsc, 0x44);
|
|
bshw_set_sync_reg(bsc, ti->ti_sync);
|
|
bshw_issue_satcmd(bsc, cb, 0);
|
|
if (bs_check_smit(ti) || bsc->sc_p.datalen <= 0)
|
|
bshw_set_count(bsc, 0);
|
|
else
|
|
bs_dma_xfer(ti, BSHW_CMD_CHECK(cb, BSREAD));
|
|
bshw_set_lun(bsc, ti->ti_lun); /* XXX */
|
|
bshw_start_sat(bsc, 0);
|
|
}
|
|
|
|
/*************************************************
|
|
* <DATA PHASE>
|
|
*************************************************/
|
|
#define DR (STR_BSY | STR_DBR)
|
|
|
|
void
|
|
bs_poll_timeout(bsc, s)
|
|
struct bs_softc *bsc;
|
|
char *s;
|
|
{
|
|
struct targ_info *ti;
|
|
|
|
bs_printf(NULL, s, "timeout");
|
|
bsc->sc_flags |= BSRESET;
|
|
if ((ti = bsc->sc_nexus) && ti->ti_ctab.tqh_first)
|
|
ti->ti_error |= BSTIMEOUT;
|
|
}
|
|
|
|
static BS_INLINE u_int8_t
|
|
bs_read_1byte(bsc)
|
|
struct bs_softc *bsc;
|
|
{
|
|
register u_int wc;
|
|
|
|
bshw_start_sxfer(bsc);
|
|
for (wc = bsc->sc_wc; (bshw_get_auxstat(bsc) & DR) != DR && --wc; );
|
|
if (wc)
|
|
return bshw_read_data(bsc);
|
|
else
|
|
bs_poll_timeout(bsc, "read_1byte");
|
|
|
|
return 0;
|
|
}
|
|
|
|
static BS_INLINE void
|
|
bs_write_1byte(bsc, data)
|
|
struct bs_softc *bsc;
|
|
u_int8_t data;
|
|
{
|
|
register u_int wc;
|
|
|
|
bshw_start_sxfer(bsc);
|
|
for (wc = bsc->sc_wc; (bshw_get_auxstat(bsc) & DR) != DR && --wc; );
|
|
if (wc)
|
|
bshw_write_data(bsc, data);
|
|
else
|
|
bs_poll_timeout(bsc, "write_1byte");
|
|
}
|
|
|
|
static int
|
|
bs_xfer(bsc, data, len)
|
|
struct bs_softc *bsc;
|
|
char *data;
|
|
int len;
|
|
{
|
|
u_int8_t aux;
|
|
u_int count, wc;
|
|
|
|
bshw_set_count(bsc, len);
|
|
bshw_start_xfer(bsc);
|
|
|
|
for (count = 0, wc = bsc->sc_wc; count < len && --wc; )
|
|
{
|
|
if (((aux = bshw_get_auxstat(bsc)) & DR) == DR)
|
|
{
|
|
if (bsc->sc_busstat & BSHW_READ)
|
|
*(data++) = bshw_read_data(bsc);
|
|
else
|
|
bshw_write_data(bsc, *(data++));
|
|
count++;
|
|
wc = bsc->sc_wc;
|
|
}
|
|
|
|
if (aux & STR_INT)
|
|
break;
|
|
}
|
|
|
|
if (wc == 0)
|
|
bs_poll_timeout(bsc, "bs_xfer");
|
|
|
|
return count;
|
|
}
|
|
#undef DR
|
|
|
|
static void
|
|
bs_io_xfer(ti)
|
|
struct targ_info *ti;
|
|
{
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
struct sc_p *sp = &bsc->sc_p;
|
|
u_int count, dummy;
|
|
|
|
/* switch dma trasnfr mode */
|
|
bshw_set_poll_trans(bsc, ti->ti_cfgflags);
|
|
sp->seglen = 0;
|
|
sp->bufp = NULL;
|
|
|
|
if (sp->datalen <= 0)
|
|
{
|
|
ti->ti_error |= BSDMAABNORMAL;
|
|
dummy = 0;
|
|
count = bs_xfer(bsc, (u_int8_t *) &dummy, 1);
|
|
}
|
|
else
|
|
count = bs_xfer(bsc, sp->data, sp->datalen);
|
|
|
|
sp->data += count;
|
|
sp->datalen -= count;
|
|
}
|
|
|
|
/************************************************
|
|
* <COMMAND PHASE>
|
|
************************************************/
|
|
static BS_INLINE void
|
|
bs_commandout(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
u_int8_t scsi_cmd[16];
|
|
int len;
|
|
|
|
BS_SETUP_PHASE(CMDPHASE);
|
|
|
|
if (bs_check_link(ti, cb))
|
|
{
|
|
bcopy(cb->cmd, scsi_cmd, cb->cmdlen);
|
|
scsi_cmd[cb->cmdlen - 1] |= 0x01;
|
|
len = bs_xfer(bsc, scsi_cmd, cb->cmdlen);
|
|
}
|
|
else
|
|
len = bs_xfer(bsc, cb->cmd, cb->cmdlen);
|
|
|
|
if (len != cb->cmdlen)
|
|
ti->ti_error |= BSCMDABNORMAL;
|
|
}
|
|
|
|
/************************************************
|
|
* <STATUS IN>
|
|
************************************************/
|
|
static BS_INLINE void
|
|
bs_status_check(bsc, ti)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
{
|
|
|
|
if (ti->ti_status == ST_GOOD || ti->ti_status == ST_INTERGOOD)
|
|
return;
|
|
|
|
switch (ti->ti_status)
|
|
{
|
|
case ST_MET:
|
|
case ST_INTERMET:
|
|
case ST_CHKCOND:
|
|
ti->ti_error |= BSREQSENSE;
|
|
break;
|
|
|
|
case ST_BUSY:
|
|
ti->ti_error |= BSTARGETBUSY;
|
|
break;
|
|
|
|
default:
|
|
ti->ti_error |= BSSTATUSERROR;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* <MSG IN>
|
|
************************************************/
|
|
#define MSGWAIT(cnt) { if (ti->ti_msginptr < (cnt)) return; }
|
|
|
|
static void
|
|
bs_quick_abort(ti, msg)
|
|
struct targ_info *ti;
|
|
u_int msg;
|
|
{
|
|
struct ccb *cb;
|
|
|
|
if ((cb = ti->ti_ctab.tqh_first) == NULL)
|
|
return;
|
|
|
|
cb->msgoutlen = 1;
|
|
cb->msgout[0] = msg;
|
|
cb->rcnt++;
|
|
|
|
ti->ti_error |= BSMSGERROR;
|
|
}
|
|
|
|
static void
|
|
bs_msgin_error(ti, count)
|
|
struct targ_info *ti;
|
|
u_int count;
|
|
{
|
|
int n;
|
|
|
|
MSGWAIT(count);
|
|
|
|
bs_printf(ti, "msgin", "illegal msg");
|
|
|
|
for (n = 0; n < ti->ti_msginptr; n ++)
|
|
printf("[0x%x] ", (u_int) ti->ti_msgin[n]);
|
|
printf("\n");
|
|
|
|
bs_quick_abort(ti, MSG_REJECT);
|
|
ti->ti_msginptr = 0;
|
|
}
|
|
|
|
static void
|
|
bs_msgin_ext(ti)
|
|
struct targ_info *ti;
|
|
{
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
struct ccb *cb = ti->ti_ctab.tqh_first;
|
|
int count;
|
|
u_int reqlen;
|
|
u_int32_t *ptr;
|
|
struct msgbase msg;
|
|
|
|
MSGWAIT(2);
|
|
|
|
reqlen = ti->ti_msgin[1];
|
|
if (reqlen == 0)
|
|
reqlen = 256;
|
|
|
|
if (ti->ti_msginptr >= MAXMSGLEN)
|
|
ti->ti_msginptr = 3; /* XXX */
|
|
|
|
MSGWAIT(reqlen + 2);
|
|
|
|
switch (MKMSG_EXTEND(ti->ti_msgin[1], ti->ti_msgin[2]))
|
|
{
|
|
case MKMSG_EXTEND(MSG_EXTEND_MDPLEN, MSG_EXTEND_MDPCODE):
|
|
ptr = (u_int32_t *)(&ti->ti_msgin[3]);
|
|
count = (int) htonl((long) (*ptr));
|
|
|
|
bsc->sc_p.seglen = ti->ti_scsp.seglen = 0;
|
|
if (bsc->sc_p.datalen - count >= 0 &&
|
|
bsc->sc_p.datalen - count <= cb->datalen)
|
|
{
|
|
bsc->sc_p.datalen -= count;
|
|
bsc->sc_p.data += count;
|
|
}
|
|
else
|
|
bs_msgin_error(ti, 7);
|
|
break;
|
|
|
|
case MKMSG_EXTEND(MSG_EXTEND_SYNCHLEN, MSG_EXTEND_SYNCHCODE):
|
|
ti->ti_syncnow.period = ti->ti_msgin[3];
|
|
ti->ti_syncnow.offset = ti->ti_msgin[4];
|
|
if (ti->ti_syncnow.offset == 0)
|
|
ti->ti_syncnow.period = 0;
|
|
|
|
if (ti->ti_syncnow.state != BS_SYNCMSG_ASSERT)
|
|
{
|
|
bs_start_syncmsg(ti, NULL, BS_SYNCMSG_REQUESTED);
|
|
bscmdstart(ti, BSCMDSTART);
|
|
}
|
|
else
|
|
BS_SETUP_SYNCSTATE(BS_SYNCMSG_ACCEPT)
|
|
break;
|
|
|
|
case MKMSG_EXTEND(MSG_EXTEND_WIDELEN, MSG_EXTEND_WIDECODE):
|
|
msg.msglen = MSG_EXTEND_WIDELEN + 2;
|
|
msg.msg[0] = MSG_EXTEND;
|
|
msg.msg[1] = MSG_EXTEND_WIDELEN;
|
|
msg.msg[2] = MSG_EXTEND_WIDECODE;
|
|
msg.msg[3] = 0;
|
|
msg.flag = 0;
|
|
bs_make_msg_ccb(ti, cb->lun, cb, &msg, 0);
|
|
break;
|
|
|
|
default:
|
|
bs_msgin_error(ti, 0);
|
|
return;
|
|
}
|
|
|
|
ti->ti_msginptr = 0;
|
|
return;
|
|
}
|
|
|
|
static void
|
|
bs_msg_reject(ti)
|
|
struct targ_info *ti;
|
|
{
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
struct ccb *cb = ti->ti_ctab.tqh_first;
|
|
char *s = "unexpected msg reject";
|
|
|
|
switch (ti->ti_ophase)
|
|
{
|
|
case CMDPHASE:
|
|
s = "cmd rejected";
|
|
cb->flags &= ~BSLINK;
|
|
BS_SETUP_MSGPHASE(IOCOMPLETED);
|
|
break;
|
|
|
|
case MSGOUT:
|
|
if (ti->ti_msgout & 0x80)
|
|
{
|
|
s = "identify msg rejected";
|
|
cb->flags &= ~BSDISC;
|
|
BS_SETUP_MSGPHASE(IOCOMPLETED);
|
|
}
|
|
else if (ti->ti_msgout == MSG_EXTEND)
|
|
{
|
|
switch (ti->ti_emsgout)
|
|
{
|
|
case MSG_EXTEND_SYNCHCODE:
|
|
BS_SETUP_SYNCSTATE(BS_SYNCMSG_REJECT);
|
|
return;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
bs_debug_print(bsc, ti);
|
|
bs_printf(ti, "msgin", s);
|
|
ti->ti_error |= BSMSGERROR;
|
|
}
|
|
|
|
static BS_INLINE void
|
|
bs_msgin(bsc, ti)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
{
|
|
|
|
BS_SETUP_PHASE(MSGIN);
|
|
|
|
switch (ti->ti_msgin[0])
|
|
{
|
|
case MSG_SAVESP:
|
|
BS_SAVE_SDP
|
|
break;
|
|
|
|
case MSG_RESTORESP:
|
|
BS_RESTORE_SDP
|
|
bs_printf(ti, "msgin", "restore scsi pointer");
|
|
break;
|
|
|
|
case MSG_REJECT:
|
|
bs_msg_reject(ti);
|
|
break;
|
|
|
|
case 0xf:
|
|
break;
|
|
|
|
case MSG_I_ERROR:/* all I -> T : nothing to do*/
|
|
case MSG_ABORT:
|
|
case MSG_PARITY:
|
|
case MSG_RESET:
|
|
case 0xe:
|
|
bs_msgin_error(ti, 1);
|
|
goto resume;
|
|
|
|
case MSG_NOOP:
|
|
break;
|
|
|
|
case MSG_EXTEND:
|
|
bs_msgin_ext(ti);
|
|
goto resume;
|
|
|
|
case 0xd:
|
|
bs_msgin_error(ti, 2);
|
|
goto resume;
|
|
|
|
case MSG_DISCON:
|
|
BS_SETUP_MSGPHASE(DISCONNECTASSERT);
|
|
break;
|
|
|
|
case MSG_COMP:
|
|
BS_SETUP_MSGPHASE(IOCOMPLETED);
|
|
break;
|
|
|
|
case MSG_LCOMP:
|
|
case MSG_LCOMP_F:
|
|
bs_status_check(bsc, ti);
|
|
if (bscmddone(ti) == NULL)
|
|
{
|
|
if (bscmdstart(ti, BSCMDSTART) == 0)
|
|
{
|
|
bs_printf(ti, "msgin", "cmd line miss");
|
|
bs_force_abort(ti);
|
|
}
|
|
}
|
|
else
|
|
bscmdstart(ti, BSCMDRESTART);
|
|
#ifdef BS_STATICS
|
|
bs_linkcmd_count[ti->ti_id]++;
|
|
#endif /* BS_STATICS */
|
|
BS_LOAD_SDP
|
|
ti->ti_status = ST_UNK;
|
|
break;
|
|
|
|
default:
|
|
if (ti->ti_msgin[0] & 0x80)
|
|
{
|
|
if ((ti->ti_msgin[0] & 0x07) != ti->ti_lun)
|
|
{
|
|
ti->ti_lun = (ti->ti_msgin[0] & 0x07);
|
|
bshw_set_dst_id(bsc, ti->ti_id, ti->ti_lun);
|
|
bshw_set_sync_reg(bsc, ti->ti_sync);
|
|
|
|
bs_printf(ti, "msgin", "lun error");
|
|
bs_quick_abort(ti, MSG_ABORT);
|
|
}
|
|
break;
|
|
}
|
|
else if (ti->ti_msgin[0] < 0x20)
|
|
bs_msgin_error(ti, 1);
|
|
else if (ti->ti_msgin[0] < 0x30)
|
|
bs_msgin_error(ti, 2);
|
|
else
|
|
bs_msgin_error(ti, 1);
|
|
goto resume;
|
|
}
|
|
|
|
ti->ti_msginptr = 0;
|
|
|
|
resume:
|
|
return;
|
|
}
|
|
|
|
/************************************************
|
|
* <MSG OUT>
|
|
************************************************/
|
|
static BS_INLINE void
|
|
bs_msgout(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
u_int8_t msg[MAXMSGLEN + 1];
|
|
|
|
if (ti->ti_phase == MSGOUT)
|
|
{
|
|
if (cb->rcnt ++ < bsc->sc_retry)
|
|
cb->msgoutlen = ti->ti_omsgoutlen;
|
|
}
|
|
else
|
|
BS_SETUP_PHASE(MSGOUT);
|
|
|
|
if (ti->ti_ophase == SELECTED)
|
|
{
|
|
identify:
|
|
if (cb->msgoutlen == 0)
|
|
{
|
|
ti->ti_msgout = bs_identify_msg(ti);
|
|
ti->ti_omsgoutlen = 0;
|
|
bs_write_1byte(bsc, ti->ti_msgout);
|
|
}
|
|
else
|
|
{
|
|
if (cb->msgout[0] != MSG_RESET &&
|
|
cb->msgout[0] != MSG_ABORT)
|
|
{
|
|
msg[0] = bs_identify_msg(ti);
|
|
bcopy(cb->msgout, &msg[1], cb->msgoutlen);
|
|
bs_xfer(bsc, msg, cb->msgoutlen + 1);
|
|
}
|
|
else
|
|
bs_xfer(bsc, cb->msgout, cb->msgoutlen);
|
|
|
|
ti->ti_msgout = cb->msgout[0];
|
|
ti->ti_emsgout = cb->msgout[2];
|
|
ti->ti_omsgoutlen = cb->msgoutlen;
|
|
cb->msgoutlen = 0;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (ti->ti_ophase == SATSEL)
|
|
{
|
|
/* XXX:
|
|
* Maybe identify msg rejected due to
|
|
* a parity error in target side.
|
|
*/
|
|
|
|
bs_printf(ti, "msgout", "msg identify retry (SAT)");
|
|
goto identify;
|
|
}
|
|
|
|
if (cb->msgoutlen == 0)
|
|
{
|
|
ti->ti_msgout = MSG_REJECT;
|
|
ti->ti_omsgoutlen = 0;
|
|
bs_write_1byte(bsc, ti->ti_msgout);
|
|
}
|
|
else
|
|
{
|
|
ti->ti_msgout = cb->msgout[0];
|
|
ti->ti_emsgout = cb->msgout[2];
|
|
ti->ti_omsgoutlen = cb->msgoutlen;
|
|
bs_xfer(bsc, cb->msgout, cb->msgoutlen);
|
|
cb->msgoutlen = 0;
|
|
}
|
|
}
|
|
|
|
/************************************************
|
|
* <DISCONNECT>
|
|
************************************************/
|
|
static BS_INLINE void
|
|
bs_disconnect_phase(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
|
|
switch (bsc->sc_msgphase)
|
|
{
|
|
default:
|
|
panic("%s unknown msg phase\n", bsc->sc_dvname);
|
|
break;
|
|
|
|
case DISCONNECTASSERT:
|
|
case FREE:
|
|
#ifdef BS_STATICS
|
|
bs_statics[ti->ti_id].disconnected++;
|
|
#endif /* BS_STATICS */
|
|
if (ti->ti_cfgflags & BS_SCSI_SAVESP)
|
|
BS_SAVE_SDP;
|
|
BS_HOST_TERMINATE;
|
|
BS_SETUP_PHASE(DISCONNECTED);
|
|
bsc->sc_dtgnum ++;
|
|
bshoststart(bsc, NULL);
|
|
break;
|
|
|
|
case IOCOMPLETED:
|
|
bs_status_check(bsc, ti);
|
|
cb = bscmddone(ti);
|
|
#ifdef BS_DIAG
|
|
ti->ti_flags &= ~BSNEXUS;
|
|
#endif /* BS_DIAG */
|
|
BS_SETUP_PHASE(FREE);
|
|
if (cb || bsc->sc_sttab.tqh_first == NULL)
|
|
{
|
|
BS_HOST_TERMINATE;
|
|
bscmdstart(ti, BSCMDSTART);
|
|
}
|
|
else
|
|
{
|
|
/* give a chance to other target */
|
|
bscmdstart(ti, BSCMDSTART);
|
|
BS_HOST_TERMINATE;
|
|
bshoststart(bsc, NULL);
|
|
}
|
|
break;
|
|
}
|
|
|
|
BS_SETUP_MSGPHASE(FREE);
|
|
}
|
|
|
|
/**************************************************
|
|
* <PHASE ERROR>
|
|
**************************************************/
|
|
#define scsi_status (bsc->sc_busstat)
|
|
|
|
struct bs_err {
|
|
u_char *pe_msg;
|
|
u_int pe_err;
|
|
u_int pe_ph;
|
|
};
|
|
|
|
struct bs_err bs_cmderr[] = {
|
|
/*0*/ { "illegal cmd", BSABNORMAL, UNDEF },
|
|
/*1*/ { "unexpected bus free", BSABNORMAL, FREE },
|
|
/*2*/ { NULL, BSSELTIMEOUT, FREE},
|
|
/*3*/ { "scsi bus parity error", BSPARITY, UNDEF },
|
|
/*4*/ { "scsi bus parity error", BSPARITY, UNDEF },
|
|
/*5*/ { "unknown" , BSFATALIO, UNDEF },
|
|
/*6*/ { "miss reselection (target mode)", BSFATALIO, UNDEF },
|
|
/*7*/ { "wrong status byte", BSPARITY, STATUSIN },
|
|
};
|
|
|
|
static void
|
|
bs_phase_error(ti, cb)
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
struct bs_softc *bsc = ti->ti_bsc;
|
|
struct bs_err *pep;
|
|
char *s = NULL;
|
|
|
|
if ((scsi_status & BSR_CM) == BSR_CMDERR &&
|
|
(scsi_status & BSR_PHVALID) == 0)
|
|
{
|
|
pep = &bs_cmderr[scsi_status & BSR_PM];
|
|
ti->ti_error |= pep->pe_err;
|
|
if (pep->pe_msg)
|
|
{
|
|
bs_debug_print(bsc, ti);
|
|
bs_printf(ti, "bsintr", pep->pe_msg);
|
|
}
|
|
BS_SETUP_PHASE(pep->pe_ph);
|
|
}
|
|
else
|
|
{
|
|
ti->ti_error |= BSABNORMAL;
|
|
bs_debug_print(bsc, ti);
|
|
bs_printf(ti, "bsintr", "phase error");
|
|
BS_SETUP_PHASE(UNDEF);
|
|
}
|
|
|
|
BS_SETUP_MSGPHASE(FREE);
|
|
switch (ti->ti_phase)
|
|
{
|
|
case FREE:
|
|
BS_SETUP_PHASE(UNDEF);
|
|
cb = bscmddone(ti);
|
|
#ifdef BS_DIAG
|
|
ti->ti_flags &= ~BSNEXUS;
|
|
#endif /* BS_DIAG */
|
|
BS_HOST_TERMINATE;
|
|
BS_SETUP_PHASE(FREE);
|
|
bscmdstart(ti, ((cb == NULL) ? BSCMDSTART : BSCMDRESTART));
|
|
break;
|
|
|
|
case STATUSIN:
|
|
ti->ti_error |= BSSTATUSERROR;
|
|
ti->ti_status = bshw_get_status_insat(bsc); /* XXX SAT */
|
|
bs_debug_print(bsc, ti);
|
|
break;
|
|
|
|
case UNDEF:
|
|
default:
|
|
ti->ti_error |= BSABNORMAL;
|
|
bs_reset_nexus(bsc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**************************************************
|
|
* ### SCSI PHASE SEQUENCER ###
|
|
**************************************************/
|
|
static inline void bs_ack_wait __P((struct bs_softc *, struct targ_info *, struct ccb *));
|
|
|
|
static inline void
|
|
bs_ack_wait(bsc, ti, cb)
|
|
struct bs_softc *bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
{
|
|
int wc = bsc->sc_wc;
|
|
|
|
for (wc = bsc->sc_wc; bshw_get_busstat(bsc) != BSR_ACKREQ && wc > 0; )
|
|
wc --;
|
|
|
|
if (wc <= 0)
|
|
{
|
|
bs_printf(ti, "bs_ack_wait", "timeout I");
|
|
return;
|
|
}
|
|
|
|
bshw_get_auxstat(bsc);
|
|
scsi_status = bshw_get_busstat(bsc);
|
|
|
|
if (cb->msgoutlen > 0)
|
|
{
|
|
bshw_assert_atn(bsc);
|
|
delay(800);
|
|
BS_SETUP_PHASE(ATTENTIONASSERT);
|
|
}
|
|
|
|
bshw_negate_ack(bsc);
|
|
|
|
#ifdef WAITNEXTP
|
|
for (wc = bsc->sc_wc; bshw_get_busstat(bsc) == BSR_ACKREQ && wc > 0; )
|
|
wc --;
|
|
|
|
if (wc <= 0)
|
|
bs_printf(ti, "bs_ack_wait", "timeout II");
|
|
#endif /* WAITNEXTP */
|
|
}
|
|
|
|
int
|
|
bs_sequencer(bsc)
|
|
struct bs_softc *bsc;
|
|
{
|
|
register struct targ_info *ti;
|
|
struct ccb *cb;
|
|
|
|
/**************************************************
|
|
* Check reset
|
|
**************************************************/
|
|
if (bsc->sc_flags & (BSRESET | BSINACTIVE))
|
|
{
|
|
if (bsc->sc_flags & BSRESET)
|
|
bs_reset_nexus(bsc);
|
|
return 1;
|
|
}
|
|
|
|
/**************************************************
|
|
* Get status & bus phase
|
|
**************************************************/
|
|
if ((bshw_get_auxstat(bsc) & STR_INT) == 0)
|
|
return 0;
|
|
|
|
scsi_status = bshw_get_busstat(bsc);
|
|
if (scsi_status == ((u_int8_t) -1))
|
|
{
|
|
bs_debug_print_all(bsc);
|
|
printf("%s strange scsi bus status\n");
|
|
return 1;
|
|
}
|
|
/**************************************************
|
|
* Check reselection, or nexus
|
|
**************************************************/
|
|
if (scsi_status == BSR_RESEL)
|
|
{
|
|
bs_reselect(bsc);
|
|
return 1;
|
|
}
|
|
|
|
ti = bsc->sc_nexus;
|
|
if (ti == NULL || (cb = ti->ti_ctab.tqh_first) == NULL)
|
|
{
|
|
bs_debug_print_all(bsc);
|
|
bs_printf(ti, "bsintr", "no nexus");
|
|
bs_reset_nexus(bsc);
|
|
return 1;
|
|
}
|
|
|
|
/**************************************************
|
|
* Debug section
|
|
**************************************************/
|
|
#ifdef BS_DEBUG
|
|
if (bs_debug_flag)
|
|
{
|
|
bs_debug_print(bsc, ti);
|
|
if (bs_debug_flag > 1)
|
|
Debugger();
|
|
}
|
|
#endif /* BS_DEBUG */
|
|
|
|
/**************************************************
|
|
* internal scsi phase
|
|
**************************************************/
|
|
switch (ti->ti_phase)
|
|
{
|
|
case SELECTASSERT:
|
|
bs_selected(bsc, ti, cb);
|
|
return 1;
|
|
|
|
case SATSEL:
|
|
BS_SELECTION_TERMINATE;
|
|
|
|
case SATRESEL:
|
|
if (bsc->sc_flags & (BSDMASTART | BSSMITSTART))
|
|
{
|
|
if (bsc->sc_flags & BSSMITSTART)
|
|
{
|
|
bs_debug_print_all(bsc);
|
|
bs_reset_nexus(bsc);
|
|
bs_printf(ti, "bsintr", "smit transfer");
|
|
return 1;
|
|
}
|
|
|
|
BS_SETUP_PHASE(DATAPHASE); /* XXX */
|
|
bs_dma_xfer_end(ti);
|
|
ti->ti_phase = ti->ti_ophase; /* XXX */
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* XXX:
|
|
* check check check for safty !!
|
|
*/
|
|
if (bsc->sc_selwait)
|
|
{
|
|
/* Ghaaa! phase error! retry! */
|
|
bs_phase_error(ti, cb);
|
|
return 1;
|
|
}
|
|
|
|
if (bsc->sc_flags & (BSDMASTART | BSSMITSTART))
|
|
{
|
|
if (bsc->sc_flags & BSDMASTART)
|
|
bs_dma_xfer_end(ti);
|
|
else
|
|
bs_smit_xfer_end(ti);
|
|
}
|
|
break;
|
|
}
|
|
|
|
/**************************************************
|
|
* hw scsi phase
|
|
**************************************************/
|
|
if (scsi_status & BSR_PHVALID)
|
|
{
|
|
/**************************************************
|
|
* Normal SCSI phase.
|
|
**************************************************/
|
|
if ((scsi_status & BSR_CM) == BSR_CMDABT)
|
|
{
|
|
bs_phase_error(ti, cb);
|
|
return 1;
|
|
}
|
|
|
|
switch (scsi_status & BSR_PM)
|
|
{
|
|
case BSR_DATAOUT:
|
|
case BSR_DATAIN:
|
|
BS_SETUP_PHASE(DATAPHASE);
|
|
|
|
if (bsc->sc_p.datalen <= 0 ||
|
|
(ti->ti_flags & BSFORCEIOPOLL))
|
|
{
|
|
bs_io_xfer(ti);
|
|
return 1;
|
|
}
|
|
|
|
if (bs_check_smit(ti) &&
|
|
(bsc->sc_p.datalen % sizeof(u_int32_t)) == 0)
|
|
{
|
|
bs_lc_smit_xfer(ti, scsi_status & BSR_IOR);
|
|
return 1;
|
|
}
|
|
|
|
bs_dma_xfer(ti, scsi_status & BSR_IOR);
|
|
bshw_start_xfer(bsc);
|
|
return 1;
|
|
|
|
case BSR_CMDOUT:
|
|
bs_commandout(bsc, ti, cb);
|
|
return 1;
|
|
|
|
case BSR_STATIN:
|
|
if (bs_check_sat(ti))
|
|
{
|
|
BS_SETUP_PHASE(SATCOMPSEQ);
|
|
bshw_set_count(bsc, 0);
|
|
bshw_cmd_pass(bsc, 0x41);
|
|
bshw_start_sat(bsc, 0);
|
|
}
|
|
else
|
|
{
|
|
BS_SETUP_PHASE(STATUSIN);
|
|
ti->ti_status = bs_read_1byte(bsc);
|
|
}
|
|
return 1;
|
|
|
|
case BSR_UNSPINFO0:
|
|
case BSR_UNSPINFO1:
|
|
bs_debug_print(bsc, ti);
|
|
bs_printf(ti, "bsintr", "illegal bus phase");
|
|
return 1;
|
|
|
|
case BSR_MSGOUT:
|
|
bs_msgout(bsc, ti, cb);
|
|
return 1;
|
|
|
|
case BSR_MSGIN:/* msg in */
|
|
if (bs_check_sat(ti))
|
|
{
|
|
if (ti->ti_phase == RESELECTED)
|
|
{
|
|
bs_sat_continue(bsc, ti, cb);
|
|
return 1;
|
|
}
|
|
/* XXX */
|
|
if (ti->ti_status == ST_UNK)
|
|
ti->ti_status = bshw_get_status_insat(bsc);
|
|
}
|
|
|
|
ti->ti_msgin[ti->ti_msginptr ++] = bs_read_1byte(bsc);
|
|
bs_msgin(bsc, ti);
|
|
if (bsc->sc_cfgflags & BSC_FASTACK)
|
|
bs_ack_wait(bsc, ti, cb);
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/**************************************************
|
|
* Special SCSI phase
|
|
**************************************************/
|
|
switch (scsi_status)
|
|
{
|
|
case BSR_SATSDP:/* SAT with save data pointer */
|
|
BS_SAVE_SDP
|
|
bshw_cmd_pass(bsc, 0x41);
|
|
bshw_start_sat(bsc, 0);
|
|
BS_SETUP_PHASE(SATSDP)
|
|
return 1;
|
|
|
|
case BSR_SATFIN:/* SAT COMPLETE */
|
|
ti->ti_status = bshw_get_status_insat(bsc);
|
|
BS_SETUP_MSGPHASE(IOCOMPLETED);
|
|
bs_disconnect_phase(bsc, ti, cb);
|
|
return 1;
|
|
|
|
case BSR_ACKREQ:/* negate ACK */
|
|
if (cb->msgoutlen > 0)
|
|
{
|
|
bshw_assert_atn(bsc);
|
|
delay(800);
|
|
BS_SETUP_PHASE(ATTENTIONASSERT);
|
|
}
|
|
bshw_negate_ack(bsc);
|
|
return 1;
|
|
|
|
case BSR_DISC:/* disconnect */
|
|
bs_disconnect_phase(bsc, ti, cb);
|
|
return 1;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
bs_phase_error(ti, cb);
|
|
return 1;
|
|
}
|
|
|
|
/*****************************************************************
|
|
* INTERNAL POLLING FUNCTIONS
|
|
*****************************************************************/
|
|
static int
|
|
bs_scsi_cmd_poll_internal(cti)
|
|
struct targ_info *cti;
|
|
{
|
|
struct bs_softc *bsc = cti->ti_bsc;
|
|
struct targ_info *ti;
|
|
struct ccb *cb;
|
|
int i, waits, delay_count;
|
|
|
|
bsc->sc_poll++;
|
|
|
|
/* setup timeout count */
|
|
if ((ti = bsc->sc_nexus) == NULL ||
|
|
(cb = ti->ti_ctab.tqh_first) == NULL)
|
|
waits = BS_DEFAULT_TIMEOUT_SECOND * 1000000;
|
|
else
|
|
waits = cb->tcmax * 1000000;
|
|
|
|
/* force all current jobs into the polling state. */
|
|
for (i = 0; i < NTARGETS; i++)
|
|
{
|
|
if (ti = bsc->sc_ti[i])
|
|
{
|
|
ti->ti_flags |= BSFORCEIOPOLL;
|
|
if (cb = ti->ti_ctab.tqh_first)
|
|
cb->flags |= BSFORCEIOPOLL;
|
|
}
|
|
}
|
|
|
|
/* do io */
|
|
bsc->sc_flags &= ~BSJOBDONE;
|
|
do
|
|
{
|
|
delay_count = ((bsc->sc_flags & BSDMASTART) ? 1000000 : 100);
|
|
delay(delay_count);
|
|
waits -= delay_count;
|
|
bs_sequencer(bsc);
|
|
}
|
|
while (waits >= 0 && (bsc->sc_flags & (BSUNDERRESET | BSJOBDONE)) == 0);
|
|
|
|
/* done */
|
|
bsc->sc_poll--;
|
|
if (waits < 0 || (bsc->sc_flags & BSUNDERRESET))
|
|
{
|
|
bs_printf(NULL, "cmd_poll", "timeout or fatal");
|
|
return HASERROR;
|
|
}
|
|
|
|
return COMPLETE;
|
|
}
|
|
|
|
int
|
|
bs_scsi_cmd_poll(cti, targetcb)
|
|
struct targ_info *cti;
|
|
struct ccb *targetcb;
|
|
{
|
|
struct bs_softc *bsc = cti->ti_bsc;
|
|
struct targ_info *ti;
|
|
int s, error = COMPLETE;
|
|
|
|
s = splbio();
|
|
bs_terminate_timeout(bsc);
|
|
|
|
if (bsc->sc_hstate == BSC_TARG_CHECK)
|
|
{
|
|
if ((error = bs_scsi_cmd_poll_internal(cti)) != COMPLETE)
|
|
bs_reset_nexus(bsc);
|
|
}
|
|
else
|
|
{
|
|
if (bsc->sc_outccb)
|
|
bs_panic(bsc, "bs_cmd_poll: internal error");
|
|
|
|
bsc->sc_flags &= ~BSPOLLDONE;
|
|
bsc->sc_outccb = targetcb;
|
|
|
|
while ((bsc->sc_flags & BSPOLLDONE) == 0)
|
|
{
|
|
if (bs_scsi_cmd_poll_internal(cti) != COMPLETE)
|
|
{
|
|
if ((ti = bsc->sc_nexus) && ti->ti_ctab.tqh_first)
|
|
ti->ti_error |= (BSTIMEOUT | BSABNORMAL);
|
|
bs_reset_nexus(bsc);
|
|
}
|
|
}
|
|
|
|
bsc->sc_outccb = NULL;
|
|
}
|
|
|
|
bs_start_timeout(bsc);
|
|
softintr(bsc->sc_irqmasks);
|
|
splx(s);
|
|
return error;
|
|
}
|