/*      $NetBSD: ncr5380.c,v 1.79 2023/08/01 21:26:27 andvar Exp $      */

/*
 * Copyright (c) 1995 Leo Weppelman.
 * 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.
 *
 * 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.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ncr5380.c,v 1.79 2023/08/01 21:26:27 andvar Exp $");

/*
 * Bit mask of targets you want debugging to be shown
 */
uint8_t dbg_target_mask = 0x7f;

/*
 * Set bit for target when parity checking must be disabled.
 * My (LWP) Maxtor 7245S  seems to generate parity errors on about 50%
 * of all transfers while the data is correct!?
 */
uint8_t ncr5380_no_parchk = 0xff;

#ifdef  AUTO_SENSE

/*
 * Bit masks of targets that accept linked commands, and those
 * that we've already checked out.  Some devices will report
 * that they support linked commands when they have problems with
 * them.  By default, don't try them on any devices.  Allow an
 * option to override.
 */
#ifdef  TRY_SCSI_LINKED_COMMANDS
uint8_t ncr_test_link = ((~TRY_SCSI_LINKED_COMMANDS) & 0x7f);
#else
uint8_t ncr_test_link = 0x7f;
#endif
uint8_t ncr_will_link = 0x00;

#endif  /* AUTO_SENSE */

/*
 * This is the default sense-command we send.
 */
static uint8_t sense_cmd[] = {
        SCSI_REQUEST_SENSE, 0, 0, 0, sizeof(struct scsi_sense_data), 0
};

/*
 * True if the main co-routine is running
 */
static volatile int     main_running = 0;

/*
 * Mask of targets selected
 */
static uint8_t  busy;

static void     ncr5380_minphys(struct buf *bp);
static void     ncr5380_scsi_request(struct scsipi_channel *,
                    scsipi_adapter_req_t, void *);
static void     ncr5380_show_scsi_cmd(struct scsipi_xfer *xs);

static SC_REQ   req_queue[NREQ];
static SC_REQ   *free_head = NULL;      /* Free request structures      */


/*
 * Inline functions:
 */

/*
 * Wait for request-line to become active. When it doesn't return 0.
 * Otherwise return != 0.
 * The timeouts in the 'wait_req_*' functions are arbitrary and rather
 * large. In 99% of the invocations nearly no timeout is needed but in
 * some cases (especially when using my tapedrive, a Tandberg 3600) the
 * device is busy internally and the first SCSI-phase will be delayed.
 */
static inline int
wait_req_true(void)
{
        int timeout = 250000;

        while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) == 0 && --timeout)
                delay(1);
        return GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ;
}

/*
 * Wait for request-line to become inactive. When it doesn't return 0.
 * Otherwise return != 0.
 */
static inline int
wait_req_false(void)
{
        int timeout = 250000;

        while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) && --timeout)
                delay(1);
        return (GET_5380_REG(NCR5380_IDSTAT) & SC_S_REQ) == 0;
}

static inline void
ack_message(void)
{

        SET_5380_REG(NCR5380_ICOM, 0);
}

static inline void
nack_message(SC_REQ *reqp, u_char msg)
{

        SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
        reqp->msgout = msg;
}

static inline void
finish_req(SC_REQ *reqp)
{
        int                     sps;
        struct scsipi_xfer      *xs = reqp->xs;

#ifdef REAL_DMA
        /*
         * If we bounced, free the bounce buffer
         */
        if (reqp->dr_flag & DRIVER_BOUNCING)
                free_bounceb(reqp->bounceb);
#endif /* REAL_DMA */
#ifdef DBG_REQ
        if (dbg_target_mask & (1 << reqp->targ_id))
                show_request(reqp, "DONE");
#endif
#ifdef DBG_ERR_RET
        if ((dbg_target_mask & (1 << reqp->targ_id)) && (reqp->xs->error != 0))
                show_request(reqp, "ERR_RET");
#endif
        /*
         * Return request to free-q
         */
        sps = splbio();
        reqp->next = free_head;
        free_head  = reqp;
        splx(sps);

        if ((reqp->dr_flag & DRIVER_LINKCHK) == 0)
                scsipi_done(xs);
}

/*
 * Auto config stuff....
 */
static void     ncr_attach(device_t, device_t, void *);
static int      ncr_match(device_t, cfdata_t, void *);

/*
 * Tricks to make driver-name configurable
 */
#define CFNAME(n)       __CONCAT(n,_cd)
#define CANAME(n)       __CONCAT(n,_ca)
#define CFSTRING(n)     __STRING(n)
#define CFDRNAME(n)     n

CFATTACH_DECL_NEW(CFDRNAME(DRNAME), sizeof(struct ncr_softc),
    ncr_match, ncr_attach, NULL, NULL);

extern struct cfdriver CFNAME(DRNAME);

static int
ncr_match(device_t parent, cfdata_t cf, void *aux)
{

        return machine_match(parent, cf, aux, &CFNAME(DRNAME));
}

static void
ncr_attach(device_t parent, device_t self, void *aux)
{
        struct ncr_softc        *sc;
        int                     i;

        sc = device_private(self);
        sc->sc_dev = self;

        sc->sc_adapter.adapt_dev = self;
        sc->sc_adapter.adapt_openings = 7;
        sc->sc_adapter.adapt_max_periph = 1;
        sc->sc_adapter.adapt_ioctl = NULL;
        sc->sc_adapter.adapt_minphys = ncr5380_minphys;
        sc->sc_adapter.adapt_request = ncr5380_scsi_request;

        sc->sc_channel.chan_adapter = &sc->sc_adapter;
        sc->sc_channel.chan_bustype = &scsi_bustype;
        sc->sc_channel.chan_channel = 0;
        sc->sc_channel.chan_ntargets = 8;
        sc->sc_channel.chan_nluns = 8;
        sc->sc_channel.chan_id = 7;

        /*
         * bitmasks
         */
        sc->sc_noselatn = 0;
        sc->sc_selected = 0;

        /*
         * Initialize machine-type specific things...
         */
        scsi_mach_init(sc);
        printf("\n");

        /*
         * Initialize request queue freelist.
         */
        for (i = 0; i < NREQ; i++) {
                req_queue[i].next = free_head;
                free_head = &req_queue[i];
        }

        /*
         * Initialize the host adapter
         */
        scsi_idisable();
        ENABLE_NCR5380(sc);
        SET_5380_REG(NCR5380_ICOM, 0);
        SET_5380_REG(NCR5380_MODE, IMODE_BASE);
        SET_5380_REG(NCR5380_TCOM, 0);
        SET_5380_REG(NCR5380_IDSTAT, 0);
        scsi_ienable();

        /*
         * attach all scsi units on us
         */
        config_found(self, &sc->sc_channel, scsiprint, CFARGS_NONE);
}

/*
 * End of auto config stuff....
 */

/*
 * Carry out a request from the high level driver.
 */
