drivers/net/cnxk/cnxk_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(C) 2021 Marvell.
   3  */
   4 #include <cnxk_ethdev.h>
   5
   6 static inline uint64_t
   7 nix_get_rx_offload_capa(struct cnxk_eth_dev *dev)
   8 {
   9         uint64_t capa = CNXK_NIX_RX_OFFLOAD_CAPA;
  10
  11         if (roc_nix_is_vf_or_sdp(&dev->nix) ||
  12             dev->npc.switch_header_type == ROC_PRIV_FLAGS_HIGIG)
  13                 capa &= ~DEV_RX_OFFLOAD_TIMESTAMP;
  14
  15         return capa;
  16 }
  17
  18 static inline uint64_t
  19 nix_get_tx_offload_capa(struct cnxk_eth_dev *dev)
  20 {
  21         RTE_SET_USED(dev);
  22         return CNXK_NIX_TX_OFFLOAD_CAPA;
  23 }
  24
  25 static inline uint32_t
  26 nix_get_speed_capa(struct cnxk_eth_dev *dev)
  27 {
  28         uint32_t speed_capa;
  29
  30         /* Auto negotiation disabled */
  31         speed_capa = ETH_LINK_SPEED_FIXED;
  32         if (!roc_nix_is_vf_or_sdp(&dev->nix) && !roc_nix_is_lbk(&dev->nix)) {
  33                 speed_capa |= ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G |
  34                               ETH_LINK_SPEED_25G | ETH_LINK_SPEED_40G |
  35                               ETH_LINK_SPEED_50G | ETH_LINK_SPEED_100G;
  36         }
  37
  38         return speed_capa;
  39 }
  40
  41 static void
  42 nix_enable_mseg_on_jumbo(struct cnxk_eth_rxq_sp *rxq)
  43 {
  44         struct rte_pktmbuf_pool_private *mbp_priv;
  45         struct rte_eth_dev *eth_dev;
  46         struct cnxk_eth_dev *dev;
  47         uint32_t buffsz;
  48
  49         dev = rxq->dev;
  50         eth_dev = dev->eth_dev;
  51
  52         /* Get rx buffer size */
  53         mbp_priv = rte_mempool_get_priv(rxq->qconf.mp);
  54         buffsz = mbp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM;
  55
  56         if (eth_dev->data->dev_conf.rxmode.max_rx_pkt_len > buffsz) {
  57                 dev->rx_offloads |= DEV_RX_OFFLOAD_SCATTER;
  58                 dev->tx_offloads |= DEV_TX_OFFLOAD_MULTI_SEGS;
  59         }
  60 }
  61
  62 int
  63 nix_recalc_mtu(struct rte_eth_dev *eth_dev)
  64 {
  65         struct rte_eth_dev_data *data = eth_dev->data;
  66         struct cnxk_eth_rxq_sp *rxq;
  67         uint16_t mtu;
  68         int rc;
  69
  70         rxq = ((struct cnxk_eth_rxq_sp *)data->rx_queues[0]) - 1;
  71         /* Setup scatter mode if needed by jumbo */
  72         nix_enable_mseg_on_jumbo(rxq);
  73
  74         /* Setup MTU based on max_rx_pkt_len */
  75         mtu = data->dev_conf.rxmode.max_rx_pkt_len - CNXK_NIX_L2_OVERHEAD +
  76                                 CNXK_NIX_MAX_VTAG_ACT_SIZE;
  77
  78         rc = cnxk_nix_mtu_set(eth_dev, mtu);
  79         if (rc)
  80                 plt_err("Failed to set default MTU size, rc=%d", rc);
  81
  82         return rc;
  83 }
  84
  85 static int
  86 nix_init_flow_ctrl_config(struct rte_eth_dev *eth_dev)
  87 {
  88         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
  89         struct cnxk_fc_cfg *fc = &dev->fc_cfg;
  90         struct rte_eth_fc_conf fc_conf = {0};
  91         int rc;
  92
  93         /* Both Rx & Tx flow ctrl get enabled(RTE_FC_FULL) in HW
  94          * by AF driver, update those info in PMD structure.
  95          */
  96         rc = cnxk_nix_flow_ctrl_get(eth_dev, &fc_conf);
  97         if (rc)
  98                 goto exit;
  99
 100         fc->mode = fc_conf.mode;
 101         fc->rx_pause = (fc_conf.mode == RTE_FC_FULL) ||
 102                         (fc_conf.mode == RTE_FC_RX_PAUSE);
 103         fc->tx_pause = (fc_conf.mode == RTE_FC_FULL) ||
 104                         (fc_conf.mode == RTE_FC_TX_PAUSE);
 105
 106 exit:
 107         return rc;
 108 }
 109
 110 static int
 111 nix_update_flow_ctrl_config(struct rte_eth_dev *eth_dev)
 112 {
 113         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 114         struct cnxk_fc_cfg *fc = &dev->fc_cfg;
 115         struct rte_eth_fc_conf fc_cfg = {0};
 116
 117         if (roc_nix_is_vf_or_sdp(&dev->nix))
 118                 return 0;
 119
 120         fc_cfg.mode = fc->mode;
 121
 122         /* To avoid Link credit deadlock on Ax, disable Tx FC if it's enabled */
 123         if (roc_model_is_cn96_ax() &&
 124             dev->npc.switch_header_type != ROC_PRIV_FLAGS_HIGIG &&
 125             (fc_cfg.mode == RTE_FC_FULL || fc_cfg.mode == RTE_FC_RX_PAUSE)) {
 126                 fc_cfg.mode =
 127                                 (fc_cfg.mode == RTE_FC_FULL ||
 128                                 fc_cfg.mode == RTE_FC_TX_PAUSE) ?
 129                                 RTE_FC_TX_PAUSE : RTE_FC_NONE;
 130         }
 131
 132         return cnxk_nix_flow_ctrl_set(eth_dev, &fc_cfg);
 133 }
 134
 135 uint64_t
 136 cnxk_nix_rxq_mbuf_setup(struct cnxk_eth_dev *dev)
 137 {
 138         uint16_t port_id = dev->eth_dev->data->port_id;
 139         struct rte_mbuf mb_def;
 140         uint64_t *tmp;
 141
 142         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, data_off) % 8 != 0);
 143         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, refcnt) -
 144                                  offsetof(struct rte_mbuf, data_off) !=
 145                          2);
 146         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, nb_segs) -
 147                                  offsetof(struct rte_mbuf, data_off) !=
 148                          4);
 149         RTE_BUILD_BUG_ON(offsetof(struct rte_mbuf, port) -
 150                                  offsetof(struct rte_mbuf, data_off) !=
 151                          6);
 152         mb_def.nb_segs = 1;
 153         mb_def.data_off = RTE_PKTMBUF_HEADROOM +
 154                           (dev->ptp_en * CNXK_NIX_TIMESYNC_RX_OFFSET);
 155         mb_def.port = port_id;
 156         rte_mbuf_refcnt_set(&mb_def, 1);
 157
 158         /* Prevent compiler reordering: rearm_data covers previous fields */
 159         rte_compiler_barrier();
 160         tmp = (uint64_t *)&mb_def.rearm_data;
 161
 162         return *tmp;
 163 }
 164
 165 static inline uint8_t
 166 nix_sq_max_sqe_sz(struct cnxk_eth_dev *dev)
 167 {
 168         /*
 169          * Maximum three segments can be supported with W8, Choose
 170          * NIX_MAXSQESZ_W16 for multi segment offload.
 171          */
 172         if (dev->tx_offloads & DEV_TX_OFFLOAD_MULTI_SEGS)
 173                 return NIX_MAXSQESZ_W16;
 174         else
 175                 return NIX_MAXSQESZ_W8;
 176 }
 177
 178 int
 179 cnxk_nix_tx_queue_setup(struct rte_eth_dev *eth_dev, uint16_t qid,
 180                         uint16_t nb_desc, uint16_t fp_tx_q_sz,
 181                         const struct rte_eth_txconf *tx_conf)
 182 {
 183         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 184         const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
 185         struct cnxk_eth_txq_sp *txq_sp;
 186         struct roc_nix_sq *sq;
 187         size_t txq_sz;
 188         int rc;
 189
 190         /* Free memory prior to re-allocation if needed. */
 191         if (eth_dev->data->tx_queues[qid] != NULL) {
 192                 plt_nix_dbg("Freeing memory prior to re-allocation %d", qid);
 193                 dev_ops->tx_queue_release(eth_dev->data->tx_queues[qid]);
 194                 eth_dev->data->tx_queues[qid] = NULL;
 195         }
 196
 197         /* Setup ROC SQ */
 198         sq = &dev->sqs[qid];
 199         sq->qid = qid;
 200         sq->nb_desc = nb_desc;
 201         sq->max_sqe_sz = nix_sq_max_sqe_sz(dev);
 202
 203         rc = roc_nix_sq_init(&dev->nix, sq);
 204         if (rc) {
 205                 plt_err("Failed to init sq=%d, rc=%d", qid, rc);
 206                 return rc;
 207         }
 208
 209         rc = -ENOMEM;
 210         txq_sz = sizeof(struct cnxk_eth_txq_sp) + fp_tx_q_sz;
 211         txq_sp = plt_zmalloc(txq_sz, PLT_CACHE_LINE_SIZE);
 212         if (!txq_sp) {
 213                 plt_err("Failed to alloc tx queue mem");
 214                 rc |= roc_nix_sq_fini(sq);
 215                 return rc;
 216         }
 217
 218         txq_sp->dev = dev;
 219         txq_sp->qid = qid;
 220         txq_sp->qconf.conf.tx = *tx_conf;
 221         txq_sp->qconf.nb_desc = nb_desc;
 222
 223         plt_nix_dbg("sq=%d fc=%p offload=0x%" PRIx64 " lmt_addr=%p"
 224                     " nb_sqb_bufs=%d sqes_per_sqb_log2=%d",
 225                     qid, sq->fc, dev->tx_offloads, sq->lmt_addr,
 226                     sq->nb_sqb_bufs, sq->sqes_per_sqb_log2);
 227
 228         /* Store start of fast path area */
 229         eth_dev->data->tx_queues[qid] = txq_sp + 1;
 230         eth_dev->data->tx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STOPPED;
 231         return 0;
 232 }
 233
 234 static void
 235 cnxk_nix_tx_queue_release(void *txq)
 236 {
 237         struct cnxk_eth_txq_sp *txq_sp;
 238         struct cnxk_eth_dev *dev;
 239         struct roc_nix_sq *sq;
 240         uint16_t qid;
 241         int rc;
 242
 243         if (!txq)
 244                 return;
 245
 246         txq_sp = cnxk_eth_txq_to_sp(txq);
 247         dev = txq_sp->dev;
 248         qid = txq_sp->qid;
 249
 250         plt_nix_dbg("Releasing txq %u", qid);
 251
 252         /* Cleanup ROC SQ */
 253         sq = &dev->sqs[qid];
 254         rc = roc_nix_sq_fini(sq);
 255         if (rc)
 256                 plt_err("Failed to cleanup sq, rc=%d", rc);
 257
 258         /* Finally free */
 259         plt_free(txq_sp);
 260 }
 261
 262 int
 263 cnxk_nix_rx_queue_setup(struct rte_eth_dev *eth_dev, uint16_t qid,
 264                         uint16_t nb_desc, uint16_t fp_rx_q_sz,
 265                         const struct rte_eth_rxconf *rx_conf,
 266                         struct rte_mempool *mp)
 267 {
 268         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 269         struct cnxk_eth_rxq_sp *rxq_sp;
 270         struct rte_mempool_ops *ops;
 271         const char *platform_ops;
 272         struct roc_nix_rq *rq;
 273         struct roc_nix_cq *cq;
 274         uint16_t first_skip;
 275         int rc = -EINVAL;
 276         size_t rxq_sz;
 277
 278         /* Sanity checks */
 279         if (rx_conf->rx_deferred_start == 1) {
 280                 plt_err("Deferred Rx start is not supported");
 281                 goto fail;
 282         }
 283
 284         platform_ops = rte_mbuf_platform_mempool_ops();
 285         /* This driver needs cnxk_npa mempool ops to work */
 286         ops = rte_mempool_get_ops(mp->ops_index);
 287         if (strncmp(ops->name, platform_ops, RTE_MEMPOOL_OPS_NAMESIZE)) {
 288                 plt_err("mempool ops should be of cnxk_npa type");
 289                 goto fail;
 290         }
 291
 292         if (mp->pool_id == 0) {
 293                 plt_err("Invalid pool_id");
 294                 goto fail;
 295         }
 296
 297         /* Free memory prior to re-allocation if needed */
 298         if (eth_dev->data->rx_queues[qid] != NULL) {
 299                 const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
 300
 301                 plt_nix_dbg("Freeing memory prior to re-allocation %d", qid);
 302                 dev_ops->rx_queue_release(eth_dev->data->rx_queues[qid]);
 303                 eth_dev->data->rx_queues[qid] = NULL;
 304         }
 305
 306         /* Setup ROC CQ */
 307         cq = &dev->cqs[qid];
 308         cq->qid = qid;
 309         cq->nb_desc = nb_desc;
 310         rc = roc_nix_cq_init(&dev->nix, cq);
 311         if (rc) {
 312                 plt_err("Failed to init roc cq for rq=%d, rc=%d", qid, rc);
 313                 goto fail;
 314         }
 315
 316         /* Setup ROC RQ */
 317         rq = &dev->rqs[qid];
 318         rq->qid = qid;
 319         rq->aura_handle = mp->pool_id;
 320         rq->flow_tag_width = 32;
 321         rq->sso_ena = false;
 322
 323         /* Calculate first mbuf skip */
 324         first_skip = (sizeof(struct rte_mbuf));
 325         first_skip += RTE_PKTMBUF_HEADROOM;
 326         first_skip += rte_pktmbuf_priv_size(mp);
 327         rq->first_skip = first_skip;
 328         rq->later_skip = sizeof(struct rte_mbuf);
 329         rq->lpb_size = mp->elt_size;
 330
 331         rc = roc_nix_rq_init(&dev->nix, rq, !!eth_dev->data->dev_started);
 332         if (rc) {
 333                 plt_err("Failed to init roc rq for rq=%d, rc=%d", qid, rc);
 334                 goto cq_fini;
 335         }
 336
 337         /* Allocate and setup fast path rx queue */
 338         rc = -ENOMEM;
 339         rxq_sz = sizeof(struct cnxk_eth_rxq_sp) + fp_rx_q_sz;
 340         rxq_sp = plt_zmalloc(rxq_sz, PLT_CACHE_LINE_SIZE);
 341         if (!rxq_sp) {
 342                 plt_err("Failed to alloc rx queue for rq=%d", qid);
 343                 goto rq_fini;
 344         }
 345
 346         /* Setup slow path fields */
 347         rxq_sp->dev = dev;
 348         rxq_sp->qid = qid;
 349         rxq_sp->qconf.conf.rx = *rx_conf;
 350         rxq_sp->qconf.nb_desc = nb_desc;
 351         rxq_sp->qconf.mp = mp;
 352
 353         plt_nix_dbg("rq=%d pool=%s nb_desc=%d->%d", qid, mp->name, nb_desc,
 354                     cq->nb_desc);
 355
 356         /* Store start of fast path area */
 357         eth_dev->data->rx_queues[qid] = rxq_sp + 1;
 358         eth_dev->data->rx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STOPPED;
 359
 360         /* Calculating delta and freq mult between PTP HI clock and tsc.
 361          * These are needed in deriving raw clock value from tsc counter.
 362          * read_clock eth op returns raw clock value.
 363          */
 364         if ((dev->rx_offloads & DEV_RX_OFFLOAD_TIMESTAMP) || dev->ptp_en) {
 365                 rc = cnxk_nix_tsc_convert(dev);
 366                 if (rc) {
 367                         plt_err("Failed to calculate delta and freq mult");
 368                         goto rq_fini;
 369                 }
 370         }
 371
 372         return 0;
 373 rq_fini:
 374         rc |= roc_nix_rq_fini(rq);
 375 cq_fini:
 376         rc |= roc_nix_cq_fini(cq);
 377 fail:
 378         return rc;
 379 }
 380
 381 static void
 382 cnxk_nix_rx_queue_release(void *rxq)
 383 {
 384         struct cnxk_eth_rxq_sp *rxq_sp;
 385         struct cnxk_eth_dev *dev;
 386         struct roc_nix_rq *rq;
 387         struct roc_nix_cq *cq;
 388         uint16_t qid;
 389         int rc;
 390
 391         if (!rxq)
 392                 return;
 393
 394         rxq_sp = cnxk_eth_rxq_to_sp(rxq);
 395         dev = rxq_sp->dev;
 396         qid = rxq_sp->qid;
 397
 398         plt_nix_dbg("Releasing rxq %u", qid);
 399
 400         /* Cleanup ROC RQ */
 401         rq = &dev->rqs[qid];
 402         rc = roc_nix_rq_fini(rq);
 403         if (rc)
 404                 plt_err("Failed to cleanup rq, rc=%d", rc);
 405
 406         /* Cleanup ROC CQ */
 407         cq = &dev->cqs[qid];
 408         rc = roc_nix_cq_fini(cq);
 409         if (rc)
 410                 plt_err("Failed to cleanup cq, rc=%d", rc);
 411
 412         /* Finally free fast path area */
 413         plt_free(rxq_sp);
 414 }
 415
 416 uint32_t
 417 cnxk_rss_ethdev_to_nix(struct cnxk_eth_dev *dev, uint64_t ethdev_rss,
 418                        uint8_t rss_level)
 419 {
 420         uint32_t flow_key_type[RSS_MAX_LEVELS][6] = {
 421                 {FLOW_KEY_TYPE_IPV4, FLOW_KEY_TYPE_IPV6, FLOW_KEY_TYPE_TCP,
 422                  FLOW_KEY_TYPE_UDP, FLOW_KEY_TYPE_SCTP, FLOW_KEY_TYPE_ETH_DMAC},
 423                 {FLOW_KEY_TYPE_INNR_IPV4, FLOW_KEY_TYPE_INNR_IPV6,
 424                  FLOW_KEY_TYPE_INNR_TCP, FLOW_KEY_TYPE_INNR_UDP,
 425                  FLOW_KEY_TYPE_INNR_SCTP, FLOW_KEY_TYPE_INNR_ETH_DMAC},
 426                 {FLOW_KEY_TYPE_IPV4 | FLOW_KEY_TYPE_INNR_IPV4,
 427                  FLOW_KEY_TYPE_IPV6 | FLOW_KEY_TYPE_INNR_IPV6,
 428                  FLOW_KEY_TYPE_TCP | FLOW_KEY_TYPE_INNR_TCP,
 429                  FLOW_KEY_TYPE_UDP | FLOW_KEY_TYPE_INNR_UDP,
 430                  FLOW_KEY_TYPE_SCTP | FLOW_KEY_TYPE_INNR_SCTP,
 431                  FLOW_KEY_TYPE_ETH_DMAC | FLOW_KEY_TYPE_INNR_ETH_DMAC}
 432         };
 433         uint32_t flowkey_cfg = 0;
 434
 435         dev->ethdev_rss_hf = ethdev_rss;
 436
 437         if (ethdev_rss & ETH_RSS_L2_PAYLOAD &&
 438             dev->npc.switch_header_type == ROC_PRIV_FLAGS_LEN_90B) {
 439                 flowkey_cfg |= FLOW_KEY_TYPE_CH_LEN_90B;
 440         }
 441
 442         if (ethdev_rss & ETH_RSS_C_VLAN)
 443                 flowkey_cfg |= FLOW_KEY_TYPE_VLAN;
 444
 445         if (ethdev_rss & ETH_RSS_L3_SRC_ONLY)
 446                 flowkey_cfg |= FLOW_KEY_TYPE_L3_SRC;
 447
 448         if (ethdev_rss & ETH_RSS_L3_DST_ONLY)
 449                 flowkey_cfg |= FLOW_KEY_TYPE_L3_DST;
 450
 451         if (ethdev_rss & ETH_RSS_L4_SRC_ONLY)
 452                 flowkey_cfg |= FLOW_KEY_TYPE_L4_SRC;
 453
 454         if (ethdev_rss & ETH_RSS_L4_DST_ONLY)
 455                 flowkey_cfg |= FLOW_KEY_TYPE_L4_DST;
 456
 457         if (ethdev_rss & RSS_IPV4_ENABLE)
 458                 flowkey_cfg |= flow_key_type[rss_level][RSS_IPV4_INDEX];
 459
 460         if (ethdev_rss & RSS_IPV6_ENABLE)
 461                 flowkey_cfg |= flow_key_type[rss_level][RSS_IPV6_INDEX];
 462
 463         if (ethdev_rss & ETH_RSS_TCP)
 464                 flowkey_cfg |= flow_key_type[rss_level][RSS_TCP_INDEX];
 465
 466         if (ethdev_rss & ETH_RSS_UDP)
 467                 flowkey_cfg |= flow_key_type[rss_level][RSS_UDP_INDEX];
 468
 469         if (ethdev_rss & ETH_RSS_SCTP)
 470                 flowkey_cfg |= flow_key_type[rss_level][RSS_SCTP_INDEX];
 471
 472         if (ethdev_rss & ETH_RSS_L2_PAYLOAD)
 473                 flowkey_cfg |= flow_key_type[rss_level][RSS_DMAC_INDEX];
 474
 475         if (ethdev_rss & RSS_IPV6_EX_ENABLE)
 476                 flowkey_cfg |= FLOW_KEY_TYPE_IPV6_EXT;
 477
 478         if (ethdev_rss & ETH_RSS_PORT)
 479                 flowkey_cfg |= FLOW_KEY_TYPE_PORT;
 480
 481         if (ethdev_rss & ETH_RSS_NVGRE)
 482                 flowkey_cfg |= FLOW_KEY_TYPE_NVGRE;
 483
 484         if (ethdev_rss & ETH_RSS_VXLAN)
 485                 flowkey_cfg |= FLOW_KEY_TYPE_VXLAN;
 486
 487         if (ethdev_rss & ETH_RSS_GENEVE)
 488                 flowkey_cfg |= FLOW_KEY_TYPE_GENEVE;
 489
 490         if (ethdev_rss & ETH_RSS_GTPU)
 491                 flowkey_cfg |= FLOW_KEY_TYPE_GTPU;
 492
 493         return flowkey_cfg;
 494 }
 495
 496 static void
 497 nix_free_queue_mem(struct cnxk_eth_dev *dev)
 498 {
 499         plt_free(dev->rqs);
 500         plt_free(dev->cqs);
 501         plt_free(dev->sqs);
 502         dev->rqs = NULL;
 503         dev->cqs = NULL;
 504         dev->sqs = NULL;
 505 }
 506
 507 static int
 508 nix_rss_default_setup(struct cnxk_eth_dev *dev)
 509 {
 510         struct rte_eth_dev *eth_dev = dev->eth_dev;
 511         uint8_t rss_hash_level;
 512         uint32_t flowkey_cfg;
 513         uint64_t rss_hf;
 514
 515         rss_hf = eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf;
 516         rss_hash_level = ETH_RSS_LEVEL(rss_hf);
 517         if (rss_hash_level)
 518                 rss_hash_level -= 1;
 519
 520         flowkey_cfg = cnxk_rss_ethdev_to_nix(dev, rss_hf, rss_hash_level);
 521         return roc_nix_rss_default_setup(&dev->nix, flowkey_cfg);
 522 }
 523
 524 static int
 525 nix_store_queue_cfg_and_then_release(struct rte_eth_dev *eth_dev)
 526 {
 527         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 528         const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
 529         struct cnxk_eth_qconf *tx_qconf = NULL;
 530         struct cnxk_eth_qconf *rx_qconf = NULL;
 531         struct cnxk_eth_rxq_sp *rxq_sp;
 532         struct cnxk_eth_txq_sp *txq_sp;
 533         int i, nb_rxq, nb_txq;
 534         void **txq, **rxq;
 535
 536         nb_rxq = RTE_MIN(dev->nb_rxq, eth_dev->data->nb_rx_queues);
 537         nb_txq = RTE_MIN(dev->nb_txq, eth_dev->data->nb_tx_queues);
 538
 539         tx_qconf = malloc(nb_txq * sizeof(*tx_qconf));
 540         if (tx_qconf == NULL) {
 541                 plt_err("Failed to allocate memory for tx_qconf");
 542                 goto fail;
 543         }
 544
 545         rx_qconf = malloc(nb_rxq * sizeof(*rx_qconf));
 546         if (rx_qconf == NULL) {
 547                 plt_err("Failed to allocate memory for rx_qconf");
 548                 goto fail;
 549         }
 550
 551         txq = eth_dev->data->tx_queues;
 552         for (i = 0; i < nb_txq; i++) {
 553                 if (txq[i] == NULL) {
 554                         tx_qconf[i].valid = false;
 555                         plt_info("txq[%d] is already released", i);
 556                         continue;
 557                 }
 558                 txq_sp = cnxk_eth_txq_to_sp(txq[i]);
 559                 memcpy(&tx_qconf[i], &txq_sp->qconf, sizeof(*tx_qconf));
 560                 tx_qconf[i].valid = true;
 561                 dev_ops->tx_queue_release(txq[i]);
 562                 eth_dev->data->tx_queues[i] = NULL;
 563         }
 564
 565         rxq = eth_dev->data->rx_queues;
 566         for (i = 0; i < nb_rxq; i++) {
 567                 if (rxq[i] == NULL) {
 568                         rx_qconf[i].valid = false;
 569                         plt_info("rxq[%d] is already released", i);
 570                         continue;
 571                 }
 572                 rxq_sp = cnxk_eth_rxq_to_sp(rxq[i]);
 573                 memcpy(&rx_qconf[i], &rxq_sp->qconf, sizeof(*rx_qconf));
 574                 rx_qconf[i].valid = true;
 575                 dev_ops->rx_queue_release(rxq[i]);
 576                 eth_dev->data->rx_queues[i] = NULL;
 577         }
 578
 579         dev->tx_qconf = tx_qconf;
 580         dev->rx_qconf = rx_qconf;
 581         return 0;
 582
 583 fail:
 584         free(tx_qconf);
 585         free(rx_qconf);
 586         return -ENOMEM;
 587 }
 588
 589 static int
 590 nix_restore_queue_cfg(struct rte_eth_dev *eth_dev)
 591 {
 592         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 593         const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
 594         struct cnxk_eth_qconf *tx_qconf = dev->tx_qconf;
 595         struct cnxk_eth_qconf *rx_qconf = dev->rx_qconf;
 596         int rc, i, nb_rxq, nb_txq;
 597         void **txq, **rxq;
 598
 599         nb_rxq = RTE_MIN(dev->nb_rxq, eth_dev->data->nb_rx_queues);
 600         nb_txq = RTE_MIN(dev->nb_txq, eth_dev->data->nb_tx_queues);
 601
 602         rc = -ENOMEM;
 603         /* Setup tx & rx queues with previous configuration so
 604          * that the queues can be functional in cases like ports
 605          * are started without re configuring queues.
 606          *
 607          * Usual re config sequence is like below:
 608          * port_configure() {
 609          *      if(reconfigure) {
 610          *              queue_release()
 611          *              queue_setup()
 612          *      }
 613          *      queue_configure() {
 614          *              queue_release()
 615          *              queue_setup()
 616          *      }
 617          * }
 618          * port_start()
 619          *
 620          * In some application's control path, queue_configure() would
 621          * NOT be invoked for TXQs/RXQs in port_configure().
 622          * In such cases, queues can be functional after start as the
 623          * queues are already setup in port_configure().
 624          */
 625         for (i = 0; i < nb_txq; i++) {
 626                 if (!tx_qconf[i].valid)
 627                         continue;
 628                 rc = dev_ops->tx_queue_setup(eth_dev, i, tx_qconf[i].nb_desc, 0,
 629                                              &tx_qconf[i].conf.tx);
 630                 if (rc) {
 631                         plt_err("Failed to setup tx queue rc=%d", rc);
 632                         txq = eth_dev->data->tx_queues;
 633                         for (i -= 1; i >= 0; i--)
 634                                 dev_ops->tx_queue_release(txq[i]);
 635                         goto fail;
 636                 }
 637         }
 638
 639         free(tx_qconf);
 640         tx_qconf = NULL;
 641
 642         for (i = 0; i < nb_rxq; i++) {
 643                 if (!rx_qconf[i].valid)
 644                         continue;
 645                 rc = dev_ops->rx_queue_setup(eth_dev, i, rx_qconf[i].nb_desc, 0,
 646                                              &rx_qconf[i].conf.rx,
 647                                              rx_qconf[i].mp);
 648                 if (rc) {
 649                         plt_err("Failed to setup rx queue rc=%d", rc);
 650                         rxq = eth_dev->data->rx_queues;
 651                         for (i -= 1; i >= 0; i--)
 652                                 dev_ops->rx_queue_release(rxq[i]);
 653                         goto tx_queue_release;
 654                 }
 655         }
 656
 657         free(rx_qconf);
 658         rx_qconf = NULL;
 659
 660         return 0;
 661
 662 tx_queue_release:
 663         txq = eth_dev->data->tx_queues;
 664         for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
 665                 dev_ops->tx_queue_release(txq[i]);
 666 fail:
 667         if (tx_qconf)
 668                 free(tx_qconf);
 669         if (rx_qconf)
 670                 free(rx_qconf);
 671
 672         return rc;
 673 }
 674
 675 static uint16_t
 676 nix_eth_nop_burst(void *queue, struct rte_mbuf **mbufs, uint16_t pkts)
 677 {
 678         RTE_SET_USED(queue);
 679         RTE_SET_USED(mbufs);
 680         RTE_SET_USED(pkts);
 681
 682         return 0;
 683 }
 684
 685 static void
 686 nix_set_nop_rxtx_function(struct rte_eth_dev *eth_dev)
 687 {
 688         /* These dummy functions are required for supporting
 689          * some applications which reconfigure queues without
 690          * stopping tx burst and rx burst threads(eg kni app)
 691          * When the queues context is saved, txq/rxqs are released
 692          * which caused app crash since rx/tx burst is still
 693          * on different lcores
 694          */
 695         eth_dev->tx_pkt_burst = nix_eth_nop_burst;
 696         eth_dev->rx_pkt_burst = nix_eth_nop_burst;
 697         rte_mb();
 698 }
 699
 700 static int
 701 nix_lso_tun_fmt_update(struct cnxk_eth_dev *dev)
 702 {
 703         uint8_t udp_tun[ROC_NIX_LSO_TUN_MAX];
 704         uint8_t tun[ROC_NIX_LSO_TUN_MAX];
 705         struct roc_nix *nix = &dev->nix;
 706         int rc;
 707
 708         rc = roc_nix_lso_fmt_get(nix, udp_tun, tun);
 709         if (rc)
 710                 return rc;
 711
 712         dev->lso_tun_fmt = ((uint64_t)tun[ROC_NIX_LSO_TUN_V4V4] |
 713                             (uint64_t)tun[ROC_NIX_LSO_TUN_V4V6] << 8 |
 714                             (uint64_t)tun[ROC_NIX_LSO_TUN_V6V4] << 16 |
 715                             (uint64_t)tun[ROC_NIX_LSO_TUN_V6V6] << 24);
 716
 717         dev->lso_tun_fmt |= ((uint64_t)udp_tun[ROC_NIX_LSO_TUN_V4V4] << 32 |
 718                              (uint64_t)udp_tun[ROC_NIX_LSO_TUN_V4V6] << 40 |
 719                              (uint64_t)udp_tun[ROC_NIX_LSO_TUN_V6V4] << 48 |
 720                              (uint64_t)udp_tun[ROC_NIX_LSO_TUN_V6V6] << 56);
 721         return 0;
 722 }
 723
 724 static int
 725 nix_lso_fmt_setup(struct cnxk_eth_dev *dev)
 726 {
 727         struct roc_nix *nix = &dev->nix;
 728         int rc;
 729
 730         /* Nothing much to do if offload is not enabled */
 731         if (!(dev->tx_offloads &
 732               (DEV_TX_OFFLOAD_TCP_TSO | DEV_TX_OFFLOAD_VXLAN_TNL_TSO |
 733                DEV_TX_OFFLOAD_GENEVE_TNL_TSO | DEV_TX_OFFLOAD_GRE_TNL_TSO)))
 734                 return 0;
 735
 736         /* Setup LSO formats in AF. Its a no-op if other ethdev has
 737          * already set it up
 738          */
 739         rc = roc_nix_lso_fmt_setup(nix);
 740         if (rc)
 741                 return rc;
 742
 743         return nix_lso_tun_fmt_update(dev);
 744 }
 745
 746 int
 747 cnxk_nix_configure(struct rte_eth_dev *eth_dev)
 748 {
 749         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
 750         struct rte_eth_dev_data *data = eth_dev->data;
 751         struct rte_eth_conf *conf = &data->dev_conf;
 752         struct rte_eth_rxmode *rxmode = &conf->rxmode;
 753         struct rte_eth_txmode *txmode = &conf->txmode;
 754         char ea_fmt[RTE_ETHER_ADDR_FMT_SIZE];
 755         struct roc_nix_fc_cfg fc_cfg = {0};
 756         struct roc_nix *nix = &dev->nix;
 757         struct rte_ether_addr *ea;
 758         uint8_t nb_rxq, nb_txq;
 759         uint64_t rx_cfg;
 760         void *qs;
 761         int rc;
 762
 763         rc = -EINVAL;
 764
 765         /* Sanity checks */
 766         if (rte_eal_has_hugepages() == 0) {
 767                 plt_err("Huge page is not configured");
 768                 goto fail_configure;
 769         }
 770
 771         if (conf->dcb_capability_en == 1) {
 772                 plt_err("dcb enable is not supported");
 773                 goto fail_configure;
 774         }
 775
 776         if (conf->fdir_conf.mode != RTE_FDIR_MODE_NONE) {
 777                 plt_err("Flow director is not supported");
 778                 goto fail_configure;
 779         }
 780
 781         if (rxmode->mq_mode != ETH_MQ_RX_NONE &&
 782             rxmode->mq_mode != ETH_MQ_RX_RSS) {
 783                 plt_err("Unsupported mq rx mode %d", rxmode->mq_mode);
 784                 goto fail_configure;
 785         }
 786
 787         if (txmode->mq_mode != ETH_MQ_TX_NONE) {
 788                 plt_err("Unsupported mq tx mode %d", txmode->mq_mode);
 789                 goto fail_configure;
 790         }
 791
 792         /* Free the resources allocated from the previous configure */
 793         if (dev->configured == 1) {
 794                 /* Unregister queue irq's */
 795                 roc_nix_unregister_queue_irqs(nix);
 796
 797                 /* Unregister CQ irqs if present */
 798                 if (eth_dev->data->dev_conf.intr_conf.rxq)
 799                         roc_nix_unregister_cq_irqs(nix);
 800
 801                 /* Set no-op functions */
 802                 nix_set_nop_rxtx_function(eth_dev);
 803                 /* Store queue config for later */
 804                 rc = nix_store_queue_cfg_and_then_release(eth_dev);
 805                 if (rc)
 806                         goto fail_configure;
 807                 roc_nix_tm_fini(nix);
 808                 roc_nix_lf_free(nix);
 809         }
 810
 811         dev->rx_offloads = rxmode->offloads;
 812         dev->tx_offloads = txmode->offloads;
 813
 814         /* Prepare rx cfg */
 815         rx_cfg = ROC_NIX_LF_RX_CFG_DIS_APAD;
 816         if (dev->rx_offloads &
 817             (DEV_RX_OFFLOAD_TCP_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM)) {
 818                 rx_cfg |= ROC_NIX_LF_RX_CFG_CSUM_OL4;
 819                 rx_cfg |= ROC_NIX_LF_RX_CFG_CSUM_IL4;
 820         }
 821         rx_cfg |= (ROC_NIX_LF_RX_CFG_DROP_RE | ROC_NIX_LF_RX_CFG_L2_LEN_ERR |
 822                    ROC_NIX_LF_RX_CFG_LEN_IL4 | ROC_NIX_LF_RX_CFG_LEN_IL3 |
 823                    ROC_NIX_LF_RX_CFG_LEN_OL4 | ROC_NIX_LF_RX_CFG_LEN_OL3);
 824
 825         nb_rxq = RTE_MAX(data->nb_rx_queues, 1);
 826         nb_txq = RTE_MAX(data->nb_tx_queues, 1);
 827
 828         /* Alloc a nix lf */
 829         rc = roc_nix_lf_alloc(nix, nb_rxq, nb_txq, rx_cfg);
 830         if (rc) {
 831                 plt_err("Failed to init nix_lf rc=%d", rc);
 832                 goto fail_configure;
 833         }
 834
 835         dev->npc.channel = roc_nix_get_base_chan(nix);
 836
 837         nb_rxq = data->nb_rx_queues;
 838         nb_txq = data->nb_tx_queues;
 839         rc = -ENOMEM;
 840         if (nb_rxq) {
 841                 /* Allocate memory for roc rq's and cq's */
 842                 qs = plt_zmalloc(sizeof(struct roc_nix_rq) * nb_rxq, 0);
 843                 if (!qs) {
 844                         plt_err("Failed to alloc rqs");
 845                         goto free_nix_lf;
 846                 }
 847                 dev->rqs = qs;
 848
 849                 qs = plt_zmalloc(sizeof(struct roc_nix_cq) * nb_rxq, 0);
 850                 if (!qs) {
 851                         plt_err("Failed to alloc cqs");
 852                         goto free_nix_lf;
 853                 }
 854                 dev->cqs = qs;
 855         }
 856
 857         if (nb_txq) {
 858                 /* Allocate memory for roc sq's */
 859                 qs = plt_zmalloc(sizeof(struct roc_nix_sq) * nb_txq, 0);
 860                 if (!qs) {
 861                         plt_err("Failed to alloc sqs");
 862                         goto free_nix_lf;
 863                 }
 864                 dev->sqs = qs;
 865         }
 866
 867         /* Re-enable NIX LF error interrupts */
 868         roc_nix_err_intr_ena_dis(nix, true);
 869         roc_nix_ras_intr_ena_dis(nix, true);
 870
 871         if (nix->rx_ptp_ena &&
 872             dev->npc.switch_header_type == ROC_PRIV_FLAGS_HIGIG) {
 873                 plt_err("Both PTP and switch header enabled");
 874                 goto free_nix_lf;
 875         }
 876
 877         rc = roc_nix_switch_hdr_set(nix, dev->npc.switch_header_type);
 878         if (rc) {
 879                 plt_err("Failed to enable switch type nix_lf rc=%d", rc);
 880                 goto free_nix_lf;
 881         }
 882
 883         /* Setup LSO if needed */
 884         rc = nix_lso_fmt_setup(dev);
 885         if (rc) {
 886                 plt_err("Failed to setup nix lso format fields, rc=%d", rc);
 887                 goto free_nix_lf;
 888         }
 889
 890         /* Configure RSS */
 891         rc = nix_rss_default_setup(dev);
 892         if (rc) {
 893                 plt_err("Failed to configure rss rc=%d", rc);
 894                 goto free_nix_lf;
 895         }
 896
 897         /* Init the default TM scheduler hierarchy */
 898         rc = roc_nix_tm_init(nix);
 899         if (rc) {
 900                 plt_err("Failed to init traffic manager, rc=%d", rc);
 901                 goto free_nix_lf;
 902         }
 903
 904         rc = roc_nix_tm_hierarchy_enable(nix, ROC_NIX_TM_DEFAULT, false);
 905         if (rc) {
 906                 plt_err("Failed to enable default tm hierarchy, rc=%d", rc);
 907                 goto tm_fini;
 908         }
 909
 910         /* Register queue IRQs */
 911         rc = roc_nix_register_queue_irqs(nix);
 912         if (rc) {
 913                 plt_err("Failed to register queue interrupts rc=%d", rc);
 914                 goto tm_fini;
 915         }
 916
 917         /* Register cq IRQs */
 918         if (eth_dev->data->dev_conf.intr_conf.rxq) {
 919                 if (eth_dev->data->nb_rx_queues > dev->nix.cints) {
 920                         plt_err("Rx interrupt cannot be enabled, rxq > %d",
 921                                 dev->nix.cints);
 922                         goto q_irq_fini;
 923                 }
 924                 /* Rx interrupt feature cannot work with vector mode because,
 925                  * vector mode does not process packets unless min 4 pkts are
 926                  * received, while cq interrupts are generated even for 1 pkt
 927                  * in the CQ.
 928                  */
 929                 dev->scalar_ena = true;
 930
 931                 rc = roc_nix_register_cq_irqs(nix);
 932                 if (rc) {
 933                         plt_err("Failed to register CQ interrupts rc=%d", rc);
 934                         goto q_irq_fini;
 935                 }
 936         }
 937
 938         /* Configure loop back mode */
 939         rc = roc_nix_mac_loopback_enable(nix,
 940                                          eth_dev->data->dev_conf.lpbk_mode);
 941         if (rc) {
 942                 plt_err("Failed to configure cgx loop back mode rc=%d", rc);
 943                 goto cq_fini;
 944         }
 945
 946         /* Init flow control configuration */
 947         fc_cfg.cq_cfg_valid = false;
 948         fc_cfg.rxchan_cfg.enable = true;
 949         rc = roc_nix_fc_config_set(nix, &fc_cfg);
 950         if (rc) {
 951                 plt_err("Failed to initialize flow control rc=%d", rc);
 952                 goto cq_fini;
 953         }
 954
 955         /* Update flow control configuration to PMD */
 956         rc = nix_init_flow_ctrl_config(eth_dev);
 957         if (rc) {
 958                 plt_err("Failed to initialize flow control rc=%d", rc);
 959                 goto cq_fini;
 960         }
 961         /*
 962          * Restore queue config when reconfigure followed by
 963          * reconfigure and no queue configure invoked from application case.
 964          */
 965         if (dev->configured == 1) {
 966                 rc = nix_restore_queue_cfg(eth_dev);
 967                 if (rc)
 968                         goto cq_fini;
 969         }
 970
 971         /* Update the mac address */
 972         ea = eth_dev->data->mac_addrs;
 973         memcpy(ea, dev->mac_addr, RTE_ETHER_ADDR_LEN);
 974         if (rte_is_zero_ether_addr(ea))
 975                 rte_eth_random_addr((uint8_t *)ea);
 976
 977         rte_ether_format_addr(ea_fmt, RTE_ETHER_ADDR_FMT_SIZE, ea);
 978
 979         plt_nix_dbg("Configured port%d mac=%s nb_rxq=%d nb_txq=%d"
 980                     " rx_offloads=0x%" PRIx64 " tx_offloads=0x%" PRIx64 "",
 981                     eth_dev->data->port_id, ea_fmt, nb_rxq, nb_txq,
 982                     dev->rx_offloads, dev->tx_offloads);
 983
 984         /* All good */
 985         dev->configured = 1;
 986         dev->nb_rxq = data->nb_rx_queues;
 987         dev->nb_txq = data->nb_tx_queues;
 988         return 0;
 989
 990 cq_fini:
 991         roc_nix_unregister_cq_irqs(nix);
 992 q_irq_fini:
 993         roc_nix_unregister_queue_irqs(nix);
 994 tm_fini:
 995         roc_nix_tm_fini(nix);
 996 free_nix_lf:
 997         nix_free_queue_mem(dev);
 998         rc |= roc_nix_lf_free(nix);
 999 fail_configure:
1000         dev->configured = 0;
1001         return rc;
1002 }
1003
1004 int
1005 cnxk_nix_tx_queue_start(struct rte_eth_dev *eth_dev, uint16_t qid)
1006 {
1007         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1008         struct rte_eth_dev_data *data = eth_dev->data;
1009         struct roc_nix_sq *sq = &dev->sqs[qid];
1010         int rc = -EINVAL;
1011
1012         if (data->tx_queue_state[qid] == RTE_ETH_QUEUE_STATE_STARTED)
1013                 return 0;
1014
1015         rc = roc_nix_tm_sq_aura_fc(sq, true);
1016         if (rc) {
1017                 plt_err("Failed to enable sq aura fc, txq=%u, rc=%d", qid, rc);
1018                 goto done;
1019         }
1020
1021         data->tx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STARTED;
1022 done:
1023         return rc;
1024 }
1025
1026 int
1027 cnxk_nix_tx_queue_stop(struct rte_eth_dev *eth_dev, uint16_t qid)
1028 {
1029         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1030         struct rte_eth_dev_data *data = eth_dev->data;
1031         struct roc_nix_sq *sq = &dev->sqs[qid];
1032         int rc;
1033
1034         if (data->tx_queue_state[qid] == RTE_ETH_QUEUE_STATE_STOPPED)
1035                 return 0;
1036
1037         rc = roc_nix_tm_sq_aura_fc(sq, false);
1038         if (rc) {
1039                 plt_err("Failed to disable sqb aura fc, txq=%u, rc=%d", qid,
1040                         rc);
1041                 goto done;
1042         }
1043
1044         data->tx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STOPPED;
1045 done:
1046         return rc;
1047 }
1048
1049 static int
1050 cnxk_nix_rx_queue_start(struct rte_eth_dev *eth_dev, uint16_t qid)
1051 {
1052         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1053         struct rte_eth_dev_data *data = eth_dev->data;
1054         struct roc_nix_rq *rq = &dev->rqs[qid];
1055         int rc;
1056
1057         if (data->rx_queue_state[qid] == RTE_ETH_QUEUE_STATE_STARTED)
1058                 return 0;
1059
1060         rc = roc_nix_rq_ena_dis(rq, true);
1061         if (rc) {
1062                 plt_err("Failed to enable rxq=%u, rc=%d", qid, rc);
1063                 goto done;
1064         }
1065
1066         data->rx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STARTED;
1067 done:
1068         return rc;
1069 }
1070
1071 static int
1072 cnxk_nix_rx_queue_stop(struct rte_eth_dev *eth_dev, uint16_t qid)
1073 {
1074         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1075         struct rte_eth_dev_data *data = eth_dev->data;
1076         struct roc_nix_rq *rq = &dev->rqs[qid];
1077         int rc;
1078
1079         if (data->rx_queue_state[qid] == RTE_ETH_QUEUE_STATE_STOPPED)
1080                 return 0;
1081
1082         rc = roc_nix_rq_ena_dis(rq, false);
1083         if (rc) {
1084                 plt_err("Failed to disable rxq=%u, rc=%d", qid, rc);
1085                 goto done;
1086         }
1087
1088         data->rx_queue_state[qid] = RTE_ETH_QUEUE_STATE_STOPPED;
1089 done:
1090         return rc;
1091 }
1092
1093 static int
1094 cnxk_nix_dev_stop(struct rte_eth_dev *eth_dev)
1095 {
1096         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1097         const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
1098         struct rte_mbuf *rx_pkts[32];
1099         struct rte_eth_link link;
1100         int count, i, j, rc;
1101         void *rxq;
1102
1103         /* Disable switch hdr pkind */
1104         roc_nix_switch_hdr_set(&dev->nix, 0);
1105
1106         /* Stop link change events */
1107         if (!roc_nix_is_vf_or_sdp(&dev->nix))
1108                 roc_nix_mac_link_event_start_stop(&dev->nix, false);
1109
1110         /* Disable Rx via NPC */
1111         roc_nix_npc_rx_ena_dis(&dev->nix, false);
1112
1113         /* Stop rx queues and free up pkts pending */
1114         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
1115                 rc = dev_ops->rx_queue_stop(eth_dev, i);
1116                 if (rc)
1117                         continue;
1118
1119                 rxq = eth_dev->data->rx_queues[i];
1120                 count = dev->rx_pkt_burst_no_offload(rxq, rx_pkts, 32);
1121                 while (count) {
1122                         for (j = 0; j < count; j++)
1123                                 rte_pktmbuf_free(rx_pkts[j]);
1124                         count = dev->rx_pkt_burst_no_offload(rxq, rx_pkts, 32);
1125                 }
1126         }
1127
1128         /* Stop tx queues  */
1129         for (i = 0; i < eth_dev->data->nb_tx_queues; i++)
1130                 dev_ops->tx_queue_stop(eth_dev, i);
1131
1132         /* Bring down link status internally */
1133         memset(&link, 0, sizeof(link));
1134         rte_eth_linkstatus_set(eth_dev, &link);
1135
1136         return 0;
1137 }
1138
1139 int
1140 cnxk_nix_dev_start(struct rte_eth_dev *eth_dev)
1141 {
1142         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1143         int rc, i;
1144
1145         if (eth_dev->data->nb_rx_queues != 0 && !dev->ptp_en) {
1146                 rc = nix_recalc_mtu(eth_dev);
1147                 if (rc)
1148                         return rc;
1149         }
1150
1151         /* Start rx queues */
1152         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
1153                 rc = cnxk_nix_rx_queue_start(eth_dev, i);
1154                 if (rc)
1155                         return rc;
1156         }
1157
1158         /* Start tx queues  */
1159         for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
1160                 rc = cnxk_nix_tx_queue_start(eth_dev, i);
1161                 if (rc)
1162                         return rc;
1163         }
1164
1165         /* Update Flow control configuration */
1166         rc = nix_update_flow_ctrl_config(eth_dev);
1167         if (rc) {
1168                 plt_err("Failed to enable flow control. error code(%d)", rc);
1169                 return rc;
1170         }
1171
1172         /* Enable Rx in NPC */
1173         rc = roc_nix_npc_rx_ena_dis(&dev->nix, true);
1174         if (rc) {
1175                 plt_err("Failed to enable NPC rx %d", rc);
1176                 return rc;
1177         }
1178
1179         cnxk_nix_toggle_flag_link_cfg(dev, true);
1180
1181         /* Start link change events */
1182         if (!roc_nix_is_vf_or_sdp(&dev->nix)) {
1183                 rc = roc_nix_mac_link_event_start_stop(&dev->nix, true);
1184                 if (rc) {
1185                         plt_err("Failed to start cgx link event %d", rc);
1186                         goto rx_disable;
1187                 }
1188         }
1189
1190         /* Enable PTP if it is requested by the user or already
1191          * enabled on PF owning this VF
1192          */
1193         memset(&dev->tstamp, 0, sizeof(struct cnxk_timesync_info));
1194         if ((dev->rx_offloads & DEV_RX_OFFLOAD_TIMESTAMP) || dev->ptp_en)
1195                 cnxk_eth_dev_ops.timesync_enable(eth_dev);
1196         else
1197                 cnxk_eth_dev_ops.timesync_disable(eth_dev);
1198
1199         if (dev->rx_offloads & DEV_RX_OFFLOAD_TIMESTAMP) {
1200                 rc = rte_mbuf_dyn_rx_timestamp_register
1201                         (&dev->tstamp.tstamp_dynfield_offset,
1202                          &dev->tstamp.rx_tstamp_dynflag);
1203                 if (rc != 0) {
1204                         plt_err("Failed to register Rx timestamp field/flag");
1205                         goto rx_disable;
1206                 }
1207         }
1208
1209         cnxk_nix_toggle_flag_link_cfg(dev, false);
1210
1211         return 0;
1212
1213 rx_disable:
1214         roc_nix_npc_rx_ena_dis(&dev->nix, false);
1215         cnxk_nix_toggle_flag_link_cfg(dev, false);
1216         return rc;
1217 }
1218
1219 static int cnxk_nix_dev_reset(struct rte_eth_dev *eth_dev);
1220 static int cnxk_nix_dev_close(struct rte_eth_dev *eth_dev);
1221
1222 /* CNXK platform independent eth dev ops */
1223 struct eth_dev_ops cnxk_eth_dev_ops = {
1224         .mtu_set = cnxk_nix_mtu_set,
1225         .mac_addr_add = cnxk_nix_mac_addr_add,
1226         .mac_addr_remove = cnxk_nix_mac_addr_del,
1227         .mac_addr_set = cnxk_nix_mac_addr_set,
1228         .dev_infos_get = cnxk_nix_info_get,
1229         .link_update = cnxk_nix_link_update,
1230         .tx_queue_release = cnxk_nix_tx_queue_release,
1231         .rx_queue_release = cnxk_nix_rx_queue_release,
1232         .dev_stop = cnxk_nix_dev_stop,
1233         .dev_close = cnxk_nix_dev_close,
1234         .dev_reset = cnxk_nix_dev_reset,
1235         .tx_queue_start = cnxk_nix_tx_queue_start,
1236         .rx_queue_start = cnxk_nix_rx_queue_start,
1237         .rx_queue_stop = cnxk_nix_rx_queue_stop,
1238         .dev_supported_ptypes_get = cnxk_nix_supported_ptypes_get,
1239         .promiscuous_enable = cnxk_nix_promisc_enable,
1240         .promiscuous_disable = cnxk_nix_promisc_disable,
1241         .allmulticast_enable = cnxk_nix_allmulticast_enable,
1242         .allmulticast_disable = cnxk_nix_allmulticast_disable,
1243         .rx_burst_mode_get = cnxk_nix_rx_burst_mode_get,
1244         .tx_burst_mode_get = cnxk_nix_tx_burst_mode_get,
1245         .flow_ctrl_get = cnxk_nix_flow_ctrl_get,
1246         .flow_ctrl_set = cnxk_nix_flow_ctrl_set,
1247         .dev_set_link_up = cnxk_nix_set_link_up,
1248         .dev_set_link_down = cnxk_nix_set_link_down,
1249         .get_module_info = cnxk_nix_get_module_info,
1250         .get_module_eeprom = cnxk_nix_get_module_eeprom,
1251         .rx_queue_intr_enable = cnxk_nix_rx_queue_intr_enable,
1252         .rx_queue_intr_disable = cnxk_nix_rx_queue_intr_disable,
1253         .pool_ops_supported = cnxk_nix_pool_ops_supported,
1254         .queue_stats_mapping_set = cnxk_nix_queue_stats_mapping,
1255         .stats_get = cnxk_nix_stats_get,
1256         .stats_reset = cnxk_nix_stats_reset,
1257         .xstats_get = cnxk_nix_xstats_get,
1258         .xstats_get_names = cnxk_nix_xstats_get_names,
1259         .xstats_reset = cnxk_nix_xstats_reset,
1260         .xstats_get_by_id = cnxk_nix_xstats_get_by_id,
1261         .xstats_get_names_by_id = cnxk_nix_xstats_get_names_by_id,
1262         .fw_version_get = cnxk_nix_fw_version_get,
1263         .rxq_info_get = cnxk_nix_rxq_info_get,
1264         .txq_info_get = cnxk_nix_txq_info_get,
1265         .tx_done_cleanup = cnxk_nix_tx_done_cleanup,
1266         .flow_ops_get = cnxk_nix_flow_ops_get,
1267         .get_reg = cnxk_nix_dev_get_reg,
1268         .timesync_read_rx_timestamp = cnxk_nix_timesync_read_rx_timestamp,
1269         .timesync_read_tx_timestamp = cnxk_nix_timesync_read_tx_timestamp,
1270         .timesync_read_time = cnxk_nix_timesync_read_time,
1271         .timesync_write_time = cnxk_nix_timesync_write_time,
1272         .timesync_adjust_time = cnxk_nix_timesync_adjust_time,
1273         .read_clock = cnxk_nix_read_clock,
1274         .reta_update = cnxk_nix_reta_update,
1275         .reta_query = cnxk_nix_reta_query,
1276         .rss_hash_update = cnxk_nix_rss_hash_update,
1277         .rss_hash_conf_get = cnxk_nix_rss_hash_conf_get,
1278         .set_mc_addr_list = cnxk_nix_mc_addr_list_configure,
1279 };
1280
1281 static int
1282 cnxk_eth_dev_init(struct rte_eth_dev *eth_dev)
1283 {
1284         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1285         struct roc_nix *nix = &dev->nix;
1286         struct rte_pci_device *pci_dev;
1287         int rc, max_entries;
1288
1289         eth_dev->dev_ops = &cnxk_eth_dev_ops;
1290
1291         /* For secondary processes, the primary has done all the work */
1292         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1293                 return 0;
1294
1295         pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1296         rte_eth_copy_pci_info(eth_dev, pci_dev);
1297
1298         /* Parse devargs string */
1299         rc = cnxk_ethdev_parse_devargs(eth_dev->device->devargs, dev);
1300         if (rc) {
1301                 plt_err("Failed to parse devargs rc=%d", rc);
1302                 goto error;
1303         }
1304
1305         /* Initialize base roc nix */
1306         nix->pci_dev = pci_dev;
1307         nix->hw_vlan_ins = true;
1308         rc = roc_nix_dev_init(nix);
1309         if (rc) {
1310                 plt_err("Failed to initialize roc nix rc=%d", rc);
1311                 goto error;
1312         }
1313
1314         /* Register up msg callbacks */
1315         roc_nix_mac_link_cb_register(nix, cnxk_eth_dev_link_status_cb);
1316
1317         /* Register up msg callbacks */
1318         roc_nix_mac_link_info_get_cb_register(nix,
1319                                               cnxk_eth_dev_link_status_get_cb);
1320
1321         dev->eth_dev = eth_dev;
1322         dev->configured = 0;
1323         dev->ptype_disable = 0;
1324
1325         /* For vfs, returned max_entries will be 0. but to keep default mac
1326          * address, one entry must be allocated. so setting up to 1.
1327          */
1328         if (roc_nix_is_vf_or_sdp(nix))
1329                 max_entries = 1;
1330         else
1331                 max_entries = roc_nix_mac_max_entries_get(nix);
1332
1333         if (max_entries <= 0) {
1334                 plt_err("Failed to get max entries for mac addr");
1335                 rc = -ENOTSUP;
1336                 goto dev_fini;
1337         }
1338
1339         eth_dev->data->mac_addrs =
1340                 rte_zmalloc("mac_addr", max_entries * RTE_ETHER_ADDR_LEN, 0);
1341         if (eth_dev->data->mac_addrs == NULL) {
1342                 plt_err("Failed to allocate memory for mac addr");
1343                 rc = -ENOMEM;
1344                 goto dev_fini;
1345         }
1346
1347         dev->max_mac_entries = max_entries;
1348         dev->dmac_filter_count = 1;
1349
1350         /* Get mac address */
1351         rc = roc_nix_npc_mac_addr_get(nix, dev->mac_addr);
1352         if (rc) {
1353                 plt_err("Failed to get mac addr, rc=%d", rc);
1354                 goto free_mac_addrs;
1355         }
1356
1357         /* Update the mac address */
1358         memcpy(eth_dev->data->mac_addrs, dev->mac_addr, RTE_ETHER_ADDR_LEN);
1359
1360         if (!roc_nix_is_vf_or_sdp(nix)) {
1361                 /* Sync same MAC address to CGX/RPM table */
1362                 rc = roc_nix_mac_addr_set(nix, dev->mac_addr);
1363                 if (rc) {
1364                         plt_err("Failed to set mac addr, rc=%d", rc);
1365                         goto free_mac_addrs;
1366                 }
1367         }
1368
1369         /* Union of all capabilities supported by CNXK.
1370          * Platform specific capabilities will be
1371          * updated later.
1372          */
1373         dev->rx_offload_capa = nix_get_rx_offload_capa(dev);
1374         dev->tx_offload_capa = nix_get_tx_offload_capa(dev);
1375         dev->speed_capa = nix_get_speed_capa(dev);
1376
1377         /* Initialize roc npc */
1378         dev->npc.roc_nix = nix;
1379         rc = roc_npc_init(&dev->npc);
1380         if (rc)
1381                 goto free_mac_addrs;
1382
1383         plt_nix_dbg("Port=%d pf=%d vf=%d ver=%s hwcap=0x%" PRIx64
1384                     " rxoffload_capa=0x%" PRIx64 " txoffload_capa=0x%" PRIx64,
1385                     eth_dev->data->port_id, roc_nix_get_pf(nix),
1386                     roc_nix_get_vf(nix), CNXK_ETH_DEV_PMD_VERSION, dev->hwcap,
1387                     dev->rx_offload_capa, dev->tx_offload_capa);
1388         return 0;
1389
1390 free_mac_addrs:
1391         rte_free(eth_dev->data->mac_addrs);
1392 dev_fini:
1393         roc_nix_dev_fini(nix);
1394 error:
1395         plt_err("Failed to init nix eth_dev rc=%d", rc);
1396         return rc;
1397 }
1398
1399 static int
1400 cnxk_eth_dev_uninit(struct rte_eth_dev *eth_dev, bool reset)
1401 {
1402         struct cnxk_eth_dev *dev = cnxk_eth_pmd_priv(eth_dev);
1403         const struct eth_dev_ops *dev_ops = eth_dev->dev_ops;
1404         struct roc_nix *nix = &dev->nix;
1405         int rc, i;
1406
1407         /* Nothing to be done for secondary processes */
1408         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1409                 return 0;
1410
1411         /* Clear the flag since we are closing down */
1412         dev->configured = 0;
1413
1414         roc_nix_npc_rx_ena_dis(nix, false);
1415
1416         /* Disable and free rte_flow entries */
1417         roc_npc_fini(&dev->npc);
1418
1419         /* Disable link status events */
1420         roc_nix_mac_link_event_start_stop(nix, false);
1421
1422         /* Unregister the link update op, this is required to stop VFs from
1423          * receiving link status updates on exit path.
1424          */
1425         roc_nix_mac_link_cb_unregister(nix);
1426
1427         /* Free up SQs */
1428         for (i = 0; i < eth_dev->data->nb_tx_queues; i++) {
1429                 dev_ops->tx_queue_release(eth_dev->data->tx_queues[i]);
1430                 eth_dev->data->tx_queues[i] = NULL;
1431         }
1432         eth_dev->data->nb_tx_queues = 0;
1433
1434         /* Free up RQ's and CQ's */
1435         for (i = 0; i < eth_dev->data->nb_rx_queues; i++) {
1436                 dev_ops->rx_queue_release(eth_dev->data->rx_queues[i]);
1437                 eth_dev->data->rx_queues[i] = NULL;
1438         }
1439         eth_dev->data->nb_rx_queues = 0;
1440
1441         /* Free tm resources */
1442         roc_nix_tm_fini(nix);
1443
1444         /* Unregister queue irqs */
1445         roc_nix_unregister_queue_irqs(nix);
1446
1447         /* Unregister cq irqs */
1448         if (eth_dev->data->dev_conf.intr_conf.rxq)
1449                 roc_nix_unregister_cq_irqs(nix);
1450
1451         /* Free ROC RQ's, SQ's and CQ's memory */
1452         nix_free_queue_mem(dev);
1453
1454         /* Free nix lf resources */
1455         rc = roc_nix_lf_free(nix);
1456         if (rc)
1457                 plt_err("Failed to free nix lf, rc=%d", rc);
1458
1459         rte_free(eth_dev->data->mac_addrs);
1460         eth_dev->data->mac_addrs = NULL;
1461
1462         rc = roc_nix_dev_fini(nix);
1463         /* Can be freed later by PMD if NPA LF is in use */
1464         if (rc == -EAGAIN) {
1465                 if (!reset)
1466                         eth_dev->data->dev_private = NULL;
1467                 return 0;
1468         } else if (rc) {
1469                 plt_err("Failed in nix dev fini, rc=%d", rc);
1470         }
1471
1472         return rc;
1473 }
1474
1475 static int
1476 cnxk_nix_dev_close(struct rte_eth_dev *eth_dev)
1477 {
1478         cnxk_eth_dev_uninit(eth_dev, false);
1479         return 0;
1480 }
1481
1482 static int
1483 cnxk_nix_dev_reset(struct rte_eth_dev *eth_dev)
1484 {
1485         int rc;
1486
1487         rc = cnxk_eth_dev_uninit(eth_dev, true);
1488         if (rc)
1489                 return rc;
1490
1491         return cnxk_eth_dev_init(eth_dev);
1492 }
1493
1494 int
1495 cnxk_nix_remove(struct rte_pci_device *pci_dev)
1496 {
1497         struct rte_eth_dev *eth_dev;
1498         struct roc_nix *nix;
1499         int rc = -EINVAL;
1500
1501         eth_dev = rte_eth_dev_allocated(pci_dev->device.name);
1502         if (eth_dev) {
1503                 /* Cleanup eth dev */
1504                 rc = cnxk_eth_dev_uninit(eth_dev, false);
1505                 if (rc)
1506                         return rc;
1507
1508                 rte_eth_dev_release_port(eth_dev);
1509         }
1510
1511         /* Nothing to be done for secondary processes */
1512         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1513                 return 0;
1514
1515         /* Check if this device is hosting common resource */
1516         nix = roc_idev_npa_nix_get();
1517         if (nix->pci_dev != pci_dev)
1518                 return 0;
1519
1520         /* Try nix fini now */
1521         rc = roc_nix_dev_fini(nix);
1522         if (rc == -EAGAIN) {
1523                 plt_info("%s: common resource in use by other devices",
1524                          pci_dev->name);
1525                 goto exit;
1526         } else if (rc) {
1527                 plt_err("Failed in nix dev fini, rc=%d", rc);
1528                 goto exit;
1529         }
1530
1531         /* Free device pointer as rte_ethdev does not have it anymore */
1532         rte_free(nix);
1533 exit:
1534         return rc;
1535 }
1536
1537 int
1538 cnxk_nix_probe(struct rte_pci_driver *pci_drv, struct rte_pci_device *pci_dev)
1539 {
1540         int rc;
1541
1542         RTE_SET_USED(pci_drv);
1543
1544         rc = rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct cnxk_eth_dev),
1545                                            cnxk_eth_dev_init);
1546
1547         /* On error on secondary, recheck if port exists in primary or
1548          * in mid of detach state.
1549          */
1550         if (rte_eal_process_type() != RTE_PROC_PRIMARY && rc)
1551                 if (!rte_eth_dev_allocated(pci_dev->device.name))
1552                         return 0;
1553         return rc;
1554 }