/*      $NetBSD: mb89352.c,v 1.63 2023/05/10 00:10:54 riastradh Exp $   */
/*      NecBSD: mb89352.c,v 1.4 1998/03/14 07:31:20 kmatsuda Exp        */

/*-
* Copyright (c) 1996-1999,2004 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Charles M. Hannum, Masaru Oki and Kouichi Matsuda.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``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 FOUNDATION OR CONTRIBUTORS
* 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 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 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.
*/
/*
* [NetBSD for NEC PC-98 series]
*  Copyright (c) 1996, 1997, 1998
*      NetBSD/pc98 porting staff. All rights reserved.
*  Copyright (c) 1996, 1997, 1998
*      Kouichi Matsuda. All rights reserved.
*/

/*
* Acknowledgements: Many of the algorithms used in this driver are
* inspired by the work of Julian Elischer ([email protected]) and
* Charles Hannum ([email protected]).  Thanks a million!
*/

/* TODO list:
* 1) Get the DMA stuff working.
* 2) Get the iov/uio stuff working. Is this a good thing ???
* 3) Get the synch stuff working.
* 4) Rewrite it to use malloc for the acb structs instead of static alloc.?
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: mb89352.c,v 1.63 2023/05/10 00:10:54 riastradh Exp $");

#ifdef DDB
#define integrate
#else
#define integrate       inline static
#endif

/*
* A few customizable items:
*/

/* Synchronous data transfers? */
#define SPC_USE_SYNCHRONOUS     0
#define SPC_SYNC_REQ_ACK_OFS    8

/* Wide data transfers? */
#define SPC_USE_WIDE            0
#define SPC_MAX_WIDTH           0

/* Max attempts made to transmit a message */
#define SPC_MSG_MAX_ATTEMPT     3 /* Not used now XXX */

/*
* Some spin loop parameters (essentially how long to wait some places)
* The problem(?) is that sometimes we expect either to be able to transmit a
* byte or to get a new one from the SCSI bus pretty soon.  In order to avoid
* returning from the interrupt just to get yanked back for the next byte we
* may spin in the interrupt routine waiting for this byte to come.  How long?
* This is really (SCSI) device and processor dependent.  Tuneable, I guess.
*/
#define SPC_MSGIN_SPIN  1       /* Will spinwait upto ?ms for a new msg byte */
#define SPC_MSGOUT_SPIN 1

/*
* Include debug functions?  At the end of this file there are a bunch of
* functions that will print out various information regarding queued SCSI
* commands, driver state and chip contents.  You can call them from the
* kernel debugger.  If you set SPC_DEBUG to 0 they are not included (the
* kernel uses less memory) but you lose the debugging facilities.
*/
#if 0
#define SPC_DEBUG               1
#endif

#define SPC_ABORT_TIMEOUT       2000    /* time to wait for abort */

/* threshold length for DMA transfer */
#define SPC_MIN_DMA_LEN 32

#ifdef luna68k  /* XXX old drives like DK312C in LUNAs require this */
#define NO_MANUAL_XFER
#endif
#ifdef x68k     /* XXX it seems x68k SPC SCSI hardware has some quirks */
#define NEED_DREQ_ON_HARDWARE_XFER
#define NO_MANUAL_XFER
#endif

/* End of customizable parameters */

/*
* MB89352 SCSI Protocol Controller (SPC) routines.
*/

#include "opt_ddb.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/queue.h>

#include <sys/intr.h>
#include <sys/bus.h>

#include <dev/scsipi/scsi_all.h>
#include <dev/scsipi/scsipi_all.h>
#include <dev/scsipi/scsi_message.h>
#include <dev/scsipi/scsiconf.h>

#include <dev/ic/mb89352reg.h>
#include <dev/ic/mb89352var.h>

#include "ioconf.h"

#ifndef DDB
#define Debugger() panic("should call debugger here (mb89352.c)")
#endif /* ! DDB */

#if SPC_DEBUG
int spc_debug = 0x00; /* SPC_SHOWSTART|SPC_SHOWMISC|SPC_SHOWTRACE; */
#endif

void    spc_done(struct spc_softc *, struct spc_acb *);
void    spc_dequeue(struct spc_softc *, struct spc_acb *);
void    spc_scsipi_request(struct scsipi_channel *, scsipi_adapter_req_t,
   void *);
int     spc_poll(struct spc_softc *, struct scsipi_xfer *, int);
integrate void  spc_sched_msgout(struct spc_softc *, uint8_t);
integrate void  spc_setsync(struct spc_softc *, struct spc_tinfo *);
void    spc_select(struct spc_softc *, struct spc_acb *);
void    spc_timeout(void *);
void    spc_scsi_reset(struct spc_softc *);
void    spc_reset(struct spc_softc *);
void    spc_free_acb(struct spc_softc *, struct spc_acb *, int);
struct spc_acb* spc_get_acb(struct spc_softc *);
int     spc_reselect(struct spc_softc *, int);
void    spc_msgin(struct spc_softc *);
void    spc_abort(struct spc_softc *, struct spc_acb *);
void    spc_msgout(struct spc_softc *);
int     spc_dataout_pio(struct spc_softc *, uint8_t *, int);
int     spc_datain_pio(struct spc_softc *, uint8_t *, int);
#if SPC_DEBUG
void    spc_print_acb(struct spc_acb *);
void    spc_dump_driver(struct spc_softc *);
void    spc_dump89352(struct spc_softc *);
void    spc_show_scsi_cmd(struct spc_acb *);
void    spc_print_active_acb(void);
#endif

/*
* INITIALIZATION ROUTINES (probe, attach ++)
*/

/*
* Do the real search-for-device.
* Prerequisite: sc->sc_iobase should be set to the proper value
*/
int
spc_find(bus_space_tag_t iot, bus_space_handle_t ioh, int bdid)
{
       long timeout = SPC_ABORT_TIMEOUT;

       SPC_TRACE(("spc: probing for spc-chip\n"));
       /*
        * Disable interrupts then reset the FUJITSU chip.
        */
       bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_CTRLRST);
       bus_space_write_1(iot, ioh, SCMD, 0);
       bus_space_write_1(iot, ioh, PCTL, 0);
       bus_space_write_1(iot, ioh, TEMP, 0);
       bus_space_write_1(iot, ioh, TCH, 0);
       bus_space_write_1(iot, ioh, TCM, 0);
       bus_space_write_1(iot, ioh, TCL, 0);
       bus_space_write_1(iot, ioh, INTS, 0);
       bus_space_write_1(iot, ioh, SCTL,
           SCTL_DISABLE | SCTL_ABRT_ENAB | SCTL_PARITY_ENAB | SCTL_RESEL_ENAB);
       bus_space_write_1(iot, ioh, BDID, bdid);
       delay(400);
       bus_space_write_1(iot, ioh, SCTL,
           bus_space_read_1(iot, ioh, SCTL) & ~SCTL_DISABLE);

       /* The following detection is derived from spc.c
        * (by Takahide Matsutsuka) in FreeBSD/pccard-test.
        */
       while (bus_space_read_1(iot, ioh, PSNS) && timeout) {
               timeout--;
               DELAY(1);
       }
       if (timeout == 0) {
               printf("spc: find failed\n");
               return 0;
       }

       SPC_START(("SPC found"));
       return 1;
}

void
spc_attach(struct spc_softc *sc)
{
       struct scsipi_adapter *adapt = &sc->sc_adapter;
       struct scsipi_channel *chan = &sc->sc_channel;

       SPC_TRACE(("spc_attach  "));
       sc->sc_state = SPC_INIT;

       sc->sc_freq = 20;       /* XXXX Assume 20 MHz. */

#if SPC_USE_SYNCHRONOUS
       /*
        * These are the bounds of the sync period, based on the frequency of
        * the chip's clock input and the size and offset of the sync period
        * register.
        *
        * For a 20MHz clock, this gives us 25, or 100ns, or 10MB/s, as a
        * maximum transfer rate, and 112.5, or 450ns, or 2.22MB/s, as a
        * minimum transfer rate.
        */
       sc->sc_minsync = (2 * 250) / sc->sc_freq;
       sc->sc_maxsync = (9 * 250) / sc->sc_freq;
#endif

       /*
        * Fill in the adapter.
        */
       adapt->adapt_dev = sc->sc_dev;
       adapt->adapt_nchannels = 1;
       adapt->adapt_openings = 7;
       adapt->adapt_max_periph = 1;
       adapt->adapt_request = spc_scsipi_request;
       adapt->adapt_minphys = minphys;

       chan->chan_adapter = &sc->sc_adapter;
       chan->chan_bustype = &scsi_bustype;
       chan->chan_channel = 0;
       chan->chan_ntargets = 8;
       chan->chan_nluns = 8;
       chan->chan_id = sc->sc_initiator;

       /*
        * Add reference to adapter so that we drop the reference after
        * config_found() to make sure the adapter is disabled.
        */
       if (scsipi_adapter_addref(adapt) != 0) {
               aprint_error_dev(sc->sc_dev, "unable to enable controller\n");
               return;
       }

       spc_init(sc, 1);        /* Init chip and driver */

       /*
        * ask the adapter what subunits are present
        */
       sc->sc_child = config_found(sc->sc_dev, chan, scsiprint, CFARGS_NONE);
       scsipi_adapter_delref(adapt);
}