static void
ncr5380_scsi_request(struct scsipi_channel *chan, scsipi_adapter_req_t req,
    void *arg)
{
        struct scsipi_xfer *xs;
        struct ncr_softc *sc;
        int     sps;
        SC_REQ  *reqp, *link, *tmp;
        int     flags;

        sc = device_private(chan->chan_adapter->adapt_dev);

        switch (req) {
        case ADAPTER_REQ_RUN_XFER:
                xs = arg;

                /*
                 * We do not queue RESET commands
                 */
                flags = xs->xs_control;
                if (flags & XS_CTL_RESET) {
                        scsi_reset_verbose(sc, "Got reset-command");
                        scsipi_done(xs);
                        return;
                }

                /*
                 * Get a request block
                 */
                sps = splbio();
                if ((reqp = free_head) == 0) {
                        xs->error = XS_RESOURCE_SHORTAGE;
                        scsipi_done(xs);
                        splx(sps);
                        return;
                }
                free_head  = reqp->next;
                reqp->next = NULL;
                splx(sps);

                /*
                 * Initialize our private fields
                 */
                reqp->dr_flag   = (flags & XS_CTL_POLL) ? DRIVER_NOINT : 0;
                reqp->phase     = NR_PHASE;
                reqp->msgout    = MSG_NOOP;
                reqp->status    = SCSGOOD;
                reqp->message   = 0xff;
                reqp->link      = NULL;
                reqp->xs        = xs;
                reqp->targ_id   = xs->xs_periph->periph_target;
                reqp->targ_lun  = xs->xs_periph->periph_lun;
                reqp->xdata_ptr = (u_char*)xs->data;
                reqp->xdata_len = xs->datalen;
                memcpy(&reqp->xcmd, xs->cmd, xs->cmdlen);
                reqp->xcmd_len = xs->cmdlen;
                reqp->xcmd.bytes[0] |= reqp->targ_lun << 5;

#ifdef REAL_DMA
                /*
                 * Check if DMA can be used on this request
                 */
                if (scsi_dmaok(reqp))
                        reqp->dr_flag |= DRIVER_DMAOK;
#endif /* REAL_DMA */

                /*
                 * Insert the command into the issue queue. Note that
                 * 'REQUEST SENSE' commands are inserted at the head of the
                 * queue since any command will clear the existing contingent
                 * allegience condition and the sense data is only valid while
                 * the condition exists. When possible, link the command to a
                 * previous command to the same target. This is not very
                 * sensible when AUTO_SENSE is not defined! Interrupts are
                 * disabled while we are fiddling with the issue-queue.
                 */
                sps = splbio();
                link = NULL;
                if ((issue_q == NULL) ||
                    (reqp->xcmd.opcode == SCSI_REQUEST_SENSE)) {
                        reqp->next = issue_q;
                        issue_q    = reqp;
                } else {
                        tmp  = issue_q;
                        do {
                                if (!link && (tmp->targ_id == reqp->targ_id) &&
                                    !tmp->link)
                                        link = tmp;
                        } while (tmp->next && (tmp = tmp->next));
                        tmp->next = reqp;
#ifdef AUTO_SENSE
                        if (link && (ncr_will_link & (1<<reqp->targ_id))) {
                                link->link = reqp;
                                link->xcmd.bytes[link->xs->cmdlen-2] |= 1;
                        }
#endif
        }
#ifdef AUTO_SENSE
                /*
                 * If we haven't already, check the target for link support.
                 * Do this by prefixing the current command with a dummy
                 * Request_Sense command, link the dummy to the current
                 * command, and insert the dummy command at the head of the
                 * issue queue.  Set the DRIVER_LINKCHK flag so that we'll
                 * ignore the results of the dummy command, since we only
                 * care about whether it was accepted or not.
                 */
                if (!link && (ncr_test_link & (1 << reqp->targ_id)) == 0 &&
                    (tmp = free_head) && (reqp->dr_flag & DRIVER_NOINT) == 0) {
                        free_head = tmp->next;
                        tmp->dr_flag = (reqp->dr_flag & ~DRIVER_DMAOK) |
                            DRIVER_LINKCHK;
                        tmp->phase = NR_PHASE;
                        tmp->msgout = MSG_NOOP;
                        tmp->status = SCSGOOD;
                        tmp->xs = reqp->xs;
                        tmp->targ_id = reqp->targ_id;
                        tmp->targ_lun = reqp->targ_lun;
                        memcpy(&tmp->xcmd, sense_cmd, sizeof(sense_cmd));
                        tmp->xcmd_len = sizeof(sense_cmd);
                        tmp->xdata_ptr = (u_char *)&tmp->xs->sense.scsi_sense;
                        tmp->xdata_len = sizeof(tmp->xs->sense.scsi_sense);
                        ncr_test_link |= 1<<tmp->targ_id;
                        tmp->link = reqp;
                        tmp->xcmd.bytes[sizeof(sense_cmd)-2] |= 1;
                        tmp->next = issue_q;
                        issue_q = tmp;
#ifdef DBG_REQ
                        if (dbg_target_mask & (1 << tmp->targ_id))
                                show_request(tmp, "LINKCHK");
#endif
                }
#endif
                splx(sps);

#ifdef DBG_REQ
                if (dbg_target_mask & (1 << reqp->targ_id))
                        show_request(reqp,
                            (reqp->xcmd.opcode == SCSI_REQUEST_SENSE) ?
                            "HEAD":"TAIL");
#endif

                run_main(sc);
                return;

        case ADAPTER_REQ_GROW_RESOURCES:
                /* XXX Not supported. */
                return;

        case ADAPTER_REQ_SET_XFER_MODE:
                /* XXX Not supported. */
                return;
        }
}

static void
ncr5380_minphys(struct buf *bp)
{

        if (bp->b_bcount > MIN_PHYS)
                bp->b_bcount = MIN_PHYS;
        minphys(bp);
}
#undef MIN_PHYS

