* Copyright (c) 2009-2012,2016 Microsoft Corp.

/* $NetBSD: hvs.c,v 1.7 2021/08/07 16:19:11 thorpej Exp $ */
/* $OpenBSD: hvs.c,v 1.17 2017/08/10 17:22:48 mikeb Exp $ */

/*-
* Copyright (c) 2009-2012,2016 Microsoft Corp.
* Copyright (c) 2012 NetApp Inc.
* Copyright (c) 2012 Citrix Inc.
* Copyright (c) 2017 Mike Belopuhov <[email protected]>
* 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 unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.
*/

/*
* The OpenBSD port was done under funding by Esdenera Networks GmbH.
*/

/* #define HVS_DEBUG_IO */

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

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/buf.h>
#include <sys/bus.h>
#include <sys/kmem.h>
#include <sys/mutex.h>

#include <uvm/uvm_extern.h>

#include <dev/hyperv/vmbusvar.h>

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

#define HVS_PROTO_VERSION_WIN6 0x200
#define HVS_PROTO_VERSION_WIN7 0x402
#define HVS_PROTO_VERSION_WIN8 0x501
#define HVS_PROTO_VERSION_WIN8_1 0x600
#define HVS_PROTO_VERSION_WIN10 0x602

#define HVS_MSG_IODONE 0x01
#define HVS_MSG_DEVGONE 0x02
#define HVS_MSG_ENUMERATE 0x0b

#define HVS_REQ_SCSIIO 0x03
#define HVS_REQ_STARTINIT 0x07
#define HVS_REQ_FINISHINIT 0x08
#define HVS_REQ_QUERYPROTO 0x09
#define HVS_REQ_QUERYPROPS 0x0a
#define HVS_REQ_CREATEMULTICHANNELS 0x0d

struct hvs_cmd_hdr {
uint32_t hdr_op;
uint32_t hdr_flags;
uint32_t hdr_status;
#define cmd_op cmd_hdr.hdr_op
#define cmd_flags cmd_hdr.hdr_flags
#define cmd_status cmd_hdr.hdr_status
} __packed;

/* Negotiate version */
struct hvs_cmd_ver {
struct hvs_cmd_hdr cmd_hdr;
uint16_t cmd_ver;
uint16_t cmd_rev;
} __packed;

/* Query channel properties */
struct hvs_chp {
uint16_t chp_proto;
uint8_t chp_path;
uint8_t chp_target;
uint16_t chp_maxchan;
uint16_t chp_port;
uint32_t chp_chflags;
#define CHP_CHFLAGS_MULTI_CHANNEL 0x1
uint32_t chp_maxfer;
uint64_t chp_chanid;
} __packed;

struct hvs_cmd_chp {
struct hvs_cmd_hdr cmd_hdr;
struct hvs_chp cmd_chp;
} __packed;

#define SENSE_DATA_LEN_WIN7 18
#define SENSE_DATA_LEN 20
#define MAX_SRB_DATA 20

/* SCSI Request Block */
struct hvs_srb {
uint16_t srb_reqlen;
uint8_t srb_iostatus;
uint8_t srb_scsistatus;

uint8_t srb_initiator;
uint8_t srb_bus;
uint8_t srb_target;
uint8_t srb_lun;

uint8_t srb_cdblen;
uint8_t srb_senselen;
uint8_t srb_direction;
uint8_t _reserved;

uint32_t srb_datalen;
uint8_t srb_data[MAX_SRB_DATA];
} __packed;

#define SRB_DATA_WRITE 0
#define SRB_DATA_READ 1
#define SRB_DATA_NONE 2

#define SRB_STATUS_PENDING 0x00
#define SRB_STATUS_SUCCESS 0x01
#define SRB_STATUS_ABORTED 0x02
#define SRB_STATUS_ERROR 0x04
#define SRB_STATUS_INVALID_LUN 0x20
#define SRB_STATUS_QUEUE_FROZEN 0x40
#define SRB_STATUS_AUTOSENSE_VALID 0x80

#define SRB_FLAGS_QUEUE_ACTION_ENABLE 0x00000002
#define SRB_FLAGS_DISABLE_DISCONNECT 0x00000004
#define SRB_FLAGS_DISABLE_SYNCH_TRANSFER 0x00000008
#define SRB_FLAGS_BYPASS_FROZEN_QUEUE 0x00000010
#define SRB_FLAGS_DISABLE_AUTOSENSE 0x00000020
#define SRB_FLAGS_DATA_IN 0x00000040
#define SRB_FLAGS_DATA_OUT 0x00000080
#define SRB_FLAGS_NO_DATA_TRANSFER 0x00000000
#define SRB_FLAGS_NO_QUEUE_FREEZE 0x00000100
#define SRB_FLAGS_ADAPTER_CACHE_ENABLE 0x00000200
#define SRB_FLAGS_FREE_SENSE_BUFFER 0x00000400