void
spc_childdet(device_t self, device_t child)
{
       struct spc_softc *sc = device_private(self);

       if (sc->sc_child == child)
               sc->sc_child = NULL;
}

int
spc_detach(device_t self, int flags)
{
       int error;

       error = config_detach_children(self, flags);
       if (error)
               return error;

       return 0;
}

/*
* Initialize MB89352 chip itself
* The following conditions should hold:
* spc_isa_probe should have succeeded, i.e. the iobase address in spc_softc
* must be valid.
*/
void
spc_reset(struct spc_softc *sc)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_reset  "));
       /*
        * Disable interrupts then reset the FUJITSU chip.
        */
       bus_space_write_1(iot, ioh, SCTL, SCTL_DISABLE | SCTL_CTRLRST);
       bus_space_write_1(iot, ioh, SCMD, 0);
       bus_space_write_1(iot, ioh, TMOD, 0);
       bus_space_write_1(iot, ioh, PCTL, 0);
       bus_space_write_1(iot, ioh, TEMP, 0);
       bus_space_write_1(iot, ioh, TCH, 0);
       bus_space_write_1(iot, ioh, TCM, 0);
       bus_space_write_1(iot, ioh, TCL, 0);
       bus_space_write_1(iot, ioh, INTS, 0);
       bus_space_write_1(iot, ioh, SCTL,
           SCTL_DISABLE | SCTL_ABRT_ENAB | SCTL_PARITY_ENAB | SCTL_RESEL_ENAB);
       bus_space_write_1(iot, ioh, BDID, sc->sc_initiator);
       delay(400);
       bus_space_write_1(iot, ioh, SCTL,
           bus_space_read_1(iot, ioh, SCTL) & ~SCTL_DISABLE);
}


/*
* Pull the SCSI RST line for 500us.
*/
void
spc_scsi_reset(struct spc_softc *sc)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_scsi_reset  "));
       bus_space_write_1(iot, ioh, SCMD,
           bus_space_read_1(iot, ioh, SCMD) | SCMD_RST);
       delay(500);
       bus_space_write_1(iot, ioh, SCMD,
           bus_space_read_1(iot, ioh, SCMD) & ~SCMD_RST);
       delay(50);
}

/*
* Initialize spc SCSI driver.
*/
void
spc_init(struct spc_softc *sc, int bus_reset)
{
       struct spc_acb *acb;
       int r;

       SPC_TRACE(("spc_init  "));
       if (bus_reset) {
               spc_reset(sc);
               spc_scsi_reset(sc);
       }
       spc_reset(sc);

       if (sc->sc_state == SPC_INIT) {
               /* First time through; initialize. */
               TAILQ_INIT(&sc->ready_list);
               TAILQ_INIT(&sc->nexus_list);
               TAILQ_INIT(&sc->free_list);
               sc->sc_nexus = NULL;
               acb = sc->sc_acb;
               memset(acb, 0, sizeof(sc->sc_acb));
               for (r = 0; r < sizeof(sc->sc_acb) / sizeof(*acb); r++) {
                       TAILQ_INSERT_TAIL(&sc->free_list, acb, chain);
                       acb++;
               }
               memset(&sc->sc_tinfo, 0, sizeof(sc->sc_tinfo));
       } else {
               /* Cancel any active commands. */
               sc->sc_state = SPC_CLEANING;
               if ((acb = sc->sc_nexus) != NULL) {
                       acb->xs->error = XS_DRIVER_STUFFUP;
                       callout_stop(&acb->xs->xs_callout);
                       spc_done(sc, acb);
               }
               while ((acb = TAILQ_FIRST(&sc->nexus_list)) != NULL) {
                       acb->xs->error = XS_DRIVER_STUFFUP;
                       callout_stop(&acb->xs->xs_callout);
                       spc_done(sc, acb);
               }
       }

       sc->sc_prevphase = PH_INVALID;
       for (r = 0; r < 8; r++) {
               struct spc_tinfo *ti = &sc->sc_tinfo[r];

               ti->flags = 0;
#if SPC_USE_SYNCHRONOUS
               ti->flags |= DO_SYNC;
               ti->period = sc->sc_minsync;
               ti->offset = SPC_SYNC_REQ_ACK_OFS;
#else
               ti->period = ti->offset = 0;
#endif
#if SPC_USE_WIDE
               ti->flags |= DO_WIDE;
               ti->width = SPC_MAX_WIDTH;
#else
               ti->width = 0;
#endif
       }

       sc->sc_state = SPC_IDLE;
       bus_space_write_1(sc->sc_iot, sc->sc_ioh, SCTL,
           bus_space_read_1(sc->sc_iot, sc->sc_ioh, SCTL) | SCTL_INTR_ENAB);
}

void
spc_free_acb(struct spc_softc *sc, struct spc_acb *acb, int flags)
{
       int s;

       SPC_TRACE(("spc_free_acb  "));
       s = splbio();

       acb->flags = 0;
       TAILQ_INSERT_HEAD(&sc->free_list, acb, chain);
       splx(s);
}

struct spc_acb *
spc_get_acb(struct spc_softc *sc)
{
       struct spc_acb *acb;
       int s;

       SPC_TRACE(("spc_get_acb  "));
       s = splbio();
       acb = TAILQ_FIRST(&sc->free_list);
       if (acb != NULL) {
               TAILQ_REMOVE(&sc->free_list, acb, chain);
               acb->flags |= ACB_ALLOC;
       }
       splx(s);
       return acb;
}

/*
* DRIVER FUNCTIONS CALLABLE FROM HIGHER LEVEL DRIVERS
*/

/*
* Expected sequence:
* 1) Command inserted into ready list
* 2) Command selected for execution
* 3) Command won arbitration and has selected target device
* 4) Send message out (identify message, eventually also sync.negotiations)
* 5) Send command
* 5a) Receive disconnect message, disconnect.
* 5b) Reselected by target
* 5c) Receive identify message from target.
* 6) Send or receive data
* 7) Receive status
* 8) Receive message (command complete etc.)
*/

/*
* Start a SCSI-command
* This function is called by the higher level SCSI-driver to queue/run
* SCSI-commands.
*/
void
spc_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
   void *arg)
{
       struct scsipi_xfer *xs;
       struct scsipi_periph *periph __diagused;
       struct spc_softc *sc = device_private(chan->chan_adapter->adapt_dev);
       struct spc_acb *acb;
       int s, flags;

       switch (req) {
       case ADAPTER_REQ_RUN_XFER:
               xs = arg;
               periph = xs->xs_periph;
               SPC_TRACE(("spc_scsipi_request  "));
               SPC_CMDS(("[0x%x, %d]->%d ", (int)xs->cmd->opcode, xs->cmdlen,
                   periph->periph_target));

               flags = xs->xs_control;
               acb = spc_get_acb(sc);
#ifdef DIAGNOSTIC
               /*
                * This should nerver happen as we track the resources
                * in the mid-layer.
                */
               if (acb == NULL) {
                       scsipi_printaddr(periph);
                       printf("unable to allocate acb\n");
                       panic("spc_scsipi_request");
               }
#endif

               /* Initialize acb */
               acb->xs = xs;
               acb->timeout = xs->timeout;

               if (xs->xs_control & XS_CTL_RESET) {
                       acb->flags |= ACB_RESET;
                       acb->scsipi_cmd_length = 0;
                       acb->data_length = 0;
               } else {
                       memcpy(&acb->scsipi_cmd, xs->cmd, xs->cmdlen);
                       acb->scsipi_cmd_length = xs->cmdlen;
                       acb->data_addr = xs->data;
                       acb->data_length = xs->datalen;
               }
               acb->target_stat = 0;

               s = splbio();

               TAILQ_INSERT_TAIL(&sc->ready_list, acb, chain);
               /*
                * Start scheduling unless a queue process is in progress.
                */
               if (sc->sc_state == SPC_IDLE)
                       spc_sched(sc);
               /*
                * After successful sending, check if we should return just now.
                * If so, return SUCCESSFULLY_QUEUED.
                */

               splx(s);

               if ((flags & XS_CTL_POLL) == 0)
                       return;

               /* Not allowed to use interrupts, use polling instead */
               s = splbio();
               if (spc_poll(sc, xs, acb->timeout)) {
                       spc_timeout(acb);
                       if (spc_poll(sc, xs, acb->timeout))
                               spc_timeout(acb);
               }
               splx(s);
               return;
       case ADAPTER_REQ_GROW_RESOURCES:
               /* XXX Not supported. */
               return;
       case ADAPTER_REQ_SET_XFER_MODE:
           {
               /*
                * We don't support Sync, Wide, or Tagged Command Queuing.
                * Just callback now, to report this.
                */
               struct scsipi_xfer_mode *xm = arg;

               xm->xm_mode = 0;
               xm->xm_period = 0;
               xm->xm_offset = 0;
               scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
               return;
           }
       }
}

