/*      $NetBSD: sc.c,v 1.20 2024/09/25 09:08:22 rin Exp $      */

/*
 * Copyright (c) 1992 OMRON Corporation.
 *
 * This code is derived from software contributed to Berkeley by
 * OMRON Corporation.
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the University of
 *      California, Berkeley and its contributors.
 * 4. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 *      @(#)sc.c        8.1 (Berkeley) 6/10/93
 */
/*
 * Copyright (c) 1992, 1993
 *      The Regents of the University of California.  All rights reserved.
 *
 * This code is derived from software contributed to Berkeley by
 * OMRON Corporation.
 *
 * 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. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
 *
 *      @(#)sc.c        8.1 (Berkeley) 6/10/93
 */

/*
 * sc.c -- SCSI Protocole Controller (SPC)  driver
 * remaked by A.Fujita, MAR-11-199
 */


#define NSC     2

#include <sys/param.h>
#include <luna68k/stand/boot/samachdep.h>
#include <luna68k/stand/boot/scsireg.h>
#include <luna68k/stand/boot/scsivar.h>

#define SCSI_ID         7

static void screset(struct scsi_softc *);
static void scprobe(struct scsi_softc *, uint, uint);
static int issue_select(struct scsidevice *, uint8_t);
static void ixfer_start(struct scsidevice *, int, uint8_t, int);
static void ixfer_out(struct scsidevice *, int, uint8_t *);
static void ixfer_in(struct scsidevice *, int, uint8_t *);
static int scrun(int, int, uint8_t *, int, uint8_t *, int, volatile int *);
static int scfinish(int);
static void scabort(struct scsi_softc *);

struct  scsi_softc scsi_softc[NSC];

/*
 * Initialize SPC & Data Structure
 */

int
scinit(int ctlr, void *addr)
{
        struct scsi_softc *hs;
        uint id;

        if (ctlr < 0 || ctlr >= NSC)
                return 0;

        hs = &scsi_softc[ctlr];
        hs->sc_ctlr   = ctlr;
        hs->sc_spc    = addr;

        hs->sc_flags  = 0;
        hs->sc_phase  = BUS_FREE_PHASE;
        hs->sc_target = SCSI_ID;

        hs->sc_cdb    = NULL;
        hs->sc_cdblen = 0;
        hs->sc_buf    = NULL;
        hs->sc_len    = 0;
        hs->sc_lock   = NULL;

        hs->sc_stat   = 0;
        hs->sc_msg[0] = 0;

        screset(hs);

        for (id = 0; id < 7; id++)
                scprobe(hs, id, 0);

        return 1;
}

static void
screset(struct scsi_softc *hs)
{
        struct scsidevice *hd = hs->sc_spc;

        printf("sc%d at 0x%08lx: ", hs->sc_ctlr, (u_long)hs->sc_spc);

        /*
         * Disable interrupts then reset the FUJI chip.
         */

        hd->scsi_sctl = SCTL_DISABLE | SCTL_CTRLRST;
        hd->scsi_scmd = 0;
        hd->scsi_pctl = 0;
        hd->scsi_temp = 0;
        hd->scsi_tch  = 0;
        hd->scsi_tcm  = 0;
        hd->scsi_tcl  = 0;
        hd->scsi_ints = 0;

        /* We can use Asynchronous Transfer only */
        printf("async");

        /*
         * Configure MB89352 with its SCSI address, all
         * interrupts enabled & appropriate parity.
         */
        hd->scsi_bdid = SCSI_ID;
        hd->scsi_sctl = SCTL_DISABLE | SCTL_ABRT_ENAB|
                        SCTL_PARITY_ENAB | SCTL_RESEL_ENAB |
                        SCTL_INTR_ENAB;
        printf(", parity");

        DELAY(400);
        hd->scsi_sctl &= ~SCTL_DISABLE;

        printf(", ID %d\n", SCSI_ID);
}

/*
 * XXX
 * sensebuf and inqbuf may be uninitialized for some cases.
 * Real fix should be to check return values everywhere in
 * scsi_request_sense(), scsi_immed_command(), and functions
 * called from them.
 */
#pragma GCC diagnostic push                                     /* XXX { */
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

