io/cpqary3/cpqary3_transport.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (C) 2013 Hewlett-Packard Development Company, L.P.
 */

#include <sys/sdt.h>
#include "cpqary3.h"

/*
 * Local Functions Definitions
 */

static int cpqary3_tgt_init(dev_info_t *, dev_info_t *, scsi_hba_tran_t *,
    struct scsi_device *);
static int cpqary3_tgt_probe(struct scsi_device *, int (*)());
static int cpqary3_transport(struct scsi_address *, struct scsi_pkt *);
static int cpqary3_reset(struct scsi_address *, int);
static int cpqary3_abort(struct scsi_address *, struct scsi_pkt *);
static int cpqary3_getcap(struct scsi_address *, char *, int);
static int cpqary3_setcap(struct scsi_address *, char *, int, int);
static int cpqary3_dma_alloc(cpqary3_t *, struct scsi_pkt *,
    struct buf *, int, int (*)());
static int cpqary3_dma_move(struct scsi_pkt *, struct buf *, cpqary3_t *);
static int cpqary3_handle_flag_nointr(cpqary3_cmdpvt_t *, struct scsi_pkt *);
static int cpqary3_poll(cpqary3_t *, uint32_t);
static void cpqary3_dmafree(struct scsi_address *, struct scsi_pkt *);
static void cpqary3_dma_sync(struct scsi_address *, struct scsi_pkt *);
static void cpqary3_destroy_pkt(struct scsi_address *, struct scsi_pkt *);
static struct scsi_pkt *cpqary3_init_pkt(struct scsi_address *,
    struct scsi_pkt *, struct buf *, int, int, int, int, int (*callback)(),
    caddr_t);
static int cpqary3_additional_cmd(struct scsi_pkt *scsi_pktp, cpqary3_t *);
void cpqary3_oscmd_complete(cpqary3_cmdpvt_t *);
static uint8_t cpqary3_is_scsi_read_write(struct scsi_pkt *scsi_pktp);

/*
 * External Variable Declarations
 */

extern ddi_dma_attr_t cpqary3_dma_attr;

/*
 * Function :   cpqary3_init_hbatran
 * Description  :   This routine initializes the transport vector in the
 *          SCSA architecture for entry ponts in this driver.
 * Called By    :   cpqary3_attach()
 * Parameters   :   per_controller
 * Calls    :   None
 * Return Values:   None
 */
void
cpqary3_init_hbatran(cpqary3_t *ctlr)
{
    scsi_hba_tran_t *hba_tran;

    ASSERT(ctlr != NULL);

    hba_tran = ctlr->hba_tran;

    /*
     * Memory for the transport vector has been allocated by now.
     * initialize all the entry points in this vector
     */

    hba_tran->tran_hba_private = (void *)ctlr;

    /* Target Driver Instance Initialization */
    hba_tran->tran_tgt_init = cpqary3_tgt_init;
    hba_tran->tran_tgt_probe = cpqary3_tgt_probe;

    /* Resource Allocation */
    hba_tran->tran_init_pkt = cpqary3_init_pkt;
    hba_tran->tran_destroy_pkt = cpqary3_destroy_pkt;
    hba_tran->tran_sync_pkt = cpqary3_dma_sync;
    hba_tran->tran_dmafree = cpqary3_dmafree;

    /* Command Transport */
    hba_tran->tran_start = cpqary3_transport;

    /* Capability Management */
    hba_tran->tran_getcap = cpqary3_getcap;
    hba_tran->tran_setcap = cpqary3_setcap;

    /* Abort and Reset */
    hba_tran->tran_reset = cpqary3_reset;
    hba_tran->tran_abort = cpqary3_abort;
}

/*
 * Function :   cpqary3_tgt_init ()
 * Description  :   This routine validates the target ID.
 * Called By    :   cpqary3_init_hbatran()
 * Parameters   :   HBA-instance, target instance, transport vector,
 *          scsi-device structure
 * Calls    :   cpqary3_detect_target_geometry(),
 *          cpqary3_probe4targets()
 * Return Values:   DDI_SUCCESS : A Target exists at this ID.
 *          DDI_FAILURE : No such target exists.
 */
/* ARGSUSED */
static int
cpqary3_tgt_init(dev_info_t *hba_dip, dev_info_t *tgt_dip,
    scsi_hba_tran_t *hba_tran, struct scsi_device *sd)
{
    uint32_t    tid = SD2TGT(sd);
    uint32_t    lun = SD2LUN(sd);
    cpqary3_t   *ctlr;

    ctlr = (cpqary3_t *)hba_tran->tran_hba_private;

    /* HPQacucli Changes */

    extern int8_t   cpqary3_detect_target_geometry(cpqary3_t *);
    if ((CPQARY3_SUCCESS == cpqary3_probe4targets(ctlr)) &&
        (ctlr->num_of_targets > 0)) {
        (void) cpqary3_detect_target_geometry(ctlr);
    }

    /* HPQacucli Changes */
    /*
     * Validate the Target ID
     * Validate Lun --Ver1.10--
     * If not a valid target id, return FAILURE.
     * Derieve the per-controller
     */

    if ((tid >= CPQARY3_MAX_TGT) || (lun != 0)) {
        DTRACE_PROBE2(tgt_init_notsup,
            cpqary3_t *, ctlr, uint32_t, tid);
        return (DDI_FAILURE);
    }

    /*
     * Check to see if a target structure corrresponding to this
     * target Id exists.(support only for Logical Drives and Controller)
     * if target exists, update target flags, return SUCCESS
     * is target does not exist, return FAILURE
     */

    mutex_enter(&ctlr->sw_mutex);

    if (!(ctlr->cpqary3_tgtp[tid])) {
        mutex_exit(&ctlr->sw_mutex);
        return (DDI_FAILURE);
    }

    ctlr->cpqary3_tgtp[tid]->tgt_dip = tgt_dip;
    ctlr->cpqary3_tgtp[tid]->ctlr_flags = CPQARY3_CAP_DISCON_ENABLED |
        CPQARY3_CAP_SYNC_ENABLED | CPQARY3_CAP_WIDE_XFER_ENABLED |
        CPQARY3_CAP_ARQ_ENABLED;

    mutex_exit(&ctlr->sw_mutex);

    DTRACE_PROBE1(tgt_init_done, uint32_t, tid);

    return (DDI_SUCCESS);
}