/*
* Used when interrupt driven I/O isn't allowed, e.g. during boot.
*/
int
spc_poll(struct spc_softc *sc, struct scsipi_xfer *xs, int count)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_poll  "));
       while (count) {
               /*
                * If we had interrupts enabled, would we
                * have got an interrupt?
                */
               if (bus_space_read_1(iot, ioh, INTS) != 0)
                       spc_intr(sc);
               if ((xs->xs_status & XS_STS_DONE) != 0)
                       return 0;
               delay(1000);
               count--;
       }
       return 1;
}

/*
* LOW LEVEL SCSI UTILITIES
*/

integrate void
spc_sched_msgout(struct spc_softc *sc, uint8_t m)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_sched_msgout  "));
       if (sc->sc_msgpriq == 0)
               bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN);
       sc->sc_msgpriq |= m;
}

/*
* Set synchronous transfer offset and period.
*/
integrate void
spc_setsync(struct spc_softc *sc, struct spc_tinfo *ti)
{
#if SPC_USE_SYNCHRONOUS
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_setsync  "));
       if (ti->offset != 0)
               bus_space_write_1(iot, ioh, TMOD,
                   ((ti->period * sc->sc_freq) / 250 - 2) << 4 | ti->offset);
       else
               bus_space_write_1(iot, ioh, TMOD, 0);
#endif
}

/*
* Start a selection.  This is used by spc_sched() to select an idle target.
*/
void
spc_select(struct spc_softc *sc, struct spc_acb *acb)
{
       struct scsipi_periph *periph = acb->xs->xs_periph;
       int target = periph->periph_target;
       struct spc_tinfo *ti = &sc->sc_tinfo[target];
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       SPC_TRACE(("spc_select  "));
       spc_setsync(sc, ti);

#if 0
       bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ATN);
#endif

       bus_space_write_1(iot, ioh, PCTL, 0);
       bus_space_write_1(iot, ioh, TEMP,
           (1 << sc->sc_initiator) | (1 << target));
       /*
        * Setup BSY timeout (selection timeout).
        * 250ms according to the SCSI specification.
        * T = (X * 256 + 15) * Tclf * 2  (Tclf = 200ns on x68k)
        * To setup 256ms timeout,
        * 128000ns/200ns = X * 256 + 15
        * 640 - 15 = X * 256
        * X = 625 / 256
        * X = 2 + 113 / 256
        *  ==> tch = 2, tcm = 113 (correct?)
        */
       /* Time to the information transfer phase start. */
       /* XXX These values should be calculated from sc_freq */
       bus_space_write_1(iot, ioh, TCH, 2);
       bus_space_write_1(iot, ioh, TCM, 113);
       bus_space_write_1(iot, ioh, TCL, 3);
       bus_space_write_1(iot, ioh, SCMD, SCMD_SELECT);

       sc->sc_state = SPC_SELECTING;
}

int
spc_reselect(struct spc_softc *sc, int message)
{
       uint8_t selid, target, lun;
       struct spc_acb *acb;
       struct scsipi_periph *periph;
       struct spc_tinfo *ti;

       SPC_TRACE(("spc_reselect  "));
       /*
        * The SCSI chip made a snapshot of the data bus while the reselection
        * was being negotiated.  This enables us to determine which target did
        * the reselect.
        */
       selid = sc->sc_selid & ~(1 << sc->sc_initiator);
       if (selid & (selid - 1)) {
               printf("%s: reselect with invalid selid %02x; "
                   "sending DEVICE RESET\n", device_xname(sc->sc_dev), selid);
               SPC_BREAK();
               goto reset;
       }

       /*
        * Search wait queue for disconnected cmd
        * The list should be short, so I haven't bothered with
        * any more sophisticated structures than a simple
        * singly linked list.
        */
       target = ffs(selid) - 1;
       lun = message & 0x07;
       TAILQ_FOREACH(acb, &sc->nexus_list, chain) {
               periph = acb->xs->xs_periph;
               if (periph->periph_target == target &&
                   periph->periph_lun == lun)
                       break;
       }
       if (acb == NULL) {
               printf("%s: reselect from target %d lun %d with no nexus; "
                   "sending ABORT\n", device_xname(sc->sc_dev), target, lun);
               SPC_BREAK();
               goto abort;
       }

       /* Make this nexus active again. */
       TAILQ_REMOVE(&sc->nexus_list, acb, chain);
       sc->sc_state = SPC_CONNECTED;
       sc->sc_nexus = acb;
       ti = &sc->sc_tinfo[target];
       ti->lubusy |= (1 << lun);
       spc_setsync(sc, ti);

       if (acb->flags & ACB_RESET)
               spc_sched_msgout(sc, SEND_DEV_RESET);
       else if (acb->flags & ACB_ABORT)
               spc_sched_msgout(sc, SEND_ABORT);

       /* Do an implicit RESTORE POINTERS. */
       sc->sc_dp = acb->data_addr;
       sc->sc_dleft = acb->data_length;
       sc->sc_cp = (uint8_t *)&acb->scsipi_cmd;
       sc->sc_cleft = acb->scsipi_cmd_length;

       return (0);

reset:
       spc_sched_msgout(sc, SEND_DEV_RESET);
       return (1);

abort:
       spc_sched_msgout(sc, SEND_ABORT);
       return (1);
}

/*
* Schedule a SCSI operation.  This has now been pulled out of the interrupt
* handler so that we may call it from spc_scsi_cmd and spc_done.  This may
* save us an unnecessary interrupt just to get things going.  Should only be
* called when state == SPC_IDLE and at bio pl.
*/
void
spc_sched(struct spc_softc *sc)
{
       struct spc_acb *acb;
       struct scsipi_periph *periph;
       struct spc_tinfo *ti;

       /* missing the hw, just return and wait for our hw */
       if (sc->sc_flags & SPC_INACTIVE)
               return;
       SPC_TRACE(("spc_sched  "));
       /*
        * Find first acb in ready queue that is for a target/lunit pair that
        * is not busy.
        */
       TAILQ_FOREACH(acb, &sc->ready_list, chain) {
               periph = acb->xs->xs_periph;
               ti = &sc->sc_tinfo[periph->periph_target];
               if ((ti->lubusy & (1 << periph->periph_lun)) == 0) {
                       SPC_MISC(("selecting %d:%d  ",
                           periph->periph_target, periph->periph_lun));
                       TAILQ_REMOVE(&sc->ready_list, acb, chain);
                       sc->sc_nexus = acb;
                       spc_select(sc, acb);
                       return;
               } else {
                       SPC_MISC(("%d:%d busy\n",
                           periph->periph_target, periph->periph_lun));
               }
       }
       SPC_MISC(("idle  "));
       /* Nothing to start; just enable reselections and wait. */
}

