static int
hn_rndis_halt(struct hn_softc *sc)
{
struct vmbus_xact *xact;
struct rndis_halt_req *halt;
struct hn_nvs_sendctx sndc;
size_t comp_len;
xact = vmbus_xact_get(sc->hn_xact, sizeof(*halt));
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for RNDIS halt\n");
return (ENXIO);
}
halt = vmbus_xact_req_data(xact);
halt->rm_type = REMOTE_NDIS_HALT_MSG;
halt->rm_len = sizeof(*halt);
halt->rm_rid = hn_rndis_rid(sc);
/* No RNDIS completion; rely on NVS message send completion */
hn_nvs_sendctx_init(&sndc, hn_nvs_sent_xact, xact);
hn_rndis_xact_exec1(sc, xact, sizeof(*halt), &sndc, &comp_len);
vmbus_xact_put(xact);
if (bootverbose)
if_printf(sc->hn_ifp, "RNDIS halt done\n");
return (0);
}
void
vmbus_msghc_reset(struct vmbus_msghc *mh, size_t dsize)
{
struct hypercall_postmsg_in *inprm;
if (dsize > HYPERCALL_POSTMSGIN_DSIZE_MAX)
panic("invalid data size %zu", dsize);
inprm = vmbus_xact_req_data(mh->mh_xact);
memset(inprm, 0, HYPERCALL_POSTMSGIN_SIZE);
inprm->hc_connid = VMBUS_CONNID_MESSAGE;
inprm->hc_msgtype = HYPERV_MSGTYPE_CHANNEL;
inprm->hc_dsize = dsize;
}
static int
hn_rndis_set(struct hn_softc *sc, uint32_t oid, const void *data, size_t dlen)
{
struct rndis_set_req *req;
const struct rndis_set_comp *comp;
struct vmbus_xact *xact;
size_t reqlen, comp_len;
uint32_t rid;
int error;
KASSERT(dlen > 0, ("invalid dlen %zu", dlen));
reqlen = sizeof(*req) + dlen;
xact = vmbus_xact_get(sc->hn_xact, reqlen);
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for RNDIS set 0x%08x\n", oid);
return (ENXIO);
}
rid = hn_rndis_rid(sc);
req = vmbus_xact_req_data(xact);
req->rm_type = REMOTE_NDIS_SET_MSG;
req->rm_len = reqlen;
req->rm_rid = rid;
req->rm_oid = oid;
req->rm_infobuflen = dlen;
req->rm_infobufoffset = RNDIS_SET_REQ_INFOBUFOFFSET;
/* Data immediately follows RNDIS set. */
memcpy(req + 1, data, dlen);
comp_len = sizeof(*comp);
comp = hn_rndis_xact_execute(sc, xact, rid, reqlen, &comp_len,
REMOTE_NDIS_SET_CMPLT);
if (comp == NULL) {
if_printf(sc->hn_ifp, "exec RNDIS set 0x%08x failed\n", oid);
error = EIO;
goto done;
}
if (comp->rm_status != RNDIS_STATUS_SUCCESS) {
if_printf(sc->hn_ifp, "RNDIS set 0x%08x failed: "
"status 0x%08x\n", oid, comp->rm_status);
error = EIO;
goto done;
}
error = 0;
done:
vmbus_xact_put(xact);
return (error);
}
static int
hn_nvs_doinit(struct hn_softc *sc, uint32_t nvs_ver)
{
struct vmbus_xact *xact;
struct hn_nvs_init *init;
const struct hn_nvs_init_resp *resp;
size_t resp_len;
uint32_t status;
xact = vmbus_xact_get(sc->hn_xact, sizeof(*init));
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for nvs init\n");
return (ENXIO);
}
init = vmbus_xact_req_data(xact);
init->nvs_type = HN_NVS_TYPE_INIT;
init->nvs_ver_min = nvs_ver;
init->nvs_ver_max = nvs_ver;
resp_len = sizeof(*resp);
resp = hn_nvs_xact_execute(sc, xact, init, sizeof(*init), &resp_len,
HN_NVS_TYPE_INIT_RESP);
if (resp == NULL) {
if_printf(sc->hn_ifp, "exec init failed\n");
vmbus_xact_put(xact);
return (EIO);
}
status = resp->nvs_status;
vmbus_xact_put(xact);
if (status != HN_NVS_STATUS_OK) {
if (bootverbose) {
/*
* Caller may try another NVS version, and will log
* error if there are no more NVS versions to try,
* so don't bark out loud here.
*/
if_printf(sc->hn_ifp, "nvs init failed for ver 0x%x\n",
nvs_ver);
}
return (EINVAL);
}
return (0);
}
static int
hn_nvs_conn_chim(struct hn_softc *sc)
{
struct vmbus_xact *xact = NULL;
struct hn_nvs_chim_conn *chim;
const struct hn_nvs_chim_connresp *resp;
size_t resp_len;
uint32_t status, sectsz;
int error;
/*
* Connect chimney sending buffer GPADL to the primary channel.
*
* NOTE:
* Only primary channel has chimney sending buffer connected to it.
* Sub-channels just share this chimney sending buffer.
*/
error = vmbus_chan_gpadl_connect(sc->hn_prichan,
sc->hn_chim_dma.hv_paddr, HN_CHIM_SIZE, &sc->hn_chim_gpadl);
if (error) {
if_printf(sc->hn_ifp, "chim gpadl conn failed: %d\n", error);
goto cleanup;
}
/*
* Connect chimney sending buffer to NVS
*/
xact = vmbus_xact_get(sc->hn_xact, sizeof(*chim));
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for nvs chim conn\n");
error = ENXIO;
goto cleanup;
}
chim = vmbus_xact_req_data(xact);
chim->nvs_type = HN_NVS_TYPE_CHIM_CONN;
chim->nvs_gpadl = sc->hn_chim_gpadl;
chim->nvs_sig = HN_NVS_CHIM_SIG;
resp_len = sizeof(*resp);
resp = hn_nvs_xact_execute(sc, xact, chim, sizeof(*chim), &resp_len,
HN_NVS_TYPE_CHIM_CONNRESP);
if (resp == NULL) {
if_printf(sc->hn_ifp, "exec nvs chim conn failed\n");
error = EIO;
goto cleanup;
}
status = resp->nvs_status;
sectsz = resp->nvs_sectsz;
vmbus_xact_put(xact);
xact = NULL;
if (status != HN_NVS_STATUS_OK) {
if_printf(sc->hn_ifp, "nvs chim conn failed: %x\n", status);
error = EIO;
goto cleanup;
}
if (sectsz == 0) {
if_printf(sc->hn_ifp, "zero chimney sending buffer "
"section size\n");
return (0);
}
sc->hn_chim_szmax = sectsz;
sc->hn_chim_cnt = HN_CHIM_SIZE / sc->hn_chim_szmax;
if (HN_CHIM_SIZE % sc->hn_chim_szmax != 0) {
if_printf(sc->hn_ifp, "chimney sending sections are "
"not properly aligned\n");
}
if (sc->hn_chim_cnt % LONG_BIT != 0) {
if_printf(sc->hn_ifp, "discard %d chimney sending sections\n",
sc->hn_chim_cnt % LONG_BIT);
}
sc->hn_chim_bmap_cnt = sc->hn_chim_cnt / LONG_BIT;
sc->hn_chim_bmap = malloc(sc->hn_chim_bmap_cnt * sizeof(u_long),
M_DEVBUF, M_WAITOK | M_ZERO);
/* Done! */
sc->hn_flags |= HN_FLAG_CHIM_CONNECTED;
if (bootverbose) {
if_printf(sc->hn_ifp, "chimney sending buffer %d/%d\n",
sc->hn_chim_szmax, sc->hn_chim_cnt);
}
return (0);
cleanup:
if (xact != NULL)
vmbus_xact_put(xact);
hn_nvs_disconn_chim(sc);
return (error);
}
static int
hn_nvs_conn_rxbuf(struct hn_softc *sc)
{
struct vmbus_xact *xact = NULL;
struct hn_nvs_rxbuf_conn *conn;
const struct hn_nvs_rxbuf_connresp *resp;
size_t resp_len;
uint32_t status;
int error, rxbuf_size;
/*
* Limit RXBUF size for old NVS.
*/
if (sc->hn_nvs_ver <= HN_NVS_VERSION_2)
rxbuf_size = HN_RXBUF_SIZE_COMPAT;
else
rxbuf_size = HN_RXBUF_SIZE;
/*
* Connect the RXBUF GPADL to the primary channel.
*
* NOTE:
* Only primary channel has RXBUF connected to it. Sub-channels
* just share this RXBUF.
*/
error = vmbus_chan_gpadl_connect(sc->hn_prichan,
sc->hn_rxbuf_dma.hv_paddr, rxbuf_size, &sc->hn_rxbuf_gpadl);
if (error) {
if_printf(sc->hn_ifp, "rxbuf gpadl conn failed: %d\n",
error);
goto cleanup;
}
/*
* Connect RXBUF to NVS.
*/
xact = vmbus_xact_get(sc->hn_xact, sizeof(*conn));
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for nvs rxbuf conn\n");
error = ENXIO;
goto cleanup;
}
conn = vmbus_xact_req_data(xact);
conn->nvs_type = HN_NVS_TYPE_RXBUF_CONN;
conn->nvs_gpadl = sc->hn_rxbuf_gpadl;
conn->nvs_sig = HN_NVS_RXBUF_SIG;
resp_len = sizeof(*resp);
resp = hn_nvs_xact_execute(sc, xact, conn, sizeof(*conn), &resp_len,
HN_NVS_TYPE_RXBUF_CONNRESP);
if (resp == NULL) {
if_printf(sc->hn_ifp, "exec nvs rxbuf conn failed\n");
error = EIO;
goto cleanup;
}
status = resp->nvs_status;
vmbus_xact_put(xact);
xact = NULL;
if (status != HN_NVS_STATUS_OK) {
if_printf(sc->hn_ifp, "nvs rxbuf conn failed: %x\n", status);
error = EIO;
goto cleanup;
}
sc->hn_flags |= HN_FLAG_RXBUF_CONNECTED;
return (0);
cleanup:
if (xact != NULL)
vmbus_xact_put(xact);
hn_nvs_disconn_rxbuf(sc);
return (error);
}
static int
hn_rndis_init(struct hn_softc *sc)
{
struct rndis_init_req *req;
const struct rndis_init_comp *comp;
struct vmbus_xact *xact;
size_t comp_len;
uint32_t rid;
int error;
xact = vmbus_xact_get(sc->hn_xact, sizeof(*req));
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for RNDIS init\n");
return (ENXIO);
}
rid = hn_rndis_rid(sc);
req = vmbus_xact_req_data(xact);
req->rm_type = REMOTE_NDIS_INITIALIZE_MSG;
req->rm_len = sizeof(*req);
req->rm_rid = rid;
req->rm_ver_major = RNDIS_VERSION_MAJOR;
req->rm_ver_minor = RNDIS_VERSION_MINOR;
req->rm_max_xfersz = HN_RNDIS_XFER_SIZE;
comp_len = RNDIS_INIT_COMP_SIZE_MIN;
comp = hn_rndis_xact_execute(sc, xact, rid, sizeof(*req), &comp_len,
REMOTE_NDIS_INITIALIZE_CMPLT);
if (comp == NULL) {
if_printf(sc->hn_ifp, "exec RNDIS init failed\n");
error = EIO;
goto done;
}
if (comp->rm_status != RNDIS_STATUS_SUCCESS) {
if_printf(sc->hn_ifp, "RNDIS init failed: status 0x%08x\n",
comp->rm_status);
error = EIO;
goto done;
}
sc->hn_rndis_agg_size = comp->rm_pktmaxsz;
sc->hn_rndis_agg_pkts = comp->rm_pktmaxcnt;
sc->hn_rndis_agg_align = 1U << comp->rm_align;
if (sc->hn_rndis_agg_align < sizeof(uint32_t)) {
/*
* The RNDIS packet messsage encap assumes that the RNDIS
* packet message is at least 4 bytes aligned. Fix up the
* alignment here, if the remote side sets the alignment
* too low.
*/
if_printf(sc->hn_ifp, "fixup RNDIS aggpkt align: %u -> %zu\n",
sc->hn_rndis_agg_align, sizeof(uint32_t));
sc->hn_rndis_agg_align = sizeof(uint32_t);
}
if (bootverbose) {
if_printf(sc->hn_ifp, "RNDIS ver %u.%u, "
"aggpkt size %u, aggpkt cnt %u, aggpkt align %u\n",
comp->rm_ver_major, comp->rm_ver_minor,
sc->hn_rndis_agg_size, sc->hn_rndis_agg_pkts,
sc->hn_rndis_agg_align);
}
error = 0;
done:
vmbus_xact_put(xact);
return (error);
}
static int
hn_rndis_query2(struct hn_softc *sc, uint32_t oid,
const void *idata, size_t idlen, void *odata, size_t *odlen0,
size_t min_odlen)
{
struct rndis_query_req *req;
const struct rndis_query_comp *comp;
struct vmbus_xact *xact;
size_t reqlen, odlen = *odlen0, comp_len;
int error, ofs;
uint32_t rid;
reqlen = sizeof(*req) + idlen;
xact = vmbus_xact_get(sc->hn_xact, reqlen);
if (xact == NULL) {
if_printf(sc->hn_ifp, "no xact for RNDIS query 0x%08x\n", oid);
return (ENXIO);
}
rid = hn_rndis_rid(sc);
req = vmbus_xact_req_data(xact);
req->rm_type = REMOTE_NDIS_QUERY_MSG;
req->rm_len = reqlen;
req->rm_rid = rid;
req->rm_oid = oid;
/*
* XXX
* This is _not_ RNDIS Spec conforming:
* "This MUST be set to 0 when there is no input data
* associated with the OID."
*
* If this field was set to 0 according to the RNDIS Spec,
* Hyper-V would set non-SUCCESS status in the query
* completion.
*/
req->rm_infobufoffset = RNDIS_QUERY_REQ_INFOBUFOFFSET;
if (idlen > 0) {
req->rm_infobuflen = idlen;
/* Input data immediately follows RNDIS query. */
memcpy(req + 1, idata, idlen);
}
comp_len = sizeof(*comp) + min_odlen;
comp = hn_rndis_xact_execute(sc, xact, rid, reqlen, &comp_len,
REMOTE_NDIS_QUERY_CMPLT);
if (comp == NULL) {
if_printf(sc->hn_ifp, "exec RNDIS query 0x%08x failed\n", oid);
error = EIO;
goto done;
}
if (comp->rm_status != RNDIS_STATUS_SUCCESS) {
if_printf(sc->hn_ifp, "RNDIS query 0x%08x failed: "
"status 0x%08x\n", oid, comp->rm_status);
error = EIO;
goto done;
}
if (comp->rm_infobuflen == 0 || comp->rm_infobufoffset == 0) {
/* No output data! */
if_printf(sc->hn_ifp, "RNDIS query 0x%08x, no data\n", oid);
*odlen0 = 0;
error = 0;
goto done;
}
/*
* Check output data length and offset.
*/
/* ofs is the offset from the beginning of comp. */
ofs = RNDIS_QUERY_COMP_INFOBUFOFFSET_ABS(comp->rm_infobufoffset);
if (ofs < sizeof(*comp) || ofs + comp->rm_infobuflen > comp_len) {
if_printf(sc->hn_ifp, "RNDIS query invalid comp ib off/len, "
"%u/%u\n", comp->rm_infobufoffset, comp->rm_infobuflen);
error = EINVAL;
goto done;
}
/*
* Save output data.
*/
if (comp->rm_infobuflen < odlen)
odlen = comp->rm_infobuflen;
memcpy(odata, ((const uint8_t *)comp) + ofs, odlen);
*odlen0 = odlen;
error = 0;
done:
vmbus_xact_put(xact);
return (error);
}
