Module Name: src
Committed By: snj
Date: Fri Dec 23 06:33:56 UTC 2016
Modified Files:
src/sys/arch/amd64/conf [netbsd-7]: GENERIC
src/sys/dev/pci [netbsd-7]: files.pci virtioreg.h
Added Files:
src/sys/dev/pci [netbsd-7]: vioscsi.c vioscsireg.h
Log Message:
Pull up following revision(s) (requested by bsiegert in ticket #1338):
sys/arch/amd64/conf/GENERIC: revision 1.418
sys/dev/pci/files.pci: revision 1.379
sys/dev/pci/vioscsi.c: revisions 1.1-1.8
sys/dev/pci/vioscsireg.h: revision 1.1
sys/dev/pci/virtioreg.h: revisions 1.5, 1.6
add the common flag bits
--
Add vioscsi, compile tested only (toxic)
--
this is working now, remove debugging.
--
add vioscsi
--
kill some more debugging.
--
Fake mode sense data for illegal targets. qemu reports 256 targets...
--
fix the status return.
--
Use SCSIPI_CHAN_NOSETTLE.
--
vioscsi_req_get()/virtio_enqueue_prep() failing is actually perfectly
normal - observed failures included 10, 27, 61 in-flight commands,
so probably depends on particular command mix; return with
XS_RESOURCE_SHORTAGE rather then panic
do vioscsi_req_put() when initial bus_dmamap_load() fails, as suggested
by the XXX; the vq_done hook is called by virtio, but in that case we
never get to commit the request to it
--
react on ADAPTER_REQ_SET_XFER_MODE so that we set tagged queuing
pass tag type and set id
To generate a diff of this commit:
cvs rdiff -u -r1.392.2.8 -r1.392.2.9 src/sys/arch/amd64/conf/GENERIC
cvs rdiff -u -r1.371.4.3 -r1.371.4.4 src/sys/dev/pci/files.pci
cvs rdiff -u -r0 -r1.8.2.2 src/sys/dev/pci/vioscsi.c
cvs rdiff -u -r0 -r1.1.6.2 src/sys/dev/pci/vioscsireg.h
cvs rdiff -u -r1.2 -r1.2.4.1 src/sys/dev/pci/virtioreg.h
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/arch/amd64/conf/GENERIC
diff -u src/sys/arch/amd64/conf/GENERIC:1.392.2.8 src/sys/arch/amd64/conf/GENERIC:1.392.2.9
--- src/sys/arch/amd64/conf/GENERIC:1.392.2.8 Fri Dec 9 05:10:45 2016
+++ src/sys/arch/amd64/conf/GENERIC Fri Dec 23 06:33:56 2016
@@ -1,4 +1,4 @@
-# $NetBSD: GENERIC,v 1.392.2.8 2016/12/09 05:10:45 snj Exp $
+# $NetBSD: GENERIC,v 1.392.2.9 2016/12/23 06:33:56 snj Exp $
#
# GENERIC machine description file
#
@@ -22,7 +22,7 @@ include "arch/amd64/conf/std.amd64"
options INCLUDE_CONFIG_FILE # embed config file in kernel binary
-#ident "GENERIC-$Revision: 1.392.2.8 $"
+#ident "GENERIC-$Revision: 1.392.2.9 $"
maxusers 64 # estimated number of users
@@ -1188,7 +1188,7 @@ viomb* at virtio? # Virtio memory ball
ld* at virtio? # Virtio disk device
vioif* at virtio? # Virtio network device
viornd* at virtio? # Virtio entropy device
-
+vioscsi* at virtio? # Virtio SCSI device
# Pull in optional local configuration
cinclude "arch/amd64/conf/GENERIC.local"
Index: src/sys/dev/pci/files.pci
diff -u src/sys/dev/pci/files.pci:1.371.4.3 src/sys/dev/pci/files.pci:1.371.4.4
--- src/sys/dev/pci/files.pci:1.371.4.3 Sun Apr 19 06:45:17 2015
+++ src/sys/dev/pci/files.pci Fri Dec 23 06:33:56 2016
@@ -1,4 +1,4 @@
-# $NetBSD: files.pci,v 1.371.4.3 2015/04/19 06:45:17 riz Exp $
+# $NetBSD: files.pci,v 1.371.4.4 2016/12/23 06:33:56 snj Exp $
#
# Config file and device description for machine-independent PCI code.
# Included by ports that need it. Requires that the SCSI files be
@@ -1131,7 +1131,11 @@ file dev/pci/if_vioif.c vioif
device viornd
attach viornd at virtio
-file dev/pci/viornd.c viornd
+file dev/pci/viornd.c viornd
+
+device vioscsi: scsi
+attach vioscsi at virtio
+file dev/pci/vioscsi.c vioscsi
# Silicon Motion SM712(LynxEM+) frame buffer
device lynxfb: wsemuldisplaydev, rasops16
Index: src/sys/dev/pci/virtioreg.h
diff -u src/sys/dev/pci/virtioreg.h:1.2 src/sys/dev/pci/virtioreg.h:1.2.4.1
--- src/sys/dev/pci/virtioreg.h:1.2 Fri Dec 6 02:39:58 2013
+++ src/sys/dev/pci/virtioreg.h Fri Dec 23 06:33:56 2016
@@ -1,4 +1,4 @@
-/* $NetBSD: virtioreg.h,v 1.2 2013/12/06 02:39:58 yamt Exp $ */
+/* $NetBSD: virtioreg.h,v 1.2.4.1 2016/12/23 06:33:56 snj Exp $ */
/*
* Copyright (c) 2010 Minoura Makoto.
@@ -73,7 +73,11 @@
#define PCI_PRODUCT_VIRTIO_CONSOLE 3
#define PCI_PRODUCT_VIRTIO_ENTROPY 4
#define PCI_PRODUCT_VIRTIO_BALLOON 5
+#define PCI_PRODUCT_VIRTIO_IOMEM 6
+#define PCI_PRODUCT_VIRTIO_RPMSG 7
+#define PCI_PRODUCT_VIRTIO_SCSI 8
#define PCI_PRODUCT_VIRTIO_9P 9
+#define PCI_PRODUCT_VIRTIO_MAC80211 10
/* Virtio header */
#define VIRTIO_CONFIG_DEVICE_FEATURES 0 /* 32bit */
@@ -97,6 +101,13 @@
#define VIRTIO_CONFIG_DEVICE_CONFIG_NOMSI 20
#define VIRTIO_CONFIG_DEVICE_CONFIG_MSI 22
+#define VIRTIO_COMMON_FLAG_BITS \
+ "\20" \
+ "\x1f""BAD_FEATURE" \
+ "\x1e""EVENT_IDX" \
+ "\x1d""INDIRECT_DESC" \
+ "\x19""NOTIFY_ON_EMPTY"
+
/* Virtqueue */
/* This marks a buffer as continuing via the next field. */
#define VRING_DESC_F_NEXT 1
Added files:
Index: src/sys/dev/pci/vioscsi.c
diff -u /dev/null src/sys/dev/pci/vioscsi.c:1.8.2.2
--- /dev/null Fri Dec 23 06:33:56 2016
+++ src/sys/dev/pci/vioscsi.c Fri Dec 23 06:33:56 2016
@@ -0,0 +1,559 @@
+/* $NetBSD: vioscsi.c,v 1.8.2.2 2016/12/23 06:33:56 snj 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.8.2.2 2016/12/23 06:33:56 snj Exp $");
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/device.h>
+#include <sys/bus.h>
+#include <sys/buf.h>
+
+#include <dev/pci/pcidevs.h>
+#include <dev/pci/pcireg.h>
+#include <dev/pci/pcivar.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];
+ struct vioscsi_req *sc_reqs;
+ bus_dma_segment_t sc_reqs_segs[1];
+
+ u_int32_t sc_seg_max;
+};
+
+/*
+ * 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_alloc_reqs(struct vioscsi_softc *,
+ struct virtio_softc *, int, uint32_t);
+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 *);
+static struct vioscsi_req *vioscsi_req_get(struct vioscsi_softc *);
+static void vioscsi_req_put(struct vioscsi_softc *, struct vioscsi_req *);
+
+static const char *const vioscsi_vq_names[] = {
+ "control",
+ "event",
+ "request",
+};
+
+CFATTACH_DECL_NEW(vioscsi, sizeof(struct vioscsi_softc),
+ vioscsi_match, vioscsi_attach, NULL, NULL);
+
+static int
+vioscsi_match(device_t parent, cfdata_t match, void *aux)
+{
+ struct virtio_softc *va = aux;
+
+ if (va->sc_childdevid == PCI_PRODUCT_VIRTIO_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;
+ uint32_t features;
+ char buf[256];
+ int rv;
+
+ if (vsc->sc_child != NULL) {
+ aprint_error(": parent %s already has a child\n",
+ device_xname(parent));
+ return;
+ }
+
+ sc->sc_dev = self;
+
+ vsc->sc_child = self;
+ vsc->sc_ipl = IPL_BIO;
+ vsc->sc_vqs = sc->sc_vqs;
+ vsc->sc_nvqs = __arraycount(sc->sc_vqs);
+ vsc->sc_config_change = NULL;
+ vsc->sc_intrhand = virtio_vq_intr;
+ vsc->sc_flags = 0;
+
+ features = virtio_negotiate_features(vsc, 0);
+ snprintb(buf, sizeof(buf), VIRTIO_COMMON_FLAG_BITS, features);
+ aprint_normal(": Features: %s\n", buf);
+ aprint_naive("\n");
+
+ 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);
+
+ uint16_t max_channel = virtio_read_device_config_2(vsc,
+ VIRTIO_SCSI_CONFIG_MAX_CHANNEL);
+
+ uint32_t max_lun = virtio_read_device_config_4(vsc,
+ VIRTIO_SCSI_CONFIG_MAX_LUN);
+
+ sc->sc_seg_max = seg_max;
+
+ for (size_t i = 0; i < __arraycount(sc->sc_vqs); i++) {
+ rv = virtio_alloc_vq(vsc, &sc->sc_vqs[i], i, MAXPHYS,
+ 1 + howmany(MAXPHYS, NBPG), vioscsi_vq_names[i]);
+ if (rv) {
+ aprint_error_dev(sc->sc_dev,
+ "failed to allocate virtqueue %zu\n", i);
+ return;
+ }
+ sc->sc_vqs[i].vq_done = vioscsi_vq_done;
+ }
+
+ int qsize = sc->sc_vqs[2].vq_num;
+ aprint_normal_dev(sc->sc_dev, "qsize %d\n", qsize);
+ if (vioscsi_alloc_reqs(sc, vsc, qsize, seg_max))
+ return;
+
+ /*
+ * Fill in the scsipi_adapter.
+ */
+ memset(adapt, 0, sizeof(*adapt));
+ adapt->adapt_dev = sc->sc_dev;
+ adapt->adapt_nchannels = max_channel;
+ adapt->adapt_openings = cmd_per_lun;
+ adapt->adapt_max_periph = adapt->adapt_openings;
+ adapt->adapt_request = vioscsi_scsipi_request;
+ adapt->adapt_minphys = minphys;
+
+ /*
+ * 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 = max_target;
+ chan->chan_nluns = max_lun;
+ chan->chan_id = 0;
+ chan->chan_flags = SCSIPI_CHAN_NOSETTLE;
+
+ config_found(sc->sc_dev, &sc->sc_channel, scsiprint);
+}
+
+#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[2];
+ int slot, error;
+
+ 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;
+
+ vr = vioscsi_req_get(sc);
+ /*
+ * This can happen when we run out of queue slots.
+ */
+ if (vr == NULL) {
+ xs->error = XS_RESOURCE_SHORTAGE;
+ scsipi_done(xs);
+ return;
+ }
+
+ req = &vr->vr_req;
+ slot = vr - sc->sc_reqs;
+
+ vr->vr_xs = xs;
+
+ /*
+ * "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) {
+ DPRINTF(("%s: bad target %u or lun %u\n", __func__,
+ periph->periph_target, periph->periph_lun));
+ goto stuffup;
+ }
+ req->lun[0] = 1;
+ req->lun[1] = periph->periph_target - 1;
+ req->lun[2] = 0x40 | (periph->periph_lun >> 8);
+ req->lun[3] = periph->periph_lun;
+ memset(req->lun + 4, 0, 4);
+ DPRINTF(("%s: command for %u:%u at slot %d\n", __func__,
+ periph->periph_target - 1, 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 = (intptr_t)vr;
+
+ 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(vsc->sc_dmat, vr->vr_data,
+ xs->data, xs->datalen, NULL, XS2DMA(xs));
+ switch (error) {
+ case 0:
+ break;
+ case ENOMEM:
+ case EAGAIN:
+ xs->error = XS_RESOURCE_SHORTAGE;
+ goto nomore;
+ default:
+ aprint_error_dev(sc->sc_dev, "error %d loading DMA map\n",
+ error);
+ stuffup:
+ xs->error = XS_DRIVER_STUFFUP;
+nomore:
+ vioscsi_req_put(sc, vr);
+ 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) {
+ DPRINTF(("%s: error reserving %d\n", __func__, error));
+ goto stuffup;
+ }
+
+ bus_dmamap_sync(vsc->sc_dmat, vr->vr_control,
+ offsetof(struct vioscsi_req, vr_req),
+ sizeof(struct virtio_scsi_req_hdr),
+ BUS_DMASYNC_PREWRITE);
+ bus_dmamap_sync(vsc->sc_dmat, 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(vsc->sc_dmat, 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);
+ virtio_enqueue_commit(vsc, vq, slot, 1);
+
+ if ((xs->xs_control & XS_CTL_POLL) == 0)
+ return;
+
+ DPRINTF(("%s: polling...\n", __func__));
+ // XXX: do this better.
+ int timeout = 1000;
+ do {
+ (*vsc->sc_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: done (timeout=%d)\n", __func__, timeout));
+}
+
+static void
+vioscsi_req_done(struct vioscsi_softc *sc, struct virtio_softc *vsc,
+ struct vioscsi_req *vr)
+{
+ struct scsipi_xfer *xs = vr->vr_xs;
+ struct scsi_sense_data *sense = &xs->sense.scsi_sense;
+ size_t sense_len;
+
+ DPRINTF(("%s: enter\n", __func__));
+
+ bus_dmamap_sync(vsc->sc_dmat, vr->vr_control,
+ offsetof(struct vioscsi_req, vr_req),
+ sizeof(struct virtio_scsi_req_hdr),
+ BUS_DMASYNC_POSTWRITE);
+ bus_dmamap_sync(vsc->sc_dmat, vr->vr_control,
+ offsetof(struct vioscsi_req, vr_res),
+ sizeof(struct virtio_scsi_res_hdr),
+ BUS_DMASYNC_POSTREAD);
+ bus_dmamap_sync(vsc->sc_dmat, vr->vr_data, 0, xs->datalen,
+ XS2DMAPOST(xs));
+
+ switch (vr->vr_res.response) {
+ case VIRTIO_SCSI_S_OK:
+ sense_len = MIN(sizeof(xs->sense), 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:
+ DPRINTF(("%s: bad target\n", __func__));
+ memset(sense, 0, sizeof(*sense));
+ sense->response_code = 0x70;
+ sense->flags = SKEY_ILLEGAL_REQUEST;
+ xs->error = XS_SENSE;
+ xs->status = 0;
+ xs->resid = 0;
+ break;
+ default:
+ DPRINTF(("%s: stuffup: %d\n", __func__, vr->vr_res.response));
+ xs->error = XS_DRIVER_STUFFUP;
+ xs->resid = xs->datalen;
+ break;
+ }
+
+ xs->status = vr->vr_res.status;
+ xs->resid = vr->vr_res.residual;
+
+ DPRINTF(("%s: done %d, %d, %d\n", __func__,
+ xs->error, xs->status, xs->resid));
+
+ vr->vr_xs = NULL;
+ vioscsi_req_put(sc, vr);
+ scsipi_done(xs);
+}
+
+static int
+vioscsi_vq_done(struct virtqueue *vq)
+{
+ struct virtio_softc *vsc = vq->vq_owner;
+ struct vioscsi_softc *sc = device_private(vsc->sc_child);
+ int ret = 0;
+
+ DPRINTF(("%s: enter\n", __func__));
+
+ 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]);
+ ret = 1;
+ }
+
+ DPRINTF(("%s: exit %d\n", __func__, 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[2];
+ struct vioscsi_req *vr;
+ int r, slot;
+
+ if ((r = virtio_enqueue_prep(vsc, vq, &slot)) != 0) {
+ DPRINTF(("%s: virtio_enqueue_get error %d\n", __func__, r));
+ goto err1;
+ }
+ vr = &sc->sc_reqs[slot];
+
+ vr->vr_req.id = slot;
+ vr->vr_req.task_attr = VIRTIO_SCSI_S_SIMPLE;
+
+ r = bus_dmamap_create(vsc->sc_dmat,
+ 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) {
+ DPRINTF(("%s: bus_dmamap_create xs error %d\n", __func__, r));
+ goto err2;
+ }
+ r = bus_dmamap_create(vsc->sc_dmat, MAXPHYS, sc->sc_seg_max,
+ MAXPHYS, 0, BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW, &vr->vr_data);
+ if (r != 0) {
+ DPRINTF(("%s: bus_dmamap_create data error %d\n", __func__, r));
+ goto err3;
+ }
+ r = bus_dmamap_load(vsc->sc_dmat, vr->vr_control,
+ vr, offsetof(struct vioscsi_req, vr_xs), NULL,
+ BUS_DMA_NOWAIT);
+ if (r != 0) {
+ DPRINTF(("%s: bus_dmamap_create ctrl error %d\n", __func__, r));
+ goto err4;
+ }
+
+ DPRINTF(("%s: %p, %d\n", __func__, vr, slot));
+
+ return vr;
+
+err4:
+ bus_dmamap_destroy(vsc->sc_dmat, vr->vr_data);
+err3:
+ bus_dmamap_destroy(vsc->sc_dmat, vr->vr_control);
+err2:
+ virtio_enqueue_abort(vsc, vq, slot);
+err1:
+ return NULL;
+}
+
+static void
+vioscsi_req_put(struct vioscsi_softc *sc, struct vioscsi_req *vr)
+{
+ struct virtio_softc *vsc = device_private(device_parent(sc->sc_dev));
+ struct virtqueue *vq = &sc->sc_vqs[2];
+ int slot = vr - sc->sc_reqs;
+
+ DPRINTF(("%s: %p, %d\n", __func__, vr, slot));
+
+ bus_dmamap_destroy(vsc->sc_dmat, vr->vr_control);
+ bus_dmamap_destroy(vsc->sc_dmat, vr->vr_data);
+
+ virtio_dequeue_commit(vsc, vq, slot);
+}
+
+int
+vioscsi_alloc_reqs(struct vioscsi_softc *sc, struct virtio_softc *vsc,
+ int qsize, uint32_t seg_max)
+{
+ size_t allocsize;
+ int r, rsegs;
+ void *vaddr;
+
+ allocsize = qsize * sizeof(struct vioscsi_req);
+ r = bus_dmamem_alloc(vsc->sc_dmat, 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 1;
+ }
+ r = bus_dmamem_map(vsc->sc_dmat, &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(vsc->sc_dmat, &sc->sc_reqs_segs[0], 1);
+ return 1;
+ }
+ sc->sc_reqs = vaddr;
+ memset(vaddr, 0, allocsize);
+ return 0;
+}
Index: src/sys/dev/pci/vioscsireg.h
diff -u /dev/null src/sys/dev/pci/vioscsireg.h:1.1.6.2
--- /dev/null Fri Dec 23 06:33:56 2016
+++ src/sys/dev/pci/vioscsireg.h Fri Dec 23 06:33:56 2016
@@ -0,0 +1,72 @@
+/* $OpenBSD: vioscsireg.h,v 1.1 2013/12/20 21:50:49 matthew 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.
+ */
+
+/* Configuration registers */
+#define VIRTIO_SCSI_CONFIG_NUM_QUEUES 0 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_SEG_MAX 4 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_MAX_SECTORS 8 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_CMD_PER_LUN 12 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_EVENT_INFO_SIZE 16 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_SENSE_SIZE 20 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_CDB_SIZE 24 /* 32bit */
+#define VIRTIO_SCSI_CONFIG_MAX_CHANNEL 28 /* 16bit */
+#define VIRTIO_SCSI_CONFIG_MAX_TARGET 30 /* 16bit */
+#define VIRTIO_SCSI_CONFIG_MAX_LUN 32 /* 32bit */
+
+/* Feature bits */
+#define VIRTIO_SCSI_F_INOUT (1<<0)
+#define VIRTIO_SCSI_F_HOTPLUG (1<<1)
+
+/* Response status values */
+#define VIRTIO_SCSI_S_OK 0
+#define VIRTIO_SCSI_S_OVERRUN 1
+#define VIRTIO_SCSI_S_ABORTED 2
+#define VIRTIO_SCSI_S_BAD_TARGET 3
+#define VIRTIO_SCSI_S_RESET 4
+#define VIRTIO_SCSI_S_BUSY 5
+#define VIRTIO_SCSI_S_TRANSPORT_FAILURE 6
+#define VIRTIO_SCSI_S_TARGET_FAILURE 7
+#define VIRTIO_SCSI_S_NEXUS_FAILURE 8
+#define VIRTIO_SCSI_S_FAILURE 9
+
+/* Task attributes */
+#define VIRTIO_SCSI_S_SIMPLE 0
+#define VIRTIO_SCSI_S_ORDERED 1
+#define VIRTIO_SCSI_S_HEAD 2
+#define VIRTIO_SCSI_S_ACA 3
+
+/* Request header structure */
+struct virtio_scsi_req_hdr {
+ uint8_t lun[8];
+ uint64_t id;
+ uint8_t task_attr;
+ uint8_t prio;
+ uint8_t crn;
+ uint8_t cdb[32];
+} __packed;
+/* Followed by data-out. */
+
+/* Response header structure */
+struct virtio_scsi_res_hdr {
+ uint32_t sense_len;
+ uint32_t residual;
+ uint16_t status_qualifier;
+ uint8_t status;
+ uint8_t response;
+ uint8_t sense[96];
+} __packed;
+/* Followed by data-in. */