struct hvs_cmd_io {
struct hvs_cmd_hdr cmd_hdr;
struct hvs_srb cmd_srb;
/* Win8 extensions */
uint16_t _reserved;
uint8_t cmd_qtag;
uint8_t cmd_qaction;
uint32_t cmd_srbflags;
uint32_t cmd_timeout;
uint32_t cmd_qsortkey;
} __packed;

#define HVS_CMD_SIZE 64

union hvs_cmd {
struct hvs_cmd_hdr cmd_hdr;
struct hvs_cmd_ver ver;
struct hvs_cmd_chp chp;
struct hvs_cmd_io io;
uint16_t multi_chans_cnt;
uint8_t pad[HVS_CMD_SIZE];
} __packed;

#define HVS_RING_SIZE (20 * PAGE_SIZE)
#define HVS_MAX_CCB 128
#define HVS_MAX_SGE (howmany(MAXPHYS, PAGE_SIZE) + 1)

struct hvs_softc;

struct hvs_ccb {
struct scsipi_xfer *ccb_xfer; /* associated transfer */
union hvs_cmd *ccb_cmd; /* associated command */
union hvs_cmd ccb_rsp; /* response */
bus_dmamap_t ccb_dmap; /* transfer map */
uint64_t ccb_rid; /* request id */
struct vmbus_gpa_range *ccb_sgl;
int ccb_nsge;
void (*ccb_done)(struct hvs_ccb *);
void *ccb_cookie;
SIMPLEQ_ENTRY(hvs_ccb) ccb_link;
};
SIMPLEQ_HEAD(hvs_ccb_queue, hvs_ccb);

struct hvs_config;

struct hvs_softc {
device_t sc_dev;
bus_dma_tag_t sc_dmat;

struct vmbus_channel *sc_chan;

const struct hvs_config *sc_config;

struct hvs_chp sc_props;

/* CCBs */
int sc_nccb;
struct hvs_ccb *sc_ccbs;
struct hvs_ccb_queue sc_ccb_fq; /* free queue */
kmutex_t sc_ccb_fqlck;

int sc_bus;

struct scsipi_adapter sc_adapter;
struct scsipi_channel sc_channel;
device_t sc_scsibus;
#if notyet /* XXX subchannel */
u_int sc_nchan;
struct vmbus_channel *sc_sel_chan[MAXCPUS];
#endif
};

static int hvs_match(device_t, cfdata_t, void *);
static void hvs_attach(device_t, device_t, void *);
static int hvs_detach(device_t, int);

CFATTACH_DECL_NEW(hvs, sizeof(struct hvs_softc),
hvs_match, hvs_attach, hvs_detach, NULL);

static void hvs_scsipi_request(struct scsipi_channel *,
scsipi_adapter_req_t, void *);
static void hvs_scsi_cmd_done(struct hvs_ccb *);
static int hvs_start(struct hvs_softc *, struct vmbus_channel *,
struct hvs_ccb *);
static int hvs_poll(struct hvs_softc *, struct vmbus_channel *,
struct hvs_ccb *);
static void hvs_poll_done(struct hvs_ccb *);
static void hvs_intr(void *);
static void hvs_scsi_probe(void *arg);
static void hvs_scsi_done(struct scsipi_xfer *, int);

static int hvs_connect(struct hvs_softc *);
static void hvs_empty_done(struct hvs_ccb *);

static int hvs_alloc_ccbs(struct hvs_softc *);
static void hvs_free_ccbs(struct hvs_softc *);
static struct hvs_ccb *
hvs_get_ccb(struct hvs_softc *);
static void hvs_put_ccb(struct hvs_softc *, struct hvs_ccb *);

static const struct hvs_config {
uint32_t proto_version;
uint16_t reqlen;
uint8_t senselen;
bool fixup_wrong_response;
bool upgrade_spc2_to_spc3;
bool use_win8ext_flags;
} hvs_config_list[] = {
{
.proto_version = HVS_PROTO_VERSION_WIN10,
.reqlen = sizeof(struct hvs_cmd_io),
.senselen = SENSE_DATA_LEN,
.fixup_wrong_response = false,
.upgrade_spc2_to_spc3 = false,
.use_win8ext_flags = true,
},
{
.proto_version = HVS_PROTO_VERSION_WIN8_1,
.reqlen = sizeof(struct hvs_cmd_io),
.senselen = SENSE_DATA_LEN,
.fixup_wrong_response = true,
.upgrade_spc2_to_spc3 = true,
.use_win8ext_flags = true,
},
{
.proto_version = HVS_PROTO_VERSION_WIN8,
.reqlen = sizeof(struct hvs_cmd_io),
.senselen = SENSE_DATA_LEN,
.fixup_wrong_response = true,
.upgrade_spc2_to_spc3 = true,
.use_win8ext_flags = true,
},
{
.proto_version = HVS_PROTO_VERSION_WIN7,
.reqlen = offsetof(struct hvs_cmd_io, _reserved),
.senselen = SENSE_DATA_LEN_WIN7,
.fixup_wrong_response = true,
.upgrade_spc2_to_spc3 = false,
.use_win8ext_flags = false,
},
{
.proto_version = HVS_PROTO_VERSION_WIN6,
.reqlen = offsetof(struct hvs_cmd_io, _reserved),
.senselen = SENSE_DATA_LEN_WIN7,
.fixup_wrong_response = false,
.upgrade_spc2_to_spc3 = false,
.use_win8ext_flags = false,
},
};