static void
ncr5380_show_scsi_cmd(struct scsipi_xfer *xs)
{
        uint8_t *b = (uint8_t *)xs->cmd;
        int     i  = 0;

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

/*
 * The body of the driver.
 */
static void
scsi_main(struct ncr_softc *sc)
{
        SC_REQ  *req, *prev;
        int     itype;
        int     sps;

        /*
         * While running in the driver SCSI-interrupts are disabled.
         */
        scsi_idisable();
        ENABLE_NCR5380(sc);

        PID("scsi_main1");
        for (;;) {
                sps = splbio();
                if (!connected) {
                        /*
                         * Check if it is fair keep any exclusive access to
                         * DMA claimed. If not, stop queueing new jobs so
                         * the discon_q will be eventually drained and DMA
                         * can be given up.
                         */
                        if (!fair_to_keep_dma())
                                goto main_exit;

                        /*
                         * Search through the issue-queue for a command
                         * destined for a target that isn't busy.
                         */
                        prev = NULL;
                        for (req=issue_q; req != NULL;
                            prev = req, req = req->next) {
                                if ((busy & (1 << req->targ_id)) == 0) {
                                        /*
                                         * Found one, remove it from
                                         * the issue queue.
                                         */
                                        if (prev == NULL)
                                                issue_q = req->next;
                                        else
                                                prev->next = req->next;
                                        req->next = NULL;
                                        break;
                                }
                        }

                        /*
                         * When a request has just ended, we get here
                         * before an other device detects that
                         * the bus is free and that it can reconnect.
                         * The problem is that when this happens,
                         * we always baffle the device because our
                         * (initiator) id is higher.  This can cause
                         * a sort of starvation on slow devices.
                         * So we check for a pending reselection here.
                         * Note that 'connected' will be non-null
                         * if the reselection succeeds.
                         */
                        if ((GET_5380_REG(NCR5380_IDSTAT) & (SC_S_SEL|SC_S_IO))
                            == (SC_S_SEL|SC_S_IO)){
                                if (req != NULL) {
                                        req->next = issue_q;
                                        issue_q = req;
                                }
                                splx(sps);

                                reselect(sc);
                                scsi_clr_ipend();
                                goto connected;
                        }

                        /*
                         * The host is not connected and there is no request
                         * pending, exit.
                         */
                        if (req == NULL) {
                                PID("scsi_main2");
                                goto main_exit;
                        }

                        /*
                         * Re-enable interrupts before handling the request.
                         */
                        splx(sps);

#ifdef DBG_REQ
                        if (dbg_target_mask & (1 << req->targ_id))
                                show_request(req, "TARGET");
#endif
                        /*
                         * We found a request. Try to connect to the target.
                         * If the initiator fails arbitration,
                         * the command is put back in the issue queue.
                         */
                        if (scsi_select(req, 0)) {
                                sps = splbio();
                                req->next = issue_q;
                                issue_q = req;
                                splx(sps);
#ifdef DBG_REQ
                                if (dbg_target_mask & (1 << req->targ_id))
                                        ncr_tprint(req, "Select failed\n");
#endif
                        }
                } else
                        splx(sps);
connected:
                if (connected) {
                        /*
                         * If the host is currently connected but
                         * a 'real-DMA' transfer is in progress,
                         * the 'end-of-DMA' interrupt restarts main.
                         * So quit.
                         */
                        sps = splbio();
                        if (connected &&
                            (connected->dr_flag & DRIVER_IN_DMA)) {
                                PID("scsi_main3");
                                goto main_exit;
                        }
                        splx(sps);

                        /*
                         * Let the target guide us through the bus-phases
                         */
                        while (information_transfer(sc) == -1)
                                continue;
                }
        }
        /* NEVER TO REACH HERE */
        show_phase(NULL, 0);    /* XXX: Get rid of not used warning */
        panic("ncr5380-SCSI: not designed to come here");

main_exit:
        /*
         * We enter here with interrupts disabled. We are about to exit main
         * so interrupts should be re-enabled. Because interrupts are edge
         * triggered, we could already have missed the interrupt. Therefore
         * we check the IRQ-line here and re-enter when we really missed a
         * valid interrupt.
         */
        PID("scsi_main4");
        scsi_ienable();

        /*
         * If we're not currently connected, enable reselection
         * interrupts.
         */
        if (!connected)
                SET_5380_REG(NCR5380_IDSTAT, SC_HOST_ID);

        if (scsi_ipending()) {
                if ((itype = check_intr(sc)) != INTR_SPURIOUS) {
                        scsi_idisable();
                        scsi_clr_ipend();
                        splx(sps);

                        if (itype == INTR_RESEL)
                                reselect(sc);
                        else {
#ifdef REAL_DMA
                                dma_ready();
#else
                                if (pdma_ready())
                                        goto connected;
                                panic("Got DMA interrupt without DMA");
#endif
                        }
                        goto connected;
                }
        }
        reconsider_dma();
        main_running = 0;
        splx(sps);
        PID("scsi_main5");
}

#ifdef REAL_DMA
/*
 * The SCSI-DMA interrupt.
 * This interrupt can only be triggered when running in non-polled DMA
 * mode. When DMA is not active, it will be silently ignored, it is usually
 * to late because the EOP interrupt of the controller happens just a tiny
 * bit earlier. It might become useful when scatter/gather is implemented,
 * because in that case only part of the DATAIN/DATAOUT transfer is taken
 * out of a single buffer.
 */
static void
ncr_dma_intr(struct ncr_softc *sc)
{
        SC_REQ  *reqp;
        int     dma_done;

        PID("ncr_dma_intr");
        if ((reqp = connected) && (reqp->dr_flag & DRIVER_IN_DMA)) {
                scsi_idisable();
                if ((dma_done = dma_ready()) == 0) {
                        transfer_dma(reqp, reqp->phase, 0);
                        return;
                }
                run_main(sc);
        }
}
#endif /* REAL_DMA */

/*
 * The SCSI-controller interrupt. This interrupt occurs on reselections and
 * at the end of non-polled DMA-interrupts. It is assumed to be called from
 * the machine-dependent hardware interrupt.
 */
static void
ncr_ctrl_intr(struct ncr_softc *sc)
{
        int itype;

        if (main_running)
                return; /* scsi_main() should handle this one */

        while (scsi_ipending()) {
                scsi_idisable();
                if ((itype = check_intr(sc)) != INTR_SPURIOUS) {
                        if (itype == INTR_RESEL)
                                reselect(sc);
                        else {
#ifdef REAL_DMA
                                int dma_done;
                                if ((dma_done = dma_ready()) == 0) {
                                        transfer_dma(connected,
                                            connected->phase, 0);
                                        return;
                                }
#else
                                if (pdma_ready())
                                        return;
                                panic("Got DMA interrupt without DMA");
#endif
                        }
                        scsi_clr_ipend();
                }
                run_main(sc);
                return;
        }
        PID("ncr_ctrl_intr1");
}

/*
 * Initiate a connection path between the host and the target. The function
 * first goes into arbitration for the SCSI-bus. When this succeeds, the target
 * is selected and an 'IDENTIFY' message is send.
 * Returns -1 when the arbitration failed. Otherwise 0 is returned. When
 * the target does not respond (to either selection or 'MESSAGE OUT') the
 * 'done' function is executed.
 * The result code given by the driver can be influenced by setting 'code'
 * to a non-zero value. This is the case when 'select' is called by abort.
 */
static int
scsi_select(SC_REQ *reqp, int code)
{
        uint8_t                 tmp[1];
        uint8_t                 phase;
        u_long                  cnt;
        int                     sps;
        uint8_t                 atn_flag;
        uint8_t                 targ_bit;
        struct ncr_softc        *sc;

        sc = device_private(
            reqp->xs->xs_periph->periph_channel->chan_adapter->adapt_dev);
        DBG_SELPRINT ("Starting arbitration\n", 0);
        PID("scsi_select1");

        sps = splbio();

        /*
         * Prevent a race condition here. If a reselection interrupt occurred
         * between the decision to pick a new request and the call to select,
         * we abort the selection.
         * Interrupts are lowered when the 5380 is setup to arbitrate for the
         * bus.
         */
        if (connected) {
                splx(sps);
                PID("scsi_select2");
                return -1;
        }

        /*
         * Set phase bits to 0, otherwise the 5380 won't drive the bus during
         * selection.
         */
        SET_5380_REG(NCR5380_TCOM, 0);
        SET_5380_REG(NCR5380_ICOM, 0);

        /*
         * Arbitrate for the bus.
         */
        SET_5380_REG(NCR5380_DATA, SC_HOST_ID);
        SET_5380_REG(NCR5380_MODE, SC_ARBIT);

        splx(sps);

        cnt = 10;
        while ((GET_5380_REG(NCR5380_ICOM) & SC_AIP) == 0 && --cnt)
                delay(1);

        if ((GET_5380_REG(NCR5380_ICOM) & SC_AIP) == 0) {
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);
                DBG_SELPRINT ("Arbitration lost, bus not free\n",0);
                PID("scsi_select3");
                return -1;
        }

        /* The arbitration delay is 2.2 usecs */
        delay(3);

        /*
         * Check the result of the arbitration. If we failed, return -1.
         */
        if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);
                PID("scsi_select4");
                return -1;
        }

        /*
         * The spec requires that we should read the data register to
         * check for higher id's and check the SC_LA again.
         */
        tmp[0] = GET_5380_REG(NCR5380_DATA);
        if (tmp[0] & ~((SC_HOST_ID << 1) - 1)) {
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);
                DBG_SELPRINT ("Arbitration lost, higher id present\n",0);
                PID("scsi_select5");
                return -1;
        }
        if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);
                DBG_SELPRINT ("Arbitration lost,deassert SC_ARBIT\n",0);
                PID("scsi_select6");
                return -1;
        }
        SET_5380_REG(NCR5380_ICOM, SC_A_SEL | SC_A_BSY);
        if (GET_5380_REG(NCR5380_ICOM) & SC_LA) {
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);
                DBG_SELPRINT ("Arbitration lost, deassert SC_A_SEL\n", 0);
                PID("scsi_select7");
                return -1;
        }
        /* Bus settle delay + Bus clear delay = 1.2 usecs */
        delay(2);
        DBG_SELPRINT ("Arbitration complete\n", 0);

        /*
         * Now that we won the arbitration, start the selection.
         */
        targ_bit = 1 << reqp->targ_id;
        SET_5380_REG(NCR5380_DATA, SC_HOST_ID | targ_bit);

        if (sc->sc_noselatn & targ_bit)
                atn_flag = 0;
        else
                atn_flag = SC_A_ATN;

        /*
         * Raise ATN while SEL is true before BSY goes false from arbitration,
         * since this is the only way to guarantee that we'll get a MESSAGE OUT
         * phase immediately after the selection.
         */
        SET_5380_REG(NCR5380_ICOM, SC_A_BSY | SC_A_SEL | atn_flag | SC_ADTB);
        SET_5380_REG(NCR5380_MODE, IMODE_BASE);

        /*
         * Turn off reselection interrupts
         */
        SET_5380_REG(NCR5380_IDSTAT, 0);

        /*
         * Reset BSY. The delay following it, surpresses a glitch in the
         * 5380 which causes us to see our own BSY signal instead of that of
         * the target.
         */
        SET_5380_REG(NCR5380_ICOM, SC_A_SEL | atn_flag | SC_ADTB);
        delay(1);

        /*
         * Wait for the target to react, the specs call for a timeout of
         * 250 ms.
         */
        cnt = 25000;
        while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0 && --cnt)
                delay(10);

        if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
                /*
                 * There is no reaction from the target, start the selection
                 * timeout procedure. We release the databus but keep SEL
                 * 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.
                 */
                SET_5380_REG(NCR5380_ICOM, SC_A_SEL | atn_flag);
                delay(201);
                if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
                        SET_5380_REG(NCR5380_ICOM, 0);
                        reqp->xs->error      = code ? code : XS_SELTIMEOUT;
                        DBG_SELPRINT ("Target %d not responding to sel\n",
                                                                reqp->targ_id);
                        if (reqp->dr_flag & DRIVER_LINKCHK)
                                ncr_test_link &= ~(1<<reqp->targ_id);
                        finish_req(reqp);
                        PID("scsi_select8");
                        return 0;
                }
        }
        SET_5380_REG(NCR5380_ICOM, atn_flag);

        DBG_SELPRINT ("Target %d responding to select.\n", reqp->targ_id);

        /*
         * The SCSI-interrupts are disabled while a request is being handled.
         */
        scsi_idisable();

        /*
         * If we did not request ATN, then don't try to send IDENTIFY.
         */
        if (atn_flag == 0) {
                reqp->phase = PH_CMD;
                goto identify_failed;
        }

        /*
         * Here we prepare to send an 'IDENTIFY' message.
         * Allow disconnect only when interrupts are allowed.
         */
        tmp[0] = MSG_IDENTIFY(reqp->targ_lun,
            (reqp->dr_flag & DRIVER_NOINT) ? 0 : 1);
        cnt    = 1;
        phase  = PH_MSGOUT;

        /*
         * Since we followed the SCSI-spec and raised ATN while SEL was true
         * but before BSY was false during the selection, a 'MESSAGE OUT'
         * phase should follow.  Unfortunately, this does not happen on
         * all targets (Asante ethernet devices, for example), so we must
         * check the actual mode if the message transfer fails--if the
         * new phase is PH_CMD and has never been successfully selected
         * w/ATN in the past, then we assume that it is an old device
         * that doesn't support select w/ATN.
         */
        if (transfer_pio(&phase, tmp, &cnt, 0) || cnt) {

                if ((phase == PH_CMD) && (sc->sc_selected & targ_bit) == 0) {
                        DBG_SELPRINT("Target %d: not responding to ATN.\n",
                            reqp->targ_id);
                        sc->sc_noselatn |= targ_bit;
                        reqp->phase = PH_CMD;
                        goto identify_failed;
                }

                DBG_SELPRINT("Target %d: failed to send identify\n",
                    reqp->targ_id);
                /*
                 * Try to disconnect from the target.  We cannot leave
                 * it just hanging here.
                 */
                if (!reach_msg_out(sc, sizeof(struct scsipi_generic))) {
                        u_long  len   = 1;
                        uint8_t phse  = PH_MSGOUT;
                        uint8_t msg   = MSG_ABORT;

                        transfer_pio(&phse, &msg, &len, 0);
                } else
                        scsi_reset_verbose(sc,
                            "Connected to unidentified target");

                SET_5380_REG(NCR5380_ICOM, 0);
                reqp->xs->error = code ? code : XS_DRIVER_STUFFUP;
                finish_req(reqp);
                PID("scsi_select9");
                return 0;
        }
        reqp->phase = PH_MSGOUT;

