drivers/net/enic/base/vnic_dev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2008-2017 Cisco Systems, Inc.  All rights reserved.
   3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
   4  */
   5
   6 #include <rte_memzone.h>
   7 #include <rte_memcpy.h>
   8 #include <rte_string_fns.h>
   9 #include <rte_ether.h>
  10
  11 #include "vnic_dev.h"
  12 #include "vnic_resource.h"
  13 #include "vnic_devcmd.h"
  14 #include "vnic_nic.h"
  15 #include "vnic_stats.h"
  16 #include "vnic_flowman.h"
  17
  18
  19 enum vnic_proxy_type {
  20         PROXY_NONE,
  21         PROXY_BY_BDF,
  22         PROXY_BY_INDEX,
  23 };
  24
  25 struct vnic_res {
  26         void __iomem *vaddr;
  27         dma_addr_t bus_addr;
  28         unsigned int count;
  29 };
  30
  31 struct vnic_intr_coal_timer_info {
  32         uint32_t mul;
  33         uint32_t div;
  34         uint32_t max_usec;
  35 };
  36
  37 struct vnic_dev {
  38         void *priv;
  39         struct rte_pci_device *pdev;
  40         struct vnic_res res[RES_TYPE_MAX];
  41         enum vnic_dev_intr_mode intr_mode;
  42         struct vnic_devcmd __iomem *devcmd;
  43         struct vnic_devcmd_notify *notify;
  44         struct vnic_devcmd_notify notify_copy;
  45         dma_addr_t notify_pa;
  46         uint32_t notify_sz;
  47         dma_addr_t linkstatus_pa;
  48         struct vnic_stats *stats;
  49         dma_addr_t stats_pa;
  50         struct vnic_devcmd_fw_info *fw_info;
  51         dma_addr_t fw_info_pa;
  52         struct fm_info *flowman_info;
  53         dma_addr_t flowman_info_pa;
  54         enum vnic_proxy_type proxy;
  55         uint32_t proxy_index;
  56         uint64_t args[VNIC_DEVCMD_NARGS];
  57         int in_reset;
  58         struct vnic_intr_coal_timer_info intr_coal_timer_info;
  59         void *(*alloc_consistent)(void *priv, size_t size,
  60                 dma_addr_t *dma_handle, uint8_t *name);
  61         void (*free_consistent)(void *priv,
  62                 size_t size, void *vaddr,
  63                 dma_addr_t dma_handle);
  64         /*
  65          * Used to serialize devcmd access, currently from PF and its
  66          * VF representors. When there are no representors, lock is
  67          * not used.
  68          */
  69         int locked;
  70         void (*lock)(void *priv);
  71         void (*unlock)(void *priv);
  72         struct vnic_dev *pf_vdev;
  73         int vf_id;
  74 };
  75
  76 #define VNIC_MAX_RES_HDR_SIZE \
  77         (sizeof(struct vnic_resource_header) + \
  78         sizeof(struct vnic_resource) * RES_TYPE_MAX)
  79 #define VNIC_RES_STRIDE 128
  80
  81 void *vnic_dev_priv(struct vnic_dev *vdev)
  82 {
  83         return vdev->priv;
  84 }
  85
  86 void vnic_register_cbacks(struct vnic_dev *vdev,
  87         void *(*alloc_consistent)(void *priv, size_t size,
  88             dma_addr_t *dma_handle, uint8_t *name),
  89         void (*free_consistent)(void *priv,
  90             size_t size, void *vaddr,
  91             dma_addr_t dma_handle))
  92 {
  93         vdev->alloc_consistent = alloc_consistent;
  94         vdev->free_consistent = free_consistent;
  95 }
  96
  97 void vnic_register_lock(struct vnic_dev *vdev, void (*lock)(void *priv),
  98         void (*unlock)(void *priv))
  99 {
 100         vdev->lock = lock;
 101         vdev->unlock = unlock;
 102         vdev->locked = 0;
 103 }
 104
 105 static int vnic_dev_discover_res(struct vnic_dev *vdev,
 106         struct vnic_dev_bar *bar, unsigned int num_bars)
 107 {
 108         struct vnic_resource_header __iomem *rh;
 109         struct mgmt_barmap_hdr __iomem *mrh;
 110         struct vnic_resource __iomem *r;
 111         uint8_t type;
 112
 113         if (num_bars == 0)
 114                 return -EINVAL;
 115
 116         if (bar->len < VNIC_MAX_RES_HDR_SIZE) {
 117                 pr_err("vNIC BAR0 res hdr length error\n");
 118                 return -EINVAL;
 119         }
 120
 121         rh  = bar->vaddr;
 122         mrh = bar->vaddr;
 123         if (!rh) {
 124                 pr_err("vNIC BAR0 res hdr not mem-mapped\n");
 125                 return -EINVAL;
 126         }
 127
 128         /* Check for mgmt vnic in addition to normal vnic */
 129         if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) ||
 130                 (ioread32(&rh->version) != VNIC_RES_VERSION)) {
 131                 if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) ||
 132                         (ioread32(&mrh->version) != MGMTVNIC_VERSION)) {
 133                         pr_err("vNIC BAR0 res magic/version error " \
 134                                 "exp (%lx/%lx) or (%lx/%lx), curr (%x/%x)\n",
 135                                 VNIC_RES_MAGIC, VNIC_RES_VERSION,
 136                                 MGMTVNIC_MAGIC, MGMTVNIC_VERSION,
 137                                 ioread32(&rh->magic), ioread32(&rh->version));
 138                         return -EINVAL;
 139                 }
 140         }
 141
 142         if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC)
 143                 r = (struct vnic_resource __iomem *)(mrh + 1);
 144         else
 145                 r = (struct vnic_resource __iomem *)(rh + 1);
 146
 147
 148         while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {
 149                 uint8_t bar_num = ioread8(&r->bar);
 150                 uint32_t bar_offset = ioread32(&r->bar_offset);
 151                 uint32_t count = ioread32(&r->count);
 152                 uint32_t len;
 153
 154                 r++;
 155
 156                 if (bar_num >= num_bars)
 157                         continue;
 158
 159                 if (!bar[bar_num].len || !bar[bar_num].vaddr)
 160                         continue;
 161
 162                 switch (type) {
 163                 case RES_TYPE_WQ:
 164                 case RES_TYPE_RQ:
 165                 case RES_TYPE_CQ:
 166                 case RES_TYPE_INTR_CTRL:
 167                         /* each count is stride bytes long */
 168                         len = count * VNIC_RES_STRIDE;
 169                         if (len + bar_offset > bar[bar_num].len) {
 170                                 pr_err("vNIC BAR0 resource %d " \
 171                                         "out-of-bounds, offset 0x%x + " \
 172                                         "size 0x%x > bar len 0x%lx\n",
 173                                         type, bar_offset,
 174                                         len,
 175                                         bar[bar_num].len);
 176                                 return -EINVAL;
 177                         }
 178                         break;
 179                 case RES_TYPE_INTR_PBA_LEGACY:
 180                 case RES_TYPE_DEVCMD:
 181                         len = count;
 182                         break;
 183                 default:
 184                         continue;
 185                 }
 186
 187                 vdev->res[type].count = count;
 188                 vdev->res[type].vaddr = (char __iomem *)bar[bar_num].vaddr +
 189                     bar_offset;
 190                 vdev->res[type].bus_addr = bar[bar_num].bus_addr + bar_offset;
 191         }
 192
 193         return 0;
 194 }
 195
 196 unsigned int vnic_dev_get_res_count(struct vnic_dev *vdev,
 197         enum vnic_res_type type)
 198 {
 199         return vdev->res[type].count;
 200 }
 201
 202 void __iomem *vnic_dev_get_res(struct vnic_dev *vdev, enum vnic_res_type type,
 203         unsigned int index)
 204 {
 205         if (!vdev->res[type].vaddr)
 206                 return NULL;
 207
 208         switch (type) {
 209         case RES_TYPE_WQ:
 210         case RES_TYPE_RQ:
 211         case RES_TYPE_CQ:
 212         case RES_TYPE_INTR_CTRL:
 213                 return (char __iomem *)vdev->res[type].vaddr +
 214                         index * VNIC_RES_STRIDE;
 215         default:
 216                 return (char __iomem *)vdev->res[type].vaddr;
 217         }
 218 }
 219
 220 unsigned int vnic_dev_desc_ring_size(struct vnic_dev_ring *ring,
 221         unsigned int desc_count, unsigned int desc_size)
 222 {
 223         /* The base address of the desc rings must be 512 byte aligned.
 224          * Descriptor count is aligned to groups of 32 descriptors.  A
 225          * count of 0 means the maximum 4096 descriptors.  Descriptor
 226          * size is aligned to 16 bytes.
 227          */
 228
 229         unsigned int count_align = 32;
 230         unsigned int desc_align = 16;
 231
 232         ring->base_align = 512;
 233
 234         if (desc_count == 0)
 235                 desc_count = 4096;
 236
 237         ring->desc_count = VNIC_ALIGN(desc_count, count_align);
 238
 239         ring->desc_size = VNIC_ALIGN(desc_size, desc_align);
 240
 241         ring->size = ring->desc_count * ring->desc_size;
 242         ring->size_unaligned = ring->size + ring->base_align;
 243
 244         return ring->size_unaligned;
 245 }
 246
 247 void vnic_dev_clear_desc_ring(struct vnic_dev_ring *ring)
 248 {
 249         memset(ring->descs, 0, ring->size);
 250 }
 251
 252 int vnic_dev_alloc_desc_ring(struct vnic_dev *vdev,
 253         struct vnic_dev_ring *ring,
 254         unsigned int desc_count, unsigned int desc_size,
 255         __rte_unused unsigned int socket_id,
 256         char *z_name)
 257 {
 258         void *alloc_addr;
 259         dma_addr_t alloc_pa = 0;
 260
 261         vnic_dev_desc_ring_size(ring, desc_count, desc_size);
 262         alloc_addr = vdev->alloc_consistent(vdev->priv,
 263                                             ring->size_unaligned,
 264                                             &alloc_pa, (uint8_t *)z_name);
 265         if (!alloc_addr) {
 266                 pr_err("Failed to allocate ring (size=%d), aborting\n",
 267                         (int)ring->size);
 268                 return -ENOMEM;
 269         }
 270         ring->descs_unaligned = alloc_addr;
 271         if (!alloc_pa) {
 272                 pr_err("Failed to map allocated ring (size=%d), aborting\n",
 273                         (int)ring->size);
 274                 vdev->free_consistent(vdev->priv,
 275                                       ring->size_unaligned,
 276                                       alloc_addr,
 277                                       alloc_pa);
 278                 return -ENOMEM;
 279         }
 280         ring->base_addr_unaligned = alloc_pa;
 281
 282         ring->base_addr = VNIC_ALIGN(ring->base_addr_unaligned,
 283                 ring->base_align);
 284         ring->descs = (uint8_t *)ring->descs_unaligned +
 285             (ring->base_addr - ring->base_addr_unaligned);
 286
 287         vnic_dev_clear_desc_ring(ring);
 288
 289         ring->desc_avail = ring->desc_count - 1;
 290
 291         return 0;
 292 }
 293
 294 void vnic_dev_free_desc_ring(__rte_unused  struct vnic_dev *vdev,
 295         struct vnic_dev_ring *ring)
 296 {
 297         if (ring->descs) {
 298                 vdev->free_consistent(vdev->priv,
 299                                       ring->size_unaligned,
 300                                       ring->descs_unaligned,
 301                                       ring->base_addr_unaligned);
 302                 ring->descs = NULL;
 303         }
 304 }
 305
 306 static int _vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
 307         int wait)
 308 {
 309         struct vnic_devcmd __iomem *devcmd = vdev->devcmd;
 310         unsigned int i;
 311         int delay;
 312         uint32_t status;
 313         int err;
 314
 315         status = ioread32(&devcmd->status);
 316         if (status == 0xFFFFFFFF) {
 317                 /* PCI-e target device is gone */
 318                 return -ENODEV;
 319         }
 320         if (status & STAT_BUSY) {
 321
 322                 pr_err("Busy devcmd %d\n",  _CMD_N(cmd));
 323                 return -EBUSY;
 324         }
 325
 326         if (_CMD_DIR(cmd) & _CMD_DIR_WRITE) {
 327                 for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
 328                         writeq(vdev->args[i], &devcmd->args[i]);
 329                 rte_wmb(); /* complete all writes initiated till now */
 330         }
 331
 332         iowrite32(cmd, &devcmd->cmd);
 333
 334         if ((_CMD_FLAGS(cmd) & _CMD_FLAGS_NOWAIT))
 335                 return 0;
 336
 337         for (delay = 0; delay < wait; delay++) {
 338
 339                 usleep(100);
 340
 341                 status = ioread32(&devcmd->status);
 342                 if (status == 0xFFFFFFFF) {
 343                         /* PCI-e target device is gone */
 344                         return -ENODEV;
 345                 }
 346
 347                 if (!(status & STAT_BUSY)) {
 348                         if (status & STAT_ERROR) {
 349                                 err = -(int)readq(&devcmd->args[0]);
 350                                 if (cmd != CMD_CAPABILITY &&
 351                                     cmd != CMD_OVERLAY_OFFLOAD_CTRL &&
 352                                     cmd != CMD_GET_SUPP_FEATURE_VER)
 353                                         pr_err("Devcmd %d failed " \
 354                                                 "with error code %d\n",
 355                                                 _CMD_N(cmd), err);
 356                                 return err;
 357                         }
 358
 359                         if (_CMD_DIR(cmd) & _CMD_DIR_READ) {
 360                                 rte_rmb();/* finish all reads */
 361                                 for (i = 0; i < VNIC_DEVCMD_NARGS; i++)
 362                                         vdev->args[i] = readq(&devcmd->args[i]);
 363                         }
 364
 365                         return 0;
 366                 }
 367         }
 368
 369         pr_err("Timedout devcmd %d\n", _CMD_N(cmd));
 370         return -ETIMEDOUT;
 371 }
 372
 373 static int vnic_dev_cmd_proxy(struct vnic_dev *vdev,
 374         enum vnic_devcmd_cmd proxy_cmd, enum vnic_devcmd_cmd cmd,
 375         uint64_t *args, int nargs, int wait)
 376 {
 377         uint32_t status;
 378         int err;
 379
 380         /*
 381          * Proxy command consumes 2 arguments. One for proxy index,
 382          * the other is for command to be proxied
 383          */
 384         if (nargs > VNIC_DEVCMD_NARGS - 2) {
 385                 pr_err("number of args %d exceeds the maximum\n", nargs);
 386                 return -EINVAL;
 387         }
 388         memset(vdev->args, 0, sizeof(vdev->args));
 389
 390         vdev->args[0] = vdev->proxy_index;
 391         vdev->args[1] = cmd;
 392         memcpy(&vdev->args[2], args, nargs * sizeof(args[0]));
 393
 394         err = _vnic_dev_cmd(vdev, proxy_cmd, wait);
 395         if (err)
 396                 return err;
 397
 398         status = (uint32_t)vdev->args[0];
 399         if (status & STAT_ERROR) {
 400                 err = (int)vdev->args[1];
 401                 if (err != ERR_ECMDUNKNOWN ||
 402                     cmd != CMD_CAPABILITY)
 403                         pr_err("Error %d proxy devcmd %d\n", err, _CMD_N(cmd));
 404                 return err;
 405         }
 406
 407         memcpy(args, &vdev->args[1], nargs * sizeof(args[0]));
 408
 409         return 0;
 410 }
 411
 412 static int vnic_dev_cmd_no_proxy(struct vnic_dev *vdev,
 413         enum vnic_devcmd_cmd cmd, uint64_t *args, int nargs, int wait)
 414 {
 415         int err;
 416
 417         if (nargs > VNIC_DEVCMD_NARGS) {
 418                 pr_err("number of args %d exceeds the maximum\n", nargs);
 419                 return -EINVAL;
 420         }
 421         memset(vdev->args, 0, sizeof(vdev->args));
 422         memcpy(vdev->args, args, nargs * sizeof(args[0]));
 423
 424         err = _vnic_dev_cmd(vdev, cmd, wait);
 425
 426         memcpy(args, vdev->args, nargs * sizeof(args[0]));
 427
 428         return err;
 429 }
 430
 431 void vnic_dev_cmd_proxy_by_index_start(struct vnic_dev *vdev, uint16_t index)
 432 {
 433         vdev->proxy = PROXY_BY_INDEX;
 434         vdev->proxy_index = index;
 435 }
 436
 437 void vnic_dev_cmd_proxy_end(struct vnic_dev *vdev)
 438 {
 439         vdev->proxy = PROXY_NONE;
 440         vdev->proxy_index = 0;
 441 }
 442
 443 int vnic_dev_cmd(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
 444         uint64_t *a0, uint64_t *a1, int wait)
 445 {
 446         uint64_t args[2];
 447         bool vf_rep;
 448         int vf_idx;
 449         int err;
 450
 451         vf_rep = false;
 452         if (vdev->pf_vdev) {
 453                 vf_rep = true;
 454                 vf_idx = vdev->vf_id;
 455                 /* Everything below assumes PF vdev */
 456                 vdev = vdev->pf_vdev;
 457         }
 458         if (vdev->lock)
 459                 vdev->lock(vdev->priv);
 460         /* For VF representor, proxy devcmd to VF index */
 461         if (vf_rep)
 462                 vnic_dev_cmd_proxy_by_index_start(vdev, vf_idx);
 463
 464         args[0] = *a0;
 465         args[1] = *a1;
 466         memset(vdev->args, 0, sizeof(vdev->args));
 467
 468         switch (vdev->proxy) {
 469         case PROXY_BY_INDEX:
 470                 err =  vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd,
 471                                 args, ARRAY_SIZE(args), wait);
 472                 break;
 473         case PROXY_BY_BDF:
 474                 err =  vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd,
 475                                 args, ARRAY_SIZE(args), wait);
 476                 break;
 477         case PROXY_NONE:
 478         default:
 479                 err = vnic_dev_cmd_no_proxy(vdev, cmd, args, 2, wait);
 480                 break;
 481         }
 482
 483         if (vf_rep)
 484                 vnic_dev_cmd_proxy_end(vdev);
 485         if (vdev->unlock)
 486                 vdev->unlock(vdev->priv);
 487         if (err == 0) {
 488                 *a0 = args[0];
 489                 *a1 = args[1];
 490         }
 491
 492         return err;
 493 }
 494
 495 int vnic_dev_cmd_args(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd,
 496                       uint64_t *args, int nargs, int wait)
 497 {
 498         bool vf_rep;
 499         int vf_idx;
 500         int err;
 501
 502         vf_rep = false;
 503         if (vdev->pf_vdev) {
 504                 vf_rep = true;
 505                 vf_idx = vdev->vf_id;
 506                 vdev = vdev->pf_vdev;
 507         }
 508         if (vdev->lock)
 509                 vdev->lock(vdev->priv);
 510         if (vf_rep)
 511                 vnic_dev_cmd_proxy_by_index_start(vdev, vf_idx);
 512
 513         switch (vdev->proxy) {
 514         case PROXY_BY_INDEX:
 515                 err = vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_INDEX, cmd,
 516                                 args, nargs, wait);
 517                 break;
 518         case PROXY_BY_BDF:
 519                 err = vnic_dev_cmd_proxy(vdev, CMD_PROXY_BY_BDF, cmd,
 520                                 args, nargs, wait);
 521                 break;
 522         case PROXY_NONE:
 523         default:
 524                 err = vnic_dev_cmd_no_proxy(vdev, cmd, args, nargs, wait);
 525                 break;
 526         }
 527
 528         if (vf_rep)
 529                 vnic_dev_cmd_proxy_end(vdev);
 530         if (vdev->unlock)
 531                 vdev->unlock(vdev->priv);
 532         return err;
 533 }
 534
 535 int vnic_dev_fw_info(struct vnic_dev *vdev,
 536                      struct vnic_devcmd_fw_info **fw_info)
 537 {
 538         char name[RTE_MEMZONE_NAMESIZE];
 539         uint64_t a0, a1 = 0;
 540         int wait = 1000;
 541         int err = 0;
 542         static uint32_t instance;
 543
 544         if (!vdev->fw_info) {
 545                 snprintf((char *)name, sizeof(name), "vnic_fw_info-%u",
 546                          instance++);
 547                 vdev->fw_info = vdev->alloc_consistent(vdev->priv,
 548                         sizeof(struct vnic_devcmd_fw_info),
 549                         &vdev->fw_info_pa, (uint8_t *)name);
 550                 if (!vdev->fw_info)
 551                         return -ENOMEM;
 552                 a0 = vdev->fw_info_pa;
 553                 a1 = sizeof(struct vnic_devcmd_fw_info);
 554                 err = vnic_dev_cmd(vdev, CMD_MCPU_FW_INFO,
 555                                    &a0, &a1, wait);
 556         }
 557         *fw_info = vdev->fw_info;
 558         return err;
 559 }
 560
 561 static int vnic_dev_advanced_filters_cap(struct vnic_dev *vdev, uint64_t *args,
 562                 int nargs)
 563 {
 564         memset(args, 0, nargs * sizeof(*args));
 565         args[0] = CMD_ADD_ADV_FILTER;
 566         args[1] = FILTER_CAP_MODE_V1_FLAG;
 567         return vnic_dev_cmd_args(vdev, CMD_CAPABILITY, args, nargs, 1000);
 568 }
 569
 570 int vnic_dev_capable_adv_filters(struct vnic_dev *vdev)
 571 {
 572         uint64_t a0 = CMD_ADD_ADV_FILTER, a1 = 0;
 573         int wait = 1000;
 574         int err;
 575
 576         err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
 577         if (err)
 578                 return 0;
 579         return (a1 >= (uint32_t)FILTER_DPDK_1);
 580 }
 581
 582 int vnic_dev_flowman_cmd(struct vnic_dev *vdev, uint64_t *args, int nargs)
 583 {
 584         int wait = 1000;
 585
 586         return vnic_dev_cmd_args(vdev, CMD_FLOW_MANAGER_OP, args, nargs, wait);
 587 }
 588
 589 static int vnic_dev_flowman_enable(struct vnic_dev *vdev, uint32_t *mode,
 590                                    uint8_t *filter_actions)
 591 {
 592         char name[RTE_MEMZONE_NAMESIZE];
 593         uint64_t args[3];
 594         uint64_t ops;
 595         static uint32_t instance;
 596
 597         /* flowman devcmd available? */
 598         if (!vnic_dev_capable(vdev, CMD_FLOW_MANAGER_OP))
 599                 return 0;
 600         /* Have the version we are using? */
 601         args[0] = FM_API_VERSION_QUERY;
 602         if (vnic_dev_flowman_cmd(vdev, args, 1))
 603                 return 0;
 604         if ((args[0] & (1ULL << FM_VERSION)) == 0)
 605                 return 0;
 606         /* Select the version */
 607         args[0] = FM_API_VERSION_SELECT;
 608         args[1] = FM_VERSION;
 609         if (vnic_dev_flowman_cmd(vdev, args, 2))
 610                 return 0;
 611         /* Can we get fm_info? */
 612         if (!vdev->flowman_info) {
 613                 snprintf((char *)name, sizeof(name), "vnic_fm_info-%u",
 614                          instance++);
 615                 vdev->flowman_info = vdev->alloc_consistent(vdev->priv,
 616                         sizeof(struct fm_info),
 617                         &vdev->flowman_info_pa, (uint8_t *)name);
 618                 if (!vdev->flowman_info)
 619                         return 0;
 620         }
 621         args[0] = FM_INFO_QUERY;
 622         args[1] = vdev->flowman_info_pa;
 623         args[2] = sizeof(struct fm_info);
 624         if (vnic_dev_flowman_cmd(vdev, args, 3))
 625                 return 0;
 626         /* Have required operations? */
 627         ops = (1ULL << FMOP_END) |
 628                 (1ULL << FMOP_DROP) |
 629                 (1ULL << FMOP_RQ_STEER) |
 630                 (1ULL << FMOP_EXACT_MATCH) |
 631                 (1ULL << FMOP_MARK) |
 632                 (1ULL << FMOP_TAG) |
 633                 (1ULL << FMOP_EG_HAIRPIN) |
 634                 (1ULL << FMOP_ENCAP) |
 635                 (1ULL << FMOP_DECAP_NOSTRIP);
 636         if ((vdev->flowman_info->fm_op_mask & ops) != ops)
 637                 return 0;
 638         /* Good to use flowman now */
 639         *mode = FILTER_FLOWMAN;
 640         *filter_actions = FILTER_ACTION_RQ_STEERING_FLAG |
 641                 FILTER_ACTION_FILTER_ID_FLAG |
 642                 FILTER_ACTION_COUNTER_FLAG |
 643                 FILTER_ACTION_DROP_FLAG;
 644         return 1;
 645 }
 646
 647 /*  Determine the "best" filtering mode VIC is capable of. Returns one of 4
 648  *  value or 0 if filtering is unavailble:
 649  *      FILTER_FLOWMAN- flowman api capable
 650  *      FILTER_DPDK_1- advanced filters availabile
 651  *      FILTER_USNIC_IP_FLAG - advanced filters but with the restriction that
 652  *              the IP layer must explicitly specified. I.e. cannot have a UDP
 653  *              filter that matches both IPv4 and IPv6.
 654  *      FILTER_IPV4_5TUPLE - fallback if either of the 2 above aren't available.
 655  *              all other filter types are not available.
 656  *   Retrun true in filter_tags if supported
 657  */
 658 int vnic_dev_capable_filter_mode(struct vnic_dev *vdev, uint32_t *mode,
 659                                  uint8_t *filter_actions)
 660 {
 661         uint64_t args[4];
 662         int err;
 663         uint32_t max_level = 0;
 664
 665         /* If flowman is available, use it as it is the most capable API */
 666         if (vnic_dev_flowman_enable(vdev, mode, filter_actions))
 667                 return 0;
 668
 669         err = vnic_dev_advanced_filters_cap(vdev, args, 4);
 670
 671         /* determine supported filter actions */
 672         *filter_actions = FILTER_ACTION_RQ_STEERING_FLAG; /* always available */
 673         if (args[2] == FILTER_CAP_MODE_V1)
 674                 *filter_actions = args[3];
 675
 676         if (err || ((args[0] == 1) && (args[1] == 0))) {
 677                 /* Adv filter Command not supported or adv filters available but
 678                  * not enabled. Try the normal filter capability command.
 679                  */
 680                 args[0] = CMD_ADD_FILTER;
 681                 args[1] = 0;
 682                 err = vnic_dev_cmd_args(vdev, CMD_CAPABILITY, args, 2, 1000);
 683                 /*
 684                  * ERR_EPERM may be returned if, for example, vNIC is
 685                  * on a VF. It simply means no filtering is available
 686                  */
 687                 if (err == -ERR_EPERM) {
 688                         *mode = 0;
 689                         return 0;
 690                 }
 691                 if (err)
 692                         return err;
 693                 max_level = args[1];
 694                 goto parse_max_level;
 695         } else if (args[2] == FILTER_CAP_MODE_V1) {
 696                 /* parse filter capability mask in args[1] */
 697                 if (args[1] & FILTER_DPDK_1_FLAG)
 698                         *mode = FILTER_DPDK_1;
 699                 else if (args[1] & FILTER_USNIC_IP_FLAG)
 700                         *mode = FILTER_USNIC_IP;
 701                 else if (args[1] & FILTER_IPV4_5TUPLE_FLAG)
 702                         *mode = FILTER_IPV4_5TUPLE;
 703                 return 0;
 704         }
 705         max_level = args[1];
 706 parse_max_level:
 707         if (max_level >= (uint32_t)FILTER_USNIC_IP)
 708                 *mode = FILTER_USNIC_IP;
 709         else
 710                 *mode = FILTER_IPV4_5TUPLE;
 711         return 0;
 712 }
 713
 714 void vnic_dev_capable_udp_rss_weak(struct vnic_dev *vdev, bool *cfg_chk,
 715                                    bool *weak)
 716 {
 717         uint64_t a0 = CMD_NIC_CFG, a1 = 0;
 718         int wait = 1000;
 719         int err;
 720
 721         *cfg_chk = false;
 722         *weak = false;
 723         err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
 724         if (err == 0 && a0 != 0 && a1 != 0) {
 725                 *cfg_chk = true;
 726                 *weak = !!((a1 >> 32) & CMD_NIC_CFG_CAPF_UDP_WEAK);
 727         }
 728 }
 729
 730 int vnic_dev_capable(struct vnic_dev *vdev, enum vnic_devcmd_cmd cmd)
 731 {
 732         uint64_t a0 = (uint32_t)cmd, a1 = 0;
 733         int wait = 1000;
 734         int err;
 735
 736         err = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
 737
 738         return !(err || a0);
 739 }
 740
 741 int vnic_dev_spec(struct vnic_dev *vdev, unsigned int offset, size_t size,
 742         void *value)
 743 {
 744         uint64_t a0, a1;
 745         int wait = 1000;
 746         int err;
 747
 748         a0 = offset;
 749         a1 = size;
 750
 751         err = vnic_dev_cmd(vdev, CMD_DEV_SPEC, &a0, &a1, wait);
 752
 753         switch (size) {
 754         case 1:
 755                 *(uint8_t *)value = (uint8_t)a0;
 756                 break;
 757         case 2:
 758                 *(uint16_t *)value = (uint16_t)a0;
 759                 break;
 760         case 4:
 761                 *(uint32_t *)value = (uint32_t)a0;
 762                 break;
 763         case 8:
 764                 *(uint64_t *)value = a0;
 765                 break;
 766         default:
 767                 BUG();
 768                 break;
 769         }
 770
 771         return err;
 772 }
 773
 774 int vnic_dev_stats_clear(struct vnic_dev *vdev)
 775 {
 776         uint64_t a0 = 0, a1 = 0;
 777         int wait = 1000;
 778
 779         return vnic_dev_cmd(vdev, CMD_STATS_CLEAR, &a0, &a1, wait);
 780 }
 781
 782 int vnic_dev_stats_dump(struct vnic_dev *vdev, struct vnic_stats **stats)
 783 {
 784         uint64_t a0, a1;
 785         int wait = 1000;
 786
 787         if (!vdev->stats)
 788                 return -ENOMEM;
 789
 790         *stats = vdev->stats;
 791         a0 = vdev->stats_pa;
 792         a1 = sizeof(struct vnic_stats);
 793
 794         return vnic_dev_cmd(vdev, CMD_STATS_DUMP, &a0, &a1, wait);
 795 }
 796
 797 int vnic_dev_close(struct vnic_dev *vdev)
 798 {
 799         uint64_t a0 = 0, a1 = 0;
 800         int wait = 1000;
 801
 802         return vnic_dev_cmd(vdev, CMD_CLOSE, &a0, &a1, wait);
 803 }
 804
 805 int vnic_dev_enable_wait(struct vnic_dev *vdev)
 806 {
 807         uint64_t a0 = 0, a1 = 0;
 808         int wait = 1000;
 809
 810         if (vnic_dev_capable(vdev, CMD_ENABLE_WAIT))
 811                 return vnic_dev_cmd(vdev, CMD_ENABLE_WAIT, &a0, &a1, wait);
 812         else
 813                 return vnic_dev_cmd(vdev, CMD_ENABLE, &a0, &a1, wait);
 814 }
 815
 816 int vnic_dev_disable(struct vnic_dev *vdev)
 817 {
 818         uint64_t a0 = 0, a1 = 0;
 819         int wait = 1000;
 820
 821         return vnic_dev_cmd(vdev, CMD_DISABLE, &a0, &a1, wait);
 822 }
 823
 824 int vnic_dev_open(struct vnic_dev *vdev, int arg)
 825 {
 826         uint64_t a0 = (uint32_t)arg, a1 = 0;
 827         int wait = 1000;
 828
 829         return vnic_dev_cmd(vdev, CMD_OPEN, &a0, &a1, wait);
 830 }
 831
 832 int vnic_dev_open_done(struct vnic_dev *vdev, int *done)
 833 {
 834         uint64_t a0 = 0, a1 = 0;
 835         int wait = 1000;
 836         int err;
 837
 838         *done = 0;
 839
 840         err = vnic_dev_cmd(vdev, CMD_OPEN_STATUS, &a0, &a1, wait);
 841         if (err)
 842                 return err;
 843
 844         *done = (a0 == 0);
 845
 846         return 0;
 847 }
 848
 849 int vnic_dev_get_mac_addr(struct vnic_dev *vdev, uint8_t *mac_addr)
 850 {
 851         uint64_t a0 = 0, a1 = 0;
 852         int wait = 1000;
 853         int err, i;
 854
 855         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
 856                 mac_addr[i] = 0;
 857
 858         err = vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
 859         if (err)
 860                 return err;
 861
 862         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
 863                 mac_addr[i] = ((uint8_t *)&a0)[i];
 864
 865         return 0;
 866 }
 867
 868 int vnic_dev_packet_filter(struct vnic_dev *vdev, int directed, int multicast,
 869         int broadcast, int promisc, int allmulti)
 870 {
 871         uint64_t a0, a1 = 0;
 872         int wait = 1000;
 873         int err;
 874
 875         a0 = (directed ? CMD_PFILTER_DIRECTED : 0) |
 876              (multicast ? CMD_PFILTER_MULTICAST : 0) |
 877              (broadcast ? CMD_PFILTER_BROADCAST : 0) |
 878              (promisc ? CMD_PFILTER_PROMISCUOUS : 0) |
 879              (allmulti ? CMD_PFILTER_ALL_MULTICAST : 0);
 880
 881         err = vnic_dev_cmd(vdev, CMD_PACKET_FILTER, &a0, &a1, wait);
 882         if (err)
 883                 pr_err("Can't set packet filter\n");
 884
 885         return err;
 886 }
 887
 888 int vnic_dev_add_addr(struct vnic_dev *vdev, uint8_t *addr)
 889 {
 890         uint64_t a0 = 0, a1 = 0;
 891         int wait = 1000;
 892         int err;
 893         int i;
 894
 895         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
 896                 ((uint8_t *)&a0)[i] = addr[i];
 897
 898         err = vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
 899         if (err)
 900                 pr_err("Can't add addr [" RTE_ETHER_ADDR_PRT_FMT "], %d\n",
 901                         addr[0], addr[1], addr[2], addr[3], addr[4], addr[5],
 902                         err);
 903
 904         return err;
 905 }
 906
 907 int vnic_dev_del_addr(struct vnic_dev *vdev, uint8_t *addr)
 908 {
 909         uint64_t a0 = 0, a1 = 0;
 910         int wait = 1000;
 911         int err;
 912         int i;
 913
 914         for (i = 0; i < RTE_ETHER_ADDR_LEN; i++)
 915                 ((uint8_t *)&a0)[i] = addr[i];
 916
 917         err = vnic_dev_cmd(vdev, CMD_ADDR_DEL, &a0, &a1, wait);
 918         if (err)
 919                 pr_err("Can't del addr [" RTE_ETHER_ADDR_PRT_FMT "], %d\n",
 920                         addr[0], addr[1], addr[2], addr[3], addr[4], addr[5],
 921                         err);
 922
 923         return err;
 924 }
 925
 926 int vnic_dev_set_ig_vlan_rewrite_mode(struct vnic_dev *vdev,
 927         uint8_t ig_vlan_rewrite_mode)
 928 {
 929         uint64_t a0 = ig_vlan_rewrite_mode, a1 = 0;
 930         int wait = 1000;
 931
 932         if (vnic_dev_capable(vdev, CMD_IG_VLAN_REWRITE_MODE))
 933                 return vnic_dev_cmd(vdev, CMD_IG_VLAN_REWRITE_MODE,
 934                                 &a0, &a1, wait);
 935         else
 936                 return 0;
 937 }
 938
 939 void vnic_dev_set_reset_flag(struct vnic_dev *vdev, int state)
 940 {
 941         vdev->in_reset = state;
 942 }
 943
 944 static inline int vnic_dev_in_reset(struct vnic_dev *vdev)
 945 {
 946         return vdev->in_reset;
 947 }
 948
 949 int vnic_dev_notify_setcmd(struct vnic_dev *vdev,
 950         void *notify_addr, dma_addr_t notify_pa, uint16_t intr)
 951 {
 952         uint64_t a0, a1;
 953         int wait = 1000;
 954         int r;
 955
 956         memset(notify_addr, 0, sizeof(struct vnic_devcmd_notify));
 957         if (!vnic_dev_in_reset(vdev)) {
 958                 vdev->notify = notify_addr;
 959                 vdev->notify_pa = notify_pa;
 960         }
 961
 962         a0 = (uint64_t)notify_pa;
 963         a1 = ((uint64_t)intr << 32) & 0x0000ffff00000000ULL;
 964         a1 += sizeof(struct vnic_devcmd_notify);
 965
 966         r = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
 967         if (!vnic_dev_in_reset(vdev))
 968                 vdev->notify_sz = (r == 0) ? (uint32_t)a1 : 0;
 969
 970         return r;
 971 }
 972
 973 int vnic_dev_notify_set(struct vnic_dev *vdev, uint16_t intr)
 974 {
 975         void *notify_addr = NULL;
 976         dma_addr_t notify_pa = 0;
 977         char name[RTE_MEMZONE_NAMESIZE];
 978         static uint32_t instance;
 979
 980         if (vdev->notify || vdev->notify_pa) {
 981                 return vnic_dev_notify_setcmd(vdev, vdev->notify,
 982                                               vdev->notify_pa, intr);
 983         }
 984         if (!vnic_dev_in_reset(vdev)) {
 985                 snprintf((char *)name, sizeof(name),
 986                         "vnic_notify-%u", instance++);
 987                 notify_addr = vdev->alloc_consistent(vdev->priv,
 988                         sizeof(struct vnic_devcmd_notify),
 989                         &notify_pa, (uint8_t *)name);
 990                 if (!notify_addr)
 991                         return -ENOMEM;
 992         }
 993
 994         return vnic_dev_notify_setcmd(vdev, notify_addr, notify_pa, intr);
 995 }
 996
 997 int vnic_dev_notify_unsetcmd(struct vnic_dev *vdev)
 998 {
 999         uint64_t a0, a1;
1000         int wait = 1000;
1001         int err;
1002
1003         a0 = 0;  /* paddr = 0 to unset notify buffer */
1004         a1 = 0x0000ffff00000000ULL; /* intr num = -1 to unreg for intr */
1005         a1 += sizeof(struct vnic_devcmd_notify);
1006
1007         err = vnic_dev_cmd(vdev, CMD_NOTIFY, &a0, &a1, wait);
1008         if (!vnic_dev_in_reset(vdev)) {
1009                 vdev->notify = NULL;
1010                 vdev->notify_pa = 0;
1011                 vdev->notify_sz = 0;
1012         }
1013
1014         return err;
1015 }
1016
1017 int vnic_dev_notify_unset(struct vnic_dev *vdev)
1018 {
1019         if (vdev->notify && !vnic_dev_in_reset(vdev)) {
1020                 vdev->free_consistent(vdev->priv,
1021                         sizeof(struct vnic_devcmd_notify),
1022                         vdev->notify,
1023                         vdev->notify_pa);
1024         }
1025
1026         return vnic_dev_notify_unsetcmd(vdev);
1027 }
1028
1029 static int vnic_dev_notify_ready(struct vnic_dev *vdev)
1030 {
1031         uint32_t *words;
1032         unsigned int nwords = vdev->notify_sz / 4;
1033         unsigned int i;
1034         uint32_t csum;
1035
1036         if (!vdev->notify || !vdev->notify_sz)
1037                 return 0;
1038
1039         do {
1040                 csum = 0;
1041                 rte_memcpy(&vdev->notify_copy, vdev->notify, vdev->notify_sz);
1042                 words = (uint32_t *)&vdev->notify_copy;
1043                 for (i = 1; i < nwords; i++)
1044                         csum += words[i];
1045         } while (csum != words[0]);
1046
1047         return 1;
1048 }
1049
1050 int vnic_dev_init(struct vnic_dev *vdev, int arg)
1051 {
1052         uint64_t a0 = (uint32_t)arg, a1 = 0;
1053         int wait = 1000;
1054         int r = 0;
1055
1056         if (vnic_dev_capable(vdev, CMD_INIT))
1057                 r = vnic_dev_cmd(vdev, CMD_INIT, &a0, &a1, wait);
1058         else {
1059                 vnic_dev_cmd(vdev, CMD_INIT_v1, &a0, &a1, wait);
1060                 if (a0 & CMD_INITF_DEFAULT_MAC) {
1061                         /* Emulate these for old CMD_INIT_v1 which
1062                          * didn't pass a0 so no CMD_INITF_*.
1063                          */
1064                         vnic_dev_cmd(vdev, CMD_GET_MAC_ADDR, &a0, &a1, wait);
1065                         vnic_dev_cmd(vdev, CMD_ADDR_ADD, &a0, &a1, wait);
1066                 }
1067         }
1068         return r;
1069 }
1070
1071 void vnic_dev_intr_coal_timer_info_default(struct vnic_dev *vdev)
1072 {
1073         /* Default: hardware intr coal timer is in units of 1.5 usecs */
1074         vdev->intr_coal_timer_info.mul = 2;
1075         vdev->intr_coal_timer_info.div = 3;
1076         vdev->intr_coal_timer_info.max_usec =
1077                 vnic_dev_intr_coal_timer_hw_to_usec(vdev, 0xffff);
1078 }
1079
1080 int vnic_dev_link_status(struct vnic_dev *vdev)
1081 {
1082         if (!vnic_dev_notify_ready(vdev))
1083                 return 0;
1084
1085         return vdev->notify_copy.link_state;
1086 }
1087
1088 uint32_t vnic_dev_port_speed(struct vnic_dev *vdev)
1089 {
1090         if (!vnic_dev_notify_ready(vdev))
1091                 return 0;
1092
1093         return vdev->notify_copy.port_speed;
1094 }
1095
1096 uint32_t vnic_dev_mtu(struct vnic_dev *vdev)
1097 {
1098         if (!vnic_dev_notify_ready(vdev))
1099                 return 0;
1100
1101         return vdev->notify_copy.mtu;
1102 }
1103
1104 uint32_t vnic_dev_uif(struct vnic_dev *vdev)
1105 {
1106         if (!vnic_dev_notify_ready(vdev))
1107                 return 0;
1108
1109         return vdev->notify_copy.uif;
1110 }
1111
1112 uint32_t vnic_dev_intr_coal_timer_usec_to_hw(struct vnic_dev *vdev,
1113                                              uint32_t usec)
1114 {
1115         return (usec * vdev->intr_coal_timer_info.mul) /
1116                 vdev->intr_coal_timer_info.div;
1117 }
1118
1119 uint32_t vnic_dev_intr_coal_timer_hw_to_usec(struct vnic_dev *vdev,
1120                                              uint32_t hw_cycles)
1121 {
1122         return (hw_cycles * vdev->intr_coal_timer_info.div) /
1123                 vdev->intr_coal_timer_info.mul;
1124 }
1125
1126 uint32_t vnic_dev_get_intr_coal_timer_max(struct vnic_dev *vdev)
1127 {
1128         return vdev->intr_coal_timer_info.max_usec;
1129 }
1130
1131 int vnic_dev_alloc_stats_mem(struct vnic_dev *vdev)
1132 {
1133         char name[RTE_MEMZONE_NAMESIZE];
1134         static uint32_t instance;
1135
1136         snprintf((char *)name, sizeof(name), "vnic_stats-%u", instance++);
1137         vdev->stats = vdev->alloc_consistent(vdev->priv,
1138                                              sizeof(struct vnic_stats),
1139                                              &vdev->stats_pa, (uint8_t *)name);
1140         return vdev->stats == NULL ? -ENOMEM : 0;
1141 }
1142
1143 void vnic_dev_unregister(struct vnic_dev *vdev)
1144 {
1145         if (vdev) {
1146                 if (vdev->notify)
1147                         vdev->free_consistent(vdev->priv,
1148                                 sizeof(struct vnic_devcmd_notify),
1149                                 vdev->notify,
1150                                 vdev->notify_pa);
1151                 if (vdev->stats)
1152                         vdev->free_consistent(vdev->priv,
1153                                 sizeof(struct vnic_stats),
1154                                 vdev->stats, vdev->stats_pa);
1155                 if (vdev->flowman_info)
1156                         vdev->free_consistent(vdev->priv,
1157                                 sizeof(struct fm_info),
1158                                 vdev->flowman_info, vdev->flowman_info_pa);
1159                 if (vdev->fw_info)
1160                         vdev->free_consistent(vdev->priv,
1161                                 sizeof(struct vnic_devcmd_fw_info),
1162                                 vdev->fw_info, vdev->fw_info_pa);
1163                 rte_free(vdev);
1164         }
1165 }
1166
1167 struct vnic_dev *vnic_dev_register(struct vnic_dev *vdev,
1168         void *priv, struct rte_pci_device *pdev, struct vnic_dev_bar *bar,
1169         unsigned int num_bars)
1170 {
1171         if (!vdev) {
1172                 char name[RTE_MEMZONE_NAMESIZE];
1173                 snprintf((char *)name, sizeof(name), "%s-vnic",
1174                           pdev->device.name);
1175                 vdev = (struct vnic_dev *)rte_zmalloc_socket(name,
1176                                         sizeof(struct vnic_dev),
1177                                         RTE_CACHE_LINE_SIZE,
1178                                         pdev->device.numa_node);
1179                 if (!vdev)
1180                         return NULL;
1181         }
1182
1183         vdev->priv = priv;
1184         vdev->pdev = pdev;
1185
1186         if (vnic_dev_discover_res(vdev, bar, num_bars))
1187                 goto err_out;
1188
1189         vdev->devcmd = vnic_dev_get_res(vdev, RES_TYPE_DEVCMD, 0);
1190         if (!vdev->devcmd)
1191                 goto err_out;
1192
1193         return vdev;
1194
1195 err_out:
1196         vnic_dev_unregister(vdev);
1197         return NULL;
1198 }
1199
1200 struct vnic_dev *vnic_vf_rep_register(void *priv, struct vnic_dev *pf_vdev,
1201         int vf_id)
1202 {
1203         struct vnic_dev *vdev;
1204
1205         vdev = (struct vnic_dev *)rte_zmalloc("enic-vf-rep-vdev",
1206                                 sizeof(struct vnic_dev), RTE_CACHE_LINE_SIZE);
1207         if (!vdev)
1208                 return NULL;
1209         vdev->priv = priv;
1210         vdev->pf_vdev = pf_vdev;
1211         vdev->vf_id = vf_id;
1212         vdev->alloc_consistent = pf_vdev->alloc_consistent;
1213         vdev->free_consistent = pf_vdev->free_consistent;
1214         return vdev;
1215 }
1216
1217 /*
1218  *  vnic_dev_classifier: Add/Delete classifier entries
1219  *  @vdev: vdev of the device
1220  *  @cmd: CLSF_ADD for Add filter
1221  *        CLSF_DEL for Delete filter
1222  *  @entry: In case of ADD filter, the caller passes the RQ number in this
1223  *          variable.
1224  *          This function stores the filter_id returned by the
1225  *          firmware in the same variable before return;
1226  *
1227  *          In case of DEL filter, the caller passes the RQ number. Return
1228  *          value is irrelevant.
1229  * @data: filter data
1230  * @action: action data
1231  */
1232 int vnic_dev_classifier(struct vnic_dev *vdev, uint8_t cmd, uint16_t *entry,
1233         struct filter_v2 *data, struct filter_action_v2 *action_v2)
1234 {
1235         uint64_t a0 = 0, a1 = 0;
1236         int wait = 1000;
1237         dma_addr_t tlv_pa;
1238         int ret = -EINVAL;
1239         struct filter_tlv *tlv, *tlv_va;
1240         uint64_t tlv_size;
1241         uint32_t filter_size, action_size;
1242         static unsigned int unique_id;
1243         char z_name[RTE_MEMZONE_NAMESIZE];
1244         enum vnic_devcmd_cmd dev_cmd;
1245
1246         if (cmd == CLSF_ADD) {
1247                 dev_cmd = (data->type >= FILTER_DPDK_1) ?
1248                           CMD_ADD_ADV_FILTER : CMD_ADD_FILTER;
1249
1250                 filter_size = vnic_filter_size(data);
1251                 action_size = vnic_action_size(action_v2);
1252
1253                 tlv_size = filter_size + action_size +
1254                     2*sizeof(struct filter_tlv);
1255                 snprintf((char *)z_name, sizeof(z_name),
1256                         "vnic_clsf_%u", unique_id++);
1257                 tlv_va = vdev->alloc_consistent(vdev->priv,
1258                         tlv_size, &tlv_pa, (uint8_t *)z_name);
1259                 if (!tlv_va)
1260                         return -ENOMEM;
1261                 tlv = tlv_va;
1262                 a0 = tlv_pa;
1263                 a1 = tlv_size;
1264                 memset(tlv, 0, tlv_size);
1265                 tlv->type = CLSF_TLV_FILTER;
1266                 tlv->length = filter_size;
1267                 memcpy(&tlv->val, (void *)data, filter_size);
1268
1269                 tlv = (struct filter_tlv *)((char *)tlv +
1270                                          sizeof(struct filter_tlv) +
1271                                          filter_size);
1272
1273                 tlv->type = CLSF_TLV_ACTION;
1274                 tlv->length = action_size;
1275                 memcpy(&tlv->val, (void *)action_v2, action_size);
1276                 ret = vnic_dev_cmd(vdev, dev_cmd, &a0, &a1, wait);
1277                 *entry = (uint16_t)a0;
1278                 vdev->free_consistent(vdev->priv, tlv_size, tlv_va, tlv_pa);
1279         } else if (cmd == CLSF_DEL) {
1280                 a0 = *entry;
1281                 ret = vnic_dev_cmd(vdev, CMD_DEL_FILTER, &a0, &a1, wait);
1282         }
1283
1284         return ret;
1285 }
1286
1287 int vnic_dev_overlay_offload_ctrl(struct vnic_dev *vdev, uint8_t overlay,
1288                                   uint8_t config)
1289 {
1290         uint64_t a0 = overlay;
1291         uint64_t a1 = config;
1292         int wait = 1000;
1293
1294         return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CTRL, &a0, &a1, wait);
1295 }
1296
1297 int vnic_dev_overlay_offload_cfg(struct vnic_dev *vdev, uint8_t overlay,
1298                                  uint16_t vxlan_udp_port_number)
1299 {
1300         uint64_t a1 = vxlan_udp_port_number;
1301         uint64_t a0 = overlay;
1302         int wait = 1000;
1303
1304         return vnic_dev_cmd(vdev, CMD_OVERLAY_OFFLOAD_CFG, &a0, &a1, wait);
1305 }
1306
1307 int vnic_dev_capable_vxlan(struct vnic_dev *vdev)
1308 {
1309         uint64_t a0 = VIC_FEATURE_VXLAN;
1310         uint64_t a1 = 0;
1311         int wait = 1000;
1312         int ret;
1313
1314         ret = vnic_dev_cmd(vdev, CMD_GET_SUPP_FEATURE_VER, &a0, &a1, wait);
1315         /* 1 if the NIC can do VXLAN for both IPv4 and IPv6 with multiple WQs */
1316         return ret == 0 &&
1317                 (a1 & (FEATURE_VXLAN_IPV6 | FEATURE_VXLAN_MULTI_WQ)) ==
1318                 (FEATURE_VXLAN_IPV6 | FEATURE_VXLAN_MULTI_WQ);
1319 }
1320
1321 int vnic_dev_capable_geneve(struct vnic_dev *vdev)
1322 {
1323         uint64_t a0 = VIC_FEATURE_GENEVE;
1324         uint64_t a1 = 0;
1325         int wait = 1000;
1326         int ret;
1327
1328         ret = vnic_dev_cmd(vdev, CMD_GET_SUPP_FEATURE_VER, &a0, &a1, wait);
1329         return ret == 0 && !!(a1 & FEATURE_GENEVE_OPTIONS);
1330 }
1331
1332 uint64_t vnic_dev_capable_cq_entry_size(struct vnic_dev *vdev)
1333 {
1334         uint64_t a0 = CMD_CQ_ENTRY_SIZE_SET;
1335         uint64_t a1 = 0;
1336         int wait = 1000;
1337         int ret;
1338
1339         ret = vnic_dev_cmd(vdev, CMD_CAPABILITY, &a0, &a1, wait);
1340         /* All models support 16B CQ entry by default */
1341         if (!(ret == 0 && a0 == 0))
1342                 a1 = VNIC_RQ_CQ_ENTRY_SIZE_16_CAPABLE;
1343         return a1;
1344 }
1345
1346 int vnic_dev_set_cq_entry_size(struct vnic_dev *vdev, uint32_t rq_idx,
1347                                uint32_t size_flag)
1348 {
1349         uint64_t a0 = rq_idx;
1350         uint64_t a1 = size_flag;
1351         int wait = 1000;
1352
1353         return vnic_dev_cmd(vdev, CMD_CQ_ENTRY_SIZE_SET, &a0, &a1, wait);
1354 }