/*      $NetBSD: vioscsi.c,v 1.36 2023/03/25 11:04:34 mlelstv Exp $     */
/*      $OpenBSD: vioscsi.c,v 1.3 2015/03/14 03:38:49 jsg Exp $ */

/*
 * Copyright (c) 2013 Google Inc.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: vioscsi.c,v 1.36 2023/03/25 11:04:34 mlelstv Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/bus.h>
#include <sys/buf.h>
#include <sys/module.h>

#include <dev/pci/vioscsireg.h>
#include <dev/pci/virtiovar.h>

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

#ifdef VIOSCSI_DEBUG
static int vioscsi_debug = 1;
#define DPRINTF(f) do { if (vioscsi_debug) printf f; } while (/*CONSTCOND*/0)
#else
#define DPRINTF(f) ((void)0)
#endif

struct vioscsi_req {
        struct virtio_scsi_req_hdr       vr_req;
        struct virtio_scsi_res_hdr       vr_res;
        struct scsipi_xfer              *vr_xs;
        bus_dmamap_t                     vr_control;
        bus_dmamap_t                     vr_data;
};

struct vioscsi_softc {
        device_t                 sc_dev;
        struct scsipi_adapter    sc_adapter;
        struct scsipi_channel    sc_channel;

        struct virtqueue         sc_vqs[3];
#define VIOSCSI_VQ_CONTROL      0
#define VIOSCSI_VQ_EVENT        1
#define VIOSCSI_VQ_REQUEST      2

        struct vioscsi_req      *sc_reqs;
        int                      sc_nreqs;
        bus_dma_segment_t        sc_reqs_segs[1];

        u_int32_t                sc_seg_max;

        kmutex_t                 sc_mutex;
};

/*
 * Each block request uses at least two segments - one for the header
 * and one for the status.
*/
#define VIRTIO_SCSI_MIN_SEGMENTS 2

static int       vioscsi_match(device_t, cfdata_t, void *);
static void      vioscsi_attach(device_t, device_t, void *);
static int       vioscsi_detach(device_t, int);

static int       vioscsi_alloc_reqs(struct vioscsi_softc *,
    struct virtio_softc *, int);
static void      vioscsi_free_reqs(struct vioscsi_softc *,
    struct virtio_softc *);
static void      vioscsi_scsipi_request(struct scsipi_channel *,
    scsipi_adapter_req_t, void *);
static int       vioscsi_vq_done(struct virtqueue *);
static void      vioscsi_req_done(struct vioscsi_softc *, struct virtio_softc *,
    struct vioscsi_req *, struct virtqueue *, int);
static struct vioscsi_req *vioscsi_req_get(struct vioscsi_softc *);
static void      vioscsi_bad_target(struct scsipi_xfer *);

static const char *const vioscsi_vq_names[] = {
        "control",
        "event",
        "request",
};

CFATTACH_DECL3_NEW(vioscsi, sizeof(struct vioscsi_softc),
    vioscsi_match, vioscsi_attach, vioscsi_detach, NULL, NULL, NULL,
    DVF_DETACH_SHUTDOWN);

static int
vioscsi_match(device_t parent, cfdata_t match, void *aux)
{
        struct virtio_attach_args *va = aux;

        if (va->sc_childdevid == VIRTIO_DEVICE_ID_SCSI)
                return 1;

        return 0;
}