/*
 * Function :   cpqary3_tgt_probe()
 * Description  :   This routine probes into the Target Details.
 * Called By    :   cpqary3_init_hbatran()
 * Parameters   :   scsi-device structure, calling function if any
 * Calls    :   None
 * Return Values:   value returned by scsi_hba_probe()
 */
static int
cpqary3_tgt_probe(struct scsi_device *sd, int (*waitfunc)())
{
#ifdef CPQARY3_DEBUG
    int status;
#endif

    /*
     * Probe for the presence of the target, using the scsi_hba_probe().
     * It inturn issues the SCSI inquiry command that is serviced by our
     * driver
     */

    /* HPQacucli Changes */
    extern int8_t       cpqary3_detect_target_geometry(cpqary3_t *);
    struct scsi_hba_tran    *hba_tran = sd->sd_address.a_hba_tran;
    cpqary3_t       *ctlr = hba_tran->tran_hba_private;

    if ((CPQARY3_SUCCESS == cpqary3_probe4targets(ctlr)) &&
        (ctlr->num_of_targets > 0)) {
        (void) cpqary3_detect_target_geometry(ctlr);
    }
    /* HPQacucli Changes */

    return (scsi_hba_probe(sd, waitfunc));

#ifdef CPQARY3_DEBUG

    /* Comment the previous line of code */
    status = scsi_hba_probe(sd, waitfunc);
    cmn_err(CE_CONT, "CPQary3 : _tgt_probe : target = %d \n", SD2TGT(sd));
    cmn_err(CE_CONT, "CPQary3 : _tgt_probe : scsi_hba_probe returned %d \n",
        status);
    cmn_err(CE_CONT, "CPQary3 : _tgt_probe : Leaving \n");
    return (status);

#endif
}

/*
 * Function :   cpqary3_init_pkt
 * Description  :   This routine allocates resources for a SCSI packet.
 * Called By    :   cpqary3_init_pkt()
 * Parameters   :   SCSI address, SCSI packet, buffer, CDB length,
 *          SCB length, driver private length, flags modifier,
 *          callback function, arguement for the callback function
 * Calls    :   cpqary3_dma_alloc(), cpqary3_dma_move()
 * Return Values:   allocated SCSI packet / NULL
 */
/* ARGSUSED */
static struct scsi_pkt *
cpqary3_init_pkt(struct scsi_address *sa, struct scsi_pkt *scsi_pktp,
    struct buf *bp, int cmdlen, int statuslen, int tgtlen,
    int flags, int (*callback)(), caddr_t arg)
{
    cpqary3_t   *cpqary3p;
    dev_info_t  *dip;
    cpqary3_pkt_t   *cpqary3_pktp;
    struct scsi_pkt *new_scsi_pktp;

    ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);

    cpqary3p = SA2CTLR(sa);
    dip = cpqary3p->dip;

    /*
     * If the SCSI packet is NULL, allocate frresh resources to it.
     * Else, get the next available resources for the same
     */

    if (!scsi_pktp) {
        scsi_pktp = scsi_hba_pkt_alloc(dip, sa, cmdlen, statuslen,
            tgtlen, sizeof (cpqary3_pkt_t), callback, NULL);
        if (!scsi_pktp)
            return (NULL);

        cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;
        bzero(cpqary3_pktp, sizeof (cpqary3_pkt_t));

        cpqary3_pktp->scsi_cmd_pkt = scsi_pktp;

        /*
         * Store the CDB length and sense data length in the
         * pkt private
         */
        cpqary3_pktp->cdb_len = cmdlen;
        cpqary3_pktp->scb_len = statuslen;
        cpqary3_pktp->cmd_dmahandle = NULL;
        cpqary3_pktp->memp = (cpqary3_cmdpvt_t *)NULL;

        /*
         * Initialize to NULL all the fields of scsi_pktp, except
         * pkt_scbp, pkt_cdbp, pkt_ha_private and pkt_private members.
         */
        scsi_pktp->pkt_address = *sa;
        scsi_pktp->pkt_comp = (void (*) ())NULL;
        scsi_pktp->pkt_flags = 0;
        scsi_pktp->pkt_time = 0;
        scsi_pktp->pkt_resid = 0;
        scsi_pktp->pkt_statistics = 0;
        scsi_pktp->pkt_state = 0;
        scsi_pktp->pkt_reason = 0;

        if (flags & PKT_CONSISTENT)
            cpqary3_pktp->cmd_flags |=  DDI_DMA_CONSISTENT;

        if (flags & PKT_DMA_PARTIAL)
            cpqary3_pktp->cmd_flags |= DDI_DMA_PARTIAL;

        new_scsi_pktp = scsi_pktp;
    } else {
        new_scsi_pktp = NULL;
        cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;
    }

    cpqary3_pktp->bf = bp;

    /*
     * If any I/O is desired, Allocate/Move DMA resources for the SCSI
     * packet
     * If first time allocation for this SCSI packet, allocate fresh DMA
     * Else, move the already allocated DMA resources
     */
    if (bp && bp->b_bcount != 0) { /* I/O is desired */
        if (!cpqary3_pktp->cmd_dmahandle) { /* First time allocation */
            if (cpqary3_dma_alloc(cpqary3p, scsi_pktp,
                bp, flags, callback) == CPQARY3_FAILURE) {
                if (new_scsi_pktp)
                    scsi_hba_pkt_free(sa, new_scsi_pktp);
                return ((struct scsi_pkt *)NULL);
            }
        } else {
            ASSERT(new_scsi_pktp == NULL);
            if (CPQARY3_FAILURE ==
                cpqary3_dma_move(scsi_pktp, bp, cpqary3p)) {
                return ((struct scsi_pkt *)NULL);
            }
        }
    }

    return (scsi_pktp);
}

/*
 * Function :   cpqary3_dma_alloc()
 * Description  :   This routine services requests for memory (dynamic)
 *          as and when required by the OS.
 * Called By    :   cpqary3_init_pkt()
 * Parameters   :   per-controller, SCSI packet, buffer, flag modifier,
 *          callback function
 * Calls    :   None
 * Return Values:   SUCCESS / FAILURE
 */
static int
cpqary3_dma_alloc(cpqary3_t *cpqary3p, struct scsi_pkt *scsi_pktp,
    struct buf *bp, int flags, int (*callback)())
{
    int32_t     (*cb)(caddr_t);
    int32_t     retvalue;
    uint32_t    i = 0;
    uint32_t    dma_flags;
    cpqary3_pkt_t   *cpqary3_pktp;
    ddi_dma_attr_t  tmp_dma_attr;