#if notyet /* XXX subchannel */
static int hvs_chan_cnt;
#endif

static int
hvs_match(device_t parent, cfdata_t cf, void *aux)
{
struct vmbus_attach_args *aa = aux;

if (memcmp(aa->aa_type, &hyperv_guid_ide, sizeof(*aa->aa_type)) != 0 &&
memcmp(aa->aa_type, &hyperv_guid_scsi, sizeof(*aa->aa_type)) != 0)
return 0;
return 1;
}

static void
hvs_attach(device_t parent, device_t self, void *aux)
{
extern struct cfdata cfdata[];
struct hvs_softc *sc = device_private(self);
struct vmbus_attach_args *aa = aux;
struct scsipi_adapter *adapt = &sc->sc_adapter;
struct scsipi_channel *chan = &sc->sc_channel;
const char *bus;
bool is_scsi;

sc->sc_dev = self;
sc->sc_chan = aa->aa_chan;
sc->sc_dmat = sc->sc_chan->ch_sc->sc_dmat;
#if notyet /* XXX subchannel */
sc->sc_nchan = 1;
sc->sc_sel_chan[0] = sc->sc_chan;
#endif

if (memcmp(aa->aa_type, &hyperv_guid_scsi, sizeof(*aa->aa_type)) == 0) {
is_scsi = true;
bus = "SCSI";
} else {
is_scsi = false;
bus = "IDE";
}

aprint_naive("\n");
aprint_normal(": Hyper-V StorVSC %s\n", bus);

if (vmbus_channel_setdeferred(sc->sc_chan, device_xname(self))) {
aprint_error_dev(self,
"failed to create the interrupt thread\n");
return;
}

if (vmbus_channel_open(sc->sc_chan, HVS_RING_SIZE, &sc->sc_props,
sizeof(sc->sc_props), hvs_intr, sc)) {
aprint_error_dev(self, "failed to open channel\n");
return;
}

if (hvs_alloc_ccbs(sc))
return;

if (hvs_connect(sc))
return;

aprint_normal_dev(self, "protocol %u.%u\n",
(sc->sc_config->proto_version >> 8) & 0xff,
sc->sc_config->proto_version & 0xff);

adapt = &sc->sc_adapter;
adapt->adapt_dev = self;
adapt->adapt_nchannels = 1;
adapt->adapt_openings = sc->sc_nccb;
adapt->adapt_max_periph = adapt->adapt_openings;
adapt->adapt_request = hvs_scsipi_request;
adapt->adapt_minphys = minphys;
adapt->adapt_flags = SCSIPI_ADAPT_MPSAFE;

chan = &sc->sc_channel;
chan->chan_adapter = adapt;
chan->chan_bustype = &scsi_bustype; /* XXX IDE/ATAPI */
chan->chan_channel = 0;
chan->chan_ntargets = 2;
chan->chan_nluns = is_scsi ? 64 : 1;
chan->chan_id = 0;
chan->chan_flags = SCSIPI_CHAN_NOSETTLE;
chan->chan_defquirks |= PQUIRK_ONLYBIG;

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

/*
* If the driver has successfully attached to an IDE device,
* we need to make sure that the same disk is not available to
* the system via pciide(4) or piixide(4) causing DUID conflicts
* and preventing system from booting.
*/
if (!is_scsi && sc->sc_scsibus != NULL) {
static const char *disable_devices[] = {
"wd",
};
size_t j;

for (j = 0; j < __arraycount(disable_devices); j++) {
const char *dev = disable_devices[j];
size_t len = strlen(dev);
int devno;

for (devno = 0; cfdata[devno].cf_name != NULL; devno++) {
cfdata_t cf = &cfdata[devno];

if (strlen(cf->cf_name) != len ||
strncasecmp(dev, cf->cf_name, len) != 0 ||
cf->cf_fstate != FSTATE_STAR)
continue;

cf->cf_fstate = FSTATE_DSTAR;
}
}
}
}