/*
* POST PROCESSING OF SCSI_CMD (usually current)
*/
void
spc_done(struct spc_softc *sc, struct spc_acb *acb)
{
       struct scsipi_xfer *xs = acb->xs;
       struct scsipi_periph *periph = xs->xs_periph;
       struct spc_tinfo *ti = &sc->sc_tinfo[periph->periph_target];

       SPC_TRACE(("spc_done  "));

       if (xs->error == XS_NOERROR) {
               if (acb->flags & ACB_ABORT) {
                       xs->error = XS_DRIVER_STUFFUP;
               } else {
                       switch (acb->target_stat) {
                       case SCSI_CHECK:
                               /* First, save the return values */
                               xs->resid = acb->data_length;
                               /* FALLTHROUGH */
                       case SCSI_BUSY:
                               xs->status = acb->target_stat;
                               xs->error = XS_BUSY;
                               break;
                       case SCSI_OK:
                               xs->resid = acb->data_length;
                               break;
                       default:
                               xs->error = XS_DRIVER_STUFFUP;
#if SPC_DEBUG
                               printf("%s: spc_done: bad stat 0x%x\n",
                                   device_xname(sc->sc_dev), acb->target_stat);
#endif
                               break;
                       }
               }
       }

#if SPC_DEBUG
       if ((spc_debug & SPC_SHOWMISC) != 0) {
               if (xs->resid != 0)
                       printf("resid=%d ", xs->resid);
               else
                       printf("error=%d\n", xs->error);
       }
#endif

       /*
        * Remove the ACB from whatever queue it happens to be on.
        */
       if (acb->flags & ACB_NEXUS)
               ti->lubusy &= ~(1 << periph->periph_lun);
       if (acb == sc->sc_nexus) {
               sc->sc_nexus = NULL;
               sc->sc_state = SPC_IDLE;
               spc_sched(sc);
       } else
               spc_dequeue(sc, acb);

       spc_free_acb(sc, acb, xs->xs_control);
       ti->cmds++;
       scsipi_done(xs);
}

void
spc_dequeue(struct spc_softc *sc, struct spc_acb *acb)
{

       SPC_TRACE(("spc_dequeue  "));
       if (acb->flags & ACB_NEXUS)
               TAILQ_REMOVE(&sc->nexus_list, acb, chain);
       else
               TAILQ_REMOVE(&sc->ready_list, acb, chain);
}

/*
* INTERRUPT/PROTOCOL ENGINE
*/

/*
* 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.
*/
void
spc_msgin(struct spc_softc *sc)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;
       int n;
       uint8_t msg;

       SPC_TRACE(("spc_msgin  "));

       if (sc->sc_prevphase == PH_MSGIN) {
               /* 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_flags &= ~SPC_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 (;;) {
#ifdef NO_MANUAL_XFER /* XXX */
               uint8_t intstat;
               if (bus_space_read_1(iot, ioh, INTS) != 0) {
                       /*
                        * Target left MESSAGE IN, probably because it
                        * a) noticed our ATN signal, or
                        * b) ran out of messages.
                        */
                       goto out;
               }
#endif
               /* If parity error, just dump everything on the floor. */
               if ((bus_space_read_1(iot, ioh, SERR) &
                    (SERR_SCSI_PAR|SERR_SPC_PAR)) != 0) {
                       sc->sc_flags |= SPC_DROP_MSGIN;
                       spc_sched_msgout(sc, SEND_PARITY_ERROR);
               }

#ifdef NO_MANUAL_XFER /* XXX */
               /* send TRANSFER command. */
               bus_space_write_1(iot, ioh, TCH, 0);
               bus_space_write_1(iot, ioh, TCM, 0);
               bus_space_write_1(iot, ioh, TCL, 1);
               bus_space_write_1(iot, ioh, PCTL,
                   sc->sc_phase | PCTL_BFINT_ENAB);
#ifdef NEED_DREQ_ON_HARDWARE_XFER
               bus_space_write_1(iot, ioh, SCMD, SCMD_XFR);
#else
               bus_space_write_1(iot, ioh, SCMD, SCMD_XFR | SCMD_PROG_XFR);
#endif
               intstat = 0;
               for (;;) {
                       if ((bus_space_read_1(iot, ioh, SSTS) &
                           SSTS_DREG_EMPTY) == 0)
                               break;
                       /*
                        * We have to read INTS before checking SSTS to avoid
                        * race between SSTS_DREG_EMPTY and INTS_CMD_DONE.
                        */
                       if (intstat != 0)
                               goto out;
                       intstat = bus_space_read_1(iot, ioh, INTS);
               }
               msg = bus_space_read_1(iot, ioh, DREG);
#else
               if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_ATN) != 0)
                       bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN);
               bus_space_write_1(iot, ioh, PCTL, PCTL_BFINT_ENAB | PH_MSGIN);

               while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) {
                       if ((bus_space_read_1(iot, ioh, PSNS) & PH_MASK)
                           != PH_MSGIN ||
                           bus_space_read_1(iot, ioh, INTS) != 0)
                               /*
                                * Target left MESSAGE IN, probably because it
                                * a) noticed our ATN signal, or
                                * b) ran out of messages.
                                */
                               goto out;
                       DELAY(1);       /* XXX needs timeout */
               }

               msg = bus_space_read_1(iot, ioh, TEMP);
#endif

               /* Gather incoming message bytes if needed. */
               if ((sc->sc_flags & SPC_DROP_MSGIN) == 0) {
                       if (n >= SPC_MAX_MSG_LEN) {
                               sc->sc_flags |= SPC_DROP_MSGIN;
                               spc_sched_msgout(sc, SEND_REJECT);
                       } else {
                               *sc->sc_imp++ = msg;
                               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 && MSG_IS1BYTE(sc->sc_imess[0]))
                                       break;
                               if (n == 2 && MSG_IS2BYTE(sc->sc_imess[0]))
                                       break;
                               if (n >= 3 && MSG_ISEXTENDED(sc->sc_imess[0]) &&
                                   n == sc->sc_imess[1] + 2)
                                       break;
                       }
               }
               /*
                * If we reach this spot we're either:
                * a) in the middle of a multi-byte message, or
                * b) dropping bytes.
                */

#ifndef NO_MANUAL_XFER /* XXX */
               /* Ack the last byte read. */
               bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK);
               while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0)
                       DELAY(1);       /* XXX needs timeout */
               bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK);
#endif
       }

       SPC_MISC(("n=%d imess=0x%02x  ", n, sc->sc_imess[0]));

       /* We now have a complete message.  Parse it. */
       switch (sc->sc_state) {
               struct spc_acb *acb;
               struct spc_tinfo *ti;

       case SPC_CONNECTED:
               SPC_ASSERT(sc->sc_nexus != NULL);
               acb = sc->sc_nexus;
               ti = &sc->sc_tinfo[acb->xs->xs_periph->periph_target];

               switch (sc->sc_imess[0]) {
               case MSG_CMDCOMPLETE:
#if 0
                       if (sc->sc_dleft < 0) {
                               periph = acb->xs->xs_periph;
                               printf("%s: %ld extra bytes from %d:%d\n",
                                   device_xname(sc->sc_dev),
                                   (long)-sc->sc_dleft,
                                   periph->periph_target, periph->periph_lun);
                               sc->sc_dleft = 0;
                       }
#endif
                       acb->xs->resid = acb->data_length = sc->sc_dleft;
                       sc->sc_state = SPC_CMDCOMPLETE;
                       break;

               case MSG_PARITY_ERROR:
                       /* Resend the last message. */
                       spc_sched_msgout(sc, sc->sc_lastmsg);
                       break;

               case MSG_MESSAGE_REJECT:
                       SPC_MISC(("message rejected %02x  ", sc->sc_lastmsg));
                       switch (sc->sc_lastmsg) {
#if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE
                       case SEND_IDENTIFY:
                               ti->flags &= ~(DO_SYNC | DO_WIDE);
                               ti->period = ti->offset = 0;
                               spc_setsync(sc, ti);
                               ti->width = 0;
                               break;
#endif
#if SPC_USE_SYNCHRONOUS
                       case SEND_SDTR:
                               ti->flags &= ~DO_SYNC;
                               ti->period = ti->offset = 0;
                               spc_setsync(sc, ti);
                               break;
#endif
#if SPC_USE_WIDE
                       case SEND_WDTR:
                               ti->flags &= ~DO_WIDE;
                               ti->width = 0;
                               break;
#endif
                       case SEND_INIT_DET_ERR:
                               spc_sched_msgout(sc, SEND_ABORT);
                               break;
                       }
                       break;

               case MSG_NOOP:
                       break;

               case MSG_DISCONNECT:
                       ti->dconns++;
                       sc->sc_state = SPC_DISCONNECT;
                       break;

               case MSG_SAVEDATAPOINTER:
                       acb->data_addr = sc->sc_dp;
                       acb->data_length = sc->sc_dleft;
                       break;

               case MSG_RESTOREPOINTERS:
                       sc->sc_dp = acb->data_addr;
                       sc->sc_dleft = acb->data_length;
                       sc->sc_cp = (uint8_t *)&acb->scsipi_cmd;
                       sc->sc_cleft = acb->scsipi_cmd_length;
                       break;

               case MSG_EXTENDED:
                       switch (sc->sc_imess[2]) {
#if SPC_USE_SYNCHRONOUS
                       case MSG_EXT_SDTR:
                               if (sc->sc_imess[1] != 3)
                                       goto reject;
                               ti->period = sc->sc_imess[3];
                               ti->offset = sc->sc_imess[4];
                               ti->flags &= ~DO_SYNC;
                               if (ti->offset == 0) {
                               } else if (ti->period < sc->sc_minsync ||
                                   ti->period > sc->sc_maxsync ||
                                   ti->offset > 8) {
                                       ti->period = ti->offset = 0;
                                       spc_sched_msgout(sc, SEND_SDTR);
                               } else {
                                       scsipi_printaddr(acb->xs->xs_periph);
                                       printf("sync, offset %d, "
                                           "period %dnsec\n",
                                           ti->offset, ti->period * 4);
                               }
                               spc_setsync(sc, ti);
                               break;
#endif

#if SPC_USE_WIDE
                       case MSG_EXT_WDTR:
                               if (sc->sc_imess[1] != 2)
                                       goto reject;
                               ti->width = sc->sc_imess[3];
                               ti->flags &= ~DO_WIDE;
                               if (ti->width == 0) {
                               } else if (ti->width > SPC_MAX_WIDTH) {
                                       ti->width = 0;
                                       spc_sched_msgout(sc, SEND_WDTR);
                               } else {
                                       scsipi_printaddr(acb->xs->xs_periph);
                                       printf("wide, width %d\n",
                                           1 << (3 + ti->width));
                               }
                               break;
#endif

                       default:
                               printf("%s: unrecognized MESSAGE EXTENDED; "
                                   "sending REJECT\n",
                                   device_xname(sc->sc_dev));
                               SPC_BREAK();
                               goto reject;
                       }
                       break;

               default:
                       printf("%s: unrecognized MESSAGE; sending REJECT\n",
                           device_xname(sc->sc_dev));
                       SPC_BREAK();
               reject:
                       spc_sched_msgout(sc, SEND_REJECT);
                       break;
               }
               break;

       case SPC_RESELECTED:
               if (!MSG_ISIDENTIFY(sc->sc_imess[0])) {
                       printf("%s: reselect without IDENTIFY; "
                           "sending DEVICE RESET\n", device_xname(sc->sc_dev));
                       SPC_BREAK();
                       goto reset;
               }

               (void) spc_reselect(sc, sc->sc_imess[0]);
               break;

       default:
               printf("%s: unexpected MESSAGE IN; sending DEVICE RESET\n",
                   device_xname(sc->sc_dev));
               SPC_BREAK();
       reset:
               spc_sched_msgout(sc, SEND_DEV_RESET);
               break;

#ifdef notdef
       abort:
               spc_sched_msgout(sc, SEND_ABORT);
               break;
#endif
       }

