/*      $NetBSD: aic79xx_osm.c,v 1.36 2021/08/07 16:19:12 thorpej Exp $ */

/*
 * Bus independent NetBSD shim for the aic7xxx based adaptec SCSI controllers
 *
 * Copyright (c) 1994-2002 Justin T. Gibbs.
 * Copyright (c) 2001-2002 Adaptec Inc.
 * 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,
 *    without modification.
 * 2. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU Public License ("GPL").
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 * //depot/aic7xxx/freebsd/dev/aic7xxx/aic79xx_osm.c#26 $
 *
 * $FreeBSD: src/sys/dev/aic7xxx/aic79xx_osm.c,v 1.11 2003/05/04 00:20:07 gibbs Exp $
 */
/*
 * Ported from FreeBSD by Pascal Renauld, Network Storage Solutions, Inc.
 * - April 2003
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: aic79xx_osm.c,v 1.36 2021/08/07 16:19:12 thorpej Exp $");

#include <dev/ic/aic79xx_osm.h>
#include <dev/ic/aic79xx_inline.h>

#ifndef AHD_TMODE_ENABLE
#define AHD_TMODE_ENABLE 0
#endif

static int      ahd_ioctl(struct scsipi_channel *channel, u_long cmd,
                          void *addr, int flag, struct proc *p);
static void     ahd_action(struct scsipi_channel *chan,
                           scsipi_adapter_req_t req, void *arg);
static void     ahd_execute_scb(void *arg, bus_dma_segment_t *dm_segs,
                                int nsegments);
static int      ahd_poll(struct ahd_softc *ahd, int wait);
static void     ahd_setup_data(struct ahd_softc *ahd, struct scsipi_xfer *xs,
                               struct scb *scb);

#if NOT_YET
static void     ahd_set_recoveryscb(struct ahd_softc *ahd, struct scb *scb);
#endif

static bool     ahd_pmf_suspend(device_t, const pmf_qual_t *);
static bool     ahd_pmf_resume(device_t, const pmf_qual_t *);
static bool     ahd_pmf_shutdown(device_t, int);

/*
 * Attach all the sub-devices we can find
 */
int
ahd_attach(struct ahd_softc *ahd)
{
        int     s;
        char    ahd_info[256];

        ahd_controller_info(ahd, ahd_info, sizeof(ahd_info));
        aprint_normal("%s: %s\n", ahd_name(ahd), ahd_info);

        ahd_lock(ahd, &s);

        ahd->sc_adapter.adapt_dev = ahd->sc_dev;
        ahd->sc_adapter.adapt_nchannels = 1;

        ahd->sc_adapter.adapt_openings = ahd->scb_data.numscbs - 1;
        ahd->sc_adapter.adapt_max_periph = 32;

        ahd->sc_adapter.adapt_ioctl = ahd_ioctl;
        ahd->sc_adapter.adapt_minphys = ahd_minphys;
        ahd->sc_adapter.adapt_request = ahd_action;

        ahd->sc_channel.chan_adapter = &ahd->sc_adapter;
        ahd->sc_channel.chan_bustype = &scsi_bustype;
        ahd->sc_channel.chan_channel = 0;
        ahd->sc_channel.chan_ntargets = AHD_NUM_TARGETS;
        ahd->sc_channel.chan_nluns = 8 /*AHD_NUM_LUNS*/;
        ahd->sc_channel.chan_id = ahd->our_id;
        ahd->sc_channel.chan_flags |= SCSIPI_CHAN_CANGROW;

        ahd->sc_child = config_found(ahd->sc_dev, &ahd->sc_channel, scsiprint,
            CFARGS_NONE);

        ahd_intr_enable(ahd, TRUE);

        if (ahd->flags & AHD_RESET_BUS_A)
                ahd_reset_channel(ahd, 'A', TRUE);

        if (!pmf_device_register1(ahd->sc_dev,
            ahd_pmf_suspend, ahd_pmf_resume, ahd_pmf_shutdown))
                aprint_error_dev(ahd->sc_dev,
                    "couldn't establish power handler\n");

        ahd_unlock(ahd, &s);

        return (1);
}

static bool
ahd_pmf_suspend(device_t dev, const pmf_qual_t *qual)
{
        struct ahd_softc *sc = device_private(dev);
#if 0
        return (ahd_suspend(sc) == 0);
#else
        ahd_shutdown(sc);
        return true;
#endif
}