static int
hvs_detach(device_t self, int flags)
{

/* XXX detach */

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
hvs_scsipi_request(struct scsipi_channel *chan, scsipi_adapter_req_t request,
void *arg)
{
struct scsipi_adapter *adapt = chan->chan_adapter;
struct hvs_softc *sc = device_private(adapt->adapt_dev);
struct scsipi_xfer *xs;
struct scsipi_xfer_mode *xm;
struct scsipi_periph *periph;
struct hvs_ccb *ccb;
union hvs_cmd cmd;
struct hvs_cmd_io *io = &cmd.io;
struct hvs_srb *srb = &io->cmd_srb;
int i, error;

switch (request) {
default:
device_printf(sc->sc_dev,
"%s: unhandled request %u\n", __func__, request);
return;

case ADAPTER_REQ_GROW_RESOURCES:
/* Not supported. */
return;

case ADAPTER_REQ_SET_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;

case ADAPTER_REQ_RUN_XFER:
break;
}

xs = arg;

if (xs->cmdlen > MAX_SRB_DATA) {
device_printf(sc->sc_dev, "CDB is too big: %d\n",
xs->cmdlen);
memset(&xs->sense, 0, sizeof(xs->sense));
xs->sense.scsi_sense.response_code =
SSD_RCODE_VALID | SSD_RCODE_CURRENT;
xs->sense.scsi_sense.flags = SSD_ILI;
xs->sense.scsi_sense.asc = 0x20;
hvs_scsi_done(xs, XS_SENSE);
return;
}

ccb = hvs_get_ccb(sc);
if (ccb == NULL) {
device_printf(sc->sc_dev, "failed to allocate ccb\n");
hvs_scsi_done(xs, XS_RESOURCE_SHORTAGE);
return;
}

periph = xs->xs_periph;

memset(&cmd, 0, sizeof(cmd));

srb->srb_initiator = chan->chan_id;
srb->srb_bus = sc->sc_bus;
srb->srb_target = periph->periph_target - 1;
srb->srb_lun = periph->periph_lun;
srb->srb_cdblen = xs->cmdlen;
memcpy(srb->srb_data, xs->cmd, xs->cmdlen);

if (sc->sc_config->use_win8ext_flags) {
io->cmd_timeout = 60;
SET(io->cmd_srbflags, SRB_FLAGS_DISABLE_SYNCH_TRANSFER);
}

switch (xs->xs_control & (XS_CTL_DATA_IN | XS_CTL_DATA_OUT)) {
case XS_CTL_DATA_IN:
srb->srb_direction = SRB_DATA_READ;
if (sc->sc_config->use_win8ext_flags)
SET(io->cmd_srbflags, SRB_FLAGS_DATA_IN);
break;
case XS_CTL_DATA_OUT:
srb->srb_direction = SRB_DATA_WRITE;
if (sc->sc_config->use_win8ext_flags)
SET(io->cmd_srbflags, SRB_FLAGS_DATA_OUT);
break;
default:
srb->srb_direction = SRB_DATA_NONE;
if (sc->sc_config->use_win8ext_flags)
SET(io->cmd_srbflags, SRB_FLAGS_NO_DATA_TRANSFER);
break;
}

srb->srb_datalen = xs->datalen;
srb->srb_reqlen = sc->sc_config->reqlen;
srb->srb_senselen = sc->sc_config->senselen;

cmd.cmd_op = HVS_REQ_SCSIIO;
cmd.cmd_flags = VMBUS_CHANPKT_FLAG_RC;

if (xs->datalen > 0) {
error = bus_dmamap_load(sc->sc_dmat, ccb->ccb_dmap, xs->data,
xs->datalen, NULL, XS2DMA(xs));
if (error) {
device_printf(sc->sc_dev,
"failed to load %d bytes (%d)\n", xs->datalen,
error);
hvs_put_ccb(sc, ccb);
hvs_scsi_done(xs, (error == ENOMEM || error == EAGAIN) ?
XS_RESOURCE_SHORTAGE : XS_DRIVER_STUFFUP);
return;
}
bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmap, 0, xs->datalen,
XS2DMAPRE(xs));

ccb->ccb_sgl->gpa_len = xs->datalen;
ccb->ccb_sgl->gpa_ofs = (vaddr_t)xs->data & PAGE_MASK;
for (i = 0; i < ccb->ccb_dmap->dm_nsegs; i++)
ccb->ccb_sgl->gpa_page[i] =
atop(ccb->ccb_dmap->dm_segs[i].ds_addr);
ccb->ccb_nsge = ccb->ccb_dmap->dm_nsegs;
} else
ccb->ccb_nsge = 0;

ccb->ccb_xfer = xs;
ccb->ccb_cmd = &cmd;
ccb->ccb_done = hvs_scsi_cmd_done;

#ifdef HVS_DEBUG_IO
printf("%s: %u.%u: rid %"PRIu64" opcode %#x control %#x datalen %d\n",
device_xname(sc->sc_dev), periph->periph_target, periph->periph_lun,
ccb->ccb_rid, xs->cmd->opcode, xs->xs_control, xs->datalen);
#endif

if (xs->xs_control & XS_CTL_POLL)
error = hvs_poll(sc, sc->sc_chan, ccb);
else
error = hvs_start(sc, sc->sc_chan, ccb);
if (error) {
hvs_put_ccb(sc, ccb);
hvs_scsi_done(xs, (error == ENOMEM || error == EAGAIN) ?
XS_RESOURCE_SHORTAGE : XS_DRIVER_STUFFUP);
}
}

