drivers/net/octeontx2/otx2_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2019 Marvell International Ltd.
   3  */
   4
   5 #include <inttypes.h>
   6 #include <math.h>
   7
   8 #include <rte_ethdev_pci.h>
   9 #include <rte_io.h>
  10 #include <rte_malloc.h>
  11 #include <rte_mbuf.h>
  12 #include <rte_mbuf_pool_ops.h>
  13 #include <rte_mempool.h>
  14
  15 #include "otx2_ethdev.h"
  16
  17 static inline uint64_t
  18 nix_get_rx_offload_capa(struct otx2_eth_dev *dev)
  19 {
  20         uint64_t capa = NIX_RX_OFFLOAD_CAPA;
  21
  22         if (otx2_dev_is_vf(dev))
  23                 capa &= ~DEV_RX_OFFLOAD_TIMESTAMP;
  24
  25         return capa;
  26 }
  27
  28 static inline uint64_t
  29 nix_get_tx_offload_capa(struct otx2_eth_dev *dev)
  30 {
  31         RTE_SET_USED(dev);
  32
  33         return NIX_TX_OFFLOAD_CAPA;
  34 }
  35
  36 static const struct otx2_dev_ops otx2_dev_ops = {
  37         .link_status_update = otx2_eth_dev_link_status_update,
  38         .ptp_info_update = otx2_eth_dev_ptp_info_update
  39 };
  40
  41 static int
  42 nix_lf_alloc(struct otx2_eth_dev *dev, uint32_t nb_rxq, uint32_t nb_txq)
  43 {
  44         struct otx2_mbox *mbox = dev->mbox;
  45         struct nix_lf_alloc_req *req;
  46         struct nix_lf_alloc_rsp *rsp;
  47         int rc;
  48
  49         req = otx2_mbox_alloc_msg_nix_lf_alloc(mbox);
  50         req->rq_cnt = nb_rxq;
  51         req->sq_cnt = nb_txq;
  52         req->cq_cnt = nb_rxq;
  53         /* XQE_SZ should be in Sync with NIX_CQ_ENTRY_SZ */
  54         RTE_BUILD_BUG_ON(NIX_CQ_ENTRY_SZ != 128);
  55         req->xqe_sz = NIX_XQESZ_W16;
  56         req->rss_sz = dev->rss_info.rss_size;
  57         req->rss_grps = NIX_RSS_GRPS;
  58         req->npa_func = otx2_npa_pf_func_get();
  59         req->sso_func = otx2_sso_pf_func_get();
  60         req->rx_cfg = BIT_ULL(35 /* DIS_APAD */);
  61         if (dev->rx_offloads & (DEV_RX_OFFLOAD_TCP_CKSUM |
  62                          DEV_RX_OFFLOAD_UDP_CKSUM)) {
  63                 req->rx_cfg |= BIT_ULL(37 /* CSUM_OL4 */);
  64                 req->rx_cfg |= BIT_ULL(36 /* CSUM_IL4 */);
  65         }
  66
  67         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
  68         if (rc)
  69                 return rc;
  70
  71         dev->sqb_size = rsp->sqb_size;
  72         dev->tx_chan_base = rsp->tx_chan_base;
  73         dev->rx_chan_base = rsp->rx_chan_base;
  74         dev->rx_chan_cnt = rsp->rx_chan_cnt;
  75         dev->tx_chan_cnt = rsp->tx_chan_cnt;
  76         dev->lso_tsov4_idx = rsp->lso_tsov4_idx;
  77         dev->lso_tsov6_idx = rsp->lso_tsov6_idx;
  78         dev->lf_tx_stats = rsp->lf_tx_stats;
  79         dev->lf_rx_stats = rsp->lf_rx_stats;
  80         dev->cints = rsp->cints;
  81         dev->qints = rsp->qints;
  82         dev->npc_flow.channel = dev->rx_chan_base;
  83
  84         return 0;
  85 }
  86
  87 static int
  88 nix_lf_free(struct otx2_eth_dev *dev)
  89 {
  90         struct otx2_mbox *mbox = dev->mbox;
  91         struct nix_lf_free_req *req;
  92         struct ndc_sync_op *ndc_req;
  93         int rc;
  94
  95         /* Sync NDC-NIX for LF */
  96         ndc_req = otx2_mbox_alloc_msg_ndc_sync_op(mbox);
  97         ndc_req->nix_lf_tx_sync = 1;
  98         ndc_req->nix_lf_rx_sync = 1;
  99         rc = otx2_mbox_process(mbox);
 100         if (rc)
 101                 otx2_err("Error on NDC-NIX-[TX, RX] LF sync, rc %d", rc);
 102
 103         req = otx2_mbox_alloc_msg_nix_lf_free(mbox);
 104         /* Let AF driver free all this nix lf's
 105          * NPC entries allocated using NPC MBOX.
 106          */
 107         req->flags = 0;
 108
 109         return otx2_mbox_process(mbox);
 110 }
 111
 112 int
 113 otx2_cgx_rxtx_start(struct otx2_eth_dev *dev)
 114 {
 115         struct otx2_mbox *mbox = dev->mbox;
 116
 117         if (otx2_dev_is_vf(dev))
 118                 return 0;
 119
 120         otx2_mbox_alloc_msg_cgx_start_rxtx(mbox);
 121
 122         return otx2_mbox_process(mbox);
 123 }
 124
 125 int
 126 otx2_cgx_rxtx_stop(struct otx2_eth_dev *dev)
 127 {
 128         struct otx2_mbox *mbox = dev->mbox;
 129
 130         if (otx2_dev_is_vf(dev))
 131                 return 0;
 132
 133         otx2_mbox_alloc_msg_cgx_stop_rxtx(mbox);
 134
 135         return otx2_mbox_process(mbox);
 136 }
 137
 138 static inline void
 139 nix_rx_queue_reset(struct otx2_eth_rxq *rxq)
 140 {
 141         rxq->head = 0;
 142         rxq->available = 0;
 143 }
 144
 145 static inline uint32_t
 146 nix_qsize_to_val(enum nix_q_size_e qsize)
 147 {
 148         return (16UL << (qsize * 2));
 149 }
 150
 151 static inline enum nix_q_size_e
 152 nix_qsize_clampup_get(struct otx2_eth_dev *dev, uint32_t val)
 153 {
 154         int i;
 155
 156         if (otx2_ethdev_fixup_is_min_4k_q(dev))
 157                 i = nix_q_size_4K;
 158         else
 159                 i = nix_q_size_16;
 160
 161         for (; i < nix_q_size_max; i++)
 162                 if (val <= nix_qsize_to_val(i))
 163                         break;
 164
 165         if (i >= nix_q_size_max)
 166                 i = nix_q_size_max - 1;
 167
 168         return i;
 169 }
 170
 171 static int
 172 nix_cq_rq_init(struct rte_eth_dev *eth_dev, struct otx2_eth_dev *dev,
 173                uint16_t qid, struct otx2_eth_rxq *rxq, struct rte_mempool *mp)
 174 {
 175         struct otx2_mbox *mbox = dev->mbox;
 176         const struct rte_memzone *rz;
 177         uint32_t ring_size, cq_size;
 178         struct nix_aq_enq_req *aq;
 179         uint16_t first_skip;
 180         int rc;
 181
 182         cq_size = rxq->qlen;
 183         ring_size = cq_size * NIX_CQ_ENTRY_SZ;
 184         rz = rte_eth_dma_zone_reserve(eth_dev, "cq", qid, ring_size,
 185                                       NIX_CQ_ALIGN, dev->node);
 186         if (rz == NULL) {
 187                 otx2_err("Failed to allocate mem for cq hw ring");
 188                 rc = -ENOMEM;
 189                 goto fail;
 190         }
 191         memset(rz->addr, 0, rz->len);
 192         rxq->desc = (uintptr_t)rz->addr;
 193         rxq->qmask = cq_size - 1;
 194
 195         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 196         aq->qidx = qid;
 197         aq->ctype = NIX_AQ_CTYPE_CQ;
 198         aq->op = NIX_AQ_INSTOP_INIT;
 199
 200         aq->cq.ena = 1;
 201         aq->cq.caching = 1;
 202         aq->cq.qsize = rxq->qsize;
 203         aq->cq.base = rz->iova;
 204         aq->cq.avg_level = 0xff;
 205         aq->cq.cq_err_int_ena = BIT(NIX_CQERRINT_CQE_FAULT);
 206         aq->cq.cq_err_int_ena |= BIT(NIX_CQERRINT_DOOR_ERR);
 207
 208         /* TX pause frames enable flowctrl on RX side */
 209         if (dev->fc_info.tx_pause) {
 210                 /* Single bpid is allocated for all rx channels for now */
 211                 aq->cq.bpid = dev->fc_info.bpid[0];
 212                 aq->cq.bp = NIX_CQ_BP_LEVEL;
 213                 aq->cq.bp_ena = 1;
 214         }
 215
 216         /* Many to one reduction */
 217         aq->cq.qint_idx = qid % dev->qints;
 218
 219         if (otx2_ethdev_fixup_is_limit_cq_full(dev)) {
 220                 uint16_t min_rx_drop;
 221                 const float rx_cq_skid = 1024 * 256;
 222
 223                 min_rx_drop = ceil(rx_cq_skid / (float)cq_size);
 224                 aq->cq.drop = min_rx_drop;
 225                 aq->cq.drop_ena = 1;
 226         }
 227
 228         rc = otx2_mbox_process(mbox);
 229         if (rc) {
 230                 otx2_err("Failed to init cq context");
 231                 goto fail;
 232         }
 233
 234         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 235         aq->qidx = qid;
 236         aq->ctype = NIX_AQ_CTYPE_RQ;
 237         aq->op = NIX_AQ_INSTOP_INIT;
 238
 239         aq->rq.sso_ena = 0;
 240         aq->rq.cq = qid; /* RQ to CQ 1:1 mapped */
 241         aq->rq.spb_ena = 0;
 242         aq->rq.lpb_aura = npa_lf_aura_handle_to_aura(mp->pool_id);
 243         first_skip = (sizeof(struct rte_mbuf));
 244         first_skip += RTE_PKTMBUF_HEADROOM;
 245         first_skip += rte_pktmbuf_priv_size(mp);
 246         rxq->data_off = first_skip;
 247
 248         first_skip /= 8; /* Expressed in number of dwords */
 249         aq->rq.first_skip = first_skip;
 250         aq->rq.later_skip = (sizeof(struct rte_mbuf) / 8);
 251         aq->rq.flow_tagw = 32; /* 32-bits */
 252         aq->rq.lpb_sizem1 = rte_pktmbuf_data_room_size(mp);
 253         aq->rq.lpb_sizem1 += rte_pktmbuf_priv_size(mp);
 254         aq->rq.lpb_sizem1 += sizeof(struct rte_mbuf);
 255         aq->rq.lpb_sizem1 /= 8;
 256         aq->rq.lpb_sizem1 -= 1; /* Expressed in size minus one */
 257         aq->rq.ena = 1;
 258         aq->rq.pb_caching = 0x2; /* First cache aligned block to LLC */
 259         aq->rq.xqe_imm_size = 0; /* No pkt data copy to CQE */
 260         aq->rq.rq_int_ena = 0;
 261         /* Many to one reduction */
 262         aq->rq.qint_idx = qid % dev->qints;
 263
 264         if (otx2_ethdev_fixup_is_limit_cq_full(dev))
 265                 aq->rq.xqe_drop_ena = 1;
 266
 267         rc = otx2_mbox_process(mbox);
 268         if (rc) {
 269                 otx2_err("Failed to init rq context");
 270                 goto fail;
 271         }
 272
 273         return 0;
 274 fail:
 275         return rc;
 276 }
 277
 278 static int
 279 nix_rq_enb_dis(struct rte_eth_dev *eth_dev,
 280                struct otx2_eth_rxq *rxq, const bool enb)
 281 {
 282         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 283         struct otx2_mbox *mbox = dev->mbox;
 284         struct nix_aq_enq_req *aq;
 285
 286         /* Pkts will be dropped silently if RQ is disabled */
 287         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 288         aq->qidx = rxq->rq;
 289         aq->ctype = NIX_AQ_CTYPE_RQ;
 290         aq->op = NIX_AQ_INSTOP_WRITE;
 291
 292         aq->rq.ena = enb;
 293         aq->rq_mask.ena = ~(aq->rq_mask.ena);
 294
 295         return otx2_mbox_process(mbox);
 296 }
 297
 298 static int
 299 nix_cq_rq_uninit(struct rte_eth_dev *eth_dev, struct otx2_eth_rxq *rxq)
 300 {
 301         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 302         struct otx2_mbox *mbox = dev->mbox;
 303         struct nix_aq_enq_req *aq;
 304         int rc;
 305
 306         /* RQ is already disabled */
 307         /* Disable CQ */
 308         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 309         aq->qidx = rxq->rq;
 310         aq->ctype = NIX_AQ_CTYPE_CQ;
 311         aq->op = NIX_AQ_INSTOP_WRITE;
 312
 313         aq->cq.ena = 0;
 314         aq->cq_mask.ena = ~(aq->cq_mask.ena);
 315
 316         rc = otx2_mbox_process(mbox);
 317         if (rc < 0) {
 318                 otx2_err("Failed to disable cq context");
 319                 return rc;
 320         }
 321
 322         return 0;
 323 }
 324
 325 static inline int
 326 nix_get_data_off(struct otx2_eth_dev *dev)
 327 {
 328         return otx2_ethdev_is_ptp_en(dev) ? NIX_TIMESYNC_RX_OFFSET : 0;
 329 }
 330
 331 uint64_t
 332 otx2_nix_rxq_mbuf_setup(struct otx2_eth_dev *dev, uint16_t port_id)
 333 {
 334         struct rte_mbuf mb_def;
 335         uint64_t *tmp;
 336
 337         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_off) % 8 != 0);
 338         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, refcnt) -
 339                                 offsetof(struct rte_mbuf, data_off) != 2);
 340         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, nb_segs) -
 341                                 offsetof(struct rte_mbuf, data_off) != 4);
 342         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, port) -
 343                                 offsetof(struct rte_mbuf, data_off) != 6);
 344         mb_def.nb_segs = 1;
 345         mb_def.data_off = RTE_PKTMBUF_HEADROOM + nix_get_data_off(dev);
 346         mb_def.port = port_id;
 347         rte_mbuf_refcnt_set(&mb_def, 1);
 348
 349         /* Prevent compiler reordering: rearm_data covers previous fields */
 350         rte_compiler_barrier();
 351         tmp = (uint64_t *)&mb_def.rearm_data;
 352
 353         return *tmp;
 354 }
 355
 356 static void
 357 otx2_nix_rx_queue_release(void *rx_queue)
 358 {
 359         struct otx2_eth_rxq *rxq = rx_queue;
 360
 361         if (!rxq)
 362                 return;
 363
 364         otx2_nix_dbg("Releasing rxq %u", rxq->rq);
 365         nix_cq_rq_uninit(rxq->eth_dev, rxq);
 366         rte_free(rx_queue);
 367 }
 368
 369 static int
 370 otx2_nix_rx_queue_setup(struct rte_eth_dev *eth_dev, uint16_t rq,
 371                         uint16_t nb_desc, unsigned int socket,
 372                         const struct rte_eth_rxconf *rx_conf,
 373                         struct rte_mempool *mp)
 374 {
 375         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 376         struct rte_mempool_ops *ops;
 377         struct otx2_eth_rxq *rxq;
 378         const char *platform_ops;
 379         enum nix_q_size_e qsize;
 380         uint64_t offloads;
 381         int rc;
 382
 383         rc = -EINVAL;
 384
 385         /* Compile time check to make sure all fast path elements in a CL */
 386         RTE_BUILD_BUG_ON(offsetof(struct otx2_eth_rxq, slow_path_start) >= 128);
 387
 388         /* Sanity checks */
 389         if (rx_conf->rx_deferred_start == 1) {
 390                 otx2_err("Deferred Rx start is not supported");
 391                 goto fail;
 392         }
 393
 394         platform_ops = rte_mbuf_platform_mempool_ops();
 395         /* This driver needs octeontx2_npa mempool ops to work */
 396         ops = rte_mempool_get_ops(mp->ops_index);
 397         if (strncmp(ops->name, platform_ops, RTE_MEMPOOL_OPS_NAMESIZE)) {
 398                 otx2_err("mempool ops should be of octeontx2_npa type");
 399                 goto fail;
 400         }
 401
 402         if (mp->pool_id == 0) {
 403                 otx2_err("Invalid pool_id");
 404                 goto fail;
 405         }
 406
 407         /* Free memory prior to re-allocation if needed */
 408         if (eth_dev->data->rx_queues[rq] != NULL) {
 409                 otx2_nix_dbg("Freeing memory prior to re-allocation %d", rq);
 410                 otx2_nix_rx_queue_release(eth_dev->data->rx_queues[rq]);
 411                 eth_dev->data->rx_queues[rq] = NULL;
 412         }
 413
 414         offloads = rx_conf->offloads | eth_dev->data->dev_conf.rxmode.offloads;
 415         dev->rx_offloads |= offloads;
 416
 417         /* Find the CQ queue size */
 418         qsize = nix_qsize_clampup_get(dev, nb_desc);
 419         /* Allocate rxq memory */
 420         rxq = rte_zmalloc_socket("otx2 rxq", sizeof(*rxq), OTX2_ALIGN, socket);
 421         if (rxq == NULL) {
 422                 otx2_err("Failed to allocate rq=%d", rq);
 423                 rc = -ENOMEM;
 424                 goto fail;
 425         }
 426
 427         rxq->eth_dev = eth_dev;
 428         rxq->rq = rq;
 429         rxq->cq_door = dev->base + NIX_LF_CQ_OP_DOOR;
 430         rxq->cq_status = (int64_t *)(dev->base + NIX_LF_CQ_OP_STATUS);
 431         rxq->wdata = (uint64_t)rq << 32;
 432         rxq->aura = npa_lf_aura_handle_to_aura(mp->pool_id);
 433         rxq->mbuf_initializer = otx2_nix_rxq_mbuf_setup(dev,
 434                                                         eth_dev->data->port_id);
 435         rxq->offloads = offloads;
 436         rxq->pool = mp;
 437         rxq->qlen = nix_qsize_to_val(qsize);
 438         rxq->qsize = qsize;
 439         rxq->lookup_mem = otx2_nix_fastpath_lookup_mem_get();
 440         rxq->tstamp = &dev->tstamp;
 441
 442         /* Alloc completion queue */
 443         rc = nix_cq_rq_init(eth_dev, dev, rq, rxq, mp);
 444         if (rc) {
 445                 otx2_err("Failed to allocate rxq=%u", rq);
 446                 goto free_rxq;
 447         }
 448
 449         rxq->qconf.socket_id = socket;
 450         rxq->qconf.nb_desc = nb_desc;
 451         rxq->qconf.mempool = mp;
 452         memcpy(&rxq->qconf.conf.rx, rx_conf, sizeof(struct rte_eth_rxconf));
 453
 454         nix_rx_queue_reset(rxq);
 455         otx2_nix_dbg("rq=%d pool=%s qsize=%d nb_desc=%d->%d",
 456                      rq, mp->name, qsize, nb_desc, rxq->qlen);
 457
 458         eth_dev->data->rx_queues[rq] = rxq;
 459         eth_dev->data->rx_queue_state[rq] = RTE_ETH_QUEUE_STATE_STOPPED;
 460         return 0;
 461
 462 free_rxq:
 463         otx2_nix_rx_queue_release(rxq);
 464 fail:
 465         return rc;
 466 }
 467
 468 static inline uint8_t
 469 nix_sq_max_sqe_sz(struct otx2_eth_txq *txq)
 470 {
 471         /*
 472          * Maximum three segments can be supported with W8, Choose
 473          * NIX_MAXSQESZ_W16 for multi segment offload.
 474          */
 475         if (txq->offloads & DEV_TX_OFFLOAD_MULTI_SEGS)
 476                 return NIX_MAXSQESZ_W16;
 477         else
 478                 return NIX_MAXSQESZ_W8;
 479 }
 480
 481 static int
 482 nix_sq_init(struct otx2_eth_txq *txq)
 483 {
 484         struct otx2_eth_dev *dev = txq->dev;
 485         struct otx2_mbox *mbox = dev->mbox;
 486         struct nix_aq_enq_req *sq;
 487         uint32_t rr_quantum;
 488         uint16_t smq;
 489         int rc;
 490
 491         if (txq->sqb_pool->pool_id == 0)
 492                 return -EINVAL;
 493
 494         rc = otx2_nix_tm_get_leaf_data(dev, txq->sq, &rr_quantum, &smq);
 495         if (rc) {
 496                 otx2_err("Failed to get sq->smq(leaf node), rc=%d", rc);
 497                 return rc;
 498         }
 499
 500         sq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 501         sq->qidx = txq->sq;
 502         sq->ctype = NIX_AQ_CTYPE_SQ;
 503         sq->op = NIX_AQ_INSTOP_INIT;
 504         sq->sq.max_sqe_size = nix_sq_max_sqe_sz(txq);
 505
 506         sq->sq.smq = smq;
 507         sq->sq.smq_rr_quantum = rr_quantum;
 508         sq->sq.default_chan = dev->tx_chan_base;
 509         sq->sq.sqe_stype = NIX_STYPE_STF;
 510         sq->sq.ena = 1;
 511         if (sq->sq.max_sqe_size == NIX_MAXSQESZ_W8)
 512                 sq->sq.sqe_stype = NIX_STYPE_STP;
 513         sq->sq.sqb_aura =
 514                 npa_lf_aura_handle_to_aura(txq->sqb_pool->pool_id);
 515         sq->sq.sq_int_ena = BIT(NIX_SQINT_LMT_ERR);
 516         sq->sq.sq_int_ena |= BIT(NIX_SQINT_SQB_ALLOC_FAIL);
 517         sq->sq.sq_int_ena |= BIT(NIX_SQINT_SEND_ERR);
 518         sq->sq.sq_int_ena |= BIT(NIX_SQINT_MNQ_ERR);
 519
 520         /* Many to one reduction */
 521         sq->sq.qint_idx = txq->sq % dev->qints;
 522
 523         return otx2_mbox_process(mbox);
 524 }
 525
 526 static int
 527 nix_sq_uninit(struct otx2_eth_txq *txq)
 528 {
 529         struct otx2_eth_dev *dev = txq->dev;
 530         struct otx2_mbox *mbox = dev->mbox;
 531         struct ndc_sync_op *ndc_req;
 532         struct nix_aq_enq_rsp *rsp;
 533         struct nix_aq_enq_req *aq;
 534         uint16_t sqes_per_sqb;
 535         void *sqb_buf;
 536         int rc, count;
 537
 538         otx2_nix_dbg("Cleaning up sq %u", txq->sq);
 539
 540         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 541         aq->qidx = txq->sq;
 542         aq->ctype = NIX_AQ_CTYPE_SQ;
 543         aq->op = NIX_AQ_INSTOP_READ;
 544
 545         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
 546         if (rc)
 547                 return rc;
 548
 549         /* Check if sq is already cleaned up */
 550         if (!rsp->sq.ena)
 551                 return 0;
 552
 553         /* Disable sq */
 554         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 555         aq->qidx = txq->sq;
 556         aq->ctype = NIX_AQ_CTYPE_SQ;
 557         aq->op = NIX_AQ_INSTOP_WRITE;
 558
 559         aq->sq_mask.ena = ~aq->sq_mask.ena;
 560         aq->sq.ena = 0;
 561
 562         rc = otx2_mbox_process(mbox);
 563         if (rc)
 564                 return rc;
 565
 566         /* Read SQ and free sqb's */
 567         aq = otx2_mbox_alloc_msg_nix_aq_enq(mbox);
 568         aq->qidx = txq->sq;
 569         aq->ctype = NIX_AQ_CTYPE_SQ;
 570         aq->op = NIX_AQ_INSTOP_READ;
 571
 572         rc = otx2_mbox_process_msg(mbox, (void *)&rsp);
 573         if (rc)
 574                 return rc;
 575
 576         if (aq->sq.smq_pend)
 577                 otx2_err("SQ has pending sqe's");
 578
 579         count = aq->sq.sqb_count;
 580         sqes_per_sqb = 1 << txq->sqes_per_sqb_log2;
 581         /* Free SQB's that are used */
 582         sqb_buf = (void *)rsp->sq.head_sqb;
 583         while (count) {
 584                 void *next_sqb;
 585
 586                 next_sqb = *(void **)((uintptr_t)sqb_buf + ((sqes_per_sqb - 1) *
 587                                       nix_sq_max_sqe_sz(txq)));
 588                 npa_lf_aura_op_free(txq->sqb_pool->pool_id, 1,
 589                                     (uint64_t)sqb_buf);
 590                 sqb_buf = next_sqb;
 591                 count--;
 592         }
 593
 594         /* Free next to use sqb */
 595         if (rsp->sq.next_sqb)
 596                 npa_lf_aura_op_free(txq->sqb_pool->pool_id, 1,
 597                                     rsp->sq.next_sqb);
 598
 599         /* Sync NDC-NIX-TX for LF */
 600         ndc_req = otx2_mbox_alloc_msg_ndc_sync_op(mbox);
 601         ndc_req->nix_lf_tx_sync = 1;
 602         rc = otx2_mbox_process(mbox);
 603         if (rc)
 604                 otx2_err("Error on NDC-NIX-TX LF sync, rc %d", rc);
 605
 606         return rc;
 607 }
 608
 609 static int
 610 nix_sqb_aura_limit_cfg(struct rte_mempool *mp, uint16_t nb_sqb_bufs)
 611 {
 612         struct otx2_npa_lf *npa_lf = otx2_intra_dev_get_cfg()->npa_lf;
 613         struct npa_aq_enq_req *aura_req;
 614
 615         aura_req = otx2_mbox_alloc_msg_npa_aq_enq(npa_lf->mbox);
 616         aura_req->aura_id = npa_lf_aura_handle_to_aura(mp->pool_id);
 617         aura_req->ctype = NPA_AQ_CTYPE_AURA;
 618         aura_req->op = NPA_AQ_INSTOP_WRITE;
 619
 620         aura_req->aura.limit = nb_sqb_bufs;
 621         aura_req->aura_mask.limit = ~(aura_req->aura_mask.limit);
 622
 623         return otx2_mbox_process(npa_lf->mbox);
 624 }
 625
 626 static int
 627 nix_alloc_sqb_pool(int port, struct otx2_eth_txq *txq, uint16_t nb_desc)
 628 {
 629         struct otx2_eth_dev *dev = txq->dev;
 630         uint16_t sqes_per_sqb, nb_sqb_bufs;
 631         char name[RTE_MEMPOOL_NAMESIZE];
 632         struct rte_mempool_objsz sz;
 633         struct npa_aura_s *aura;
 634         uint32_t tmp, blk_sz;
 635
 636         aura = (struct npa_aura_s *)((uintptr_t)txq->fc_mem + OTX2_ALIGN);
 637         snprintf(name, sizeof(name), "otx2_sqb_pool_%d_%d", port, txq->sq);
 638         blk_sz = dev->sqb_size;
 639
 640         if (nix_sq_max_sqe_sz(txq) == NIX_MAXSQESZ_W16)
 641                 sqes_per_sqb = (dev->sqb_size / 8) / 16;
 642         else
 643                 sqes_per_sqb = (dev->sqb_size / 8) / 8;
 644
 645         nb_sqb_bufs = nb_desc / sqes_per_sqb;
 646         /* Clamp up to devarg passed SQB count */
 647         nb_sqb_bufs =  RTE_MIN(dev->max_sqb_count, RTE_MAX(NIX_MIN_SQB,
 648                               nb_sqb_bufs + NIX_SQB_LIST_SPACE));
 649
 650         txq->sqb_pool = rte_mempool_create_empty(name, NIX_MAX_SQB, blk_sz,
 651                                                  0, 0, dev->node,
 652                                                  MEMPOOL_F_NO_SPREAD);
 653         txq->nb_sqb_bufs = nb_sqb_bufs;
 654         txq->sqes_per_sqb_log2 = (uint16_t)rte_log2_u32(sqes_per_sqb);
 655         txq->nb_sqb_bufs_adj = nb_sqb_bufs -
 656                 RTE_ALIGN_MUL_CEIL(nb_sqb_bufs, sqes_per_sqb) / sqes_per_sqb;
 657         txq->nb_sqb_bufs_adj =
 658                 (NIX_SQB_LOWER_THRESH * txq->nb_sqb_bufs_adj) / 100;
 659
 660         if (txq->sqb_pool == NULL) {
 661                 otx2_err("Failed to allocate sqe mempool");
 662                 goto fail;
 663         }
 664
 665         memset(aura, 0, sizeof(*aura));
 666         aura->fc_ena = 1;
 667         aura->fc_addr = txq->fc_iova;
 668         aura->fc_hyst_bits = 0; /* Store count on all updates */
 669         if (rte_mempool_set_ops_byname(txq->sqb_pool, "octeontx2_npa", aura)) {
 670                 otx2_err("Failed to set ops for sqe mempool");
 671                 goto fail;
 672         }
 673         if (rte_mempool_populate_default(txq->sqb_pool) < 0) {
 674                 otx2_err("Failed to populate sqe mempool");
 675                 goto fail;
 676         }
 677
 678         tmp = rte_mempool_calc_obj_size(blk_sz, MEMPOOL_F_NO_SPREAD, &sz);
 679         if (dev->sqb_size != sz.elt_size) {
 680                 otx2_err("sqe pool block size is not expected %d != %d",
 681                          dev->sqb_size, tmp);
 682                 goto fail;
 683         }
 684
 685         nix_sqb_aura_limit_cfg(txq->sqb_pool, txq->nb_sqb_bufs);
 686
 687         return 0;
 688 fail:
 689         return -ENOMEM;
 690 }
 691
 692 void
 693 otx2_nix_form_default_desc(struct otx2_eth_txq *txq)
 694 {
 695         struct nix_send_ext_s *send_hdr_ext;
 696         struct nix_send_hdr_s *send_hdr;
 697         struct nix_send_mem_s *send_mem;
 698         union nix_send_sg_s *sg;
 699
 700         /* Initialize the fields based on basic single segment packet */
 701         memset(&txq->cmd, 0, sizeof(txq->cmd));
 702
 703         if (txq->dev->tx_offload_flags & NIX_TX_NEED_EXT_HDR) {
 704                 send_hdr = (struct nix_send_hdr_s *)&txq->cmd[0];
 705                 /* 2(HDR) + 2(EXT_HDR) + 1(SG) + 1(IOVA) = 6/2 - 1 = 2 */
 706                 send_hdr->w0.sizem1 = 2;
 707
 708                 send_hdr_ext = (struct nix_send_ext_s *)&txq->cmd[2];
 709                 send_hdr_ext->w0.subdc = NIX_SUBDC_EXT;
 710                 if (txq->dev->tx_offload_flags & NIX_TX_OFFLOAD_TSTAMP_F) {
 711                         /* Default: one seg packet would have:
 712                          * 2(HDR) + 2(EXT) + 1(SG) + 1(IOVA) + 2(MEM)
 713                          * => 8/2 - 1 = 3
 714                          */
 715                         send_hdr->w0.sizem1 = 3;
 716                         send_hdr_ext->w0.tstmp = 1;
 717
 718                         /* To calculate the offset for send_mem,
 719                          * send_hdr->w0.sizem1 * 2
 720                          */
 721                         send_mem = (struct nix_send_mem_s *)(txq->cmd +
 722                                                 (send_hdr->w0.sizem1 << 1));
 723                         send_mem->subdc = NIX_SUBDC_MEM;
 724                         send_mem->dsz = 0x0;
 725                         send_mem->wmem = 0x1;
 726                         send_mem->alg = NIX_SENDMEMALG_SETTSTMP;
 727                         send_mem->addr = txq->dev->tstamp.tx_tstamp_iova;
 728                 }
 729                 sg = (union nix_send_sg_s *)&txq->cmd[4];
 730         } else {
 731                 send_hdr = (struct nix_send_hdr_s *)&txq->cmd[0];
 732                 /* 2(HDR) + 1(SG) + 1(IOVA) = 4/2 - 1 = 1 */
 733                 send_hdr->w0.sizem1 = 1;
 734                 sg = (union nix_send_sg_s *)&txq->cmd[2];
 735         }
 736
 737         send_hdr->w0.sq = txq->sq;
 738         sg->subdc = NIX_SUBDC_SG;
 739         sg->segs = 1;
 740         sg->ld_type = NIX_SENDLDTYPE_LDD;
 741
 742         rte_smp_wmb();
 743 }
 744
 745 static void
 746 otx2_nix_tx_queue_release(void *_txq)
 747 {
 748         struct otx2_eth_txq *txq = _txq;
 749         struct rte_eth_dev *eth_dev;
 750
 751         if (!txq)
 752                 return;
 753
 754         eth_dev = txq->dev->eth_dev;
 755
 756         otx2_nix_dbg("Releasing txq %u", txq->sq);
 757
 758         /* Flush and disable tm */
 759         otx2_nix_tm_sw_xoff(txq, eth_dev->data->dev_started);
 760
 761         /* Free sqb's and disable sq */
 762         nix_sq_uninit(txq);
 763
 764         if (txq->sqb_pool) {
 765                 rte_mempool_free(txq->sqb_pool);
 766                 txq->sqb_pool = NULL;
 767         }
 768         rte_free(txq);
 769 }
 770
 771
 772 static int
 773 otx2_nix_tx_queue_setup(struct rte_eth_dev *eth_dev, uint16_t sq,
 774                         uint16_t nb_desc, unsigned int socket_id,
 775                         const struct rte_eth_txconf *tx_conf)
 776 {
 777         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 778         const struct rte_memzone *fc;
 779         struct otx2_eth_txq *txq;
 780         uint64_t offloads;
 781         int rc;
 782
 783         rc = -EINVAL;
 784
 785         /* Compile time check to make sure all fast path elements in a CL */
 786         RTE_BUILD_BUG_ON(offsetof(struct otx2_eth_txq, slow_path_start) >= 128);
 787
 788         if (tx_conf->tx_deferred_start) {
 789                 otx2_err("Tx deferred start is not supported");
 790                 goto fail;
 791         }
 792
 793         /* Free memory prior to re-allocation if needed. */
 794         if (eth_dev->data->tx_queues[sq] != NULL) {
 795                 otx2_nix_dbg("Freeing memory prior to re-allocation %d", sq);
 796                 otx2_nix_tx_queue_release(eth_dev->data->tx_queues[sq]);
 797                 eth_dev->data->tx_queues[sq] = NULL;
 798         }
 799
 800         /* Find the expected offloads for this queue */
 801         offloads = tx_conf->offloads | eth_dev->data->dev_conf.txmode.offloads;
 802
 803         /* Allocating tx queue data structure */
 804         txq = rte_zmalloc_socket("otx2_ethdev TX queue", sizeof(*txq),
 805                                  OTX2_ALIGN, socket_id);
 806         if (txq == NULL) {
 807                 otx2_err("Failed to alloc txq=%d", sq);
 808                 rc = -ENOMEM;
 809                 goto fail;
 810         }
 811         txq->sq = sq;
 812         txq->dev = dev;
 813         txq->sqb_pool = NULL;
 814         txq->offloads = offloads;
 815         dev->tx_offloads |= offloads;
 816
 817         /*
 818          * Allocate memory for flow control updates from HW.
 819          * Alloc one cache line, so that fits all FC_STYPE modes.
 820          */
 821         fc = rte_eth_dma_zone_reserve(eth_dev, "fcmem", sq,
 822                                       OTX2_ALIGN + sizeof(struct npa_aura_s),
 823                                       OTX2_ALIGN, dev->node);
 824         if (fc == NULL) {
 825                 otx2_err("Failed to allocate mem for fcmem");
 826                 rc = -ENOMEM;
 827                 goto free_txq;
 828         }
 829         txq->fc_iova = fc->iova;
 830         txq->fc_mem = fc->addr;
 831
 832         /* Initialize the aura sqb pool */
 833         rc = nix_alloc_sqb_pool(eth_dev->data->port_id, txq, nb_desc);
 834         if (rc) {
 835                 otx2_err("Failed to alloc sqe pool rc=%d", rc);
 836                 goto free_txq;
 837         }
 838
 839         /* Initialize the SQ */
 840         rc = nix_sq_init(txq);
 841         if (rc) {
 842                 otx2_err("Failed to init sq=%d context", sq);
 843                 goto free_txq;
 844         }
 845
 846         txq->fc_cache_pkts = 0;
 847         txq->io_addr = dev->base + NIX_LF_OP_SENDX(0);
 848         /* Evenly distribute LMT slot for each sq */
 849         txq->lmt_addr = (void *)(dev->lmt_addr + ((sq & LMT_SLOT_MASK) << 12));
 850
 851         txq->qconf.socket_id = socket_id;
 852         txq->qconf.nb_desc = nb_desc;
 853         memcpy(&txq->qconf.conf.tx, tx_conf, sizeof(struct rte_eth_txconf));
 854
 855         otx2_nix_form_default_desc(txq);
 856
 857         otx2_nix_dbg("sq=%d fc=%p offload=0x%" PRIx64 " sqb=0x%" PRIx64 ""
 858                      " lmt_addr=%p nb_sqb_bufs=%d sqes_per_sqb_log2=%d", sq,
 859                      fc->addr, offloads, txq->sqb_pool->pool_id, txq->lmt_addr,
 860                      txq->nb_sqb_bufs, txq->sqes_per_sqb_log2);
 861         eth_dev->data->tx_queues[sq] = txq;
 862         eth_dev->data->tx_queue_state[sq] = RTE_ETH_QUEUE_STATE_STOPPED;
 863         return 0;
 864
 865 free_txq:
 866         otx2_nix_tx_queue_release(txq);
 867 fail:
 868         return rc;
 869 }
 870
 871 static int
 872 nix_store_queue_cfg_and_then_release(struct rte_eth_dev *eth_dev)
 873 {
 874         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 875         struct otx2_eth_qconf *tx_qconf = NULL;
 876         struct otx2_eth_qconf *rx_qconf = NULL;
 877         struct otx2_eth_txq **txq;
 878         struct otx2_eth_rxq **rxq;
 879         int i, nb_rxq, nb_txq;
 880
 881         nb_rxq = RTE_MIN(dev->configured_nb_rx_qs, eth_dev->data->nb_rx_queues);
 882         nb_txq = RTE_MIN(dev->configured_nb_tx_qs, eth_dev->data->nb_tx_queues);
 883
 884         tx_qconf = malloc(nb_txq * sizeof(*tx_qconf));
 885         if (tx_qconf == NULL) {
 886                 otx2_err("Failed to allocate memory for tx_qconf");
 887                 goto fail;
 888         }
 889
 890         rx_qconf = malloc(nb_rxq * sizeof(*rx_qconf));
 891         if (rx_qconf == NULL) {
 892                 otx2_err("Failed to allocate memory for rx_qconf");
 893                 goto fail;
 894         }
 895
 896         txq = (struct otx2_eth_txq **)eth_dev->data->tx_queues;
 897         for (i = 0; i < nb_txq; i++) {
 898                 if (txq[i] == NULL) {
 899                         otx2_err("txq[%d] is already released", i);
 900                         goto fail;
 901                 }
 902                 memcpy(&tx_qconf[i], &txq[i]->qconf, sizeof(*tx_qconf));
 903                 otx2_nix_tx_queue_release(txq[i]);
 904                 eth_dev->data->tx_queues[i] = NULL;
 905         }
 906
 907         rxq = (struct otx2_eth_rxq **)eth_dev->data->rx_queues;
 908         for (i = 0; i < nb_rxq; i++) {
 909                 if (rxq[i] == NULL) {
 910                         otx2_err("rxq[%d] is already released", i);
 911                         goto fail;
 912                 }
 913                 memcpy(&rx_qconf[i], &rxq[i]->qconf, sizeof(*rx_qconf));
 914                 otx2_nix_rx_queue_release(rxq[i]);
 915                 eth_dev->data->rx_queues[i] = NULL;
 916         }
 917
 918         dev->tx_qconf = tx_qconf;
 919         dev->rx_qconf = rx_qconf;
 920         return 0;
 921
 922 fail:
 923         if (tx_qconf)
 924                 free(tx_qconf);
 925         if (rx_qconf)
 926                 free(rx_qconf);
 927
 928         return -ENOMEM;
 929 }
 930
 931 static int
 932 nix_restore_queue_cfg(struct rte_eth_dev *eth_dev)
 933 {
 934         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
 935         struct otx2_eth_qconf *tx_qconf = dev->tx_qconf;
 936         struct otx2_eth_qconf *rx_qconf = dev->rx_qconf;
 937         struct otx2_eth_txq **txq;
 938         struct otx2_eth_rxq **rxq;
 939         int rc, i, nb_rxq, nb_txq;
 940
 941         nb_rxq = RTE_MIN(dev->configured_nb_rx_qs, eth_dev->data->nb_rx_queues);
 942         nb_txq = RTE_MIN(dev->configured_nb_tx_qs, eth_dev->data->nb_tx_queues);
 943
 944         rc = -ENOMEM;
 945         /* Setup tx & rx queues with previous configuration so
 946          * that the queues can be functional in cases like ports
 947          * are started without re configuring queues.
 948          *
 949          * Usual re config sequence is like below:
 950          * port_configure() {
 951          *      if(reconfigure) {
 952          *              queue_release()
 953          *              queue_setup()
 954          *      }
 955          *      queue_configure() {
 956          *              queue_release()
 957          *              queue_setup()
 958          *      }
 959          * }
 960          * port_start()
 961          *
 962          * In some application's control path, queue_configure() would
 963          * NOT be invoked for TXQs/RXQs in port_configure().
 964          * In such cases, queues can be functional after start as the
 965          * queues are already setup in port_configure().
 966          */
 967         for (i = 0; i < nb_txq; i++) {
 968                 rc = otx2_nix_tx_queue_setup(eth_dev, i, tx_qconf[i].nb_desc,
 969                                              tx_qconf[i].socket_id,
 970                                              &tx_qconf[i].conf.tx);
 971                 if (rc) {
 972                         otx2_err("Failed to setup tx queue rc=%d", rc);
 973                         txq = (struct otx2_eth_txq **)eth_dev->data->tx_queues;
 974                         for (i -= 1; i >= 0; i--)
 975                                 otx2_nix_tx_queue_release(txq[i]);
 976                         goto fail;
 977                 }
 978         }
 979
 980         free(tx_qconf); tx_qconf = NULL;
 981
 982         for (i = 0; i < nb_rxq; i++) {
 983                 rc = otx2_nix_rx_queue_setup(eth_dev, i, rx_qconf[i].nb_desc,
 984                                              rx_qconf[i].socket_id,
 985                                              &rx_qconf[i].conf.rx,
 986                                              rx_qconf[i].mempool);
 987                 if (rc) {
 988                         otx2_err("Failed to setup rx queue rc=%d", rc);
 989                         rxq = (struct otx2_eth_rxq **)eth_dev->data->rx_queues;
 990                         for (i -= 1; i >= 0; i--)
 991                                 otx2_nix_rx_queue_release(rxq[i]);
 992                         goto release_tx_queues;
 993                 }
 994         }
 995
 996         free(rx_qconf); rx_qconf = NULL;
 997
 998         return 0;
 999
1000 release_tx_queues:
1001         txq = (struct otx2_eth_txq **)eth_dev->data->tx_queues;
1002         for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
1003                 otx2_nix_tx_queue_release(txq[i]);
1004 fail:
1005         if (tx_qconf)
1006                 free(tx_qconf);
1007         if (rx_qconf)
1008                 free(rx_qconf);
1009
1010         return rc;
1011 }
1012
1013 static uint16_t
1014 nix_eth_nop_burst(void *queue, struct rte_mbuf **mbufs, uint16_t pkts)
1015 {
1016         RTE_SET_USED(queue);
1017         RTE_SET_USED(mbufs);
1018         RTE_SET_USED(pkts);
1019
1020         return 0;
1021 }
1022
1023 static void
1024 nix_set_nop_rxtx_function(struct rte_eth_dev *eth_dev)
1025 {
1026         /* These dummy functions are required for supporting
1027          * some applications which reconfigure queues without
1028          * stopping tx burst and rx burst threads(eg kni app)
1029          * When the queues context is saved, txq/rxqs are released
1030          * which caused app crash since rx/tx burst is still
1031          * on different lcores
1032          */
1033         eth_dev->tx_pkt_burst = nix_eth_nop_burst;
1034         eth_dev->rx_pkt_burst = nix_eth_nop_burst;
1035         rte_mb();
1036 }
1037
1038 static int
1039 otx2_nix_configure(struct rte_eth_dev *eth_dev)
1040 {
1041         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
1042         struct rte_eth_dev_data *data = eth_dev->data;
1043         struct rte_eth_conf *conf = &data->dev_conf;
1044         struct rte_eth_rxmode *rxmode = &conf->rxmode;
1045         struct rte_eth_txmode *txmode = &conf->txmode;
1046         char ea_fmt[RTE_ETHER_ADDR_FMT_SIZE];
1047         struct rte_ether_addr *ea;
1048         uint8_t nb_rxq, nb_txq;
1049         int rc;
1050
1051         rc = -EINVAL;
1052
1053         /* Sanity checks */
1054         if (rte_eal_has_hugepages() == 0) {
1055                 otx2_err("Huge page is not configured");
1056                 goto fail;
1057         }
1058
1059         if (rte_eal_iova_mode() != RTE_IOVA_VA) {
1060                 otx2_err("iova mode should be va");
1061                 goto fail;
1062         }
1063
1064         if (conf->link_speeds & ETH_LINK_SPEED_FIXED) {
1065                 otx2_err("Setting link speed/duplex not supported");
1066                 goto fail;
1067         }
1068
1069         if (conf->dcb_capability_en == 1) {
1070                 otx2_err("dcb enable is not supported");
1071                 goto fail;
1072         }
1073
1074         if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) {
1075                 otx2_err("Flow director is not supported");
1076                 goto fail;
1077         }
1078
1079         if (rxmode->mq_mode != ETH_MQ_RX_NONE &&
1080             rxmode->mq_mode != ETH_MQ_RX_RSS) {
1081                 otx2_err("Unsupported mq rx mode %d", rxmode->mq_mode);
1082                 goto fail;
1083         }
1084
1085         if (txmode->mq_mode != ETH_MQ_TX_NONE) {
1086                 otx2_err("Unsupported mq tx mode %d", txmode->mq_mode);
1087                 goto fail;
1088         }
1089
1090         /* Free the resources allocated from the previous configure */
1091         if (dev->configured == 1) {
1092                 otx2_nix_rxchan_bpid_cfg(eth_dev, false);
1093                 otx2_nix_vlan_fini(eth_dev);
1094                 oxt2_nix_unregister_queue_irqs(eth_dev);
1095                 nix_set_nop_rxtx_function(eth_dev);
1096                 rc = nix_store_queue_cfg_and_then_release(eth_dev);
1097                 if (rc)
1098                         goto fail;
1099                 otx2_nix_tm_fini(eth_dev);
1100                 nix_lf_free(dev);
1101         }
1102
1103         if (otx2_dev_is_A0(dev) &&
1104             (txmode->offloads & DEV_TX_OFFLOAD_SCTP_CKSUM) &&
1105             ((txmode->offloads & DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM) ||
1106             (txmode->offloads & DEV_TX_OFFLOAD_OUTER_UDP_CKSUM))) {
1107                 otx2_err("Outer IP and SCTP checksum unsupported");
1108                 rc = -EINVAL;
1109                 goto fail;
1110         }
1111
1112         dev->rx_offloads = rxmode->offloads;
1113         dev->tx_offloads = txmode->offloads;
1114         dev->rss_info.rss_grps = NIX_RSS_GRPS;
1115
1116         nb_rxq = RTE_MAX(data->nb_rx_queues, 1);
1117         nb_txq = RTE_MAX(data->nb_tx_queues, 1);
1118
1119         /* Alloc a nix lf */
1120         rc = nix_lf_alloc(dev, nb_rxq, nb_txq);
1121         if (rc) {
1122                 otx2_err("Failed to init nix_lf rc=%d", rc);
1123                 goto fail;
1124         }
1125
1126         /* Configure RSS */
1127         rc = otx2_nix_rss_config(eth_dev);
1128         if (rc) {
1129                 otx2_err("Failed to configure rss rc=%d", rc);
1130                 goto free_nix_lf;
1131         }
1132
1133         /* Init the default TM scheduler hierarchy */
1134         rc = otx2_nix_tm_init_default(eth_dev);
1135         if (rc) {
1136                 otx2_err("Failed to init traffic manager rc=%d", rc);
1137                 goto free_nix_lf;
1138         }
1139
1140         rc = otx2_nix_vlan_offload_init(eth_dev);
1141         if (rc) {
1142                 otx2_err("Failed to init vlan offload rc=%d", rc);
1143                 goto free_nix_lf;
1144         }
1145
1146         /* Register queue IRQs */
1147         rc = oxt2_nix_register_queue_irqs(eth_dev);
1148         if (rc) {
1149                 otx2_err("Failed to register queue interrupts rc=%d", rc);
1150                 goto free_nix_lf;
1151         }
1152
1153         rc = otx2_nix_rxchan_bpid_cfg(eth_dev, true);
1154         if (rc) {
1155                 otx2_err("Failed to configure nix rx chan bpid cfg rc=%d", rc);
1156                 goto free_nix_lf;
1157         }
1158
1159         /* Enable PTP if it was requested by the app or if it is already
1160          * enabled in PF owning this VF
1161          */
1162         memset(&dev->tstamp, 0, sizeof(struct otx2_timesync_info));
1163         if ((dev->rx_offloads & DEV_RX_OFFLOAD_TIMESTAMP) ||
1164             otx2_ethdev_is_ptp_en(dev))
1165                 otx2_nix_timesync_enable(eth_dev);
1166         else
1167                 otx2_nix_timesync_disable(eth_dev);
1168
1169         /*
1170          * Restore queue config when reconfigure followed by
1171          * reconfigure and no queue configure invoked from application case.
1172          */
1173         if (dev->configured == 1) {
1174                 rc = nix_restore_queue_cfg(eth_dev);
1175                 if (rc)
1176                         goto free_nix_lf;
1177         }
1178
1179         /* Update the mac address */
1180         ea = eth_dev->data->mac_addrs;
1181         memcpy(ea, dev->mac_addr, RTE_ETHER_ADDR_LEN);
1182         if (rte_is_zero_ether_addr(ea))
1183                 rte_eth_random_addr((uint8_t *)ea);
1184
1185         rte_ether_format_addr(ea_fmt, RTE_ETHER_ADDR_FMT_SIZE, ea);
1186
1187         otx2_nix_dbg("Configured port%d mac=%s nb_rxq=%d nb_txq=%d"
1188                 " rx_offloads=0x%" PRIx64 " tx_offloads=0x%" PRIx64 ""
1189                 " rx_flags=0x%x tx_flags=0x%x",
1190                 eth_dev->data->port_id, ea_fmt, nb_rxq,
1191                 nb_txq, dev->rx_offloads, dev->tx_offloads,
1192                 dev->rx_offload_flags, dev->tx_offload_flags);
1193
1194         /* All good */
1195         dev->configured = 1;
1196         dev->configured_nb_rx_qs = data->nb_rx_queues;
1197         dev->configured_nb_tx_qs = data->nb_tx_queues;
1198         return 0;
1199
1200 free_nix_lf:
1201         rc = nix_lf_free(dev);
1202 fail:
1203         return rc;
1204 }
1205
1206 int
1207 otx2_nix_tx_queue_start(struct rte_eth_dev *eth_dev, uint16_t qidx)
1208 {
1209         struct rte_eth_dev_data *data = eth_dev->data;
1210         struct otx2_eth_txq *txq;
1211         int rc = -EINVAL;
1212
1213         txq = eth_dev->data->tx_queues[qidx];
1214
1215         if (data->tx_queue_state[qidx] == RTE_ETH_QUEUE_STATE_STARTED)
1216                 return 0;
1217
1218         rc = otx2_nix_sq_sqb_aura_fc(txq, true);
1219         if (rc) {
1220                 otx2_err("Failed to enable sqb aura fc, txq=%u, rc=%d",
1221                          qidx, rc);
1222                 goto done;
1223         }
1224
1225         data->tx_queue_state[qidx] = RTE_ETH_QUEUE_STATE_STARTED;
1226
1227 done:
1228         return rc;
1229 }
1230
1231 int
1232 otx2_nix_tx_queue_stop(struct rte_eth_dev *eth_dev, uint16_t qidx)
1233 {
1234         struct rte_eth_dev_data *data = eth_dev->data;
1235         struct otx2_eth_txq *txq;
1236         int rc;
1237
1238         txq = eth_dev->data->tx_queues[qidx];
1239
1240         if (data->tx_queue_state[qidx] == RTE_ETH_QUEUE_STATE_STOPPED)
1241                 return 0;
1242
1243         txq->fc_cache_pkts = 0;
1244
1245         rc = otx2_nix_sq_sqb_aura_fc(txq, false);
1246         if (rc) {
1247                 otx2_err("Failed to disable sqb aura fc, txq=%u, rc=%d",
1248                          qidx, rc);
1249                 goto done;
1250         }
1251
1252         data->tx_queue_state[qidx] = RTE_ETH_QUEUE_STATE_STOPPED;
1253
1254 done:
1255         return rc;
1256 }
1257
1258 static int
1259 otx2_nix_rx_queue_start(struct rte_eth_dev *eth_dev, uint16_t qidx)
1260 {
1261         struct otx2_eth_rxq *rxq = eth_dev->data->rx_queues[qidx];
1262         struct rte_eth_dev_data *data = eth_dev->data;
1263         int rc;
1264
1265         if (data->rx_queue_state[qidx] == RTE_ETH_QUEUE_STATE_STARTED)
1266                 return 0;
1267
1268         rc = nix_rq_enb_dis(rxq->eth_dev, rxq, true);
1269         if (rc) {
1270                 otx2_err("Failed to enable rxq=%u, rc=%d", qidx, rc);
1271                 goto done;
1272         }
1273
1274         data->rx_queue_state[qidx] = RTE_ETH_QUEUE_STATE_STARTED;
1275
1276 done:
1277         return rc;
1278 }
1279
1280 static int
1281 otx2_nix_rx_queue_stop(struct rte_eth_dev *eth_dev, uint16_t qidx)
1282 {
1283         struct otx2_eth_rxq *rxq = eth_dev->data->rx_queues[qidx];
1284         struct rte_eth_dev_data *data = eth_dev->data;
1285         int rc;
1286
1287         if (data->rx_queue_state[qidx] == RTE_ETH_QUEUE_STATE_STOPPED)
1288                 return 0;
1289
1290         rc = nix_rq_enb_dis(rxq->eth_dev, rxq, false);
1291         if (rc) {
1292                 otx2_err("Failed to disable rxq=%u, rc=%d", qidx, rc);
1293                 goto done;
1294         }
1295
1296         data->rx_queue_state[qidx] = RTE_ETH_QUEUE_STATE_STOPPED;
1297
1298 done:
1299         return rc;
1300 }
1301
1302 /* Initialize and register driver with DPDK Application */
1303 static const struct eth_dev_ops otx2_eth_dev_ops = {
1304         .dev_infos_get            = otx2_nix_info_get,
1305         .dev_configure            = otx2_nix_configure,
1306         .link_update              = otx2_nix_link_update,
1307         .tx_queue_setup           = otx2_nix_tx_queue_setup,
1308         .tx_queue_release         = otx2_nix_tx_queue_release,
1309         .rx_queue_setup           = otx2_nix_rx_queue_setup,
1310         .rx_queue_release         = otx2_nix_rx_queue_release,
1311         .tx_queue_start           = otx2_nix_tx_queue_start,
1312         .tx_queue_stop            = otx2_nix_tx_queue_stop,
1313         .rx_queue_start           = otx2_nix_rx_queue_start,
1314         .rx_queue_stop            = otx2_nix_rx_queue_stop,
1315         .dev_supported_ptypes_get = otx2_nix_supported_ptypes_get,
1316         .stats_get                = otx2_nix_dev_stats_get,
1317         .stats_reset              = otx2_nix_dev_stats_reset,
1318         .get_reg                  = otx2_nix_dev_get_reg,
1319         .mac_addr_add             = otx2_nix_mac_addr_add,
1320         .mac_addr_remove          = otx2_nix_mac_addr_del,
1321         .mac_addr_set             = otx2_nix_mac_addr_set,
1322         .promiscuous_enable       = otx2_nix_promisc_enable,
1323         .promiscuous_disable      = otx2_nix_promisc_disable,
1324         .allmulticast_enable      = otx2_nix_allmulticast_enable,
1325         .allmulticast_disable     = otx2_nix_allmulticast_disable,
1326         .queue_stats_mapping_set  = otx2_nix_queue_stats_mapping,
1327         .reta_update              = otx2_nix_dev_reta_update,
1328         .reta_query               = otx2_nix_dev_reta_query,
1329         .rss_hash_update          = otx2_nix_rss_hash_update,
1330         .rss_hash_conf_get        = otx2_nix_rss_hash_conf_get,
1331         .xstats_get               = otx2_nix_xstats_get,
1332         .xstats_get_names         = otx2_nix_xstats_get_names,
1333         .xstats_reset             = otx2_nix_xstats_reset,
1334         .xstats_get_by_id         = otx2_nix_xstats_get_by_id,
1335         .xstats_get_names_by_id   = otx2_nix_xstats_get_names_by_id,
1336         .rxq_info_get             = otx2_nix_rxq_info_get,
1337         .txq_info_get             = otx2_nix_txq_info_get,
1338         .rx_queue_count           = otx2_nix_rx_queue_count,
1339         .rx_descriptor_done       = otx2_nix_rx_descriptor_done,
1340         .rx_descriptor_status     = otx2_nix_rx_descriptor_status,
1341         .tx_done_cleanup          = otx2_nix_tx_done_cleanup,
1342         .pool_ops_supported       = otx2_nix_pool_ops_supported,
1343         .filter_ctrl              = otx2_nix_dev_filter_ctrl,
1344         .get_module_info          = otx2_nix_get_module_info,
1345         .get_module_eeprom        = otx2_nix_get_module_eeprom,
1346         .fw_version_get           = otx2_nix_fw_version_get,
1347         .flow_ctrl_get            = otx2_nix_flow_ctrl_get,
1348         .flow_ctrl_set            = otx2_nix_flow_ctrl_set,
1349         .timesync_enable          = otx2_nix_timesync_enable,
1350         .timesync_disable         = otx2_nix_timesync_disable,
1351         .timesync_read_rx_timestamp = otx2_nix_timesync_read_rx_timestamp,
1352         .timesync_read_tx_timestamp = otx2_nix_timesync_read_tx_timestamp,
1353         .timesync_adjust_time     = otx2_nix_timesync_adjust_time,
1354         .timesync_read_time       = otx2_nix_timesync_read_time,
1355         .timesync_write_time      = otx2_nix_timesync_write_time,
1356         .vlan_offload_set         = otx2_nix_vlan_offload_set,
1357         .vlan_filter_set          = otx2_nix_vlan_filter_set,
1358         .vlan_strip_queue_set     = otx2_nix_vlan_strip_queue_set,
1359         .vlan_tpid_set            = otx2_nix_vlan_tpid_set,
1360         .vlan_pvid_set            = otx2_nix_vlan_pvid_set,
1361 };
1362
1363 static inline int
1364 nix_lf_attach(struct otx2_eth_dev *dev)
1365 {
1366         struct otx2_mbox *mbox = dev->mbox;
1367         struct rsrc_attach_req *req;
1368
1369         /* Attach NIX(lf) */
1370         req = otx2_mbox_alloc_msg_attach_resources(mbox);
1371         req->modify = true;
1372         req->nixlf = true;
1373
1374         return otx2_mbox_process(mbox);
1375 }
1376
1377 static inline int
1378 nix_lf_get_msix_offset(struct otx2_eth_dev *dev)
1379 {
1380         struct otx2_mbox *mbox = dev->mbox;
1381         struct msix_offset_rsp *msix_rsp;
1382         int rc;
1383
1384         /* Get NPA and NIX MSIX vector offsets */
1385         otx2_mbox_alloc_msg_msix_offset(mbox);
1386
1387         rc = otx2_mbox_process_msg(mbox, (void *)&msix_rsp);
1388
1389         dev->nix_msixoff = msix_rsp->nix_msixoff;
1390
1391         return rc;
1392 }
1393
1394 static inline int
1395 otx2_eth_dev_lf_detach(struct otx2_mbox *mbox)
1396 {
1397         struct rsrc_detach_req *req;
1398
1399         req = otx2_mbox_alloc_msg_detach_resources(mbox);
1400
1401         /* Detach all except npa lf */
1402         req->partial = true;
1403         req->nixlf = true;
1404         req->sso = true;
1405         req->ssow = true;
1406         req->timlfs = true;
1407         req->cptlfs = true;
1408
1409         return otx2_mbox_process(mbox);
1410 }
1411
1412 static int
1413 otx2_eth_dev_init(struct rte_eth_dev *eth_dev)
1414 {
1415         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
1416         struct rte_pci_device *pci_dev;
1417         int rc, max_entries;
1418
1419         eth_dev->dev_ops = &otx2_eth_dev_ops;
1420
1421         /* For secondary processes, the primary has done all the work */
1422         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
1423                 /* Setup callbacks for secondary process */
1424                 otx2_eth_set_tx_function(eth_dev);
1425                 otx2_eth_set_rx_function(eth_dev);
1426                 return 0;
1427         }
1428
1429         pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1430
1431         rte_eth_copy_pci_info(eth_dev, pci_dev);
1432         eth_dev->data->dev_flags |= RTE_ETH_DEV_CLOSE_REMOVE;
1433
1434         /* Zero out everything after OTX2_DEV to allow proper dev_reset() */
1435         memset(&dev->otx2_eth_dev_data_start, 0, sizeof(*dev) -
1436                 offsetof(struct otx2_eth_dev, otx2_eth_dev_data_start));
1437
1438         /* Parse devargs string */
1439         rc = otx2_ethdev_parse_devargs(eth_dev->device->devargs, dev);
1440         if (rc) {
1441                 otx2_err("Failed to parse devargs rc=%d", rc);
1442                 goto error;
1443         }
1444
1445         if (!dev->mbox_active) {
1446                 /* Initialize the base otx2_dev object
1447                  * only if already present
1448                  */
1449                 rc = otx2_dev_init(pci_dev, dev);
1450                 if (rc) {
1451                         otx2_err("Failed to initialize otx2_dev rc=%d", rc);
1452                         goto error;
1453                 }
1454         }
1455         /* Device generic callbacks */
1456         dev->ops = &otx2_dev_ops;
1457         dev->eth_dev = eth_dev;
1458
1459         /* Grab the NPA LF if required */
1460         rc = otx2_npa_lf_init(pci_dev, dev);
1461         if (rc)
1462                 goto otx2_dev_uninit;
1463
1464         dev->configured = 0;
1465         dev->drv_inited = true;
1466         dev->base = dev->bar2 + (RVU_BLOCK_ADDR_NIX0 << 20);
1467         dev->lmt_addr = dev->bar2 + (RVU_BLOCK_ADDR_LMT << 20);
1468
1469         /* Attach NIX LF */
1470         rc = nix_lf_attach(dev);
1471         if (rc)
1472                 goto otx2_npa_uninit;
1473
1474         /* Get NIX MSIX offset */
1475         rc = nix_lf_get_msix_offset(dev);
1476         if (rc)
1477                 goto otx2_npa_uninit;
1478
1479         /* Register LF irq handlers */
1480         rc = otx2_nix_register_irqs(eth_dev);
1481         if (rc)
1482                 goto mbox_detach;
1483
1484         /* Get maximum number of supported MAC entries */
1485         max_entries = otx2_cgx_mac_max_entries_get(dev);
1486         if (max_entries < 0) {
1487                 otx2_err("Failed to get max entries for mac addr");
1488                 rc = -ENOTSUP;
1489                 goto unregister_irq;
1490         }
1491
1492         /* For VFs, returned max_entries will be 0. But to keep default MAC
1493          * address, one entry must be allocated. So setting up to 1.
1494          */
1495         if (max_entries == 0)
1496                 max_entries = 1;
1497
1498         eth_dev->data->mac_addrs = rte_zmalloc("mac_addr", max_entries *
1499                                                RTE_ETHER_ADDR_LEN, 0);
1500         if (eth_dev->data->mac_addrs == NULL) {
1501                 otx2_err("Failed to allocate memory for mac addr");
1502                 rc = -ENOMEM;
1503                 goto unregister_irq;
1504         }
1505
1506         dev->max_mac_entries = max_entries;
1507
1508         rc = otx2_nix_mac_addr_get(eth_dev, dev->mac_addr);
1509         if (rc)
1510                 goto free_mac_addrs;
1511
1512         /* Update the mac address */
1513         memcpy(eth_dev->data->mac_addrs, dev->mac_addr, RTE_ETHER_ADDR_LEN);
1514
1515         /* Also sync same MAC address to CGX table */
1516         otx2_cgx_mac_addr_set(eth_dev, &eth_dev->data->mac_addrs[0]);
1517
1518         /* Initialize the tm data structures */
1519         otx2_nix_tm_conf_init(eth_dev);
1520
1521         dev->tx_offload_capa = nix_get_tx_offload_capa(dev);
1522         dev->rx_offload_capa = nix_get_rx_offload_capa(dev);
1523
1524         if (otx2_dev_is_A0(dev)) {
1525                 dev->hwcap |= OTX2_FIXUP_F_MIN_4K_Q;
1526                 dev->hwcap |= OTX2_FIXUP_F_LIMIT_CQ_FULL;
1527         }
1528
1529         /* Initialize rte-flow */
1530         rc = otx2_flow_init(dev);
1531         if (rc)
1532                 goto free_mac_addrs;
1533
1534         otx2_nix_dbg("Port=%d pf=%d vf=%d ver=%s msix_off=%d hwcap=0x%" PRIx64
1535                      " rxoffload_capa=0x%" PRIx64 " txoffload_capa=0x%" PRIx64,
1536                      eth_dev->data->port_id, dev->pf, dev->vf,
1537                      OTX2_ETH_DEV_PMD_VERSION, dev->nix_msixoff, dev->hwcap,
1538                      dev->rx_offload_capa, dev->tx_offload_capa);
1539         return 0;
1540
1541 free_mac_addrs:
1542         rte_free(eth_dev->data->mac_addrs);
1543 unregister_irq:
1544         otx2_nix_unregister_irqs(eth_dev);
1545 mbox_detach:
1546         otx2_eth_dev_lf_detach(dev->mbox);
1547 otx2_npa_uninit:
1548         otx2_npa_lf_fini();
1549 otx2_dev_uninit:
1550         otx2_dev_fini(pci_dev, dev);
1551 error:
1552         otx2_err("Failed to init nix eth_dev rc=%d", rc);
1553         return rc;
1554 }
1555
1556 static int
1557 otx2_eth_dev_uninit(struct rte_eth_dev *eth_dev, bool mbox_close)
1558 {
1559         struct otx2_eth_dev *dev = otx2_eth_pmd_priv(eth_dev);
1560         struct rte_pci_device *pci_dev;
1561         int rc, i;
1562
1563         /* Nothing to be done for secondary processes */
1564         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1565                 return 0;
1566
1567         /* Disable nix bpid config */
1568         otx2_nix_rxchan_bpid_cfg(eth_dev, false);
1569
1570         /* Disable vlan offloads */
1571         otx2_nix_vlan_fini(eth_dev);
1572
1573         /* Disable other rte_flow entries */
1574         otx2_flow_fini(dev);
1575
1576         /* Disable PTP if already enabled */
1577         if (otx2_ethdev_is_ptp_en(dev))
1578                 otx2_nix_timesync_disable(eth_dev);
1579
1580         /* Free up SQs */
1581         for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
1582                 otx2_nix_tx_queue_release(eth_dev->data->tx_queues[i]);
1583                 eth_dev->data->tx_queues[i] = NULL;
1584         }
1585         eth_dev->data->nb_tx_queues = 0;
1586
1587         /* Free up RQ's and CQ's */
1588         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
1589                 otx2_nix_rx_queue_release(eth_dev->data->rx_queues[i]);
1590                 eth_dev->data->rx_queues[i] = NULL;
1591         }
1592         eth_dev->data->nb_rx_queues = 0;
1593
1594         /* Free tm resources */
1595         rc = otx2_nix_tm_fini(eth_dev);
1596         if (rc)
1597                 otx2_err("Failed to cleanup tm, rc=%d", rc);
1598
1599         /* Unregister queue irqs */
1600         oxt2_nix_unregister_queue_irqs(eth_dev);
1601
1602         rc = nix_lf_free(dev);
1603         if (rc)
1604                 otx2_err("Failed to free nix lf, rc=%d", rc);
1605
1606         rc = otx2_npa_lf_fini();
1607         if (rc)
1608                 otx2_err("Failed to cleanup npa lf, rc=%d", rc);
1609
1610         rte_free(eth_dev->data->mac_addrs);
1611         eth_dev->data->mac_addrs = NULL;
1612         dev->drv_inited = false;
1613
1614         pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1615         otx2_nix_unregister_irqs(eth_dev);
1616
1617         rc = otx2_eth_dev_lf_detach(dev->mbox);
1618         if (rc)
1619                 otx2_err("Failed to detach resources, rc=%d", rc);
1620
1621         /* Check if mbox close is needed */
1622         if (!mbox_close)
1623                 return 0;
1624
1625         if (otx2_npa_lf_active(dev) || otx2_dev_active_vfs(dev)) {
1626                 /* Will be freed later by PMD */
1627                 eth_dev->data->dev_private = NULL;
1628                 return 0;
1629         }
1630
1631         otx2_dev_fini(pci_dev, dev);
1632         return 0;
1633 }
1634
1635 static int
1636 nix_remove(struct rte_pci_device *pci_dev)
1637 {
1638         struct rte_eth_dev *eth_dev;
1639         struct otx2_idev_cfg *idev;
1640         struct otx2_dev *otx2_dev;
1641         int rc;
1642
1643         eth_dev = rte_eth_dev_allocated(pci_dev->device.name);
1644         if (eth_dev) {
1645                 /* Cleanup eth dev */
1646                 rc = otx2_eth_dev_uninit(eth_dev, true);
1647                 if (rc)
1648                         return rc;
1649
1650                 rte_eth_dev_pci_release(eth_dev);
1651         }
1652
1653         /* Nothing to be done for secondary processes */
1654         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1655                 return 0;
1656
1657         /* Check for common resources */
1658         idev = otx2_intra_dev_get_cfg();
1659         if (!idev || !idev->npa_lf || idev->npa_lf->pci_dev != pci_dev)
1660                 return 0;
1661
1662         otx2_dev = container_of(idev->npa_lf, struct otx2_dev, npalf);
1663
1664         if (otx2_npa_lf_active(otx2_dev) || otx2_dev_active_vfs(otx2_dev))
1665                 goto exit;
1666
1667         /* Safe to cleanup mbox as no more users */
1668         otx2_dev_fini(pci_dev, otx2_dev);
1669         rte_free(otx2_dev);
1670         return 0;
1671
1672 exit:
1673         otx2_info("%s: common resource in use by other devices", pci_dev->name);
1674         return -EAGAIN;
1675 }
1676
1677 static int
1678 nix_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
1679 {
1680         int rc;
1681
1682         RTE_SET_USED(pci_drv);
1683
1684         rc = rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct otx2_eth_dev),
1685                                            otx2_eth_dev_init);
1686
1687         /* On error on secondary, recheck if port exists in primary or
1688          * in mid of detach state.
1689          */
1690         if (rte_eal_process_type() != RTE_PROC_PRIMARY && rc)
1691                 if (!rte_eth_dev_allocated(pci_dev->device.name))
1692                         return 0;
1693         return rc;
1694 }
1695
1696 static const struct rte_pci_id pci_nix_map[] = {
1697         {
1698                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, PCI_DEVID_OCTEONTX2_RVU_PF)
1699         },
1700         {
1701                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, PCI_DEVID_OCTEONTX2_RVU_VF)
1702         },
1703         {
1704                 RTE_PCI_DEVICE(PCI_VENDOR_ID_CAVIUM,
1705                                PCI_DEVID_OCTEONTX2_RVU_AF_VF)
1706         },
1707         {
1708                 .vendor_id = 0,
1709         },
1710 };
1711
1712 static struct rte_pci_driver pci_nix = {
1713         .id_table = pci_nix_map,
1714         .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_IOVA_AS_VA |
1715                         RTE_PCI_DRV_INTR_LSC,
1716         .probe = nix_probe,
1717         .remove = nix_remove,
1718 };
1719
1720 RTE_PMD_REGISTER_PCI(net_octeontx2, pci_nix);
1721 RTE_PMD_REGISTER_PCI_TABLE(net_octeontx2, pci_nix_map);
1722 RTE_PMD_REGISTER_KMOD_DEP(net_octeontx2, "vfio-pci");