    cpqary3_pktp = (cpqary3_pkt_t *)scsi_pktp->pkt_ha_private;

    ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC);
    /*
     * Record the direction of the data transfer, so that it
     * can be used in appropriate synchronization during cpqary3_sync_pkt()
     */
    if (bp->b_flags & B_READ) {
        cpqary3_pktp->cmd_flags &= ~CFLAG_DMASEND;
        dma_flags = DDI_DMA_READ;
    } else {
        cpqary3_pktp->cmd_flags |= CFLAG_DMASEND;
        dma_flags = DDI_DMA_WRITE;
    }

    if (flags & PKT_CONSISTENT) {
        cpqary3_pktp->cmd_flags |= CFLAG_CMDIOPB;
        dma_flags |= DDI_DMA_CONSISTENT;
    }

    if (flags & PKT_DMA_PARTIAL) {
        dma_flags |= DDI_DMA_PARTIAL;
    }

    tmp_dma_attr = cpqary3_dma_attr;

    /* SG */
    tmp_dma_attr.dma_attr_sgllen = cpqary3p->sg_cnt;
    /* SG */

    cb = (callback == NULL_FUNC) ? DDI_DMA_DONTWAIT : DDI_DMA_SLEEP;

    /*
     * DMA resources are allocated thru a 2 step protocol :
     * - allocate a DMA handle
     * - bind the buffer to the handle
     * If both the steps succeed, we have succeeded in allocating resources
     */

    if (DDI_SUCCESS != (retvalue = ddi_dma_alloc_handle(cpqary3p->dip,
        &tmp_dma_attr, cb, CPQARY3_DMA_NO_CALLBACK,
        &cpqary3_pktp->cmd_dmahandle))) {
        switch (retvalue) {
        case DDI_DMA_NORESOURCES:
            /*
             * No Resources are available to be allocated
             */
            bioerror(bp, CPQARY3_BUFFER_ERROR_CLEAR);
            break;

        case DDI_DMA_BADATTR:
            /*
             * The attributes stated in our DMA attribute
             * structure is such that potential DMA resources can
             * not be allocated.
             */
            cmn_err(CE_CONT, "CPQary3: DmaAlloc: "
                "AllocHandle Failed BadAttr\n");
            bioerror(bp, EFAULT);
            break;

        default:
            /*
             * There is no other possible return value
             */
            cmn_err(CE_WARN,
                "CPQary3: dma_alloc: Unexpected Return Value %x "
                "From call to Allocate DMA Handle \n", retvalue);
            break;
        }
        return (CPQARY3_FAILURE);
    }

    retvalue = ddi_dma_buf_bind_handle(cpqary3_pktp->cmd_dmahandle, bp,
        dma_flags, cb, CPQARY3_DMA_NO_CALLBACK,
        &cpqary3_pktp->cmd_dmacookies[0], &cpqary3_pktp->cmd_ncookies);

    switch (retvalue) {
    case DDI_DMA_PARTIAL_MAP :
    case DDI_DMA_MAPPED :
        if (DDI_DMA_PARTIAL_MAP == retvalue) {
            if (ddi_dma_numwin(cpqary3_pktp->cmd_dmahandle,
                &cpqary3_pktp->cmd_nwin) == DDI_FAILURE) {
                cmn_err(CE_PANIC, "CPQary3: Retrieval of DMA "
                    "windows number failed");
            }

            if (ddi_dma_getwin(cpqary3_pktp->cmd_dmahandle,
                cpqary3_pktp->cmd_curwin,
                &cpqary3_pktp->cmd_dma_offset,
                &cpqary3_pktp->cmd_dma_len,
                &cpqary3_pktp->cmd_dmacookies[0],
                &cpqary3_pktp->cmd_ncookies) == DDI_FAILURE) {
                cmn_err(CE_PANIC, "CPQary3: Activation of New "
                    "DMA Window Failed");
            }
        } else {
            cpqary3_pktp->cmd_nwin = 1;
            cpqary3_pktp->cmd_dma_len = 0;
            cpqary3_pktp->cmd_dma_offset = 0;
        }

        cpqary3_pktp->cmd_dmacount = 0;
        i = 0;
        for (;;) {
            cpqary3_pktp->cmd_dmacount +=
                cpqary3_pktp->cmd_dmacookies[i++].dmac_size;
            /* SG */
            /* Check Out for Limits */
            if (i == cpqary3p->sg_cnt ||
                i == cpqary3_pktp->cmd_ncookies)
                break;
            /* SG */

            ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
                &cpqary3_pktp->cmd_dmacookies[i]);
        }

        cpqary3_pktp->cmd_cookie = i;
        cpqary3_pktp->cmd_cookiecnt = i;
        cpqary3_pktp->cmd_flags |= CFLAG_DMAVALID;

        scsi_pktp->pkt_resid =
            bp->b_bcount - cpqary3_pktp->cmd_dmacount;

        return (CPQARY3_SUCCESS);

    case DDI_DMA_NORESOURCES:
        bioerror(bp, CPQARY3_BUFFER_ERROR_CLEAR);
        break;

    case DDI_DMA_NOMAPPING:
        bioerror(bp, EFAULT);
        break;

    case DDI_DMA_TOOBIG:
        bioerror(bp, EINVAL);
        break;

    case DDI_DMA_INUSE:
        cmn_err(CE_PANIC, "CPQary3: Another I/O transaction "
            "is using the DMA handle");

    default:
        cmn_err(CE_PANIC, "CPQary3: Unexpected ERROR "
            "returned from Call to Bind Buffer "
            "to Handle : 0x%X", i);
    }

    ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);
    cpqary3_pktp->cmd_dmahandle = NULL;
    cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;

    return (CPQARY3_FAILURE);

}

/*
 * Function :   cpqary3_dma_move()
 * Description  :   This routine gets the next DMA window.
 * Called By    :   cpqary3_init_pkt()
 * Parameters   :   per-controller, SCSI packet, buffer
 * Calls    :   None
 * Return Values:   SUCCESS / FAILURE
 */