static int
hvs_start(struct hvs_softc *sc, struct vmbus_channel *chan, struct hvs_ccb *ccb)
{
union hvs_cmd *cmd = ccb->ccb_cmd;
int error;

ccb->ccb_cmd = NULL;

if (ccb->ccb_nsge > 0) {
error = vmbus_channel_send_prpl(chan, ccb->ccb_sgl,
ccb->ccb_nsge, cmd, HVS_CMD_SIZE, ccb->ccb_rid);
if (error) {
device_printf(sc->sc_dev,
"failed to submit operation %x via prpl\n",
cmd->cmd_op);
bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmap);
}
} else {
error = vmbus_channel_send(chan, cmd, HVS_CMD_SIZE,
ccb->ccb_rid, VMBUS_CHANPKT_TYPE_INBAND,
VMBUS_CHANPKT_FLAG_RC);
if (error)
device_printf(sc->sc_dev,
"failed to submit operation %x\n", cmd->cmd_op);
}

return error;
}

static void
hvs_poll_done(struct hvs_ccb *ccb)
{
int *rv = ccb->ccb_cookie;

if (ccb->ccb_cmd) {
memcpy(&ccb->ccb_rsp, ccb->ccb_cmd, HVS_CMD_SIZE);
ccb->ccb_cmd = &ccb->ccb_rsp;
} else
memset(&ccb->ccb_rsp, 0, HVS_CMD_SIZE);

*rv = 0;
}

static int
hvs_poll(struct hvs_softc *sc, struct vmbus_channel *chan, struct hvs_ccb *ccb)
{
void (*done)(struct hvs_ccb *);
void *cookie;
int s, rv = 1;

done = ccb->ccb_done;
cookie = ccb->ccb_cookie;

ccb->ccb_done = hvs_poll_done;
ccb->ccb_cookie = &rv;

if (hvs_start(sc, chan, ccb)) {
ccb->ccb_cookie = cookie;
ccb->ccb_done = done;
return -1;
}

while (rv == 1) {
delay(10);
s = splbio();
hvs_intr(sc);
splx(s);
}

ccb->ccb_cookie = cookie;
ccb->ccb_done = done;
ccb->ccb_done(ccb);

return 0;
}

static void
hvs_intr(void *xsc)
{
struct hvs_softc *sc = xsc;
struct hvs_ccb *ccb;
union hvs_cmd cmd;
uint64_t rid;
uint32_t rlen;
int error;

for (;;) {
error = vmbus_channel_recv(sc->sc_chan, &cmd, sizeof(cmd),
&rlen, &rid, 0);
switch (error) {
case 0:
break;
case EAGAIN:
/* No more messages to process */
return;
default:
device_printf(sc->sc_dev,
"error %d while receiving a reply\n", error);
return;
}
if (rlen != sizeof(cmd)) {
device_printf(sc->sc_dev, "short read: %u\n", rlen);
return;
}

#ifdef HVS_DEBUG_IO
printf("%s: rid %"PRIu64" operation %u flags %#x status %#x\n",
device_xname(sc->sc_dev), rid, cmd.cmd_op, cmd.cmd_flags,
cmd.cmd_status);
#endif

switch (cmd.cmd_op) {
case HVS_MSG_IODONE:
if (rid >= sc->sc_nccb) {
device_printf(sc->sc_dev,
"invalid response %#"PRIx64"\n", rid);
continue;
}
ccb = &sc->sc_ccbs[rid];
ccb->ccb_cmd = &cmd;
ccb->ccb_done(ccb);
break;
case HVS_MSG_ENUMERATE:
hvs_scsi_probe(sc);
break;
default:
device_printf(sc->sc_dev,
"operation %u is not implemented\n", cmd.cmd_op);
break;
}
}
}

