drivers/net/txgbe/txgbe_rxtx.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2015-2020
   3  */
   4
   5 #include <sys/queue.h>
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <stdint.h>
  12 #include <stdarg.h>
  13 #include <unistd.h>
  14 #include <inttypes.h>
  15
  16 #include <rte_byteorder.h>
  17 #include <rte_common.h>
  18 #include <rte_cycles.h>
  19 #include <rte_log.h>
  20 #include <rte_debug.h>
  21 #include <rte_ethdev.h>
  22 #include <rte_ethdev_driver.h>
  23 #include <rte_memzone.h>
  24 #include <rte_atomic.h>
  25 #include <rte_mempool.h>
  26 #include <rte_malloc.h>
  27 #include <rte_mbuf.h>
  28 #include <rte_ether.h>
  29 #include <rte_prefetch.h>
  30 #include <rte_udp.h>
  31 #include <rte_tcp.h>
  32 #include <rte_sctp.h>
  33 #include <rte_string_fns.h>
  34 #include <rte_errno.h>
  35 #include <rte_ip.h>
  36 #include <rte_net.h>
  37
  38 #include "txgbe_logs.h"
  39 #include "base/txgbe.h"
  40 #include "txgbe_ethdev.h"
  41 #include "txgbe_rxtx.h"
  42
  43 #ifdef RTE_LIBRTE_IEEE1588
  44 #define TXGBE_TX_IEEE1588_TMST PKT_TX_IEEE1588_TMST
  45 #else
  46 #define TXGBE_TX_IEEE1588_TMST 0
  47 #endif
  48
  49 /* Bit Mask to indicate what bits required for building TX context */
  50 static const u64 TXGBE_TX_OFFLOAD_MASK = (PKT_TX_IP_CKSUM |
  51                 PKT_TX_OUTER_IPV6 |
  52                 PKT_TX_OUTER_IPV4 |
  53                 PKT_TX_IPV6 |
  54                 PKT_TX_IPV4 |
  55                 PKT_TX_VLAN_PKT |
  56                 PKT_TX_L4_MASK |
  57                 PKT_TX_TCP_SEG |
  58                 PKT_TX_TUNNEL_MASK |
  59                 PKT_TX_OUTER_IP_CKSUM |
  60                 TXGBE_TX_IEEE1588_TMST);
  61
  62 #define TXGBE_TX_OFFLOAD_NOTSUP_MASK \
  63                 (PKT_TX_OFFLOAD_MASK ^ TXGBE_TX_OFFLOAD_MASK)
  64
  65 /*
  66  * Prefetch a cache line into all cache levels.
  67  */
  68 #define rte_txgbe_prefetch(p)   rte_prefetch0(p)
  69
  70 static int
  71 txgbe_is_vf(struct rte_eth_dev *dev)
  72 {
  73         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
  74
  75         switch (hw->mac.type) {
  76         case txgbe_mac_raptor_vf:
  77                 return 1;
  78         default:
  79                 return 0;
  80         }
  81 }
  82
  83 /*********************************************************************
  84  *
  85  *  TX functions
  86  *
  87  **********************************************************************/
  88
  89 /*
  90  * Check for descriptors with their DD bit set and free mbufs.
  91  * Return the total number of buffers freed.
  92  */
  93 static __rte_always_inline int
  94 txgbe_tx_free_bufs(struct txgbe_tx_queue *txq)
  95 {
  96         struct txgbe_tx_entry *txep;
  97         uint32_t status;
  98         int i, nb_free = 0;
  99         struct rte_mbuf *m, *free[RTE_TXGBE_TX_MAX_FREE_BUF_SZ];
 100
 101         /* check DD bit on threshold descriptor */
 102         status = txq->tx_ring[txq->tx_next_dd].dw3;
 103         if (!(status & rte_cpu_to_le_32(TXGBE_TXD_DD))) {
 104                 if (txq->nb_tx_free >> 1 < txq->tx_free_thresh)
 105                         txgbe_set32_masked(txq->tdc_reg_addr,
 106                                 TXGBE_TXCFG_FLUSH, TXGBE_TXCFG_FLUSH);
 107                 return 0;
 108         }
 109
 110         /*
 111          * first buffer to free from S/W ring is at index
 112          * tx_next_dd - (tx_free_thresh-1)
 113          */
 114         txep = &txq->sw_ring[txq->tx_next_dd - (txq->tx_free_thresh - 1)];
 115         for (i = 0; i < txq->tx_free_thresh; ++i, ++txep) {
 116                 /* free buffers one at a time */
 117                 m = rte_pktmbuf_prefree_seg(txep->mbuf);
 118                 txep->mbuf = NULL;
 119
 120                 if (unlikely(m == NULL))
 121                         continue;
 122
 123                 if (nb_free >= RTE_TXGBE_TX_MAX_FREE_BUF_SZ ||
 124                     (nb_free > 0 && m->pool != free[0]->pool)) {
 125                         rte_mempool_put_bulk(free[0]->pool,
 126                                              (void **)free, nb_free);
 127                         nb_free = 0;
 128                 }
 129
 130                 free[nb_free++] = m;
 131         }
 132
 133         if (nb_free > 0)
 134                 rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
 135
 136         /* buffers were freed, update counters */
 137         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + txq->tx_free_thresh);
 138         txq->tx_next_dd = (uint16_t)(txq->tx_next_dd + txq->tx_free_thresh);
 139         if (txq->tx_next_dd >= txq->nb_tx_desc)
 140                 txq->tx_next_dd = (uint16_t)(txq->tx_free_thresh - 1);
 141
 142         return txq->tx_free_thresh;
 143 }
 144
 145 /* Populate 4 descriptors with data from 4 mbufs */
 146 static inline void
 147 tx4(volatile struct txgbe_tx_desc *txdp, struct rte_mbuf **pkts)
 148 {
 149         uint64_t buf_dma_addr;
 150         uint32_t pkt_len;
 151         int i;
 152
 153         for (i = 0; i < 4; ++i, ++txdp, ++pkts) {
 154                 buf_dma_addr = rte_mbuf_data_iova(*pkts);
 155                 pkt_len = (*pkts)->data_len;
 156
 157                 /* write data to descriptor */
 158                 txdp->qw0 = rte_cpu_to_le_64(buf_dma_addr);
 159                 txdp->dw2 = cpu_to_le32(TXGBE_TXD_FLAGS |
 160                                         TXGBE_TXD_DATLEN(pkt_len));
 161                 txdp->dw3 = cpu_to_le32(TXGBE_TXD_PAYLEN(pkt_len));
 162
 163                 rte_prefetch0(&(*pkts)->pool);
 164         }
 165 }
 166
 167 /* Populate 1 descriptor with data from 1 mbuf */
 168 static inline void
 169 tx1(volatile struct txgbe_tx_desc *txdp, struct rte_mbuf **pkts)
 170 {
 171         uint64_t buf_dma_addr;
 172         uint32_t pkt_len;
 173
 174         buf_dma_addr = rte_mbuf_data_iova(*pkts);
 175         pkt_len = (*pkts)->data_len;
 176
 177         /* write data to descriptor */
 178         txdp->qw0 = cpu_to_le64(buf_dma_addr);
 179         txdp->dw2 = cpu_to_le32(TXGBE_TXD_FLAGS |
 180                                 TXGBE_TXD_DATLEN(pkt_len));
 181         txdp->dw3 = cpu_to_le32(TXGBE_TXD_PAYLEN(pkt_len));
 182
 183         rte_prefetch0(&(*pkts)->pool);
 184 }
 185
 186 /*
 187  * Fill H/W descriptor ring with mbuf data.
 188  * Copy mbuf pointers to the S/W ring.
 189  */
 190 static inline void
 191 txgbe_tx_fill_hw_ring(struct txgbe_tx_queue *txq, struct rte_mbuf **pkts,
 192                       uint16_t nb_pkts)
 193 {
 194         volatile struct txgbe_tx_desc *txdp = &txq->tx_ring[txq->tx_tail];
 195         struct txgbe_tx_entry *txep = &txq->sw_ring[txq->tx_tail];
 196         const int N_PER_LOOP = 4;
 197         const int N_PER_LOOP_MASK = N_PER_LOOP - 1;
 198         int mainpart, leftover;
 199         int i, j;
 200
 201         /*
 202          * Process most of the packets in chunks of N pkts.  Any
 203          * leftover packets will get processed one at a time.
 204          */
 205         mainpart = (nb_pkts & ((uint32_t)~N_PER_LOOP_MASK));
 206         leftover = (nb_pkts & ((uint32_t)N_PER_LOOP_MASK));
 207         for (i = 0; i < mainpart; i += N_PER_LOOP) {
 208                 /* Copy N mbuf pointers to the S/W ring */
 209                 for (j = 0; j < N_PER_LOOP; ++j)
 210                         (txep + i + j)->mbuf = *(pkts + i + j);
 211                 tx4(txdp + i, pkts + i);
 212         }
 213
 214         if (unlikely(leftover > 0)) {
 215                 for (i = 0; i < leftover; ++i) {
 216                         (txep + mainpart + i)->mbuf = *(pkts + mainpart + i);
 217                         tx1(txdp + mainpart + i, pkts + mainpart + i);
 218                 }
 219         }
 220 }
 221
 222 static inline uint16_t
 223 tx_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 224              uint16_t nb_pkts)
 225 {
 226         struct txgbe_tx_queue *txq = (struct txgbe_tx_queue *)tx_queue;
 227         uint16_t n = 0;
 228
 229         /*
 230          * Begin scanning the H/W ring for done descriptors when the
 231          * number of available descriptors drops below tx_free_thresh.  For
 232          * each done descriptor, free the associated buffer.
 233          */
 234         if (txq->nb_tx_free < txq->tx_free_thresh)
 235                 txgbe_tx_free_bufs(txq);
 236
 237         /* Only use descriptors that are available */
 238         nb_pkts = (uint16_t)RTE_MIN(txq->nb_tx_free, nb_pkts);
 239         if (unlikely(nb_pkts == 0))
 240                 return 0;
 241
 242         /* Use exactly nb_pkts descriptors */
 243         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_pkts);
 244
 245         /*
 246          * At this point, we know there are enough descriptors in the
 247          * ring to transmit all the packets.  This assumes that each
 248          * mbuf contains a single segment, and that no new offloads
 249          * are expected, which would require a new context descriptor.
 250          */
 251
 252         /*
 253          * See if we're going to wrap-around. If so, handle the top
 254          * of the descriptor ring first, then do the bottom.  If not,
 255          * the processing looks just like the "bottom" part anyway...
 256          */
 257         if ((txq->tx_tail + nb_pkts) > txq->nb_tx_desc) {
 258                 n = (uint16_t)(txq->nb_tx_desc - txq->tx_tail);
 259                 txgbe_tx_fill_hw_ring(txq, tx_pkts, n);
 260                 txq->tx_tail = 0;
 261         }
 262
 263         /* Fill H/W descriptor ring with mbuf data */
 264         txgbe_tx_fill_hw_ring(txq, tx_pkts + n, (uint16_t)(nb_pkts - n));
 265         txq->tx_tail = (uint16_t)(txq->tx_tail + (nb_pkts - n));
 266
 267         /*
 268          * Check for wrap-around. This would only happen if we used
 269          * up to the last descriptor in the ring, no more, no less.
 270          */
 271         if (txq->tx_tail >= txq->nb_tx_desc)
 272                 txq->tx_tail = 0;
 273
 274         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 275                    (uint16_t)txq->port_id, (uint16_t)txq->queue_id,
 276                    (uint16_t)txq->tx_tail, (uint16_t)nb_pkts);
 277
 278         /* update tail pointer */
 279         rte_wmb();
 280         txgbe_set32_relaxed(txq->tdt_reg_addr, txq->tx_tail);
 281
 282         return nb_pkts;
 283 }
 284
 285 uint16_t
 286 txgbe_xmit_pkts_simple(void *tx_queue, struct rte_mbuf **tx_pkts,
 287                        uint16_t nb_pkts)
 288 {
 289         uint16_t nb_tx;
 290
 291         /* Try to transmit at least chunks of TX_MAX_BURST pkts */
 292         if (likely(nb_pkts <= RTE_PMD_TXGBE_TX_MAX_BURST))
 293                 return tx_xmit_pkts(tx_queue, tx_pkts, nb_pkts);
 294
 295         /* transmit more than the max burst, in chunks of TX_MAX_BURST */
 296         nb_tx = 0;
 297         while (nb_pkts) {
 298                 uint16_t ret, n;
 299
 300                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_TXGBE_TX_MAX_BURST);
 301                 ret = tx_xmit_pkts(tx_queue, &tx_pkts[nb_tx], n);
 302                 nb_tx = (uint16_t)(nb_tx + ret);
 303                 nb_pkts = (uint16_t)(nb_pkts - ret);
 304                 if (ret < n)
 305                         break;
 306         }
 307
 308         return nb_tx;
 309 }
 310
 311 static inline void
 312 txgbe_set_xmit_ctx(struct txgbe_tx_queue *txq,
 313                 volatile struct txgbe_tx_ctx_desc *ctx_txd,
 314                 uint64_t ol_flags, union txgbe_tx_offload tx_offload)
 315 {
 316         union txgbe_tx_offload tx_offload_mask;
 317         uint32_t type_tucmd_mlhl;
 318         uint32_t mss_l4len_idx;
 319         uint32_t ctx_idx;
 320         uint32_t vlan_macip_lens;
 321         uint32_t tunnel_seed;
 322
 323         ctx_idx = txq->ctx_curr;
 324         tx_offload_mask.data[0] = 0;
 325         tx_offload_mask.data[1] = 0;
 326
 327         /* Specify which HW CTX to upload. */
 328         mss_l4len_idx = TXGBE_TXD_IDX(ctx_idx);
 329         type_tucmd_mlhl = TXGBE_TXD_CTXT;
 330
 331         tx_offload_mask.ptid |= ~0;
 332         type_tucmd_mlhl |= TXGBE_TXD_PTID(tx_offload.ptid);
 333
 334         /* check if TCP segmentation required for this packet */
 335         if (ol_flags & PKT_TX_TCP_SEG) {
 336                 tx_offload_mask.l2_len |= ~0;
 337                 tx_offload_mask.l3_len |= ~0;
 338                 tx_offload_mask.l4_len |= ~0;
 339                 tx_offload_mask.tso_segsz |= ~0;
 340                 mss_l4len_idx |= TXGBE_TXD_MSS(tx_offload.tso_segsz);
 341                 mss_l4len_idx |= TXGBE_TXD_L4LEN(tx_offload.l4_len);
 342         } else { /* no TSO, check if hardware checksum is needed */
 343                 if (ol_flags & PKT_TX_IP_CKSUM) {
 344                         tx_offload_mask.l2_len |= ~0;
 345                         tx_offload_mask.l3_len |= ~0;
 346                 }
 347
 348                 switch (ol_flags & PKT_TX_L4_MASK) {
 349                 case PKT_TX_UDP_CKSUM:
 350                         mss_l4len_idx |=
 351                                 TXGBE_TXD_L4LEN(sizeof(struct rte_udp_hdr));
 352                         tx_offload_mask.l2_len |= ~0;
 353                         tx_offload_mask.l3_len |= ~0;
 354                         break;
 355                 case PKT_TX_TCP_CKSUM:
 356                         mss_l4len_idx |=
 357                                 TXGBE_TXD_L4LEN(sizeof(struct rte_tcp_hdr));
 358                         tx_offload_mask.l2_len |= ~0;
 359                         tx_offload_mask.l3_len |= ~0;
 360                         break;
 361                 case PKT_TX_SCTP_CKSUM:
 362                         mss_l4len_idx |=
 363                                 TXGBE_TXD_L4LEN(sizeof(struct rte_sctp_hdr));
 364                         tx_offload_mask.l2_len |= ~0;
 365                         tx_offload_mask.l3_len |= ~0;
 366                         break;
 367                 default:
 368                         break;
 369                 }
 370         }
 371
 372         vlan_macip_lens = TXGBE_TXD_IPLEN(tx_offload.l3_len >> 1);
 373
 374         if (ol_flags & PKT_TX_TUNNEL_MASK) {
 375                 tx_offload_mask.outer_tun_len |= ~0;
 376                 tx_offload_mask.outer_l2_len |= ~0;
 377                 tx_offload_mask.outer_l3_len |= ~0;
 378                 tx_offload_mask.l2_len |= ~0;
 379                 tunnel_seed = TXGBE_TXD_ETUNLEN(tx_offload.outer_tun_len >> 1);
 380                 tunnel_seed |= TXGBE_TXD_EIPLEN(tx_offload.outer_l3_len >> 2);
 381
 382                 switch (ol_flags & PKT_TX_TUNNEL_MASK) {
 383                 case PKT_TX_TUNNEL_IPIP:
 384                         /* for non UDP / GRE tunneling, set to 0b */
 385                         break;
 386                 case PKT_TX_TUNNEL_VXLAN:
 387                 case PKT_TX_TUNNEL_GENEVE:
 388                         tunnel_seed |= TXGBE_TXD_ETYPE_UDP;
 389                         break;
 390                 case PKT_TX_TUNNEL_GRE:
 391                         tunnel_seed |= TXGBE_TXD_ETYPE_GRE;
 392                         break;
 393                 default:
 394                         PMD_TX_LOG(ERR, "Tunnel type not supported");
 395                         return;
 396                 }
 397                 vlan_macip_lens |= TXGBE_TXD_MACLEN(tx_offload.outer_l2_len);
 398         } else {
 399                 tunnel_seed = 0;
 400                 vlan_macip_lens |= TXGBE_TXD_MACLEN(tx_offload.l2_len);
 401         }
 402
 403         if (ol_flags & PKT_TX_VLAN_PKT) {
 404                 tx_offload_mask.vlan_tci |= ~0;
 405                 vlan_macip_lens |= TXGBE_TXD_VLAN(tx_offload.vlan_tci);
 406         }
 407
 408         txq->ctx_cache[ctx_idx].flags = ol_flags;
 409         txq->ctx_cache[ctx_idx].tx_offload.data[0] =
 410                 tx_offload_mask.data[0] & tx_offload.data[0];
 411         txq->ctx_cache[ctx_idx].tx_offload.data[1] =
 412                 tx_offload_mask.data[1] & tx_offload.data[1];
 413         txq->ctx_cache[ctx_idx].tx_offload_mask = tx_offload_mask;
 414
 415         ctx_txd->dw0 = rte_cpu_to_le_32(vlan_macip_lens);
 416         ctx_txd->dw1 = rte_cpu_to_le_32(tunnel_seed);
 417         ctx_txd->dw2 = rte_cpu_to_le_32(type_tucmd_mlhl);
 418         ctx_txd->dw3 = rte_cpu_to_le_32(mss_l4len_idx);
 419 }
 420
 421 /*
 422  * Check which hardware context can be used. Use the existing match
 423  * or create a new context descriptor.
 424  */
 425 static inline uint32_t
 426 what_ctx_update(struct txgbe_tx_queue *txq, uint64_t flags,
 427                    union txgbe_tx_offload tx_offload)
 428 {
 429         /* If match with the current used context */
 430         if (likely(txq->ctx_cache[txq->ctx_curr].flags == flags &&
 431                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[0] ==
 432                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[0]
 433                      & tx_offload.data[0])) &&
 434                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[1] ==
 435                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[1]
 436                      & tx_offload.data[1]))))
 437                 return txq->ctx_curr;
 438
 439         /* What if match with the next context  */
 440         txq->ctx_curr ^= 1;
 441         if (likely(txq->ctx_cache[txq->ctx_curr].flags == flags &&
 442                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[0] ==
 443                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[0]
 444                      & tx_offload.data[0])) &&
 445                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[1] ==
 446                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[1]
 447                      & tx_offload.data[1]))))
 448                 return txq->ctx_curr;
 449
 450         /* Mismatch, use the previous context */
 451         return TXGBE_CTX_NUM;
 452 }
 453
 454 static inline uint32_t
 455 tx_desc_cksum_flags_to_olinfo(uint64_t ol_flags)
 456 {
 457         uint32_t tmp = 0;
 458
 459         if ((ol_flags & PKT_TX_L4_MASK) != PKT_TX_L4_NO_CKSUM) {
 460                 tmp |= TXGBE_TXD_CC;
 461                 tmp |= TXGBE_TXD_L4CS;
 462         }
 463         if (ol_flags & PKT_TX_IP_CKSUM) {
 464                 tmp |= TXGBE_TXD_CC;
 465                 tmp |= TXGBE_TXD_IPCS;
 466         }
 467         if (ol_flags & PKT_TX_OUTER_IP_CKSUM) {
 468                 tmp |= TXGBE_TXD_CC;
 469                 tmp |= TXGBE_TXD_EIPCS;
 470         }
 471         if (ol_flags & PKT_TX_TCP_SEG) {
 472                 tmp |= TXGBE_TXD_CC;
 473                 /* implies IPv4 cksum */
 474                 if (ol_flags & PKT_TX_IPV4)
 475                         tmp |= TXGBE_TXD_IPCS;
 476                 tmp |= TXGBE_TXD_L4CS;
 477         }
 478         if (ol_flags & PKT_TX_VLAN_PKT)
 479                 tmp |= TXGBE_TXD_CC;
 480
 481         return tmp;
 482 }
 483
 484 static inline uint32_t
 485 tx_desc_ol_flags_to_cmdtype(uint64_t ol_flags)
 486 {
 487         uint32_t cmdtype = 0;
 488
 489         if (ol_flags & PKT_TX_VLAN_PKT)
 490                 cmdtype |= TXGBE_TXD_VLE;
 491         if (ol_flags & PKT_TX_TCP_SEG)
 492                 cmdtype |= TXGBE_TXD_TSE;
 493         if (ol_flags & PKT_TX_MACSEC)
 494                 cmdtype |= TXGBE_TXD_LINKSEC;
 495         return cmdtype;
 496 }
 497
 498 static inline uint8_t
 499 tx_desc_ol_flags_to_ptid(uint64_t oflags, uint32_t ptype)
 500 {
 501         bool tun;
 502
 503         if (ptype)
 504                 return txgbe_encode_ptype(ptype);
 505
 506         /* Only support flags in TXGBE_TX_OFFLOAD_MASK */
 507         tun = !!(oflags & PKT_TX_TUNNEL_MASK);
 508
 509         /* L2 level */
 510         ptype = RTE_PTYPE_L2_ETHER;
 511         if (oflags & PKT_TX_VLAN)
 512                 ptype |= RTE_PTYPE_L2_ETHER_VLAN;
 513
 514         /* L3 level */
 515         if (oflags & (PKT_TX_OUTER_IPV4 | PKT_TX_OUTER_IP_CKSUM))
 516                 ptype |= RTE_PTYPE_L3_IPV4;
 517         else if (oflags & (PKT_TX_OUTER_IPV6))
 518                 ptype |= RTE_PTYPE_L3_IPV6;
 519
 520         if (oflags & (PKT_TX_IPV4 | PKT_TX_IP_CKSUM))
 521                 ptype |= (tun ? RTE_PTYPE_INNER_L3_IPV4 : RTE_PTYPE_L3_IPV4);
 522         else if (oflags & (PKT_TX_IPV6))
 523                 ptype |= (tun ? RTE_PTYPE_INNER_L3_IPV6 : RTE_PTYPE_L3_IPV6);
 524
 525         /* L4 level */
 526         switch (oflags & (PKT_TX_L4_MASK)) {
 527         case PKT_TX_TCP_CKSUM:
 528                 ptype |= (tun ? RTE_PTYPE_INNER_L4_TCP : RTE_PTYPE_L4_TCP);
 529                 break;
 530         case PKT_TX_UDP_CKSUM:
 531                 ptype |= (tun ? RTE_PTYPE_INNER_L4_UDP : RTE_PTYPE_L4_UDP);
 532                 break;
 533         case PKT_TX_SCTP_CKSUM:
 534                 ptype |= (tun ? RTE_PTYPE_INNER_L4_SCTP : RTE_PTYPE_L4_SCTP);
 535                 break;
 536         }
 537
 538         if (oflags & PKT_TX_TCP_SEG)
 539                 ptype |= (tun ? RTE_PTYPE_INNER_L4_TCP : RTE_PTYPE_L4_TCP);
 540
 541         /* Tunnel */
 542         switch (oflags & PKT_TX_TUNNEL_MASK) {
 543         case PKT_TX_TUNNEL_VXLAN:
 544                 ptype |= RTE_PTYPE_L2_ETHER |
 545                          RTE_PTYPE_L3_IPV4 |
 546                          RTE_PTYPE_TUNNEL_VXLAN;
 547                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 548                 break;
 549         case PKT_TX_TUNNEL_GRE:
 550                 ptype |= RTE_PTYPE_L2_ETHER |
 551                          RTE_PTYPE_L3_IPV4 |
 552                          RTE_PTYPE_TUNNEL_GRE;
 553                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 554                 break;
 555         case PKT_TX_TUNNEL_GENEVE:
 556                 ptype |= RTE_PTYPE_L2_ETHER |
 557                          RTE_PTYPE_L3_IPV4 |
 558                          RTE_PTYPE_TUNNEL_GENEVE;
 559                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 560                 break;
 561         case PKT_TX_TUNNEL_VXLAN_GPE:
 562                 ptype |= RTE_PTYPE_L2_ETHER |
 563                          RTE_PTYPE_L3_IPV4 |
 564                          RTE_PTYPE_TUNNEL_VXLAN_GPE;
 565                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 566                 break;
 567         case PKT_TX_TUNNEL_IPIP:
 568         case PKT_TX_TUNNEL_IP:
 569                 ptype |= RTE_PTYPE_L2_ETHER |
 570                          RTE_PTYPE_L3_IPV4 |
 571                          RTE_PTYPE_TUNNEL_IP;
 572                 break;
 573         }
 574
 575         return txgbe_encode_ptype(ptype);
 576 }
 577
 578 #ifndef DEFAULT_TX_FREE_THRESH
 579 #define DEFAULT_TX_FREE_THRESH 32
 580 #endif
 581
 582 /* Reset transmit descriptors after they have been used */
 583 static inline int
 584 txgbe_xmit_cleanup(struct txgbe_tx_queue *txq)
 585 {
 586         struct txgbe_tx_entry *sw_ring = txq->sw_ring;
 587         volatile struct txgbe_tx_desc *txr = txq->tx_ring;
 588         uint16_t last_desc_cleaned = txq->last_desc_cleaned;
 589         uint16_t nb_tx_desc = txq->nb_tx_desc;
 590         uint16_t desc_to_clean_to;
 591         uint16_t nb_tx_to_clean;
 592         uint32_t status;
 593
 594         /* Determine the last descriptor needing to be cleaned */
 595         desc_to_clean_to = (uint16_t)(last_desc_cleaned + txq->tx_free_thresh);
 596         if (desc_to_clean_to >= nb_tx_desc)
 597                 desc_to_clean_to = (uint16_t)(desc_to_clean_to - nb_tx_desc);
 598
 599         /* Check to make sure the last descriptor to clean is done */
 600         desc_to_clean_to = sw_ring[desc_to_clean_to].last_id;
 601         status = txr[desc_to_clean_to].dw3;
 602         if (!(status & rte_cpu_to_le_32(TXGBE_TXD_DD))) {
 603                 PMD_TX_FREE_LOG(DEBUG,
 604                                 "TX descriptor %4u is not done"
 605                                 "(port=%d queue=%d)",
 606                                 desc_to_clean_to,
 607                                 txq->port_id, txq->queue_id);
 608                 if (txq->nb_tx_free >> 1 < txq->tx_free_thresh)
 609                         txgbe_set32_masked(txq->tdc_reg_addr,
 610                                 TXGBE_TXCFG_FLUSH, TXGBE_TXCFG_FLUSH);
 611                 /* Failed to clean any descriptors, better luck next time */
 612                 return -(1);
 613         }
 614
 615         /* Figure out how many descriptors will be cleaned */
 616         if (last_desc_cleaned > desc_to_clean_to)
 617                 nb_tx_to_clean = (uint16_t)((nb_tx_desc - last_desc_cleaned) +
 618                                                         desc_to_clean_to);
 619         else
 620                 nb_tx_to_clean = (uint16_t)(desc_to_clean_to -
 621                                                 last_desc_cleaned);
 622
 623         PMD_TX_FREE_LOG(DEBUG,
 624                         "Cleaning %4u TX descriptors: %4u to %4u "
 625                         "(port=%d queue=%d)",
 626                         nb_tx_to_clean, last_desc_cleaned, desc_to_clean_to,
 627                         txq->port_id, txq->queue_id);
 628
 629         /*
 630          * The last descriptor to clean is done, so that means all the
 631          * descriptors from the last descriptor that was cleaned
 632          * up to the last descriptor with the RS bit set
 633          * are done. Only reset the threshold descriptor.
 634          */
 635         txr[desc_to_clean_to].dw3 = 0;
 636
 637         /* Update the txq to reflect the last descriptor that was cleaned */
 638         txq->last_desc_cleaned = desc_to_clean_to;
 639         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + nb_tx_to_clean);
 640
 641         /* No Error */
 642         return 0;
 643 }
 644
 645 static inline uint8_t
 646 txgbe_get_tun_len(struct rte_mbuf *mbuf)
 647 {
 648         struct txgbe_genevehdr genevehdr;
 649         const struct txgbe_genevehdr *gh;
 650         uint8_t tun_len;
 651
 652         switch (mbuf->ol_flags & PKT_TX_TUNNEL_MASK) {
 653         case PKT_TX_TUNNEL_IPIP:
 654                 tun_len = 0;
 655                 break;
 656         case PKT_TX_TUNNEL_VXLAN:
 657         case PKT_TX_TUNNEL_VXLAN_GPE:
 658                 tun_len = sizeof(struct txgbe_udphdr)
 659                         + sizeof(struct txgbe_vxlanhdr);
 660                 break;
 661         case PKT_TX_TUNNEL_GRE:
 662                 tun_len = sizeof(struct txgbe_nvgrehdr);
 663                 break;
 664         case PKT_TX_TUNNEL_GENEVE:
 665                 gh = rte_pktmbuf_read(mbuf,
 666                         mbuf->outer_l2_len + mbuf->outer_l3_len,
 667                         sizeof(genevehdr), &genevehdr);
 668                 tun_len = sizeof(struct txgbe_udphdr)
 669                         + sizeof(struct txgbe_genevehdr)
 670                         + (gh->opt_len << 2);
 671                 break;
 672         default:
 673                 tun_len = 0;
 674         }
 675
 676         return tun_len;
 677 }
 678
 679 uint16_t
 680 txgbe_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 681                 uint16_t nb_pkts)
 682 {
 683         struct txgbe_tx_queue *txq;
 684         struct txgbe_tx_entry *sw_ring;
 685         struct txgbe_tx_entry *txe, *txn;
 686         volatile struct txgbe_tx_desc *txr;
 687         volatile struct txgbe_tx_desc *txd;
 688         struct rte_mbuf     *tx_pkt;
 689         struct rte_mbuf     *m_seg;
 690         uint64_t buf_dma_addr;
 691         uint32_t olinfo_status;
 692         uint32_t cmd_type_len;
 693         uint32_t pkt_len;
 694         uint16_t slen;
 695         uint64_t ol_flags;
 696         uint16_t tx_id;
 697         uint16_t tx_last;
 698         uint16_t nb_tx;
 699         uint16_t nb_used;
 700         uint64_t tx_ol_req;
 701         uint32_t ctx = 0;
 702         uint32_t new_ctx;
 703         union txgbe_tx_offload tx_offload;
 704
 705         tx_offload.data[0] = 0;
 706         tx_offload.data[1] = 0;
 707         txq = tx_queue;
 708         sw_ring = txq->sw_ring;
 709         txr     = txq->tx_ring;
 710         tx_id   = txq->tx_tail;
 711         txe = &sw_ring[tx_id];
 712
 713         /* Determine if the descriptor ring needs to be cleaned. */
 714         if (txq->nb_tx_free < txq->tx_free_thresh)
 715                 txgbe_xmit_cleanup(txq);
 716
 717         rte_prefetch0(&txe->mbuf->pool);
 718
 719         /* TX loop */
 720         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
 721                 new_ctx = 0;
 722                 tx_pkt = *tx_pkts++;
 723                 pkt_len = tx_pkt->pkt_len;
 724
 725                 /*
 726                  * Determine how many (if any) context descriptors
 727                  * are needed for offload functionality.
 728                  */
 729                 ol_flags = tx_pkt->ol_flags;
 730
 731                 /* If hardware offload required */
 732                 tx_ol_req = ol_flags & TXGBE_TX_OFFLOAD_MASK;
 733                 if (tx_ol_req) {
 734                         tx_offload.ptid = tx_desc_ol_flags_to_ptid(tx_ol_req,
 735                                         tx_pkt->packet_type);
 736                         tx_offload.l2_len = tx_pkt->l2_len;
 737                         tx_offload.l3_len = tx_pkt->l3_len;
 738                         tx_offload.l4_len = tx_pkt->l4_len;
 739                         tx_offload.vlan_tci = tx_pkt->vlan_tci;
 740                         tx_offload.tso_segsz = tx_pkt->tso_segsz;
 741                         tx_offload.outer_l2_len = tx_pkt->outer_l2_len;
 742                         tx_offload.outer_l3_len = tx_pkt->outer_l3_len;
 743                         tx_offload.outer_tun_len = txgbe_get_tun_len(tx_pkt);
 744
 745                         /* If new context need be built or reuse the exist ctx*/
 746                         ctx = what_ctx_update(txq, tx_ol_req, tx_offload);
 747                         /* Only allocate context descriptor if required */
 748                         new_ctx = (ctx == TXGBE_CTX_NUM);
 749                         ctx = txq->ctx_curr;
 750                 }
 751
 752                 /*
 753                  * Keep track of how many descriptors are used this loop
 754                  * This will always be the number of segments + the number of
 755                  * Context descriptors required to transmit the packet
 756                  */
 757                 nb_used = (uint16_t)(tx_pkt->nb_segs + new_ctx);
 758
 759                 /*
 760                  * The number of descriptors that must be allocated for a
 761                  * packet is the number of segments of that packet, plus 1
 762                  * Context Descriptor for the hardware offload, if any.
 763                  * Determine the last TX descriptor to allocate in the TX ring
 764                  * for the packet, starting from the current position (tx_id)
 765                  * in the ring.
 766                  */
 767                 tx_last = (uint16_t)(tx_id + nb_used - 1);
 768
 769                 /* Circular ring */
 770                 if (tx_last >= txq->nb_tx_desc)
 771                         tx_last = (uint16_t)(tx_last - txq->nb_tx_desc);
 772
 773                 PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u pktlen=%u"
 774                            " tx_first=%u tx_last=%u",
 775                            (uint16_t)txq->port_id,
 776                            (uint16_t)txq->queue_id,
 777                            (uint32_t)pkt_len,
 778                            (uint16_t)tx_id,
 779                            (uint16_t)tx_last);
 780
 781                 /*
 782                  * Make sure there are enough TX descriptors available to
 783                  * transmit the entire packet.
 784                  * nb_used better be less than or equal to txq->tx_free_thresh
 785                  */
 786                 if (nb_used > txq->nb_tx_free) {
 787                         PMD_TX_FREE_LOG(DEBUG,
 788                                         "Not enough free TX descriptors "
 789                                         "nb_used=%4u nb_free=%4u "
 790                                         "(port=%d queue=%d)",
 791                                         nb_used, txq->nb_tx_free,
 792                                         txq->port_id, txq->queue_id);
 793
 794                         if (txgbe_xmit_cleanup(txq) != 0) {
 795                                 /* Could not clean any descriptors */
 796                                 if (nb_tx == 0)
 797                                         return 0;
 798                                 goto end_of_tx;
 799                         }
 800
 801                         /* nb_used better be <= txq->tx_free_thresh */
 802                         if (unlikely(nb_used > txq->tx_free_thresh)) {
 803                                 PMD_TX_FREE_LOG(DEBUG,
 804                                         "The number of descriptors needed to "
 805                                         "transmit the packet exceeds the "
 806                                         "RS bit threshold. This will impact "
 807                                         "performance."
 808                                         "nb_used=%4u nb_free=%4u "
 809                                         "tx_free_thresh=%4u. "
 810                                         "(port=%d queue=%d)",
 811                                         nb_used, txq->nb_tx_free,
 812                                         txq->tx_free_thresh,
 813                                         txq->port_id, txq->queue_id);
 814                                 /*
 815                                  * Loop here until there are enough TX
 816                                  * descriptors or until the ring cannot be
 817                                  * cleaned.
 818                                  */
 819                                 while (nb_used > txq->nb_tx_free) {
 820                                         if (txgbe_xmit_cleanup(txq) != 0) {
 821                                                 /*
 822                                                  * Could not clean any
 823                                                  * descriptors
 824                                                  */
 825                                                 if (nb_tx == 0)
 826                                                         return 0;
 827                                                 goto end_of_tx;
 828                                         }
 829                                 }
 830                         }
 831                 }
 832
 833                 /*
 834                  * By now there are enough free TX descriptors to transmit
 835                  * the packet.
 836                  */
 837
 838                 /*
 839                  * Set common flags of all TX Data Descriptors.
 840                  *
 841                  * The following bits must be set in all Data Descriptors:
 842                  *   - TXGBE_TXD_DTYP_DATA
 843                  *   - TXGBE_TXD_DCMD_DEXT
 844                  *
 845                  * The following bits must be set in the first Data Descriptor
 846                  * and are ignored in the other ones:
 847                  *   - TXGBE_TXD_DCMD_IFCS
 848                  *   - TXGBE_TXD_MAC_1588
 849                  *   - TXGBE_TXD_DCMD_VLE
 850                  *
 851                  * The following bits must only be set in the last Data
 852                  * Descriptor:
 853                  *   - TXGBE_TXD_CMD_EOP
 854                  *
 855                  * The following bits can be set in any Data Descriptor, but
 856                  * are only set in the last Data Descriptor:
 857                  *   - TXGBE_TXD_CMD_RS
 858                  */
 859                 cmd_type_len = TXGBE_TXD_FCS;
 860
 861 #ifdef RTE_LIBRTE_IEEE1588
 862                 if (ol_flags & PKT_TX_IEEE1588_TMST)
 863                         cmd_type_len |= TXGBE_TXD_1588;
 864 #endif
 865
 866                 olinfo_status = 0;
 867                 if (tx_ol_req) {
 868                         if (ol_flags & PKT_TX_TCP_SEG) {
 869                                 /* when TSO is on, paylen in descriptor is the
 870                                  * not the packet len but the tcp payload len
 871                                  */
 872                                 pkt_len -= (tx_offload.l2_len +
 873                                         tx_offload.l3_len + tx_offload.l4_len);
 874                                 pkt_len -=
 875                                         (tx_pkt->ol_flags & PKT_TX_TUNNEL_MASK)
 876                                         ? tx_offload.outer_l2_len +
 877                                           tx_offload.outer_l3_len : 0;
 878                         }
 879
 880                         /*
 881                          * Setup the TX Advanced Context Descriptor if required
 882                          */
 883                         if (new_ctx) {
 884                                 volatile struct txgbe_tx_ctx_desc *ctx_txd;
 885
 886                                 ctx_txd = (volatile struct txgbe_tx_ctx_desc *)
 887                                     &txr[tx_id];
 888
 889                                 txn = &sw_ring[txe->next_id];
 890                                 rte_prefetch0(&txn->mbuf->pool);
 891
 892                                 if (txe->mbuf != NULL) {
 893                                         rte_pktmbuf_free_seg(txe->mbuf);
 894                                         txe->mbuf = NULL;
 895                                 }
 896
 897                                 txgbe_set_xmit_ctx(txq, ctx_txd, tx_ol_req,
 898                                         tx_offload);
 899
 900                                 txe->last_id = tx_last;
 901                                 tx_id = txe->next_id;
 902                                 txe = txn;
 903                         }
 904
 905                         /*
 906                          * Setup the TX Advanced Data Descriptor,
 907                          * This path will go through
 908                          * whatever new/reuse the context descriptor
 909                          */
 910                         cmd_type_len  |= tx_desc_ol_flags_to_cmdtype(ol_flags);
 911                         olinfo_status |=
 912                                 tx_desc_cksum_flags_to_olinfo(ol_flags);
 913                         olinfo_status |= TXGBE_TXD_IDX(ctx);
 914                 }
 915
 916                 olinfo_status |= TXGBE_TXD_PAYLEN(pkt_len);
 917
 918                 m_seg = tx_pkt;
 919                 do {
 920                         txd = &txr[tx_id];
 921                         txn = &sw_ring[txe->next_id];
 922                         rte_prefetch0(&txn->mbuf->pool);
 923
 924                         if (txe->mbuf != NULL)
 925                                 rte_pktmbuf_free_seg(txe->mbuf);
 926                         txe->mbuf = m_seg;
 927
 928                         /*
 929                          * Set up Transmit Data Descriptor.
 930                          */
 931                         slen = m_seg->data_len;
 932                         buf_dma_addr = rte_mbuf_data_iova(m_seg);
 933                         txd->qw0 = rte_cpu_to_le_64(buf_dma_addr);
 934                         txd->dw2 = rte_cpu_to_le_32(cmd_type_len | slen);
 935                         txd->dw3 = rte_cpu_to_le_32(olinfo_status);
 936                         txe->last_id = tx_last;
 937                         tx_id = txe->next_id;
 938                         txe = txn;
 939                         m_seg = m_seg->next;
 940                 } while (m_seg != NULL);
 941
 942                 /*
 943                  * The last packet data descriptor needs End Of Packet (EOP)
 944                  */
 945                 cmd_type_len |= TXGBE_TXD_EOP;
 946                 txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_used);
 947
 948                 txd->dw2 |= rte_cpu_to_le_32(cmd_type_len);
 949         }
 950
 951 end_of_tx:
 952
 953         rte_wmb();
 954
 955         /*
 956          * Set the Transmit Descriptor Tail (TDT)
 957          */
 958         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 959                    (uint16_t)txq->port_id, (uint16_t)txq->queue_id,
 960                    (uint16_t)tx_id, (uint16_t)nb_tx);
 961         txgbe_set32_relaxed(txq->tdt_reg_addr, tx_id);
 962         txq->tx_tail = tx_id;
 963
 964         return nb_tx;
 965 }
 966
 967 /*********************************************************************
 968  *
 969  *  TX prep functions
 970  *
 971  **********************************************************************/
 972 uint16_t
 973 txgbe_prep_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
 974 {
 975         int i, ret;
 976         uint64_t ol_flags;
 977         struct rte_mbuf *m;
 978         struct txgbe_tx_queue *txq = (struct txgbe_tx_queue *)tx_queue;
 979
 980         for (i = 0; i < nb_pkts; i++) {
 981                 m = tx_pkts[i];
 982                 ol_flags = m->ol_flags;
 983
 984                 /**
 985                  * Check if packet meets requirements for number of segments
 986                  *
 987                  * NOTE: for txgbe it's always (40 - WTHRESH) for both TSO and
 988                  *       non-TSO
 989                  */
 990
 991                 if (m->nb_segs > TXGBE_TX_MAX_SEG - txq->wthresh) {
 992                         rte_errno = -EINVAL;
 993                         return i;
 994                 }
 995
 996                 if (ol_flags & TXGBE_TX_OFFLOAD_NOTSUP_MASK) {
 997                         rte_errno = -ENOTSUP;
 998                         return i;
 999                 }
1000
1001 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
1002                 ret = rte_validate_tx_offload(m);
1003                 if (ret != 0) {
1004                         rte_errno = ret;
1005                         return i;
1006                 }
1007 #endif
1008                 ret = rte_net_intel_cksum_prepare(m);
1009                 if (ret != 0) {
1010                         rte_errno = ret;
1011                         return i;
1012                 }
1013         }
1014
1015         return i;
1016 }
1017
1018 /*********************************************************************
1019  *
1020  *  RX functions
1021  *
1022  **********************************************************************/
1023 /* @note: fix txgbe_dev_supported_ptypes_get() if any change here. */
1024 static inline uint32_t
1025 txgbe_rxd_pkt_info_to_pkt_type(uint32_t pkt_info, uint16_t ptid_mask)
1026 {
1027         uint16_t ptid = TXGBE_RXD_PTID(pkt_info);
1028
1029         ptid &= ptid_mask;
1030
1031         return txgbe_decode_ptype(ptid);
1032 }
1033
1034 static inline uint64_t
1035 txgbe_rxd_pkt_info_to_pkt_flags(uint32_t pkt_info)
1036 {
1037         static uint64_t ip_rss_types_map[16] __rte_cache_aligned = {
1038                 0, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH,
1039                 0, PKT_RX_RSS_HASH, 0, PKT_RX_RSS_HASH,
1040                 PKT_RX_RSS_HASH, 0, 0, 0,
1041                 0, 0, 0,  PKT_RX_FDIR,
1042         };
1043 #ifdef RTE_LIBRTE_IEEE1588
1044         static uint64_t ip_pkt_etqf_map[8] = {
1045                 0, 0, 0, PKT_RX_IEEE1588_PTP,
1046                 0, 0, 0, 0,
1047         };
1048         int etfid = txgbe_etflt_id(TXGBE_RXD_PTID(pkt_info));
1049         if (likely(-1 != etfid))
1050                 return ip_pkt_etqf_map[etfid] |
1051                        ip_rss_types_map[TXGBE_RXD_RSSTYPE(pkt_info)];
1052         else
1053                 return ip_rss_types_map[TXGBE_RXD_RSSTYPE(pkt_info)];
1054 #else
1055         return ip_rss_types_map[TXGBE_RXD_RSSTYPE(pkt_info)];
1056 #endif
1057 }
1058
1059 static inline uint64_t
1060 rx_desc_status_to_pkt_flags(uint32_t rx_status, uint64_t vlan_flags)
1061 {
1062         uint64_t pkt_flags;
1063
1064         /*
1065          * Check if VLAN present only.
1066          * Do not check whether L3/L4 rx checksum done by NIC or not,
1067          * That can be found from rte_eth_rxmode.offloads flag
1068          */
1069         pkt_flags = (rx_status & TXGBE_RXD_STAT_VLAN &&
1070                      vlan_flags & PKT_RX_VLAN_STRIPPED)
1071                     ? vlan_flags : 0;
1072
1073 #ifdef RTE_LIBRTE_IEEE1588
1074         if (rx_status & TXGBE_RXD_STAT_1588)
1075                 pkt_flags = pkt_flags | PKT_RX_IEEE1588_TMST;
1076 #endif
1077         return pkt_flags;
1078 }
1079
1080 static inline uint64_t
1081 rx_desc_error_to_pkt_flags(uint32_t rx_status)
1082 {
1083         uint64_t pkt_flags = 0;
1084
1085         /* checksum offload can't be disabled */
1086         if (rx_status & TXGBE_RXD_STAT_IPCS) {
1087                 pkt_flags |= (rx_status & TXGBE_RXD_ERR_IPCS
1088                                 ? PKT_RX_IP_CKSUM_BAD : PKT_RX_IP_CKSUM_GOOD);
1089         }
1090
1091         if (rx_status & TXGBE_RXD_STAT_L4CS) {
1092                 pkt_flags |= (rx_status & TXGBE_RXD_ERR_L4CS
1093                                 ? PKT_RX_L4_CKSUM_BAD : PKT_RX_L4_CKSUM_GOOD);
1094         }
1095
1096         if (rx_status & TXGBE_RXD_STAT_EIPCS &&
1097             rx_status & TXGBE_RXD_ERR_EIPCS) {
1098                 pkt_flags |= PKT_RX_EIP_CKSUM_BAD;
1099         }
1100
1101         return pkt_flags;
1102 }
1103
1104 /*
1105  * LOOK_AHEAD defines how many desc statuses to check beyond the
1106  * current descriptor.
1107  * It must be a pound define for optimal performance.
1108  * Do not change the value of LOOK_AHEAD, as the txgbe_rx_scan_hw_ring
1109  * function only works with LOOK_AHEAD=8.
1110  */
1111 #define LOOK_AHEAD 8
1112 #if (LOOK_AHEAD != 8)
1113 #error "PMD TXGBE: LOOK_AHEAD must be 8\n"
1114 #endif
1115 static inline int
1116 txgbe_rx_scan_hw_ring(struct txgbe_rx_queue *rxq)
1117 {
1118         volatile struct txgbe_rx_desc *rxdp;
1119         struct txgbe_rx_entry *rxep;
1120         struct rte_mbuf *mb;
1121         uint16_t pkt_len;
1122         uint64_t pkt_flags;
1123         int nb_dd;
1124         uint32_t s[LOOK_AHEAD];
1125         uint32_t pkt_info[LOOK_AHEAD];
1126         int i, j, nb_rx = 0;
1127         uint32_t status;
1128
1129         /* get references to current descriptor and S/W ring entry */
1130         rxdp = &rxq->rx_ring[rxq->rx_tail];
1131         rxep = &rxq->sw_ring[rxq->rx_tail];
1132
1133         status = rxdp->qw1.lo.status;
1134         /* check to make sure there is at least 1 packet to receive */
1135         if (!(status & rte_cpu_to_le_32(TXGBE_RXD_STAT_DD)))
1136                 return 0;
1137
1138         /*
1139          * Scan LOOK_AHEAD descriptors at a time to determine which descriptors
1140          * reference packets that are ready to be received.
1141          */
1142         for (i = 0; i < RTE_PMD_TXGBE_RX_MAX_BURST;
1143              i += LOOK_AHEAD, rxdp += LOOK_AHEAD, rxep += LOOK_AHEAD) {
1144                 /* Read desc statuses backwards to avoid race condition */
1145                 for (j = 0; j < LOOK_AHEAD; j++)
1146                         s[j] = rte_le_to_cpu_32(rxdp[j].qw1.lo.status);
1147
1148                 rte_smp_rmb();
1149
1150                 /* Compute how many status bits were set */
1151                 for (nb_dd = 0; nb_dd < LOOK_AHEAD &&
1152                                 (s[nb_dd] & TXGBE_RXD_STAT_DD); nb_dd++)
1153                         ;
1154
1155                 for (j = 0; j < nb_dd; j++)
1156                         pkt_info[j] = rte_le_to_cpu_32(rxdp[j].qw0.dw0);
1157
1158                 nb_rx += nb_dd;
1159
1160                 /* Translate descriptor info to mbuf format */
1161                 for (j = 0; j < nb_dd; ++j) {
1162                         mb = rxep[j].mbuf;
1163                         pkt_len = rte_le_to_cpu_16(rxdp[j].qw1.hi.len) -
1164                                   rxq->crc_len;
1165                         mb->data_len = pkt_len;
1166                         mb->pkt_len = pkt_len;
1167                         mb->vlan_tci = rte_le_to_cpu_16(rxdp[j].qw1.hi.tag);
1168
1169                         /* convert descriptor fields to rte mbuf flags */
1170                         pkt_flags = rx_desc_status_to_pkt_flags(s[j],
1171                                         rxq->vlan_flags);
1172                         pkt_flags |= rx_desc_error_to_pkt_flags(s[j]);
1173                         pkt_flags |=
1174                                 txgbe_rxd_pkt_info_to_pkt_flags(pkt_info[j]);
1175                         mb->ol_flags = pkt_flags;
1176                         mb->packet_type =
1177                                 txgbe_rxd_pkt_info_to_pkt_type(pkt_info[j],
1178                                 rxq->pkt_type_mask);
1179
1180                         if (likely(pkt_flags & PKT_RX_RSS_HASH))
1181                                 mb->hash.rss =
1182                                         rte_le_to_cpu_32(rxdp[j].qw0.dw1);
1183                         else if (pkt_flags & PKT_RX_FDIR) {
1184                                 mb->hash.fdir.hash =
1185                                         rte_le_to_cpu_16(rxdp[j].qw0.hi.csum) &
1186                                         TXGBE_ATR_HASH_MASK;
1187                                 mb->hash.fdir.id =
1188                                         rte_le_to_cpu_16(rxdp[j].qw0.hi.ipid);
1189                         }
1190                 }
1191
1192                 /* Move mbuf pointers from the S/W ring to the stage */
1193                 for (j = 0; j < LOOK_AHEAD; ++j)
1194                         rxq->rx_stage[i + j] = rxep[j].mbuf;
1195
1196                 /* stop if all requested packets could not be received */
1197                 if (nb_dd != LOOK_AHEAD)
1198                         break;
1199         }
1200
1201         /* clear software ring entries so we can cleanup correctly */
1202         for (i = 0; i < nb_rx; ++i)
1203                 rxq->sw_ring[rxq->rx_tail + i].mbuf = NULL;
1204
1205         return nb_rx;
1206 }
1207
1208 static inline int
1209 txgbe_rx_alloc_bufs(struct txgbe_rx_queue *rxq, bool reset_mbuf)
1210 {
1211         volatile struct txgbe_rx_desc *rxdp;
1212         struct txgbe_rx_entry *rxep;
1213         struct rte_mbuf *mb;
1214         uint16_t alloc_idx;
1215         __le64 dma_addr;
1216         int diag, i;
1217
1218         /* allocate buffers in bulk directly into the S/W ring */
1219         alloc_idx = rxq->rx_free_trigger - (rxq->rx_free_thresh - 1);
1220         rxep = &rxq->sw_ring[alloc_idx];
1221         diag = rte_mempool_get_bulk(rxq->mb_pool, (void *)rxep,
1222                                     rxq->rx_free_thresh);
1223         if (unlikely(diag != 0))
1224                 return -ENOMEM;
1225
1226         rxdp = &rxq->rx_ring[alloc_idx];
1227         for (i = 0; i < rxq->rx_free_thresh; ++i) {
1228                 /* populate the static rte mbuf fields */
1229                 mb = rxep[i].mbuf;
1230                 if (reset_mbuf)
1231                         mb->port = rxq->port_id;
1232
1233                 rte_mbuf_refcnt_set(mb, 1);
1234                 mb->data_off = RTE_PKTMBUF_HEADROOM;
1235
1236                 /* populate the descriptors */
1237                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(mb));
1238                 TXGBE_RXD_HDRADDR(&rxdp[i], 0);
1239                 TXGBE_RXD_PKTADDR(&rxdp[i], dma_addr);
1240         }
1241
1242         /* update state of internal queue structure */
1243         rxq->rx_free_trigger = rxq->rx_free_trigger + rxq->rx_free_thresh;
1244         if (rxq->rx_free_trigger >= rxq->nb_rx_desc)
1245                 rxq->rx_free_trigger = rxq->rx_free_thresh - 1;
1246
1247         /* no errors */
1248         return 0;
1249 }
1250
1251 static inline uint16_t
1252 txgbe_rx_fill_from_stage(struct txgbe_rx_queue *rxq, struct rte_mbuf **rx_pkts,
1253                          uint16_t nb_pkts)
1254 {
1255         struct rte_mbuf **stage = &rxq->rx_stage[rxq->rx_next_avail];
1256         int i;
1257
1258         /* how many packets are ready to return? */
1259         nb_pkts = (uint16_t)RTE_MIN(nb_pkts, rxq->rx_nb_avail);
1260
1261         /* copy mbuf pointers to the application's packet list */
1262         for (i = 0; i < nb_pkts; ++i)
1263                 rx_pkts[i] = stage[i];
1264
1265         /* update internal queue state */
1266         rxq->rx_nb_avail = (uint16_t)(rxq->rx_nb_avail - nb_pkts);
1267         rxq->rx_next_avail = (uint16_t)(rxq->rx_next_avail + nb_pkts);
1268
1269         return nb_pkts;
1270 }
1271
1272 static inline uint16_t
1273 txgbe_rx_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1274              uint16_t nb_pkts)
1275 {
1276         struct txgbe_rx_queue *rxq = (struct txgbe_rx_queue *)rx_queue;
1277         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1278         uint16_t nb_rx = 0;
1279
1280         /* Any previously recv'd pkts will be returned from the Rx stage */
1281         if (rxq->rx_nb_avail)
1282                 return txgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1283
1284         /* Scan the H/W ring for packets to receive */
1285         nb_rx = (uint16_t)txgbe_rx_scan_hw_ring(rxq);
1286
1287         /* update internal queue state */
1288         rxq->rx_next_avail = 0;
1289         rxq->rx_nb_avail = nb_rx;
1290         rxq->rx_tail = (uint16_t)(rxq->rx_tail + nb_rx);
1291
1292         /* if required, allocate new buffers to replenish descriptors */
1293         if (rxq->rx_tail > rxq->rx_free_trigger) {
1294                 uint16_t cur_free_trigger = rxq->rx_free_trigger;
1295
1296                 if (txgbe_rx_alloc_bufs(rxq, true) != 0) {
1297                         int i, j;
1298
1299                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1300                                    "queue_id=%u", (uint16_t)rxq->port_id,
1301                                    (uint16_t)rxq->queue_id);
1302
1303                         dev->data->rx_mbuf_alloc_failed +=
1304                                 rxq->rx_free_thresh;
1305
1306                         /*
1307                          * Need to rewind any previous receives if we cannot
1308                          * allocate new buffers to replenish the old ones.
1309                          */
1310                         rxq->rx_nb_avail = 0;
1311                         rxq->rx_tail = (uint16_t)(rxq->rx_tail - nb_rx);
1312                         for (i = 0, j = rxq->rx_tail; i < nb_rx; ++i, ++j)
1313                                 rxq->sw_ring[j].mbuf = rxq->rx_stage[i];
1314
1315                         return 0;
1316                 }
1317
1318                 /* update tail pointer */
1319                 rte_wmb();
1320                 txgbe_set32_relaxed(rxq->rdt_reg_addr, cur_free_trigger);
1321         }
1322
1323         if (rxq->rx_tail >= rxq->nb_rx_desc)
1324                 rxq->rx_tail = 0;
1325
1326         /* received any packets this loop? */
1327         if (rxq->rx_nb_avail)
1328                 return txgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1329
1330         return 0;
1331 }
1332
1333 /* split requests into chunks of size RTE_PMD_TXGBE_RX_MAX_BURST */
1334 uint16_t
1335 txgbe_recv_pkts_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1336                            uint16_t nb_pkts)
1337 {
1338         uint16_t nb_rx;
1339
1340         if (unlikely(nb_pkts == 0))
1341                 return 0;
1342
1343         if (likely(nb_pkts <= RTE_PMD_TXGBE_RX_MAX_BURST))
1344                 return txgbe_rx_recv_pkts(rx_queue, rx_pkts, nb_pkts);
1345
1346         /* request is relatively large, chunk it up */
1347         nb_rx = 0;
1348         while (nb_pkts) {
1349                 uint16_t ret, n;
1350
1351                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_TXGBE_RX_MAX_BURST);
1352                 ret = txgbe_rx_recv_pkts(rx_queue, &rx_pkts[nb_rx], n);
1353                 nb_rx = (uint16_t)(nb_rx + ret);
1354                 nb_pkts = (uint16_t)(nb_pkts - ret);
1355                 if (ret < n)
1356                         break;
1357         }
1358
1359         return nb_rx;
1360 }
1361
1362 uint16_t
1363 txgbe_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1364                 uint16_t nb_pkts)
1365 {
1366         struct txgbe_rx_queue *rxq;
1367         volatile struct txgbe_rx_desc *rx_ring;
1368         volatile struct txgbe_rx_desc *rxdp;
1369         struct txgbe_rx_entry *sw_ring;
1370         struct txgbe_rx_entry *rxe;
1371         struct rte_mbuf *rxm;
1372         struct rte_mbuf *nmb;
1373         struct txgbe_rx_desc rxd;
1374         uint64_t dma_addr;
1375         uint32_t staterr;
1376         uint32_t pkt_info;
1377         uint16_t pkt_len;
1378         uint16_t rx_id;
1379         uint16_t nb_rx;
1380         uint16_t nb_hold;
1381         uint64_t pkt_flags;
1382
1383         nb_rx = 0;
1384         nb_hold = 0;
1385         rxq = rx_queue;
1386         rx_id = rxq->rx_tail;
1387         rx_ring = rxq->rx_ring;
1388         sw_ring = rxq->sw_ring;
1389         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1390         while (nb_rx < nb_pkts) {
1391                 /*
1392                  * The order of operations here is important as the DD status
1393                  * bit must not be read after any other descriptor fields.
1394                  * rx_ring and rxdp are pointing to volatile data so the order
1395                  * of accesses cannot be reordered by the compiler. If they were
1396                  * not volatile, they could be reordered which could lead to
1397                  * using invalid descriptor fields when read from rxd.
1398                  */
1399                 rxdp = &rx_ring[rx_id];
1400                 staterr = rxdp->qw1.lo.status;
1401                 if (!(staterr & rte_cpu_to_le_32(TXGBE_RXD_STAT_DD)))
1402                         break;
1403                 rxd = *rxdp;
1404
1405                 /*
1406                  * End of packet.
1407                  *
1408                  * If the TXGBE_RXD_STAT_EOP flag is not set, the RX packet
1409                  * is likely to be invalid and to be dropped by the various
1410                  * validation checks performed by the network stack.
1411                  *
1412                  * Allocate a new mbuf to replenish the RX ring descriptor.
1413                  * If the allocation fails:
1414                  *    - arrange for that RX descriptor to be the first one
1415                  *      being parsed the next time the receive function is
1416                  *      invoked [on the same queue].
1417                  *
1418                  *    - Stop parsing the RX ring and return immediately.
1419                  *
1420                  * This policy do not drop the packet received in the RX
1421                  * descriptor for which the allocation of a new mbuf failed.
1422                  * Thus, it allows that packet to be later retrieved if
1423                  * mbuf have been freed in the mean time.
1424                  * As a side effect, holding RX descriptors instead of
1425                  * systematically giving them back to the NIC may lead to
1426                  * RX ring exhaustion situations.
1427                  * However, the NIC can gracefully prevent such situations
1428                  * to happen by sending specific "back-pressure" flow control
1429                  * frames to its peer(s).
1430                  */
1431                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1432                            "ext_err_stat=0x%08x pkt_len=%u",
1433                            (uint16_t)rxq->port_id, (uint16_t)rxq->queue_id,
1434                            (uint16_t)rx_id, (uint32_t)staterr,
1435                            (uint16_t)rte_le_to_cpu_16(rxd.qw1.hi.len));
1436
1437                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
1438                 if (nmb == NULL) {
1439                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1440                                    "queue_id=%u", (uint16_t)rxq->port_id,
1441                                    (uint16_t)rxq->queue_id);
1442                         dev->data->rx_mbuf_alloc_failed++;
1443                         break;
1444                 }
1445
1446                 nb_hold++;
1447                 rxe = &sw_ring[rx_id];
1448                 rx_id++;
1449                 if (rx_id == rxq->nb_rx_desc)
1450                         rx_id = 0;
1451
1452                 /* Prefetch next mbuf while processing current one. */
1453                 rte_txgbe_prefetch(sw_ring[rx_id].mbuf);
1454
1455                 /*
1456                  * When next RX descriptor is on a cache-line boundary,
1457                  * prefetch the next 4 RX descriptors and the next 8 pointers
1458                  * to mbufs.
1459                  */
1460                 if ((rx_id & 0x3) == 0) {
1461                         rte_txgbe_prefetch(&rx_ring[rx_id]);
1462                         rte_txgbe_prefetch(&sw_ring[rx_id]);
1463                 }
1464
1465                 rxm = rxe->mbuf;
1466                 rxe->mbuf = nmb;
1467                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
1468                 TXGBE_RXD_HDRADDR(rxdp, 0);
1469                 TXGBE_RXD_PKTADDR(rxdp, dma_addr);
1470
1471                 /*
1472                  * Initialize the returned mbuf.
1473                  * 1) setup generic mbuf fields:
1474                  *    - number of segments,
1475                  *    - next segment,
1476                  *    - packet length,
1477                  *    - RX port identifier.
1478                  * 2) integrate hardware offload data, if any:
1479                  *    - RSS flag & hash,
1480                  *    - IP checksum flag,
1481                  *    - VLAN TCI, if any,
1482                  *    - error flags.
1483                  */
1484                 pkt_len = (uint16_t)(rte_le_to_cpu_16(rxd.qw1.hi.len) -
1485                                       rxq->crc_len);
1486                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
1487                 rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
1488                 rxm->nb_segs = 1;
1489                 rxm->next = NULL;
1490                 rxm->pkt_len = pkt_len;
1491                 rxm->data_len = pkt_len;
1492                 rxm->port = rxq->port_id;
1493
1494                 pkt_info = rte_le_to_cpu_32(rxd.qw0.dw0);
1495                 /* Only valid if PKT_RX_VLAN set in pkt_flags */
1496                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.qw1.hi.tag);
1497
1498                 pkt_flags = rx_desc_status_to_pkt_flags(staterr,
1499                                         rxq->vlan_flags);
1500                 pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1501                 pkt_flags |= txgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1502                 rxm->ol_flags = pkt_flags;
1503                 rxm->packet_type = txgbe_rxd_pkt_info_to_pkt_type(pkt_info,
1504                                                        rxq->pkt_type_mask);
1505
1506                 if (likely(pkt_flags & PKT_RX_RSS_HASH)) {
1507                         rxm->hash.rss = rte_le_to_cpu_32(rxd.qw0.dw1);
1508                 } else if (pkt_flags & PKT_RX_FDIR) {
1509                         rxm->hash.fdir.hash =
1510                                 rte_le_to_cpu_16(rxd.qw0.hi.csum) &
1511                                 TXGBE_ATR_HASH_MASK;
1512                         rxm->hash.fdir.id = rte_le_to_cpu_16(rxd.qw0.hi.ipid);
1513                 }
1514                 /*
1515                  * Store the mbuf address into the next entry of the array
1516                  * of returned packets.
1517                  */
1518                 rx_pkts[nb_rx++] = rxm;
1519         }
1520         rxq->rx_tail = rx_id;
1521
1522         /*
1523          * If the number of free RX descriptors is greater than the RX free
1524          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1525          * register.
1526          * Update the RDT with the value of the last processed RX descriptor
1527          * minus 1, to guarantee that the RDT register is never equal to the
1528          * RDH register, which creates a "full" ring situation from the
1529          * hardware point of view...
1530          */
1531         nb_hold = (uint16_t)(nb_hold + rxq->nb_rx_hold);
1532         if (nb_hold > rxq->rx_free_thresh) {
1533                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1534                            "nb_hold=%u nb_rx=%u",
1535                            (uint16_t)rxq->port_id, (uint16_t)rxq->queue_id,
1536                            (uint16_t)rx_id, (uint16_t)nb_hold,
1537                            (uint16_t)nb_rx);
1538                 rx_id = (uint16_t)((rx_id == 0) ?
1539                                 (rxq->nb_rx_desc - 1) : (rx_id - 1));
1540                 txgbe_set32(rxq->rdt_reg_addr, rx_id);
1541                 nb_hold = 0;
1542         }
1543         rxq->nb_rx_hold = nb_hold;
1544         return nb_rx;
1545 }
1546
1547 /**
1548  * txgbe_fill_cluster_head_buf - fill the first mbuf of the returned packet
1549  *
1550  * Fill the following info in the HEAD buffer of the Rx cluster:
1551  *    - RX port identifier
1552  *    - hardware offload data, if any:
1553  *      - RSS flag & hash
1554  *      - IP checksum flag
1555  *      - VLAN TCI, if any
1556  *      - error flags
1557  * @head HEAD of the packet cluster
1558  * @desc HW descriptor to get data from
1559  * @rxq Pointer to the Rx queue
1560  */
1561 static inline void
1562 txgbe_fill_cluster_head_buf(struct rte_mbuf *head, struct txgbe_rx_desc *desc,
1563                 struct txgbe_rx_queue *rxq, uint32_t staterr)
1564 {
1565         uint32_t pkt_info;
1566         uint64_t pkt_flags;
1567
1568         head->port = rxq->port_id;
1569
1570         /* The vlan_tci field is only valid when PKT_RX_VLAN is
1571          * set in the pkt_flags field.
1572          */
1573         head->vlan_tci = rte_le_to_cpu_16(desc->qw1.hi.tag);
1574         pkt_info = rte_le_to_cpu_32(desc->qw0.dw0);
1575         pkt_flags = rx_desc_status_to_pkt_flags(staterr, rxq->vlan_flags);
1576         pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1577         pkt_flags |= txgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1578         head->ol_flags = pkt_flags;
1579         head->packet_type = txgbe_rxd_pkt_info_to_pkt_type(pkt_info,
1580                                                 rxq->pkt_type_mask);
1581
1582         if (likely(pkt_flags & PKT_RX_RSS_HASH)) {
1583                 head->hash.rss = rte_le_to_cpu_32(desc->qw0.dw1);
1584         } else if (pkt_flags & PKT_RX_FDIR) {
1585                 head->hash.fdir.hash = rte_le_to_cpu_16(desc->qw0.hi.csum)
1586                                 & TXGBE_ATR_HASH_MASK;
1587                 head->hash.fdir.id = rte_le_to_cpu_16(desc->qw0.hi.ipid);
1588         }
1589 }
1590
1591 /**
1592  * txgbe_recv_pkts_lro - receive handler for and LRO case.
1593  *
1594  * @rx_queue Rx queue handle
1595  * @rx_pkts table of received packets
1596  * @nb_pkts size of rx_pkts table
1597  * @bulk_alloc if TRUE bulk allocation is used for a HW ring refilling
1598  *
1599  * Handles the Rx HW ring completions when RSC feature is configured. Uses an
1600  * additional ring of txgbe_rsc_entry's that will hold the relevant RSC info.
1601  *
1602  * We use the same logic as in Linux and in FreeBSD txgbe drivers:
1603  * 1) When non-EOP RSC completion arrives:
1604  *    a) Update the HEAD of the current RSC aggregation cluster with the new
1605  *       segment's data length.
1606  *    b) Set the "next" pointer of the current segment to point to the segment
1607  *       at the NEXTP index.
1608  *    c) Pass the HEAD of RSC aggregation cluster on to the next NEXTP entry
1609  *       in the sw_rsc_ring.
1610  * 2) When EOP arrives we just update the cluster's total length and offload
1611  *    flags and deliver the cluster up to the upper layers. In our case - put it
1612  *    in the rx_pkts table.
1613  *
1614  * Returns the number of received packets/clusters (according to the "bulk
1615  * receive" interface).
1616  */
1617 static inline uint16_t
1618 txgbe_recv_pkts_lro(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts,
1619                     bool bulk_alloc)
1620 {
1621         struct txgbe_rx_queue *rxq = rx_queue;
1622         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1623         volatile struct txgbe_rx_desc *rx_ring = rxq->rx_ring;
1624         struct txgbe_rx_entry *sw_ring = rxq->sw_ring;
1625         struct txgbe_scattered_rx_entry *sw_sc_ring = rxq->sw_sc_ring;
1626         uint16_t rx_id = rxq->rx_tail;
1627         uint16_t nb_rx = 0;
1628         uint16_t nb_hold = rxq->nb_rx_hold;
1629         uint16_t prev_id = rxq->rx_tail;
1630
1631         while (nb_rx < nb_pkts) {
1632                 bool eop;
1633                 struct txgbe_rx_entry *rxe;
1634                 struct txgbe_scattered_rx_entry *sc_entry;
1635                 struct txgbe_scattered_rx_entry *next_sc_entry = NULL;
1636                 struct txgbe_rx_entry *next_rxe = NULL;
1637                 struct rte_mbuf *first_seg;
1638                 struct rte_mbuf *rxm;
1639                 struct rte_mbuf *nmb = NULL;
1640                 struct txgbe_rx_desc rxd;
1641                 uint16_t data_len;
1642                 uint16_t next_id;
1643                 volatile struct txgbe_rx_desc *rxdp;
1644                 uint32_t staterr;
1645
1646 next_desc:
1647                 /*
1648                  * The code in this whole file uses the volatile pointer to
1649                  * ensure the read ordering of the status and the rest of the
1650                  * descriptor fields (on the compiler level only!!!). This is so
1651                  * UGLY - why not to just use the compiler barrier instead? DPDK
1652                  * even has the rte_compiler_barrier() for that.
1653                  *
1654                  * But most importantly this is just wrong because this doesn't
1655                  * ensure memory ordering in a general case at all. For
1656                  * instance, DPDK is supposed to work on Power CPUs where
1657                  * compiler barrier may just not be enough!
1658                  *
1659                  * I tried to write only this function properly to have a
1660                  * starting point (as a part of an LRO/RSC series) but the
1661                  * compiler cursed at me when I tried to cast away the
1662                  * "volatile" from rx_ring (yes, it's volatile too!!!). So, I'm
1663                  * keeping it the way it is for now.
1664                  *
1665                  * The code in this file is broken in so many other places and
1666                  * will just not work on a big endian CPU anyway therefore the
1667                  * lines below will have to be revisited together with the rest
1668                  * of the txgbe PMD.
1669                  *
1670                  * TODO:
1671                  *    - Get rid of "volatile" and let the compiler do its job.
1672                  *    - Use the proper memory barrier (rte_rmb()) to ensure the
1673                  *      memory ordering below.
1674                  */
1675                 rxdp = &rx_ring[rx_id];
1676                 staterr = rte_le_to_cpu_32(rxdp->qw1.lo.status);
1677
1678                 if (!(staterr & TXGBE_RXD_STAT_DD))
1679                         break;
1680
1681                 rxd = *rxdp;
1682
1683                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1684                                   "staterr=0x%x data_len=%u",
1685                            rxq->port_id, rxq->queue_id, rx_id, staterr,
1686                            rte_le_to_cpu_16(rxd.qw1.hi.len));
1687
1688                 if (!bulk_alloc) {
1689                         nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
1690                         if (nmb == NULL) {
1691                                 PMD_RX_LOG(DEBUG, "RX mbuf alloc failed "
1692                                                   "port_id=%u queue_id=%u",
1693                                            rxq->port_id, rxq->queue_id);
1694
1695                                 dev->data->rx_mbuf_alloc_failed++;
1696                                 break;
1697                         }
1698                 } else if (nb_hold > rxq->rx_free_thresh) {
1699                         uint16_t next_rdt = rxq->rx_free_trigger;
1700
1701                         if (!txgbe_rx_alloc_bufs(rxq, false)) {
1702                                 rte_wmb();
1703                                 txgbe_set32_relaxed(rxq->rdt_reg_addr,
1704                                                             next_rdt);
1705                                 nb_hold -= rxq->rx_free_thresh;
1706                         } else {
1707                                 PMD_RX_LOG(DEBUG, "RX bulk alloc failed "
1708                                                   "port_id=%u queue_id=%u",
1709                                            rxq->port_id, rxq->queue_id);
1710
1711                                 dev->data->rx_mbuf_alloc_failed++;
1712                                 break;
1713                         }
1714                 }
1715
1716                 nb_hold++;
1717                 rxe = &sw_ring[rx_id];
1718                 eop = staterr & TXGBE_RXD_STAT_EOP;
1719
1720                 next_id = rx_id + 1;
1721                 if (next_id == rxq->nb_rx_desc)
1722                         next_id = 0;
1723
1724                 /* Prefetch next mbuf while processing current one. */
1725                 rte_txgbe_prefetch(sw_ring[next_id].mbuf);
1726
1727                 /*
1728                  * When next RX descriptor is on a cache-line boundary,
1729                  * prefetch the next 4 RX descriptors and the next 4 pointers
1730                  * to mbufs.
1731                  */
1732                 if ((next_id & 0x3) == 0) {
1733                         rte_txgbe_prefetch(&rx_ring[next_id]);
1734                         rte_txgbe_prefetch(&sw_ring[next_id]);
1735                 }
1736
1737                 rxm = rxe->mbuf;
1738
1739                 if (!bulk_alloc) {
1740                         __le64 dma =
1741                           rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
1742                         /*
1743                          * Update RX descriptor with the physical address of the
1744                          * new data buffer of the new allocated mbuf.
1745                          */
1746                         rxe->mbuf = nmb;
1747
1748                         rxm->data_off = RTE_PKTMBUF_HEADROOM;
1749                         TXGBE_RXD_HDRADDR(rxdp, 0);
1750                         TXGBE_RXD_PKTADDR(rxdp, dma);
1751                 } else {
1752                         rxe->mbuf = NULL;
1753                 }
1754
1755                 /*
1756                  * Set data length & data buffer address of mbuf.
1757                  */
1758                 data_len = rte_le_to_cpu_16(rxd.qw1.hi.len);
1759                 rxm->data_len = data_len;
1760
1761                 if (!eop) {
1762                         uint16_t nextp_id;
1763                         /*
1764                          * Get next descriptor index:
1765                          *  - For RSC it's in the NEXTP field.
1766                          *  - For a scattered packet - it's just a following
1767                          *    descriptor.
1768                          */
1769                         if (TXGBE_RXD_RSCCNT(rxd.qw0.dw0))
1770                                 nextp_id = TXGBE_RXD_NEXTP(staterr);
1771                         else
1772                                 nextp_id = next_id;
1773
1774                         next_sc_entry = &sw_sc_ring[nextp_id];
1775                         next_rxe = &sw_ring[nextp_id];
1776                         rte_txgbe_prefetch(next_rxe);
1777                 }
1778
1779                 sc_entry = &sw_sc_ring[rx_id];
1780                 first_seg = sc_entry->fbuf;
1781                 sc_entry->fbuf = NULL;
1782
1783                 /*
1784                  * If this is the first buffer of the received packet,
1785                  * set the pointer to the first mbuf of the packet and
1786                  * initialize its context.
1787                  * Otherwise, update the total length and the number of segments
1788                  * of the current scattered packet, and update the pointer to
1789                  * the last mbuf of the current packet.
1790                  */
1791                 if (first_seg == NULL) {
1792                         first_seg = rxm;
1793                         first_seg->pkt_len = data_len;
1794                         first_seg->nb_segs = 1;
1795                 } else {
1796                         first_seg->pkt_len += data_len;
1797                         first_seg->nb_segs++;
1798                 }
1799
1800                 prev_id = rx_id;
1801                 rx_id = next_id;
1802
1803                 /*
1804                  * If this is not the last buffer of the received packet, update
1805                  * the pointer to the first mbuf at the NEXTP entry in the
1806                  * sw_sc_ring and continue to parse the RX ring.
1807                  */
1808                 if (!eop && next_rxe) {
1809                         rxm->next = next_rxe->mbuf;
1810                         next_sc_entry->fbuf = first_seg;
1811                         goto next_desc;
1812                 }
1813
1814                 /* Initialize the first mbuf of the returned packet */
1815                 txgbe_fill_cluster_head_buf(first_seg, &rxd, rxq, staterr);
1816
1817                 /*
1818                  * Deal with the case, when HW CRC srip is disabled.
1819                  * That can't happen when LRO is enabled, but still could
1820                  * happen for scattered RX mode.
1821                  */
1822                 first_seg->pkt_len -= rxq->crc_len;
1823                 if (unlikely(rxm->data_len <= rxq->crc_len)) {
1824                         struct rte_mbuf *lp;
1825
1826                         for (lp = first_seg; lp->next != rxm; lp = lp->next)
1827                                 ;
1828
1829                         first_seg->nb_segs--;
1830                         lp->data_len -= rxq->crc_len - rxm->data_len;
1831                         lp->next = NULL;
1832                         rte_pktmbuf_free_seg(rxm);
1833                 } else {
1834                         rxm->data_len -= rxq->crc_len;
1835                 }
1836
1837                 /* Prefetch data of first segment, if configured to do so. */
1838                 rte_packet_prefetch((char *)first_seg->buf_addr +
1839                         first_seg->data_off);
1840
1841                 /*
1842                  * Store the mbuf address into the next entry of the array
1843                  * of returned packets.
1844                  */
1845                 rx_pkts[nb_rx++] = first_seg;
1846         }
1847
1848         /*
1849          * Record index of the next RX descriptor to probe.
1850          */
1851         rxq->rx_tail = rx_id;
1852
1853         /*
1854          * If the number of free RX descriptors is greater than the RX free
1855          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1856          * register.
1857          * Update the RDT with the value of the last processed RX descriptor
1858          * minus 1, to guarantee that the RDT register is never equal to the
1859          * RDH register, which creates a "full" ring situation from the
1860          * hardware point of view...
1861          */
1862         if (!bulk_alloc && nb_hold > rxq->rx_free_thresh) {
1863                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1864                            "nb_hold=%u nb_rx=%u",
1865                            rxq->port_id, rxq->queue_id, rx_id, nb_hold, nb_rx);
1866
1867                 rte_wmb();
1868                 txgbe_set32_relaxed(rxq->rdt_reg_addr, prev_id);
1869                 nb_hold = 0;
1870         }
1871
1872         rxq->nb_rx_hold = nb_hold;
1873         return nb_rx;
1874 }
1875
1876 uint16_t
1877 txgbe_recv_pkts_lro_single_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1878                                  uint16_t nb_pkts)
1879 {
1880         return txgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, false);
1881 }
1882
1883 uint16_t
1884 txgbe_recv_pkts_lro_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1885                                uint16_t nb_pkts)
1886 {
1887         return txgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, true);
1888 }
1889
1890 uint64_t
1891 txgbe_get_rx_queue_offloads(struct rte_eth_dev *dev __rte_unused)
1892 {
1893         return DEV_RX_OFFLOAD_VLAN_STRIP;
1894 }
1895
1896 uint64_t
1897 txgbe_get_rx_port_offloads(struct rte_eth_dev *dev)
1898 {
1899         uint64_t offloads;
1900         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
1901         struct rte_eth_dev_sriov *sriov = &RTE_ETH_DEV_SRIOV(dev);
1902
1903         offloads = DEV_RX_OFFLOAD_IPV4_CKSUM  |
1904                    DEV_RX_OFFLOAD_UDP_CKSUM   |
1905                    DEV_RX_OFFLOAD_TCP_CKSUM   |
1906                    DEV_RX_OFFLOAD_KEEP_CRC    |
1907                    DEV_RX_OFFLOAD_JUMBO_FRAME |
1908                    DEV_RX_OFFLOAD_VLAN_FILTER |
1909                    DEV_RX_OFFLOAD_RSS_HASH |
1910                    DEV_RX_OFFLOAD_SCATTER;
1911
1912         if (!txgbe_is_vf(dev))
1913                 offloads |= (DEV_RX_OFFLOAD_VLAN_FILTER |
1914                              DEV_RX_OFFLOAD_QINQ_STRIP |
1915                              DEV_RX_OFFLOAD_VLAN_EXTEND);
1916
1917         /*
1918          * RSC is only supported by PF devices in a non-SR-IOV
1919          * mode.
1920          */
1921         if (hw->mac.type == txgbe_mac_raptor && !sriov->active)
1922                 offloads |= DEV_RX_OFFLOAD_TCP_LRO;
1923
1924         if (hw->mac.type == txgbe_mac_raptor)
1925                 offloads |= DEV_RX_OFFLOAD_MACSEC_STRIP;
1926
1927         offloads |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM;
1928
1929         return offloads;
1930 }
1931
1932 static void __rte_cold
1933 txgbe_tx_queue_release_mbufs(struct txgbe_tx_queue *txq)
1934 {
1935         unsigned int i;
1936
1937         if (txq->sw_ring != NULL) {
1938                 for (i = 0; i < txq->nb_tx_desc; i++) {
1939                         if (txq->sw_ring[i].mbuf != NULL) {
1940                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
1941                                 txq->sw_ring[i].mbuf = NULL;
1942                         }
1943                 }
1944         }
1945 }
1946
1947 static void __rte_cold
1948 txgbe_tx_free_swring(struct txgbe_tx_queue *txq)
1949 {
1950         if (txq != NULL &&
1951             txq->sw_ring != NULL)
1952                 rte_free(txq->sw_ring);
1953 }
1954
1955 static void __rte_cold
1956 txgbe_tx_queue_release(struct txgbe_tx_queue *txq)
1957 {
1958         if (txq != NULL && txq->ops != NULL) {
1959                 txq->ops->release_mbufs(txq);
1960                 txq->ops->free_swring(txq);
1961                 rte_free(txq);
1962         }
1963 }
1964
1965 void __rte_cold
1966 txgbe_dev_tx_queue_release(void *txq)
1967 {
1968         txgbe_tx_queue_release(txq);
1969 }
1970
1971 /* (Re)set dynamic txgbe_tx_queue fields to defaults */
1972 static void __rte_cold
1973 txgbe_reset_tx_queue(struct txgbe_tx_queue *txq)
1974 {
1975         static const struct txgbe_tx_desc zeroed_desc = {0};
1976         struct txgbe_tx_entry *txe = txq->sw_ring;
1977         uint16_t prev, i;
1978
1979         /* Zero out HW ring memory */
1980         for (i = 0; i < txq->nb_tx_desc; i++)
1981                 txq->tx_ring[i] = zeroed_desc;
1982
1983         /* Initialize SW ring entries */
1984         prev = (uint16_t)(txq->nb_tx_desc - 1);
1985         for (i = 0; i < txq->nb_tx_desc; i++) {
1986                 volatile struct txgbe_tx_desc *txd = &txq->tx_ring[i];
1987
1988                 txd->dw3 = rte_cpu_to_le_32(TXGBE_TXD_DD);
1989                 txe[i].mbuf = NULL;
1990                 txe[i].last_id = i;
1991                 txe[prev].next_id = i;
1992                 prev = i;
1993         }
1994
1995         txq->tx_next_dd = (uint16_t)(txq->tx_free_thresh - 1);
1996         txq->tx_tail = 0;
1997
1998         /*
1999          * Always allow 1 descriptor to be un-allocated to avoid
2000          * a H/W race condition
2001          */
2002         txq->last_desc_cleaned = (uint16_t)(txq->nb_tx_desc - 1);
2003         txq->nb_tx_free = (uint16_t)(txq->nb_tx_desc - 1);
2004         txq->ctx_curr = 0;
2005         memset((void *)&txq->ctx_cache, 0,
2006                 TXGBE_CTX_NUM * sizeof(struct txgbe_ctx_info));
2007 }
2008
2009 static const struct txgbe_txq_ops def_txq_ops = {
2010         .release_mbufs = txgbe_tx_queue_release_mbufs,
2011         .free_swring = txgbe_tx_free_swring,
2012         .reset = txgbe_reset_tx_queue,
2013 };
2014
2015 /* Takes an ethdev and a queue and sets up the tx function to be used based on
2016  * the queue parameters. Used in tx_queue_setup by primary process and then
2017  * in dev_init by secondary process when attaching to an existing ethdev.
2018  */
2019 void __rte_cold
2020 txgbe_set_tx_function(struct rte_eth_dev *dev, struct txgbe_tx_queue *txq)
2021 {
2022         /* Use a simple Tx queue (no offloads, no multi segs) if possible */
2023         if (txq->offloads == 0 &&
2024                         txq->tx_free_thresh >= RTE_PMD_TXGBE_TX_MAX_BURST) {
2025                 PMD_INIT_LOG(DEBUG, "Using simple tx code path");
2026                 dev->tx_pkt_burst = txgbe_xmit_pkts_simple;
2027                 dev->tx_pkt_prepare = NULL;
2028         } else {
2029                 PMD_INIT_LOG(DEBUG, "Using full-featured tx code path");
2030                 PMD_INIT_LOG(DEBUG,
2031                                 " - offloads = 0x%" PRIx64,
2032                                 txq->offloads);
2033                 PMD_INIT_LOG(DEBUG,
2034                                 " - tx_free_thresh = %lu [RTE_PMD_TXGBE_TX_MAX_BURST=%lu]",
2035                                 (unsigned long)txq->tx_free_thresh,
2036                                 (unsigned long)RTE_PMD_TXGBE_TX_MAX_BURST);
2037                 dev->tx_pkt_burst = txgbe_xmit_pkts;
2038                 dev->tx_pkt_prepare = txgbe_prep_pkts;
2039         }
2040 }
2041
2042 uint64_t
2043 txgbe_get_tx_queue_offloads(struct rte_eth_dev *dev)
2044 {
2045         RTE_SET_USED(dev);
2046
2047         return 0;
2048 }
2049
2050 uint64_t
2051 txgbe_get_tx_port_offloads(struct rte_eth_dev *dev)
2052 {
2053         uint64_t tx_offload_capa;
2054
2055         tx_offload_capa =
2056                 DEV_TX_OFFLOAD_VLAN_INSERT |
2057                 DEV_TX_OFFLOAD_IPV4_CKSUM  |
2058                 DEV_TX_OFFLOAD_UDP_CKSUM   |
2059                 DEV_TX_OFFLOAD_TCP_CKSUM   |
2060                 DEV_TX_OFFLOAD_SCTP_CKSUM  |
2061                 DEV_TX_OFFLOAD_TCP_TSO     |
2062                 DEV_TX_OFFLOAD_UDP_TSO     |
2063                 DEV_TX_OFFLOAD_UDP_TNL_TSO      |
2064                 DEV_TX_OFFLOAD_IP_TNL_TSO       |
2065                 DEV_TX_OFFLOAD_VXLAN_TNL_TSO    |
2066                 DEV_TX_OFFLOAD_GRE_TNL_TSO      |
2067                 DEV_TX_OFFLOAD_IPIP_TNL_TSO     |
2068                 DEV_TX_OFFLOAD_GENEVE_TNL_TSO   |
2069                 DEV_TX_OFFLOAD_MULTI_SEGS;
2070
2071         if (!txgbe_is_vf(dev))
2072                 tx_offload_capa |= DEV_TX_OFFLOAD_QINQ_INSERT;
2073
2074         tx_offload_capa |= DEV_TX_OFFLOAD_MACSEC_INSERT;
2075
2076         tx_offload_capa |= DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM;
2077
2078         return tx_offload_capa;
2079 }
2080
2081 int __rte_cold
2082 txgbe_dev_tx_queue_setup(struct rte_eth_dev *dev,
2083                          uint16_t queue_idx,
2084                          uint16_t nb_desc,
2085                          unsigned int socket_id,
2086                          const struct rte_eth_txconf *tx_conf)
2087 {
2088         const struct rte_memzone *tz;
2089         struct txgbe_tx_queue *txq;
2090         struct txgbe_hw     *hw;
2091         uint16_t tx_free_thresh;
2092         uint64_t offloads;
2093
2094         PMD_INIT_FUNC_TRACE();
2095         hw = TXGBE_DEV_HW(dev);
2096
2097         offloads = tx_conf->offloads | dev->data->dev_conf.txmode.offloads;
2098
2099         /*
2100          * Validate number of transmit descriptors.
2101          * It must not exceed hardware maximum, and must be multiple
2102          * of TXGBE_ALIGN.
2103          */
2104         if (nb_desc % TXGBE_TXD_ALIGN != 0 ||
2105             nb_desc > TXGBE_RING_DESC_MAX ||
2106             nb_desc < TXGBE_RING_DESC_MIN) {
2107                 return -EINVAL;
2108         }
2109
2110         /*
2111          * The TX descriptor ring will be cleaned after txq->tx_free_thresh
2112          * descriptors are used or if the number of descriptors required
2113          * to transmit a packet is greater than the number of free TX
2114          * descriptors.
2115          * One descriptor in the TX ring is used as a sentinel to avoid a
2116          * H/W race condition, hence the maximum threshold constraints.
2117          * When set to zero use default values.
2118          */
2119         tx_free_thresh = (uint16_t)((tx_conf->tx_free_thresh) ?
2120                         tx_conf->tx_free_thresh : DEFAULT_TX_FREE_THRESH);
2121         if (tx_free_thresh >= (nb_desc - 3)) {
2122                 PMD_INIT_LOG(ERR, "tx_free_thresh must be less than the number of "
2123                              "TX descriptors minus 3. (tx_free_thresh=%u "
2124                              "port=%d queue=%d)",
2125                              (unsigned int)tx_free_thresh,
2126                              (int)dev->data->port_id, (int)queue_idx);
2127                 return -(EINVAL);
2128         }
2129
2130         if ((nb_desc % tx_free_thresh) != 0) {
2131                 PMD_INIT_LOG(ERR, "tx_free_thresh must be a divisor of the "
2132                              "number of TX descriptors. (tx_free_thresh=%u "
2133                              "port=%d queue=%d)", (unsigned int)tx_free_thresh,
2134                              (int)dev->data->port_id, (int)queue_idx);
2135                 return -(EINVAL);
2136         }
2137
2138         /* Free memory prior to re-allocation if needed... */
2139         if (dev->data->tx_queues[queue_idx] != NULL) {
2140                 txgbe_tx_queue_release(dev->data->tx_queues[queue_idx]);
2141                 dev->data->tx_queues[queue_idx] = NULL;
2142         }
2143
2144         /* First allocate the tx queue data structure */
2145         txq = rte_zmalloc_socket("ethdev TX queue",
2146                                  sizeof(struct txgbe_tx_queue),
2147                                  RTE_CACHE_LINE_SIZE, socket_id);
2148         if (txq == NULL)
2149                 return -ENOMEM;
2150
2151         /*
2152          * Allocate TX ring hardware descriptors. A memzone large enough to
2153          * handle the maximum ring size is allocated in order to allow for
2154          * resizing in later calls to the queue setup function.
2155          */
2156         tz = rte_eth_dma_zone_reserve(dev, "tx_ring", queue_idx,
2157                         sizeof(struct txgbe_tx_desc) * TXGBE_RING_DESC_MAX,
2158                         TXGBE_ALIGN, socket_id);
2159         if (tz == NULL) {
2160                 txgbe_tx_queue_release(txq);
2161                 return -ENOMEM;
2162         }
2163
2164         txq->nb_tx_desc = nb_desc;
2165         txq->tx_free_thresh = tx_free_thresh;
2166         txq->pthresh = tx_conf->tx_thresh.pthresh;
2167         txq->hthresh = tx_conf->tx_thresh.hthresh;
2168         txq->wthresh = tx_conf->tx_thresh.wthresh;
2169         txq->queue_id = queue_idx;
2170         txq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2171                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2172         txq->port_id = dev->data->port_id;
2173         txq->offloads = offloads;
2174         txq->ops = &def_txq_ops;
2175         txq->tx_deferred_start = tx_conf->tx_deferred_start;
2176
2177         /* Modification to set tail pointer for virtual function
2178          * if vf is detected.
2179          */
2180         if (hw->mac.type == txgbe_mac_raptor_vf) {
2181                 txq->tdt_reg_addr = TXGBE_REG_ADDR(hw, TXGBE_TXWP(queue_idx));
2182                 txq->tdc_reg_addr = TXGBE_REG_ADDR(hw, TXGBE_TXCFG(queue_idx));
2183         } else {
2184                 txq->tdt_reg_addr = TXGBE_REG_ADDR(hw,
2185                                                 TXGBE_TXWP(txq->reg_idx));
2186                 txq->tdc_reg_addr = TXGBE_REG_ADDR(hw,
2187                                                 TXGBE_TXCFG(txq->reg_idx));
2188         }
2189
2190         txq->tx_ring_phys_addr = TMZ_PADDR(tz);
2191         txq->tx_ring = (struct txgbe_tx_desc *)TMZ_VADDR(tz);
2192
2193         /* Allocate software ring */
2194         txq->sw_ring = rte_zmalloc_socket("txq->sw_ring",
2195                                 sizeof(struct txgbe_tx_entry) * nb_desc,
2196                                 RTE_CACHE_LINE_SIZE, socket_id);
2197         if (txq->sw_ring == NULL) {
2198                 txgbe_tx_queue_release(txq);
2199                 return -ENOMEM;
2200         }
2201         PMD_INIT_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%" PRIx64,
2202                      txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr);
2203
2204         /* set up scalar TX function as appropriate */
2205         txgbe_set_tx_function(dev, txq);
2206
2207         txq->ops->reset(txq);
2208
2209         dev->data->tx_queues[queue_idx] = txq;
2210
2211         return 0;
2212 }
2213
2214 /**
2215  * txgbe_free_sc_cluster - free the not-yet-completed scattered cluster
2216  *
2217  * The "next" pointer of the last segment of (not-yet-completed) RSC clusters
2218  * in the sw_rsc_ring is not set to NULL but rather points to the next
2219  * mbuf of this RSC aggregation (that has not been completed yet and still
2220  * resides on the HW ring). So, instead of calling for rte_pktmbuf_free() we
2221  * will just free first "nb_segs" segments of the cluster explicitly by calling
2222  * an rte_pktmbuf_free_seg().
2223  *
2224  * @m scattered cluster head
2225  */
2226 static void __rte_cold
2227 txgbe_free_sc_cluster(struct rte_mbuf *m)
2228 {
2229         uint16_t i, nb_segs = m->nb_segs;
2230         struct rte_mbuf *next_seg;
2231
2232         for (i = 0; i < nb_segs; i++) {
2233                 next_seg = m->next;
2234                 rte_pktmbuf_free_seg(m);
2235                 m = next_seg;
2236         }
2237 }
2238
2239 static void __rte_cold
2240 txgbe_rx_queue_release_mbufs(struct txgbe_rx_queue *rxq)
2241 {
2242         unsigned int i;
2243
2244         if (rxq->sw_ring != NULL) {
2245                 for (i = 0; i < rxq->nb_rx_desc; i++) {
2246                         if (rxq->sw_ring[i].mbuf != NULL) {
2247                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
2248                                 rxq->sw_ring[i].mbuf = NULL;
2249                         }
2250                 }
2251                 if (rxq->rx_nb_avail) {
2252                         for (i = 0; i < rxq->rx_nb_avail; ++i) {
2253                                 struct rte_mbuf *mb;
2254
2255                                 mb = rxq->rx_stage[rxq->rx_next_avail + i];
2256                                 rte_pktmbuf_free_seg(mb);
2257                         }
2258                         rxq->rx_nb_avail = 0;
2259                 }
2260         }
2261
2262         if (rxq->sw_sc_ring)
2263                 for (i = 0; i < rxq->nb_rx_desc; i++)
2264                         if (rxq->sw_sc_ring[i].fbuf) {
2265                                 txgbe_free_sc_cluster(rxq->sw_sc_ring[i].fbuf);
2266                                 rxq->sw_sc_ring[i].fbuf = NULL;
2267                         }
2268 }
2269
2270 static void __rte_cold
2271 txgbe_rx_queue_release(struct txgbe_rx_queue *rxq)
2272 {
2273         if (rxq != NULL) {
2274                 txgbe_rx_queue_release_mbufs(rxq);
2275                 rte_free(rxq->sw_ring);
2276                 rte_free(rxq->sw_sc_ring);
2277                 rte_free(rxq);
2278         }
2279 }
2280
2281 void __rte_cold
2282 txgbe_dev_rx_queue_release(void *rxq)
2283 {
2284         txgbe_rx_queue_release(rxq);
2285 }
2286
2287 /*
2288  * Check if Rx Burst Bulk Alloc function can be used.
2289  * Return
2290  *        0: the preconditions are satisfied and the bulk allocation function
2291  *           can be used.
2292  *  -EINVAL: the preconditions are NOT satisfied and the default Rx burst
2293  *           function must be used.
2294  */
2295 static inline int __rte_cold
2296 check_rx_burst_bulk_alloc_preconditions(struct txgbe_rx_queue *rxq)
2297 {
2298         int ret = 0;
2299
2300         /*
2301          * Make sure the following pre-conditions are satisfied:
2302          *   rxq->rx_free_thresh >= RTE_PMD_TXGBE_RX_MAX_BURST
2303          *   rxq->rx_free_thresh < rxq->nb_rx_desc
2304          *   (rxq->nb_rx_desc % rxq->rx_free_thresh) == 0
2305          * Scattered packets are not supported.  This should be checked
2306          * outside of this function.
2307          */
2308         if (!(rxq->rx_free_thresh >= RTE_PMD_TXGBE_RX_MAX_BURST)) {
2309                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2310                              "rxq->rx_free_thresh=%d, "
2311                              "RTE_PMD_TXGBE_RX_MAX_BURST=%d",
2312                              rxq->rx_free_thresh, RTE_PMD_TXGBE_RX_MAX_BURST);
2313                 ret = -EINVAL;
2314         } else if (!(rxq->rx_free_thresh < rxq->nb_rx_desc)) {
2315                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2316                              "rxq->rx_free_thresh=%d, "
2317                              "rxq->nb_rx_desc=%d",
2318                              rxq->rx_free_thresh, rxq->nb_rx_desc);
2319                 ret = -EINVAL;
2320         } else if (!((rxq->nb_rx_desc % rxq->rx_free_thresh) == 0)) {
2321                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2322                              "rxq->nb_rx_desc=%d, "
2323                              "rxq->rx_free_thresh=%d",
2324                              rxq->nb_rx_desc, rxq->rx_free_thresh);
2325                 ret = -EINVAL;
2326         }
2327
2328         return ret;
2329 }
2330
2331 /* Reset dynamic txgbe_rx_queue fields back to defaults */
2332 static void __rte_cold
2333 txgbe_reset_rx_queue(struct txgbe_adapter *adapter, struct txgbe_rx_queue *rxq)
2334 {
2335         static const struct txgbe_rx_desc zeroed_desc = {
2336                                                 {{0}, {0} }, {{0}, {0} } };
2337         unsigned int i;
2338         uint16_t len = rxq->nb_rx_desc;
2339
2340         /*
2341          * By default, the Rx queue setup function allocates enough memory for
2342          * TXGBE_RING_DESC_MAX.  The Rx Burst bulk allocation function requires
2343          * extra memory at the end of the descriptor ring to be zero'd out.
2344          */
2345         if (adapter->rx_bulk_alloc_allowed)
2346                 /* zero out extra memory */
2347                 len += RTE_PMD_TXGBE_RX_MAX_BURST;
2348
2349         /*
2350          * Zero out HW ring memory. Zero out extra memory at the end of
2351          * the H/W ring so look-ahead logic in Rx Burst bulk alloc function
2352          * reads extra memory as zeros.
2353          */
2354         for (i = 0; i < len; i++)
2355                 rxq->rx_ring[i] = zeroed_desc;
2356
2357         /*
2358          * initialize extra software ring entries. Space for these extra
2359          * entries is always allocated
2360          */
2361         memset(&rxq->fake_mbuf, 0x0, sizeof(rxq->fake_mbuf));
2362         for (i = rxq->nb_rx_desc; i < len; ++i)
2363                 rxq->sw_ring[i].mbuf = &rxq->fake_mbuf;
2364
2365         rxq->rx_nb_avail = 0;
2366         rxq->rx_next_avail = 0;
2367         rxq->rx_free_trigger = (uint16_t)(rxq->rx_free_thresh - 1);
2368         rxq->rx_tail = 0;
2369         rxq->nb_rx_hold = 0;
2370         rxq->pkt_first_seg = NULL;
2371         rxq->pkt_last_seg = NULL;
2372 }
2373
2374 int __rte_cold
2375 txgbe_dev_rx_queue_setup(struct rte_eth_dev *dev,
2376                          uint16_t queue_idx,
2377                          uint16_t nb_desc,
2378                          unsigned int socket_id,
2379                          const struct rte_eth_rxconf *rx_conf,
2380                          struct rte_mempool *mp)
2381 {
2382         const struct rte_memzone *rz;
2383         struct txgbe_rx_queue *rxq;
2384         struct txgbe_hw     *hw;
2385         uint16_t len;
2386         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2387         uint64_t offloads;
2388
2389         PMD_INIT_FUNC_TRACE();
2390         hw = TXGBE_DEV_HW(dev);
2391
2392         offloads = rx_conf->offloads | dev->data->dev_conf.rxmode.offloads;
2393
2394         /*
2395          * Validate number of receive descriptors.
2396          * It must not exceed hardware maximum, and must be multiple
2397          * of TXGBE_ALIGN.
2398          */
2399         if (nb_desc % TXGBE_RXD_ALIGN != 0 ||
2400                         nb_desc > TXGBE_RING_DESC_MAX ||
2401                         nb_desc < TXGBE_RING_DESC_MIN) {
2402                 return -EINVAL;
2403         }
2404
2405         /* Free memory prior to re-allocation if needed... */
2406         if (dev->data->rx_queues[queue_idx] != NULL) {
2407                 txgbe_rx_queue_release(dev->data->rx_queues[queue_idx]);
2408                 dev->data->rx_queues[queue_idx] = NULL;
2409         }
2410
2411         /* First allocate the rx queue data structure */
2412         rxq = rte_zmalloc_socket("ethdev RX queue",
2413                                  sizeof(struct txgbe_rx_queue),
2414                                  RTE_CACHE_LINE_SIZE, socket_id);
2415         if (rxq == NULL)
2416                 return -ENOMEM;
2417         rxq->mb_pool = mp;
2418         rxq->nb_rx_desc = nb_desc;
2419         rxq->rx_free_thresh = rx_conf->rx_free_thresh;
2420         rxq->queue_id = queue_idx;
2421         rxq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2422                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2423         rxq->port_id = dev->data->port_id;
2424         if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_KEEP_CRC)
2425                 rxq->crc_len = RTE_ETHER_CRC_LEN;
2426         else
2427                 rxq->crc_len = 0;
2428         rxq->drop_en = rx_conf->rx_drop_en;
2429         rxq->rx_deferred_start = rx_conf->rx_deferred_start;
2430         rxq->offloads = offloads;
2431
2432         /*
2433          * The packet type in RX descriptor is different for different NICs.
2434          * So set different masks for different NICs.
2435          */
2436         rxq->pkt_type_mask = TXGBE_PTID_MASK;
2437
2438         /*
2439          * Allocate RX ring hardware descriptors. A memzone large enough to
2440          * handle the maximum ring size is allocated in order to allow for
2441          * resizing in later calls to the queue setup function.
2442          */
2443         rz = rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx,
2444                                       RX_RING_SZ, TXGBE_ALIGN, socket_id);
2445         if (rz == NULL) {
2446                 txgbe_rx_queue_release(rxq);
2447                 return -ENOMEM;
2448         }
2449
2450         /*
2451          * Zero init all the descriptors in the ring.
2452          */
2453         memset(rz->addr, 0, RX_RING_SZ);
2454
2455         /*
2456          * Modified to setup VFRDT for Virtual Function
2457          */
2458         if (hw->mac.type == txgbe_mac_raptor_vf) {
2459                 rxq->rdt_reg_addr =
2460                         TXGBE_REG_ADDR(hw, TXGBE_RXWP(queue_idx));
2461                 rxq->rdh_reg_addr =
2462                         TXGBE_REG_ADDR(hw, TXGBE_RXRP(queue_idx));
2463         } else {
2464                 rxq->rdt_reg_addr =
2465                         TXGBE_REG_ADDR(hw, TXGBE_RXWP(rxq->reg_idx));
2466                 rxq->rdh_reg_addr =
2467                         TXGBE_REG_ADDR(hw, TXGBE_RXRP(rxq->reg_idx));
2468         }
2469
2470         rxq->rx_ring_phys_addr = TMZ_PADDR(rz);
2471         rxq->rx_ring = (struct txgbe_rx_desc *)TMZ_VADDR(rz);
2472
2473         /*
2474          * Certain constraints must be met in order to use the bulk buffer
2475          * allocation Rx burst function. If any of Rx queues doesn't meet them
2476          * the feature should be disabled for the whole port.
2477          */
2478         if (check_rx_burst_bulk_alloc_preconditions(rxq)) {
2479                 PMD_INIT_LOG(DEBUG, "queue[%d] doesn't meet Rx Bulk Alloc "
2480                                     "preconditions - canceling the feature for "
2481                                     "the whole port[%d]",
2482                              rxq->queue_id, rxq->port_id);
2483                 adapter->rx_bulk_alloc_allowed = false;
2484         }
2485
2486         /*
2487          * Allocate software ring. Allow for space at the end of the
2488          * S/W ring to make sure look-ahead logic in bulk alloc Rx burst
2489          * function does not access an invalid memory region.
2490          */
2491         len = nb_desc;
2492         if (adapter->rx_bulk_alloc_allowed)
2493                 len += RTE_PMD_TXGBE_RX_MAX_BURST;
2494
2495         rxq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
2496                                           sizeof(struct txgbe_rx_entry) * len,
2497                                           RTE_CACHE_LINE_SIZE, socket_id);
2498         if (!rxq->sw_ring) {
2499                 txgbe_rx_queue_release(rxq);
2500                 return -ENOMEM;
2501         }
2502
2503         /*
2504          * Always allocate even if it's not going to be needed in order to
2505          * simplify the code.
2506          *
2507          * This ring is used in LRO and Scattered Rx cases and Scattered Rx may
2508          * be requested in txgbe_dev_rx_init(), which is called later from
2509          * dev_start() flow.
2510          */
2511         rxq->sw_sc_ring =
2512                 rte_zmalloc_socket("rxq->sw_sc_ring",
2513                                   sizeof(struct txgbe_scattered_rx_entry) * len,
2514                                   RTE_CACHE_LINE_SIZE, socket_id);
2515         if (!rxq->sw_sc_ring) {
2516                 txgbe_rx_queue_release(rxq);
2517                 return -ENOMEM;
2518         }
2519
2520         PMD_INIT_LOG(DEBUG, "sw_ring=%p sw_sc_ring=%p hw_ring=%p "
2521                             "dma_addr=0x%" PRIx64,
2522                      rxq->sw_ring, rxq->sw_sc_ring, rxq->rx_ring,
2523                      rxq->rx_ring_phys_addr);
2524
2525         dev->data->rx_queues[queue_idx] = rxq;
2526
2527         txgbe_reset_rx_queue(adapter, rxq);
2528
2529         return 0;
2530 }
2531
2532 void __rte_cold
2533 txgbe_dev_clear_queues(struct rte_eth_dev *dev)
2534 {
2535         unsigned int i;
2536         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2537
2538         PMD_INIT_FUNC_TRACE();
2539
2540         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2541                 struct txgbe_tx_queue *txq = dev->data->tx_queues[i];
2542
2543                 if (txq != NULL) {
2544                         txq->ops->release_mbufs(txq);
2545                         txq->ops->reset(txq);
2546                 }
2547         }
2548
2549         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2550                 struct txgbe_rx_queue *rxq = dev->data->rx_queues[i];
2551
2552                 if (rxq != NULL) {
2553                         txgbe_rx_queue_release_mbufs(rxq);
2554                         txgbe_reset_rx_queue(adapter, rxq);
2555                 }
2556         }
2557 }
2558
2559 void
2560 txgbe_dev_free_queues(struct rte_eth_dev *dev)
2561 {
2562         unsigned int i;
2563
2564         PMD_INIT_FUNC_TRACE();
2565
2566         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2567                 txgbe_dev_rx_queue_release(dev->data->rx_queues[i]);
2568                 dev->data->rx_queues[i] = NULL;
2569         }
2570         dev->data->nb_rx_queues = 0;
2571
2572         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2573                 txgbe_dev_tx_queue_release(dev->data->tx_queues[i]);
2574                 dev->data->tx_queues[i] = NULL;
2575         }
2576         dev->data->nb_tx_queues = 0;
2577 }
2578
2579 /**
2580  * Receive Side Scaling (RSS)
2581  *
2582  * Principles:
2583  * The source and destination IP addresses of the IP header and the source
2584  * and destination ports of TCP/UDP headers, if any, of received packets are
2585  * hashed against a configurable random key to compute a 32-bit RSS hash result.
2586  * The seven (7) LSBs of the 32-bit hash result are used as an index into a
2587  * 128-entry redirection table (RETA).  Each entry of the RETA provides a 3-bit
2588  * RSS output index which is used as the RX queue index where to store the
2589  * received packets.
2590  * The following output is supplied in the RX write-back descriptor:
2591  *     - 32-bit result of the Microsoft RSS hash function,
2592  *     - 4-bit RSS type field.
2593  */
2594
2595 /*
2596  * Used as the default key.
2597  */
2598 static uint8_t rss_intel_key[40] = {
2599         0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2,
2600         0x41, 0x67, 0x25, 0x3D, 0x43, 0xA3, 0x8F, 0xB0,
2601         0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
2602         0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C,
2603         0x6A, 0x42, 0xB7, 0x3B, 0xBE, 0xAC, 0x01, 0xFA,
2604 };
2605
2606 static void
2607 txgbe_rss_disable(struct rte_eth_dev *dev)
2608 {
2609         struct txgbe_hw *hw;
2610
2611         hw = TXGBE_DEV_HW(dev);
2612
2613         wr32m(hw, TXGBE_RACTL, TXGBE_RACTL_RSSENA, 0);
2614 }
2615
2616 int
2617 txgbe_dev_rss_hash_update(struct rte_eth_dev *dev,
2618                           struct rte_eth_rss_conf *rss_conf)
2619 {
2620         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2621         uint8_t  *hash_key;
2622         uint32_t mrqc;
2623         uint32_t rss_key;
2624         uint64_t rss_hf;
2625         uint16_t i;
2626
2627         if (!txgbe_rss_update_sp(hw->mac.type)) {
2628                 PMD_DRV_LOG(ERR, "RSS hash update is not supported on this "
2629                         "NIC.");
2630                 return -ENOTSUP;
2631         }
2632
2633         hash_key = rss_conf->rss_key;
2634         if (hash_key) {
2635                 /* Fill in RSS hash key */
2636                 for (i = 0; i < 10; i++) {
2637                         rss_key  = LS32(hash_key[(i * 4) + 0], 0, 0xFF);
2638                         rss_key |= LS32(hash_key[(i * 4) + 1], 8, 0xFF);
2639                         rss_key |= LS32(hash_key[(i * 4) + 2], 16, 0xFF);
2640                         rss_key |= LS32(hash_key[(i * 4) + 3], 24, 0xFF);
2641                         wr32a(hw, TXGBE_REG_RSSKEY, i, rss_key);
2642                 }
2643         }
2644
2645         /* Set configured hashing protocols */
2646         rss_hf = rss_conf->rss_hf & TXGBE_RSS_OFFLOAD_ALL;
2647         mrqc = rd32(hw, TXGBE_RACTL);
2648         mrqc &= ~TXGBE_RACTL_RSSMASK;
2649         if (rss_hf & ETH_RSS_IPV4)
2650                 mrqc |= TXGBE_RACTL_RSSIPV4;
2651         if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
2652                 mrqc |= TXGBE_RACTL_RSSIPV4TCP;
2653         if (rss_hf & ETH_RSS_IPV6 ||
2654             rss_hf & ETH_RSS_IPV6_EX)
2655                 mrqc |= TXGBE_RACTL_RSSIPV6;
2656         if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP ||
2657             rss_hf & ETH_RSS_IPV6_TCP_EX)
2658                 mrqc |= TXGBE_RACTL_RSSIPV6TCP;
2659         if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
2660                 mrqc |= TXGBE_RACTL_RSSIPV4UDP;
2661         if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP ||
2662             rss_hf & ETH_RSS_IPV6_UDP_EX)
2663                 mrqc |= TXGBE_RACTL_RSSIPV6UDP;
2664
2665         if (rss_hf)
2666                 mrqc |= TXGBE_RACTL_RSSENA;
2667         else
2668                 mrqc &= ~TXGBE_RACTL_RSSENA;
2669
2670         wr32(hw, TXGBE_RACTL, mrqc);
2671
2672         return 0;
2673 }
2674
2675 int
2676 txgbe_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
2677                             struct rte_eth_rss_conf *rss_conf)
2678 {
2679         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2680         uint8_t *hash_key;
2681         uint32_t mrqc;
2682         uint32_t rss_key;
2683         uint64_t rss_hf;
2684         uint16_t i;
2685
2686         hash_key = rss_conf->rss_key;
2687         if (hash_key) {
2688                 /* Return RSS hash key */
2689                 for (i = 0; i < 10; i++) {
2690                         rss_key = rd32a(hw, TXGBE_REG_RSSKEY, i);
2691                         hash_key[(i * 4) + 0] = RS32(rss_key, 0, 0xFF);
2692                         hash_key[(i * 4) + 1] = RS32(rss_key, 8, 0xFF);
2693                         hash_key[(i * 4) + 2] = RS32(rss_key, 16, 0xFF);
2694                         hash_key[(i * 4) + 3] = RS32(rss_key, 24, 0xFF);
2695                 }
2696         }
2697
2698         rss_hf = 0;
2699         mrqc = rd32(hw, TXGBE_RACTL);
2700         if (mrqc & TXGBE_RACTL_RSSIPV4)
2701                 rss_hf |= ETH_RSS_IPV4;
2702         if (mrqc & TXGBE_RACTL_RSSIPV4TCP)
2703                 rss_hf |= ETH_RSS_NONFRAG_IPV4_TCP;
2704         if (mrqc & TXGBE_RACTL_RSSIPV6)
2705                 rss_hf |= ETH_RSS_IPV6 |
2706                           ETH_RSS_IPV6_EX;
2707         if (mrqc & TXGBE_RACTL_RSSIPV6TCP)
2708                 rss_hf |= ETH_RSS_NONFRAG_IPV6_TCP |
2709                           ETH_RSS_IPV6_TCP_EX;
2710         if (mrqc & TXGBE_RACTL_RSSIPV4UDP)
2711                 rss_hf |= ETH_RSS_NONFRAG_IPV4_UDP;
2712         if (mrqc & TXGBE_RACTL_RSSIPV6UDP)
2713                 rss_hf |= ETH_RSS_NONFRAG_IPV6_UDP |
2714                           ETH_RSS_IPV6_UDP_EX;
2715         if (!(mrqc & TXGBE_RACTL_RSSENA))
2716                 rss_hf = 0;
2717
2718         rss_hf &= TXGBE_RSS_OFFLOAD_ALL;
2719
2720         rss_conf->rss_hf = rss_hf;
2721         return 0;
2722 }
2723
2724 static void
2725 txgbe_rss_configure(struct rte_eth_dev *dev)
2726 {
2727         struct rte_eth_rss_conf rss_conf;
2728         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2729         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2730         uint32_t reta;
2731         uint16_t i;
2732         uint16_t j;
2733
2734         PMD_INIT_FUNC_TRACE();
2735
2736         /*
2737          * Fill in redirection table
2738          * The byte-swap is needed because NIC registers are in
2739          * little-endian order.
2740          */
2741         if (adapter->rss_reta_updated == 0) {
2742                 reta = 0;
2743                 for (i = 0, j = 0; i < ETH_RSS_RETA_SIZE_128; i++, j++) {
2744                         if (j == dev->data->nb_rx_queues)
2745                                 j = 0;
2746                         reta = (reta >> 8) | LS32(j, 24, 0xFF);
2747                         if ((i & 3) == 3)
2748                                 wr32a(hw, TXGBE_REG_RSSTBL, i >> 2, reta);
2749                 }
2750         }
2751         /*
2752          * Configure the RSS key and the RSS protocols used to compute
2753          * the RSS hash of input packets.
2754          */
2755         rss_conf = dev->data->dev_conf.rx_adv_conf.rss_conf;
2756         if (rss_conf.rss_key == NULL)
2757                 rss_conf.rss_key = rss_intel_key; /* Default hash key */
2758         txgbe_dev_rss_hash_update(dev, &rss_conf);
2759 }
2760
2761 #define NUM_VFTA_REGISTERS 128
2762 #define NIC_RX_BUFFER_SIZE 0x200
2763
2764 static void
2765 txgbe_vmdq_dcb_configure(struct rte_eth_dev *dev)
2766 {
2767         struct rte_eth_vmdq_dcb_conf *cfg;
2768         struct txgbe_hw *hw;
2769         enum rte_eth_nb_pools num_pools;
2770         uint32_t mrqc, vt_ctl, queue_mapping, vlanctrl;
2771         uint16_t pbsize;
2772         uint8_t nb_tcs; /* number of traffic classes */
2773         int i;
2774
2775         PMD_INIT_FUNC_TRACE();
2776         hw = TXGBE_DEV_HW(dev);
2777         cfg = &dev->data->dev_conf.rx_adv_conf.vmdq_dcb_conf;
2778         num_pools = cfg->nb_queue_pools;
2779         /* Check we have a valid number of pools */
2780         if (num_pools != ETH_16_POOLS && num_pools != ETH_32_POOLS) {
2781                 txgbe_rss_disable(dev);
2782                 return;
2783         }
2784         /* 16 pools -> 8 traffic classes, 32 pools -> 4 traffic classes */
2785         nb_tcs = (uint8_t)(ETH_VMDQ_DCB_NUM_QUEUES / (int)num_pools);
2786
2787         /*
2788          * split rx buffer up into sections, each for 1 traffic class
2789          */
2790         pbsize = (uint16_t)(NIC_RX_BUFFER_SIZE / nb_tcs);
2791         for (i = 0; i < nb_tcs; i++) {
2792                 uint32_t rxpbsize = rd32(hw, TXGBE_PBRXSIZE(i));
2793
2794                 rxpbsize &= (~(0x3FF << 10));
2795                 /* clear 10 bits. */
2796                 rxpbsize |= (pbsize << 10); /* set value */
2797                 wr32(hw, TXGBE_PBRXSIZE(i), rxpbsize);
2798         }
2799         /* zero alloc all unused TCs */
2800         for (i = nb_tcs; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
2801                 uint32_t rxpbsize = rd32(hw, TXGBE_PBRXSIZE(i));
2802
2803                 rxpbsize &= (~(0x3FF << 10));
2804                 /* clear 10 bits. */
2805                 wr32(hw, TXGBE_PBRXSIZE(i), rxpbsize);
2806         }
2807
2808         if (num_pools == ETH_16_POOLS) {
2809                 mrqc = TXGBE_PORTCTL_NUMTC_8;
2810                 mrqc |= TXGBE_PORTCTL_NUMVT_16;
2811         } else {
2812                 mrqc = TXGBE_PORTCTL_NUMTC_4;
2813                 mrqc |= TXGBE_PORTCTL_NUMVT_32;
2814         }
2815         wr32m(hw, TXGBE_PORTCTL,
2816               TXGBE_PORTCTL_NUMTC_MASK | TXGBE_PORTCTL_NUMVT_MASK, mrqc);
2817
2818         vt_ctl = TXGBE_POOLCTL_RPLEN;
2819         if (cfg->enable_default_pool)
2820                 vt_ctl |= TXGBE_POOLCTL_DEFPL(cfg->default_pool);
2821         else
2822                 vt_ctl |= TXGBE_POOLCTL_DEFDSA;
2823
2824         wr32(hw, TXGBE_POOLCTL, vt_ctl);
2825
2826         queue_mapping = 0;
2827         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++)
2828                 /*
2829                  * mapping is done with 3 bits per priority,
2830                  * so shift by i*3 each time
2831                  */
2832                 queue_mapping |= ((cfg->dcb_tc[i] & 0x07) << (i * 3));
2833
2834         wr32(hw, TXGBE_RPUP2TC, queue_mapping);
2835
2836         wr32(hw, TXGBE_ARBRXCTL, TXGBE_ARBRXCTL_RRM);
2837
2838         /* enable vlan filtering and allow all vlan tags through */
2839         vlanctrl = rd32(hw, TXGBE_VLANCTL);
2840         vlanctrl |= TXGBE_VLANCTL_VFE; /* enable vlan filters */
2841         wr32(hw, TXGBE_VLANCTL, vlanctrl);
2842
2843         /* enable all vlan filters */
2844         for (i = 0; i < NUM_VFTA_REGISTERS; i++)
2845                 wr32(hw, TXGBE_VLANTBL(i), 0xFFFFFFFF);
2846
2847         wr32(hw, TXGBE_POOLRXENA(0),
2848                         num_pools == ETH_16_POOLS ? 0xFFFF : 0xFFFFFFFF);
2849
2850         wr32(hw, TXGBE_ETHADDRIDX, 0);
2851         wr32(hw, TXGBE_ETHADDRASSL, 0xFFFFFFFF);
2852         wr32(hw, TXGBE_ETHADDRASSH, 0xFFFFFFFF);
2853
2854         /* set up filters for vlan tags as configured */
2855         for (i = 0; i < cfg->nb_pool_maps; i++) {
2856                 /* set vlan id in VF register and set the valid bit */
2857                 wr32(hw, TXGBE_PSRVLANIDX, i);
2858                 wr32(hw, TXGBE_PSRVLAN, (TXGBE_PSRVLAN_EA |
2859                                 (cfg->pool_map[i].vlan_id & 0xFFF)));
2860
2861                 wr32(hw, TXGBE_PSRVLANPLM(0), cfg->pool_map[i].pools);
2862         }
2863 }
2864
2865 /**
2866  * txgbe_dcb_config_tx_hw_config - Configure general DCB TX parameters
2867  * @dev: pointer to eth_dev structure
2868  * @dcb_config: pointer to txgbe_dcb_config structure
2869  */
2870 static void
2871 txgbe_dcb_tx_hw_config(struct rte_eth_dev *dev,
2872                        struct txgbe_dcb_config *dcb_config)
2873 {
2874         uint32_t reg;
2875         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2876
2877         PMD_INIT_FUNC_TRACE();
2878
2879         /* Disable the Tx desc arbiter */
2880         reg = rd32(hw, TXGBE_ARBTXCTL);
2881         reg |= TXGBE_ARBTXCTL_DIA;
2882         wr32(hw, TXGBE_ARBTXCTL, reg);
2883
2884         /* Enable DCB for Tx with 8 TCs */
2885         reg = rd32(hw, TXGBE_PORTCTL);
2886         reg &= TXGBE_PORTCTL_NUMTC_MASK;
2887         reg |= TXGBE_PORTCTL_DCB;
2888         if (dcb_config->num_tcs.pg_tcs == 8)
2889                 reg |= TXGBE_PORTCTL_NUMTC_8;
2890         else
2891                 reg |= TXGBE_PORTCTL_NUMTC_4;
2892
2893         wr32(hw, TXGBE_PORTCTL, reg);
2894
2895         /* Enable the Tx desc arbiter */
2896         reg = rd32(hw, TXGBE_ARBTXCTL);
2897         reg &= ~TXGBE_ARBTXCTL_DIA;
2898         wr32(hw, TXGBE_ARBTXCTL, reg);
2899 }
2900
2901 /**
2902  * txgbe_vmdq_dcb_hw_tx_config - Configure general VMDQ+DCB TX parameters
2903  * @dev: pointer to rte_eth_dev structure
2904  * @dcb_config: pointer to txgbe_dcb_config structure
2905  */
2906 static void
2907 txgbe_vmdq_dcb_hw_tx_config(struct rte_eth_dev *dev,
2908                         struct txgbe_dcb_config *dcb_config)
2909 {
2910         struct rte_eth_vmdq_dcb_tx_conf *vmdq_tx_conf =
2911                         &dev->data->dev_conf.tx_adv_conf.vmdq_dcb_tx_conf;
2912         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2913
2914         PMD_INIT_FUNC_TRACE();
2915         /*PF VF Transmit Enable*/
2916         wr32(hw, TXGBE_POOLTXENA(0),
2917                 vmdq_tx_conf->nb_queue_pools ==
2918                                 ETH_16_POOLS ? 0xFFFF : 0xFFFFFFFF);
2919
2920         /*Configure general DCB TX parameters*/
2921         txgbe_dcb_tx_hw_config(dev, dcb_config);
2922 }
2923
2924 static void
2925 txgbe_vmdq_dcb_rx_config(struct rte_eth_dev *dev,
2926                         struct txgbe_dcb_config *dcb_config)
2927 {
2928         struct rte_eth_vmdq_dcb_conf *vmdq_rx_conf =
2929                         &dev->data->dev_conf.rx_adv_conf.vmdq_dcb_conf;
2930         struct txgbe_dcb_tc_config *tc;
2931         uint8_t i, j;
2932
2933         /* convert rte_eth_conf.rx_adv_conf to struct txgbe_dcb_config */
2934         if (vmdq_rx_conf->nb_queue_pools == ETH_16_POOLS) {
2935                 dcb_config->num_tcs.pg_tcs = ETH_8_TCS;
2936                 dcb_config->num_tcs.pfc_tcs = ETH_8_TCS;
2937         } else {
2938                 dcb_config->num_tcs.pg_tcs = ETH_4_TCS;
2939                 dcb_config->num_tcs.pfc_tcs = ETH_4_TCS;
2940         }
2941
2942         /* Initialize User Priority to Traffic Class mapping */
2943         for (j = 0; j < TXGBE_DCB_TC_MAX; j++) {
2944                 tc = &dcb_config->tc_config[j];
2945                 tc->path[TXGBE_DCB_RX_CONFIG].up_to_tc_bitmap = 0;
2946         }
2947
2948         /* User Priority to Traffic Class mapping */
2949         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
2950                 j = vmdq_rx_conf->dcb_tc[i];
2951                 tc = &dcb_config->tc_config[j];
2952                 tc->path[TXGBE_DCB_RX_CONFIG].up_to_tc_bitmap |=
2953                                                 (uint8_t)(1 << i);
2954         }
2955 }
2956
2957 static void
2958 txgbe_dcb_vt_tx_config(struct rte_eth_dev *dev,
2959                         struct txgbe_dcb_config *dcb_config)
2960 {
2961         struct rte_eth_vmdq_dcb_tx_conf *vmdq_tx_conf =
2962                         &dev->data->dev_conf.tx_adv_conf.vmdq_dcb_tx_conf;
2963         struct txgbe_dcb_tc_config *tc;
2964         uint8_t i, j;
2965
2966         /* convert rte_eth_conf.rx_adv_conf to struct txgbe_dcb_config */
2967         if (vmdq_tx_conf->nb_queue_pools == ETH_16_POOLS) {
2968                 dcb_config->num_tcs.pg_tcs = ETH_8_TCS;
2969                 dcb_config->num_tcs.pfc_tcs = ETH_8_TCS;
2970         } else {
2971                 dcb_config->num_tcs.pg_tcs = ETH_4_TCS;
2972                 dcb_config->num_tcs.pfc_tcs = ETH_4_TCS;
2973         }
2974
2975         /* Initialize User Priority to Traffic Class mapping */
2976         for (j = 0; j < TXGBE_DCB_TC_MAX; j++) {
2977                 tc = &dcb_config->tc_config[j];
2978                 tc->path[TXGBE_DCB_TX_CONFIG].up_to_tc_bitmap = 0;
2979         }
2980
2981         /* User Priority to Traffic Class mapping */
2982         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
2983                 j = vmdq_tx_conf->dcb_tc[i];
2984                 tc = &dcb_config->tc_config[j];
2985                 tc->path[TXGBE_DCB_TX_CONFIG].up_to_tc_bitmap |=
2986                                                 (uint8_t)(1 << i);
2987         }
2988 }
2989
2990 static void
2991 txgbe_dcb_rx_config(struct rte_eth_dev *dev,
2992                 struct txgbe_dcb_config *dcb_config)
2993 {
2994         struct rte_eth_dcb_rx_conf *rx_conf =
2995                         &dev->data->dev_conf.rx_adv_conf.dcb_rx_conf;
2996         struct txgbe_dcb_tc_config *tc;
2997         uint8_t i, j;
2998
2999         dcb_config->num_tcs.pg_tcs = (uint8_t)rx_conf->nb_tcs;
3000         dcb_config->num_tcs.pfc_tcs = (uint8_t)rx_conf->nb_tcs;
3001
3002         /* Initialize User Priority to Traffic Class mapping */
3003         for (j = 0; j < TXGBE_DCB_TC_MAX; j++) {
3004                 tc = &dcb_config->tc_config[j];
3005                 tc->path[TXGBE_DCB_RX_CONFIG].up_to_tc_bitmap = 0;
3006         }
3007
3008         /* User Priority to Traffic Class mapping */
3009         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3010                 j = rx_conf->dcb_tc[i];
3011                 tc = &dcb_config->tc_config[j];
3012                 tc->path[TXGBE_DCB_RX_CONFIG].up_to_tc_bitmap |=
3013                                                 (uint8_t)(1 << i);
3014         }
3015 }
3016
3017 static void
3018 txgbe_dcb_tx_config(struct rte_eth_dev *dev,
3019                 struct txgbe_dcb_config *dcb_config)
3020 {
3021         struct rte_eth_dcb_tx_conf *tx_conf =
3022                         &dev->data->dev_conf.tx_adv_conf.dcb_tx_conf;
3023         struct txgbe_dcb_tc_config *tc;
3024         uint8_t i, j;
3025
3026         dcb_config->num_tcs.pg_tcs = (uint8_t)tx_conf->nb_tcs;
3027         dcb_config->num_tcs.pfc_tcs = (uint8_t)tx_conf->nb_tcs;
3028
3029         /* Initialize User Priority to Traffic Class mapping */
3030         for (j = 0; j < TXGBE_DCB_TC_MAX; j++) {
3031                 tc = &dcb_config->tc_config[j];
3032                 tc->path[TXGBE_DCB_TX_CONFIG].up_to_tc_bitmap = 0;
3033         }
3034
3035         /* User Priority to Traffic Class mapping */
3036         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3037                 j = tx_conf->dcb_tc[i];
3038                 tc = &dcb_config->tc_config[j];
3039                 tc->path[TXGBE_DCB_TX_CONFIG].up_to_tc_bitmap |=
3040                                                 (uint8_t)(1 << i);
3041         }
3042 }
3043
3044 /**
3045  * txgbe_dcb_rx_hw_config - Configure general DCB RX HW parameters
3046  * @dev: pointer to eth_dev structure
3047  * @dcb_config: pointer to txgbe_dcb_config structure
3048  */
3049 static void
3050 txgbe_dcb_rx_hw_config(struct rte_eth_dev *dev,
3051                        struct txgbe_dcb_config *dcb_config)
3052 {
3053         uint32_t reg;
3054         uint32_t vlanctrl;
3055         uint8_t i;
3056         uint32_t q;
3057         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3058
3059         PMD_INIT_FUNC_TRACE();
3060         /*
3061          * Disable the arbiter before changing parameters
3062          * (always enable recycle mode; WSP)
3063          */
3064         reg = TXGBE_ARBRXCTL_RRM | TXGBE_ARBRXCTL_WSP | TXGBE_ARBRXCTL_DIA;
3065         wr32(hw, TXGBE_ARBRXCTL, reg);
3066
3067         reg = rd32(hw, TXGBE_PORTCTL);
3068         reg &= ~(TXGBE_PORTCTL_NUMTC_MASK | TXGBE_PORTCTL_NUMVT_MASK);
3069         if (dcb_config->num_tcs.pg_tcs == 4) {
3070                 reg |= TXGBE_PORTCTL_NUMTC_4;
3071                 if (dcb_config->vt_mode)
3072                         reg |= TXGBE_PORTCTL_NUMVT_32;
3073                 else
3074                         wr32(hw, TXGBE_POOLCTL, 0);
3075         }
3076
3077         if (dcb_config->num_tcs.pg_tcs == 8) {
3078                 reg |= TXGBE_PORTCTL_NUMTC_8;
3079                 if (dcb_config->vt_mode)
3080                         reg |= TXGBE_PORTCTL_NUMVT_16;
3081                 else
3082                         wr32(hw, TXGBE_POOLCTL, 0);
3083         }
3084
3085         wr32(hw, TXGBE_PORTCTL, reg);
3086
3087         if (RTE_ETH_DEV_SRIOV(dev).active == 0) {
3088                 /* Disable drop for all queues in VMDQ mode*/
3089                 for (q = 0; q < TXGBE_MAX_RX_QUEUE_NUM; q++) {
3090                         u32 val = 1 << (q % 32);
3091                         wr32m(hw, TXGBE_QPRXDROP(q / 32), val, val);
3092                 }
3093         } else {
3094                 /* Enable drop for all queues in SRIOV mode */
3095                 for (q = 0; q < TXGBE_MAX_RX_QUEUE_NUM; q++) {
3096                         u32 val = 1 << (q % 32);
3097                         wr32m(hw, TXGBE_QPRXDROP(q / 32), val, val);
3098                 }
3099         }
3100
3101         /* VLNCTL: enable vlan filtering and allow all vlan tags through */
3102         vlanctrl = rd32(hw, TXGBE_VLANCTL);
3103         vlanctrl |= TXGBE_VLANCTL_VFE; /* enable vlan filters */
3104         wr32(hw, TXGBE_VLANCTL, vlanctrl);
3105
3106         /* VLANTBL - enable all vlan filters */
3107         for (i = 0; i < NUM_VFTA_REGISTERS; i++)
3108                 wr32(hw, TXGBE_VLANTBL(i), 0xFFFFFFFF);
3109
3110         /*
3111          * Configure Rx packet plane (recycle mode; WSP) and
3112          * enable arbiter
3113          */
3114         reg = TXGBE_ARBRXCTL_RRM | TXGBE_ARBRXCTL_WSP;
3115         wr32(hw, TXGBE_ARBRXCTL, reg);
3116 }
3117
3118 static void
3119 txgbe_dcb_hw_arbite_rx_config(struct txgbe_hw *hw, uint16_t *refill,
3120                 uint16_t *max, uint8_t *bwg_id, uint8_t *tsa, uint8_t *map)
3121 {
3122         txgbe_dcb_config_rx_arbiter_raptor(hw, refill, max, bwg_id,
3123                                           tsa, map);
3124 }
3125
3126 static void
3127 txgbe_dcb_hw_arbite_tx_config(struct txgbe_hw *hw, uint16_t *refill,
3128                 uint16_t *max, uint8_t *bwg_id, uint8_t *tsa, uint8_t *map)
3129 {
3130         switch (hw->mac.type) {
3131         case txgbe_mac_raptor:
3132                 txgbe_dcb_config_tx_desc_arbiter_raptor(hw, refill,
3133                                                         max, bwg_id, tsa);
3134                 txgbe_dcb_config_tx_data_arbiter_raptor(hw, refill,
3135                                                         max, bwg_id, tsa, map);
3136                 break;
3137         default:
3138                 break;
3139         }
3140 }
3141
3142 #define DCB_RX_CONFIG  1
3143 #define DCB_TX_CONFIG  1
3144 #define DCB_TX_PB      1024
3145 /**
3146  * txgbe_dcb_hw_configure - Enable DCB and configure
3147  * general DCB in VT mode and non-VT mode parameters
3148  * @dev: pointer to rte_eth_dev structure
3149  * @dcb_config: pointer to txgbe_dcb_config structure
3150  */
3151 static int
3152 txgbe_dcb_hw_configure(struct rte_eth_dev *dev,
3153                         struct txgbe_dcb_config *dcb_config)
3154 {
3155         int     ret = 0;
3156         uint8_t i, pfc_en, nb_tcs;
3157         uint16_t pbsize, rx_buffer_size;
3158         uint8_t config_dcb_rx = 0;
3159         uint8_t config_dcb_tx = 0;
3160         uint8_t tsa[TXGBE_DCB_TC_MAX] = {0};
3161         uint8_t bwgid[TXGBE_DCB_TC_MAX] = {0};
3162         uint16_t refill[TXGBE_DCB_TC_MAX] = {0};
3163         uint16_t max[TXGBE_DCB_TC_MAX] = {0};
3164         uint8_t map[TXGBE_DCB_TC_MAX] = {0};
3165         struct txgbe_dcb_tc_config *tc;
3166         uint32_t max_frame = dev->data->mtu +
3167                         RTE_ETHER_HDR_LEN + RTE_ETHER_CRC_LEN;
3168         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3169         struct txgbe_bw_conf *bw_conf = TXGBE_DEV_BW_CONF(dev);
3170
3171         switch (dev->data->dev_conf.rxmode.mq_mode) {
3172         case ETH_MQ_RX_VMDQ_DCB:
3173                 dcb_config->vt_mode = true;
3174                 config_dcb_rx = DCB_RX_CONFIG;
3175                 /*
3176                  * get dcb and VT rx configuration parameters
3177                  * from rte_eth_conf
3178                  */
3179                 txgbe_vmdq_dcb_rx_config(dev, dcb_config);
3180                 /*Configure general VMDQ and DCB RX parameters*/
3181                 txgbe_vmdq_dcb_configure(dev);
3182                 break;
3183         case ETH_MQ_RX_DCB:
3184         case ETH_MQ_RX_DCB_RSS:
3185                 dcb_config->vt_mode = false;
3186                 config_dcb_rx = DCB_RX_CONFIG;
3187                 /* Get dcb TX configuration parameters from rte_eth_conf */
3188                 txgbe_dcb_rx_config(dev, dcb_config);
3189                 /*Configure general DCB RX parameters*/
3190                 txgbe_dcb_rx_hw_config(dev, dcb_config);
3191                 break;
3192         default:
3193                 PMD_INIT_LOG(ERR, "Incorrect DCB RX mode configuration");
3194                 break;
3195         }
3196         switch (dev->data->dev_conf.txmode.mq_mode) {
3197         case ETH_MQ_TX_VMDQ_DCB:
3198                 dcb_config->vt_mode = true;
3199                 config_dcb_tx = DCB_TX_CONFIG;
3200                 /* get DCB and VT TX configuration parameters
3201                  * from rte_eth_conf
3202                  */
3203                 txgbe_dcb_vt_tx_config(dev, dcb_config);
3204                 /* Configure general VMDQ and DCB TX parameters */
3205                 txgbe_vmdq_dcb_hw_tx_config(dev, dcb_config);
3206                 break;
3207
3208         case ETH_MQ_TX_DCB:
3209                 dcb_config->vt_mode = false;
3210                 config_dcb_tx = DCB_TX_CONFIG;
3211                 /* get DCB TX configuration parameters from rte_eth_conf */
3212                 txgbe_dcb_tx_config(dev, dcb_config);
3213                 /* Configure general DCB TX parameters */
3214                 txgbe_dcb_tx_hw_config(dev, dcb_config);
3215                 break;
3216         default:
3217                 PMD_INIT_LOG(ERR, "Incorrect DCB TX mode configuration");
3218                 break;
3219         }
3220
3221         nb_tcs = dcb_config->num_tcs.pfc_tcs;
3222         /* Unpack map */
3223         txgbe_dcb_unpack_map_cee(dcb_config, TXGBE_DCB_RX_CONFIG, map);
3224         if (nb_tcs == ETH_4_TCS) {
3225                 /* Avoid un-configured priority mapping to TC0 */
3226                 uint8_t j = 4;
3227                 uint8_t mask = 0xFF;
3228
3229                 for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES - 4; i++)
3230                         mask = (uint8_t)(mask & (~(1 << map[i])));
3231                 for (i = 0; mask && (i < TXGBE_DCB_TC_MAX); i++) {
3232                         if ((mask & 0x1) && j < ETH_DCB_NUM_USER_PRIORITIES)
3233                                 map[j++] = i;
3234                         mask >>= 1;
3235                 }
3236                 /* Re-configure 4 TCs BW */
3237                 for (i = 0; i < nb_tcs; i++) {
3238                         tc = &dcb_config->tc_config[i];
3239                         if (bw_conf->tc_num != nb_tcs)
3240                                 tc->path[TXGBE_DCB_TX_CONFIG].bwg_percent =
3241                                         (uint8_t)(100 / nb_tcs);
3242                         tc->path[TXGBE_DCB_RX_CONFIG].bwg_percent =
3243                                                 (uint8_t)(100 / nb_tcs);
3244                 }
3245                 for (; i < TXGBE_DCB_TC_MAX; i++) {
3246                         tc = &dcb_config->tc_config[i];
3247                         tc->path[TXGBE_DCB_TX_CONFIG].bwg_percent = 0;
3248                         tc->path[TXGBE_DCB_RX_CONFIG].bwg_percent = 0;
3249                 }
3250         } else {
3251                 /* Re-configure 8 TCs BW */
3252                 for (i = 0; i < nb_tcs; i++) {
3253                         tc = &dcb_config->tc_config[i];
3254                         if (bw_conf->tc_num != nb_tcs)
3255                                 tc->path[TXGBE_DCB_TX_CONFIG].bwg_percent =
3256                                         (uint8_t)(100 / nb_tcs + (i & 1));
3257                         tc->path[TXGBE_DCB_RX_CONFIG].bwg_percent =
3258                                 (uint8_t)(100 / nb_tcs + (i & 1));
3259                 }
3260         }
3261
3262         rx_buffer_size = NIC_RX_BUFFER_SIZE;
3263
3264         if (config_dcb_rx) {
3265                 /* Set RX buffer size */
3266                 pbsize = (uint16_t)(rx_buffer_size / nb_tcs);
3267                 uint32_t rxpbsize = pbsize << 10;
3268
3269                 for (i = 0; i < nb_tcs; i++)
3270                         wr32(hw, TXGBE_PBRXSIZE(i), rxpbsize);
3271
3272                 /* zero alloc all unused TCs */
3273                 for (; i < ETH_DCB_NUM_USER_PRIORITIES; i++)
3274                         wr32(hw, TXGBE_PBRXSIZE(i), 0);
3275         }
3276         if (config_dcb_tx) {
3277                 /* Only support an equally distributed
3278                  *  Tx packet buffer strategy.
3279                  */
3280                 uint32_t txpktsize = TXGBE_PBTXSIZE_MAX / nb_tcs;
3281                 uint32_t txpbthresh = (txpktsize / DCB_TX_PB) -
3282                                         TXGBE_TXPKT_SIZE_MAX;
3283
3284                 for (i = 0; i < nb_tcs; i++) {
3285                         wr32(hw, TXGBE_PBTXSIZE(i), txpktsize);
3286                         wr32(hw, TXGBE_PBTXDMATH(i), txpbthresh);
3287                 }
3288                 /* Clear unused TCs, if any, to zero buffer size*/
3289                 for (; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3290                         wr32(hw, TXGBE_PBTXSIZE(i), 0);
3291                         wr32(hw, TXGBE_PBTXDMATH(i), 0);
3292                 }
3293         }
3294
3295         /*Calculates traffic class credits*/
3296         txgbe_dcb_calculate_tc_credits_cee(hw, dcb_config, max_frame,
3297                                 TXGBE_DCB_TX_CONFIG);
3298         txgbe_dcb_calculate_tc_credits_cee(hw, dcb_config, max_frame,
3299                                 TXGBE_DCB_RX_CONFIG);
3300
3301         if (config_dcb_rx) {
3302                 /* Unpack CEE standard containers */
3303                 txgbe_dcb_unpack_refill_cee(dcb_config,
3304                                 TXGBE_DCB_RX_CONFIG, refill);
3305                 txgbe_dcb_unpack_max_cee(dcb_config, max);
3306                 txgbe_dcb_unpack_bwgid_cee(dcb_config,
3307                                 TXGBE_DCB_RX_CONFIG, bwgid);
3308                 txgbe_dcb_unpack_tsa_cee(dcb_config,
3309                                 TXGBE_DCB_RX_CONFIG, tsa);
3310                 /* Configure PG(ETS) RX */
3311                 txgbe_dcb_hw_arbite_rx_config(hw, refill, max, bwgid, tsa, map);
3312         }
3313
3314         if (config_dcb_tx) {
3315                 /* Unpack CEE standard containers */
3316                 txgbe_dcb_unpack_refill_cee(dcb_config,
3317                                 TXGBE_DCB_TX_CONFIG, refill);
3318                 txgbe_dcb_unpack_max_cee(dcb_config, max);
3319                 txgbe_dcb_unpack_bwgid_cee(dcb_config,
3320                                 TXGBE_DCB_TX_CONFIG, bwgid);
3321                 txgbe_dcb_unpack_tsa_cee(dcb_config,
3322                                 TXGBE_DCB_TX_CONFIG, tsa);
3323                 /* Configure PG(ETS) TX */
3324                 txgbe_dcb_hw_arbite_tx_config(hw, refill, max, bwgid, tsa, map);
3325         }
3326
3327         /* Configure queue statistics registers */
3328         txgbe_dcb_config_tc_stats_raptor(hw, dcb_config);
3329
3330         /* Check if the PFC is supported */
3331         if (dev->data->dev_conf.dcb_capability_en & ETH_DCB_PFC_SUPPORT) {
3332                 pbsize = (uint16_t)(rx_buffer_size / nb_tcs);
3333                 for (i = 0; i < nb_tcs; i++) {
3334                         /* If the TC count is 8,
3335                          * and the default high_water is 48,
3336                          * the low_water is 16 as default.
3337                          */
3338                         hw->fc.high_water[i] = (pbsize * 3) / 4;
3339                         hw->fc.low_water[i] = pbsize / 4;
3340                         /* Enable pfc for this TC */
3341                         tc = &dcb_config->tc_config[i];
3342                         tc->pfc = txgbe_dcb_pfc_enabled;
3343                 }
3344                 txgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
3345                 if (dcb_config->num_tcs.pfc_tcs == ETH_4_TCS)
3346                         pfc_en &= 0x0F;
3347                 ret = txgbe_dcb_config_pfc(hw, pfc_en, map);
3348         }
3349
3350         return ret;
3351 }
3352
3353 void txgbe_configure_pb(struct rte_eth_dev *dev)
3354 {
3355         struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
3356         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3357
3358         int hdrm;
3359         int tc = dev_conf->rx_adv_conf.dcb_rx_conf.nb_tcs;
3360
3361         /* Reserve 256KB(/512KB) rx buffer for fdir */
3362         hdrm = 256; /*KB*/
3363
3364         hw->mac.setup_pba(hw, tc, hdrm, PBA_STRATEGY_EQUAL);
3365 }
3366
3367 void txgbe_configure_port(struct rte_eth_dev *dev)
3368 {
3369         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3370         int i = 0;
3371         uint16_t tpids[8] = {RTE_ETHER_TYPE_VLAN, RTE_ETHER_TYPE_QINQ,
3372                                 0x9100, 0x9200,
3373                                 0x0000, 0x0000,
3374                                 0x0000, 0x0000};
3375
3376         PMD_INIT_FUNC_TRACE();
3377
3378         /* default outer vlan tpid */
3379         wr32(hw, TXGBE_EXTAG,
3380                 TXGBE_EXTAG_ETAG(RTE_ETHER_TYPE_ETAG) |
3381                 TXGBE_EXTAG_VLAN(RTE_ETHER_TYPE_QINQ));
3382
3383         /* default inner vlan tpid */
3384         wr32m(hw, TXGBE_VLANCTL,
3385                 TXGBE_VLANCTL_TPID_MASK,
3386                 TXGBE_VLANCTL_TPID(RTE_ETHER_TYPE_VLAN));
3387         wr32m(hw, TXGBE_DMATXCTRL,
3388                 TXGBE_DMATXCTRL_TPID_MASK,
3389                 TXGBE_DMATXCTRL_TPID(RTE_ETHER_TYPE_VLAN));
3390
3391         /* default vlan tpid filters */
3392         for (i = 0; i < 8; i++) {
3393                 wr32m(hw, TXGBE_TAGTPID(i / 2),
3394                         (i % 2 ? TXGBE_TAGTPID_MSB_MASK
3395                                : TXGBE_TAGTPID_LSB_MASK),
3396                         (i % 2 ? TXGBE_TAGTPID_MSB(tpids[i])
3397                                : TXGBE_TAGTPID_LSB(tpids[i])));
3398         }
3399
3400         /* default vxlan port */
3401         wr32(hw, TXGBE_VXLANPORT, 4789);
3402 }
3403
3404 /**
3405  * txgbe_configure_dcb - Configure DCB  Hardware
3406  * @dev: pointer to rte_eth_dev
3407  */
3408 void txgbe_configure_dcb(struct rte_eth_dev *dev)
3409 {
3410         struct txgbe_dcb_config *dcb_cfg = TXGBE_DEV_DCB_CONFIG(dev);
3411         struct rte_eth_conf *dev_conf = &dev->data->dev_conf;
3412
3413         PMD_INIT_FUNC_TRACE();
3414
3415         /* check support mq_mode for DCB */
3416         if (dev_conf->rxmode.mq_mode != ETH_MQ_RX_VMDQ_DCB &&
3417             dev_conf->rxmode.mq_mode != ETH_MQ_RX_DCB &&
3418             dev_conf->rxmode.mq_mode != ETH_MQ_RX_DCB_RSS)
3419                 return;
3420
3421         if (dev->data->nb_rx_queues > ETH_DCB_NUM_QUEUES)
3422                 return;
3423
3424         /** Configure DCB hardware **/
3425         txgbe_dcb_hw_configure(dev, dcb_cfg);
3426 }
3427
3428 /*
3429  * VMDq only support for 10 GbE NIC.
3430  */
3431 static void
3432 txgbe_vmdq_rx_hw_configure(struct rte_eth_dev *dev)
3433 {
3434         struct rte_eth_vmdq_rx_conf *cfg;
3435         struct txgbe_hw *hw;
3436         enum rte_eth_nb_pools num_pools;
3437         uint32_t mrqc, vt_ctl, vlanctrl;
3438         uint32_t vmolr = 0;
3439         int i;
3440
3441         PMD_INIT_FUNC_TRACE();
3442         hw = TXGBE_DEV_HW(dev);
3443         cfg = &dev->data->dev_conf.rx_adv_conf.vmdq_rx_conf;
3444         num_pools = cfg->nb_queue_pools;
3445
3446         txgbe_rss_disable(dev);
3447
3448         /* enable vmdq */
3449         mrqc = TXGBE_PORTCTL_NUMVT_64;
3450         wr32m(hw, TXGBE_PORTCTL, TXGBE_PORTCTL_NUMVT_MASK, mrqc);
3451
3452         /* turn on virtualisation and set the default pool */
3453         vt_ctl = TXGBE_POOLCTL_RPLEN;
3454         if (cfg->enable_default_pool)
3455                 vt_ctl |= TXGBE_POOLCTL_DEFPL(cfg->default_pool);
3456         else
3457                 vt_ctl |= TXGBE_POOLCTL_DEFDSA;
3458
3459         wr32(hw, TXGBE_POOLCTL, vt_ctl);
3460
3461         for (i = 0; i < (int)num_pools; i++) {
3462                 vmolr = txgbe_convert_vm_rx_mask_to_val(cfg->rx_mode, vmolr);
3463                 wr32(hw, TXGBE_POOLETHCTL(i), vmolr);
3464         }
3465
3466         /* enable vlan filtering and allow all vlan tags through */
3467         vlanctrl = rd32(hw, TXGBE_VLANCTL);
3468         vlanctrl |= TXGBE_VLANCTL_VFE; /* enable vlan filters */
3469         wr32(hw, TXGBE_VLANCTL, vlanctrl);
3470
3471         /* enable all vlan filters */
3472         for (i = 0; i < NUM_VFTA_REGISTERS; i++)
3473                 wr32(hw, TXGBE_VLANTBL(i), UINT32_MAX);
3474
3475         /* pool enabling for receive - 64 */
3476         wr32(hw, TXGBE_POOLRXENA(0), UINT32_MAX);
3477         if (num_pools == ETH_64_POOLS)
3478                 wr32(hw, TXGBE_POOLRXENA(1), UINT32_MAX);
3479
3480         /*
3481          * allow pools to read specific mac addresses
3482          * In this case, all pools should be able to read from mac addr 0
3483          */
3484         wr32(hw, TXGBE_ETHADDRIDX, 0);
3485         wr32(hw, TXGBE_ETHADDRASSL, 0xFFFFFFFF);
3486         wr32(hw, TXGBE_ETHADDRASSH, 0xFFFFFFFF);
3487
3488         /* set up filters for vlan tags as configured */
3489         for (i = 0; i < cfg->nb_pool_maps; i++) {
3490                 /* set vlan id in VF register and set the valid bit */
3491                 wr32(hw, TXGBE_PSRVLANIDX, i);
3492                 wr32(hw, TXGBE_PSRVLAN, (TXGBE_PSRVLAN_EA |
3493                                 TXGBE_PSRVLAN_VID(cfg->pool_map[i].vlan_id)));
3494                 /*
3495                  * Put the allowed pools in VFB reg. As we only have 16 or 64
3496                  * pools, we only need to use the first half of the register
3497                  * i.e. bits 0-31
3498                  */
3499                 if (((cfg->pool_map[i].pools >> 32) & UINT32_MAX) == 0)
3500                         wr32(hw, TXGBE_PSRVLANPLM(0),
3501                                 (cfg->pool_map[i].pools & UINT32_MAX));
3502                 else
3503                         wr32(hw, TXGBE_PSRVLANPLM(1),
3504                                 ((cfg->pool_map[i].pools >> 32) & UINT32_MAX));
3505         }
3506
3507         /* Tx General Switch Control Enables VMDQ loopback */
3508         if (cfg->enable_loop_back) {
3509                 wr32(hw, TXGBE_PSRCTL, TXGBE_PSRCTL_LBENA);
3510                 for (i = 0; i < 64; i++)
3511                         wr32m(hw, TXGBE_POOLETHCTL(i),
3512                                 TXGBE_POOLETHCTL_LLB, TXGBE_POOLETHCTL_LLB);
3513         }
3514
3515         txgbe_flush(hw);
3516 }
3517
3518 /*
3519  * txgbe_vmdq_tx_hw_configure - Configure general VMDq TX parameters
3520  * @hw: pointer to hardware structure
3521  */
3522 static void
3523 txgbe_vmdq_tx_hw_configure(struct txgbe_hw *hw)
3524 {
3525         uint32_t reg;
3526         uint32_t q;
3527
3528         PMD_INIT_FUNC_TRACE();
3529         /*PF VF Transmit Enable*/
3530         wr32(hw, TXGBE_POOLTXENA(0), UINT32_MAX);
3531         wr32(hw, TXGBE_POOLTXENA(1), UINT32_MAX);
3532
3533         /* Disable the Tx desc arbiter */
3534         reg = rd32(hw, TXGBE_ARBTXCTL);
3535         reg |= TXGBE_ARBTXCTL_DIA;
3536         wr32(hw, TXGBE_ARBTXCTL, reg);
3537
3538         wr32m(hw, TXGBE_PORTCTL, TXGBE_PORTCTL_NUMVT_MASK,
3539                 TXGBE_PORTCTL_NUMVT_64);
3540
3541         /* Disable drop for all queues */
3542         for (q = 0; q < 128; q++) {
3543                 u32 val = 1 << (q % 32);
3544                 wr32m(hw, TXGBE_QPRXDROP(q / 32), val, val);
3545         }
3546
3547         /* Enable the Tx desc arbiter */
3548         reg = rd32(hw, TXGBE_ARBTXCTL);
3549         reg &= ~TXGBE_ARBTXCTL_DIA;
3550         wr32(hw, TXGBE_ARBTXCTL, reg);
3551
3552         txgbe_flush(hw);
3553 }
3554
3555 static int __rte_cold
3556 txgbe_alloc_rx_queue_mbufs(struct txgbe_rx_queue *rxq)
3557 {
3558         struct txgbe_rx_entry *rxe = rxq->sw_ring;
3559         uint64_t dma_addr;
3560         unsigned int i;
3561
3562         /* Initialize software ring entries */
3563         for (i = 0; i < rxq->nb_rx_desc; i++) {
3564                 volatile struct txgbe_rx_desc *rxd;
3565                 struct rte_mbuf *mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
3566
3567                 if (mbuf == NULL) {
3568                         PMD_INIT_LOG(ERR, "RX mbuf alloc failed queue_id=%u",
3569                                      (unsigned int)rxq->queue_id);
3570                         return -ENOMEM;
3571                 }
3572
3573                 mbuf->data_off = RTE_PKTMBUF_HEADROOM;
3574                 mbuf->port = rxq->port_id;
3575
3576                 dma_addr =
3577                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(mbuf));
3578                 rxd = &rxq->rx_ring[i];
3579                 TXGBE_RXD_HDRADDR(rxd, 0);
3580                 TXGBE_RXD_PKTADDR(rxd, dma_addr);
3581                 rxe[i].mbuf = mbuf;
3582         }
3583
3584         return 0;
3585 }
3586
3587 static int
3588 txgbe_config_vf_rss(struct rte_eth_dev *dev)
3589 {
3590         struct txgbe_hw *hw;
3591         uint32_t mrqc;
3592
3593         txgbe_rss_configure(dev);
3594
3595         hw = TXGBE_DEV_HW(dev);
3596
3597         /* enable VF RSS */
3598         mrqc = rd32(hw, TXGBE_PORTCTL);
3599         mrqc &= ~(TXGBE_PORTCTL_NUMTC_MASK | TXGBE_PORTCTL_NUMVT_MASK);
3600         switch (RTE_ETH_DEV_SRIOV(dev).active) {
3601         case ETH_64_POOLS:
3602                 mrqc |= TXGBE_PORTCTL_NUMVT_64;
3603                 break;
3604
3605         case ETH_32_POOLS:
3606                 mrqc |= TXGBE_PORTCTL_NUMVT_32;
3607                 break;
3608
3609         default:
3610                 PMD_INIT_LOG(ERR, "Invalid pool number in IOV mode with VMDQ RSS");
3611                 return -EINVAL;
3612         }
3613
3614         wr32(hw, TXGBE_PORTCTL, mrqc);
3615
3616         return 0;
3617 }
3618
3619 static int
3620 txgbe_config_vf_default(struct rte_eth_dev *dev)
3621 {
3622         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3623         uint32_t mrqc;
3624
3625         mrqc = rd32(hw, TXGBE_PORTCTL);
3626         mrqc &= ~(TXGBE_PORTCTL_NUMTC_MASK | TXGBE_PORTCTL_NUMVT_MASK);
3627         switch (RTE_ETH_DEV_SRIOV(dev).active) {
3628         case ETH_64_POOLS:
3629                 mrqc |= TXGBE_PORTCTL_NUMVT_64;
3630                 break;
3631
3632         case ETH_32_POOLS:
3633                 mrqc |= TXGBE_PORTCTL_NUMVT_32;
3634                 break;
3635
3636         case ETH_16_POOLS:
3637                 mrqc |= TXGBE_PORTCTL_NUMVT_16;
3638                 break;
3639         default:
3640                 PMD_INIT_LOG(ERR,
3641                         "invalid pool number in IOV mode");
3642                 return 0;
3643         }
3644
3645         wr32(hw, TXGBE_PORTCTL, mrqc);
3646
3647         return 0;
3648 }
3649
3650 static int
3651 txgbe_dev_mq_rx_configure(struct rte_eth_dev *dev)
3652 {
3653         if (RTE_ETH_DEV_SRIOV(dev).active == 0) {
3654                 /*
3655                  * SRIOV inactive scheme
3656                  * any DCB/RSS w/o VMDq multi-queue setting
3657                  */
3658                 switch (dev->data->dev_conf.rxmode.mq_mode) {
3659                 case ETH_MQ_RX_RSS:
3660                 case ETH_MQ_RX_DCB_RSS:
3661                 case ETH_MQ_RX_VMDQ_RSS:
3662                         txgbe_rss_configure(dev);
3663                         break;
3664
3665                 case ETH_MQ_RX_VMDQ_DCB:
3666                         txgbe_vmdq_dcb_configure(dev);
3667                         break;
3668
3669                 case ETH_MQ_RX_VMDQ_ONLY:
3670                         txgbe_vmdq_rx_hw_configure(dev);
3671                         break;
3672
3673                 case ETH_MQ_RX_NONE:
3674                 default:
3675                         /* if mq_mode is none, disable rss mode.*/
3676                         txgbe_rss_disable(dev);
3677                         break;
3678                 }
3679         } else {
3680                 /* SRIOV active scheme
3681                  * Support RSS together with SRIOV.
3682                  */
3683                 switch (dev->data->dev_conf.rxmode.mq_mode) {
3684                 case ETH_MQ_RX_RSS:
3685                 case ETH_MQ_RX_VMDQ_RSS:
3686                         txgbe_config_vf_rss(dev);
3687                         break;
3688                 case ETH_MQ_RX_VMDQ_DCB:
3689                 case ETH_MQ_RX_DCB:
3690                 /* In SRIOV, the configuration is the same as VMDq case */
3691                         txgbe_vmdq_dcb_configure(dev);
3692                         break;
3693                 /* DCB/RSS together with SRIOV is not supported */
3694                 case ETH_MQ_RX_VMDQ_DCB_RSS:
3695                 case ETH_MQ_RX_DCB_RSS:
3696                         PMD_INIT_LOG(ERR,
3697                                 "Could not support DCB/RSS with VMDq & SRIOV");
3698                         return -1;
3699                 default:
3700                         txgbe_config_vf_default(dev);
3701                         break;
3702                 }
3703         }
3704
3705         return 0;
3706 }
3707
3708 static int
3709 txgbe_dev_mq_tx_configure(struct rte_eth_dev *dev)
3710 {
3711         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3712         uint32_t mtqc;
3713         uint32_t rttdcs;
3714
3715         /* disable arbiter */
3716         rttdcs = rd32(hw, TXGBE_ARBTXCTL);
3717         rttdcs |= TXGBE_ARBTXCTL_DIA;
3718         wr32(hw, TXGBE_ARBTXCTL, rttdcs);
3719
3720         if (RTE_ETH_DEV_SRIOV(dev).active == 0) {
3721                 /*
3722                  * SRIOV inactive scheme
3723                  * any DCB w/o VMDq multi-queue setting
3724                  */
3725                 if (dev->data->dev_conf.txmode.mq_mode == ETH_MQ_TX_VMDQ_ONLY)
3726                         txgbe_vmdq_tx_hw_configure(hw);
3727                 else
3728                         wr32m(hw, TXGBE_PORTCTL, TXGBE_PORTCTL_NUMVT_MASK, 0);
3729         } else {
3730                 switch (RTE_ETH_DEV_SRIOV(dev).active) {
3731                 /*
3732                  * SRIOV active scheme
3733                  * FIXME if support DCB together with VMDq & SRIOV
3734                  */
3735                 case ETH_64_POOLS:
3736                         mtqc = TXGBE_PORTCTL_NUMVT_64;
3737                         break;
3738                 case ETH_32_POOLS:
3739                         mtqc = TXGBE_PORTCTL_NUMVT_32;
3740                         break;
3741                 case ETH_16_POOLS:
3742                         mtqc = TXGBE_PORTCTL_NUMVT_16;
3743                         break;
3744                 default:
3745                         mtqc = 0;
3746                         PMD_INIT_LOG(ERR, "invalid pool number in IOV mode");
3747                 }
3748                 wr32m(hw, TXGBE_PORTCTL, TXGBE_PORTCTL_NUMVT_MASK, mtqc);
3749         }
3750
3751         /* re-enable arbiter */
3752         rttdcs &= ~TXGBE_ARBTXCTL_DIA;
3753         wr32(hw, TXGBE_ARBTXCTL, rttdcs);
3754
3755         return 0;
3756 }
3757
3758 /**
3759  * txgbe_get_rscctl_maxdesc
3760  *
3761  * @pool Memory pool of the Rx queue
3762  */
3763 static inline uint32_t
3764 txgbe_get_rscctl_maxdesc(struct rte_mempool *pool)
3765 {
3766         struct rte_pktmbuf_pool_private *mp_priv = rte_mempool_get_priv(pool);
3767
3768         uint16_t maxdesc =
3769                 RTE_IPV4_MAX_PKT_LEN /
3770                         (mp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM);
3771
3772         if (maxdesc >= 16)
3773                 return TXGBE_RXCFG_RSCMAX_16;
3774         else if (maxdesc >= 8)
3775                 return TXGBE_RXCFG_RSCMAX_8;
3776         else if (maxdesc >= 4)
3777                 return TXGBE_RXCFG_RSCMAX_4;
3778         else
3779                 return TXGBE_RXCFG_RSCMAX_1;
3780 }
3781
3782 /**
3783  * txgbe_set_rsc - configure RSC related port HW registers
3784  *
3785  * Configures the port's RSC related registers.
3786  *
3787  * @dev port handle
3788  *
3789  * Returns 0 in case of success or a non-zero error code
3790  */
3791 static int
3792 txgbe_set_rsc(struct rte_eth_dev *dev)
3793 {
3794         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
3795         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3796         struct rte_eth_dev_info dev_info = { 0 };
3797         bool rsc_capable = false;
3798         uint16_t i;
3799         uint32_t rdrxctl;
3800         uint32_t rfctl;
3801
3802         /* Sanity check */
3803         dev->dev_ops->dev_infos_get(dev, &dev_info);
3804         if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_LRO)
3805                 rsc_capable = true;
3806
3807         if (!rsc_capable && (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO)) {
3808                 PMD_INIT_LOG(CRIT, "LRO is requested on HW that doesn't "
3809                                    "support it");
3810                 return -EINVAL;
3811         }
3812
3813         /* RSC global configuration */
3814
3815         if ((rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC) &&
3816              (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO)) {
3817                 PMD_INIT_LOG(CRIT, "LRO can't be enabled when HW CRC "
3818                                     "is disabled");
3819                 return -EINVAL;
3820         }
3821
3822         rfctl = rd32(hw, TXGBE_PSRCTL);
3823         if (rsc_capable && (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO))
3824                 rfctl &= ~TXGBE_PSRCTL_RSCDIA;
3825         else
3826                 rfctl |= TXGBE_PSRCTL_RSCDIA;
3827         wr32(hw, TXGBE_PSRCTL, rfctl);
3828
3829         /* If LRO hasn't been requested - we are done here. */
3830         if (!(rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO))
3831                 return 0;
3832
3833         /* Set PSRCTL.RSCACK bit */
3834         rdrxctl = rd32(hw, TXGBE_PSRCTL);
3835         rdrxctl |= TXGBE_PSRCTL_RSCACK;
3836         wr32(hw, TXGBE_PSRCTL, rdrxctl);
3837
3838         /* Per-queue RSC configuration */
3839         for (i = 0; i < dev->data->nb_rx_queues; i++) {
3840                 struct txgbe_rx_queue *rxq = dev->data->rx_queues[i];
3841                 uint32_t srrctl =
3842                         rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
3843                 uint32_t psrtype =
3844                         rd32(hw, TXGBE_POOLRSS(rxq->reg_idx));
3845                 uint32_t eitr =
3846                         rd32(hw, TXGBE_ITR(rxq->reg_idx));
3847
3848                 /*
3849                  * txgbe PMD doesn't support header-split at the moment.
3850                  */
3851                 srrctl &= ~TXGBE_RXCFG_HDRLEN_MASK;
3852                 srrctl |= TXGBE_RXCFG_HDRLEN(128);
3853
3854                 /*
3855                  * TODO: Consider setting the Receive Descriptor Minimum
3856                  * Threshold Size for an RSC case. This is not an obviously
3857                  * beneficiary option but the one worth considering...
3858                  */
3859
3860                 srrctl |= TXGBE_RXCFG_RSCENA;
3861                 srrctl &= ~TXGBE_RXCFG_RSCMAX_MASK;
3862                 srrctl |= txgbe_get_rscctl_maxdesc(rxq->mb_pool);
3863                 psrtype |= TXGBE_POOLRSS_L4HDR;
3864
3865                 /*
3866                  * RSC: Set ITR interval corresponding to 2K ints/s.
3867                  *
3868                  * Full-sized RSC aggregations for a 10Gb/s link will
3869                  * arrive at about 20K aggregation/s rate.
3870                  *
3871                  * 2K inst/s rate will make only 10% of the
3872                  * aggregations to be closed due to the interrupt timer
3873                  * expiration for a streaming at wire-speed case.
3874                  *
3875                  * For a sparse streaming case this setting will yield
3876                  * at most 500us latency for a single RSC aggregation.
3877                  */
3878                 eitr &= ~TXGBE_ITR_IVAL_MASK;
3879                 eitr |= TXGBE_ITR_IVAL_10G(TXGBE_QUEUE_ITR_INTERVAL_DEFAULT);
3880                 eitr |= TXGBE_ITR_WRDSA;
3881
3882                 wr32(hw, TXGBE_RXCFG(rxq->reg_idx), srrctl);
3883                 wr32(hw, TXGBE_POOLRSS(rxq->reg_idx), psrtype);
3884                 wr32(hw, TXGBE_ITR(rxq->reg_idx), eitr);
3885
3886                 /*
3887                  * RSC requires the mapping of the queue to the
3888                  * interrupt vector.
3889                  */
3890                 txgbe_set_ivar_map(hw, 0, rxq->reg_idx, i);
3891         }
3892
3893         dev->data->lro = 1;
3894
3895         PMD_INIT_LOG(DEBUG, "enabling LRO mode");
3896
3897         return 0;
3898 }
3899
3900 void __rte_cold
3901 txgbe_set_rx_function(struct rte_eth_dev *dev)
3902 {
3903         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
3904
3905         /*
3906          * Initialize the appropriate LRO callback.
3907          *
3908          * If all queues satisfy the bulk allocation preconditions
3909          * (adapter->rx_bulk_alloc_allowed is TRUE) then we may use
3910          * bulk allocation. Otherwise use a single allocation version.
3911          */
3912         if (dev->data->lro) {
3913                 if (adapter->rx_bulk_alloc_allowed) {
3914                         PMD_INIT_LOG(DEBUG, "LRO is requested. Using a bulk "
3915                                            "allocation version");
3916                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_bulk_alloc;
3917                 } else {
3918                         PMD_INIT_LOG(DEBUG, "LRO is requested. Using a single "
3919                                            "allocation version");
3920                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_single_alloc;
3921                 }
3922         } else if (dev->data->scattered_rx) {
3923                 /*
3924                  * Set the non-LRO scattered callback: there are bulk and
3925                  * single allocation versions.
3926                  */
3927                 if (adapter->rx_bulk_alloc_allowed) {
3928                         PMD_INIT_LOG(DEBUG, "Using a Scattered with bulk "
3929                                            "allocation callback (port=%d).",
3930                                      dev->data->port_id);
3931                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_bulk_alloc;
3932                 } else {
3933                         PMD_INIT_LOG(DEBUG, "Using Regular (non-vector, "
3934                                             "single allocation) "
3935                                             "Scattered Rx callback "
3936                                             "(port=%d).",
3937                                      dev->data->port_id);
3938
3939                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_single_alloc;
3940                 }
3941         /*
3942          * Below we set "simple" callbacks according to port/queues parameters.
3943          * If parameters allow we are going to choose between the following
3944          * callbacks:
3945          *    - Bulk Allocation
3946          *    - Single buffer allocation (the simplest one)
3947          */
3948         } else if (adapter->rx_bulk_alloc_allowed) {
3949                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are "
3950                                     "satisfied. Rx Burst Bulk Alloc function "
3951                                     "will be used on port=%d.",
3952                              dev->data->port_id);
3953
3954                 dev->rx_pkt_burst = txgbe_recv_pkts_bulk_alloc;
3955         } else {
3956                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are not "
3957                                     "satisfied, or Scattered Rx is requested "
3958                                     "(port=%d).",
3959                              dev->data->port_id);
3960
3961                 dev->rx_pkt_burst = txgbe_recv_pkts;
3962         }
3963 }
3964
3965 /*
3966  * Initializes Receive Unit.
3967  */
3968 int __rte_cold
3969 txgbe_dev_rx_init(struct rte_eth_dev *dev)
3970 {
3971         struct txgbe_hw *hw;
3972         struct txgbe_rx_queue *rxq;
3973         uint64_t bus_addr;
3974         uint32_t fctrl;
3975         uint32_t hlreg0;
3976         uint32_t srrctl;
3977         uint32_t rdrxctl;
3978         uint32_t rxcsum;
3979         uint16_t buf_size;
3980         uint16_t i;
3981         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
3982         int rc;
3983
3984         PMD_INIT_FUNC_TRACE();
3985         hw = TXGBE_DEV_HW(dev);
3986
3987         /*
3988          * Make sure receives are disabled while setting
3989          * up the RX context (registers, descriptor rings, etc.).
3990          */
3991         wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_ENA, 0);
3992         wr32m(hw, TXGBE_PBRXCTL, TXGBE_PBRXCTL_ENA, 0);
3993
3994         /* Enable receipt of broadcasted frames */
3995         fctrl = rd32(hw, TXGBE_PSRCTL);
3996         fctrl |= TXGBE_PSRCTL_BCA;
3997         wr32(hw, TXGBE_PSRCTL, fctrl);
3998
3999         /*
4000          * Configure CRC stripping, if any.
4001          */
4002         hlreg0 = rd32(hw, TXGBE_SECRXCTL);
4003         if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
4004                 hlreg0 &= ~TXGBE_SECRXCTL_CRCSTRIP;
4005         else
4006                 hlreg0 |= TXGBE_SECRXCTL_CRCSTRIP;
4007         wr32(hw, TXGBE_SECRXCTL, hlreg0);
4008
4009         /*
4010          * Configure jumbo frame support, if any.
4011          */
4012         if (rx_conf->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
4013                 wr32m(hw, TXGBE_FRMSZ, TXGBE_FRMSZ_MAX_MASK,
4014                         TXGBE_FRMSZ_MAX(rx_conf->max_rx_pkt_len));
4015         } else {
4016                 wr32m(hw, TXGBE_FRMSZ, TXGBE_FRMSZ_MAX_MASK,
4017                         TXGBE_FRMSZ_MAX(TXGBE_FRAME_SIZE_DFT));
4018         }
4019
4020         /*
4021          * If loopback mode is configured, set LPBK bit.
4022          */
4023         hlreg0 = rd32(hw, TXGBE_PSRCTL);
4024         if (hw->mac.type == txgbe_mac_raptor &&
4025             dev->data->dev_conf.lpbk_mode)
4026                 hlreg0 |= TXGBE_PSRCTL_LBENA;
4027         else
4028                 hlreg0 &= ~TXGBE_PSRCTL_LBENA;
4029
4030         wr32(hw, TXGBE_PSRCTL, hlreg0);
4031
4032         /*
4033          * Assume no header split and no VLAN strip support
4034          * on any Rx queue first .
4035          */
4036         rx_conf->offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
4037
4038         /* Setup RX queues */
4039         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4040                 rxq = dev->data->rx_queues[i];
4041
4042                 /*
4043                  * Reset crc_len in case it was changed after queue setup by a
4044                  * call to configure.
4045                  */
4046                 if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
4047                         rxq->crc_len = RTE_ETHER_CRC_LEN;
4048                 else
4049                         rxq->crc_len = 0;
4050
4051                 /* Setup the Base and Length of the Rx Descriptor Rings */
4052                 bus_addr = rxq->rx_ring_phys_addr;
4053                 wr32(hw, TXGBE_RXBAL(rxq->reg_idx),
4054                                 (uint32_t)(bus_addr & BIT_MASK32));
4055                 wr32(hw, TXGBE_RXBAH(rxq->reg_idx),
4056                                 (uint32_t)(bus_addr >> 32));
4057                 wr32(hw, TXGBE_RXRP(rxq->reg_idx), 0);
4058                 wr32(hw, TXGBE_RXWP(rxq->reg_idx), 0);
4059
4060                 srrctl = TXGBE_RXCFG_RNGLEN(rxq->nb_rx_desc);
4061
4062                 /* Set if packets are dropped when no descriptors available */
4063                 if (rxq->drop_en)
4064                         srrctl |= TXGBE_RXCFG_DROP;
4065
4066                 /*
4067                  * Configure the RX buffer size in the PKTLEN field of
4068                  * the RXCFG register of the queue.
4069                  * The value is in 1 KB resolution. Valid values can be from
4070                  * 1 KB to 16 KB.
4071                  */
4072                 buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rxq->mb_pool) -
4073                         RTE_PKTMBUF_HEADROOM);
4074                 buf_size = ROUND_UP(buf_size, 0x1 << 10);
4075                 srrctl |= TXGBE_RXCFG_PKTLEN(buf_size);
4076
4077                 wr32(hw, TXGBE_RXCFG(rxq->reg_idx), srrctl);
4078
4079                 /* It adds dual VLAN length for supporting dual VLAN */
4080                 if (dev->data->dev_conf.rxmode.max_rx_pkt_len +
4081                                             2 * TXGBE_VLAN_TAG_SIZE > buf_size)
4082                         dev->data->scattered_rx = 1;
4083                 if (rxq->offloads & DEV_RX_OFFLOAD_VLAN_STRIP)
4084                         rx_conf->offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
4085         }
4086
4087         if (rx_conf->offloads & DEV_RX_OFFLOAD_SCATTER)
4088                 dev->data->scattered_rx = 1;
4089
4090         /*
4091          * Device configured with multiple RX queues.
4092          */
4093         txgbe_dev_mq_rx_configure(dev);
4094
4095         /*
4096          * Setup the Checksum Register.
4097          * Disable Full-Packet Checksum which is mutually exclusive with RSS.
4098          * Enable IP/L4 checksum computation by hardware if requested to do so.
4099          */
4100         rxcsum = rd32(hw, TXGBE_PSRCTL);
4101         rxcsum |= TXGBE_PSRCTL_PCSD;
4102         if (rx_conf->offloads & DEV_RX_OFFLOAD_CHECKSUM)
4103                 rxcsum |= TXGBE_PSRCTL_L4CSUM;
4104         else
4105                 rxcsum &= ~TXGBE_PSRCTL_L4CSUM;
4106
4107         wr32(hw, TXGBE_PSRCTL, rxcsum);
4108
4109         if (hw->mac.type == txgbe_mac_raptor) {
4110                 rdrxctl = rd32(hw, TXGBE_SECRXCTL);
4111                 if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
4112                         rdrxctl &= ~TXGBE_SECRXCTL_CRCSTRIP;
4113                 else
4114                         rdrxctl |= TXGBE_SECRXCTL_CRCSTRIP;
4115                 wr32(hw, TXGBE_SECRXCTL, rdrxctl);
4116         }
4117
4118         rc = txgbe_set_rsc(dev);
4119         if (rc)
4120                 return rc;
4121
4122         txgbe_set_rx_function(dev);
4123
4124         return 0;
4125 }
4126
4127 /*
4128  * Initializes Transmit Unit.
4129  */
4130 void __rte_cold
4131 txgbe_dev_tx_init(struct rte_eth_dev *dev)
4132 {
4133         struct txgbe_hw     *hw;
4134         struct txgbe_tx_queue *txq;
4135         uint64_t bus_addr;
4136         uint16_t i;
4137
4138         PMD_INIT_FUNC_TRACE();
4139         hw = TXGBE_DEV_HW(dev);
4140
4141         /* Setup the Base and Length of the Tx Descriptor Rings */
4142         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4143                 txq = dev->data->tx_queues[i];
4144
4145                 bus_addr = txq->tx_ring_phys_addr;
4146                 wr32(hw, TXGBE_TXBAL(txq->reg_idx),
4147                                 (uint32_t)(bus_addr & BIT_MASK32));
4148                 wr32(hw, TXGBE_TXBAH(txq->reg_idx),
4149                                 (uint32_t)(bus_addr >> 32));
4150                 wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_BUFLEN_MASK,
4151                         TXGBE_TXCFG_BUFLEN(txq->nb_tx_desc));
4152                 /* Setup the HW Tx Head and TX Tail descriptor pointers */
4153                 wr32(hw, TXGBE_TXRP(txq->reg_idx), 0);
4154                 wr32(hw, TXGBE_TXWP(txq->reg_idx), 0);
4155         }
4156
4157         /* Device configured with multiple TX queues. */
4158         txgbe_dev_mq_tx_configure(dev);
4159 }
4160
4161 /*
4162  * Set up link loopback mode Tx->Rx.
4163  */
4164 static inline void __rte_cold
4165 txgbe_setup_loopback_link_raptor(struct txgbe_hw *hw)
4166 {
4167         PMD_INIT_FUNC_TRACE();
4168
4169         wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_LB, TXGBE_MACRXCFG_LB);
4170
4171         msec_delay(50);
4172 }
4173
4174 /*
4175  * Start Transmit and Receive Units.
4176  */
4177 int __rte_cold
4178 txgbe_dev_rxtx_start(struct rte_eth_dev *dev)
4179 {
4180         struct txgbe_hw     *hw;
4181         struct txgbe_tx_queue *txq;
4182         struct txgbe_rx_queue *rxq;
4183         uint32_t dmatxctl;
4184         uint32_t rxctrl;
4185         uint16_t i;
4186         int ret = 0;
4187
4188         PMD_INIT_FUNC_TRACE();
4189         hw = TXGBE_DEV_HW(dev);
4190
4191         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4192                 txq = dev->data->tx_queues[i];
4193                 /* Setup Transmit Threshold Registers */
4194                 wr32m(hw, TXGBE_TXCFG(txq->reg_idx),
4195                       TXGBE_TXCFG_HTHRESH_MASK |
4196                       TXGBE_TXCFG_WTHRESH_MASK,
4197                       TXGBE_TXCFG_HTHRESH(txq->hthresh) |
4198                       TXGBE_TXCFG_WTHRESH(txq->wthresh));
4199         }
4200
4201         dmatxctl = rd32(hw, TXGBE_DMATXCTRL);
4202         dmatxctl |= TXGBE_DMATXCTRL_ENA;
4203         wr32(hw, TXGBE_DMATXCTRL, dmatxctl);
4204
4205         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4206                 txq = dev->data->tx_queues[i];
4207                 if (!txq->tx_deferred_start) {
4208                         ret = txgbe_dev_tx_queue_start(dev, i);
4209                         if (ret < 0)
4210                                 return ret;
4211                 }
4212         }
4213
4214         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4215                 rxq = dev->data->rx_queues[i];
4216                 if (!rxq->rx_deferred_start) {
4217                         ret = txgbe_dev_rx_queue_start(dev, i);
4218                         if (ret < 0)
4219                                 return ret;
4220                 }
4221         }
4222
4223         /* Enable Receive engine */
4224         rxctrl = rd32(hw, TXGBE_PBRXCTL);
4225         rxctrl |= TXGBE_PBRXCTL_ENA;
4226         hw->mac.enable_rx_dma(hw, rxctrl);
4227
4228         /* If loopback mode is enabled, set up the link accordingly */
4229         if (hw->mac.type == txgbe_mac_raptor &&
4230             dev->data->dev_conf.lpbk_mode)
4231                 txgbe_setup_loopback_link_raptor(hw);
4232
4233         return 0;
4234 }
4235
4236 void
4237 txgbe_dev_save_rx_queue(struct txgbe_hw *hw, uint16_t rx_queue_id)
4238 {
4239         u32 *reg = &hw->q_rx_regs[rx_queue_id * 8];
4240         *(reg++) = rd32(hw, TXGBE_RXBAL(rx_queue_id));
4241         *(reg++) = rd32(hw, TXGBE_RXBAH(rx_queue_id));
4242         *(reg++) = rd32(hw, TXGBE_RXCFG(rx_queue_id));
4243 }
4244
4245 void
4246 txgbe_dev_store_rx_queue(struct txgbe_hw *hw, uint16_t rx_queue_id)
4247 {
4248         u32 *reg = &hw->q_rx_regs[rx_queue_id * 8];
4249         wr32(hw, TXGBE_RXBAL(rx_queue_id), *(reg++));
4250         wr32(hw, TXGBE_RXBAH(rx_queue_id), *(reg++));
4251         wr32(hw, TXGBE_RXCFG(rx_queue_id), *(reg++) & ~TXGBE_RXCFG_ENA);
4252 }
4253
4254 void
4255 txgbe_dev_save_tx_queue(struct txgbe_hw *hw, uint16_t tx_queue_id)
4256 {
4257         u32 *reg = &hw->q_tx_regs[tx_queue_id * 8];
4258         *(reg++) = rd32(hw, TXGBE_TXBAL(tx_queue_id));
4259         *(reg++) = rd32(hw, TXGBE_TXBAH(tx_queue_id));
4260         *(reg++) = rd32(hw, TXGBE_TXCFG(tx_queue_id));
4261 }
4262
4263 void
4264 txgbe_dev_store_tx_queue(struct txgbe_hw *hw, uint16_t tx_queue_id)
4265 {
4266         u32 *reg = &hw->q_tx_regs[tx_queue_id * 8];
4267         wr32(hw, TXGBE_TXBAL(tx_queue_id), *(reg++));
4268         wr32(hw, TXGBE_TXBAH(tx_queue_id), *(reg++));
4269         wr32(hw, TXGBE_TXCFG(tx_queue_id), *(reg++) & ~TXGBE_TXCFG_ENA);
4270 }
4271
4272 /*
4273  * Start Receive Units for specified queue.
4274  */
4275 int __rte_cold
4276 txgbe_dev_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
4277 {
4278         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
4279         struct txgbe_rx_queue *rxq;
4280         uint32_t rxdctl;
4281         int poll_ms;
4282
4283         PMD_INIT_FUNC_TRACE();
4284
4285         rxq = dev->data->rx_queues[rx_queue_id];
4286
4287         /* Allocate buffers for descriptor rings */
4288         if (txgbe_alloc_rx_queue_mbufs(rxq) != 0) {
4289                 PMD_INIT_LOG(ERR, "Could not alloc mbuf for queue:%d",
4290                              rx_queue_id);
4291                 return -1;
4292         }
4293         rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
4294         rxdctl |= TXGBE_RXCFG_ENA;
4295         wr32(hw, TXGBE_RXCFG(rxq->reg_idx), rxdctl);
4296
4297         /* Wait until RX Enable ready */
4298         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
4299         do {
4300                 rte_delay_ms(1);
4301                 rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
4302         } while (--poll_ms && !(rxdctl & TXGBE_RXCFG_ENA));
4303         if (!poll_ms)
4304                 PMD_INIT_LOG(ERR, "Could not enable Rx Queue %d", rx_queue_id);
4305         rte_wmb();
4306         wr32(hw, TXGBE_RXRP(rxq->reg_idx), 0);
4307         wr32(hw, TXGBE_RXWP(rxq->reg_idx), rxq->nb_rx_desc - 1);
4308         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
4309
4310         return 0;
4311 }
4312
4313 /*
4314  * Stop Receive Units for specified queue.
4315  */
4316 int __rte_cold
4317 txgbe_dev_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id)
4318 {
4319         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
4320         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
4321         struct txgbe_rx_queue *rxq;
4322         uint32_t rxdctl;
4323         int poll_ms;
4324
4325         PMD_INIT_FUNC_TRACE();
4326
4327         rxq = dev->data->rx_queues[rx_queue_id];
4328
4329         txgbe_dev_save_rx_queue(hw, rxq->reg_idx);
4330         wr32m(hw, TXGBE_RXCFG(rxq->reg_idx), TXGBE_RXCFG_ENA, 0);
4331
4332         /* Wait until RX Enable bit clear */
4333         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
4334         do {
4335                 rte_delay_ms(1);
4336                 rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
4337         } while (--poll_ms && (rxdctl & TXGBE_RXCFG_ENA));
4338         if (!poll_ms)
4339                 PMD_INIT_LOG(ERR, "Could not disable Rx Queue %d", rx_queue_id);
4340
4341         rte_delay_us(RTE_TXGBE_WAIT_100_US);
4342         txgbe_dev_store_rx_queue(hw, rxq->reg_idx);
4343
4344         txgbe_rx_queue_release_mbufs(rxq);
4345         txgbe_reset_rx_queue(adapter, rxq);
4346         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
4347
4348         return 0;
4349 }
4350
4351 /*
4352  * Start Transmit Units for specified queue.
4353  */
4354 int __rte_cold
4355 txgbe_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
4356 {
4357         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
4358         struct txgbe_tx_queue *txq;
4359         uint32_t txdctl;
4360         int poll_ms;
4361
4362         PMD_INIT_FUNC_TRACE();
4363
4364         txq = dev->data->tx_queues[tx_queue_id];
4365         wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_ENA, TXGBE_TXCFG_ENA);
4366
4367         /* Wait until TX Enable ready */
4368         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
4369         do {
4370                 rte_delay_ms(1);
4371                 txdctl = rd32(hw, TXGBE_TXCFG(txq->reg_idx));
4372         } while (--poll_ms && !(txdctl & TXGBE_TXCFG_ENA));
4373         if (!poll_ms)
4374                 PMD_INIT_LOG(ERR, "Could not enable "
4375                              "Tx Queue %d", tx_queue_id);
4376
4377         rte_wmb();
4378         wr32(hw, TXGBE_TXWP(txq->reg_idx), txq->tx_tail);
4379         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
4380
4381         return 0;
4382 }
4383
4384 /*
4385  * Stop Transmit Units for specified queue.
4386  */
4387 int __rte_cold
4388 txgbe_dev_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
4389 {
4390         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
4391         struct txgbe_tx_queue *txq;
4392         uint32_t txdctl;
4393         uint32_t txtdh, txtdt;
4394         int poll_ms;
4395
4396         PMD_INIT_FUNC_TRACE();
4397
4398         txq = dev->data->tx_queues[tx_queue_id];
4399
4400         /* Wait until TX queue is empty */
4401         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
4402         do {
4403                 rte_delay_us(RTE_TXGBE_WAIT_100_US);
4404                 txtdh = rd32(hw, TXGBE_TXRP(txq->reg_idx));
4405                 txtdt = rd32(hw, TXGBE_TXWP(txq->reg_idx));
4406         } while (--poll_ms && (txtdh != txtdt));
4407         if (!poll_ms)
4408                 PMD_INIT_LOG(ERR,
4409                         "Tx Queue %d is not empty when stopping.",
4410                         tx_queue_id);
4411
4412         txgbe_dev_save_tx_queue(hw, txq->reg_idx);
4413         wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_ENA, 0);
4414
4415         /* Wait until TX Enable bit clear */
4416         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
4417         do {
4418                 rte_delay_ms(1);
4419                 txdctl = rd32(hw, TXGBE_TXCFG(txq->reg_idx));
4420         } while (--poll_ms && (txdctl & TXGBE_TXCFG_ENA));
4421         if (!poll_ms)
4422                 PMD_INIT_LOG(ERR, "Could not disable Tx Queue %d",
4423                         tx_queue_id);
4424
4425         rte_delay_us(RTE_TXGBE_WAIT_100_US);
4426         txgbe_dev_store_tx_queue(hw, txq->reg_idx);
4427
4428         if (txq->ops != NULL) {
4429                 txq->ops->release_mbufs(txq);
4430                 txq->ops->reset(txq);
4431         }
4432         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
4433
4434         return 0;
4435 }
4436
4437 void
4438 txgbe_rxq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
4439         struct rte_eth_rxq_info *qinfo)
4440 {
4441         struct txgbe_rx_queue *rxq;
4442
4443         rxq = dev->data->rx_queues[queue_id];
4444
4445         qinfo->mp = rxq->mb_pool;
4446         qinfo->scattered_rx = dev->data->scattered_rx;
4447         qinfo->nb_desc = rxq->nb_rx_desc;
4448
4449         qinfo->conf.rx_free_thresh = rxq->rx_free_thresh;
4450         qinfo->conf.rx_drop_en = rxq->drop_en;
4451         qinfo->conf.rx_deferred_start = rxq->rx_deferred_start;
4452         qinfo->conf.offloads = rxq->offloads;
4453 }
4454
4455 void
4456 txgbe_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
4457         struct rte_eth_txq_info *qinfo)
4458 {
4459         struct txgbe_tx_queue *txq;
4460
4461         txq = dev->data->tx_queues[queue_id];
4462
4463         qinfo->nb_desc = txq->nb_tx_desc;
4464
4465         qinfo->conf.tx_thresh.pthresh = txq->pthresh;
4466         qinfo->conf.tx_thresh.hthresh = txq->hthresh;
4467         qinfo->conf.tx_thresh.wthresh = txq->wthresh;
4468
4469         qinfo->conf.tx_free_thresh = txq->tx_free_thresh;
4470         qinfo->conf.offloads = txq->offloads;
4471         qinfo->conf.tx_deferred_start = txq->tx_deferred_start;
4472 }
4473