identify_failed:
        sc->sc_selected |= targ_bit;

#ifdef notyet /* LWP: Do we need timeouts in the driver? */
        /*
         * Command is connected, start timer ticking.
         */
        ccb_p->xtimeout = ccb_p->timeout + Lbolt;
#endif

        connected  = reqp;
        busy      |= targ_bit;
        PID("scsi_select10");
        return 0;
}

/*
 * Return codes:
 *       0: Job has finished or disconnected, find something else
 *      -1: keep on calling information_transfer() from scsi_main()
 */
static int
information_transfer(struct ncr_softc *sc)
{
        SC_REQ  *reqp = connected;
        uint8_t tmp, phase;
        u_long  len;

        PID("info_transf1");
        /*
         * Clear pending interrupts from 5380-chip.
         */
        scsi_clr_ipend();

        /*
         * The SCSI-spec requires BSY to be true while connected to a target,
         * loosing it means we lost the target...
         * Also REQ needs to be asserted here to indicate that the bus-phase
         * is valid. When the target does not supply REQ within a 'reasonable'
         * amount of time, it's probably lost in its own maze of twisting
         * passages, we have to reset the bus to free it.
         */
        if (GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY)
                wait_req_true();
        tmp = GET_5380_REG(NCR5380_IDSTAT);


        if ((tmp & (SC_S_BSY|SC_S_REQ)) != (SC_S_BSY|SC_S_REQ)) {
                busy           &= ~(1 << reqp->targ_id);
                connected       = NULL;
                reqp->xs->error = XS_TIMEOUT;
                finish_req(reqp);
                if ((tmp & SC_S_REQ) == 0)
                        scsi_reset_verbose(sc,
                                           "Timeout waiting for phase-change");
                PID("info_transf2");
                return 0;
        }

        phase = (tmp >> 2) & 7;
        if (phase != reqp->phase) {
                reqp->phase = phase;
#ifdef DBG_INF
                if (dbg_target_mask & (1 << reqp->targ_id))
                        DBG_INFPRINT(show_phase, reqp, phase);
#endif
        } else {
                /*
                 * Same data-phase. If same error give up
                 */
                if ((reqp->msgout == MSG_ABORT) &&
                    ((phase == PH_DATAOUT) || (phase == PH_DATAIN))) {
                        busy     &= ~(1 << reqp->targ_id);
                        connected = NULL;
                        reqp->xs->error = XS_TIMEOUT;
                        finish_req(reqp);
                        scsi_reset_verbose(sc, "Failure to abort command");
                        return 0;
                }
        }

        switch (phase) {
        case PH_DATAOUT:
#ifdef DBG_NOWRITE
                ncr_tprint(reqp, "NOWRITE set -- write attempt aborted.");
                reqp->msgout = MSG_ABORT;
                SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
                return -1;
#endif /* DBG_NOWRITE */
                /*
                 * If this is the first write using DMA, fill
                 * the bounce buffer.
                 */
                if (reqp->xdata_ptr == reqp->xs->data) { /* XXX */
                        if (reqp->dr_flag & DRIVER_BOUNCING)
                                memcpy(reqp->bounceb, reqp->xdata_ptr,
                                    reqp->xdata_len);
                }

        case PH_DATAIN:
                if (reqp->xdata_len <= 0) {
                        /*
                         * Target keeps requesting data. Try to get into
                         * message-out phase by feeding/taking 100 byte.
                         */
                        ncr_tprint(reqp, "Target requests too much data\n");
                        reqp->msgout = MSG_ABORT;
                        SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
                        reach_msg_out(sc, 100);
                        return -1;
                }
#ifdef REAL_DMA
                if (reqp->dr_flag & DRIVER_DMAOK) {
                        int poll = REAL_DMA_POLL|(reqp->dr_flag & DRIVER_NOINT);
                        transfer_dma(reqp, phase, poll);
                        if (!poll)
                                return 0;
                } else
#endif
                {
                        PID("info_transf3");
                        len = reqp->xdata_len;
#ifdef USE_PDMA
                        if (transfer_pdma(&phase, reqp->xdata_ptr, &len) == 0)
                                return 0;
#else
                        transfer_pio(&phase, reqp->xdata_ptr, &len, 0);
#endif
                        reqp->xdata_ptr += reqp->xdata_len - len;
                        reqp->xdata_len  = len;
                }
                return -1;
        case PH_MSGIN:
                /*
                 * We only expect single byte messages here.
                 */
                len = 1;
                transfer_pio(&phase, &tmp, &len, 1);
                reqp->message = tmp;
                return handle_message(reqp, tmp);
        case PH_MSGOUT:
                len = 1;
                transfer_pio(&phase, &reqp->msgout, &len, 0);
                if (reqp->msgout == MSG_ABORT) {
                        busy     &= ~(1 << reqp->targ_id);
                        connected = NULL;
                        if (!reqp->xs->error)
                                reqp->xs->error = XS_DRIVER_STUFFUP;
                        finish_req(reqp);
                        PID("info_transf4");
                        return 0;
                }
                reqp->msgout = MSG_NOOP;
                return -1;
        case PH_CMD :
                len = reqp->xcmd_len;
                transfer_pio(&phase, (uint8_t *)&reqp->xcmd, &len, 0);
                PID("info_transf5");
                return -1;
        case PH_STATUS:
                len = 1;
                transfer_pio(&phase, &tmp, &len, 0);
                reqp->status = tmp;
                PID("info_transf6");
                return -1;
        default:
                ncr_tprint(reqp, "Unknown phase\n");
        }
        PID("info_transf7");
        return -1;
}