static int
cpqary3_dma_move(struct scsi_pkt *scsi_pktp, struct buf *bp,
    cpqary3_t *cpqary3p)
{
    uint32_t        i = 0;
    cpqary3_pkt_t   *cpqary3_pktp;

    cpqary3_pktp = PKT2PVTPKT(scsi_pktp);

    /*
     * If there are no more cookies remaining in this window,
     * must move to the next window first.
     */
    if (cpqary3_pktp->cmd_cookie == cpqary3_pktp->cmd_ncookies) {
        /* For small pkts, leave things where they are */
        if ((cpqary3_pktp->cmd_curwin == cpqary3_pktp->cmd_nwin) &&
            (cpqary3_pktp->cmd_nwin == 1))
            return (CPQARY3_SUCCESS);

        /* Shall not be able to move if last window */
        if (++cpqary3_pktp->cmd_curwin >= cpqary3_pktp->cmd_nwin)
            return (CPQARY3_FAILURE);

        if (ddi_dma_getwin(cpqary3_pktp->cmd_dmahandle,
            cpqary3_pktp->cmd_curwin, &cpqary3_pktp->cmd_dma_offset,
            &cpqary3_pktp->cmd_dma_len,
            &cpqary3_pktp->cmd_dmacookies[0],
            &cpqary3_pktp->cmd_ncookies) == DDI_FAILURE)
            return (CPQARY3_FAILURE);

        cpqary3_pktp->cmd_cookie = 0;
    } else {
        /* Still more cookies in this window - get the next one */
        ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
            &cpqary3_pktp->cmd_dmacookies[0]);
    }

    /* Get remaining cookies in this window, up to our maximum */
    for (;;) {
        cpqary3_pktp->cmd_dmacount +=
            cpqary3_pktp->cmd_dmacookies[i++].dmac_size;
        cpqary3_pktp->cmd_cookie++;
        /* SG */
        /* no. of DATA SEGMENTS */
        if (i == cpqary3p->sg_cnt ||
            cpqary3_pktp->cmd_cookie == cpqary3_pktp->cmd_ncookies)
            break;
        /* SG */

        ddi_dma_nextcookie(cpqary3_pktp->cmd_dmahandle,
            &cpqary3_pktp->cmd_dmacookies[i]);
    }

    cpqary3_pktp->cmd_cookiecnt = i;
    scsi_pktp->pkt_resid = bp->b_bcount - cpqary3_pktp->cmd_dmacount;

    return (CPQARY3_SUCCESS);

}

/*
 * Function :   cpqary3_transport()
 * Description  :   This routine services requests from the OS that are
 *          directed towards the targets.(any SCSI command)
 * Called By    :   kernel
 * Parameters   :   SCSI address, SCSI packet, buffer
 * Calls    :   cpqary3_build_iop, cpqary3_add2submitted
 * Return Values:   TRAN_ACCEPT : The driver accepts the command.
 *          TRAN_BUSY   : Required resources not available
 *                  at the moment.
 *          TRAN_FATAL_ERROR: A target no longer exists.
 */
static int
cpqary3_transport(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
{
    cpqary3_t       *ctlr;
    cpqary3_pkt_t       *cpqary3_pktp;
    cpqary3_tgt_t       *tgtp;
    cpqary3_cmdpvt_t    *memp;

    ASSERT(sa != NULL);
    ctlr = SA2CTLR(sa);
    cpqary3_pktp = PKT2PVTPKT(scsi_pktp);
    tgtp = ctlr->cpqary3_tgtp[SA2TGT(sa)];

    if (!tgtp)
        return (TRAN_FATAL_ERROR);

    if (tgtp->type == CPQARY3_TARGET_NONE)
        return (TRAN_FATAL_ERROR);

    if (cpqary3_additional_cmd(scsi_pktp, ctlr))
        return (TRAN_ACCEPT);

    /*
     * Attempt to occupy a free command memory block
     * If not successful, return TRAN_BUSY
     * Else, build the Command
     * Submit it to the controller
     * If NO_INTR flag is set, wait for the completion of the command and
     * when the command completes, update packet values appropriately and
     * return TRAN_ACCEPT.
     * Make an entry in the submitted Q
     * return TRAN_ACCEPT
     */

    if (NULL == (memp = cpqary3_cmdlist_occupy(ctlr)))
        return (TRAN_BUSY);

    cpqary3_pktp->memp = memp;
    memp->pvt_pkt = cpqary3_pktp;

    if ((cpqary3_pktp->cmd_flags & DDI_DMA_CONSISTENT) &&
        cpqary3_pktp->cmd_dmahandle) {
        (void) ddi_dma_sync(cpqary3_pktp->cmd_dmahandle, 0, 0,
            DDI_DMA_SYNC_FORDEV);
    }
    /* SG */
    ASSERT(cpqary3_pktp->cmd_cookiecnt <= ctlr->sg_cnt);
    /* SG */

    /* PERF */
    memp->complete = cpqary3_oscmd_complete;
    /* PERF */

    switch (cpqary3_build_cmdlist(memp, SA2TGT(sa))) {
    case CPQARY3_SUCCESS :
        if (scsi_pktp->pkt_flags & FLAG_NOINTR) {
            return (cpqary3_handle_flag_nointr(memp, scsi_pktp));
        }
        cpqary3_pktp->cmd_start_time = ddi_get_lbolt();
        mutex_enter(&ctlr->hw_mutex);
        /* CONTROLLER_LOCKUP */
        if (EIO == cpqary3_submit(ctlr, memp->cmdlist_phyaddr)) {
            mutex_exit(&ctlr->hw_mutex);
            cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
            return (TRAN_FATAL_ERROR);
        }
        /* CONTROLLER_LOCKUP */
        mutex_exit(&ctlr->hw_mutex);
        break;
    case CPQARY3_FAILURE :
        cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
        return (TRAN_FATAL_ERROR);
    default: /* Never occurs */
        cmn_err(CE_NOTE, "CPQary3 : Transport : Unexpected Error");
        return (TRAN_FATAL_ERROR);
    }

    return (TRAN_ACCEPT);
}

/*
 * Function :   cpqary3_dmafree
 * Description  :   This routine de-allocates previously allocated
 *          DMA resources.
 * Called By    :   kernel
 * Parameters   :   SCSI address, SCSI packet
 * Calls    :   None
 * Return Values:   None
 */
/* ARGSUSED */
static void
cpqary3_dmafree(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
{
    cpqary3_pkt_t   *cpqary3_pktp;

    cpqary3_pktp = PKT2PVTPKT(scsi_pktp);

    /*
     * If any DMA was succesfully attempted earlier, free all allocated
     * resources
     */

    if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
        if (!cpqary3_pktp->cmd_dmahandle) {
            DTRACE_PROBE(dmafree_null);
            return;
        }
        cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;
        (void) ddi_dma_unbind_handle(cpqary3_pktp->cmd_dmahandle);
        ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);
        cpqary3_pktp->cmd_dmahandle = NULL;
    }
}