static bool
ahd_pmf_resume(device_t dev, const pmf_qual_t *qual)
{
#if 0
        struct ahd_softc *sc = device_private(dev);

        return (ahd_resume(sc) == 0);
#else
        return true;
#endif
}

static bool
ahd_pmf_shutdown(device_t dev, int howto)
{
        struct ahd_softc *sc = device_private(dev);

        /* Disable all interrupt sources by resetting the controller */
        ahd_shutdown(sc);

        return true;
}

static int
ahd_ioctl(struct scsipi_channel *channel, u_long cmd,
          void *addr, int flag, struct proc *p)
{
        struct ahd_softc *ahd;
        int s, ret = ENOTTY;

        ahd = device_private(channel->chan_adapter->adapt_dev);

        switch (cmd) {
        case SCBUSIORESET:
                s = splbio();
                ahd_reset_channel(ahd, channel->chan_channel == 1 ? 'B' : 'A', TRUE);
                splx(s);
                ret = 0;
                break;
        default:
                break;
        }

        return ret;
}

/*
 * Catch an interrupt from the adapter
 */
void
ahd_platform_intr(void *arg)
{
        struct  ahd_softc *ahd;

        ahd = arg;

        printf("%s; ahd_platform_intr\n", ahd_name(ahd));

        ahd_intr(ahd);
}

/*
 * We have an scb which has been processed by the
 * adaptor, now we look to see how the operation * went.
 */
void
ahd_done(struct ahd_softc *ahd, struct scb *scb)
{
        struct scsipi_xfer      *xs;
        struct scsipi_periph    *periph;
        int                     s;

        LIST_REMOVE(scb, pending_links);

        xs = scb->xs;
        periph = xs->xs_periph;

        callout_stop(&scb->xs->xs_callout);

        if (xs->datalen) {
                int op;

                if (xs->xs_control & XS_CTL_DATA_IN)
                        op = BUS_DMASYNC_POSTREAD;
                else
                        op = BUS_DMASYNC_POSTWRITE;

                bus_dmamap_sync(ahd->parent_dmat, scb->dmamap, 0,
                                scb->dmamap->dm_mapsize, op);
                bus_dmamap_unload(ahd->parent_dmat, scb->dmamap);
        }

        /*
         * If the recovery SCB completes, we have to be
         * out of our timeout.
         */
        if ((scb->flags & SCB_RECOVERY_SCB) != 0) {
                struct  scb *list_scb;

                /*
                 * We were able to complete the command successfully,
                 * so reinstate the timeouts for all other pending
                 * commands.
                 */
                LIST_FOREACH(list_scb, &ahd->pending_scbs, pending_links) {
                        struct scsipi_xfer      *txs = list_scb->xs;

                        if (!(txs->xs_control & XS_CTL_POLL)) {
                                callout_reset(&txs->xs_callout,
                                    (txs->timeout > 1000000) ?
                                    (txs->timeout / 1000) * hz :
                                    (txs->timeout * hz) / 1000,
                                    ahd_timeout, list_scb);
                        }
                }

                if (ahd_get_transaction_status(scb) != XS_NOERROR)
                        ahd_set_transaction_status(scb, XS_TIMEOUT);
                scsipi_printaddr(xs->xs_periph);
                printf("%s: no longer in timeout, status = %x\n",
                       ahd_name(ahd), xs->status);
        }

        if (xs->error != XS_NOERROR) {
                /* Don't clobber any existing error state */
        } else if ((xs->status == SCSI_STATUS_BUSY) ||
                   (xs->status == SCSI_STATUS_QUEUE_FULL)) {
                ahd_set_transaction_status(scb, XS_BUSY);
                printf("%s: drive (ID %d, LUN %d) queue full (SCB 0x%x)\n",
                       ahd_name(ahd), SCB_GET_TARGET(ahd,scb), SCB_GET_LUN(scb), SCB_GET_TAG(scb));
        } else if ((scb->flags & SCB_SENSE) != 0) {
                /*
                 * We performed autosense retrieval.
                 *
                 * zero the sense data before having
                 * the drive fill it.  The SCSI spec mandates
                 * that any untransferred data should be
                 * assumed to be zero.  Complete the 'bounce'
                 * of sense information through buffers accessible
                 * via bus-space by copying it into the clients
                 * csio.
                 */
                memset(&xs->sense.scsi_sense, 0, sizeof(xs->sense.scsi_sense));
                memcpy(&xs->sense.scsi_sense, ahd_get_sense_buf(ahd, scb),
                       sizeof(struct scsi_sense_data));

                ahd_set_transaction_status(scb, XS_SENSE);
        } else if ((scb->flags & SCB_PKT_SENSE) != 0) {
                struct scsi_status_iu_header *siu;
                u_int sense_len;
#ifdef AHD_DEBUG
                int i;
#endif
                /*
                 * Copy only the sense data into the provided buffer.
                 */
                siu = (struct scsi_status_iu_header *)scb->sense_data;
                sense_len = MIN(scsi_4btoul(siu->sense_length),
                                sizeof(xs->sense.scsi_sense));
                memset(&xs->sense.scsi_sense, 0, sizeof(xs->sense.scsi_sense));
                memcpy(&xs->sense.scsi_sense,
                       scb->sense_data + SIU_SENSE_OFFSET(siu), sense_len);
#ifdef AHD_DEBUG
                printf("Copied %d bytes of sense data offset %d:", sense_len,
                       SIU_SENSE_OFFSET(siu));
                for (i = 0; i < sense_len; i++)
                        printf(" 0x%x", ((uint8_t *)&xs->sense.scsi_sense)[i]);
                printf("\n");
#endif
                ahd_set_transaction_status(scb, XS_SENSE);
        }

        if (scb->flags & SCB_FREEZE_QUEUE) {
                scsipi_periph_thaw(periph, 1);
                scb->flags &= ~SCB_FREEZE_QUEUE;
        }

        if (scb->flags & SCB_REQUEUE)
                ahd_set_transaction_status(scb, XS_REQUEUE);

        ahd_lock(ahd, &s);
        ahd_free_scb(ahd, scb);
        ahd_unlock(ahd, &s);

        scsipi_done(xs);
}