#ifndef NO_MANUAL_XFER /* XXX */
       /* Ack the last message byte. */
       bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK);
       while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0)
               DELAY(1);       /* XXX needs timeout */
       bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK);
#endif

       /* Go get the next message, if any. */
       goto nextmsg;

out:
#ifdef NO_MANUAL_XFER /* XXX */
       /* Ack the last message byte. */
       bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK);
#endif
       SPC_MISC(("n=%d imess=0x%02x  ", n, sc->sc_imess[0]));
}

/*
* Send the highest priority, scheduled message.
*/
void
spc_msgout(struct spc_softc *sc)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;
#if SPC_USE_SYNCHRONOUS
       struct spc_tinfo *ti;
#endif
       int n;

       SPC_TRACE(("spc_msgout  "));

       if (sc->sc_prevphase == PH_MSGOUT) {
               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.
                        */
                       SPC_MISC(("retransmitting  "));
                       sc->sc_msgpriq |= sc->sc_msgoutq;
                       /*
                        * Set ATN.  If we're just sending a trivial 1-byte
                        * message, we'll clear ATN later on anyway.
                        */
                       bus_space_write_1(iot, ioh, SCMD,
                           SCMD_SET_ATN);      /* XXX? */
               } 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;
       sc->sc_lastmsg = 0;

nextmsg:
       /* Pick up highest priority message. */
       sc->sc_currmsg = sc->sc_msgpriq & -sc->sc_msgpriq;
       sc->sc_msgpriq &= ~sc->sc_currmsg;
       sc->sc_msgoutq |= sc->sc_currmsg;

       /* Build the outgoing message data. */
       switch (sc->sc_currmsg) {
       case SEND_IDENTIFY:
               SPC_ASSERT(sc->sc_nexus != NULL);
               sc->sc_omess[0] =
                   MSG_IDENTIFY(sc->sc_nexus->xs->xs_periph->periph_lun, 1);
               n = 1;
               break;

#if SPC_USE_SYNCHRONOUS
       case SEND_SDTR:
               SPC_ASSERT(sc->sc_nexus != NULL);
               ti = &sc->sc_tinfo[sc->sc_nexus->xs->xs_periph->periph_target];
               sc->sc_omess[4] = MSG_EXTENDED;
               sc->sc_omess[3] = MSG_EXT_SDTR_LEN;
               sc->sc_omess[2] = MSG_EXT_SDTR;
               sc->sc_omess[1] = ti->period >> 2;
               sc->sc_omess[0] = ti->offset;
               n = 5;
               break;
#endif

#if SPC_USE_WIDE
       case SEND_WDTR:
               SPC_ASSERT(sc->sc_nexus != NULL);
               ti = &sc->sc_tinfo[sc->sc_nexus->xs->xs_periph->periph_target];
               sc->sc_omess[3] = MSG_EXTENDED;
               sc->sc_omess[2] = MSG_EXT_WDTR_LEN;
               sc->sc_omess[1] = MSG_EXT_WDTR;
               sc->sc_omess[0] = ti->width;
               n = 4;
               break;
#endif

       case SEND_DEV_RESET:
               sc->sc_flags |= SPC_ABORTING;
               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:
               sc->sc_flags |= SPC_ABORTING;
               sc->sc_omess[0] = MSG_ABORT;
               n = 1;
               break;

       default:
               printf("%s: unexpected MESSAGE OUT; sending NOOP\n",
                   device_xname(sc->sc_dev));
               SPC_BREAK();
               sc->sc_omess[0] = MSG_NOOP;
               n = 1;
               break;
       }
       sc->sc_omp = &sc->sc_omess[n];

nextbyte:
       /* Send message bytes. */
       /* send TRANSFER command. */
       bus_space_write_1(iot, ioh, TCH, n >> 16);
       bus_space_write_1(iot, ioh, TCM, n >> 8);
       bus_space_write_1(iot, ioh, TCL, n);
       bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB);
#ifdef NEED_DREQ_ON_HARDWARE_XFER
       bus_space_write_1(iot, ioh, SCMD, SCMD_XFR);    /* XXX */
#else
       bus_space_write_1(iot, ioh, SCMD,
           SCMD_XFR | SCMD_PROG_XFR);
#endif
       for (;;) {
               if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0)
                       break;
               if (bus_space_read_1(iot, ioh, INTS) != 0)
                       goto out;
       }
       for (;;) {
#if 0
               for (;;) {
                       if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0)
                               break;
                       /* Wait for REQINIT.  XXX Need timeout. */
               }
#endif
               if (bus_space_read_1(iot, ioh, INTS) != 0) {
                       /*
                        * Target left MESSAGE OUT, possibly to reject
                        * our message.
                        *
                        * If this is the last message being sent, then we
                        * deassert ATN, since either the target is going to
                        * ignore this message, or it's going to ask for a
                        * retransmission via MESSAGE PARITY ERROR (in which
                        * case we reassert ATN anyway).
                        */
#if 0
                       if (sc->sc_msgpriq == 0)
                               bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN);
#endif
                       goto out;
               }

#if 0
               /* Clear ATN before last byte if this is the last message. */
               if (n == 1 && sc->sc_msgpriq == 0)
                       bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN);
#endif

               while ((bus_space_read_1(iot, ioh, SSTS) & SSTS_DREG_FULL) != 0)
                       DELAY(1);
               /* Send message byte. */
               bus_space_write_1(iot, ioh, DREG, *--sc->sc_omp);
               --n;
               /* Keep track of the last message we've sent any bytes of. */
               sc->sc_lastmsg = sc->sc_currmsg;
#if 0
               /* Wait for ACK to be negated.  XXX Need timeout. */
               while ((bus_space_read_1(iot, ioh, PSNS) & ACKI) != 0)
                       ;
#endif

               if (n == 0)
                       break;
       }

       /* We get here only if the entire message has been transmitted. */
       if (sc->sc_msgpriq != 0) {
               /* 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:
       /* Disable REQ/ACK protocol. */
       return;
}