static void
vioscsi_attach(device_t parent, device_t self, void *aux)
{
        struct vioscsi_softc *sc = device_private(self);
        struct virtio_softc *vsc = device_private(parent);
        struct scsipi_adapter *adapt = &sc->sc_adapter;
        struct scsipi_channel *chan = &sc->sc_channel;
        int rv, qsize = 0, i = 0;
        int ipl = IPL_BIO;

        if (virtio_child(vsc) != NULL) {
                aprint_error(": parent %s already has a child\n",
                    device_xname(parent));
                return;
        }

        sc->sc_dev = self;

        virtio_child_attach_start(vsc, self, ipl,
            0, VIRTIO_COMMON_FLAG_BITS);

        mutex_init(&sc->sc_mutex, MUTEX_DEFAULT, ipl);

        uint32_t cmd_per_lun = virtio_read_device_config_4(vsc,
            VIRTIO_SCSI_CONFIG_CMD_PER_LUN);

        uint32_t seg_max = virtio_read_device_config_4(vsc,
            VIRTIO_SCSI_CONFIG_SEG_MAX);

        uint16_t max_target = virtio_read_device_config_2(vsc,
            VIRTIO_SCSI_CONFIG_MAX_TARGET);

        uint32_t max_lun = virtio_read_device_config_4(vsc,
            VIRTIO_SCSI_CONFIG_MAX_LUN);

        sc->sc_seg_max = seg_max;

        for(i=0; i < __arraycount(sc->sc_vqs); i++) {
                virtio_init_vq_vqdone(vsc, &sc->sc_vqs[i], i,
                    vioscsi_vq_done);
                rv = virtio_alloc_vq(vsc, &sc->sc_vqs[i], MAXPHYS,
                    VIRTIO_SCSI_MIN_SEGMENTS + howmany(MAXPHYS, NBPG),
                    vioscsi_vq_names[i]);
                if (rv) {
                        aprint_error_dev(sc->sc_dev,
                            "failed to allocate virtqueue %d\n", i);
                        goto err;
                }

                if (i == VIOSCSI_VQ_REQUEST)
                        sc->sc_vqs[i].vq_done = vioscsi_vq_done;
        }

        qsize = sc->sc_vqs[VIOSCSI_VQ_REQUEST].vq_num;
        if (vioscsi_alloc_reqs(sc, vsc, qsize))
                goto err;

        aprint_normal_dev(sc->sc_dev,
            "cmd_per_lun %u qsize %d seg_max %u max_target %hu"
            " max_lun %u\n",
            cmd_per_lun, qsize, seg_max, max_target, max_lun);

        if (virtio_child_attach_finish(vsc, sc->sc_vqs,
            __arraycount(sc->sc_vqs), NULL,
            VIRTIO_F_INTR_MSIX | VIRTIO_F_INTR_MPSAFE) != 0)
                goto err;

        /*
         * Fill in the scsipi_adapter.
         */
        memset(adapt, 0, sizeof(*adapt));
        adapt->adapt_dev = sc->sc_dev;
        adapt->adapt_nchannels = 1;
        adapt->adapt_openings = MIN(qsize, cmd_per_lun);
        adapt->adapt_max_periph = adapt->adapt_openings;
        adapt->adapt_request = vioscsi_scsipi_request;
        adapt->adapt_minphys = minphys;
        adapt->adapt_flags = SCSIPI_ADAPT_MPSAFE;

        /*
         * Fill in the scsipi_channel.
         */
        memset(chan, 0, sizeof(*chan));
        chan->chan_adapter = adapt;
        chan->chan_bustype = &scsi_bustype;
        chan->chan_channel = 0;
        chan->chan_ntargets = MIN(1 + max_target, 256); /* cap reasonably */
        chan->chan_nluns = MIN(1 + max_lun, 16384);     /* cap reasonably */
        chan->chan_id = max_target + 1;
        chan->chan_flags = SCSIPI_CHAN_NOSETTLE;

        config_found(self, &sc->sc_channel, scsiprint, CFARGS_NONE);
        return;

err:
        if (qsize > 0)
                vioscsi_free_reqs(sc, vsc);

        for (i=0; i < __arraycount(sc->sc_vqs); i++) {
                virtio_free_vq(vsc, &sc->sc_vqs[i]);
        }

        virtio_child_attach_failed(vsc);
}

static int
vioscsi_detach(device_t self, int flags)
{
        struct vioscsi_softc *sc = device_private(self);
        struct virtio_softc *vsc = device_private(device_parent(sc->sc_dev));
        int rc, i;

        /*
         * Dequeue all pending finished requests. Must be done
         * before we try to detach children so that we process
         * their pending requests while they still exist.
         */
        if (sc->sc_vqs[VIOSCSI_VQ_REQUEST].vq_num > 0)
                vioscsi_vq_done(&sc->sc_vqs[VIOSCSI_VQ_REQUEST]);

        if ((rc = config_detach_children(self, flags)) != 0)
                return rc;

        virtio_reset(vsc);

        for (i = 0; i < __arraycount(sc->sc_vqs); i++) {
                if (sc->sc_vqs[i].vq_num > 0)
                        virtio_free_vq(vsc, &sc->sc_vqs[i]);
        }

        vioscsi_free_reqs(sc, vsc);

        virtio_child_detach(vsc);

        mutex_destroy(&sc->sc_mutex);

        return 0;
}

