Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/arch/sun3/dev/ncr5380sbc.c

1970 lines
47 KiB
C
Raw Blame History

/* $NetBSD: ncr5380sbc.c,v 1.1 1995/10/29 21:19:09 gwr Exp $ */
/*
* Copyright (c) 1995 David Jones, Gordon W. Ross
* Copyright (c) 1994 Jarle Greipsland
* 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 authors may not be used to endorse or promote products
* derived from this software without specific prior written permission.
* 4. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by
* David Jones and Gordon Ross
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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.
*/
/*
* This is a machine-independent driver for the NCR5380
* SCSI Bus Controller (SBC), also known as the Am5380.
*
* This code should work with any memory-mapped 5380,
* and can be shared by multiple adapters that address
* the 5380 with different register offset spacings.
* (This can happen on the atari, for example.)
* For porting/design info. see: ncr5380.doc
*
* Credits, history:
*
* David Jones is the author of most of the code that now
* appears in this file, and was the architect of the
* current overall structure (MI/MD code separation, etc.)
*
* Gordon Ross integrated the message phase code, added lots of
* comments about what happens when and why (re. SCSI spec.),
* and debugged some reentrance problems.
*
* The message in/out code was taken nearly verbatim from
* the aic6360 driver by Jarle Greipsland.
*
* Several other NCR5380 drivers were used for reference
* while developing this driver, including work by:
* The Alice Group (mac68k port) namely:
* Allen K. Briggs, Chris P. Caputo, Michael L. Finch,
* Bradley A. Grantham, and Lawrence A. Kesteloot
* Michael L. Hitch (amiga drivers: sci.c)
* Leo Weppelman (atari driver: ncr5380.c)
* There are others too. Thanks, everyone.
*/
#include <sys/types.h>
#include <sys/malloc.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/errno.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/device.h>
#include <scsi/scsi_all.h>
#include <scsi/scsi_debug.h>
#include <scsi/scsi_message.h>
#include <scsi/scsiconf.h>
#if 0 /* XXX - not yet... */
#include <dev/ic/ncr5380reg.h>
#include <dev/ic/ncr5380var.h>
#else
#include "ncr5380reg.h"
#include "ncr5380var.h"
#endif
static int ncr5380_wait_req __P((struct ncr5380_softc *));
static int ncr5380_wait_not_req __P((struct ncr5380_softc *));
static void ncr5380_sched __P((struct ncr5380_softc *));
static void ncr5380_done __P((struct ncr5380_softc *));
static int ncr5380_select
__P((struct ncr5380_softc *, struct scsi_xfer *));
static void ncr5380_reselect __P((struct ncr5380_softc *));
static int ncr5380_msg_in __P((struct ncr5380_softc *));
static int ncr5380_msg_out __P((struct ncr5380_softc *));
static int ncr5380_data_xfer __P((struct ncr5380_softc *, int));
static int ncr5380_command __P((struct ncr5380_softc *));
static int ncr5380_status __P((struct ncr5380_softc *));
static void ncr5380_machine __P((struct ncr5380_softc *));
/*
* Action flags returned by the info_tranfer functions:
* (These determine what happens next.)
*/
#define ACT_CONTINUE 0x00 /* No flags: expect another phase */
#define ACT_DISCONNECT 0x01 /* Target is disconnecting */
#define ACT_CMD_DONE 0x02 /* Need to call scsi_done() */
#define ACT_ABORT_CMD 0x04 /* Need to forcibly disconnect it */
#define ACT_RESET_BUS 0x08 /* Need bus reset (cmd timeout) */
#define ACT_WAIT_INTR 0x10 /* Wait for interrupt (DMA) */
/*****************************************************************
* Debugging stuff
*****************************************************************/
#ifdef DDB
int Debugger();
#else
/* This is used only in recoverable places. */
#define Debugger() printf("Debug: ncr5380.c:%d\n", __LINE__)
#endif
#define DEBUG XXX
#ifdef DEBUG
int ncr5380_debug = 0;
/* extern struct scsi_link *thescsilink; */
#define NCR_BREAK() Debugger()
#define NCR_PRINT(b, s) \
do {if ((ncr5380_debug & (b)) != 0) printf s;} while (0)
#else /* DEBUG */
#define NCR_BREAK() /* nah */
#define NCR_PRINT(b, s)
#endif /* DEBUG */
#define NCR_MISC(s) NCR_PRINT(0x01, s)
#define NCR_MSGS(s) NCR_PRINT(0x02, s)
#define NCR_CMDS(s) NCR_PRINT(0x04, s)
#define NCR_TRACE(s) NCR_PRINT(0x10, s)
#define NCR_START(s) NCR_PRINT(0x20, s)
#ifdef DEBUG
static char *
phase_names[8] = {
"DATA_OUT",
"DATA_IN",
"COMMAND",
"STATUS",
"UNSPEC1",
"UNSPEC2",
"MSG_OUT",
"MSG_IN",
};
static int
ncr5380_show_scsi_cmd(xs)
struct scsi_xfer *xs;
{
u_char *b = (u_char *) xs->cmd;
int i = 0;
if ( ! ( xs->flags & SCSI_RESET ) ) {
printf("si(%d:%d:%d)-",
xs->sc_link->scsibus,
xs->sc_link->target,
xs->sc_link->lun);
while (i < xs->cmdlen) {
if (i) printf(",");
printf("%x",b[i++]);
}
printf("-\n");
} else {
printf("si(%d:%d:%d)-RESET-\n",
xs->sc_link->scsibus,
xs->sc_link->target,
xs->sc_link->lun);
}
}
static void
ncr5380_show_sense(xs)
struct scsi_xfer *xs;
{
u_char *b = (u_char *)&xs->sense;
int i;
printf("sense:");
for (i = 0; i < sizeof(xs->sense); i++)
printf(" %02x", b[i]);
printf("\n");
}
#endif
/*****************************************************************
* Actual chip control
*****************************************************************/
/*
* XXX: These timeouts might need to be tuned...
*/
/* This one is used when waiting for a phase change. (X100uS.) */
int ncr5380_wait_phase_timo = 1000 * 10 * 300; /* 5 min. */
/* These are used in the following inline functions. */
int ncr5380_wait_req_timo = 1000 * 50; /* X2 = 100 mS. */
int ncr5380_wait_nrq_timo = 1000 * 25; /* X2 = 50 mS. */
/* Return zero on success. */
static __inline__ int ncr5380_wait_req(sc)
struct ncr5380_softc *sc;
{
register int timo = ncr5380_wait_req_timo;
for (;;) {
if (*sc->sci_bus_csr & SCI_BUS_REQ) {
timo = 0; /* return 0 */
break;
}
if (--timo < 0)
break; /* return -1 */
delay(2);
}
return (timo);
}
/* Return zero on success. */
static __inline__ int ncr5380_wait_not_req(sc)
struct ncr5380_softc *sc;
{
register int timo = ncr5380_wait_nrq_timo;
for (;;) {
if ((*sc->sci_bus_csr & SCI_BUS_REQ) == 0) {
timo = 0; /* return 0 */
break;
}
if (--timo < 0)
break; /* return -1 */
delay(2);
}
return (timo);
}
/* Ask the target for a MSG_OUT phase. */
static __inline__ void
ncr_sched_msgout(sc, msg_code)
struct ncr5380_softc *sc;
int msg_code;
{
/* First time, raise ATN line. */
if (sc->sc_msgpriq == 0) {
register u_char icmd;
icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
*sc->sci_icmd = icmd | SCI_ICMD_ATN;
delay(2);
}
sc->sc_msgpriq |= msg_code;
}
int
ncr5380_pio_out(sc, phase, count, data)
struct ncr5380_softc *sc;
int phase, count;
unsigned char *data;
{
register u_char icmd;
register int resid;
icmd = *(sc->sci_icmd) & SCI_ICMD_RMASK;
icmd |= SCI_ICMD_DATA;
*sc->sci_icmd = icmd;
resid = count;
while (resid > 0) {
if (!SCI_BUSY(sc)) {
NCR_MISC(("ncr5380_pio_out: lost BSY\n"));
break;
}
if (ncr5380_wait_req(sc)) {
NCR_MISC(("ncr5380_pio_out: no REQ\n"));
break;
}
if (SCI_CUR_PHASE(*sc->sci_bus_csr) != phase)
break;
/* Put the data on the bus. */
*sc->sci_odata = *data++;
/* Tell the target it's there. */
icmd |= SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
/* Wait for target to get it. */
if (ncr5380_wait_not_req(sc)) {
NCR_MISC(("ncr5380_pio_out: stuck REQ\n"));
break;
}
/* OK, it's got it. */
icmd &= ~SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
--resid;
}
/* Stop driving the data bus. */
icmd &= ~SCI_ICMD_DATA;
*sc->sci_icmd = icmd;
return (count - resid);
}
int
ncr5380_pio_in(sc, phase, count, data)
struct ncr5380_softc *sc;
int phase, count;
unsigned char *data;
{
register u_char icmd;
register int resid;
icmd = *(sc->sci_icmd) & SCI_ICMD_RMASK;
resid = count;
while (resid > 0) {
if (!SCI_BUSY(sc)) {
NCR_MISC(("ncr5380_pio_in: lost BSY\n"));
break;
}
if (ncr5380_wait_req(sc)) {
NCR_MISC(("ncr5380_pio_in: no REQ\n"));
break;
}
/* A phase change is not valid until AFTER REQ rises! */
if (SCI_CUR_PHASE(*sc->sci_bus_csr) != phase)
break;
/* Read the data bus. */
*data++ = *sc->sci_data;
/* Tell target we got it. */
icmd |= SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
/* Wait for target to drop REQ... */
if (ncr5380_wait_not_req(sc)) {
NCR_MISC(("ncr5380_pio_in: stuck REQ\n"));
break;
}
/* OK, we can drop ACK. */
icmd &= ~SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
--resid;
}
return (count - resid);
}
void
ncr5380_init(sc)
struct ncr5380_softc *sc;
{
int i, j;
for (i = 0; i < SCI_OPENINGS; i++)
sc->sc_ring[i].sr_xs = NULL;
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
sc->sc_matrix[i][j] = NULL;
sc->sc_link.openings = SCI_OPENINGS;
sc->sc_prevphase = PHASE_INVALID;
sc->sc_msg_flags = 0; /* XXX */
/* XXX: Reselect interrupts... */
*sc->sci_sel_enb = 0x80;
}
void
ncr5380_reset_scsibus(sc)
struct ncr5380_softc *sc;
{
NCR_MISC(("ncr5380_reset_scsibus\n"));
*sc->sci_icmd = SCI_ICMD_RST;
delay(500);
*sc->sci_icmd = 0;
*sc->sci_mode = 0;
*sc->sci_tcmd = 0;
SCI_CLR_INTR(sc);
/* XXX - Need long delay here! */
delay(100000);
/* XXX - Need to cancel disconnected requests. */
}
/*
* Interrupt handler for the SCSI Bus Controller (SBC)
* This is also called by a timeout handler after it
* raises to the appropriate SPL.
*/
int
ncr5380_sbc_intr(sc)
struct ncr5380_softc *sc;
{
int claimed = 0;
u_char st;
if (sc->sc_dma_flags & DMA5380_INPROGRESS) {
/* Stop DMA to prevent register conflicts */
NCR_MISC(("ncr5380_sbc_intr: call DMA stop\n"));
(*sc->sc_dma_stop)(sc);
/* Will check for error in ncr5380_machine */
/* We know the nexus is busy during DMA. */
}
/* OK, now we can look at the SBC. */
st = *sc->sci_csr;
SCI_CLR_INTR(sc);
NCR_MISC(("ncr5380_sbc_intr: st=0x%x\n", st));
/* XXX - There may be a better place to check... */
if (st & SCI_CSR_PERR) {
printf("ncr5380_sbc_intr: parity error!\n");
}
if (sc->sc_current == NULL) {
/*
* Might be reselect. ncr5380_reselect() will check, and
* set up the connection if so.
*/
ncr5380_reselect(sc);
}
/*
* The remaining documented interrupt causes are phase mismatch and
* disconnect. In addition, the sunsi controller may produce a state
* where SCI_CSR_DONE is false, yet DMA is complete.
*
* The procedure in all these cases is to let ncr5380_machine() figure
* out what to do next.
*/
if (sc->sc_current) {
/* This will usually free-up the nexus. */
ncr5380_machine(sc);
claimed = 1;
}
/* Maybe we can start another command now... */
if (sc->sc_current == NULL)
ncr5380_sched(sc);
return claimed;
}
/*****************************************************************
* Interface to higher level
*****************************************************************/
/*
* Enter a new SCSI command into the "issue" queue, and
* if there is work to do, start it going.
*
* WARNING: This can be called recursively!
* (see comment in ncr5380_done)
*/
int
ncr5380_scsi_cmd(xs)
struct scsi_xfer *xs;
{
struct ncr5380_softc *sc = xs->sc_link->adapter_softc;
int s, r, i, flags;
extern int cold; /* XXX */
/* thescsilink = xs->sc_link; */
flags = xs->flags;
/*
* XXX: Hack: During autoconfig, force polling mode.
* Needed as long as sdsize() can be called while cold,
* otherwise timeouts will never call back (grumble).
*/
if (cold)
flags |= SCSI_POLL;
if (flags & SCSI_DATA_UIO)
panic("ncr5380: scsi data uio requested");
if (sc->sc_current && (flags & SCSI_POLL))
panic("ncr5380_scsi_cmd: can't poll while busy");
s = splbio();
/* Find lowest empty slot in ring buffer. */
for (i = 0; i < SCI_OPENINGS; i++)
if (sc->sc_ring[i].sr_xs == NULL)
break;
if (i == SCI_OPENINGS) {
splx(s);
return TRY_AGAIN_LATER;
}
/* Create queue entry */
sc->sc_ring[i].sr_xs = xs;
sc->sc_ring[i].sr_target = xs->sc_link->target;
sc->sc_ring[i].sr_lun = xs->sc_link->lun;
sc->sc_ring[i].sr_data = xs->data;
sc->sc_ring[i].sr_datalen = xs->datalen;
sc->sc_ring[i].sr_dma_hand = NULL;
sc->sc_ring[i].sr_flags = (flags & SCSI_POLL) ? SR_IMMED : 0;
sc->sc_ring[i].sr_status = -1; /* no value */
sc->sc_ncmds++;
/*
* Consider starting another command if the bus is idle.
* To stop recursion, this is non-NULL when scsi_done()
* calls back here to issue the next command.
*/
if (sc->sc_current == NULL)
ncr5380_sched(sc);
splx(s);
/* The call to ncr5380_sched() may have finished it. */
if (xs->flags & ITSDONE) {
return COMPLETE;
}
if (flags & SCSI_POLL)
panic("ncr5380_scsi_cmd: poll didn't finish");
return SUCCESSFULLY_QUEUED;
}
/*
* Schedule a SCSI operation. This routine should return
* only after it achieves one of the following conditions:
* Bus is busy (sc->sc_current != NULL)
* All targets are busy (i.e. disconnected)
*/
static void
ncr5380_sched(sc)
struct ncr5380_softc *sc;
{
struct scsi_xfer *xs;
struct sci_req *sr;
int target, lun;
int error, i;
#ifdef DIAGNOSTIC
if ((getsr() & PSL_IPL) < PSL_IPL2)
panic("ncr5380_sched: bad spl");
if (sc->sc_current)
panic("ncr5380_sched: bus already busy");
#endif
next_job:
/*
* Grab the next job from queue.
*
* Always start the search where we last looked.
* The REQUEST_SENSE logic depends on this to
* choose the same job as was last picked, so it
* can just clear sc_current and reschedule.
*/
i = sc->sc_rr;
sr = NULL;
do {
if (sc->sc_ring[i].sr_xs) {
target = sc->sc_ring[i].sr_target;
lun = sc->sc_ring[i].sr_lun;
if (sc->sc_matrix[target][lun] == NULL) {
sc->sc_matrix[target][lun] = sr = &sc->sc_ring[i];
sc->sc_rr = i;
break;
}
}
i++;
if (i == SCI_OPENINGS)
i = 0;
} while (i != sc->sc_rr);
if (sr == NULL)
return; /* No more work to do. */
xs = sr->sr_xs;
error = ncr5380_select(sc, xs);
if (sc->sc_current) {
/* Lost the race! reselected out from under us! */
if (sr->sr_flags & SR_IMMED) {
printf("%s: reselected while polling (reset)\n",
sc->sc_dev.dv_xname);
error = XS_BUSY;
goto reset;
}
/* Work with the reselected target. */
sr = sc->sc_current;
xs = sr->sr_xs;
goto have_nexus;
}
sc->sc_current = sr; /* connected */
/* Initialize pointers, etc. */
sc->sc_dataptr = sr->sr_data;
sc->sc_datalen = sr->sr_datalen;
sc->sc_dma_hand = sr->sr_dma_hand;
switch (error) {
case XS_NOERROR:
break;
case XS_BUSY:
reset:
/* XXX - Reset and try again. */
printf("%s: SCSI bus busy, resetting...\n",
sc->sc_dev.dv_xname);
ncr5380_reset_scsibus(sc);
/* fallthrough */
case XS_SELTIMEOUT:
default:
NCR_MISC(("ncr5380_sched: select error=%d\n", error));
xs->error = error;
ncr5380_done(sc);
goto next_job;
}
/*
* Selection was successful.
* We now have a new command.
*/
NCR_CMDS(("next cmd: ",
ncr5380_show_scsi_cmd(xs) ));
sc->sc_prevphase = PHASE_MSG_IN;
if (xs->flags & SCSI_RESET) {
sc->sc_msgpriq = SEND_DEV_RESET;
goto have_nexus;
}
sc->sc_msgpriq = SEND_IDENTIFY;
if (sc->sc_dataptr && sc->sc_dma_alloc &&
(sc->sc_datalen >= sc->sc_min_dma_len))
{
/* Allocate DMA space */
sc->sc_dma_flags = 0;
if (xs->flags & SCSI_DATA_OUT)
sc->sc_dma_flags |= DMA5380_WRITE;
if (xs->bp && (xs->bp->b_flags & B_PHYS))
sc->sc_dma_flags |= DMA5380_PHYS;
if (sr->sr_flags & SR_IMMED)
sc->sc_dma_flags |= DMA5380_POLL;
/* This may also set DMA5380_POLL */
(*sc->sc_dma_alloc)(sc);
/* Now, _maybe_ sc_dma_hand is set. */
}
sr->sr_dma_hand = sc->sc_dma_hand;
have_nexus:
ncr5380_machine(sc);
/*
* What state did ncr5380_machine() leave us in?
* Hopefully it sometimes completes a job...
*/
if (sc->sc_current)
return; /* Have work in progress... */
goto next_job;
}
/*
* POST PROCESSING OF SCSI_CMD (usually current)
* Called by ncr5380_sched(), ncr5380_machine()
*/
static void
ncr5380_done(sc)
struct ncr5380_softc *sc;
{
struct sci_req *sr = sc->sc_current;
struct scsi_xfer *xs = sr->sr_xs;
/* Clean up DMA associated with this command */
if (sc->sc_dma_hand) {
(*sc->sc_dma_free)(sc);
sc->sc_dma_hand = NULL;
}
if (xs->error)
goto finish;
NCR_MISC(("ncr5380_done, sr_status=%d\n", sr->sr_status));
switch (sr->sr_status) {
case SCSI_OK: /* 0 */
if (sr->sr_flags & SR_SENSE) {
/* ncr5380_show_sense(xs); */
xs->error = XS_SENSE;
}
break;
case SCSI_CHECK:
if (sr->sr_flags & SR_SENSE) {
/* Sense command also asked for sense? */
printf("ncr5380_done: sense asked for sense\n");
NCR_BREAK();
xs->error = XS_DRIVER_STUFFUP;
break;
}
sr->sr_flags |= SR_SENSE;
NCR_MISC(("ncr5380_done: start request sense\n"));
NCR_CMDS(("cmd: ", ncr5380_show_scsi_cmd(xs) ));
/*
* Leave queued, but clear sc_current so we start over
* with selection. Guaranteed to get the same request.
*/
sc->sc_current = NULL;
sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
return;
case SCSI_BUSY:
xs->error = XS_BUSY;
break;
case -1:
/* This is our "impossible" initial value. */
/* fallthrough */
default:
printf("%s: target %d, bad status=%d\n",
sc->sc_dev.dv_xname, sr->sr_target, sr->sr_status);
xs->error = XS_DRIVER_STUFFUP;
break;
}
finish:
NCR_MISC(("ncr5380_done: finished target=%d, LUN=%d\n",
sr->sr_target, sr->sr_lun));
/*
* Dequeue the finished command
*/
sc->sc_matrix[sr->sr_target][sr->sr_lun] = NULL;
sc->sc_ncmds--;
sr->sr_xs = NULL;
/*
* Do not clear sc_current quite yet. The call to scsi_done()
* below may recursively call ncr5380_scsi_cmd() and leaving
* sc->sc_current != NULL ends the recursion after the new
* command is enqueued.
*/
xs->flags |= ITSDONE;
scsi_done(xs);
/* Allow ncr5380_sched() to be called again. */
sc->sc_current = NULL; /* idle */
}
/*
* Reselect handler: checks for reselection, and if we are being
* reselected, it sets up sc->sc_current.
*
* We are reselected when:
* SEL is TRUE
* IO is TRUE
* BSY is FALSE
*/
void
ncr5380_reselect(sc)
struct ncr5380_softc *sc;
{
int target, lun, phase, timo;
u_char bus, data, icmd, msg;
#ifdef DIAGNOSTIC
if (sc->sc_current)
panic("ncr5380_reselect: already have nexus!");
#endif
/*
* First, check the select line.
* (That has to be set by now.)
*/
bus = *(sc->sci_bus_csr);
if ((bus & SCI_BUS_SEL) == 0) {
/* Not a selection or reselection. */
return;
}
/*
* Now wait for: SEL==1, BSY==0
* before reading the data bus.
*/
for (timo = 25000;;) {
if ((bus & SCI_BUS_BSY) == 0)
break;
if (--timo <= 0) {
printf("%s: reselect, BSY stuck, bus=0x%x\n",
sc->sc_dev.dv_xname, bus);
/* Not much we can do. Reset the bus. */
ncr5380_reset_scsibus(sc);
return;
}
delay(10);
bus = *(sc->sci_bus_csr);
/* If SEL went away, forget it. */
if ((bus & SCI_BUS_SEL) == 0)
return;
/* Still have SEL, check BSY. */
}
/*
* Good. We have SEL=1 and BSY=0. Now wait for a
* "bus settle delay" before we sample the data bus
*/
delay(2);
data = *(sc->sci_data) & 0xFF;
/* XXX - Should check parity... */
/*
* Is this a reselect (I/O == 1) or have we been
* selected as a target? (I/O == 0)
*/
if ((bus & SCI_BUS_IO) == 0) {
printf("%s: selected as target, data=0x%x\n",
sc->sc_dev.dv_xname, data);
/* Not much we can do. Reset the bus. */
ncr5380_reset_scsibus(sc);
return;
}
/*
* OK, this is a reselection.
*/
for (target = 0; target < 7; target++)
if (data & (1 << target))
break;
if ((data & 0x7F) != (1 << target)) {
/* No selecting ID? or >2 IDs on bus? */
printf("%s: bad reselect, data=0x%x\n",
sc->sc_dev.dv_xname, data);
return;
}
NCR_MISC(("ncr5380_reselect: data=0x%x\n", data));
/* Raise BSY to acknowledge target reselection. */
*(sc->sci_icmd) = SCI_ICMD_BSY;
/* Wait for target to drop SEL. */
for (timo = 1000;;) {
bus = *(sc->sci_bus_csr);
if ((bus & SCI_BUS_SEL) == 0)
break; /* success */
if (--timo <= 0) {
printf("%s: reselect, SEL stuck, bus=0x%x\n",
sc->sc_dev.dv_xname, bus);
/* Not much we can do. Reset the bus. */
ncr5380_reset_scsibus(sc);
return;
}
delay(5);
}
/* Now we drop BSY, and we are connected. */
*(sc->sci_icmd) = 0;
*sc->sci_sel_enb = 0;
SCI_CLR_INTR(sc);
/*
* At this point the target should send an IDENTIFY message,
* which will permit us to determine the reselecting LUN.
* If not, we assume LUN 0.
*/
lun = 0;
/* Wait for REQ before reading bus phase. */
if (ncr5380_wait_req(sc)) {
printf("%s: reselect, no REQ\n",
sc->sc_dev.dv_xname);
/* Try to send an ABORT message. */
goto abort;
}
phase = SCI_CUR_PHASE(*sc->sci_bus_csr);
if (phase != PHASE_MSG_IN) {
printf("%s: reselect, phase=%d\n",
sc->sc_dev.dv_xname, phase);
goto abort;
}
/* Ack. the new phase. */
*(sc->sci_tcmd) = phase;
/* Peek at the message byte without consuming it! */
msg = *(sc->sci_data);
if ((msg & 0x80) == 0) {
printf("%s: reselect, not identify, msg=%d\n",
sc->sc_dev.dv_xname, msg);
goto abort;
}
lun = msg & 7;
/* We now know target/LUN. Do we have the request? */
sc->sc_current = sc->sc_matrix[target][lun];
if (sc->sc_current) {
/* Now consume the IDENTIFY message. */
ncr5380_pio_in(sc, PHASE_MSG_IN, 1, &msg);
/* Implicit restore pointers message */
sc->sc_dataptr = sc->sc_current->sr_data;
sc->sc_datalen = sc->sc_current->sr_datalen;
sc->sc_dma_hand = sc->sc_current->sr_dma_hand;
/* We now have a nexus. */
return;
}
printf("%s: phantom reselect: target=%d, LUN=%d\n",
sc->sc_dev.dv_xname, target, lun);
abort:
/*
* Try to send an ABORT message.
* Raise ATN, then raise ACK...
*/
icmd = SCI_ICMD_ATN;
*sc->sci_icmd = icmd;
delay(2);
/* Now consume the IDENTIFY message. */
ncr5380_pio_in(sc, PHASE_MSG_IN, 1, &msg);
/* Finally try to send the ABORT. */
sc->sc_prevphase = PHASE_MSG_IN;
sc->sc_msgpriq = SEND_ABORT;
*(sc->sci_tcmd) = PHASE_MSG_OUT;
ncr5380_msg_out(sc);
*sc->sci_sel_enb = 0x80;
}
/*
* Select target: xs is the transfer that we are selecting for.
* sc->sc_current should be NULL.
*
* Returns:
* sc->sc_current != NULL ==> we were reselected (race!)
* XS_NOERROR ==> selection worked
* XS_BUSY ==> lost arbitration
* XS_SELTIMEOUT ==> no response to selection
*/
static int
ncr5380_select(sc, xs)
struct ncr5380_softc *sc;
struct scsi_xfer *xs;
{
int timo;
u_char bus, data, icmd;
NCR_MISC(("ncr5380_select: begin, target=%d\n",
xs->sc_link->target));
/* Check for reselect */
ncr5380_reselect(sc);
if (sc->sc_current) {
NCR_MISC(("ncr5380_select: reselected!\n"));
return XS_NOERROR; /* reselected */
}
/*
* Set phase bits to 0, otherwise the 5380 won't drive the bus during
* selection.
*/
*sc->sci_icmd = icmd = 0;
*sc->sci_mode = 0;
*sc->sci_tcmd = 0;
NCR_MISC(("ncr5380_select: arbitration\n"));
/*
* Arbitrate for the bus. The 5380 takes care of the
* time-critical bus interactions. We set our ID bit
* in the output data register and set MODE_ARB. The
* 5380 watches for the required "bus free" period.
* If and when the "bus free" period is detected, the
* 5380 then drives BSY, drives the data bus, and sets
* the "arbitration in progress" (AIP) bit to let us
* know arbitration has started. We then wait for one
* arbitration delay (2.2uS) and check the ICMD_LST bit,
* which will be set if someone else drives SEL.
*/
*(sc->sci_odata) = 0x80; /* OUR_ID */
*(sc->sci_mode) = SCI_MODE_ARB;
/* Wait for ICMD_AIP. */
for (timo = 50000;;) {
if (*(sc->sci_icmd) & SCI_ICMD_AIP)
break;
if (--timo <= 0) {
/* Did not see any "bus free" period. */
NCR_MISC(("ncr5380_select: failed, bus busy\n"));
*sc->sci_mode = 0;
return XS_BUSY;
}
delay(2);
}
/* Got AIP. Wait one arbitration delay (2.2 uS.) */
delay(3);
/* Check for ICMD_LST */
if (*(sc->sci_icmd) & SCI_ICMD_LST) {
/* Some other target asserted SEL. */
NCR_MISC(("ncr5380_select: lost arbitration\n"));
*sc->sci_mode = 0;
return XS_BUSY;
}
/*
* No other device has declared itself the winner.
* The spec. says to check for higher IDs, but we
* are always the highest (ID=7) so don't bother.
* We can now declare victory by asserting SEL.
*
* Note that the 5380 is asserting BSY because we
* asked it to do arbitration. We will now hold
* BSY directly so we can turn off ARB mode.
*/
icmd = (SCI_ICMD_BSY | SCI_ICMD_SEL);
*sc->sci_icmd = icmd;
/*
* "The SCSI device that wins arbitration shall wait
* at least a bus clear delay plus a bus settle delay
* after asserting the SEL signal before changing
* any [other] signal." (1.2uS. total)
*/
delay(2);
#if 1
/*
* XXX: Check one last time to see if we really
* XXX: did win arbitration. (too paranoid?)
*/
if (*(sc->sci_icmd) & SCI_ICMD_LST) {
NCR_MISC(("ncr5380_select: lost arb. after SEL\n"));
*sc->sci_icmd = 0;
*sc->sci_mode = 0;
return XS_BUSY;
}
#endif
/* Leave ARB mode Now that we drive BSY+SEL */
*sc->sci_mode = 0;
*sc->sci_sel_enb = 0;
/*
* Arbitration is complete. Now do selection:
* Drive the data bus with the ID bits for both
* the host and target. Also set ATN now, to
* ask the target for a messgae out phase.
*/
NCR_MISC(("ncr5380_select: selection\n"));
data = (1 << xs->sc_link->target);
*(sc->sci_odata) = 0x80 | data;
icmd |= (SCI_ICMD_DATA | SCI_ICMD_ATN);
*(sc->sci_icmd) = icmd;
delay(2); /* two deskew delays. */
/* De-assert BSY (targets sample the data now). */
icmd &= ~SCI_ICMD_BSY;
*(sc->sci_icmd) = icmd;
delay(3); /* Bus settle delay. */
/*
* Wait for the target to assert BSY.
* SCSI spec. says wait for 250 mS.
*/
for (timo = 25000;;) {
if (*sc->sci_bus_csr & SCI_BUS_BSY)
goto success;
if (--timo <= 0)
break;
delay(10);
}
/*
* There is no reaction from the target. Start the selection
* timeout procedure. We release the databus but keep SEL+ATN
* asserted. After that we wait a 'selection abort time' (200
* usecs) and 2 deskew delays (90 ns) and check BSY again.
* When BSY is asserted, we assume the selection succeeded,
* otherwise we release the bus.
*/
icmd &= ~SCI_ICMD_DATA;
*(sc->sci_icmd) = icmd;
delay(201);
if ((*sc->sci_bus_csr & SCI_BUS_BSY) == 0) {
/* Really no device on bus */
*sc->sci_icmd = 0;
*sc->sci_mode = 0;
*sc->sci_sel_enb = 0x80;
NCR_MISC(("ncr5380_select: device down\n"));
return XS_SELTIMEOUT;
}
success:
/*
* The target is now driving BSY, so we can stop
* driving SEL and the data bus (keep ATN true).
* Configure the ncr5380 to monitor BSY, parity.
*/
icmd &= ~(SCI_ICMD_DATA | SCI_ICMD_SEL);
*sc->sci_icmd = icmd;
/* XXX - Make parity checking optional? */
*sc->sci_mode = (SCI_MODE_MONBSY | SCI_MODE_PAR_CHK);
NCR_MISC(("ncr5380_select: success\n"));
return XS_NOERROR;
}
/*****************************************************************
* Functions to handle each info. transfer phase:
*****************************************************************/
/*
* The message system:
*
* This is a revamped message system that now should easier accomodate
* new messages, if necessary.
*
* Currently we accept these messages:
* IDENTIFY (when reselecting)
* COMMAND COMPLETE # (expect bus free after messages marked #)
* NOOP
* MESSAGE REJECT
* SYNCHRONOUS DATA TRANSFER REQUEST
* SAVE DATA POINTER
* RESTORE POINTERS
* DISCONNECT #
*
* We may send these messages in prioritized order:
* BUS DEVICE RESET # if SCSI_RESET & xs->flags (or in weird sits.)
* MESSAGE PARITY ERROR par. err. during MSGI
* MESSAGE REJECT If we get a message we don't know how to handle
* ABORT # send on errors
* INITIATOR DETECTED ERROR also on errors (SCSI2) (during info xfer)
* IDENTIFY At the start of each transfer
* SYNCHRONOUS DATA TRANSFER REQUEST if appropriate
* NOOP if nothing else fits the bill ...
*/
#define IS1BYTEMSG(m) (((m) != 0x01 && (m) < 0x20) || (m) >= 0x80)
#define IS2BYTEMSG(m) (((m) & 0xf0) == 0x20)
#define ISEXTMSG(m) ((m) == 0x01)
/*
* Precondition:
* The SCSI bus is already in the MSGI phase and there is a message byte
* on the bus, along with an asserted REQ signal.
*
* Our return value determines whether our caller, ncr5380_machine()
* will expect to see another REQ (and possibly phase change).
*/
static int
ncr5380_msg_in(sc)
register struct ncr5380_softc *sc;
{
struct sci_req *sr = sc->sc_current;
int n, phase, timo;
int act_flags;
register u_char icmd;
act_flags = ACT_CONTINUE;
icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
if (sc->sc_prevphase == PHASE_MSG_IN) {
/* This is a continuation of the previous message. */
n = sc->sc_imp - sc->sc_imess;
goto nextbyte;
}
/* This is a new MESSAGE IN phase. Clean up our state. */
sc->sc_msg_flags &= ~NCR_DROP_MSGIN;
nextmsg:
n = 0;
sc->sc_imp = &sc->sc_imess[n];
nextbyte:
/*
* Read a whole message, but don't ack the last byte. If we reject the
* message, we have to assert ATN during the message transfer phase
* itself.
*/
for (;;) {
/*
* Read a message byte.
* First, check BSY, REQ, phase...
*/
if (!SCI_BUSY(sc)) {
NCR_MISC(("ncr5380_msg_in: lost BSY\n"));
/* XXX - Assume the command completed? */
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
return (act_flags);
}
if (ncr5380_wait_req(sc)) {
NCR_MISC(("ncr5380_msg_in: BSY but no REQ\n"));
/* XXX - Try asserting ATN...? */
act_flags |= ACT_RESET_BUS;
return (act_flags);
}
phase = SCI_CUR_PHASE(*sc->sci_bus_csr);
if (phase != PHASE_MSG_IN) {
/*
* Target left MESSAGE IN, probably because it
* a) noticed our ATN signal, or
* b) ran out of messages.
*/
return (act_flags);
}
/* Still in MESSAGE IN phase, and REQ is asserted. */
if (*sc->sci_csr & SCI_CSR_PERR) {
ncr_sched_msgout(sc, SEND_PARITY_ERROR);
sc->sc_msg_flags |= NCR_DROP_MSGIN;
}
/* Gather incoming message bytes if needed. */
if ((sc->sc_msg_flags & NCR_DROP_MSGIN) == 0) {
if (n >= NCR_MAX_MSG_LEN) {
ncr_sched_msgout(sc, SEND_REJECT);
sc->sc_msg_flags |= NCR_DROP_MSGIN;
} else {
*sc->sc_imp++ = *sc->sci_data;
n++;
/*
* This testing is suboptimal, but most
* messages will be of the one byte variety, so
* it should not affect performance
* significantly.
*/
if (n == 1 && IS1BYTEMSG(sc->sc_imess[0]))
goto have_msg;
if (n == 2 && IS2BYTEMSG(sc->sc_imess[0]))
goto have_msg;
if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
n == sc->sc_imess[1] + 2)
goto have_msg;
}
}
/*
* If we reach this spot we're either:
* a) in the middle of a multi-byte message, or
* b) dropping bytes.
*/
/* Ack the last byte read. */
icmd |= SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
if (ncr5380_wait_not_req(sc)) {
NCR_MISC(("ncr5380_msg_in: stuck REQ\n"));
act_flags |= ACT_RESET_BUS;
return (act_flags);
}
icmd &= ~SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
/* back to nextbyte */
}
have_msg:
/* We now have a complete message. Parse it. */
NCR_MSGS(("n=%d imess=0x%02x ", n, sc->sc_imess[0]));
/* Make sure we are connected. */
if (sc->sc_current == NULL) {
printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
goto reset;
}
sr = sc->sc_current;
switch (sc->sc_imess[0]) {
case MSG_CMDCOMPLETE:
/* sc->sc_state = NCR_CMDCOMPLETE; */
if (sc->sc_datalen < 0) {
printf("%s: %d extra bytes from %d:%d\n",
sc->sc_dev.dv_xname, -sc->sc_datalen,
sr->sr_target, sr->sr_lun);
sc->sc_datalen = 0;
}
/* Target is about to disconnect. */
NCR_MISC(("ncr5380_msg_in: cmdcomplete\n"));
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
break;
case MSG_DISCONNECT:
/* sc->sc_state = NCR_DISCONNECT; */
/* Target is about to disconnect. */
NCR_MISC(("ncr5380_msg_in: disconnect\n"));
act_flags |= ACT_DISCONNECT;
break;
case MSG_PARITY_ERROR:
/* Resend the last message. */
ncr_sched_msgout(sc, sc->sc_msgout);
break;
case MSG_MESSAGE_REJECT:
/* The target rejects the last message we sent. */
NCR_MSGS(("ncr5380_msg_in: reject\n"));
switch (sc->sc_msgout) {
case SEND_IDENTIFY:
/* Really old target controller? */
/* XXX ... */
break;
case SEND_INIT_DET_ERR:
goto abort;
}
break;
case MSG_NOOP:
break;
case MSG_SAVEDATAPOINTER:
sr->sr_data = sc->sc_dataptr;
sr->sr_datalen = sc->sc_datalen;
sr->sr_dma_hand = sc->sc_dma_hand;
break;
case MSG_RESTOREPOINTERS:
sc->sc_dataptr = sr->sr_data;
sc->sc_datalen = sr->sr_datalen;
sc->sc_dma_hand = sr->sr_dma_hand;
break;
case MSG_EXTENDED:
switch (sc->sc_imess[2]) {
case MSG_EXT_SDTR:
case MSG_EXT_WDTR:
/* The ncr5380 can not do synchronous mode. */
goto reject;
default:
printf("%s: unrecognized MESSAGE EXTENDED; sending REJECT\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
goto reject;
}
break;
default:
printf("%s: unrecognized MESSAGE; sending REJECT\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
/* fallthrough */
reject:
ncr_sched_msgout(sc, SEND_REJECT);
break;
reset:
sc->sc_msg_flags |= NCR_ABORTING;
ncr_sched_msgout(sc, SEND_DEV_RESET);
break;
abort:
sc->sc_msg_flags |= NCR_ABORTING;
ncr_sched_msgout(sc, SEND_ABORT);
break;
}
/* Ack the last byte read. */
icmd |= SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
if (ncr5380_wait_not_req(sc)) {
NCR_MISC(("ncr5380_msg_in: stuck REQ\n"));
act_flags |= ACT_RESET_BUS;
}
icmd &= ~SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
/* Go get the next message, if any. */
if (act_flags == ACT_CONTINUE)
goto nextmsg;
return (act_flags);
}
/*
* The message out (and in) stuff is a bit complicated:
* If the target requests another message (sequence) without
* having changed phase in between it really asks for a
* retransmit, probably due to parity error(s).
* The following messages can be sent:
* IDENTIFY @ These 4 stem from SCSI command activity
* SDTR @
* WDTR @
* DEV_RESET @
* REJECT if MSGI doesn't make sense
* PARITY_ERROR if parity error while in MSGI
* INIT_DET_ERR if parity error while not in MSGI
* ABORT if INIT_DET_ERR rejected
* NOOP if asked for a message and there's nothing to send
*
* Note that we call this one with (sc_current == NULL)
* when sending ABORT for unwanted reselections.
*/
static int
ncr5380_msg_out(sc)
register struct ncr5380_softc *sc;
{
struct sci_req *sr = sc->sc_current;
int n, phase, resel;
int progress, act_flags;
register u_char icmd;
NCR_TRACE(("ncr_msgout "));
progress = 0; /* did we send any messages? */
act_flags = ACT_CONTINUE;
icmd = *sc->sci_icmd & SCI_ICMD_RMASK;
/*
* Set ATN. If we're just sending a trivial 1-byte message,
* we'll clear ATN later on anyway. Also drive the data bus.
*/
icmd |= (SCI_ICMD_ATN | SCI_ICMD_DATA);
*sc->sci_icmd = icmd;
if (sc->sc_prevphase == PHASE_MSG_OUT) {
if (sc->sc_omp == sc->sc_omess) {
/*
* This is a retransmission.
*
* We get here if the target stayed in MESSAGE OUT
* phase. Section 5.1.9.2 of the SCSI 2 spec indicates
* that all of the previously transmitted messages must
* be sent again, in the same order. Therefore, we
* requeue all the previously transmitted messages, and
* start again from the top. Our simple priority
* scheme keeps the messages in the right order.
*/
NCR_MSGS(("ncr5380_msg_out: retransmit\n"));
sc->sc_msgpriq |= sc->sc_msgoutq;
} else {
/* This is a continuation of the previous message. */
n = sc->sc_omp - sc->sc_omess;
goto nextbyte;
}
}
/* No messages transmitted so far. */
sc->sc_msgoutq = 0;
nextmsg:
/* Pick up highest priority message. */
sc->sc_msgout = sc->sc_msgpriq & -sc->sc_msgpriq;
sc->sc_msgpriq &= ~sc->sc_msgout;
sc->sc_msgoutq |= sc->sc_msgout;
/* Build the outgoing message data. */
switch (sc->sc_msgout) {
case SEND_IDENTIFY:
/* (sc->sc_state != NCR_CONNECTED) */
if (sr == NULL) {
printf("%s: SEND_IDENTIFY while not connected; sending NOOP\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
goto noop;
}
resel = (sc->sc_flags & NCR5380_PERMIT_RESELECT) ? 1 : 0;
resel &= (sr->sr_flags & (SR_IMMED | SR_SENSE)) ? 0 : 1;
sc->sc_omess[0] = MSG_IDENTIFY(sr->sr_lun, resel);
n = 1;
break;
case SEND_DEV_RESET:
/* Expect disconnect after this! */
/* XXX: Kill jobs for this target? */
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
sc->sc_omess[0] = MSG_BUS_DEV_RESET;
n = 1;
break;
case SEND_REJECT:
sc->sc_omess[0] = MSG_MESSAGE_REJECT;
n = 1;
break;
case SEND_PARITY_ERROR:
sc->sc_omess[0] = MSG_PARITY_ERROR;
n = 1;
break;
case SEND_INIT_DET_ERR:
sc->sc_omess[0] = MSG_INITIATOR_DET_ERR;
n = 1;
break;
case SEND_ABORT:
/* Expect disconnect after this! */
/* XXX: Set error flag? */
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
sc->sc_omess[0] = MSG_ABORT;
n = 1;
break;
case 0:
printf("%s: unexpected MESSAGE OUT; sending NOOP\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
noop:
sc->sc_omess[0] = MSG_NOOP;
n = 1;
break;
default:
printf("%s: weird MESSAGE OUT; sending NOOP\n",
sc->sc_dev.dv_xname);
NCR_BREAK();
goto noop;
}
sc->sc_omp = &sc->sc_omess[n];
nextbyte:
/* Send message bytes. */
while (n > 0) {
/*
* Send a message byte.
* First check BSY, REQ, phase...
*/
if (!SCI_BUSY(sc)) {
NCR_MISC(("ncr5380_msg_out: lost BSY\n"));
goto out;
}
if (ncr5380_wait_req(sc)) {
NCR_MISC(("ncr5380_msg_out: no REQ\n"));
goto out;
}
phase = SCI_CUR_PHASE(*sc->sci_bus_csr);
if (phase != PHASE_MSG_OUT) {
/*
* Target left MESSAGE OUT, possibly to reject
* our message.
*/
goto out;
}
/* Yes, we can send this message byte. */
--n;
/* Clear ATN before last byte if this is the last message. */
if (n == 0 && sc->sc_msgpriq == 0) {
icmd &= ~SCI_ICMD_ATN;
*sc->sci_icmd = icmd;
/* 2 deskew delays */
delay(2); /* XXX */
}
/* Put data on the bus. */
*sc->sci_odata = *--sc->sc_omp;
/* Raise ACK to tell target data is on the bus. */
icmd |= SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
/* Wait for REQ to be negated. */
if (ncr5380_wait_not_req(sc)) {
NCR_MISC(("ncr5380_msg_out: stuck REQ\n"));
act_flags |= ACT_RESET_BUS;
goto out;
}
/* Finally, drop ACK. */
icmd &= ~SCI_ICMD_ACK;
*sc->sci_icmd = icmd;
}
progress++;
/* We get here only if the entire message has been transmitted. */
if ((sc->sc_msgpriq != 0) && (act_flags == ACT_CONTINUE)) {
/* There are more outgoing messages. */
goto nextmsg;
}
/*
* The last message has been transmitted. We need to remember the last
* message transmitted (in case the target switches to MESSAGE IN phase
* and sends a MESSAGE REJECT), and the list of messages transmitted
* this time around (in case the target stays in MESSAGE OUT phase to
* request a retransmit).
*/
out:
/* Stop driving the data bus. */
icmd &= ~SCI_ICMD_DATA;
*sc->sci_icmd = icmd;
if (!progress)
act_flags |= ACT_RESET_BUS;
return (act_flags);
}
/*
* Handle command phase.
*/
static int
ncr5380_command(sc)
struct ncr5380_softc *sc;
{
int len;
struct scsi_sense rqs;
struct sci_req *sr = sc->sc_current;
struct scsi_xfer *xs = sr->sr_xs;
if (sr->sr_flags & SR_SENSE) {
rqs.opcode = REQUEST_SENSE;
rqs.byte2 = xs->sc_link->lun << 5;
rqs.length = sizeof(xs->sense);
rqs.unused[0] = rqs.unused[1] = rqs.control = 0;
len = ncr5380_pio_out(sc, PHASE_CMD, sizeof(rqs),
(u_char *)&rqs);
}
else {
/* Assume command can be sent in one go. */
/* XXX: Do this using DMA, and get a phase change intr? */
len = ncr5380_pio_out(sc, PHASE_CMD, xs->cmdlen,
(u_char *)xs->cmd);
}
if (len != xs->cmdlen) {
printf("ncr5380_command: short transfer: wanted %d got %d.\n",
xs->cmdlen, len);
NCR_BREAK();
if (len < 6)
return ACT_RESET_BUS;
}
return ACT_CONTINUE;
}
/*
* Handle either data_in or data_out
*/
static int
ncr5380_data_xfer(sc, phase)
struct ncr5380_softc *sc;
int phase;
{
struct sci_req *sr = sc->sc_current;
struct scsi_xfer *xs = sr->sr_xs;
int expected_phase;
int i, len;
if (sc->sc_msg_flags & NCR_ABORTING) {
sc->sc_msg_flags &= ~NCR_ABORTING;
printf("%s: data phase after abort\n",
sc->sc_dev.dv_xname);
return ACT_RESET_BUS;
}
if (sr->sr_flags & SR_SENSE) {
if (phase != PHASE_DATA_IN) {
printf("%s: sense phase error\n", sc->sc_dev.dv_xname);
return (ACT_ABORT_CMD);
}
NCR_MISC(("ncr5380_data_xfer: reading sense data\n"));
len = ncr5380_pio_in(sc, phase, sizeof(xs->sense),
(u_char *)&xs->sense);
return ACT_CONTINUE; /* XXX */
}
/* Validate expected phase (data_in or data_out) */
expected_phase = (xs->flags & SCSI_DATA_OUT) ?
PHASE_DATA_OUT : PHASE_DATA_IN;
if (phase != expected_phase) {
printf("%s: data phase error\n", sc->sc_dev.dv_xname);
return (ACT_ABORT_CMD);
}
/* Make sure we have some data to move. */
if (sc->sc_datalen <= 0) {
printf("%s: can not transfer more data\n");
return (ACT_ABORT_CMD);
}
NCR_MISC(("ncr5380_data_xfer: todo=%d\n", sc->sc_datalen));
/*
* Attempt DMA only if dma_alloc gave us a DMA handle AND
* there is enough left to transfer so DMA is worth while.
* Note that we can come back here after a DMA transfer moves
* all but the last few bytes of a request, in which case
* we should finish the request using PIO. In this case
* there WILL be a dma_handle, but we should not use it.
* Data alignment was checked in DMA alloc.
*/
if (sc->sc_dma_hand &&
(sc->sc_datalen >= sc->sc_min_dma_len))
{
/* OK, really do DMA. */
(*sc->sc_dma_start)(sc);
if (sc->sc_dma_flags & DMA5380_POLL) {
(*sc->sc_dma_poll)(sc);
(*sc->sc_dma_stop)(sc);
}
if (sc->sc_dma_flags & DMA5380_INPROGRESS) {
/* Interrupt will let us continue */
NCR_MISC(("ncr5380_data_xfer: expect DMA intr.\n"));
return ACT_WAIT_INTR;
}
/* Must have done polled DMA. */
SCI_CLR_INTR(sc); /* XXX */
/* Let _machine call us again... */
return ACT_CONTINUE;
}
NCR_MISC(("ncr5380_data_xfer: doing PIO, len=%d\n", sc->sc_datalen));
if (phase == PHASE_DATA_OUT) {
len = ncr5380_pio_out(sc, phase, sc->sc_datalen, sc->sc_dataptr);
} else {
len = ncr5380_pio_in (sc, phase, sc->sc_datalen, sc->sc_dataptr);
}
sc->sc_dataptr += len;
sc->sc_datalen -= len;
NCR_MISC(("ncr5380_data_xfer: did PIO, resid=%d\n", sc->sc_datalen));
return (ACT_CONTINUE);
}
static int
ncr5380_status(sc)
struct ncr5380_softc *sc;
{
int len;
u_char status;
struct sci_req *sr = sc->sc_current;
struct scsi_xfer *xs = sr->sr_xs;
len = ncr5380_pio_in(sc, PHASE_STATUS, 1, &status);
if (len) {
sr->sr_status = status;
} else {
printf("ncr5380_status: none?\n");
}
return ACT_CONTINUE;
}
/*
* This is the big state machine that follows SCSI phase changes.
* This is somewhat like a co-routine. It will do a SCSI command,
* and exit if the command is complete, or if it must wait (usually
* for DMA).
*
* The bus must be selected, and we need to know which command is
* being undertaken.
*/
static void
ncr5380_machine(sc)
struct ncr5380_softc *sc;
{
struct sci_req *sr = sc->sc_current;
struct scsi_xfer *xs = sr->sr_xs;
int phase, act_flags, timo;
#ifdef DIAGNOSTIC
if ((getsr() & PSL_IPL) < PSL_IPL2)
panic("ncr5380_machine: bad spl");
#endif
act_flags = ACT_CONTINUE;
next_phase:
/*
* We can arrive back here due to a DMA interrupt
* or DMA timeout error. On error, reset it.
* If DMA failed, we probably can't talk to it.
*/
if (sc->sc_dma_flags & DMA5380_ERROR) {
printf("ncr5380: DMA error\n");
NCR_BREAK();
/* Make sure we don't keep trying it... */
if (sc->sc_dma_hand) {
(*sc->sc_dma_free)(sc);
sc->sc_dma_hand = NULL;
}
act_flags |= ACT_RESET_BUS;
goto do_actions;
}
if (!SCI_BUSY(sc)) {
/* Unexpected disconnect */
printf("ncr5380_machine: unexpected disconnect.\n");
xs->error = XS_DRIVER_STUFFUP;
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
goto do_actions;
}
/*
* Wait for REQ before reading the phase.
* Need to wait longer than usual here, because
* some devices are just plain slow...
*/
timo = ncr5380_wait_phase_timo;
for (;;) {
if (*sc->sci_bus_csr & SCI_BUS_REQ)
break;
if (--timo <= 0) {
printf("%s: no REQ for next phase, reset\n",
sc->sc_dev.dv_xname);
/* Reset implies disconnect, cmd fail. */
act_flags |= ACT_RESET_BUS;
goto do_actions;
}
delay(100);
}
phase = SCI_CUR_PHASE(*sc->sci_bus_csr);
NCR_MISC(("ncr5380_machine: phase=%s\n",
phase_names[phase & 7]));
/*
* We make the assumption that the device knows what it's
* doing, so any phase is good.
*/
*sc->sci_tcmd = phase; /* acknowledge */
switch (phase) {
case PHASE_DATA_OUT:
case PHASE_DATA_IN:
act_flags = ncr5380_data_xfer(sc, phase);
break;
case PHASE_CMD:
act_flags = ncr5380_command(sc);
break;
case PHASE_STATUS:
act_flags = ncr5380_status(sc);
break;
case PHASE_MSG_OUT:
act_flags = ncr5380_msg_out(sc);
break;
case PHASE_MSG_IN:
act_flags = ncr5380_msg_in(sc);
break;
default:
printf("ncr5380_machine: Unexpected phase 0x%x\n", phase);
act_flags = ACT_ABORT_CMD;
break;
} /* switch */
sc->sc_prevphase = phase;
/* short-cut */
if (act_flags == ACT_CONTINUE)
goto next_phase;
do_actions:
__asm("_ncr5380_actions:");
NCR_MISC(("ncr5380_machine: act_flags=0x%x\n", act_flags));
if (act_flags & ACT_WAIT_INTR) {
/* Wait for DMA complete interrupt (or timeout). */
NCR_MISC(("ncr5380_machine: wait for dma\n"));
return;
}
if (act_flags & ACT_RESET_BUS) {
/*
* Reset the SCSI bus, usually due to a timeout.
* The error code XS_TIMEOUT allows retries.
*/
NCR_MISC(("ncr5380_machine: reset scsi bus\n"));
ncr5380_reset_scsibus(sc);
xs->error = XS_TIMEOUT;
act_flags = (ACT_DISCONNECT | ACT_CMD_DONE);
}
/* Try ONCE to send an ABORT message. */
if (act_flags & ACT_ABORT_CMD) {
act_flags &= ~ACT_ABORT_CMD;
/* Try to send MSG_ABORT to the target. */
NCR_MISC(("ncr5380_machine: send abort\n"));
sc->sc_msg_flags |= NCR_ABORTING;
ncr_sched_msgout(sc, SEND_ABORT);
goto next_phase;
}
if (sc->sc_msg_flags & NCR_ABORTING) {
sc->sc_msg_flags &= ~NCR_ABORTING;
printf("ncr5380_machine: command aborted\n");
xs->error = XS_DRIVER_STUFFUP;
act_flags |= (ACT_DISCONNECT | ACT_CMD_DONE);
}
if (act_flags & ACT_CMD_DONE) {
/* Need to call scsi_done() */
xs->resid = sc->sc_datalen;
/* Note: this will clear sc_current */
ncr5380_done(sc);
act_flags |= ACT_DISCONNECT;
}
if (act_flags & ACT_DISCONNECT) {
/*
* The device has dropped BSY (or will soon).
* Return and let ncr5380_sched() do its thing.
*/
*sc->sci_icmd = 0;
*sc->sci_mode = 0;
*sc->sci_tcmd = 0;
SCI_CLR_INTR(sc);
*sc->sci_sel_enb = 0x80;
/*
* We may be here due to a disconnect message,
* in which case we did NOT call ncr5380_done,
* so we need to clear sc_current.
*/
sc->sc_current = NULL;
return;
}
}
Reference in New Issue View Git Blame Copy Permalink