/*
 * Function :   cpqary3_dma_sync
 * Description  :   This routine synchronizes the CPU's / HBA's view of
 *          the data associated with the pkt, typically by calling
 *          ddi_dma_sync().
 * Called By    :   kernel
 * Parameters   :   SCSI address, SCSI packet
 * Calls    :   None
 * Return Values:   None
 */
/* ARGSUSED */
static void
cpqary3_dma_sync(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
{
    cpqary3_pkt_t   *cpqary3_pktp = PKT2PVTPKT(scsi_pktp);

    /*
     * Check whether DMA was attempted successfully earlier
     * If yes and
     * if the command flags is write, then synchronise the device else
     * synchronise the CPU
     */

    if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
        (void) ddi_dma_sync(cpqary3_pktp->cmd_dmahandle,
            cpqary3_pktp->cmd_dma_offset, cpqary3_pktp->cmd_dma_len,
            (cpqary3_pktp->cmd_flags & CFLAG_DMASEND) ?
            DDI_DMA_SYNC_FORDEV : DDI_DMA_SYNC_FORCPU);
    }
}

/*
 * Function :   cpqary3_destroy_pkt
 * Description  :   This routine de-allocates previously allocated
 *          resources for the SCSI packet.
 * Called By    :   kernel
 * Parameters   :   SCSI address, SCSI packet
 * Calls    :   None
 * Return Values:   None
 */