#define XS2DMA(xs) \
    ((((xs)->xs_control & XS_CTL_DATA_IN) ? BUS_DMA_READ : BUS_DMA_WRITE) | \
    (((xs)->xs_control & XS_CTL_NOSLEEP) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK) | \
    BUS_DMA_STREAMING)

#define XS2DMAPRE(xs) (((xs)->xs_control & XS_CTL_DATA_IN) ? \
    BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE)

#define XS2DMAPOST(xs) (((xs)->xs_control & XS_CTL_DATA_IN) ? \
    BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE)

static void
vioscsi_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t
    request, void *arg)
{
        struct vioscsi_softc *sc =
            device_private(chan->chan_adapter->adapt_dev);
        struct virtio_softc *vsc = device_private(device_parent(sc->sc_dev));
        struct scsipi_xfer *xs;
        struct scsipi_periph *periph;
        struct vioscsi_req *vr;
        struct virtio_scsi_req_hdr *req;
        struct virtqueue *vq = &sc->sc_vqs[VIOSCSI_VQ_REQUEST];
        int slot, error;
        bool dopoll;

        DPRINTF(("%s: enter\n", __func__));

        switch (request) {
        case ADAPTER_REQ_RUN_XFER:
                break;
        case ADAPTER_REQ_SET_XFER_MODE:
        {
                struct scsipi_xfer_mode *xm = arg;
                xm->xm_mode = PERIPH_CAP_TQING;
                xm->xm_period = 0;
                xm->xm_offset = 0;
                scsipi_async_event(chan, ASYNC_EVENT_XFER_MODE, xm);
                return;
        }
        default:
                DPRINTF(("%s: unhandled %d\n", __func__, request));
                return;
        }

        xs = arg;
        periph = xs->xs_periph;

        /*
         * This can happen when we run out of queue slots.
         */
        vr = vioscsi_req_get(sc);
        if (vr == NULL) {
                xs->error = XS_BUSY;
                scsipi_done(xs);
                return;
        }

        req = &vr->vr_req;
        slot = vr - sc->sc_reqs;

        /*
         * "The only supported format for the LUN field is: first byte set to
         * 1, second byte set to target, third and fourth byte representing a
         * single level LUN structure, followed by four zero bytes."
         */
        if (periph->periph_target >= 256 || periph->periph_lun >= 16384
            || periph->periph_target < 0 || periph->periph_lun < 0) {
                goto stuffup;
        }

        req->lun[0] = 1;
        req->lun[1] = periph->periph_target;
        req->lun[2] = 0x40 | ((periph->periph_lun >> 8) & 0x3F);
        req->lun[3] = periph->periph_lun & 0xFF;
        memset(req->lun + 4, 0, 4);
        DPRINTF(("%s: command %p for %d:%d at slot %d\n", __func__,
            xs, periph->periph_target, periph->periph_lun, slot));

        /* tag */
        switch (XS_CTL_TAGTYPE(xs)) {
        case XS_CTL_HEAD_TAG:
                req->task_attr = VIRTIO_SCSI_S_HEAD;
                break;

#if 0   /* XXX */
        case XS_CTL_ACA_TAG:
                req->task_attr = VIRTIO_SCSI_S_ACA;
                break;
#endif

        case XS_CTL_ORDERED_TAG:
                req->task_attr = VIRTIO_SCSI_S_ORDERED;
                break;

        case XS_CTL_SIMPLE_TAG:
        default:
                req->task_attr = VIRTIO_SCSI_S_SIMPLE;
                break;
        }
        req->id = virtio_rw64(vsc, slot);

        if ((size_t)xs->cmdlen > sizeof(req->cdb)) {
                DPRINTF(("%s: bad cmdlen %zu > %zu\n", __func__,
                    (size_t)xs->cmdlen, sizeof(req->cdb)));
                goto stuffup;
        }

        memset(req->cdb, 0, sizeof(req->cdb));
        memcpy(req->cdb, xs->cmd, xs->cmdlen);

        error = bus_dmamap_load(virtio_dmat(vsc), vr->vr_data,
            xs->data, xs->datalen, NULL, XS2DMA(xs));
        if (error) {
                aprint_error_dev(sc->sc_dev, "%s: error %d loading DMA map\n",
                    __func__, error);

                if (error == ENOMEM || error == EAGAIN) {
                        /*
                         * Map is allocated with ALLOCNOW, so this should
                         * actually never ever happen.
                         */
                        xs->error = XS_RESOURCE_SHORTAGE;
                } else {
stuffup:
                        /* not a temporary condition */
                        xs->error = XS_DRIVER_STUFFUP;
                }

                virtio_enqueue_abort(vsc, vq, slot);
                scsipi_done(xs);
                return;
        }

        int nsegs = VIRTIO_SCSI_MIN_SEGMENTS;
        if ((xs->xs_control & (XS_CTL_DATA_IN|XS_CTL_DATA_OUT)) != 0)
                nsegs += vr->vr_data->dm_nsegs;

        error = virtio_enqueue_reserve(vsc, vq, slot, nsegs);
        if (error) {
                bus_dmamap_unload(virtio_dmat(vsc), vr->vr_data);
                /* slot already freed by virtio_enqueue_reserve() */
                xs->error = XS_BUSY;
                scsipi_done(xs);
                return;
        }

        vr->vr_xs = xs;

        bus_dmamap_sync(virtio_dmat(vsc), vr->vr_control,
            offsetof(struct vioscsi_req, vr_req),
            sizeof(struct virtio_scsi_req_hdr),
            BUS_DMASYNC_PREWRITE);
        bus_dmamap_sync(virtio_dmat(vsc), vr->vr_control,
            offsetof(struct vioscsi_req, vr_res),
            sizeof(struct virtio_scsi_res_hdr),
            BUS_DMASYNC_PREREAD);
        if ((xs->xs_control & (XS_CTL_DATA_IN|XS_CTL_DATA_OUT)) != 0)
                bus_dmamap_sync(virtio_dmat(vsc), vr->vr_data, 0, xs->datalen,
                    XS2DMAPRE(xs));

        virtio_enqueue_p(vsc, vq, slot, vr->vr_control,
            offsetof(struct vioscsi_req, vr_req),
            sizeof(struct virtio_scsi_req_hdr), 1);
        if (xs->xs_control & XS_CTL_DATA_OUT)
                virtio_enqueue(vsc, vq, slot, vr->vr_data, 1);
        virtio_enqueue_p(vsc, vq, slot, vr->vr_control,
            offsetof(struct vioscsi_req, vr_res),
            sizeof(struct virtio_scsi_res_hdr), 0);
        if (xs->xs_control & XS_CTL_DATA_IN)
                virtio_enqueue(vsc, vq, slot, vr->vr_data, 0);
        dopoll = (xs->xs_control & XS_CTL_POLL) != 0;
        virtio_enqueue_commit(vsc, vq, slot, 1);

        if (!dopoll)
                return;

        DPRINTF(("%s: polling...\n", __func__));
        // XXX: do this better.
        int timeout = 1000;
        do {
                virtio_intrhand(vsc);
                if (vr->vr_xs != xs)
                        break;
                delay(1000);
        } while (--timeout > 0);

        if (vr->vr_xs == xs) {
                // XXX: Abort!
                xs->error = XS_TIMEOUT;
                xs->resid = xs->datalen;
                DPRINTF(("%s: polling timeout\n", __func__));
                scsipi_done(xs);
        }
        DPRINTF(("%s: command %p done (timeout=%d)\n", __func__,
            xs, timeout));
}