static int
is_inquiry_valid(struct scsipi_inquiry_data *inq)
{

if ((inq->device & SID_TYPE) == T_NODEVICE)
return 0;
if ((inq->device & SID_QUAL) == SID_QUAL_LU_NOT_SUPP)
return 0;
return 1;
}

static void
fixup_inquiry(struct scsipi_xfer *xs, struct hvs_srb *srb)
{
struct scsipi_periph *periph = xs->xs_periph;
struct scsipi_channel *chan = periph->periph_channel;
struct scsipi_adapter *adapt = chan->chan_adapter;
struct hvs_softc *sc = device_private(adapt->adapt_dev);
struct scsipi_inquiry_data *inq = (void *)xs->data;
int datalen, resplen;
char vendor[8];

resplen = srb->srb_datalen >= 5 ? inq->additional_length + 5 : 0;
datalen = MIN(resplen, srb->srb_datalen);

/* Fixup wrong response from WS2012 */
if (sc->sc_config->fixup_wrong_response &&
!is_inquiry_valid(inq) && datalen >= 4 &&
(inq->version == 0 || inq->response_format == 0)) {
inq->version = 0x05; /* SPC-3 */
inq->response_format = SID_FORMAT_ISO;
} else if (datalen >= SCSIPI_INQUIRY_LENGTH_SCSI2) {
/*
* Upgrade SPC2 to SPC3 if host is Win8 or WS2012 R2
* to support UNMAP feature.
*/
strnvisx(vendor, sizeof(vendor), inq->vendor, sizeof(vendor),
VIS_TRIM|VIS_SAFE|VIS_OCTAL);
if (sc->sc_config->upgrade_spc2_to_spc3 &&
(inq->version & SID_ANSII) == 0x04 /* SPC-2 */ &&
!strncmp(vendor, "Msft", 4))
inq->version = 0x05; /* SPC-3 */
}
}

static void
hvs_scsi_cmd_done(struct hvs_ccb *ccb)
{
struct scsipi_xfer *xs = ccb->ccb_xfer;
struct scsipi_periph *periph = xs->xs_periph;
struct scsipi_channel *chan = periph->periph_channel;
struct scsipi_adapter *adapt = chan->chan_adapter;
struct hvs_softc *sc = device_private(adapt->adapt_dev);
union hvs_cmd *cmd = ccb->ccb_cmd;
struct hvs_srb *srb;
bus_dmamap_t map;
int error;

map = ccb->ccb_dmap;
bus_dmamap_sync(sc->sc_dmat, map, 0, map->dm_mapsize, XS2DMAPOST(xs));
bus_dmamap_unload(sc->sc_dmat, map);

xs = ccb->ccb_xfer;
srb = &cmd->io.cmd_srb;

xs->status = srb->srb_scsistatus & 0xff;

switch (xs->status) {
case SCSI_OK:
if ((srb->srb_iostatus & ~(SRB_STATUS_AUTOSENSE_VALID |
SRB_STATUS_QUEUE_FROZEN)) != SRB_STATUS_SUCCESS)
error = XS_SELTIMEOUT;
else
error = XS_NOERROR;
break;
case SCSI_BUSY:
case SCSI_QUEUE_FULL:
device_printf(sc->sc_dev, "status %#x iostatus %#x (busy)\n",
srb->srb_scsistatus, srb->srb_iostatus);
error = XS_BUSY;
break;
case SCSI_CHECK:
if (srb->srb_iostatus & SRB_STATUS_AUTOSENSE_VALID) {
memcpy(&xs->sense, srb->srb_data,
MIN(sizeof(xs->sense), srb->srb_senselen));
error = XS_SENSE;
break;
}
/* FALLTHROUGH */
default:
error = XS_DRIVER_STUFFUP;
break;
}

if (error == XS_NOERROR) {
if (xs->cmd->opcode == INQUIRY)
fixup_inquiry(xs, srb);
else if (srb->srb_direction != SRB_DATA_NONE)
xs->resid = xs->datalen - srb->srb_datalen;
}

hvs_put_ccb(sc, ccb);
hvs_scsi_done(xs, error);
}

static void
hvs_scsi_probe(void *arg)
{
struct hvs_softc *sc = arg;

if (sc->sc_scsibus != NULL)
scsi_probe_bus(device_private(sc->sc_scsibus), -1, -1);
}

static void
hvs_scsi_done(struct scsipi_xfer *xs, int error)
{

xs->error = error;
scsipi_done(xs);
}