static void
ahd_action(struct scsipi_channel *chan, scsipi_adapter_req_t req, void *arg)
{
        struct ahd_softc *ahd;
        struct ahd_initiator_tinfo *tinfo;
        struct ahd_tmode_tstate *tstate;

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

        switch(req) {

        case ADAPTER_REQ_RUN_XFER:
          {
                struct scsipi_xfer *xs;
                struct scsipi_periph *periph;
                struct scb *scb;
                struct hardware_scb *hscb;
                u_int target_id;
                u_int our_id;
                u_int col_idx;
                char channel;
                int s;

                xs = arg;
                periph = xs->xs_periph;

                SC_DEBUG(periph, SCSIPI_DB3, ("ahd_action\n"));

                target_id = periph->periph_target;
                our_id = ahd->our_id;
                channel = (chan->chan_channel == 1) ? 'B' : 'A';

                /*
                 * get an scb to use.
                 */
                ahd_lock(ahd, &s);
                tinfo = ahd_fetch_transinfo(ahd, channel, our_id,
                                            target_id, &tstate);

                if (xs->xs_tag_type != 0 ||
                    (tinfo->curr.ppr_options & MSG_EXT_PPR_IU_REQ) != 0)
                        col_idx = AHD_NEVER_COL_IDX;
                else
                        col_idx = AHD_BUILD_COL_IDX(target_id,
                            periph->periph_lun);

                if ((scb = ahd_get_scb(ahd, col_idx)) == NULL) {
                        xs->error = XS_RESOURCE_SHORTAGE;
                        ahd_unlock(ahd, &s);
                        scsipi_done(xs);
                        return;
                }
                ahd_unlock(ahd, &s);

                hscb = scb->hscb;

                SC_DEBUG(periph, SCSIPI_DB3, ("start scb(%p)\n", scb));
                scb->xs = xs;

                /*
                 * Put all the arguments for the xfer in the scb
                 */
                hscb->control = 0;
                hscb->scsiid = BUILD_SCSIID(ahd, sim, target_id, our_id);
                hscb->lun = periph->periph_lun;
                if (xs->xs_control & XS_CTL_RESET) {
                        hscb->cdb_len = 0;
                        scb->flags |= SCB_DEVICE_RESET;
                        hscb->control |= MK_MESSAGE;
                        hscb->task_management = SIU_TASKMGMT_LUN_RESET;
                        ahd_execute_scb(scb, NULL, 0);
                } else {
                        hscb->task_management = 0;
                }

                ahd_setup_data(ahd, xs, scb);
                break;
          }

        case ADAPTER_REQ_GROW_RESOURCES:
#ifdef AHC_DEBUG
                printf("%s: ADAPTER_REQ_GROW_RESOURCES\n", ahd_name(ahd));
#endif
                chan->chan_adapter->adapt_openings += ahd_alloc_scbs(ahd);
                if (ahd->scb_data.numscbs >= AHD_SCB_MAX_ALLOC)
                        chan->chan_flags &= ~SCSIPI_CHAN_CANGROW;
                break;

        case ADAPTER_REQ_SET_XFER_MODE:
            {
                struct scsipi_xfer_mode *xm = arg;
                struct ahd_devinfo devinfo;
                int target_id, our_id, first;
                u_int width;
                int s;
                char channel;
                u_int ppr_options = 0, period, offset;
                uint16_t old_autoneg;

                target_id = xm->xm_target;
                our_id = chan->chan_id;
                channel = 'A';
                s = splbio();
                tinfo = ahd_fetch_transinfo(ahd, channel, our_id, target_id,
                    &tstate);
                ahd_compile_devinfo(&devinfo, our_id, target_id,
                    0, channel, ROLE_INITIATOR);

                old_autoneg = tstate->auto_negotiate;

                /*
                 * XXX since the period and offset are not provided here,
                 * fake things by forcing a renegotiation using the user
                 * settings if this is called for the first time (i.e.
                 * during probe). Also, cap various values at the user
                 * values, assuming that the user set it up that way.
                 */
                if (ahd->inited_target[target_id] == 0) {
                        period = tinfo->user.period;
                        offset = tinfo->user.offset;
                        ppr_options = tinfo->user.ppr_options;
                        width = tinfo->user.width;
                        tstate->tagenable |=
                            (ahd->user_tagenable & devinfo.target_mask);
                        tstate->discenable |=
                            (ahd->user_discenable & devinfo.target_mask);
                        ahd->inited_target[target_id] = 1;
                        first = 1;
                } else
                        first = 0;

                if (xm->xm_mode & (PERIPH_CAP_WIDE16 | PERIPH_CAP_DT))
                        width = MSG_EXT_WDTR_BUS_16_BIT;
                else
                        width = MSG_EXT_WDTR_BUS_8_BIT;

                ahd_validate_width(ahd, NULL, &width, ROLE_UNKNOWN);
                if (width > tinfo->user.width)
                        width = tinfo->user.width;
                ahd_set_width(ahd, &devinfo, width, AHD_TRANS_GOAL, FALSE);

                if (!(xm->xm_mode & (PERIPH_CAP_SYNC | PERIPH_CAP_DT))) {
                        period = 0;
                        offset = 0;
                        ppr_options = 0;
                }

                if ((xm->xm_mode & PERIPH_CAP_DT) &&
                    (tinfo->user.ppr_options & MSG_EXT_PPR_DT_REQ))
                        ppr_options |= MSG_EXT_PPR_DT_REQ;
                else
                        ppr_options &= ~MSG_EXT_PPR_DT_REQ;

                if ((tstate->discenable & devinfo.target_mask) == 0 ||
                    (tstate->tagenable & devinfo.target_mask) == 0)
                        ppr_options &= ~MSG_EXT_PPR_IU_REQ;

                if ((xm->xm_mode & PERIPH_CAP_TQING) &&
                    (ahd->user_tagenable & devinfo.target_mask))
                        tstate->tagenable |= devinfo.target_mask;
                else
                        tstate->tagenable &= ~devinfo.target_mask;

                ahd_find_syncrate(ahd, &period, &ppr_options, AHD_SYNCRATE_MAX);
                ahd_validate_offset(ahd, NULL, period, &offset,
                    MSG_EXT_WDTR_BUS_8_BIT, ROLE_UNKNOWN);
                if (offset == 0) {
                        period = 0;
                        ppr_options = 0;
                }
                if (ppr_options != 0
                    && tinfo->user.transport_version >= 3) {
                        tinfo->goal.transport_version =
                            tinfo->user.transport_version;
                        tinfo->curr.transport_version =
                            tinfo->user.transport_version;
                }

                ahd_set_syncrate(ahd, &devinfo, period, offset,
                    ppr_options, AHD_TRANS_GOAL, FALSE);

                /*
                 * If this is the first request, and no negotiation is
                 * needed, just confirm the state to the scsipi layer,
                 * so that it can print a message.
                 */
                if (old_autoneg == tstate->auto_negotiate && first) {
                        xm->xm_mode = 0;
                        xm->xm_period = tinfo->curr.period;
                        xm->xm_offset = tinfo->curr.offset;
                        if (tinfo->curr.width == MSG_EXT_WDTR_BUS_16_BIT)
                                xm->xm_mode |= PERIPH_CAP_WIDE16;
                        if (tinfo->curr.period)
                                xm->xm_mode |= PERIPH_CAP_SYNC;
                        if (tstate->tagenable & devinfo.target_mask)
                                xm->xm_mode |= PERIPH_CAP_TQING;
                        if (tinfo->curr.ppr_options & MSG_EXT_PPR_DT_REQ)
                                xm->xm_mode |= PERIPH_CAP_DT;
                        scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
                }
                splx(s);
            }
        }

        return;
}