static void
vioscsi_req_done(struct vioscsi_softc *sc, struct virtio_softc *vsc,
    struct vioscsi_req *vr, struct virtqueue *vq, int slot)
{
        struct scsipi_xfer *xs = vr->vr_xs;
        size_t sense_len;

        DPRINTF(("%s: enter\n", __func__));

        bus_dmamap_sync(virtio_dmat(vsc), vr->vr_control,
            offsetof(struct vioscsi_req, vr_req),
            sizeof(struct virtio_scsi_req_hdr),
            BUS_DMASYNC_POSTWRITE);
        bus_dmamap_sync(virtio_dmat(vsc), vr->vr_control,
            offsetof(struct vioscsi_req, vr_res),
            sizeof(struct virtio_scsi_res_hdr),
            BUS_DMASYNC_POSTREAD);
        if (xs->datalen)
                bus_dmamap_sync(virtio_dmat(vsc), vr->vr_data, 0, xs->datalen,
                    XS2DMAPOST(xs));

        xs->status = vr->vr_res.status;
        xs->resid  = virtio_rw32(vsc, vr->vr_res.residual);

        switch (vr->vr_res.response) {
        case VIRTIO_SCSI_S_OK:
                sense_len = MIN(sizeof(xs->sense),
                                virtio_rw32(vsc, vr->vr_res.sense_len));
                memcpy(&xs->sense, vr->vr_res.sense, sense_len);
                xs->error = (sense_len == 0) ? XS_NOERROR : XS_SENSE;
                break;
        case VIRTIO_SCSI_S_BAD_TARGET:
                vioscsi_bad_target(xs);
                break;
        default:
                DPRINTF(("%s: stuffup: %d\n", __func__, vr->vr_res.response));
                xs->error = XS_DRIVER_STUFFUP;
                xs->resid = xs->datalen;
                break;
        }

