sys/dev/hyperv/netvsc/hn_nvs.c

   1 /*-
   2  * Copyright (c) 2009-2012,2016-2017 Microsoft Corp.
   3  * Copyright (c) 2010-2012 Citrix Inc.
   4  * Copyright (c) 2012 NetApp Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /*
  30  * Network Virtualization Service.
  31  */
  32
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include "opt_inet6.h"
  37 #include "opt_inet.h"
  38
  39 #include <sys/param.h>
  40 #include <sys/kernel.h>
  41 #include <sys/limits.h>
  42 #include <sys/socket.h>
  43 #include <sys/systm.h>
  44 #include <sys/taskqueue.h>
  45
  46 #include <net/ethernet.h>
  47 #include <net/if.h>
  48 #include <net/if_arp.h>
  49 #include <net/if_media.h>
  50
  51 #include <netinet/in.h>
  52 #include <netinet/tcp_lro.h>
  53
  54 #include <dev/hyperv/include/hyperv.h>
  55 #include <dev/hyperv/include/hyperv_busdma.h>
  56 #include <dev/hyperv/include/vmbus.h>
  57 #include <dev/hyperv/include/vmbus_xact.h>
  58
  59 #include <dev/hyperv/netvsc/ndis.h>
  60 #include <dev/hyperv/netvsc/if_hnreg.h>
  61 #include <dev/hyperv/netvsc/if_hnvar.h>
  62 #include <dev/hyperv/netvsc/hn_nvs.h>
  63
  64 static int                      hn_nvs_conn_chim(struct hn_softc *);
  65 static int                      hn_nvs_conn_rxbuf(struct hn_softc *);
  66 static void                     hn_nvs_disconn_chim(struct hn_softc *);
  67 static void                     hn_nvs_disconn_rxbuf(struct hn_softc *);
  68 static int                      hn_nvs_conf_ndis(struct hn_softc *, int);
  69 static int                      hn_nvs_init_ndis(struct hn_softc *);
  70 static int                      hn_nvs_doinit(struct hn_softc *, uint32_t);
  71 static int                      hn_nvs_init(struct hn_softc *);
  72 static const void               *hn_nvs_xact_execute(struct hn_softc *,
  73                                     struct vmbus_xact *, void *, int,
  74                                     size_t *, uint32_t);
  75 static void                     hn_nvs_sent_none(struct hn_nvs_sendctx *,
  76                                     struct hn_softc *, struct vmbus_channel *,
  77                                     const void *, int);
  78
  79 struct hn_nvs_sendctx           hn_nvs_sendctx_none =
  80     HN_NVS_SENDCTX_INITIALIZER(hn_nvs_sent_none, NULL);
  81
  82 static const uint32_t           hn_nvs_version[] = {
  83         HN_NVS_VERSION_5,
  84         HN_NVS_VERSION_4,
  85         HN_NVS_VERSION_2,
  86         HN_NVS_VERSION_1
  87 };
  88
  89 static const void *
  90 hn_nvs_xact_execute(struct hn_softc *sc, struct vmbus_xact *xact,
  91     void *req, int reqlen, size_t *resplen0, uint32_t type)
  92 {
  93         struct hn_nvs_sendctx sndc;
  94         size_t resplen, min_resplen = *resplen0;
  95         const struct hn_nvs_hdr *hdr;
  96         int error;
  97
  98         KASSERT(min_resplen >= sizeof(*hdr),
  99             ("invalid minimum response len %zu", min_resplen));
 100
 101         /*
 102          * Execute the xact setup by the caller.
 103          */
 104         hn_nvs_sendctx_init(&sndc, hn_nvs_sent_xact, xact);
 105
 106         vmbus_xact_activate(xact);
 107         error = hn_nvs_send(sc->hn_prichan, VMBUS_CHANPKT_FLAG_RC,
 108             req, reqlen, &sndc);
 109         if (error) {
 110                 vmbus_xact_deactivate(xact);
 111                 return (NULL);
 112         }
 113         hdr = vmbus_chan_xact_wait(sc->hn_prichan, xact, &resplen,
 114             HN_CAN_SLEEP(sc));
 115
 116         /*
 117          * Check this NVS response message.
 118          */
 119         if (resplen < min_resplen) {
 120                 if_printf(sc->hn_ifp, "invalid NVS resp len %zu\n", resplen);
 121                 return (NULL);
 122         }
 123         if (hdr->nvs_type != type) {
 124                 if_printf(sc->hn_ifp, "unexpected NVS resp 0x%08x, "
 125                     "expect 0x%08x\n", hdr->nvs_type, type);
 126                 return (NULL);
 127         }
 128         /* All pass! */
 129         *resplen0 = resplen;
 130         return (hdr);
 131 }
 132
 133 static __inline int
 134 hn_nvs_req_send(struct hn_softc *sc, void *req, int reqlen)
 135 {
 136
 137         return (hn_nvs_send(sc->hn_prichan, VMBUS_CHANPKT_FLAG_NONE,
 138             req, reqlen, &hn_nvs_sendctx_none));
 139 }
 140
 141 static int
 142 hn_nvs_conn_rxbuf(struct hn_softc *sc)
 143 {
 144         struct vmbus_xact *xact = NULL;
 145         struct hn_nvs_rxbuf_conn *conn;
 146         const struct hn_nvs_rxbuf_connresp *resp;
 147         size_t resp_len;
 148         uint32_t status;
 149         int error, rxbuf_size;
 150
 151         /*
 152          * Limit RXBUF size for old NVS.
 153          */
 154         if (sc->hn_nvs_ver <= HN_NVS_VERSION_2)
 155                 rxbuf_size = HN_RXBUF_SIZE_COMPAT;
 156         else
 157                 rxbuf_size = HN_RXBUF_SIZE;
 158
 159         /*
 160          * Connect the RXBUF GPADL to the primary channel.
 161          *
 162          * NOTE:
 163          * Only primary channel has RXBUF connected to it.  Sub-channels
 164          * just share this RXBUF.
 165          */
 166         error = vmbus_chan_gpadl_connect(sc->hn_prichan,
 167             sc->hn_rxbuf_dma.hv_paddr, rxbuf_size, &sc->hn_rxbuf_gpadl);
 168         if (error) {
 169                 if_printf(sc->hn_ifp, "rxbuf gpadl conn failed: %d\n",
 170                     error);
 171                 goto cleanup;
 172         }
 173
 174         /*
 175          * Connect RXBUF to NVS.
 176          */
 177
 178         xact = vmbus_xact_get(sc->hn_xact, sizeof(*conn));
 179         if (xact == NULL) {
 180                 if_printf(sc->hn_ifp, "no xact for nvs rxbuf conn\n");
 181                 error = ENXIO;
 182                 goto cleanup;
 183         }
 184         conn = vmbus_xact_req_data(xact);
 185         conn->nvs_type = HN_NVS_TYPE_RXBUF_CONN;
 186         conn->nvs_gpadl = sc->hn_rxbuf_gpadl;
 187         conn->nvs_sig = HN_NVS_RXBUF_SIG;
 188
 189         resp_len = sizeof(*resp);
 190         resp = hn_nvs_xact_execute(sc, xact, conn, sizeof(*conn), &resp_len,
 191             HN_NVS_TYPE_RXBUF_CONNRESP);
 192         if (resp == NULL) {
 193                 if_printf(sc->hn_ifp, "exec nvs rxbuf conn failed\n");
 194                 error = EIO;
 195                 goto cleanup;
 196         }
 197
 198         status = resp->nvs_status;
 199         vmbus_xact_put(xact);
 200         xact = NULL;
 201
 202         if (status != HN_NVS_STATUS_OK) {
 203                 if_printf(sc->hn_ifp, "nvs rxbuf conn failed: %x\n", status);
 204                 error = EIO;
 205                 goto cleanup;
 206         }
 207         sc->hn_flags |= HN_FLAG_RXBUF_CONNECTED;
 208
 209         return (0);
 210
 211 cleanup:
 212         if (xact != NULL)
 213                 vmbus_xact_put(xact);
 214         hn_nvs_disconn_rxbuf(sc);
 215         return (error);
 216 }
 217
 218 static int
 219 hn_nvs_conn_chim(struct hn_softc *sc)
 220 {
 221         struct vmbus_xact *xact = NULL;
 222         struct hn_nvs_chim_conn *chim;
 223         const struct hn_nvs_chim_connresp *resp;
 224         size_t resp_len;
 225         uint32_t status, sectsz;
 226         int error;
 227
 228         /*
 229          * Connect chimney sending buffer GPADL to the primary channel.
 230          *
 231          * NOTE:
 232          * Only primary channel has chimney sending buffer connected to it.
 233          * Sub-channels just share this chimney sending buffer.
 234          */
 235         error = vmbus_chan_gpadl_connect(sc->hn_prichan,
 236             sc->hn_chim_dma.hv_paddr, HN_CHIM_SIZE, &sc->hn_chim_gpadl);
 237         if (error) {
 238                 if_printf(sc->hn_ifp, "chim gpadl conn failed: %d\n", error);
 239                 goto cleanup;
 240         }
 241
 242         /*
 243          * Connect chimney sending buffer to NVS
 244          */
 245
 246         xact = vmbus_xact_get(sc->hn_xact, sizeof(*chim));
 247         if (xact == NULL) {
 248                 if_printf(sc->hn_ifp, "no xact for nvs chim conn\n");
 249                 error = ENXIO;
 250                 goto cleanup;
 251         }
 252         chim = vmbus_xact_req_data(xact);
 253         chim->nvs_type = HN_NVS_TYPE_CHIM_CONN;
 254         chim->nvs_gpadl = sc->hn_chim_gpadl;
 255         chim->nvs_sig = HN_NVS_CHIM_SIG;
 256
 257         resp_len = sizeof(*resp);
 258         resp = hn_nvs_xact_execute(sc, xact, chim, sizeof(*chim), &resp_len,
 259             HN_NVS_TYPE_CHIM_CONNRESP);
 260         if (resp == NULL) {
 261                 if_printf(sc->hn_ifp, "exec nvs chim conn failed\n");
 262                 error = EIO;
 263                 goto cleanup;
 264         }
 265
 266         status = resp->nvs_status;
 267         sectsz = resp->nvs_sectsz;
 268         vmbus_xact_put(xact);
 269         xact = NULL;
 270
 271         if (status != HN_NVS_STATUS_OK) {
 272                 if_printf(sc->hn_ifp, "nvs chim conn failed: %x\n", status);
 273                 error = EIO;
 274                 goto cleanup;
 275         }
 276         if (sectsz == 0 || sectsz % sizeof(uint32_t) != 0) {
 277                 /*
 278                  * Can't use chimney sending buffer; done!
 279                  */
 280                 if (sectsz == 0) {
 281                         if_printf(sc->hn_ifp, "zero chimney sending buffer "
 282                             "section size\n");
 283                 } else {
 284                         if_printf(sc->hn_ifp, "misaligned chimney sending "
 285                             "buffers, section size: %u\n", sectsz);
 286                 }
 287                 sc->hn_chim_szmax = 0;
 288                 sc->hn_chim_cnt = 0;
 289                 sc->hn_flags |= HN_FLAG_CHIM_CONNECTED;
 290                 return (0);
 291         }
 292
 293         sc->hn_chim_szmax = sectsz;
 294         sc->hn_chim_cnt = HN_CHIM_SIZE / sc->hn_chim_szmax;
 295         if (HN_CHIM_SIZE % sc->hn_chim_szmax != 0) {
 296                 if_printf(sc->hn_ifp, "chimney sending sections are "
 297                     "not properly aligned\n");
 298         }
 299         if (sc->hn_chim_cnt % LONG_BIT != 0) {
 300                 if_printf(sc->hn_ifp, "discard %d chimney sending sections\n",
 301                     sc->hn_chim_cnt % LONG_BIT);
 302         }
 303
 304         sc->hn_chim_bmap_cnt = sc->hn_chim_cnt / LONG_BIT;
 305         sc->hn_chim_bmap = malloc(sc->hn_chim_bmap_cnt * sizeof(u_long),
 306             M_DEVBUF, M_WAITOK | M_ZERO);
 307
 308         /* Done! */
 309         sc->hn_flags |= HN_FLAG_CHIM_CONNECTED;
 310         if (bootverbose) {
 311                 if_printf(sc->hn_ifp, "chimney sending buffer %d/%d\n",
 312                     sc->hn_chim_szmax, sc->hn_chim_cnt);
 313         }
 314         return (0);
 315
 316 cleanup:
 317         if (xact != NULL)
 318                 vmbus_xact_put(xact);
 319         hn_nvs_disconn_chim(sc);
 320         return (error);
 321 }
 322
 323 static void
 324 hn_nvs_disconn_rxbuf(struct hn_softc *sc)
 325 {
 326         int error;
 327
 328         if (sc->hn_flags & HN_FLAG_RXBUF_CONNECTED) {
 329                 struct hn_nvs_rxbuf_disconn disconn;
 330
 331                 /*
 332                  * Disconnect RXBUF from NVS.
 333                  */
 334                 memset(&disconn, 0, sizeof(disconn));
 335                 disconn.nvs_type = HN_NVS_TYPE_RXBUF_DISCONN;
 336                 disconn.nvs_sig = HN_NVS_RXBUF_SIG;
 337
 338                 /* NOTE: No response. */
 339                 error = hn_nvs_req_send(sc, &disconn, sizeof(disconn));
 340                 if (error) {
 341                         if_printf(sc->hn_ifp,
 342                             "send nvs rxbuf disconn failed: %d\n", error);
 343                         /*
 344                          * Fine for a revoked channel, since the hypervisor
 345                          * does not drain TX bufring for a revoked channel.
 346                          */
 347                         if (!vmbus_chan_is_revoked(sc->hn_prichan))
 348                                 sc->hn_flags |= HN_FLAG_RXBUF_REF;
 349                 }
 350                 sc->hn_flags &= ~HN_FLAG_RXBUF_CONNECTED;
 351
 352                 /*
 353                  * Wait for the hypervisor to receive this NVS request.
 354                  *
 355                  * NOTE:
 356                  * The TX bufring will not be drained by the hypervisor,
 357                  * if the primary channel is revoked.
 358                  */
 359                 while (!vmbus_chan_tx_empty(sc->hn_prichan) &&
 360                     !vmbus_chan_is_revoked(sc->hn_prichan))
 361                         pause("waittx", 1);
 362                 /*
 363                  * Linger long enough for NVS to disconnect RXBUF.
 364                  */
 365                 pause("lingtx", (200 * hz) / 1000);
 366         }
 367
 368         if (sc->hn_rxbuf_gpadl != 0) {
 369                 /*
 370                  * Disconnect RXBUF from primary channel.
 371                  */
 372                 error = vmbus_chan_gpadl_disconnect(sc->hn_prichan,
 373                     sc->hn_rxbuf_gpadl);
 374                 if (error) {
 375                         if_printf(sc->hn_ifp,
 376                             "rxbuf gpadl disconn failed: %d\n", error);
 377                         sc->hn_flags |= HN_FLAG_RXBUF_REF;
 378                 }
 379                 sc->hn_rxbuf_gpadl = 0;
 380         }
 381 }
 382
 383 static void
 384 hn_nvs_disconn_chim(struct hn_softc *sc)
 385 {
 386         int error;
 387
 388         if (sc->hn_flags & HN_FLAG_CHIM_CONNECTED) {
 389                 struct hn_nvs_chim_disconn disconn;
 390
 391                 /*
 392                  * Disconnect chimney sending buffer from NVS.
 393                  */
 394                 memset(&disconn, 0, sizeof(disconn));
 395                 disconn.nvs_type = HN_NVS_TYPE_CHIM_DISCONN;
 396                 disconn.nvs_sig = HN_NVS_CHIM_SIG;
 397
 398                 /* NOTE: No response. */
 399                 error = hn_nvs_req_send(sc, &disconn, sizeof(disconn));
 400                 if (error) {
 401                         if_printf(sc->hn_ifp,
 402                             "send nvs chim disconn failed: %d\n", error);
 403                         /*
 404                          * Fine for a revoked channel, since the hypervisor
 405                          * does not drain TX bufring for a revoked channel.
 406                          */
 407                         if (!vmbus_chan_is_revoked(sc->hn_prichan))
 408                                 sc->hn_flags |= HN_FLAG_CHIM_REF;
 409                 }
 410                 sc->hn_flags &= ~HN_FLAG_CHIM_CONNECTED;
 411
 412                 /*
 413                  * Wait for the hypervisor to receive this NVS request.
 414                  *
 415                  * NOTE:
 416                  * The TX bufring will not be drained by the hypervisor,
 417                  * if the primary channel is revoked.
 418                  */
 419                 while (!vmbus_chan_tx_empty(sc->hn_prichan) &&
 420                     !vmbus_chan_is_revoked(sc->hn_prichan))
 421                         pause("waittx", 1);
 422                 /*
 423                  * Linger long enough for NVS to disconnect chimney
 424                  * sending buffer.
 425                  */
 426                 pause("lingtx", (200 * hz) / 1000);
 427         }
 428
 429         if (sc->hn_chim_gpadl != 0) {
 430                 /*
 431                  * Disconnect chimney sending buffer from primary channel.
 432                  */
 433                 error = vmbus_chan_gpadl_disconnect(sc->hn_prichan,
 434                     sc->hn_chim_gpadl);
 435                 if (error) {
 436                         if_printf(sc->hn_ifp,
 437                             "chim gpadl disconn failed: %d\n", error);
 438                         sc->hn_flags |= HN_FLAG_CHIM_REF;
 439                 }
 440                 sc->hn_chim_gpadl = 0;
 441         }
 442
 443         if (sc->hn_chim_bmap != NULL) {
 444                 free(sc->hn_chim_bmap, M_DEVBUF);
 445                 sc->hn_chim_bmap = NULL;
 446                 sc->hn_chim_bmap_cnt = 0;
 447         }
 448 }
 449
 450 static int
 451 hn_nvs_doinit(struct hn_softc *sc, uint32_t nvs_ver)
 452 {
 453         struct vmbus_xact *xact;
 454         struct hn_nvs_init *init;
 455         const struct hn_nvs_init_resp *resp;
 456         size_t resp_len;
 457         uint32_t status;
 458
 459         xact = vmbus_xact_get(sc->hn_xact, sizeof(*init));
 460         if (xact == NULL) {
 461                 if_printf(sc->hn_ifp, "no xact for nvs init\n");
 462                 return (ENXIO);
 463         }
 464         init = vmbus_xact_req_data(xact);
 465         init->nvs_type = HN_NVS_TYPE_INIT;
 466         init->nvs_ver_min = nvs_ver;
 467         init->nvs_ver_max = nvs_ver;
 468
 469         resp_len = sizeof(*resp);
 470         resp = hn_nvs_xact_execute(sc, xact, init, sizeof(*init), &resp_len,
 471             HN_NVS_TYPE_INIT_RESP);
 472         if (resp == NULL) {
 473                 if_printf(sc->hn_ifp, "exec init failed\n");
 474                 vmbus_xact_put(xact);
 475                 return (EIO);
 476         }
 477
 478         status = resp->nvs_status;
 479         vmbus_xact_put(xact);
 480
 481         if (status != HN_NVS_STATUS_OK) {
 482                 if (bootverbose) {
 483                         /*
 484                          * Caller may try another NVS version, and will log
 485                          * error if there are no more NVS versions to try,
 486                          * so don't bark out loud here.
 487                          */
 488                         if_printf(sc->hn_ifp, "nvs init failed for ver 0x%x\n",
 489                             nvs_ver);
 490                 }
 491                 return (EINVAL);
 492         }
 493         return (0);
 494 }
 495
 496 /*
 497  * Configure MTU and enable VLAN.
 498  */
 499 static int
 500 hn_nvs_conf_ndis(struct hn_softc *sc, int mtu)
 501 {
 502         struct hn_nvs_ndis_conf conf;
 503         int error;
 504
 505         memset(&conf, 0, sizeof(conf));
 506         conf.nvs_type = HN_NVS_TYPE_NDIS_CONF;
 507         conf.nvs_mtu = mtu + ETHER_HDR_LEN;
 508         conf.nvs_caps = HN_NVS_NDIS_CONF_VLAN;
 509         if (sc->hn_nvs_ver >= HN_NVS_VERSION_5)
 510                 conf.nvs_caps |= HN_NVS_NDIS_CONF_SRIOV;
 511
 512         /* NOTE: No response. */
 513         error = hn_nvs_req_send(sc, &conf, sizeof(conf));
 514         if (error) {
 515                 if_printf(sc->hn_ifp, "send nvs ndis conf failed: %d\n", error);
 516                 return (error);
 517         }
 518
 519         if (bootverbose)
 520                 if_printf(sc->hn_ifp, "nvs ndis conf done\n");
 521         sc->hn_caps |= HN_CAP_MTU | HN_CAP_VLAN;
 522         return (0);
 523 }
 524
 525 static int
 526 hn_nvs_init_ndis(struct hn_softc *sc)
 527 {
 528         struct hn_nvs_ndis_init ndis;
 529         int error;
 530
 531         memset(&ndis, 0, sizeof(ndis));
 532         ndis.nvs_type = HN_NVS_TYPE_NDIS_INIT;
 533         ndis.nvs_ndis_major = HN_NDIS_VERSION_MAJOR(sc->hn_ndis_ver);
 534         ndis.nvs_ndis_minor = HN_NDIS_VERSION_MINOR(sc->hn_ndis_ver);
 535
 536         /* NOTE: No response. */
 537         error = hn_nvs_req_send(sc, &ndis, sizeof(ndis));
 538         if (error)
 539                 if_printf(sc->hn_ifp, "send nvs ndis init failed: %d\n", error);
 540         return (error);
 541 }
 542
 543 static int
 544 hn_nvs_init(struct hn_softc *sc)
 545 {
 546         int i, error;
 547
 548         if (device_is_attached(sc->hn_dev)) {
 549                 /*
 550                  * NVS version and NDIS version MUST NOT be changed.
 551                  */
 552                 if (bootverbose) {
 553                         if_printf(sc->hn_ifp, "reinit NVS version 0x%x, "
 554                             "NDIS version %u.%u\n", sc->hn_nvs_ver,
 555                             HN_NDIS_VERSION_MAJOR(sc->hn_ndis_ver),
 556                             HN_NDIS_VERSION_MINOR(sc->hn_ndis_ver));
 557                 }
 558
 559                 error = hn_nvs_doinit(sc, sc->hn_nvs_ver);
 560                 if (error) {
 561                         if_printf(sc->hn_ifp, "reinit NVS version 0x%x "
 562                             "failed: %d\n", sc->hn_nvs_ver, error);
 563                         return (error);
 564                 }
 565                 goto done;
 566         }
 567
 568         /*
 569          * Find the supported NVS version and set NDIS version accordingly.
 570          */
 571         for (i = 0; i < nitems(hn_nvs_version); ++i) {
 572                 error = hn_nvs_doinit(sc, hn_nvs_version[i]);
 573                 if (!error) {
 574                         sc->hn_nvs_ver = hn_nvs_version[i];
 575
 576                         /* Set NDIS version according to NVS version. */
 577                         sc->hn_ndis_ver = HN_NDIS_VERSION_6_30;
 578                         if (sc->hn_nvs_ver <= HN_NVS_VERSION_4)
 579                                 sc->hn_ndis_ver = HN_NDIS_VERSION_6_1;
 580
 581                         if (bootverbose) {
 582                                 if_printf(sc->hn_ifp, "NVS version 0x%x, "
 583                                     "NDIS version %u.%u\n", sc->hn_nvs_ver,
 584                                     HN_NDIS_VERSION_MAJOR(sc->hn_ndis_ver),
 585                                     HN_NDIS_VERSION_MINOR(sc->hn_ndis_ver));
 586                         }
 587                         goto done;
 588                 }
 589         }
 590         if_printf(sc->hn_ifp, "no NVS available\n");
 591         return (ENXIO);
 592
 593 done:
 594         if (sc->hn_nvs_ver >= HN_NVS_VERSION_5)
 595                 sc->hn_caps |= HN_CAP_HASHVAL;
 596         return (0);
 597 }
 598
 599 int
 600 hn_nvs_attach(struct hn_softc *sc, int mtu)
 601 {
 602         int error;
 603
 604         if (hyperv_ver_major >= 10) {
 605                 /* UDP 4-tuple hash is enforced. */
 606                 sc->hn_caps |= HN_CAP_UDPHASH;
 607         }
 608
 609         /*
 610          * Initialize NVS.
 611          */
 612         error = hn_nvs_init(sc);
 613         if (error)
 614                 return (error);
 615
 616         if (sc->hn_nvs_ver >= HN_NVS_VERSION_2) {
 617                 /*
 618                  * Configure NDIS before initializing it.
 619                  */
 620                 error = hn_nvs_conf_ndis(sc, mtu);
 621                 if (error)
 622                         return (error);
 623         }
 624
 625         /*
 626          * Initialize NDIS.
 627          */
 628         error = hn_nvs_init_ndis(sc);
 629         if (error)
 630                 return (error);
 631
 632         /*
 633          * Connect RXBUF.
 634          */
 635         error = hn_nvs_conn_rxbuf(sc);
 636         if (error)
 637                 return (error);
 638
 639         /*
 640          * Connect chimney sending buffer.
 641          */
 642         error = hn_nvs_conn_chim(sc);
 643         if (error) {
 644                 hn_nvs_disconn_rxbuf(sc);
 645                 return (error);
 646         }
 647         return (0);
 648 }
 649
 650 void
 651 hn_nvs_detach(struct hn_softc *sc)
 652 {
 653
 654         /* NOTE: there are no requests to stop the NVS. */
 655         hn_nvs_disconn_rxbuf(sc);
 656         hn_nvs_disconn_chim(sc);
 657 }
 658
 659 void
 660 hn_nvs_sent_xact(struct hn_nvs_sendctx *sndc,
 661     struct hn_softc *sc __unused, struct vmbus_channel *chan __unused,
 662     const void *data, int dlen)
 663 {
 664
 665         vmbus_xact_wakeup(sndc->hn_cbarg, data, dlen);
 666 }
 667
 668 static void
 669 hn_nvs_sent_none(struct hn_nvs_sendctx *sndc __unused,
 670     struct hn_softc *sc __unused, struct vmbus_channel *chan __unused,
 671     const void *data __unused, int dlen __unused)
 672 {
 673         /* EMPTY */
 674 }
 675
 676 int
 677 hn_nvs_alloc_subchans(struct hn_softc *sc, int *nsubch0)
 678 {
 679         struct vmbus_xact *xact;
 680         struct hn_nvs_subch_req *req;
 681         const struct hn_nvs_subch_resp *resp;
 682         int error, nsubch_req;
 683         uint32_t nsubch;
 684         size_t resp_len;
 685
 686         nsubch_req = *nsubch0;
 687         KASSERT(nsubch_req > 0, ("invalid # of sub-channels %d", nsubch_req));
 688
 689         xact = vmbus_xact_get(sc->hn_xact, sizeof(*req));
 690         if (xact == NULL) {
 691                 if_printf(sc->hn_ifp, "no xact for nvs subch alloc\n");
 692                 return (ENXIO);
 693         }
 694         req = vmbus_xact_req_data(xact);
 695         req->nvs_type = HN_NVS_TYPE_SUBCH_REQ;
 696         req->nvs_op = HN_NVS_SUBCH_OP_ALLOC;
 697         req->nvs_nsubch = nsubch_req;
 698
 699         resp_len = sizeof(*resp);
 700         resp = hn_nvs_xact_execute(sc, xact, req, sizeof(*req), &resp_len,
 701             HN_NVS_TYPE_SUBCH_RESP);
 702         if (resp == NULL) {
 703                 if_printf(sc->hn_ifp, "exec nvs subch alloc failed\n");
 704                 error = EIO;
 705                 goto done;
 706         }
 707         if (resp->nvs_status != HN_NVS_STATUS_OK) {
 708                 if_printf(sc->hn_ifp, "nvs subch alloc failed: %x\n",
 709                     resp->nvs_status);
 710                 error = EIO;
 711                 goto done;
 712         }
 713
 714         nsubch = resp->nvs_nsubch;
 715         if (nsubch > nsubch_req) {
 716                 if_printf(sc->hn_ifp, "%u subchans are allocated, "
 717                     "requested %d\n", nsubch, nsubch_req);
 718                 nsubch = nsubch_req;
 719         }
 720         *nsubch0 = nsubch;
 721         error = 0;
 722 done:
 723         vmbus_xact_put(xact);
 724         return (error);
 725 }
 726
 727 int
 728 hn_nvs_send_rndis_ctrl(struct vmbus_channel *chan,
 729     struct hn_nvs_sendctx *sndc, struct vmbus_gpa *gpa, int gpa_cnt)
 730 {
 731
 732         return hn_nvs_send_rndis_sglist(chan, HN_NVS_RNDIS_MTYPE_CTRL,
 733             sndc, gpa, gpa_cnt);
 734 }
 735
 736 void
 737 hn_nvs_set_datapath(struct hn_softc *sc, uint32_t path)
 738 {
 739         struct hn_nvs_datapath dp;
 740
 741         memset(&dp, 0, sizeof(dp));
 742         dp.nvs_type = HN_NVS_TYPE_SET_DATAPATH;
 743         dp.nvs_active_path = path;
 744
 745         hn_nvs_req_send(sc, &dp, sizeof(dp));
 746 }