/*
 * Handle the message 'msg' send to us by the target.
 * Return values:
 *       0 : The current command has completed.
 *      -1 : Get on to the next phase.
 */
static int
handle_message(SC_REQ *reqp, u_int msg)
{
        int     sps;
        SC_REQ  *prev, *req;

        PID("hmessage1");
        switch (msg) {
                /*
                 * Linking lets us reduce the time required to get
                 * the next command to the device, skipping the arbitration
                 * and selection time. In the current implementation,
                 * we merely have to start the next command pointed
                 * to by 'next_link'.
                 */
        case MSG_LINK_CMD_COMPLETE:
        case MSG_LINK_CMD_COMPLETEF:
                if (reqp->link == NULL) {
                        ncr_tprint(reqp, "No link for linked command");
                        nack_message(reqp, MSG_ABORT);
                        PID("hmessage2");
                        return -1;
                }
                ack_message();
                if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
                        reqp->xs->resid = reqp->xdata_len;
                        reqp->xs->error = 0;
                }

#ifdef AUTO_SENSE
                if (check_autosense(reqp, 1) == -1)
                        return -1;
#endif /* AUTO_SENSE */

#ifdef DBG_REQ
                if (dbg_target_mask & (1 << reqp->targ_id))
                        show_request(reqp->link, "LINK");
#endif
                connected = reqp->link;

                /*
                 * Unlink the 'linked' request from the issue_q
                 */
                sps  = splbio();
                prev = NULL;
                for (req = issue_q; req != NULL; prev = req, req = req->next) {
                        if (req == connected)
                                break;
                }
                if (req == NULL)
                        panic("Inconsistent issue_q");
                if (prev == NULL)
                        issue_q = req->next;
                else
                        prev->next = req->next;
                req->next = NULL;
                splx(sps);

                finish_req(reqp);
                PID("hmessage3");
                return -1;
        case MSG_ABORT:
        case MSG_CMDCOMPLETE:
                ack_message();
                connected = NULL;
                busy     &= ~(1 << reqp->targ_id);
                if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
                        reqp->xs->resid = reqp->xdata_len;
                        reqp->xs->error = 0;
                }

#ifdef AUTO_SENSE
                if (check_autosense(reqp, 0) == -1) {
                        PID("hmessage4");
                        return 0;
                }
#endif /* AUTO_SENSE */

                finish_req(reqp);
                PID("hmessage5");
                return 0;
        case MSG_MESSAGE_REJECT:
                ack_message();
                PID("hmessage6");
                return -1;
        case MSG_DISCONNECT:
                ack_message();
#ifdef DBG_REQ
                if (dbg_target_mask & (1 << reqp->targ_id))
                        show_request(reqp, "DISCON");
#endif
                sps = splbio();
                connected  = NULL;
                reqp->next = discon_q;
                discon_q   = reqp;
                splx(sps);
                PID("hmessage7");
                return 0;
        case MSG_SAVEDATAPOINTER:
        case MSG_RESTOREPOINTERS:
                /*
                 * We save pointers implicitly at disconnect.
                 * So we can ignore these messages.
                 */
                ack_message();
                PID("hmessage8");
                return -1;
        case MSG_EXTENDED:
                nack_message(reqp, MSG_MESSAGE_REJECT);
                PID("hmessage9");
                return -1;
        default:
                if ((msg & 0x80) && (msg & 0x18) == 0) {        /* IDENTIFY */
                        PID("hmessage10");
                        ack_message();
                        return 0;
                } else {
                        ncr_tprint(reqp, "Unknown message %x.  Rejecting.\n",
                            msg);
                        nack_message(reqp, MSG_MESSAGE_REJECT);
                }
                return -1;
        }
        PID("hmessage11");
        return -1;
}

/*
 * Handle reselection. If a valid reconnection occurs, connected
 * points at the reconnected command. The command is removed from the
 * disconnected queue.
 */
static void
reselect(struct ncr_softc *sc)
{
        uint8_t phase;
        u_long  len;
        uint8_t msg;
        uint8_t target_mask;
        int     abort = 0;
        SC_REQ  *tmp, *prev;

        PID("reselect1");
        target_mask = GET_5380_REG(NCR5380_DATA) & ~SC_HOST_ID;

        /*
         * At this point, we have detected that our SCSI-id is on the bus,
         * SEL is true and BSY was false for at least one bus settle
         * delay (400 ns.).
         * We must assert BSY ourselves, until the target drops the SEL signal.
         * The SCSI-spec specifies no maximum time for this, so we have to
         * choose something long enough to suit all targets.
         */
        SET_5380_REG(NCR5380_ICOM, SC_A_BSY);
        len = 250000;
        while ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_SEL) && (len > 0)) {
                delay(1);
                len--;
        }
        if (GET_5380_REG(NCR5380_IDSTAT) & SC_S_SEL) {
                /* Damn SEL isn't dropping */
                scsi_reset_verbose(sc, "Target won't drop SEL during Reselect");
                return;
        }

        SET_5380_REG(NCR5380_ICOM, 0);

        /*
         * Check if the reselection is still valid. Check twice because
         * of possible line glitches - cheaper than delay(1) and we need
         * only a few nanoseconds.
         */
        if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
                if ((GET_5380_REG(NCR5380_IDSTAT) & SC_S_BSY) == 0) {
                        ncr_aprint(sc,
                            "Stepped into the reselection timeout\n");
                        return;
                }
        }

        /*
         * Get the expected identify message.
         */
        phase = PH_MSGIN;
        len   = 1;
        transfer_pio(&phase, &msg, &len, 0);
        if (len || !MSG_ISIDENTIFY(msg)) {
                ncr_aprint(sc, "Expecting IDENTIFY, got 0x%x\n", msg);
                abort = 1;
                tmp = NULL;
        } else {
                /*
                 * Find the command reconnecting
                 */
                for (tmp = discon_q, prev = NULL; tmp != NULL;
                    prev = tmp, tmp = tmp->next) {
                        if (target_mask == (1 << tmp->targ_id)) {
                                if (prev)
                                        prev->next = tmp->next;
                                else
                                        discon_q = tmp->next;
                                tmp->next = NULL;
                                break;
                        }
                }
                if (tmp == NULL) {
                        ncr_aprint(sc,
                            "No disconnected job for targetmask %x\n",
                            target_mask);
                        abort = 1;
                }
        }
        if (abort) {
                msg   = MSG_ABORT;
                len   = 1;
                phase = PH_MSGOUT;

                SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
                if (transfer_pio(&phase, &msg, &len, 0) || len)
                        scsi_reset_verbose(sc, "Failure to abort reselection");
        } else {
                connected = tmp;
#ifdef DBG_REQ
                if (dbg_target_mask & (1 << tmp->targ_id))
                        show_request(tmp, "RECON");
#endif
        }
        PID("reselect2");
}