        DPRINTF(("%s: command %p done %d, %d, %d\n", __func__,
            xs, xs->error, xs->status, xs->resid));

        bus_dmamap_unload(virtio_dmat(vsc), vr->vr_data);
        vr->vr_xs = NULL;

        virtio_dequeue_commit(vsc, vq, slot);

        mutex_exit(&sc->sc_mutex);
        scsipi_done(xs);
        mutex_enter(&sc->sc_mutex);
}

static void
vioscsi_bad_target(struct scsipi_xfer *xs)
{
        struct scsi_sense_data *sense = &xs->sense.scsi_sense;

        DPRINTF(("%s: bad target %d:%d\n", __func__,
            xs->xs_periph->periph_target, xs->xs_periph->periph_lun));

        memset(sense, 0, sizeof(*sense));
        sense->response_code = 0x70;
        sense->flags = SKEY_ILLEGAL_REQUEST;
        xs->error = XS_SENSE;
        xs->status = 0;
        xs->resid = 0;
}

static int
vioscsi_vq_done(struct virtqueue *vq)
{
        struct virtio_softc *vsc = vq->vq_owner;
        struct vioscsi_softc *sc = device_private(virtio_child(vsc));
        int ret = 0;

        DPRINTF(("%s: enter %d\n", __func__, vq->vq_index));

        mutex_enter(&sc->sc_mutex);

        for (;;) {
                int r, slot;

                r = virtio_dequeue(vsc, vq, &slot, NULL);
                if (r != 0)
                        break;

                DPRINTF(("%s: slot=%d\n", __func__, slot));

                vioscsi_req_done(sc, vsc, &sc->sc_reqs[slot], vq, slot);

                ret = 1;
        }

        mutex_exit(&sc->sc_mutex);

        DPRINTF(("%s: exit %d: %d\n", __func__, vq->vq_index, ret));

        return ret;
}

static struct vioscsi_req *
vioscsi_req_get(struct vioscsi_softc *sc)
{
        struct virtio_softc *vsc = device_private(device_parent(sc->sc_dev));
        struct virtqueue *vq = &sc->sc_vqs[VIOSCSI_VQ_REQUEST];
        struct vioscsi_req *vr = NULL;
        int r, slot;

        mutex_enter(&sc->sc_mutex);

        if ((r = virtio_enqueue_prep(vsc, vq, &slot)) != 0) {
                DPRINTF(("%s: virtio_enqueue_get error %d\n", __func__, r));
                goto out;
        }
        KASSERT(slot < sc->sc_nreqs);
        vr = &sc->sc_reqs[slot];

        DPRINTF(("%s: %p, %d\n", __func__, vr, slot));

out:
        mutex_exit(&sc->sc_mutex);

        return vr;
}