bool
scident(uint ctlr, uint target, uint lun, struct scsi_inquiry *inqout,
    uint32_t *capout)
{
        struct scsi_inquiry inqbuf;
        struct scsi_generic_cdb inq = {
                6,
                { CMD_INQUIRY, 0, 0, 0, sizeof(inqbuf), 0 }
        };
        uint32_t capbuf[2];
        struct scsi_generic_cdb cap = {
                10,
                { CMD_READ_CAPACITY, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
        };
        int i;
        int tries = 10;

        /*
         * See if unit exists and is a disk then read block size & nblocks.
         */
        while ((i = scsi_test_unit_rdy(ctlr, target, lun)) != 0) {
                if (i < 0 || --tries < 0)
                        return false;
                if (i == STS_CHECKCOND) {
                        uint8_t sensebuf[8];
                        struct scsi_xsense *sp = (struct scsi_xsense *)sensebuf;

                        scsi_request_sense(ctlr, target, lun, sensebuf, 8);
                        if (sp->class == 7 && sp->key == 6)
                                /* drive doing an RTZ -- give it a while */
                                DELAY(1000000);
                }
                DELAY(1000);
        }
        if (scsi_immed_command(ctlr, target, lun, &inq, (uint8_t *)&inqbuf,
                               sizeof(inqbuf)) ||
            scsi_immed_command(ctlr, target, lun, &cap, (uint8_t *)&capbuf,
                               sizeof(capbuf)))
                /* doesn't exist or not a CCS device */
                return false;

        switch (inqbuf.type) {
        case 0:         /* disk */
        case 4:         /* WORM */
        case 5:         /* CD-ROM */
        case 7:         /* Magneto-optical */
                break;
        default:        /* not a disk */
                return false;
        }

        if (inqout != NULL)
                *inqout = inqbuf;
        if (capout != NULL) {
                /* assume big endian */
                capout[0] = capbuf[0];
                capout[1] = capbuf[1];
        }

        return true;
}

#pragma GCC diagnostic pop                                      /* XXX } */

static void
scprobe(struct scsi_softc *hs, uint target, uint lun)
{
        struct scsi_inquiry inqbuf;
        uint32_t capbuf[2], blocks, blksize;
        char idstr[32];
        int i;

        if (!scident(hs->sc_ctlr, target, lun, &inqbuf, capbuf))
                return;

        /* CMD_READ_CAPACITY returns the last logical data block address. */
        blocks  = capbuf[0] + 1;
        blksize = capbuf[1];

        memcpy(idstr, &inqbuf.vendor_id, 28);
        for (i = 27; i > 23; --i)
                if (idstr[i] != ' ')
                        break;
        idstr[i + 1] = '\0';
        for (i = 23; i > 7; --i)
                if (idstr[i] != ' ')
                        break;
        idstr[i + 1] = '\0';
        for (i = 7; i >= 0; --i)
                if (idstr[i] != ' ')
                        break;
        idstr[i + 1] = '\0';

        printf(" ID %d: %s %s rev %s", target, idstr, &idstr[8], &idstr[24]);
        printf(", %d bytes/sect x %d sectors\n", blksize, blocks);
}


/*
 * SPC Arbitration/Selection routine
 */

static int
issue_select(struct scsidevice *hd, uint8_t target)
{

        hd->scsi_pctl = 0;
        hd->scsi_temp = (1 << SCSI_ID) | (1 << target);

        /* select timeout is hardcoded to 250ms */
        hd->scsi_tch = 2;
        hd->scsi_tcm = 113;
        hd->scsi_tcl = 3;

        hd->scsi_scmd = SCMD_SELECT;

        return 1;
}


/*
 * SPC Manual Transfer routines
 */

/* not yet */


/*
 * SPC Program Transfer routines
 */

static void
ixfer_start(struct scsidevice *hd, int len, uint8_t phase, int wait)
{

        hd->scsi_tch  = ((len & 0xff0000) >> 16);
        hd->scsi_tcm  = ((len & 0x00ff00) >>  8);
        hd->scsi_tcl  =  (len & 0x0000ff);
        hd->scsi_pctl = phase;
        hd->scsi_scmd = SCMD_XFR | SCMD_PROG_XFR;
}

static void
ixfer_out(struct scsidevice *hd, int len, uint8_t *buf)
{

        for (; len > 0; len--) {
                while (hd->scsi_ssts & SSTS_DREG_FULL) {
                        DELAY(5);
                }
                hd->scsi_dreg = *buf++;
        }
}

static void
ixfer_in(struct scsidevice *hd, int len, uint8_t *buf)
{

        for (; len > 0; len--) {
                while (hd->scsi_ssts & SSTS_DREG_EMPTY) {
                        DELAY(5);
                }
                *buf++ = hd->scsi_dreg;
        }
}


/*
 * SPC drive routines
 */

static int
scrun(int ctlr, int target, uint8_t *cdb, int cdblen, uint8_t *buf, int len,
    volatile int *lock)
{
        struct scsi_softc *hs;
        struct scsidevice *hd;

        if (ctlr < 0 || ctlr >= NSC)
                return 0;

        hs = &scsi_softc[ctlr];
        hd = hs->sc_spc;
        if (hd == NULL)
                return 0;

        if ((hd->scsi_ssts & (SSTS_INITIATOR | SSTS_TARGET | SSTS_BUSY)) != 0)
                return 0;

        hs->sc_flags  = 0;
        hs->sc_phase  = ARB_SEL_PHASE;
        hs->sc_target = target;

        hs->sc_cdb    = cdb;
        hs->sc_cdblen = cdblen;
        hs->sc_buf    = buf;
        hs->sc_len    = len;
        hs->sc_lock   = lock;

        hs->sc_stat   = 0;
        hs->sc_msg[0] = 0;

        *(hs->sc_lock) = SC_IN_PROGRESS;
        issue_select(hd, hs->sc_target);

        return 1;
}

static int
scfinish(int ctlr)
{
        struct scsi_softc *hs = &scsi_softc[ctlr];
        int status = hs->sc_stat;

        hs->sc_flags  = 0;
        hs->sc_phase  = BUS_FREE_PHASE;
        hs->sc_target = SCSI_ID;

        hs->sc_cdb    = NULL;
        hs->sc_cdblen = 0;
        hs->sc_buf    = NULL;
        hs->sc_len    = 0;
        hs->sc_lock   = NULL;

        hs->sc_stat   = 0;
        hs->sc_msg[0] = 0;

        return status;
}

static void
scabort(struct scsi_softc *hs)
{
        struct scsidevice *hd = hs->sc_spc;
        int len;

        printf("sc%d: abort  phase=0x%x, ssts=0x%x, ints=0x%x\n",
            hs->sc_ctlr, hd->scsi_psns, hd->scsi_ssts, hd->scsi_ints);

        if (hd->scsi_ints != 0)
                /* write register value back to register */
                hd->scsi_ints = hd->scsi_ints;

        if (hd->scsi_psns == 0 || (hd->scsi_ssts & SSTS_INITIATOR) == 0)
                /* no longer connected to scsi target */
                return;

        /* get the number of bytes remaining in current xfer + fudge */
        len = (hd->scsi_tch << 16) | (hd->scsi_tcm << 8) | hd->scsi_tcl;

        /* for that many bus cycles, try to send an abort msg */
        for (len += 1024;
            ((hd->scsi_ssts & SSTS_INITIATOR)) != 0 && --len >= 0;) {
                hd->scsi_scmd = SCMD_SET_ATN;

                while ((hd->scsi_psns & PSNS_REQ) == 0) {
                        if ((hd->scsi_ssts & SSTS_INITIATOR) == 0)
                                goto out;
                        DELAY(1);
                }

                if ((hd->scsi_psns & PHASE) == MESG_OUT_PHASE)
                        hd->scsi_scmd = SCMD_RST_ATN;
                hd->scsi_pctl = hs->sc_phase = hd->scsi_psns & PHASE;

                if (hd->scsi_psns & PHASE_IO) {
                        /* one of the input phases - read & discard a byte */
                        hd->scsi_scmd = SCMD_SET_ACK;
                        while ((hd->scsi_psns & PSNS_REQ) != 0)
                                DELAY(1);
                        (void)hd->scsi_temp;
                } else {
                        /* one of the output phases - send an abort msg */
                        hd->scsi_temp = MSG_ABORT;
                        hd->scsi_scmd = SCMD_SET_ACK;
                        while ((hd->scsi_psns & PSNS_REQ) != 0)
                                DELAY(1);
                }

                hd->scsi_scmd = SCMD_RST_ACK;
        }
out:
        /*
         * Either the abort was successful & the bus is disconnected or
         * the device didn't listen.  If the latter, announce the problem.
         * Either way, reset the card & the SPC.
         */
        if (len < 0 && hs)
                printf("sc%d: abort failed.  phase=0x%x, ssts=0x%x\n",
                    hs->sc_ctlr, hd->scsi_psns, hd->scsi_ssts);
}


/*
 * SCSI Command Handler
 */

int
scsi_test_unit_rdy(int ctlr, int target, int lun)
{
        static struct scsi_cdb6 cdb = { CMD_TEST_UNIT_READY };
        int status;
        volatile int lock;

#ifdef DEBUG
        printf("scsi_test_unit_rdy( %d, %d, %d): Start\n", ctlr, target, lun);
#endif

        cdb.lun = lun;

        if (scrun(ctlr, target, (void *)&cdb, 6, NULL, 0, &lock) == 0) {
#ifdef DEBUG
                printf("scsi_test_unit_rdy: Command Transfer Failed.\n");
#endif
                return -1;
        }

        while ((lock == SC_IN_PROGRESS) || (lock == SC_DISCONNECTED))
                DELAY(10);

        status = scfinish(ctlr);

        if (lock == SC_IO_COMPLETE) {
#ifdef DEBUG
                printf("scsi_test_unit_rdy: Status -- 0x%x\n", status);
#endif
                return status;
        } else {
                return lock;
        }
}

int
scsi_request_sense(int ctlr, int target, int lun, uint8_t *buf,
    unsigned int len)
{
        static struct scsi_cdb6 cdb = { CMD_REQUEST_SENSE };
        int status;
        volatile int lock;

#ifdef DEBUG
        printf("scsi_request_sense: Start\n");
#endif

        /* Request Senseの場合、転送されるデータ長はターゲットに依存し、        */
        /* センスデータの８バイト目のAdditional Sens Lengthにより動的に決定する。*/
        /* ここではデーター転送数をcdbのAllocation Lengthに最低長である８バイト */
        /* を固定して、ＳＰＣの処理シーケンスを崩さないようにしている。         */

        /* テープユニットの状態を調べるため、Addtional Sens Fieldをアクセスする */
        /* 必要があるのでデバイスドライバ側でlenを決定することにする            */

        cdb.lun = lun;
        cdb.len = len;

        if (scrun(ctlr, target, (void *)&cdb, 6, buf, len, &lock) == 0) {
#ifdef DEBUG
                printf("scsi_request_sense: Command Transfer Failed.\n");
#endif
                return -1;
        }

        while ((lock == SC_IN_PROGRESS) || (lock == SC_DISCONNECTED))
                DELAY(10);

        status = scfinish(ctlr);

        if (lock == SC_IO_COMPLETE) {
#ifdef DEBUG
                printf("scsi_request_sense: Status -- 0x%x\n", status);
#endif
                return status;
        } else {
                return lock;
        }
}

int
scsi_immed_command(int ctlr, int target, int lun, struct scsi_generic_cdb *cdb,
    uint8_t *buf, unsigned int len)
{
        int status;
        volatile int lock;

#ifdef DEBUG
        printf("scsi_immed_command( %d, %d, %d, cdb(%d), buf, %d): Start\n",
            ctlr, target, lun, cdb->len, len);
#endif

        cdb->cdb[1] |= lun << 5;

        if (scrun(ctlr, target, (void *)&cdb->cdb[0], cdb->len, buf, len,
            &lock) == 0) {
#ifdef DEBUG
                printf("scsi_immed_command: Command Transfer Failed.\n");
#endif
                return -1;
        }

        while ((lock == SC_IN_PROGRESS) || (lock == SC_DISCONNECTED))
                DELAY(10);

        status = scfinish(ctlr);

        if (lock == SC_IO_COMPLETE) {
#ifdef DEBUG
                printf("scsi_immed_command: Status -- 0x%x\n", status);
#endif
                return status;
        } else {
                return lock;
        }
}

int
scsi_format_unit(int ctlr, int target, int lun)
{
        static struct scsi_cdb6 cdb = { CMD_FORMAT_UNIT, 0, 0, 0, 0, 0 };
        int status;
        volatile int lock;
#ifdef DEBUG
        int count = 0;
#endif

#ifdef DEBUG
        printf("scsi_format_unit( %d, %d, %d): Start\n", ctlr, target, lun);
#endif

        cdb.lun = lun;

        if (scrun(ctlr, target, (void *)&cdb, 6, NULL, 0, &lock) == 0) {
#ifdef DEBUG
                printf("scsi_format_unit: Command Transfer Failed.\n");
#endif
                return -1;
        }

        while ((lock == SC_IN_PROGRESS) || (lock == SC_DISCONNECTED)) {
                DELAY(1000000);
#ifdef DEBUG
                if ((++count % 60) == 0)
                        printf("scsi_format_unit: %d\n", count / 60);
#endif
        }

        status = scfinish(ctlr);

        if (lock == SC_IO_COMPLETE) {
#ifdef DEBUG
                printf("scsi_format_unit: Status -- 0x%x\n", status);
#endif
                return status;
        } else {
                return lock;
        }
}


/*
 * Interrupt Routine
 */

int
scintr(void)
{
        struct scsi_softc *hs;
        struct scsidevice *hd;
        uint8_t ints, temp;
        int i;
        uint8_t *buf;
        int len;

        for (i = 0; i < NSC; i++) {
                hs = &scsi_softc[i];
                hd = hs->sc_spc;
                if ((ints = hd->scsi_ints) != 0)
                        goto get_intr;
        }

        /* Unknown interrupt occurred */
        return -1;


        /*
         * Interrupt
         */

 get_intr:
#ifdef DEBUG
        printf("scintr: INTS 0x%x, SSTS 0x%x,  PCTL 0x%x,  PSNS 0x%x    0x%x\n",
            ints, hd->scsi_ssts, hd->scsi_pctl, hd->scsi_psns, hs->sc_phase);
#endif
        if (ints & INTS_RESEL) {
                if (hs->sc_phase == BUS_FREE_PHASE) {
                        temp = hd->scsi_temp & ~(1 << SCSI_ID);
                        for (i = 0; temp != 1; i++) {
                                temp >>= 1;
                        }
                        hs->sc_target = i;
                        *(hs->sc_lock) = SC_IN_PROGRESS;
                } else
                        goto abort;
        } else if (ints & INTS_DISCON) {
                if ((hs->sc_msg[0] == MSG_CMD_COMPLETE) ||
                    (hs->sc_msg[0] == MSG_DISCONNECT)) {
                        hs->sc_phase  = BUS_FREE_PHASE;
                        hs->sc_target = SCSI_ID;
                        if (hs->sc_msg[0] == MSG_CMD_COMPLETE) {
                                /* SCSI IO complete */
                                *(hs->sc_lock) = SC_IO_COMPLETE;
                        } else {
                                /* Disconnected from Target */
                                *(hs->sc_lock) = SC_DISCONNECTED;
                        }
                        hd->scsi_ints = ints;
                        return 0;
                } else
                        goto abort;
        } else if (ints & INTS_CMD_DONE) {
                if (hs->sc_phase == BUS_FREE_PHASE)
                        goto abort;
                else if (hs->sc_phase == MESG_IN_PHASE) {
                        hd->scsi_scmd = SCMD_RST_ACK;
                        hd->scsi_ints = ints;
                        hs->sc_phase  = hd->scsi_psns & PHASE;
                        return 0;
                }
                if (hs->sc_flags & SC_SEL_TIMEOUT)
                        hs->sc_flags &= ~SC_SEL_TIMEOUT;
        } else if (ints & INTS_SRV_REQ) {
                if (hs->sc_phase != MESG_IN_PHASE)
                        goto abort;
        } else if (ints & INTS_TIMEOUT) {
                if (hs->sc_phase == ARB_SEL_PHASE) {
                        if (hs->sc_flags & SC_SEL_TIMEOUT) {
                                hs->sc_flags &= ~SC_SEL_TIMEOUT;
                                hs->sc_phase  = BUS_FREE_PHASE;
                                hs->sc_target = SCSI_ID;
                                /* Such SCSI Device is not connected. */
                                *(hs->sc_lock) = SC_DEV_NOT_FOUND;
                                hd->scsi_ints = ints;
                                return 0;
                        } else {
                                /* wait more 250 usec */
                                hs->sc_flags |= SC_SEL_TIMEOUT;
                                hd->scsi_temp = 0;
                                hd->scsi_tch  = 0;
                                hd->scsi_tcm  = 0x06;
                                hd->scsi_tcl  = 0x40;
                                hd->scsi_ints = ints;
                                return 0;
                        }
                } else
                        goto abort;
        } else
                goto abort;

        hd->scsi_ints = ints;

        /*
         * Next SCSI Transfer
         */

        while ((hd->scsi_psns & PSNS_REQ) == 0) {
                DELAY(1);
        }

        hs->sc_phase = hd->scsi_psns & PHASE;

        if ((hs->sc_phase == DATA_OUT_PHASE) ||
            (hs->sc_phase == DATA_IN_PHASE)) {
                len = hs->sc_len;
                buf = hs->sc_buf;
        } else if (hs->sc_phase == CMD_PHASE) {
                len = hs->sc_cdblen;
                buf = hs->sc_cdb;
        } else if (hs->sc_phase == STATUS_PHASE) {
                len = 1;
                buf = &hs->sc_stat;
        } else {
                len = 1;
                buf = hs->sc_msg;
        }

        ixfer_start(hd, len, hs->sc_phase, 0);
        if (hs->sc_phase & PHASE_IO)
                ixfer_in(hd, len, buf);
        else
                ixfer_out(hd, len, buf);

        return 0;

        /*
         * SCSI Abort
         */
 abort:
        /* SCSI IO failed */
        scabort(hs);
        hd->scsi_ints = ints;
        *(hs->sc_lock) = SC_IO_FAILED;
        return -1;
}