drivers/net/netvsc/hn_nvs.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright (c) 2018 Microsoft Corp.
   3  * Copyright (c) 2010-2012 Citrix Inc.
   4  * Copyright (c) 2012 NetApp Inc.
   5  * All rights reserved.
   6  */
   7
   8 /*
   9  * Network Virtualization Service.
  10  */
  11
  12
  13 #include <stdint.h>
  14 #include <string.h>
  15 #include <stdio.h>
  16 #include <errno.h>
  17 #include <unistd.h>
  18
  19 #include <rte_ethdev.h>
  20 #include <rte_string_fns.h>
  21 #include <rte_memzone.h>
  22 #include <rte_malloc.h>
  23 #include <rte_atomic.h>
  24 #include <rte_branch_prediction.h>
  25 #include <rte_ether.h>
  26 #include <rte_common.h>
  27 #include <rte_errno.h>
  28 #include <rte_cycles.h>
  29 #include <rte_memory.h>
  30 #include <rte_eal.h>
  31 #include <rte_dev.h>
  32 #include <rte_bus_vmbus.h>
  33
  34 #include "hn_logs.h"
  35 #include "hn_var.h"
  36 #include "hn_nvs.h"
  37
  38 static const uint32_t hn_nvs_version[] = {
  39         NVS_VERSION_61,
  40         NVS_VERSION_6,
  41         NVS_VERSION_5,
  42         NVS_VERSION_4,
  43         NVS_VERSION_2,
  44         NVS_VERSION_1
  45 };
  46
  47 static int hn_nvs_req_send(struct hn_data *hv,
  48                            void *req, uint32_t reqlen)
  49 {
  50         return rte_vmbus_chan_send(hn_primary_chan(hv),
  51                                    VMBUS_CHANPKT_TYPE_INBAND,
  52                                    req, reqlen, 0,
  53                                    VMBUS_CHANPKT_FLAG_NONE, NULL);
  54 }
  55
  56 static int
  57 hn_nvs_execute(struct hn_data *hv,
  58                void *req, uint32_t reqlen,
  59                void *resp, uint32_t resplen,
  60                uint32_t type)
  61 {
  62         struct vmbus_channel *chan = hn_primary_chan(hv);
  63         char buffer[NVS_RESPSIZE_MAX];
  64         const struct hn_nvs_hdr *hdr;
  65         uint32_t len;
  66         int ret;
  67
  68         /* Send request to ring buffer */
  69         ret = rte_vmbus_chan_send(chan, VMBUS_CHANPKT_TYPE_INBAND,
  70                                   req, reqlen, 0,
  71                                   VMBUS_CHANPKT_FLAG_RC, NULL);
  72
  73         if (ret) {
  74                 PMD_DRV_LOG(ERR, "send request failed: %d", ret);
  75                 return ret;
  76         }
  77
  78  retry:
  79         len = sizeof(buffer);
  80         ret = rte_vmbus_chan_recv(chan, buffer, &len, NULL);
  81         if (ret == -EAGAIN) {
  82                 rte_delay_us(HN_CHAN_INTERVAL_US);
  83                 goto retry;
  84         }
  85
  86         if (ret < 0) {
  87                 PMD_DRV_LOG(ERR, "recv response failed: %d", ret);
  88                 return ret;
  89         }
  90
  91         hdr = (struct hn_nvs_hdr *)buffer;
  92         if (hdr->type != type) {
  93                 PMD_DRV_LOG(ERR, "unexpected NVS resp %#x, expect %#x",
  94                             hdr->type, type);
  95                 return -EINVAL;
  96         }
  97
  98         if (len < resplen) {
  99                 PMD_DRV_LOG(ERR,
 100                             "invalid NVS resp len %u (expect %u)",
 101                             len, resplen);
 102                 return -EINVAL;
 103         }
 104
 105         memcpy(resp, buffer, resplen);
 106
 107         /* All pass! */
 108         return 0;
 109 }
 110
 111 static int
 112 hn_nvs_doinit(struct hn_data *hv, uint32_t nvs_ver)
 113 {
 114         struct hn_nvs_init init;
 115         struct hn_nvs_init_resp resp;
 116         uint32_t status;
 117         int error;
 118
 119         memset(&init, 0, sizeof(init));
 120         init.type = NVS_TYPE_INIT;
 121         init.ver_min = nvs_ver;
 122         init.ver_max = nvs_ver;
 123
 124         error = hn_nvs_execute(hv, &init, sizeof(init),
 125                                &resp, sizeof(resp),
 126                                NVS_TYPE_INIT_RESP);
 127         if (error)
 128                 return error;
 129
 130         status = resp.status;
 131         if (status != NVS_STATUS_OK) {
 132                 /* Not fatal, try other versions */
 133                 PMD_INIT_LOG(DEBUG, "nvs init failed for ver 0x%x",
 134                              nvs_ver);
 135                 return -EINVAL;
 136         }
 137
 138         return 0;
 139 }
 140
 141 static int
 142 hn_nvs_conn_rxbuf(struct hn_data *hv)
 143 {
 144         struct hn_nvs_rxbuf_conn conn;
 145         struct hn_nvs_rxbuf_connresp resp;
 146         uint32_t status;
 147         int error;
 148
 149         /* Kernel has already setup RXBUF on primary channel. */
 150
 151         /*
 152          * Connect RXBUF to NVS.
 153          */
 154         conn.type = NVS_TYPE_RXBUF_CONN;
 155         conn.gpadl = hv->rxbuf_res->phys_addr;
 156         conn.sig = NVS_RXBUF_SIG;
 157         PMD_DRV_LOG(DEBUG, "connect rxbuff va=%p gpad=%#" PRIx64,
 158                     hv->rxbuf_res->addr,
 159                     hv->rxbuf_res->phys_addr);
 160
 161         error = hn_nvs_execute(hv, &conn, sizeof(conn),
 162                                &resp, sizeof(resp),
 163                                NVS_TYPE_RXBUF_CONNRESP);
 164         if (error) {
 165                 PMD_DRV_LOG(ERR,
 166                             "exec nvs rxbuf conn failed: %d",
 167                             error);
 168                 return error;
 169         }
 170
 171         status = resp.status;
 172         if (status != NVS_STATUS_OK) {
 173                 PMD_DRV_LOG(ERR,
 174                             "nvs rxbuf conn failed: %x", status);
 175                 return -EIO;
 176         }
 177         if (resp.nsect != 1) {
 178                 PMD_DRV_LOG(ERR,
 179                             "nvs rxbuf response num sections %u != 1",
 180                             resp.nsect);
 181                 return -EIO;
 182         }
 183
 184         PMD_DRV_LOG(INFO,
 185                     "receive buffer size %u count %u",
 186                     resp.nvs_sect[0].slotsz,
 187                     resp.nvs_sect[0].slotcnt);
 188         hv->rxbuf_section_cnt = resp.nvs_sect[0].slotcnt;
 189
 190         hv->rxbuf_info = rte_calloc("HN_RXBUF_INFO", hv->rxbuf_section_cnt,
 191                                     sizeof(*hv->rxbuf_info), RTE_CACHE_LINE_SIZE);
 192         if (!hv->rxbuf_info) {
 193                 PMD_DRV_LOG(ERR,
 194                             "could not allocate rxbuf info");
 195                 return -ENOMEM;
 196         }
 197
 198         return 0;
 199 }
 200
 201 static void
 202 hn_nvs_disconn_rxbuf(struct hn_data *hv)
 203 {
 204         struct hn_nvs_rxbuf_disconn disconn;
 205         int error;
 206
 207         /*
 208          * Disconnect RXBUF from NVS.
 209          */
 210         memset(&disconn, 0, sizeof(disconn));
 211         disconn.type = NVS_TYPE_RXBUF_DISCONN;
 212         disconn.sig = NVS_RXBUF_SIG;
 213
 214         /* NOTE: No response. */
 215         error = hn_nvs_req_send(hv, &disconn, sizeof(disconn));
 216         if (error) {
 217                 PMD_DRV_LOG(ERR,
 218                             "send nvs rxbuf disconn failed: %d",
 219                             error);
 220         }
 221
 222         rte_free(hv->rxbuf_info);
 223         /*
 224          * Linger long enough for NVS to disconnect RXBUF.
 225          */
 226         rte_delay_ms(200);
 227 }
 228
 229 static void
 230 hn_nvs_disconn_chim(struct hn_data *hv)
 231 {
 232         int error;
 233
 234         if (hv->chim_cnt != 0) {
 235                 struct hn_nvs_chim_disconn disconn;
 236
 237                 /* Disconnect chimney sending buffer from NVS. */
 238                 memset(&disconn, 0, sizeof(disconn));
 239                 disconn.type = NVS_TYPE_CHIM_DISCONN;
 240                 disconn.sig = NVS_CHIM_SIG;
 241
 242                 /* NOTE: No response. */
 243                 error = hn_nvs_req_send(hv, &disconn, sizeof(disconn));
 244
 245                 if (error) {
 246                         PMD_DRV_LOG(ERR,
 247                                     "send nvs chim disconn failed: %d", error);
 248                 }
 249
 250                 hv->chim_cnt = 0;
 251                 /*
 252                  * Linger long enough for NVS to disconnect chimney
 253                  * sending buffer.
 254                  */
 255                 rte_delay_ms(200);
 256         }
 257 }
 258
 259 static int
 260 hn_nvs_conn_chim(struct hn_data *hv)
 261 {
 262         struct hn_nvs_chim_conn chim;
 263         struct hn_nvs_chim_connresp resp;
 264         uint32_t sectsz;
 265         unsigned long len = hv->chim_res->len;
 266         int error;
 267
 268         /* Connect chimney sending buffer to NVS */
 269         memset(&chim, 0, sizeof(chim));
 270         chim.type = NVS_TYPE_CHIM_CONN;
 271         chim.gpadl = hv->chim_res->phys_addr;
 272         chim.sig = NVS_CHIM_SIG;
 273         PMD_DRV_LOG(DEBUG, "connect send buf va=%p gpad=%#" PRIx64,
 274                     hv->chim_res->addr,
 275                     hv->chim_res->phys_addr);
 276
 277         error = hn_nvs_execute(hv, &chim, sizeof(chim),
 278                                &resp, sizeof(resp),
 279                                NVS_TYPE_CHIM_CONNRESP);
 280         if (error) {
 281                 PMD_DRV_LOG(ERR, "exec nvs chim conn failed");
 282                 return error;
 283         }
 284
 285         if (resp.status != NVS_STATUS_OK) {
 286                 PMD_DRV_LOG(ERR, "nvs chim conn failed: %x",
 287                             resp.status);
 288                 return -EIO;
 289         }
 290
 291         sectsz = resp.sectsz;
 292         if (sectsz == 0 || sectsz & (sizeof(uint32_t) - 1)) {
 293                 /* Can't use chimney sending buffer; done! */
 294                 PMD_DRV_LOG(NOTICE,
 295                             "invalid chimney sending buffer section size: %u",
 296                             sectsz);
 297                 error = -EINVAL;
 298                 goto cleanup;
 299         }
 300
 301         hv->chim_szmax = sectsz;
 302         hv->chim_cnt = len / sectsz;
 303
 304         PMD_DRV_LOG(INFO, "send buffer %lu section size:%u, count:%u",
 305                     len, hv->chim_szmax, hv->chim_cnt);
 306
 307         /* Done! */
 308         return 0;
 309
 310 cleanup:
 311         hn_nvs_disconn_chim(hv);
 312         return error;
 313 }
 314
 315 /*
 316  * Configure MTU and enable VLAN.
 317  */
 318 static int
 319 hn_nvs_conf_ndis(struct hn_data *hv, unsigned int mtu)
 320 {
 321         struct hn_nvs_ndis_conf conf;
 322         int error;
 323
 324         memset(&conf, 0, sizeof(conf));
 325         conf.type = NVS_TYPE_NDIS_CONF;
 326         conf.mtu = mtu + ETHER_HDR_LEN;
 327         conf.caps = NVS_NDIS_CONF_VLAN;
 328
 329         /* TODO enable SRIOV */
 330         //if (hv->nvs_ver >= NVS_VERSION_5)
 331         //      conf.caps |= NVS_NDIS_CONF_SRIOV;
 332
 333         /* NOTE: No response. */
 334         error = hn_nvs_req_send(hv, &conf, sizeof(conf));
 335         if (error) {
 336                 PMD_DRV_LOG(ERR,
 337                             "send nvs ndis conf failed: %d", error);
 338                 return error;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static int
 345 hn_nvs_init_ndis(struct hn_data *hv)
 346 {
 347         struct hn_nvs_ndis_init ndis;
 348         int error;
 349
 350         memset(&ndis, 0, sizeof(ndis));
 351         ndis.type = NVS_TYPE_NDIS_INIT;
 352         ndis.ndis_major = NDIS_VERSION_MAJOR(hv->ndis_ver);
 353         ndis.ndis_minor = NDIS_VERSION_MINOR(hv->ndis_ver);
 354
 355         /* NOTE: No response. */
 356         error = hn_nvs_req_send(hv, &ndis, sizeof(ndis));
 357         if (error)
 358                 PMD_DRV_LOG(ERR,
 359                             "send nvs ndis init failed: %d", error);
 360
 361         return error;
 362 }
 363
 364 static int
 365 hn_nvs_init(struct hn_data *hv)
 366 {
 367         unsigned int i;
 368         int error;
 369
 370         /*
 371          * Find the supported NVS version and set NDIS version accordingly.
 372          */
 373         for (i = 0; i < RTE_DIM(hn_nvs_version); ++i) {
 374                 error = hn_nvs_doinit(hv, hn_nvs_version[i]);
 375                 if (error) {
 376                         PMD_INIT_LOG(DEBUG, "version %#x error %d",
 377                                      hn_nvs_version[i], error);
 378                         continue;
 379                 }
 380
 381                 hv->nvs_ver = hn_nvs_version[i];
 382
 383                 /* Set NDIS version according to NVS version. */
 384                 hv->ndis_ver = NDIS_VERSION_6_30;
 385                 if (hv->nvs_ver <= NVS_VERSION_4)
 386                         hv->ndis_ver = NDIS_VERSION_6_1;
 387
 388                 PMD_INIT_LOG(DEBUG,
 389                              "NVS version %#x, NDIS version %u.%u",
 390                              hv->nvs_ver, NDIS_VERSION_MAJOR(hv->ndis_ver),
 391                              NDIS_VERSION_MINOR(hv->ndis_ver));
 392                 return 0;
 393         }
 394
 395         PMD_DRV_LOG(ERR,
 396                     "no NVS compatible version available");
 397         return -ENXIO;
 398 }
 399
 400 int
 401 hn_nvs_attach(struct hn_data *hv, unsigned int mtu)
 402 {
 403         int error;
 404
 405         /*
 406          * Initialize NVS.
 407          */
 408         error = hn_nvs_init(hv);
 409         if (error)
 410                 return error;
 411
 412         /** Configure NDIS before initializing it. */
 413         if (hv->nvs_ver >= NVS_VERSION_2) {
 414                 error = hn_nvs_conf_ndis(hv, mtu);
 415                 if (error)
 416                         return error;
 417         }
 418
 419         /*
 420          * Initialize NDIS.
 421          */
 422         error = hn_nvs_init_ndis(hv);
 423         if (error)
 424                 return error;
 425
 426         /*
 427          * Connect RXBUF.
 428          */
 429         error = hn_nvs_conn_rxbuf(hv);
 430         if (error)
 431                 return error;
 432
 433         /*
 434          * Connect chimney sending buffer.
 435          */
 436         error = hn_nvs_conn_chim(hv);
 437         if (error) {
 438                 hn_nvs_disconn_rxbuf(hv);
 439                 return error;
 440         }
 441
 442         return 0;
 443 }
 444
 445 void
 446 hn_nvs_detach(struct hn_data *hv __rte_unused)
 447 {
 448         PMD_INIT_FUNC_TRACE();
 449
 450         /* NOTE: there are no requests to stop the NVS. */
 451         hn_nvs_disconn_rxbuf(hv);
 452         hn_nvs_disconn_chim(hv);
 453 }
 454
 455 /*
 456  * Ack the consumed RXBUF associated w/ this channel packet,
 457  * so that this RXBUF can be recycled by the hypervisor.
 458  */
 459 void
 460 hn_nvs_ack_rxbuf(struct vmbus_channel *chan, uint64_t tid)
 461 {
 462         unsigned int retries = 0;
 463         struct hn_nvs_rndis_ack ack = {
 464                 .type = NVS_TYPE_RNDIS_ACK,
 465                 .status = NVS_STATUS_OK,
 466         };
 467         int error;
 468
 469         PMD_RX_LOG(DEBUG, "ack RX id %" PRIu64, tid);
 470
 471  again:
 472         error = rte_vmbus_chan_send(chan, VMBUS_CHANPKT_TYPE_COMP,
 473                                     &ack, sizeof(ack), tid,
 474                                     VMBUS_CHANPKT_FLAG_NONE, NULL);
 475
 476         if (error == 0)
 477                 return;
 478
 479         if (error == -EAGAIN) {
 480                 /*
 481                  * NOTE:
 482                  * This should _not_ happen in real world, since the
 483                  * consumption of the TX bufring from the TX path is
 484                  * controlled.
 485                  */
 486                 PMD_RX_LOG(NOTICE, "RXBUF ack retry");
 487                 if (++retries < 10) {
 488                         rte_delay_ms(1);
 489                         goto again;
 490                 }
 491         }
 492         /* RXBUF leaks! */
 493         PMD_DRV_LOG(ERR, "RXBUF ack failed");
 494 }
 495
 496 int
 497 hn_nvs_alloc_subchans(struct hn_data *hv, uint32_t *nsubch)
 498 {
 499         struct hn_nvs_subch_req req;
 500         struct hn_nvs_subch_resp resp;
 501         int error;
 502
 503         memset(&req, 0, sizeof(req));
 504         req.type = NVS_TYPE_SUBCH_REQ;
 505         req.op = NVS_SUBCH_OP_ALLOC;
 506         req.nsubch = *nsubch;
 507
 508         error = hn_nvs_execute(hv, &req, sizeof(req),
 509                                &resp, sizeof(resp),
 510                                NVS_TYPE_SUBCH_RESP);
 511         if (error)
 512                 return error;
 513
 514         if (resp.status != NVS_STATUS_OK) {
 515                 PMD_INIT_LOG(ERR,
 516                              "nvs subch alloc failed: %#x",
 517                              resp.status);
 518                 return -EIO;
 519         }
 520
 521         if (resp.nsubch > *nsubch) {
 522                 PMD_INIT_LOG(NOTICE,
 523                              "%u subchans are allocated, requested %u",
 524                              resp.nsubch, *nsubch);
 525         }
 526         *nsubch = resp.nsubch;
 527
 528         return 0;
 529 }
 530
 531 void
 532 hn_nvs_set_datapath(struct hn_data *hv, uint32_t path)
 533 {
 534         struct hn_nvs_datapath dp;
 535
 536         memset(&dp, 0, sizeof(dp));
 537         dp.type = NVS_TYPE_SET_DATAPATH;
 538         dp.active_path = path;
 539
 540         hn_nvs_req_send(hv, &dp, sizeof(dp));
 541 }