/*
* spc_dataout_pio: perform a data transfer using the FIFO datapath in the spc
* Precondition: The SCSI bus should be in the DOUT phase, with REQ asserted
* and ACK deasserted (i.e. waiting for a data byte)
*
* This new revision has been optimized (I tried) to make the common case fast,
* and the rarer cases (as a result) somewhat more complex
*/
int
spc_dataout_pio(struct spc_softc *sc, uint8_t *p, int n)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;
       uint8_t intstat = 0;
       int out = 0;
#define DOUTAMOUNT 8            /* Full FIFO */

       SPC_TRACE(("spc_dataout_pio  "));
       /* send TRANSFER command. */
       bus_space_write_1(iot, ioh, TCH, n >> 16);
       bus_space_write_1(iot, ioh, TCM, n >> 8);
       bus_space_write_1(iot, ioh, TCL, n);
       bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB);
#ifdef NEED_DREQ_ON_HARDWARE_XFER
       bus_space_write_1(iot, ioh, SCMD, SCMD_XFR);    /* XXX */
#else
       bus_space_write_1(iot, ioh, SCMD,
           SCMD_XFR | SCMD_PROG_XFR);  /* XXX */
#endif
       for (;;) {
               if ((bus_space_read_1(iot, ioh, SSTS) & SSTS_BUSY) != 0)
                       break;
               if (bus_space_read_1(iot, ioh, INTS) != 0)
                       break;
       }

       /*
        * I have tried to make the main loop as tight as possible.  This
        * means that some of the code following the loop is a bit more
        * complex than otherwise.
        */
       while (n > 0) {
               int xfer;

               for (;;) {
                       intstat = bus_space_read_1(iot, ioh, INTS);
                       /* Wait till buffer is empty. */
                       if ((bus_space_read_1(iot, ioh, SSTS) &
                           SSTS_DREG_EMPTY) != 0)
                               break;
                       /* Break on interrupt. */
                       if (intstat != 0)
                               goto phasechange;
                       DELAY(1);
               }

               xfer = uimin(DOUTAMOUNT, n);

               SPC_MISC(("%d> ", xfer));

               n -= xfer;
               out += xfer;

               bus_space_write_multi_1(iot, ioh, DREG, p, xfer);
               p += xfer;
       }

       if (out == 0) {
               for (;;) {
                       if (bus_space_read_1(iot, ioh, INTS) != 0)
                               break;
                       DELAY(1);
               }
               SPC_MISC(("extra data  "));
       } else {
               /* See the bytes off chip */
               for (;;) {
                       /* Wait till buffer is empty. */
                       if ((bus_space_read_1(iot, ioh, SSTS) &
                           SSTS_DREG_EMPTY) != 0)
                               break;
                       intstat = bus_space_read_1(iot, ioh, INTS);
                       /* Break on interrupt. */
                       if (intstat != 0)
                               goto phasechange;
                       DELAY(1);
               }
       }

phasechange:
       /* Stop the FIFO data path. */

       if (intstat != 0) {
               /* Some sort of phase change. */
               int amount;

               amount = (bus_space_read_1(iot, ioh, TCH) << 16) |
                   (bus_space_read_1(iot, ioh, TCM) << 8) |
                   bus_space_read_1(iot, ioh, TCL);
               if (amount > 0) {
                       out -= amount;
                       SPC_MISC(("+%d ", amount));
               }
       }

       return out;
}

/*
* spc_datain_pio: perform data transfers using the FIFO datapath in the spc
* Precondition: The SCSI bus should be in the DIN phase, with REQ asserted
* and ACK deasserted (i.e. at least one byte is ready).
*
* For now, uses a pretty dumb algorithm, hangs around until all data has been
* transferred.  This, is OK for fast targets, but not so smart for slow
* targets which don't disconnect or for huge transfers.
*/
int
spc_datain_pio(struct spc_softc *sc, uint8_t *p, int n)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;
       int in = 0;
       uint8_t intstat, sstat;
#define DINAMOUNT 8             /* Full FIFO */

       SPC_TRACE(("spc_datain_pio  "));
       /* send TRANSFER command. */
       bus_space_write_1(iot, ioh, TCH, n >> 16);
       bus_space_write_1(iot, ioh, TCM, n >> 8);
       bus_space_write_1(iot, ioh, TCL, n);
       bus_space_write_1(iot, ioh, PCTL, sc->sc_phase | PCTL_BFINT_ENAB);
#ifdef NEED_DREQ_ON_HARDWARE_XFER
       bus_space_write_1(iot, ioh, SCMD, SCMD_XFR);    /* XXX */
#else
       bus_space_write_1(iot, ioh, SCMD,
           SCMD_XFR | SCMD_PROG_XFR);  /* XXX */
#endif

       /*
        * We leave this loop if one or more of the following is true:
        * a) phase != PH_DATAIN && FIFOs are empty
        * b) reset has occurred or busfree is detected.
        */
       intstat = 0;
       while (n > 0) {
               sstat = bus_space_read_1(iot, ioh, SSTS);
               if ((sstat & SSTS_DREG_FULL) != 0) {
                       n -= DINAMOUNT;
                       in += DINAMOUNT;
                       bus_space_read_multi_1(iot, ioh, DREG, p, DINAMOUNT);
                       p += DINAMOUNT;
               } else if ((sstat & SSTS_DREG_EMPTY) == 0) {
                       n--;
                       in++;
                       *p++ = bus_space_read_1(iot, ioh, DREG);
               } else {
                       if (intstat != 0)
                               goto phasechange;
                       intstat = bus_space_read_1(iot, ioh, INTS);
               }
       }

       /*
        * Some SCSI-devices are rude enough to transfer more data than what
        * was requested, e.g. 2048 bytes from a CD-ROM instead of the
        * requested 512.  Test for progress, i.e. real transfers.  If no real
        * transfers have been performed (n is probably already zero) and the
        * FIFO is not empty, waste some bytes....
        */
       if (in == 0) {
               for (;;) {
                       sstat = bus_space_read_1(iot, ioh, SSTS);
                       if ((sstat & SSTS_DREG_EMPTY) == 0) {
                               (void) bus_space_read_1(iot, ioh, DREG);
                       } else {
                               if (intstat != 0)
                                       goto phasechange;
                               intstat = bus_space_read_1(iot, ioh, INTS);
                       }
                       DELAY(1);
               }
               SPC_MISC(("extra data  "));
       }

phasechange:
       /* Stop the FIFO data path. */

       return in;
}