static void
ahd_execute_scb(void *arg, bus_dma_segment_t *dm_segs, int nsegments)
{
        struct scb *scb;
        struct scsipi_xfer *xs;
        struct ahd_softc *ahd;
        struct ahd_initiator_tinfo *tinfo;
        struct ahd_tmode_tstate *tstate;
        u_int  mask;
        int    s;

        scb = arg;
        xs = scb->xs;
        xs->error = 0;
        xs->status = 0;
        xs->xs_status = 0;
        ahd = device_private(
            xs->xs_periph->periph_channel->chan_adapter->adapt_dev);

        scb->sg_count = 0;
        if (nsegments != 0) {
                void *sg;
                int op;
                u_int i;

                ahd_setup_data_scb(ahd, scb);

                /* Copy the segments into our SG list */
                for (i = nsegments, sg = scb->sg_list; i > 0; i--) {

                        sg = ahd_sg_setup(ahd, scb, sg, dm_segs->ds_addr,
                                          dm_segs->ds_len,
                                          /*last*/i == 1);
                        dm_segs++;
                }

                if (xs->xs_control & XS_CTL_DATA_IN)
                        op = BUS_DMASYNC_PREREAD;
                else
                        op = BUS_DMASYNC_PREWRITE;

                bus_dmamap_sync(ahd->parent_dmat, scb->dmamap, 0,
                                scb->dmamap->dm_mapsize, op);
        }

        ahd_lock(ahd, &s);

        /*
         * Last time we need to check if this SCB needs to
         * be aborted.
         */
        if (ahd_get_scsi_status(scb) == XS_STS_DONE) {
                if (nsegments != 0)
                        bus_dmamap_unload(ahd->parent_dmat,
                                          scb->dmamap);
                ahd_free_scb(ahd, scb);
                ahd_unlock(ahd, &s);
                return;
        }

        tinfo = ahd_fetch_transinfo(ahd, SCSIID_CHANNEL(ahd, scb->hscb->scsiid),
                                    SCSIID_OUR_ID(scb->hscb->scsiid),
                                    SCSIID_TARGET(ahd, scb->hscb->scsiid),
                                    &tstate);

        mask = SCB_GET_TARGET_MASK(ahd, scb);

        if ((tstate->discenable & mask) != 0)
                scb->hscb->control |= DISCENB;

        if ((tstate->tagenable & mask) != 0)
                scb->hscb->control |= xs->xs_tag_type|TAG_ENB;

        if ((tinfo->curr.ppr_options & MSG_EXT_PPR_IU) != 0) {
                scb->flags |= SCB_PACKETIZED;
                if (scb->hscb->task_management != 0)
                        scb->hscb->control &= ~MK_MESSAGE;
        }

#if 0   /* This looks like it makes sense at first, but it can loop */
        if ((xs->xs_control & XS_CTL_DISCOVERY) &&
            (tinfo->goal.width != 0
             || tinfo->goal.period != 0
             || tinfo->goal.ppr_options != 0)) {
                scb->flags |= SCB_NEGOTIATE;
                scb->hscb->control |= MK_MESSAGE;
        } else
#endif
        if ((tstate->auto_negotiate & mask) != 0) {
                scb->flags |= SCB_AUTO_NEGOTIATE;
                scb->hscb->control |= MK_MESSAGE;
        }

        LIST_INSERT_HEAD(&ahd->pending_scbs, scb, pending_links);

        scb->flags |= SCB_ACTIVE;

        if (!(xs->xs_control & XS_CTL_POLL)) {
                callout_reset(&scb->xs->xs_callout, xs->timeout > 1000000 ?
                              (xs->timeout / 1000) * hz : (xs->timeout * hz) / 1000,
                              ahd_timeout, scb);
        }

        if ((scb->flags & SCB_TARGET_IMMEDIATE) != 0) {
                /* Define a mapping from our tag to the SCB. */
                ahd->scb_data.scbindex[SCB_GET_TAG(scb)] = scb;
                ahd_pause(ahd);
                ahd_set_scbptr(ahd, SCB_GET_TAG(scb));
                ahd_outb(ahd, RETURN_1, CONT_MSG_LOOP_TARG);
                ahd_unpause(ahd);
        } else {
                ahd_queue_scb(ahd, scb);
        }

        if (!(xs->xs_control & XS_CTL_POLL)) {
                ahd_unlock(ahd, &s);
                return;
        }
        /*
         * If we can't use interrupts, poll for completion
         */
        SC_DEBUG(xs->xs_periph, SCSIPI_DB3, ("cmd_poll\n"));
        do {
                if (ahd_poll(ahd, xs->timeout)) {
                        if (!(xs->xs_control & XS_CTL_SILENT))
                                printf("cmd fail\n");
                        ahd_timeout(scb);
                        break;
                }
        } while (!(xs->xs_status & XS_STS_DONE));

        ahd_unlock(ahd, &s);
}