static int
vioscsi_alloc_reqs(struct vioscsi_softc *sc, struct virtio_softc *vsc,
    int qsize)
{
        size_t allocsize;
        int r, rsegs, slot;
        void *vaddr;
        struct vioscsi_req *vr;

        allocsize = qsize * sizeof(struct vioscsi_req);
        r = bus_dmamem_alloc(virtio_dmat(vsc), allocsize, 0, 0,
            &sc->sc_reqs_segs[0], 1, &rsegs, BUS_DMA_NOWAIT);
        if (r != 0) {
                aprint_error_dev(sc->sc_dev,
                    "%s: bus_dmamem_alloc, size %zu, error %d\n", __func__,
                    allocsize, r);
                return r;
        }
        r = bus_dmamem_map(virtio_dmat(vsc), &sc->sc_reqs_segs[0], 1,
            allocsize, &vaddr, BUS_DMA_NOWAIT);
        if (r != 0) {
                aprint_error_dev(sc->sc_dev,
                    "%s: bus_dmamem_map failed, error %d\n", __func__, r);
                bus_dmamem_free(virtio_dmat(vsc), &sc->sc_reqs_segs[0], 1);
                return r;
        }
        memset(vaddr, 0, allocsize);

        sc->sc_reqs = vaddr;
        sc->sc_nreqs = qsize;

        /* Prepare maps for the requests */
        for (slot=0; slot < qsize; slot++) {
                vr = &sc->sc_reqs[slot];

                r = bus_dmamap_create(virtio_dmat(vsc),
                    offsetof(struct vioscsi_req, vr_xs), 1,
                    offsetof(struct vioscsi_req, vr_xs), 0,
                    BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &vr->vr_control);
                if (r != 0) {
                        aprint_error_dev(sc->sc_dev,
                            "%s: bus_dmamap_create ctrl failed, error %d\n",
                            __func__, r);
                        goto cleanup;
                }

                r = bus_dmamap_create(virtio_dmat(vsc), MAXPHYS, sc->sc_seg_max,
                    MAXPHYS, 0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &vr->vr_data);
                if (r != 0) {
                        aprint_error_dev(sc->sc_dev,
                            "%s: bus_dmamap_create data failed, error %d\n",
                            __func__, r);
                        goto cleanup;
                }

                r = bus_dmamap_load(virtio_dmat(vsc), vr->vr_control,
                    vr, offsetof(struct vioscsi_req, vr_xs), NULL,
                    BUS_DMA_NOWAIT);
                if (r != 0) {
                        aprint_error_dev(sc->sc_dev,
                            "%s: bus_dmamap_load ctrl error %d\n",
                            __func__, r);
                        goto cleanup;
                }
        }

        return 0;

cleanup:
        for (; slot > 0; slot--) {
                vr = &sc->sc_reqs[slot];

                if (vr->vr_control) {
                        /* this will also unload the mapping if loaded */
                        bus_dmamap_destroy(virtio_dmat(vsc), vr->vr_control);
                        vr->vr_control = NULL;
                }

                if (vr->vr_data) {
                        bus_dmamap_destroy(virtio_dmat(vsc), vr->vr_data);
                        vr->vr_data = NULL;
                }
        }

        bus_dmamem_unmap(virtio_dmat(vsc), vaddr, allocsize);
        bus_dmamem_free(virtio_dmat(vsc), &sc->sc_reqs_segs[0], 1);

        return r;
}

static void
vioscsi_free_reqs(struct vioscsi_softc *sc, struct virtio_softc *vsc)
{
        int slot;
        struct vioscsi_req *vr;

        if (sc->sc_nreqs == 0) {
                /* Not allocated */
                return;
        }

        /* Free request maps */
        for (slot=0; slot < sc->sc_nreqs; slot++) {
                vr = &sc->sc_reqs[slot];

                bus_dmamap_destroy(virtio_dmat(vsc), vr->vr_control);
                bus_dmamap_destroy(virtio_dmat(vsc), vr->vr_data);
        }

        bus_dmamem_unmap(virtio_dmat(vsc), sc->sc_reqs,
                         sc->sc_nreqs * sizeof(struct vioscsi_req));
        bus_dmamem_free(virtio_dmat(vsc), &sc->sc_reqs_segs[0], 1);
}

MODULE(MODULE_CLASS_DRIVER, vioscsi, "virtio");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
vioscsi_modcmd(modcmd_t cmd, void *opaque)
{
        int error = 0;

#ifdef _MODULE
        switch (cmd) {
        case MODULE_CMD_INIT:
                error = config_init_component(cfdriver_ioconf_vioscsi,
                    cfattach_ioconf_vioscsi, cfdata_ioconf_vioscsi);
                break;
        case MODULE_CMD_FINI:
                error = config_fini_component(cfdriver_ioconf_vioscsi,
                    cfattach_ioconf_vioscsi, cfdata_ioconf_vioscsi);
                break;
        default:
                error = ENOTTY;
                break;
        }
#endif

        return error;
}