static int
hvs_connect(struct hvs_softc *sc)
{
union hvs_cmd ucmd;
struct hvs_cmd_ver *cmd;
struct hvs_chp *chp;
struct hvs_ccb *ccb;
#if notyet /* XXX subchannel */
struct vmbus_softc *vsc;
struct vmbus_channel **subchan;
uint32_t version;
uint16_t max_subch, req_subch;
bool support_multichannel = false;
#endif
int i;

ccb = hvs_get_ccb(sc);
if (ccb == NULL) {
aprint_error_dev(sc->sc_dev, "failed to allocate ccb\n");
return -1;
}

ccb->ccb_done = hvs_empty_done;

cmd = (struct hvs_cmd_ver *)&ucmd;

/*
* Begin initialization
*/

memset(&ucmd, 0, sizeof(ucmd));

cmd->cmd_op = HVS_REQ_STARTINIT;
cmd->cmd_flags = VMBUS_CHANPKT_FLAG_RC;

ccb->ccb_cmd = &ucmd;
if (hvs_poll(sc, sc->sc_chan, ccb)) {
aprint_error_dev(sc->sc_dev,
"failed to send initialization command\n");
goto error;
}
if (ccb->ccb_rsp.cmd_status != 0) {
aprint_error_dev(sc->sc_dev,
"failed to initialize, status %#x\n",
ccb->ccb_rsp.cmd_status);
goto error;
}

/*
* Negotiate protocol version
*/

memset(&ucmd, 0, sizeof(ucmd));

cmd->cmd_op = HVS_REQ_QUERYPROTO;
cmd->cmd_flags = VMBUS_CHANPKT_FLAG_RC;

for (i = 0; i < __arraycount(hvs_config_list); i++) {
cmd->cmd_ver = hvs_config_list[i].proto_version;

ccb->ccb_cmd = &ucmd;
if (hvs_poll(sc, sc->sc_chan, ccb)) {
aprint_error_dev(sc->sc_dev,
"failed to send protocol query\n");
goto error;
}
if (ccb->ccb_rsp.cmd_status == 0) {
sc->sc_config = &hvs_config_list[i];
break;
}
}
if (sc->sc_config == NULL) {
aprint_error_dev(sc->sc_dev,
"failed to negotiate protocol version\n");
goto error;
}

/*
* Query channel properties
*/

memset(&ucmd, 0, sizeof(ucmd));

cmd->cmd_op = HVS_REQ_QUERYPROPS;
cmd->cmd_flags = VMBUS_CHANPKT_FLAG_RC;

ccb->ccb_cmd = &ucmd;
if (hvs_poll(sc, sc->sc_chan, ccb)) {
aprint_error_dev(sc->sc_dev,
"failed to send channel properties query\n");
goto error;
}
if (ccb->ccb_rsp.cmd_op != HVS_MSG_IODONE ||
ccb->ccb_rsp.cmd_status != 0) {
aprint_error_dev(sc->sc_dev,
"failed to obtain channel properties, status %#x\n",
ccb->ccb_rsp.cmd_status);
goto error;
}
chp = &ccb->ccb_rsp.chp.cmd_chp;

DPRINTF("%s: proto %#x path %u target %u maxchan %u port %u "
"chflags %#x maxfer %u chanid %#"PRIx64"\n",
device_xname(sc->sc_dev), chp->chp_proto, chp->chp_path,
chp->chp_target, chp->chp_maxchan, chp->chp_port,
chp->chp_chflags, chp->chp_maxfer, chp->chp_chanid);

#if notyet /* XXX subchannel */
max_subch = chp->chp_maxchan;
if (hvs_chan_cnt > 0 && hvs_chan_cnt < (max_subch + 1))
max_subch = hvs_chan_cnt - 1;

/* multi-channels feature is supported by WIN8 and above version */
version = sc->sc_chan->ch_sc->sc_proto;
if (version != VMBUS_VERSION_WIN7 && version != VMBUS_VERSION_WS2008 &&
ISSET(chp->chp_chflags, CHP_CHFLAGS_MULTI_CHANNEL))
support_multichannel = true;
#endif

/* XXX */
sc->sc_bus = chp->chp_path;
sc->sc_channel.chan_id = chp->chp_target;

/*
* Finish initialization
*/

memset(&ucmd, 0, sizeof(ucmd));

cmd->cmd_op = HVS_REQ_FINISHINIT;
cmd->cmd_flags = VMBUS_CHANPKT_FLAG_RC;

ccb->ccb_cmd = &ucmd;
if (hvs_poll(sc, sc->sc_chan, ccb)) {
aprint_error_dev(sc->sc_dev,
"failed to send initialization finish\n");
goto error;
}
if (ccb->ccb_rsp.cmd_op != HVS_MSG_IODONE ||
ccb->ccb_rsp.cmd_status != 0) {
aprint_error_dev(sc->sc_dev,
"failed to finish initialization, status %#x\n",
ccb->ccb_rsp.cmd_status);
goto error;
}

#if notyet /* XXX subchannel */
if (support_multichannel && max_subch > 0 && ncpu > 1) {
req_subch = MIN(max_subch, ncpu - 1);

memset(&ucmd, 0, sizeof(ucmd));

cmd->cmd_op = HVS_REQ_CREATEMULTICHANNELS;
cmd->cmd_flags = VMBUS_CHANPKT_FLAG_RC;
cmd->u.multi_chans_cnt = req_subch;

ccb->ccb_cmd = &ucmd;
if (hvs_poll(sc, sc->sc_chan, ccb)) {
aprint_error_dev(sc->sc_dev,
"failed to send create multi-channel\n");
goto out;
}
if (ccb->ccb_rsp.cmd_op != HVS_MSG_IODONE ||
ccb->ccb_rsp.cmd_status != 0) {
aprint_error_dev(sc->sc_dev,
"failed to create multi-channel, status %#x\n",
ccb->ccb_rsp.cmd_status);
goto out;
}

sc->sc_nchan = req_subch + 1;
subchan = vmbus_subchan_get(sc->sc_chan, req_subch);
for (i = 0; i < req_subch; i++)
hsv_subchan_attach(sc, subchan[i]);
vmbus_subchan_rel(subchan, req_subch);
aprint_normal_dev(sc->sc_dev, "using %u channels\n",
sc->sc_nchan);
}
out:
#endif
hvs_put_ccb(sc, ccb);
return 0;

error:
hvs_put_ccb(sc, ccb);
return -1;
}