static int
ahd_poll(struct ahd_softc *ahd, int wait)
{

        while (--wait) {
                DELAY(1000);
                if (ahd_inb(ahd, INTSTAT) & INT_PEND)
                        break;
        }

        if (wait == 0) {
                printf("%s: board is not responding\n", ahd_name(ahd));
                return (EIO);
        }

        ahd_intr(ahd);
        return (0);
}


static void
ahd_setup_data(struct ahd_softc *ahd, struct scsipi_xfer *xs,
               struct scb *scb)
{
        struct hardware_scb *hscb;

        hscb = scb->hscb;
        xs->resid = xs->status = 0;

        hscb->cdb_len = xs->cmdlen;
        if (hscb->cdb_len > MAX_CDB_LEN) {
                int s;
                /*
                 * Should CAM start to support CDB sizes
                 * greater than 16 bytes, we could use
                 * the sense buffer to store the CDB.
                 */
                ahd_set_transaction_status(scb,
                                           XS_DRIVER_STUFFUP);

                ahd_lock(ahd, &s);
                ahd_free_scb(ahd, scb);
                ahd_unlock(ahd, &s);
                scsipi_done(xs);
        }
        memcpy(hscb->shared_data.idata.cdb, xs->cmd, hscb->cdb_len);

        /* Only use S/G if there is a transfer */
        if (xs->datalen) {
                int error;

                error = bus_dmamap_load(ahd->parent_dmat,
                                        scb->dmamap, xs->data,
                                        xs->datalen, NULL,
                                        ((xs->xs_control & XS_CTL_NOSLEEP) ?
                                         BUS_DMA_NOWAIT : BUS_DMA_WAITOK) |
                                        BUS_DMA_STREAMING |
                                        ((xs->xs_control & XS_CTL_DATA_IN) ?
                                         BUS_DMA_READ : BUS_DMA_WRITE));
                if (error) {
#ifdef AHD_DEBUG
                        printf("%s: in ahd_setup_data(): bus_dmamap_load() "
                               "= %d\n",
                               ahd_name(ahd), error);
#endif
                        xs->error = XS_RESOURCE_SHORTAGE;
                        scsipi_done(xs);
                        return;
                }
                ahd_execute_scb(scb,
                                scb->dmamap->dm_segs,
                                scb->dmamap->dm_nsegs);
        } else {
                ahd_execute_scb(scb, NULL, 0);
        }
}