/*
 * Transfer data in a given phase using programmed I/O.
 * Returns -1 when a different phase is entered without transferring the
 * maximum number of bytes, 0 if all bytes transferred or exit is in the same
 * phase.
 */
static int
transfer_pio(u_char *phase, u_char *data, u_long *len, int dont_drop_ack)
{
        u_int   cnt = *len;
        uint8_t ph  = *phase;
        uint8_t tmp, new_icom;

        DBG_PIOPRINT("SCSI: transfer_pio start: phase: %d, len: %d\n", ph,cnt);
        PID("tpio1");
        SET_5380_REG(NCR5380_TCOM, ph);
        do {
                if (!wait_req_true()) {
                        DBG_PIOPRINT ("SCSI: transfer_pio: missing REQ\n",
                            0, 0);
                        break;
                }
                if (((GET_5380_REG(NCR5380_IDSTAT) >> 2) & 7) != ph) {
                        DBG_PIOPRINT("SCSI: transfer_pio: phase mismatch\n",
                            0, 0);
                        break;
                }
                if (PH_IN(ph)) {
                        *data++ = GET_5380_REG(NCR5380_DATA);
                        SET_5380_REG(NCR5380_ICOM, SC_A_ACK);
                        if ((cnt == 1) && dont_drop_ack)
                                new_icom = SC_A_ACK;
                        else
                                new_icom = 0;
                } else {
                        SET_5380_REG(NCR5380_DATA, *data++);

                        /*
                         * The SCSI-standard suggests that in the
                         * 'MESSAGE OUT' phase, the initiator should
                         * drop ATN on the last byte of the * message phase
                         * after REQ has been asserted for the handshake
                         * but before the initiator raises ACK.
                         */
                        if (!((ph == PH_MSGOUT) && (cnt > 1) )) {
                                SET_5380_REG(NCR5380_ICOM, SC_ADTB);
                                SET_5380_REG(NCR5380_ICOM, SC_ADTB | SC_A_ACK);
                                new_icom = 0;
                        } else {
                                SET_5380_REG(NCR5380_ICOM, SC_ADTB | SC_A_ATN);
                                SET_5380_REG(NCR5380_ICOM,
                                    SC_ADTB | SC_A_ATN | SC_A_ACK);
                                new_icom = SC_A_ATN;
                        }
                }
                if (!wait_req_false()) {
                        DBG_PIOPRINT("SCSI: transfer_pio - REQ not dropping\n",
                            0, 0);
                        break;
                }
                SET_5380_REG(NCR5380_ICOM, new_icom);

        } while (--cnt);

        if ((tmp = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ)
                *phase = (tmp >> 2) & 7;
        else
                *phase = NR_PHASE;
        *len = cnt;
        DBG_PIOPRINT("SCSI: transfer_pio done: phase: %d, len: %d\n",
            *phase, cnt);
        PID("tpio2");
        if (cnt == 0 || (*phase == ph))
                return 0;
        return -1;
}

#ifdef REAL_DMA

/*
 * Start a DMA-transfer on the device using the current pointers.
 * If 'poll' is true, the function busy-waits until DMA has completed.
 */
static void
transfer_dma(SC_REQ *reqp, u_int phase, int poll)
{
        int     dma_done;
        uint8_t mbase = 0;
        int     sps;

again:
        PID("tdma1");

        /*
         * We should be in phase, otherwise we are not allowed to
         * drive the bus.
         */
        SET_5380_REG(NCR5380_TCOM, phase);

        /*
         * Defer interrupts until DMA is fully running.
         */
        sps = splbio();

        /*
         * Clear pending interrupts and parity errors.
         */
        scsi_clr_ipend();

        if (!poll) {
                /*
                 * Enable SCSI interrupts and set IN_DMA flag, set 'mbase'
                 * to the interrupts we want enabled.
                 */
                scsi_ienable();
                reqp->dr_flag |= DRIVER_IN_DMA;
                mbase = SC_E_EOPI | SC_MON_BSY;
        } else
                scsi_idisable();
        mbase |=  IMODE_BASE | SC_M_DMA;
        scsi_dma_setup(reqp, phase, mbase);

        splx(sps);

        if (poll) {
                /*
                 * On polled-DMA transfers, we wait here until the
                 * 'end-of-DMA' condition occurs.
                 */
                poll_edma(reqp);
                if ((dma_done = dma_ready()) == 0)
                        goto again;
        }
        PID("tdma2");
}

/*
 * Check results of a DMA data-transfer.
 */
static int
dma_ready(void)
{
        SC_REQ  *reqp = connected;
        int     dmstat, is_edma;
        long    bytes_left, bytes_done;

        is_edma = get_dma_result(reqp, &bytes_left);
        dmstat  = GET_5380_REG(NCR5380_DMSTAT);

        /*
         * Check if the call is sensible and not caused by any spurious
         * interrupt.
         */
        if (!is_edma &&
            (dmstat & (SC_END_DMA|SC_BSY_ERR)) == 0 &&
            (dmstat & SC_PHS_MTCH) != 0) {
                ncr_tprint(reqp, "dma_ready: spurious call "
                    "(dm:%x,last_hit: %s)\n",
#ifdef DBG_PID
                    dmstat, last_hit[DBG_PID-1]);
#else
                    dmstat, "unknown");
#endif
                return 0;
        }

        /*
         * Clear all (pending) interrupts.
         */
        scsi_clr_ipend();

        /*
         * Update various transfer-pointers/lengths
         */
        bytes_done = reqp->dm_cur->dm_count - bytes_left;

        if ((reqp->dr_flag & DRIVER_BOUNCING) && (PH_IN(reqp->phase))) {
                /*
                 * Copy the bytes read until now from the bounce buffer
                 * to the 'real' destination. Flush the data-cache
                 * before copying.
                 */
                PCIA();
                memcpy(reqp->xdata_ptr, reqp->bouncerp, bytes_done);
                reqp->bouncerp += bytes_done;
        }

        reqp->xdata_ptr  = &reqp->xdata_ptr[bytes_done];        /* XXX */
        reqp->xdata_len -= bytes_done;                          /* XXX */
        if ((reqp->dm_cur->dm_count -= bytes_done) == 0)
                reqp->dm_cur++;
        else
                reqp->dm_cur->dm_addr += bytes_done;

        if (PH_IN(reqp->phase) && (dmstat & SC_PAR_ERR)) {
                if ((ncr5380_no_parchk & (1 << reqp->targ_id)) == 0) {
                        ncr_tprint(reqp, "parity error in data-phase\n");
                        reqp->xs->error = XS_TIMEOUT;
                }
        }

        /*
         * DMA mode should always be reset even when we will continue with the
         * next chain. It is also essential to clear the MON_BUSY because
         * when LOST_BUSY is unexpectedly set, we will not be able to drive
         * the bus....
         */
        SET_5380_REG(NCR5380_MODE, IMODE_BASE);


        if ((dmstat & SC_BSY_ERR) != 0 || (dmstat & SC_PHS_MTCH) == 0 ||
            (reqp->dm_cur > reqp->dm_last) || reqp->xs->error != 0) {

                /*
                 * Tell interrupt functions DMA mode has ended.
                 */
                reqp->dr_flag &= ~DRIVER_IN_DMA;

                /*
                 * Clear mode and icom
                 */
                SET_5380_REG(NCR5380_MODE, IMODE_BASE);
                SET_5380_REG(NCR5380_ICOM, 0);

                if (dmstat & SC_BSY_ERR) {
                        if (reqp->xs->error == 0)
                                reqp->xs->error = XS_TIMEOUT;
                        finish_req(reqp);
                        PID("dma_ready1");
                        return 1;
                }

                if (reqp->xs->error != 0) {
                        ncr_tprint(reqp, "dma-ready: code = %d\n",
                            reqp->xs->error); /* LWP */
                        reqp->msgout = MSG_ABORT;
                        SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
                }
                PID("dma_ready2");
                return 1;
        }
        return 0;
}
#endif /* REAL_DMA */