static void
cpqary3_destroy_pkt(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
{
    cpqary3_pkt_t   *cpqary3_pktp;

    cpqary3_pktp = PKT2PVTPKT(scsi_pktp);

    /*
     * Deallocate DMA Resources, if allocated.
     * Free the SCSI Packet.
     */

    if (cpqary3_pktp->cmd_flags & CFLAG_DMAVALID) {
        if (!cpqary3_pktp->cmd_dmahandle) {
            DTRACE_PROBE(dmafree_null);
        } else {
            cpqary3_pktp->cmd_flags &= ~CFLAG_DMAVALID;

            (void) ddi_dma_unbind_handle(
                cpqary3_pktp->cmd_dmahandle);
            ddi_dma_free_handle(&cpqary3_pktp->cmd_dmahandle);

            cpqary3_pktp->cmd_dmahandle = NULL;
        }
    }

    scsi_hba_pkt_free(sa, scsi_pktp);
}

/*
 * Function :   cpqary3_reset
 * Description  :   This routine resets a SCSI bus/target.
 * Called By    :   kernel
 * Parameters   :   SCSI address, reset level required
 * Calls    :   None
 * Return Values:   SUCCESS
 */
/* ARGSUSED */
static int
cpqary3_reset(struct scsi_address *sa, int level)
{
    /*
     * Fix for Crash seen during RAID 0 Drive removal -
     * just return CPQARY3_SUCCESS on reset request
     */
    return (CPQARY3_SUCCESS);
}

/*
 * Function :   cpqary3_abort()
 * Description  :   This routine aborts a particular command or all commands
 *          directed towards a target.
 * Called By    :   kernel
 * Parameters   :   SCSI address, SCSI packet
 * Calls    :   None
 * Return Values:   SUCCESS / FAILURE
 *          [ abort of concernd command(s) was a success or
 *          a failure. ]
 */
static int
cpqary3_abort(struct scsi_address *sa, struct scsi_pkt *scsi_pktp)
{
    uint32_t    tid;
    cpqary3_t   *ctlr;

    ASSERT(sa != NULL);
    tid  = SA2TGT(sa);
    ctlr = SA2CTLR(sa);

    /*
     * If SCSI packet exists, abort that particular command.
     * Else, abort all existing commands to the target
     * In either of the cases, we shall have to wait after the abort
     * functions are called to return the status.
     */

    if (!scsi_pktp) {
        return (cpqary3_send_abortcmd(ctlr, tid,
            (CommandList_t *)NULL));
    } else {
        return (cpqary3_send_abortcmd(ctlr, tid, SP2CMD(scsi_pktp)));
    }
}

/*
 * Function :   cpqary3_getcap
 * Description  :   This routine is called to get the current value of a
 *          capability.(SCSI transport capability)
 * Called By    :   kernel
 * Parameters   :   SCSI address, capability identifier, target(s) affected
 * Calls    :   None
 * Return Values:   current value of capability / -1 (if unsupported)
 */
static int
cpqary3_getcap(struct scsi_address *sa, char *capstr, int tgtonly)
{
    int     index;
    cpqary3_t   *ctlr = SA2CTLR(sa);
    cpqary3_tgt_t   *tgtp = ctlr->cpqary3_tgtp[SA2TGT(sa)];

    /*
     * If requested Capability is not supported, return -1.
     */
    if (DDI_FAILURE == (index = scsi_hba_lookup_capstr(capstr)))
        return (CAP_NOT_DEFINED);

    /*
     * Getting capability for a particulat target is supported
     * the generic form of tran_getcap() is unsupported(for all targets)
     * If directed towards a particular target, return current capability.
     */
    if (tgtonly == 0) { /* all targets */
        DTRACE_PROBE1(getcap_alltgt, int, index);
        return (CAP_NOT_DEFINED);
    }

    DTRACE_PROBE1(getcap_index, int, index);

    switch (index) {
    case SCSI_CAP_DMA_MAX:
        return ((int)cpqary3_dma_attr.dma_attr_maxxfer);
    case SCSI_CAP_DISCONNECT:
        return (tgtp->ctlr_flags & CPQARY3_CAP_DISCON_ENABLED);
    case SCSI_CAP_SYNCHRONOUS:
        return (tgtp->ctlr_flags & CPQARY3_CAP_SYNC_ENABLED);
    case SCSI_CAP_WIDE_XFER:
        return (tgtp->ctlr_flags & CPQARY3_CAP_WIDE_XFER_ENABLED);
    case SCSI_CAP_ARQ:
        return ((tgtp->ctlr_flags & CPQARY3_CAP_ARQ_ENABLED) ? 1 : 0);
    case SCSI_CAP_INITIATOR_ID:
        return (CTLR_SCSI_ID);
    case SCSI_CAP_UNTAGGED_QING:
        return (1);
    case SCSI_CAP_TAGGED_QING:
        return (1);
    case SCSI_CAP_SECTOR_SIZE:
        return (cpqary3_dma_attr.dma_attr_granular);
    case SCSI_CAP_TOTAL_SECTORS:
        return (CAP_NOT_DEFINED);
    case SCSI_CAP_GEOMETRY:
        return (cpqary3_target_geometry(sa));
    case SCSI_CAP_RESET_NOTIFICATION:
        return (0);
    default:
        return (CAP_NOT_DEFINED);
    }
}

/*
 * Function :   cpqary3_setcap
 * Description  :   This routine is called to set the current value of a
 *          capability.(SCSI transport capability)
 * Called By    :   kernel
 * Parameters   :   SCSI address, capability identifier,
 *          new capability value, target(s) affected
 * Calls    :   None
 * Return Values:   SUCCESS / FAILURE / -1 (if capability is unsupported)
 */
/* ARGSUSED */
static int
cpqary3_setcap(struct scsi_address *sa, char *capstr, int value, int tgtonly)
{
    int index;
    int retstatus = CAP_NOT_DEFINED;

    /*
     * If requested Capability is not supported, return -1.
     */
    if ((index = scsi_hba_lookup_capstr(capstr)) == DDI_FAILURE)
        return (retstatus);

    /*
     * Setting capability for a particulat target is supported
     * the generic form of tran_setcap() is unsupported(for all targets)
     * If directed towards a particular target, set & return current
     * capability.
     */
    if (!tgtonly) {
        DTRACE_PROBE1(setcap_alltgt, int, index);
        return (retstatus);
    }

    DTRACE_PROBE1(setcap_index, int, index);

    switch (index) {
    case SCSI_CAP_DMA_MAX:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_DISCONNECT:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_SYNCHRONOUS:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_WIDE_XFER:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_ARQ:
        return (1);
    case SCSI_CAP_INITIATOR_ID:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_UNTAGGED_QING:
        return (1);
    case SCSI_CAP_TAGGED_QING:
        return (1);
    case SCSI_CAP_SECTOR_SIZE:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_TOTAL_SECTORS:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_GEOMETRY:
        return (CAP_CHG_NOT_ALLOWED);
    case SCSI_CAP_RESET_NOTIFICATION:
        return (CAP_CHG_NOT_ALLOWED);
    default:
        return (CAP_NOT_DEFINED);
    }
}

/*
 * Function :   cpqary3_handle_flag_nointr
 * Description  :   This routine is called to handle submission and
 *          subsequently poll for the completion of a command,
 *          when its FLAG_NOINTR bit is set.
 * Called By    :   cpqary3_transport()
 * Parameters   :   command private structure, SCSI packet
 * Calls    :   cpqary3_intr_onoff, cpqary3_retrieve,
 *          cpqary3_submit, cpqary3_poll
 * Return Values:   TRAN_ACCEPT
 */
static int
cpqary3_handle_flag_nointr(cpqary3_cmdpvt_t *memp, struct scsi_pkt *scsi_pktp)
{
    uint32_t        tag;
    uint32_t        simple_tag;
    uint32_t        i;
    cpqary3_t       *ctlr;
    cpqary3_cmdpvt_t    *cpqary3_cmdpvtp;
    uint32_t        CmdsOutMax;
    uint32_t        no_cmds;

    RETURN_FAILURE_IF_NULL(memp);
    tag = memp->tag.tag_value;
    ctlr = memp->ctlr;
    ctlr->poll_flag = CPQARY3_FALSE;

    /*
     * Before sumitting this command, ensure all commands pending
     * with the controller are completed.
     */

    cpqary3_intr_onoff(ctlr, CPQARY3_INTR_DISABLE);
    if (ctlr->host_support & 0x4)
        cpqary3_lockup_intr_onoff(ctlr, CPQARY3_LOCKUP_INTR_DISABLE);

    no_cmds = (uint32_t)((ctlr->ctlr_maxcmds / 3) * NO_OF_CMDLIST_IN_A_BLK);
    mutex_enter(&ctlr->sw_mutex);

    for (;;) {
        ctlr->poll_flag = CPQARY3_FALSE;
        for (i = 0; i < no_cmds; i++) {
            cpqary3_cmdpvtp = &ctlr->cmdmemlistp->pool[i];
            ASSERT(cpqary3_cmdpvtp != NULL);

            if ((tag != cpqary3_cmdpvtp->tag.tag_value) &&
                (cpqary3_cmdpvtp->occupied == CPQARY3_OCCUPIED)) {
                if (ctlr->noe_support == 1) {
                    if ((cpqary3_cmdpvtp->cmdlist_memaddr->
                        Header.Tag.drvinfo_n_err ==
                        CPQARY3_NOECMD_SUCCESS) ||
                        (cpqary3_cmdpvtp->cmdpvt_flag ==
                        CPQARY3_TIMEOUT))  {
                        continue;
                    }
                } else {
                    if (cpqary3_cmdpvtp->cmdpvt_flag ==
                        CPQARY3_TIMEOUT)  {
                        continue;
                    }
                }
                ctlr->poll_flag = CPQARY3_TRUE;
            }
            /* NOE */

            if (ctlr->poll_flag == CPQARY3_TRUE) {
                break;
            }
        }

        if (ctlr->poll_flag == CPQARY3_TRUE) {
            if (!(ctlr->bddef->bd_flags & SA_BD_SAS)) {
                while ((simple_tag =
                    ddi_get32(ctlr->opq_handle,
                    (uint32_t *)ctlr->opq)) != 0xFFFFFFFF) {
                    CmdsOutMax = ctlr->ctlr_maxcmds;
                    if ((simple_tag >>
                        CPQARY3_GET_MEM_TAG) >=
                        ((CmdsOutMax / 3) * 3)) {
                        cmn_err(CE_WARN,
                            "CPQary3 : HBA returned "
                            "Spurious Tag");
                        return (CPQARY3_FAILURE);
                    }

                    cpqary3_cmdpvtp =
                        &ctlr->cmdmemlistp->pool[
                        simple_tag >> CPQARY3_GET_MEM_TAG];
                    cpqary3_cmdpvtp->cmdlist_memaddr->
                        Header.Tag.drvinfo_n_err =
                        (simple_tag & 0xF) >> 1;
                    cpqary3_cmdpvtp->complete(
                        cpqary3_cmdpvtp);
                }
            } else {
                mutex_exit(&ctlr->sw_mutex);
                if (CPQARY3_SUCCESS != cpqary3_retrieve(ctlr)) {
                    drv_usecwait(1000);
                }
                mutex_enter(&ctlr->sw_mutex); /* Changes */
            }
        } else {
            break;
        }
    }

    mutex_enter(&ctlr->hw_mutex);
    if (EIO == cpqary3_submit(ctlr, memp->cmdlist_phyaddr)) {
        mutex_exit(&ctlr->hw_mutex);
        mutex_exit(&ctlr->sw_mutex);
        cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
        return (TRAN_FATAL_ERROR);
    }

    if (CPQARY3_FAILURE == cpqary3_poll(ctlr, tag)) {
        scsi_pktp->pkt_reason = CMD_TIMEOUT;
        scsi_pktp->pkt_statistics = STAT_TIMEOUT;
        scsi_pktp->pkt_state = 0;
        mutex_exit(&ctlr->hw_mutex);
        mutex_exit(&ctlr->sw_mutex);
        cpqary3_cmdlist_release(memp, CPQARY3_HOLD_SW_MUTEX);
        cpqary3_intr_onoff(ctlr, CPQARY3_INTR_ENABLE);
        if (ctlr->host_support & 0x4)
            cpqary3_lockup_intr_onoff(ctlr,
                CPQARY3_LOCKUP_INTR_ENABLE);
        return (TRAN_ACCEPT);
    } else {
        mutex_exit(&ctlr->hw_mutex);
        mutex_exit(&ctlr->sw_mutex);
        cpqary3_intr_onoff(ctlr, CPQARY3_INTR_ENABLE);
        if (ctlr->host_support & 0x4) {
            cpqary3_lockup_intr_onoff(ctlr,
                CPQARY3_LOCKUP_INTR_ENABLE);
        }
        return (TRAN_ACCEPT);
    }
}

/*
 * Function :   cpqary3_poll
 * Description  :   This routine polls for the completion of a command.
 * Called By    :   cpqary3_handle_flag_nointr
 * Parameters   :   per controller, tag of the command to be polled
 * Calls    :   cpqary3_poll_retrieve
 * Return Values:   TRAN_ACCEPT
 */
static int
cpqary3_poll(cpqary3_t *ctlr, uint32_t tag)
{
    uint32_t        ii = 0;

    RETURN_FAILURE_IF_NULL(ctlr);

    /*
     * POLL for the completion of the said command
     * Since, we had ensured that controller is empty, we need not
     * check for the complete Retrieved Q.
     * However, we just check the Retrieved Q and complete all
     * commands in it, inclusive of the polled command.
     * if the polled command is completed, send back a success.
     */

    for (;;) {  /* this function is called with both the locks held */
        if (CPQARY3_SUCCESS != cpqary3_poll_retrieve(ctlr, tag)) {
            ii++;
            if (ii > 120000)
                return (CPQARY3_FAILURE);
            drv_usecwait(500);
            continue;
        }
        break;
    }

    return (CPQARY3_SUCCESS);
}

static int
cpqary3_additional_cmd(struct scsi_pkt *scsi_pktp, cpqary3_t *ctlr)
{
    struct scsi_arq_status *arqstat;
    /* LINTED: alignment */
    arqstat = (struct scsi_arq_status *)(scsi_pktp->pkt_scbp);

    switch (scsi_pktp->pkt_cdbp[0]) {
    case 0x35: /* Synchronize Cache */

        cpqary3_flush_cache(ctlr);

        scsi_pktp->pkt_reason = CMD_CMPLT;
        scsi_pktp->pkt_statistics = 0;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;

        if (scsi_pktp->pkt_comp) {
            (*scsi_pktp->pkt_comp)(scsi_pktp);
        }

        return (1);

    case 0x04: /* Format Unit */
        cmn_err(CE_NOTE, "The FORMAT UNIT is not supported by this "
            "device If this option is selected from the format utility "
            "do not continue further.  Please refer to cpqary3 driver "
            "man pages for details.");

        return (0);
    case SCSI_LOG_SENSE:
    case SCSI_MODE_SELECT:
    case SCSI_PERSISTENT_RESERVE_IN:
        arqstat->sts_status.sts_chk = 1; /* CHECK CONDITION */
        arqstat->sts_rqpkt_reason = CMD_CMPLT;
        arqstat->sts_rqpkt_resid = 0;
        arqstat->sts_rqpkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA;
        arqstat->sts_rqpkt_statistics = 0;
        arqstat->sts_sensedata.es_valid = 1;
        arqstat->sts_sensedata.es_class = CLASS_EXTENDED_SENSE;
        arqstat->sts_sensedata.es_key = KEY_ILLEGAL_REQUEST;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA;

        if (scsi_pktp->pkt_comp) {
            (*scsi_pktp->pkt_comp)(scsi_pktp);
        }
        return (1);
    }

    return (0);
}

/* PERF */
/*
 * Function :       cpqary3_oscmd_complete
 * Description  :       This routine processes the
 *          completed OS commands and
 *          initiates any callback that is needed.
 * Called By    :       cpqary3_transport
 * Parameters   :       per-command
 * Calls    :       cpqary3_ioctl_send_bmiccmd,
 *          cpqary3_ioctl_send_scsicmd,
 *          cpqary3_send_abortcmd, cpqary3_flush_cache,
 *          cpqary3_probe4LVs,
 *          cpqary3_probe4Tapes, cpqary3_synccmd_complete,
 *          cpqary3_detect_target_geometry,
 *          cpqary3_detect_target_geometry
 * Return Values:       None
 */
void
cpqary3_oscmd_complete(cpqary3_cmdpvt_t *cpqary3_cmdpvtp)
{
    cpqary3_t   *cpqary3p;
    ErrorInfo_t *errorinfop;
    CommandList_t   *cmdlistp;
    struct scsi_pkt *scsi_pktp;

    ASSERT(cpqary3_cmdpvtp != NULL);

    if (CPQARY3_TIMEOUT == cpqary3_cmdpvtp->cmdpvt_flag) {
        cpqary3_cmdlist_release(cpqary3_cmdpvtp,
            CPQARY3_NO_MUTEX);
        return;
    }

    cpqary3p = cpqary3_cmdpvtp->ctlr;
    cmdlistp = cpqary3_cmdpvtp->cmdlist_memaddr;
    errorinfop = cpqary3_cmdpvtp->errorinfop;

    if (cmdlistp->Header.Tag.drvinfo_n_err == CPQARY3_OSCMD_SUCCESS) {
        scsi_pktp = cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt;
        scsi_pktp->pkt_reason = CMD_CMPLT;
        scsi_pktp->pkt_statistics = 0;
        scsi_pktp->pkt_state = STATE_GOT_BUS |
            STATE_GOT_TARGET | STATE_SENT_CMD |
            STATE_XFERRED_DATA | STATE_GOT_STATUS;

        if (cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt->pkt_flags &
            FLAG_NOINTR) {
            cpqary3_cmdlist_release(cpqary3_cmdpvtp,
                CPQARY3_NO_MUTEX);
        } else {
            cpqary3_cmdlist_release(cpqary3_cmdpvtp,
                CPQARY3_NO_MUTEX);

            if (scsi_pktp->pkt_comp) {
                mutex_exit(&cpqary3p->sw_mutex);
                (*scsi_pktp->pkt_comp)(scsi_pktp);
                mutex_enter(&cpqary3p->sw_mutex);
            }
        }
        return;
    } else {
        scsi_pktp = cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt;
    }

    switch (errorinfop->CommandStatus) {
    case CISS_CMD_DATA_OVERRUN :
        scsi_pktp->pkt_reason = CMD_DATA_OVR;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
        break;

    case CISS_CMD_INVALID :
        DTRACE_PROBE1(invalid_cmd, struct scsi_pkt *, scsi_pktp);
        scsi_pktp->pkt_reason = CMD_BADMSG;
        scsi_pktp->pkt_state = STATE_GOT_BUS |STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_GOT_STATUS;
        break;

    case CISS_CMD_PROTOCOL_ERR :
        scsi_pktp->pkt_reason = CMD_BADMSG;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_GOT_STATUS;
        break;

    case CISS_CMD_HARDWARE_ERR:
    case CISS_CMD_CONNECTION_LOST:
        scsi_pktp->pkt_reason = CMD_INCOMPLETE;
        scsi_pktp->pkt_state = 0;
        break;

    case CISS_CMD_ABORTED:
    case CISS_CMD_UNSOLICITED_ABORT:
        scsi_pktp->pkt_reason = CMD_ABORTED;
        scsi_pktp->pkt_statistics = STAT_ABORTED;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
        break;

    case CISS_CMD_ABORT_FAILED:
        break;

    case CISS_CMD_TIMEOUT:
        scsi_pktp->pkt_reason = CMD_TIMEOUT;
        scsi_pktp->pkt_statistics = STAT_TIMEOUT;
        scsi_pktp->pkt_state = 0;
        break;

    case CISS_CMD_DATA_UNDERRUN:    /* Significant ONLY for Read & Write */
        if (cpqary3_is_scsi_read_write(scsi_pktp)) {
            scsi_pktp->pkt_reason = CMD_CMPLT;
            scsi_pktp->pkt_statistics = 0;
            scsi_pktp->pkt_state =
                STATE_GOT_BUS | STATE_GOT_TARGET | STATE_SENT_CMD |
                STATE_XFERRED_DATA | STATE_GOT_STATUS;
            break;
        }
        /* FALLTHROUGH */
    case CISS_CMD_SUCCESS:
    case CISS_CMD_TARGET_STATUS:
        scsi_pktp->pkt_reason = CMD_CMPLT;
        scsi_pktp->pkt_statistics = 0;
        scsi_pktp->pkt_state = STATE_GOT_BUS | STATE_GOT_TARGET |
            STATE_SENT_CMD | STATE_XFERRED_DATA | STATE_GOT_STATUS;
        break;

    default:    /* Should never Occur !!! */
        scsi_pktp->pkt_reason = CMD_TRAN_ERR;
        break;
    }


    /*
     * if ever a command completes with a CHECK CONDITION or a
     * COMMAND_TERMINATED SCSI status, Update the sense data.
     * NOTE : The CISS_CMD_INVALID command status would always result in a
     * CHECK CONDITION and hence reach this part of the code.
     */

    if ((errorinfop->ScsiStatus == SCSI_CHECK_CONDITION) ||
        (errorinfop->ScsiStatus == SCSI_COMMAND_TERMINATED)) {
        if (errorinfop->SenseLen) {
            struct scsi_arq_status  *arq_statusp;
            arq_statusp =
                /* LINTED: alignment */
                (struct scsi_arq_status *)scsi_pktp->pkt_scbp;

            if ((errorinfop->ScsiStatus == SCSI_CHECK_CONDITION)) {
                arq_statusp->sts_status.sts_chk = (uint8_t)1;
            } else {
                arq_statusp->sts_status.sts_chk = (uint8_t)1;
                arq_statusp->sts_status.sts_scsi2 = (uint8_t)1;
            }
            bzero((void *)&(arq_statusp->sts_rqpkt_status),
                sizeof (struct scsi_status));
            arq_statusp->sts_rqpkt_reason = CMD_CMPLT;
            arq_statusp->sts_rqpkt_resid = 0;
            arq_statusp->sts_rqpkt_state = scsi_pktp->pkt_state;
            arq_statusp->sts_rqpkt_statistics =
                scsi_pktp->pkt_statistics;
            bcopy((caddr_t)&errorinfop->SenseInfo[0],
                (caddr_t)(&arq_statusp->sts_sensedata),
                CPQARY3_MIN(errorinfop->SenseLen,
                cpqary3_cmdpvtp->pvt_pkt->scb_len));
            scsi_pktp->pkt_state |= STATE_ARQ_DONE;
        }
    }

    if (cpqary3_cmdpvtp->pvt_pkt->scsi_cmd_pkt->pkt_flags & FLAG_NOINTR) {
        cpqary3_cmdlist_release(cpqary3_cmdpvtp, CPQARY3_NO_MUTEX);
    } else {
        cpqary3_cmdlist_release(cpqary3_cmdpvtp, CPQARY3_NO_MUTEX);

        if (scsi_pktp->pkt_comp) {
            mutex_exit(&cpqary3p->sw_mutex);
            (*scsi_pktp->pkt_comp)(scsi_pktp);
            mutex_enter(&cpqary3p->sw_mutex);
        }
    }
}

static uint8_t
cpqary3_is_scsi_read_write(struct scsi_pkt *scsi_pktp)
{
    /*
     * In the scsi packet structure, the first byte is the SCSI Command
     * OpCode.  We check to see if it is any one of the SCSI Read or Write
     * opcodes.
     */

    switch (scsi_pktp->pkt_cdbp[0]) {
    case SCSI_READ_6:
    case SCSI_READ_10:
    case SCSI_READ_12:
    case SCSI_WRITE_6:
    case SCSI_WRITE_10:
    case SCSI_WRITE_12:
        return (1);

    default:
        return (0);
    }
}