void
ahd_timeout(void *arg)
{
        struct  scb       *scb;
        struct  ahd_softc *ahd;
        int                s;

        scb = arg;
        ahd = scb->ahd_softc;

        printf("%s: ahd_timeout\n", ahd_name(ahd));

        ahd_lock(ahd, &s);

        ahd_pause_and_flushwork(ahd);
        (void)ahd_save_modes(ahd);
#if 0
        ahd_set_modes(ahd, AHD_MODE_SCSI, AHD_MODE_SCSI);
        ahd_outb(ahd, SCSISIGO, ACKO);
        printf("set ACK\n");
        ahd_outb(ahd, SCSISIGO, 0);
        printf("clearing Ack\n");
        ahd_restore_modes(ahd, saved_modes);
#endif
        if ((scb->flags & SCB_ACTIVE) == 0) {
                /* Previous timeout took care of me already */
                printf("%s: Timedout SCB already complete. "
                       "Interrupts may not be functioning.\n", ahd_name(ahd));
                ahd_unpause(ahd);
                ahd_unlock(ahd, &s);
                return;
        }

        ahd_print_path(ahd, scb);
        printf("SCB 0x%x - timed out\n", SCB_GET_TAG(scb));
        ahd_dump_card_state(ahd);
        ahd_reset_channel(ahd, SIM_CHANNEL(ahd, sim),
                          /*initiate reset*/TRUE);
        ahd_unlock(ahd, &s);
        return;
}