static int
check_autosense(SC_REQ *reqp, int linked)
{
        int sps;

        /*
         * If this is the driver's Link Check for this target, ignore
         * the results of the command.  All we care about is whether we
         * got here from a LINK_CMD_COMPLETE or CMD_COMPLETE message.
         */
        PID("linkcheck");
        if (reqp->dr_flag & DRIVER_LINKCHK) {
                if (linked)
                        ncr_will_link |= 1<<reqp->targ_id;
                else
                        ncr_tprint(reqp, "Does not support linked commands\n");
                return 0;
        }
        /*
         * If we not executing an auto-sense and the status code
         * is request-sense, we automatically issue a request
         * sense command.
         */
        PID("cautos1");
        if ((reqp->dr_flag & DRIVER_AUTOSEN) == 0) {
                switch (reqp->status & SCSMASK) {
                case SCSCHKC:
                        memcpy(&reqp->xcmd, sense_cmd, sizeof(sense_cmd));
                        reqp->xcmd_len = sizeof(sense_cmd);
                        reqp->xdata_ptr = (u_char *)&reqp->xs->sense.scsi_sense;
                        reqp->xdata_len = sizeof(reqp->xs->sense.scsi_sense);
                        reqp->dr_flag  |= DRIVER_AUTOSEN;
                        reqp->dr_flag  &= ~DRIVER_DMAOK;
                        if (!linked) {
                                sps = splbio();
                                reqp->next = issue_q;
                                issue_q    = reqp;
                                splx(sps);
                        } else
                                reqp->xcmd.bytes[sizeof(sense_cmd)-2] |= 1;

#ifdef DBG_REQ
                        memset(reqp->xdata_ptr, 0, reqp->xdata_len);
                        if (dbg_target_mask & (1 << reqp->targ_id))
                                show_request(reqp, "AUTO-SENSE");
#endif
                        PID("cautos2");
                        return -1;
                case SCSBUSY:
                        reqp->xs->error = XS_BUSY;
                        return 0;
                }
        } else {
                /*
                 * An auto-sense has finished
                 */
                if ((reqp->status & SCSMASK) != SCSGOOD)
                        reqp->xs->error = XS_DRIVER_STUFFUP; /* SC_E_AUTOSEN; */
                else
                        reqp->xs->error = XS_SENSE;
                reqp->status = SCSCHKC;
        }
        PID("cautos3");
        return 0;
}