/*
* Catch an interrupt from the adaptor
*/
/*
* This is the workhorse routine of the driver.
* Deficiencies (for now):
* 1) always uses programmed I/O
*/
int
spc_intr(void *arg)
{
       struct spc_softc *sc = arg;
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;
       uint8_t ints;
       struct spc_acb *acb;
       struct scsipi_periph *periph;
       struct spc_tinfo *ti;
       int n;

       SPC_TRACE(("spc_intr  "));

       ints = bus_space_read_1(iot, ioh, INTS);
       if (ints == 0)
               return 0;

       /*
        * Disable interrupt.
        */
       bus_space_write_1(iot, ioh, SCTL,
           bus_space_read_1(iot, ioh, SCTL) & ~SCTL_INTR_ENAB);

       if (sc->sc_dma_done != NULL &&
           sc->sc_state == SPC_CONNECTED &&
           (sc->sc_flags & SPC_DOINGDMA) != 0 &&
           (sc->sc_phase == PH_DATAOUT || sc->sc_phase == PH_DATAIN)) {
               (*sc->sc_dma_done)(sc);
       }

loop:
       /*
        * Loop until transfer completion.
        */
       /*
        * First check for abnormal conditions, such as reset.
        */
       ints = bus_space_read_1(iot, ioh, INTS);
       SPC_MISC(("ints = 0x%x  ", ints));

       if ((ints & INTS_RST) != 0) {
               printf("%s: SCSI bus reset\n", device_xname(sc->sc_dev));
               goto reset;
       }

       /*
        * Check for less serious errors.
        */
       if ((bus_space_read_1(iot, ioh, SERR) & (SERR_SCSI_PAR|SERR_SPC_PAR))
           != 0) {
               printf("%s: SCSI bus parity error\n", device_xname(sc->sc_dev));
               if (sc->sc_prevphase == PH_MSGIN) {
                       sc->sc_flags |= SPC_DROP_MSGIN;
                       spc_sched_msgout(sc, SEND_PARITY_ERROR);
               } else
                       spc_sched_msgout(sc, SEND_INIT_DET_ERR);
       }

       /*
        * If we're not already busy doing something test for the following
        * conditions:
        * 1) We have been reselected by something
        * 2) We have selected something successfully
        * 3) Our selection process has timed out
        * 4) This is really a bus free interrupt just to get a new command
        *    going?
        * 5) Spurious interrupt?
        */
       switch (sc->sc_state) {
       case SPC_IDLE:
       case SPC_SELECTING:
               SPC_MISC(("ints:0x%02x ", ints));

               if ((ints & INTS_SEL) != 0) {
                       /*
                        * We don't currently support target mode.
                        */
                       printf("%s: target mode selected; going to BUS FREE\n",
                           device_xname(sc->sc_dev));

                       goto sched;
               } else if ((ints & INTS_RESEL) != 0) {
                       SPC_MISC(("reselected  "));

                       /*
                        * If we're trying to select a target ourselves,
                        * push our command back into the ready list.
                        */
                       if (sc->sc_state == SPC_SELECTING) {
                               SPC_MISC(("backoff selector  "));
                               SPC_ASSERT(sc->sc_nexus != NULL);
                               acb = sc->sc_nexus;
                               sc->sc_nexus = NULL;
                               TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
                       }

                       /* Save reselection ID. */
                       sc->sc_selid = bus_space_read_1(iot, ioh, TEMP);

                       sc->sc_state = SPC_RESELECTED;
               } else if ((ints & INTS_CMD_DONE) != 0) {
                       SPC_MISC(("selected  "));

                       /*
                        * We have selected a target. Things to do:
                        * a) Determine what message(s) to send.
                        * b) Verify that we're still selecting the target.
                        * c) Mark device as busy.
                        */
                       if (sc->sc_state != SPC_SELECTING) {
                               printf("%s: selection out while idle; "
                                   "resetting\n", device_xname(sc->sc_dev));
                               SPC_BREAK();
                               goto reset;
                       }
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;
                       periph = acb->xs->xs_periph;
                       ti = &sc->sc_tinfo[periph->periph_target];

                       sc->sc_msgpriq = SEND_IDENTIFY;
                       if (acb->flags & ACB_RESET)
                               sc->sc_msgpriq |= SEND_DEV_RESET;
                       else if (acb->flags & ACB_ABORT)
                               sc->sc_msgpriq |= SEND_ABORT;
                       else {
#if SPC_USE_SYNCHRONOUS
                               if ((ti->flags & DO_SYNC) != 0)
                                       sc->sc_msgpriq |= SEND_SDTR;
#endif
#if SPC_USE_WIDE
                               if ((ti->flags & DO_WIDE) != 0)
                                       sc->sc_msgpriq |= SEND_WDTR;
#endif
                       }

                       acb->flags |= ACB_NEXUS;
                       ti->lubusy |= (1 << periph->periph_lun);

                       /* Do an implicit RESTORE POINTERS. */
                       sc->sc_dp = acb->data_addr;
                       sc->sc_dleft = acb->data_length;
                       sc->sc_cp = (uint8_t *)&acb->scsipi_cmd;
                       sc->sc_cleft = acb->scsipi_cmd_length;

                       /* On our first connection, schedule a timeout. */
                       if ((acb->xs->xs_control & XS_CTL_POLL) == 0)
                               callout_reset(&acb->xs->xs_callout,
                                   mstohz(acb->timeout), spc_timeout, acb);

                       sc->sc_state = SPC_CONNECTED;
               } else if ((ints & INTS_TIMEOUT) != 0) {
                       SPC_MISC(("selection timeout  "));

                       if (sc->sc_state != SPC_SELECTING) {
                               printf("%s: selection timeout while idle; "
                                   "resetting\n", device_xname(sc->sc_dev));
                               SPC_BREAK();
                               goto reset;
                       }
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;

                       delay(250);

                       acb->xs->error = XS_SELTIMEOUT;
                       goto finish;
               } else {
                       if (sc->sc_state != SPC_IDLE) {
                               printf("%s: BUS FREE while not idle; "
                                   "state=%d\n",
                                   device_xname(sc->sc_dev), sc->sc_state);
                               SPC_BREAK();
                               goto out;
                       }

                       goto sched;
               }

               /*
                * Turn off selection stuff, and prepare to catch bus free
                * interrupts, parity errors, and phase changes.
                */

               sc->sc_flags = 0;
               sc->sc_prevphase = PH_INVALID;
               goto dophase;
       }

       if ((ints & INTS_DISCON) != 0) {
               /* We've gone to BUS FREE phase. */
               /* disable disconnect interrupt */
               bus_space_write_1(iot, ioh, PCTL,
                   bus_space_read_1(iot, ioh, PCTL) & ~PCTL_BFINT_ENAB);
               /* XXX reset interrupt */
               bus_space_write_1(iot, ioh, INTS, ints);

               switch (sc->sc_state) {
               case SPC_RESELECTED:
                       goto sched;

               case SPC_CONNECTED:
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;

#if SPC_USE_SYNCHRONOUS + SPC_USE_WIDE
                       if (sc->sc_prevphase == PH_MSGOUT) {
                               /*
                                * If the target went to BUS FREE phase during
                                * or immediately after sending a SDTR or WDTR
                                * message, disable negotiation.
                                */
                               periph = acb->xs->xs_periph;
                               ti = &sc->sc_tinfo[periph->periph_target];
                               switch (sc->sc_lastmsg) {
#if SPC_USE_SYNCHRONOUS
                               case SEND_SDTR:
                                       ti->flags &= ~DO_SYNC;
                                       ti->period = ti->offset = 0;
                                       break;
#endif
#if SPC_USE_WIDE
                               case SEND_WDTR:
                                       ti->flags &= ~DO_WIDE;
                                       ti->width = 0;
                                       break;
#endif
                               }
                       }
#endif

                       if ((sc->sc_flags & SPC_ABORTING) == 0) {
                               /*
                                * Section 5.1.1 of the SCSI 2 spec suggests
                                * issuing a REQUEST SENSE following an
                                * unexpected disconnect.  Some devices go into
                                * a contingent allegiance condition when
                                * disconnecting, and this is necessary to
                                * clean up their state.
                                */
                               printf("%s: unexpected disconnect; "
                                   "sending REQUEST SENSE\n",
                                   device_xname(sc->sc_dev));
                               SPC_BREAK();
                               acb->target_stat = SCSI_CHECK;
                               acb->xs->error = XS_NOERROR;
                               goto finish;
                       }

                       acb->xs->error = XS_DRIVER_STUFFUP;
                       goto finish;

               case SPC_DISCONNECT:
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;
                       TAILQ_INSERT_HEAD(&sc->nexus_list, acb, chain);
                       sc->sc_nexus = NULL;
                       goto sched;

               case SPC_CMDCOMPLETE:
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;
                       goto finish;
               }
       }
       else if ((ints & INTS_CMD_DONE) != 0 &&
           sc->sc_prevphase == PH_MSGIN &&
           sc->sc_state != SPC_CONNECTED)
               goto out;

dophase:
#if 0
       if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0) {
               /* Wait for REQINIT. */
               goto out;
       }
#else
       bus_space_write_1(iot, ioh, INTS, ints);
       ints = 0;
       while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0)
               delay(1);       /* need timeout XXX */
#endif

       /*
        * State transition.
        */
       sc->sc_phase = bus_space_read_1(iot, ioh, PSNS) & PH_MASK;
#if 0
       bus_space_write_1(iot, ioh, PCTL, sc->sc_phase);