int
ahd_platform_alloc(struct ahd_softc *ahd, void *platform_arg)
{
        ahd->platform_data = malloc(sizeof(struct ahd_platform_data), M_DEVBUF,
                                    M_WAITOK | M_ZERO);
        return (0);
}

void
ahd_platform_free(struct ahd_softc *ahd)
{
        free(ahd->platform_data, M_DEVBUF);
}

int
ahd_softc_comp(struct ahd_softc *lahd, struct ahd_softc *rahd)
{
        /* We don't sort softcs under NetBSD so report equal always */
        return (0);
}

int
ahd_detach(struct ahd_softc *ahd, int flags)
{
        int rv = 0;

        if (ahd->sc_child != NULL)
                rv = config_detach(ahd->sc_child, flags);

        pmf_device_deregister(ahd->sc_dev);

        ahd_free(ahd);

        return rv;
}

void
ahd_platform_set_tags(struct ahd_softc *ahd,
                      struct ahd_devinfo *devinfo, ahd_queue_alg alg)
{
        struct ahd_tmode_tstate *tstate;

        ahd_fetch_transinfo(ahd, devinfo->channel, devinfo->our_scsiid,
                            devinfo->target, &tstate);

        if (alg != AHD_QUEUE_NONE)
                tstate->tagenable |= devinfo->target_mask;
        else
                tstate->tagenable &= ~devinfo->target_mask;
}

void
ahd_send_async(struct ahd_softc *ahd, char channel, u_int target, u_int lun,
               ac_code code, void *opt_arg)
{
        struct ahd_tmode_tstate *tstate;
        struct ahd_initiator_tinfo *tinfo;
        struct ahd_devinfo devinfo;
        struct scsipi_channel *chan;
        struct scsipi_xfer_mode xm;

#ifdef DIAGNOSTIC
        if (channel != 'A')
                panic("ahd_send_async: not channel A");
#endif
        chan = &ahd->sc_channel;
        switch (code) {
        case AC_TRANSFER_NEG:
                tinfo = ahd_fetch_transinfo(ahd, channel, ahd->our_id, target,
                            &tstate);
                ahd_compile_devinfo(&devinfo, ahd->our_id, target, lun,
                    channel, ROLE_UNKNOWN);
                /*
                 * Don't bother if negotiating. XXX?
                 */
                if (tinfo->curr.period != tinfo->goal.period
                    || tinfo->curr.width != tinfo->goal.width
                    || tinfo->curr.offset != tinfo->goal.offset
                    || tinfo->curr.ppr_options != tinfo->goal.ppr_options)
                        break;
                xm.xm_target = target;
                xm.xm_mode = 0;
                xm.xm_period = tinfo->curr.period;
                xm.xm_offset = tinfo->curr.offset;
                if (tinfo->goal.ppr_options & MSG_EXT_PPR_DT_REQ)
                        xm.xm_mode |= PERIPH_CAP_DT;
                if (tinfo->curr.width == MSG_EXT_WDTR_BUS_16_BIT)
                        xm.xm_mode |= PERIPH_CAP_WIDE16;
                if (tinfo->curr.period)
                        xm.xm_mode |= PERIPH_CAP_SYNC;
                if (tstate->tagenable & devinfo.target_mask)
                        xm.xm_mode |= PERIPH_CAP_TQING;
                scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, &xm);
                break;
        case AC_BUS_RESET:
                scsipi_async_event(chan, ASYNC_EVENT_RESET, NULL);
        case AC_SENT_BDR:
        default:
                break;
        }
}