static int
reach_msg_out(struct ncr_softc *sc, u_long len)
{
        uint8_t phase;
        u_long  n = len;

        ncr_aprint(sc, "Trying to reach Message-out phase\n");
        if ((phase = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ)
                phase = (phase >> 2) & 7;
        else
                return -1;
        ncr_aprint(sc, "Trying to reach Message-out phase, now: %d\n", phase);
        if (phase == PH_MSGOUT)
                return 0;

        SET_5380_REG(NCR5380_TCOM, phase);

        do {
                if (!wait_req_true())
                        break;
                if (((GET_5380_REG(NCR5380_IDSTAT) >> 2) & 7) != phase)
                        break;
                if (PH_IN(phase)) {
                        GET_5380_REG(NCR5380_DATA);
                        SET_5380_REG(NCR5380_ICOM, SC_A_ACK | SC_A_ATN);
                } else {
                        SET_5380_REG(NCR5380_DATA, 0);
                        SET_5380_REG(NCR5380_ICOM, SC_ADTB|SC_A_ATN);
                        SET_5380_REG(NCR5380_ICOM, SC_ADTB|SC_A_ACK|SC_A_ATN);
                }
                if (!wait_req_false())
                        break;
                SET_5380_REG(NCR5380_ICOM, SC_A_ATN);
        } while (--n);

        if ((phase = GET_5380_REG(NCR5380_IDSTAT)) & SC_S_REQ) {
                phase = (phase >> 2) & 7;
                if (phase == PH_MSGOUT) {
                        ncr_aprint(sc, "Message-out phase reached after "
                                        "%ld bytes.\n", len - n);
                        return 0;
                }
                ncr_aprint(sc, "Phase now: %d after %ld bytes.\n",
                    phase, len - n);

        }
        return -1;
}

void
scsi_reset(void)
{
        SC_REQ  *tmp, *next;
        int     sps;

        PID("scsi_reset1");
        sps = splbio();
        SET_5380_REG(NCR5380_ICOM, SC_A_RST);
        delay(100);
        SET_5380_REG(NCR5380_ICOM, 0);
        scsi_clr_ipend();

        /*
         * None of the jobs in the discon_q will ever be reconnected,
         * notify this to the higher level code.
         */
        for (tmp = discon_q; tmp ;) {
                next = tmp->next;
                tmp->next = NULL;
                tmp->xs->error = XS_TIMEOUT;
                busy &= ~(1 << tmp->targ_id);
                finish_req(tmp);
                tmp = next;
        }
        discon_q = NULL;

        /*
         * The current job will never finish either.
         * The problem is that we can't finish the job because an instance
         * of main is running on it. Our best guess is that the job is currently
         * doing REAL-DMA. In that case 'dma_ready()' should correctly finish
         * the job because it detects BSY-loss.
         */
        if ((tmp = connected) != NULL) {
                if (tmp->dr_flag & DRIVER_IN_DMA) {
                        tmp->xs->error = XS_DRIVER_STUFFUP;
#ifdef REAL_DMA
                        dma_ready();
#endif
                }
        }
        splx(sps);
        PID("scsi_reset2");

        /*
         * Give the attached devices some time to handle the reset. This
         * value is arbitrary but should be relatively long.
         */
        delay(100000);
}

static void
scsi_reset_verbose(struct ncr_softc *sc, const char *why)
{

        ncr_aprint(sc, "Resetting SCSI-bus (%s)\n", why);

        scsi_reset();
}

/*
 * Check validity of the IRQ set by the 5380. If the interrupt is valid,
 * the appropriate action is carried out (reselection or DMA ready) and
 * INTR_RESEL or INTR_DMA is returned. Otherwise a console notice is written
 * and INTR_SPURIOUS is returned.
 */
static int
check_intr(struct ncr_softc *sc)
{
        SC_REQ  *reqp;

        if ((GET_5380_REG(NCR5380_IDSTAT) & (SC_S_SEL|SC_S_IO)) ==
            (SC_S_SEL|SC_S_IO))
                return INTR_RESEL;
        else {
                if ((reqp = connected) && (reqp->dr_flag & DRIVER_IN_DMA)){
                        reqp->dr_flag &= ~DRIVER_IN_DMA;
                        return INTR_DMA;
                }
        }
        printf("-->");
        scsi_show();
        scsi_clr_ipend();
        ncr_aprint(sc, "Spurious interrupt.\n");
        return INTR_SPURIOUS;
}

#ifdef REAL_DMA
/*
 * Check if DMA can be used for this request. This function also builds
 * the DMA-chain.
 */
static int
scsi_dmaok(SC_REQ *reqp)
{
        u_long                  phy_buf;
        u_long                  phy_len;
        uint8_t                 *req_addr;
        u_long                  req_len;
        struct dma_chain        *dm;

        /*
         * To be safe, do not use DMA for Falcon
         */
        if (machineid & ATARI_FALCON)
                return 0;

        /*
         * Initialize locals and requests' DMA-chain.
         */
        req_len        = reqp->xdata_len;
        req_addr       = (uint8_t *)reqp->xdata_ptr;
        dm             = reqp->dm_cur = reqp->dm_last = reqp->dm_chain;
        dm->dm_count   = dm->dm_addr = 0;
        reqp->dr_flag &= ~DRIVER_BOUNCING;

        /*
         * Do not accept zero length DMA.
         */
        if (req_len == 0)
                return 0;

        /*
         * If DMA is emulated in software, we don't have to breakup the
         * request. Just build a chain with a single element and stash in
         * the KVA and not the KPA.
         */
        if (emulated_dma()) {
                dm->dm_addr    = (u_long)req_addr;
                dm->dm_count   = req_len;
                return 1;
        }

        /*
         * LWP: I think that this restriction is not strictly necessary.
         */
        if ((req_len & 0x1) || ((u_int)req_addr & 0x3))
                return 0;

        /*
         * Build the DMA-chain.
         */
        dm->dm_addr = phy_buf = kvtop(req_addr);
        while (req_len) {
                if (req_len <
                    (phy_len = PAGE_SIZE - ((u_long)req_addr & PGOFSET)))
                        phy_len = req_len;

                req_addr     += phy_len;
                req_len      -= phy_len;
                dm->dm_count += phy_len;

                if (req_len) {
                        u_long  tmp = kvtop(req_addr);

                        if ((phy_buf + phy_len) != tmp) {
                                if (wrong_dma_range(reqp, dm)) {
                                        if (reqp->dr_flag & DRIVER_BOUNCING)
                                                goto bounceit;
                                        return 0;
                                }

                                if (++dm >= &reqp->dm_chain[MAXDMAIO]) {
                                        ncr_tprint(reqp,
                                            "dmaok: DMA chain too long!\n");
                                        return 0;
                                }
                                dm->dm_count = 0;
                                dm->dm_addr  = tmp;
                        }
                        phy_buf = tmp;
                }
        }
        if (wrong_dma_range(reqp, dm)) {
                if (reqp->dr_flag & DRIVER_BOUNCING)
                        goto bounceit;
                return 0;
        }
        reqp->dm_last = dm;
        return 1;

bounceit:
        if ((reqp->bounceb = alloc_bounceb(reqp->xdata_len)) == NULL) {
                /*
                 * If we can't get a bounce buffer, forget DMA
                 */
                reqp->dr_flag &= ~DRIVER_BOUNCING;
                return 0;
        }
        /*
         * Initialize a single DMA-range containing the bounced request
         */
        dm = reqp->dm_cur = reqp->dm_last = reqp->dm_chain;
        dm->dm_addr    = kvtop(reqp->bounceb);
        dm->dm_count   = reqp->xdata_len;
        reqp->bouncerp = reqp->bounceb;

        return 1;
}
#endif /* REAL_DMA */

static void
run_main(struct ncr_softc *sc)
{
        int sps = splbio();

        if (!main_running) {
                /*
                 * If shared resources are required, claim them
                 * before entering 'scsi_main'. If we can't get them
                 * now, assume 'run_main' will be called when the resource
                 * becomes available.
                 */
                if (!claimed_dma()) {
                        splx(sps);
                        return;
                }
                main_running = 1;
                splx(sps);
                scsi_main(sc);
        } else
                splx(sps);
}

/*
 * Prefix message with full target info.
 */
static void
ncr_tprint(SC_REQ *reqp, const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        scsipi_printaddr(reqp->xs->xs_periph);
        vprintf(fmt, ap);
        va_end(ap);
}

/*
 * Prefix message with adapter info.
 */
static void
ncr_aprint(struct ncr_softc *sc, const char *fmt, ...)
{
        va_list ap;
        char buf[256];

        va_start(ap, fmt);
        vsnprintf(buf, sizeof(buf), fmt, ap);
        va_end(ap);

        printf("%s: %s", device_xname(sc->sc_dev), buf);
}
/****************************************************************************
 *              Start Debugging Functions                                   *
 ****************************************************************************/
static const char *phase_names[] = {
        "DATA_OUT", "DATA_IN", "COMMAND", "STATUS", "NONE", "NONE", "MSG_OUT",
        "MSG_IN"
};

static void
show_phase(SC_REQ *reqp, int phase)
{

        printf("INFTRANS: %d Phase = %s\n", reqp->targ_id, phase_names[phase]);
}

static void
show_data_sense(struct scsipi_xfer *xs)
{
        uint8_t *p1, *p2;
        int     i;

        p1 = (uint8_t *)xs->cmd;
        p2 = (uint8_t *)&xs->sense.scsi_sense;
        if (*p2 == 0)
                return; /* No(n)sense */
        printf("cmd[%d]: ", xs->cmdlen);
        for (i = 0; i < xs->cmdlen; i++)
                printf("%x ", p1[i]);
        printf("\nsense: ");
        for (i = 0; i < sizeof(xs->sense.scsi_sense); i++)
                printf("%x ", p2[i]);
        printf("\n");
}

static void
show_request(SC_REQ *reqp, const char *qtxt)
{

        printf("REQ-%s: %d %p[%ld] "
            "cmd[0]=%x S=%x M=%x R=%x resid=%d dr_flag=%x %s\n",
            qtxt, reqp->targ_id, reqp->xdata_ptr, reqp->xdata_len,
            reqp->xcmd.opcode, reqp->status, reqp->message,
            reqp->xs->error, reqp->xs->resid, reqp->dr_flag,
            reqp->link ? "L":"");
        if (reqp->status == SCSCHKC)
                show_data_sense(reqp->xs);
}

static const char *sig_names[] = {
        "PAR", "SEL", "I/O", "C/D", "MSG", "REQ", "BSY", "RST",
        "ACK", "ATN", "LBSY", "PMATCH", "IRQ", "EPAR", "DREQ", "EDMA"
};

static void
show_signals(uint8_t dmstat, uint8_t idstat)
{
        u_short tmp, mask;
        int     j, need_pipe;

        tmp = idstat | ((dmstat & 3) << 8);
        printf("Bus signals (%02x/%02x): ", idstat, dmstat & 3);
        for (mask = 1, j = need_pipe = 0; mask <= tmp; mask <<= 1, j++) {
                if (tmp & mask)
                        printf("%s%s", need_pipe++ ? "|" : "", sig_names[j]);
        }
        printf("\nDma status (%02x): ", dmstat);
        for (mask = 4, j = 10, need_pipe = 0; mask <= dmstat; mask <<= 1, j++) {
                if (dmstat & mask)
                        printf("%s%s", need_pipe++ ? "|" : "", sig_names[j]);
        }
        printf("\n");
}

void
scsi_show(void)
{
        SC_REQ  *tmp;
        int     sps = splhigh();
        uint8_t idstat, dmstat;
        int     i;

        printf("scsi_show: scsi_main is%s running\n",
            main_running ? "" : " not");
        for (tmp = issue_q; tmp; tmp = tmp->next)
                show_request(tmp, "ISSUED");
        for (tmp = discon_q; tmp; tmp = tmp->next)
                show_request(tmp, "DISCONNECTED");
        if (connected)
                show_request(connected, "CONNECTED");
        if (can_access_5380()) {
                idstat = GET_5380_REG(NCR5380_IDSTAT);
                dmstat = GET_5380_REG(NCR5380_DMSTAT);
                show_signals(dmstat, idstat);
        }

        if (connected)
                printf("phase = %d, ", connected->phase);
        printf("busy:%x, spl:%04x\n", busy, sps);
#ifdef  DBG_PID
        for (i=0; i<DBG_PID; i++)
                printf("\t%d\t%s\n", i, last_hit[i]);
#endif

        splx(sps);
}