#endif

       SPC_MISC(("phase=%d\n", sc->sc_phase));
       switch (sc->sc_phase) {
       case PH_MSGOUT:
               if (sc->sc_state != SPC_CONNECTED &&
                   sc->sc_state != SPC_RESELECTED)
                       break;
               spc_msgout(sc);
               sc->sc_prevphase = PH_MSGOUT;
               goto loop;

       case PH_MSGIN:
               if (sc->sc_state != SPC_CONNECTED &&
                   sc->sc_state != SPC_RESELECTED)
                       break;
               spc_msgin(sc);
               sc->sc_prevphase = PH_MSGIN;
               goto loop;

       case PH_CMD:
               if (sc->sc_state != SPC_CONNECTED)
                       break;
#if SPC_DEBUG
               if ((spc_debug & SPC_SHOWMISC) != 0) {
                       SPC_ASSERT(sc->sc_nexus != NULL);
                       acb = sc->sc_nexus;
                       printf("cmd=0x%02x+%d  ",
                           acb->scsipi_cmd.opcode, acb->scsipi_cmd_length - 1);
               }
#endif
               n = spc_dataout_pio(sc, sc->sc_cp, sc->sc_cleft);
               sc->sc_cp += n;
               sc->sc_cleft -= n;
               sc->sc_prevphase = PH_CMD;
               goto loop;

       case PH_DATAOUT:
               if (sc->sc_state != SPC_CONNECTED)
                       break;
               SPC_MISC(("dataout dleft=%zu  ", sc->sc_dleft));
               if (sc->sc_dma_start != NULL &&
                   sc->sc_dleft > SPC_MIN_DMA_LEN) {
                       (*sc->sc_dma_start)(sc, sc->sc_dp, sc->sc_dleft, 0);
                       sc->sc_prevphase = PH_DATAOUT;
                       goto out;
               }
               n = spc_dataout_pio(sc, sc->sc_dp, sc->sc_dleft);
               sc->sc_dp += n;
               sc->sc_dleft -= n;
               sc->sc_prevphase = PH_DATAOUT;
               goto loop;

       case PH_DATAIN:
               if (sc->sc_state != SPC_CONNECTED)
                       break;
               SPC_MISC(("datain  "));
               if (sc->sc_dma_start != NULL &&
                   sc->sc_dleft > SPC_MIN_DMA_LEN) {
                       (*sc->sc_dma_start)(sc, sc->sc_dp, sc->sc_dleft, 1);
                       sc->sc_prevphase = PH_DATAIN;
                       goto out;
               }
               n = spc_datain_pio(sc, sc->sc_dp, sc->sc_dleft);
               sc->sc_dp += n;
               sc->sc_dleft -= n;
               sc->sc_prevphase = PH_DATAIN;
               goto loop;

       case PH_STAT:
               if (sc->sc_state != SPC_CONNECTED)
                       break;
               SPC_ASSERT(sc->sc_nexus != NULL);
               acb = sc->sc_nexus;

               if ((bus_space_read_1(iot, ioh, PSNS) & PSNS_ATN) != 0)
                       bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ATN);
               bus_space_write_1(iot, ioh, PCTL, PCTL_BFINT_ENAB | PH_STAT);
               while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) == 0)
                       DELAY(1);       /* XXX needs timeout */
               acb->target_stat = bus_space_read_1(iot, ioh, TEMP);
               bus_space_write_1(iot, ioh, SCMD, SCMD_SET_ACK);
               while ((bus_space_read_1(iot, ioh, PSNS) & PSNS_REQ) != 0)
                       DELAY(1);       /* XXX needs timeout */
               bus_space_write_1(iot, ioh, SCMD, SCMD_RST_ACK);

               SPC_MISC(("target_stat=0x%02x  ", acb->target_stat));
               sc->sc_prevphase = PH_STAT;
               goto loop;
       }

       printf("%s: unexpected bus phase; resetting\n",
           device_xname(sc->sc_dev));
       SPC_BREAK();
reset:
       spc_init(sc, 1);
       return 1;

finish:
       callout_stop(&acb->xs->xs_callout);
       bus_space_write_1(iot, ioh, INTS, ints);
       ints = 0;
       spc_done(sc, acb);
       goto out;

sched:
       sc->sc_state = SPC_IDLE;
       spc_sched(sc);
       goto out;

out:
       if (ints)
               bus_space_write_1(iot, ioh, INTS, ints);
       bus_space_write_1(iot, ioh, SCTL,
           bus_space_read_1(iot, ioh, SCTL) | SCTL_INTR_ENAB);
       return 1;
}

void
spc_abort(struct spc_softc *sc, struct spc_acb *acb)
{

       /* 2 secs for the abort */
       acb->timeout = SPC_ABORT_TIMEOUT;
       acb->flags |= ACB_ABORT;

       if (acb == sc->sc_nexus) {
               /*
                * If we're still selecting, the message will be scheduled
                * after selection is complete.
                */
               if (sc->sc_state == SPC_CONNECTED)
                       spc_sched_msgout(sc, SEND_ABORT);
       } else {
               spc_dequeue(sc, acb);
               TAILQ_INSERT_HEAD(&sc->ready_list, acb, chain);
               if (sc->sc_state == SPC_IDLE)
                       spc_sched(sc);
       }
}

void
spc_timeout(void *arg)
{
       struct spc_acb *acb = arg;
       struct scsipi_xfer *xs = acb->xs;
       struct scsipi_periph *periph = xs->xs_periph;
       struct spc_softc *sc;
       int s;

       sc = device_private(periph->periph_channel->chan_adapter->adapt_dev);
       scsipi_printaddr(periph);
       printf("timed out");

       s = splbio();

       if (acb->flags & ACB_ABORT) {
               /* abort timed out */
               printf(" AGAIN\n");
               /* XXX Must reset! */
       } else {
               /* abort the operation that has timed out */
               printf("\n");
               acb->xs->error = XS_TIMEOUT;
               spc_abort(sc, acb);
       }

       splx(s);
}

#ifdef SPC_DEBUG
/*
* The following functions are mostly used for debugging purposes, either
* directly called from the driver or from the kernel debugger.
*/

void
spc_show_scsi_cmd(struct spc_acb *acb)
{
       uint8_t  *b = (uint8_t *)&acb->scsipi_cmd;
       int i;

       scsipi_printaddr(acb->xs->xs_periph);
       if ((acb->xs->xs_control & XS_CTL_RESET) == 0) {
               for (i = 0; i < acb->scsipi_cmd_length; i++) {
                       if (i)
                               printf(",");
                       printf("%x", b[i]);
               }
               printf("\n");
       } else
               printf("RESET\n");
}

void
spc_print_acb(struct spc_acb *acb)
{

       printf("acb@%p xs=%p flags=%x", acb, acb->xs, acb->flags);
       printf(" dp=%p dleft=%d target_stat=%x\n",
           acb->data_addr, acb->data_length, acb->target_stat);
       spc_show_scsi_cmd(acb);
}

void
spc_print_active_acb(void)
{
       struct spc_acb *acb;
       struct spc_softc *sc = device_lookup_private(&spc_cd, 0); /* XXX */

       printf("ready list:\n");
       TAILQ_FOREACH(acb, &sc->ready_list, chain)
               spc_print_acb(acb);
       printf("nexus:\n");
       if (sc->sc_nexus != NULL)
               spc_print_acb(sc->sc_nexus);
       printf("nexus list:\n");
       TAILQ_FOREACH(acb, &sc->nexus_list, chain)
               spc_print_acb(acb);
}

void
spc_dump89352(struct spc_softc *sc)
{
       bus_space_tag_t iot = sc->sc_iot;
       bus_space_handle_t ioh = sc->sc_ioh;

       printf("mb89352: BDID=%x SCTL=%x SCMD=%x TMOD=%x\n",
           bus_space_read_1(iot, ioh, BDID),
           bus_space_read_1(iot, ioh, SCTL),
           bus_space_read_1(iot, ioh, SCMD),
           bus_space_read_1(iot, ioh, TMOD));
       printf("         INTS=%x PSNS=%x SSTS=%x SERR=%x PCTL=%x\n",
           bus_space_read_1(iot, ioh, INTS),
           bus_space_read_1(iot, ioh, PSNS),
           bus_space_read_1(iot, ioh, SSTS),
           bus_space_read_1(iot, ioh, SERR),
           bus_space_read_1(iot, ioh, PCTL));
       printf("         MBC=%x DREG=%x TEMP=%x TCH=%x TCM=%x\n",
           bus_space_read_1(iot, ioh, MBC),
#if 0
           bus_space_read_1(iot, ioh, DREG),
#else
           0,
#endif
           bus_space_read_1(iot, ioh, TEMP),
           bus_space_read_1(iot, ioh, TCH),
           bus_space_read_1(iot, ioh, TCM));
       printf("         TCL=%x EXBF=%x\n",
           bus_space_read_1(iot, ioh, TCL),
           bus_space_read_1(iot, ioh, EXBF));
}

void
spc_dump_driver(struct spc_softc *sc)
{
       struct spc_tinfo *ti;
       int i;

       printf("nexus=%p prevphase=%x\n", sc->sc_nexus, sc->sc_prevphase);
       printf("state=%x msgin=%x msgpriq=%x msgoutq=%x lastmsg=%x "
           "currmsg=%x\n", sc->sc_state, sc->sc_imess[0],
           sc->sc_msgpriq, sc->sc_msgoutq, sc->sc_lastmsg, sc->sc_currmsg);
       for (i = 0; i < 7; i++) {
               ti = &sc->sc_tinfo[i];
               printf("tinfo%d: %d cmds %d disconnects %d timeouts",
                   i, ti->cmds, ti->dconns, ti->touts);
               printf(" %d senses flags=%x\n", ti->senses, ti->flags);
       }
}
#endif