static void
hvs_empty_done(struct hvs_ccb *ccb)
{
/* nothing */
}

static int
hvs_alloc_ccbs(struct hvs_softc *sc)
{
const int dmaflags = cold ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
int i, error;

SIMPLEQ_INIT(&sc->sc_ccb_fq);
mutex_init(&sc->sc_ccb_fqlck, MUTEX_DEFAULT, IPL_BIO);

sc->sc_nccb = HVS_MAX_CCB;
sc->sc_ccbs = kmem_zalloc(sc->sc_nccb * sizeof(struct hvs_ccb),
KM_SLEEP);

for (i = 0; i < sc->sc_nccb; i++) {
error = bus_dmamap_create(sc->sc_dmat, MAXPHYS, HVS_MAX_SGE,
PAGE_SIZE, PAGE_SIZE, dmaflags, &sc->sc_ccbs[i].ccb_dmap);
if (error) {
aprint_error_dev(sc->sc_dev,
"failed to create a CCB memory map (%d)\n", error);
goto errout;
}

sc->sc_ccbs[i].ccb_sgl = kmem_zalloc(
sizeof(struct vmbus_gpa_range) * (HVS_MAX_SGE + 1),
KM_SLEEP);
sc->sc_ccbs[i].ccb_rid = i;
hvs_put_ccb(sc, &sc->sc_ccbs[i]);
}

return 0;

errout:
hvs_free_ccbs(sc);
return -1;
}

static void
hvs_free_ccbs(struct hvs_softc *sc)
{
struct hvs_ccb *ccb;
int i;

for (i = 0; i < sc->sc_nccb; i++) {
ccb = &sc->sc_ccbs[i];
if (ccb->ccb_dmap == NULL)
continue;

bus_dmamap_sync(sc->sc_dmat, ccb->ccb_dmap,
0, ccb->ccb_dmap->dm_mapsize,
BUS_DMASYNC_POSTREAD | BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->sc_dmat, ccb->ccb_dmap);
bus_dmamap_destroy(sc->sc_dmat, ccb->ccb_dmap);

kmem_free(ccb->ccb_sgl,
sizeof(struct vmbus_gpa_range) * (HVS_MAX_SGE + 1));
}

kmem_free(sc->sc_ccbs, sc->sc_nccb * sizeof(struct hvs_ccb));
sc->sc_ccbs = NULL;
sc->sc_nccb = 0;
}

static struct hvs_ccb *
hvs_get_ccb(struct hvs_softc *sc)
{
struct hvs_ccb *ccb;

mutex_enter(&sc->sc_ccb_fqlck);
ccb = SIMPLEQ_FIRST(&sc->sc_ccb_fq);
if (ccb != NULL)
SIMPLEQ_REMOVE_HEAD(&sc->sc_ccb_fq, ccb_link);
mutex_exit(&sc->sc_ccb_fqlck);

return ccb;
}

static void
hvs_put_ccb(struct hvs_softc *sc, struct hvs_ccb *ccb)
{

ccb->ccb_cmd = NULL;
ccb->ccb_xfer = NULL;
ccb->ccb_done = NULL;
ccb->ccb_cookie = NULL;
ccb->ccb_nsge = 0;

mutex_enter(&sc->sc_ccb_fqlck);
SIMPLEQ_INSERT_HEAD(&sc->sc_ccb_fq, ccb, ccb_link);
mutex_exit(&sc->sc_ccb_fqlck);
}