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 /* Bit Mask to indicate what bits required for building TX context */
  44 static const u64 TXGBE_TX_OFFLOAD_MASK = (PKT_TX_IP_CKSUM |
  45                 PKT_TX_OUTER_IPV6 |
  46                 PKT_TX_OUTER_IPV4 |
  47                 PKT_TX_IPV6 |
  48                 PKT_TX_IPV4 |
  49                 PKT_TX_VLAN_PKT |
  50                 PKT_TX_L4_MASK |
  51                 PKT_TX_TCP_SEG |
  52                 PKT_TX_TUNNEL_MASK |
  53                 PKT_TX_OUTER_IP_CKSUM);
  54
  55 #define TXGBE_TX_OFFLOAD_NOTSUP_MASK \
  56                 (PKT_TX_OFFLOAD_MASK ^ TXGBE_TX_OFFLOAD_MASK)
  57
  58 /*
  59  * Prefetch a cache line into all cache levels.
  60  */
  61 #define rte_txgbe_prefetch(p)   rte_prefetch0(p)
  62
  63 static int
  64 txgbe_is_vf(struct rte_eth_dev *dev)
  65 {
  66         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
  67
  68         switch (hw->mac.type) {
  69         case txgbe_mac_raptor_vf:
  70                 return 1;
  71         default:
  72                 return 0;
  73         }
  74 }
  75
  76 /*********************************************************************
  77  *
  78  *  TX functions
  79  *
  80  **********************************************************************/
  81
  82 /*
  83  * Check for descriptors with their DD bit set and free mbufs.
  84  * Return the total number of buffers freed.
  85  */
  86 static __rte_always_inline int
  87 txgbe_tx_free_bufs(struct txgbe_tx_queue *txq)
  88 {
  89         struct txgbe_tx_entry *txep;
  90         uint32_t status;
  91         int i, nb_free = 0;
  92         struct rte_mbuf *m, *free[RTE_TXGBE_TX_MAX_FREE_BUF_SZ];
  93
  94         /* check DD bit on threshold descriptor */
  95         status = txq->tx_ring[txq->tx_next_dd].dw3;
  96         if (!(status & rte_cpu_to_le_32(TXGBE_TXD_DD))) {
  97                 if (txq->nb_tx_free >> 1 < txq->tx_free_thresh)
  98                         txgbe_set32_masked(txq->tdc_reg_addr,
  99                                 TXGBE_TXCFG_FLUSH, TXGBE_TXCFG_FLUSH);
 100                 return 0;
 101         }
 102
 103         /*
 104          * first buffer to free from S/W ring is at index
 105          * tx_next_dd - (tx_free_thresh-1)
 106          */
 107         txep = &txq->sw_ring[txq->tx_next_dd - (txq->tx_free_thresh - 1)];
 108         for (i = 0; i < txq->tx_free_thresh; ++i, ++txep) {
 109                 /* free buffers one at a time */
 110                 m = rte_pktmbuf_prefree_seg(txep->mbuf);
 111                 txep->mbuf = NULL;
 112
 113                 if (unlikely(m == NULL))
 114                         continue;
 115
 116                 if (nb_free >= RTE_TXGBE_TX_MAX_FREE_BUF_SZ ||
 117                     (nb_free > 0 && m->pool != free[0]->pool)) {
 118                         rte_mempool_put_bulk(free[0]->pool,
 119                                              (void **)free, nb_free);
 120                         nb_free = 0;
 121                 }
 122
 123                 free[nb_free++] = m;
 124         }
 125
 126         if (nb_free > 0)
 127                 rte_mempool_put_bulk(free[0]->pool, (void **)free, nb_free);
 128
 129         /* buffers were freed, update counters */
 130         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + txq->tx_free_thresh);
 131         txq->tx_next_dd = (uint16_t)(txq->tx_next_dd + txq->tx_free_thresh);
 132         if (txq->tx_next_dd >= txq->nb_tx_desc)
 133                 txq->tx_next_dd = (uint16_t)(txq->tx_free_thresh - 1);
 134
 135         return txq->tx_free_thresh;
 136 }
 137
 138 /* Populate 4 descriptors with data from 4 mbufs */
 139 static inline void
 140 tx4(volatile struct txgbe_tx_desc *txdp, struct rte_mbuf **pkts)
 141 {
 142         uint64_t buf_dma_addr;
 143         uint32_t pkt_len;
 144         int i;
 145
 146         for (i = 0; i < 4; ++i, ++txdp, ++pkts) {
 147                 buf_dma_addr = rte_mbuf_data_iova(*pkts);
 148                 pkt_len = (*pkts)->data_len;
 149
 150                 /* write data to descriptor */
 151                 txdp->qw0 = rte_cpu_to_le_64(buf_dma_addr);
 152                 txdp->dw2 = cpu_to_le32(TXGBE_TXD_FLAGS |
 153                                         TXGBE_TXD_DATLEN(pkt_len));
 154                 txdp->dw3 = cpu_to_le32(TXGBE_TXD_PAYLEN(pkt_len));
 155
 156                 rte_prefetch0(&(*pkts)->pool);
 157         }
 158 }
 159
 160 /* Populate 1 descriptor with data from 1 mbuf */
 161 static inline void
 162 tx1(volatile struct txgbe_tx_desc *txdp, struct rte_mbuf **pkts)
 163 {
 164         uint64_t buf_dma_addr;
 165         uint32_t pkt_len;
 166
 167         buf_dma_addr = rte_mbuf_data_iova(*pkts);
 168         pkt_len = (*pkts)->data_len;
 169
 170         /* write data to descriptor */
 171         txdp->qw0 = cpu_to_le64(buf_dma_addr);
 172         txdp->dw2 = cpu_to_le32(TXGBE_TXD_FLAGS |
 173                                 TXGBE_TXD_DATLEN(pkt_len));
 174         txdp->dw3 = cpu_to_le32(TXGBE_TXD_PAYLEN(pkt_len));
 175
 176         rte_prefetch0(&(*pkts)->pool);
 177 }
 178
 179 /*
 180  * Fill H/W descriptor ring with mbuf data.
 181  * Copy mbuf pointers to the S/W ring.
 182  */
 183 static inline void
 184 txgbe_tx_fill_hw_ring(struct txgbe_tx_queue *txq, struct rte_mbuf **pkts,
 185                       uint16_t nb_pkts)
 186 {
 187         volatile struct txgbe_tx_desc *txdp = &txq->tx_ring[txq->tx_tail];
 188         struct txgbe_tx_entry *txep = &txq->sw_ring[txq->tx_tail];
 189         const int N_PER_LOOP = 4;
 190         const int N_PER_LOOP_MASK = N_PER_LOOP - 1;
 191         int mainpart, leftover;
 192         int i, j;
 193
 194         /*
 195          * Process most of the packets in chunks of N pkts.  Any
 196          * leftover packets will get processed one at a time.
 197          */
 198         mainpart = (nb_pkts & ((uint32_t)~N_PER_LOOP_MASK));
 199         leftover = (nb_pkts & ((uint32_t)N_PER_LOOP_MASK));
 200         for (i = 0; i < mainpart; i += N_PER_LOOP) {
 201                 /* Copy N mbuf pointers to the S/W ring */
 202                 for (j = 0; j < N_PER_LOOP; ++j)
 203                         (txep + i + j)->mbuf = *(pkts + i + j);
 204                 tx4(txdp + i, pkts + i);
 205         }
 206
 207         if (unlikely(leftover > 0)) {
 208                 for (i = 0; i < leftover; ++i) {
 209                         (txep + mainpart + i)->mbuf = *(pkts + mainpart + i);
 210                         tx1(txdp + mainpart + i, pkts + mainpart + i);
 211                 }
 212         }
 213 }
 214
 215 static inline uint16_t
 216 tx_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 217              uint16_t nb_pkts)
 218 {
 219         struct txgbe_tx_queue *txq = (struct txgbe_tx_queue *)tx_queue;
 220         uint16_t n = 0;
 221
 222         /*
 223          * Begin scanning the H/W ring for done descriptors when the
 224          * number of available descriptors drops below tx_free_thresh.  For
 225          * each done descriptor, free the associated buffer.
 226          */
 227         if (txq->nb_tx_free < txq->tx_free_thresh)
 228                 txgbe_tx_free_bufs(txq);
 229
 230         /* Only use descriptors that are available */
 231         nb_pkts = (uint16_t)RTE_MIN(txq->nb_tx_free, nb_pkts);
 232         if (unlikely(nb_pkts == 0))
 233                 return 0;
 234
 235         /* Use exactly nb_pkts descriptors */
 236         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_pkts);
 237
 238         /*
 239          * At this point, we know there are enough descriptors in the
 240          * ring to transmit all the packets.  This assumes that each
 241          * mbuf contains a single segment, and that no new offloads
 242          * are expected, which would require a new context descriptor.
 243          */
 244
 245         /*
 246          * See if we're going to wrap-around. If so, handle the top
 247          * of the descriptor ring first, then do the bottom.  If not,
 248          * the processing looks just like the "bottom" part anyway...
 249          */
 250         if ((txq->tx_tail + nb_pkts) > txq->nb_tx_desc) {
 251                 n = (uint16_t)(txq->nb_tx_desc - txq->tx_tail);
 252                 txgbe_tx_fill_hw_ring(txq, tx_pkts, n);
 253                 txq->tx_tail = 0;
 254         }
 255
 256         /* Fill H/W descriptor ring with mbuf data */
 257         txgbe_tx_fill_hw_ring(txq, tx_pkts + n, (uint16_t)(nb_pkts - n));
 258         txq->tx_tail = (uint16_t)(txq->tx_tail + (nb_pkts - n));
 259
 260         /*
 261          * Check for wrap-around. This would only happen if we used
 262          * up to the last descriptor in the ring, no more, no less.
 263          */
 264         if (txq->tx_tail >= txq->nb_tx_desc)
 265                 txq->tx_tail = 0;
 266
 267         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 268                    (uint16_t)txq->port_id, (uint16_t)txq->queue_id,
 269                    (uint16_t)txq->tx_tail, (uint16_t)nb_pkts);
 270
 271         /* update tail pointer */
 272         rte_wmb();
 273         txgbe_set32_relaxed(txq->tdt_reg_addr, txq->tx_tail);
 274
 275         return nb_pkts;
 276 }
 277
 278 uint16_t
 279 txgbe_xmit_pkts_simple(void *tx_queue, struct rte_mbuf **tx_pkts,
 280                        uint16_t nb_pkts)
 281 {
 282         uint16_t nb_tx;
 283
 284         /* Try to transmit at least chunks of TX_MAX_BURST pkts */
 285         if (likely(nb_pkts <= RTE_PMD_TXGBE_TX_MAX_BURST))
 286                 return tx_xmit_pkts(tx_queue, tx_pkts, nb_pkts);
 287
 288         /* transmit more than the max burst, in chunks of TX_MAX_BURST */
 289         nb_tx = 0;
 290         while (nb_pkts) {
 291                 uint16_t ret, n;
 292
 293                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_TXGBE_TX_MAX_BURST);
 294                 ret = tx_xmit_pkts(tx_queue, &tx_pkts[nb_tx], n);
 295                 nb_tx = (uint16_t)(nb_tx + ret);
 296                 nb_pkts = (uint16_t)(nb_pkts - ret);
 297                 if (ret < n)
 298                         break;
 299         }
 300
 301         return nb_tx;
 302 }
 303
 304 static inline void
 305 txgbe_set_xmit_ctx(struct txgbe_tx_queue *txq,
 306                 volatile struct txgbe_tx_ctx_desc *ctx_txd,
 307                 uint64_t ol_flags, union txgbe_tx_offload tx_offload)
 308 {
 309         union txgbe_tx_offload tx_offload_mask;
 310         uint32_t type_tucmd_mlhl;
 311         uint32_t mss_l4len_idx;
 312         uint32_t ctx_idx;
 313         uint32_t vlan_macip_lens;
 314         uint32_t tunnel_seed;
 315
 316         ctx_idx = txq->ctx_curr;
 317         tx_offload_mask.data[0] = 0;
 318         tx_offload_mask.data[1] = 0;
 319
 320         /* Specify which HW CTX to upload. */
 321         mss_l4len_idx = TXGBE_TXD_IDX(ctx_idx);
 322         type_tucmd_mlhl = TXGBE_TXD_CTXT;
 323
 324         tx_offload_mask.ptid |= ~0;
 325         type_tucmd_mlhl |= TXGBE_TXD_PTID(tx_offload.ptid);
 326
 327         /* check if TCP segmentation required for this packet */
 328         if (ol_flags & PKT_TX_TCP_SEG) {
 329                 tx_offload_mask.l2_len |= ~0;
 330                 tx_offload_mask.l3_len |= ~0;
 331                 tx_offload_mask.l4_len |= ~0;
 332                 tx_offload_mask.tso_segsz |= ~0;
 333                 mss_l4len_idx |= TXGBE_TXD_MSS(tx_offload.tso_segsz);
 334                 mss_l4len_idx |= TXGBE_TXD_L4LEN(tx_offload.l4_len);
 335         } else { /* no TSO, check if hardware checksum is needed */
 336                 if (ol_flags & PKT_TX_IP_CKSUM) {
 337                         tx_offload_mask.l2_len |= ~0;
 338                         tx_offload_mask.l3_len |= ~0;
 339                 }
 340
 341                 switch (ol_flags & PKT_TX_L4_MASK) {
 342                 case PKT_TX_UDP_CKSUM:
 343                         mss_l4len_idx |=
 344                                 TXGBE_TXD_L4LEN(sizeof(struct rte_udp_hdr));
 345                         tx_offload_mask.l2_len |= ~0;
 346                         tx_offload_mask.l3_len |= ~0;
 347                         break;
 348                 case PKT_TX_TCP_CKSUM:
 349                         mss_l4len_idx |=
 350                                 TXGBE_TXD_L4LEN(sizeof(struct rte_tcp_hdr));
 351                         tx_offload_mask.l2_len |= ~0;
 352                         tx_offload_mask.l3_len |= ~0;
 353                         break;
 354                 case PKT_TX_SCTP_CKSUM:
 355                         mss_l4len_idx |=
 356                                 TXGBE_TXD_L4LEN(sizeof(struct rte_sctp_hdr));
 357                         tx_offload_mask.l2_len |= ~0;
 358                         tx_offload_mask.l3_len |= ~0;
 359                         break;
 360                 default:
 361                         break;
 362                 }
 363         }
 364
 365         vlan_macip_lens = TXGBE_TXD_IPLEN(tx_offload.l3_len >> 1);
 366
 367         if (ol_flags & PKT_TX_TUNNEL_MASK) {
 368                 tx_offload_mask.outer_tun_len |= ~0;
 369                 tx_offload_mask.outer_l2_len |= ~0;
 370                 tx_offload_mask.outer_l3_len |= ~0;
 371                 tx_offload_mask.l2_len |= ~0;
 372                 tunnel_seed = TXGBE_TXD_ETUNLEN(tx_offload.outer_tun_len >> 1);
 373                 tunnel_seed |= TXGBE_TXD_EIPLEN(tx_offload.outer_l3_len >> 2);
 374
 375                 switch (ol_flags & PKT_TX_TUNNEL_MASK) {
 376                 case PKT_TX_TUNNEL_IPIP:
 377                         /* for non UDP / GRE tunneling, set to 0b */
 378                         break;
 379                 case PKT_TX_TUNNEL_VXLAN:
 380                 case PKT_TX_TUNNEL_GENEVE:
 381                         tunnel_seed |= TXGBE_TXD_ETYPE_UDP;
 382                         break;
 383                 case PKT_TX_TUNNEL_GRE:
 384                         tunnel_seed |= TXGBE_TXD_ETYPE_GRE;
 385                         break;
 386                 default:
 387                         PMD_TX_LOG(ERR, "Tunnel type not supported");
 388                         return;
 389                 }
 390                 vlan_macip_lens |= TXGBE_TXD_MACLEN(tx_offload.outer_l2_len);
 391         } else {
 392                 tunnel_seed = 0;
 393                 vlan_macip_lens |= TXGBE_TXD_MACLEN(tx_offload.l2_len);
 394         }
 395
 396         if (ol_flags & PKT_TX_VLAN_PKT) {
 397                 tx_offload_mask.vlan_tci |= ~0;
 398                 vlan_macip_lens |= TXGBE_TXD_VLAN(tx_offload.vlan_tci);
 399         }
 400
 401         txq->ctx_cache[ctx_idx].flags = ol_flags;
 402         txq->ctx_cache[ctx_idx].tx_offload.data[0] =
 403                 tx_offload_mask.data[0] & tx_offload.data[0];
 404         txq->ctx_cache[ctx_idx].tx_offload.data[1] =
 405                 tx_offload_mask.data[1] & tx_offload.data[1];
 406         txq->ctx_cache[ctx_idx].tx_offload_mask = tx_offload_mask;
 407
 408         ctx_txd->dw0 = rte_cpu_to_le_32(vlan_macip_lens);
 409         ctx_txd->dw1 = rte_cpu_to_le_32(tunnel_seed);
 410         ctx_txd->dw2 = rte_cpu_to_le_32(type_tucmd_mlhl);
 411         ctx_txd->dw3 = rte_cpu_to_le_32(mss_l4len_idx);
 412 }
 413
 414 /*
 415  * Check which hardware context can be used. Use the existing match
 416  * or create a new context descriptor.
 417  */
 418 static inline uint32_t
 419 what_ctx_update(struct txgbe_tx_queue *txq, uint64_t flags,
 420                    union txgbe_tx_offload tx_offload)
 421 {
 422         /* If match with the current used context */
 423         if (likely(txq->ctx_cache[txq->ctx_curr].flags == flags &&
 424                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[0] ==
 425                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[0]
 426                      & tx_offload.data[0])) &&
 427                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[1] ==
 428                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[1]
 429                      & tx_offload.data[1]))))
 430                 return txq->ctx_curr;
 431
 432         /* What if match with the next context  */
 433         txq->ctx_curr ^= 1;
 434         if (likely(txq->ctx_cache[txq->ctx_curr].flags == flags &&
 435                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[0] ==
 436                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[0]
 437                      & tx_offload.data[0])) &&
 438                    (txq->ctx_cache[txq->ctx_curr].tx_offload.data[1] ==
 439                     (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data[1]
 440                      & tx_offload.data[1]))))
 441                 return txq->ctx_curr;
 442
 443         /* Mismatch, use the previous context */
 444         return TXGBE_CTX_NUM;
 445 }
 446
 447 static inline uint32_t
 448 tx_desc_cksum_flags_to_olinfo(uint64_t ol_flags)
 449 {
 450         uint32_t tmp = 0;
 451
 452         if ((ol_flags & PKT_TX_L4_MASK) != PKT_TX_L4_NO_CKSUM) {
 453                 tmp |= TXGBE_TXD_CC;
 454                 tmp |= TXGBE_TXD_L4CS;
 455         }
 456         if (ol_flags & PKT_TX_IP_CKSUM) {
 457                 tmp |= TXGBE_TXD_CC;
 458                 tmp |= TXGBE_TXD_IPCS;
 459         }
 460         if (ol_flags & PKT_TX_OUTER_IP_CKSUM) {
 461                 tmp |= TXGBE_TXD_CC;
 462                 tmp |= TXGBE_TXD_EIPCS;
 463         }
 464         if (ol_flags & PKT_TX_TCP_SEG) {
 465                 tmp |= TXGBE_TXD_CC;
 466                 /* implies IPv4 cksum */
 467                 if (ol_flags & PKT_TX_IPV4)
 468                         tmp |= TXGBE_TXD_IPCS;
 469                 tmp |= TXGBE_TXD_L4CS;
 470         }
 471         if (ol_flags & PKT_TX_VLAN_PKT)
 472                 tmp |= TXGBE_TXD_CC;
 473
 474         return tmp;
 475 }
 476
 477 static inline uint32_t
 478 tx_desc_ol_flags_to_cmdtype(uint64_t ol_flags)
 479 {
 480         uint32_t cmdtype = 0;
 481
 482         if (ol_flags & PKT_TX_VLAN_PKT)
 483                 cmdtype |= TXGBE_TXD_VLE;
 484         if (ol_flags & PKT_TX_TCP_SEG)
 485                 cmdtype |= TXGBE_TXD_TSE;
 486         if (ol_flags & PKT_TX_MACSEC)
 487                 cmdtype |= TXGBE_TXD_LINKSEC;
 488         return cmdtype;
 489 }
 490
 491 static inline uint8_t
 492 tx_desc_ol_flags_to_ptid(uint64_t oflags, uint32_t ptype)
 493 {
 494         bool tun;
 495
 496         if (ptype)
 497                 return txgbe_encode_ptype(ptype);
 498
 499         /* Only support flags in TXGBE_TX_OFFLOAD_MASK */
 500         tun = !!(oflags & PKT_TX_TUNNEL_MASK);
 501
 502         /* L2 level */
 503         ptype = RTE_PTYPE_L2_ETHER;
 504         if (oflags & PKT_TX_VLAN)
 505                 ptype |= RTE_PTYPE_L2_ETHER_VLAN;
 506
 507         /* L3 level */
 508         if (oflags & (PKT_TX_OUTER_IPV4 | PKT_TX_OUTER_IP_CKSUM))
 509                 ptype |= RTE_PTYPE_L3_IPV4;
 510         else if (oflags & (PKT_TX_OUTER_IPV6))
 511                 ptype |= RTE_PTYPE_L3_IPV6;
 512
 513         if (oflags & (PKT_TX_IPV4 | PKT_TX_IP_CKSUM))
 514                 ptype |= (tun ? RTE_PTYPE_INNER_L3_IPV4 : RTE_PTYPE_L3_IPV4);
 515         else if (oflags & (PKT_TX_IPV6))
 516                 ptype |= (tun ? RTE_PTYPE_INNER_L3_IPV6 : RTE_PTYPE_L3_IPV6);
 517
 518         /* L4 level */
 519         switch (oflags & (PKT_TX_L4_MASK)) {
 520         case PKT_TX_TCP_CKSUM:
 521                 ptype |= (tun ? RTE_PTYPE_INNER_L4_TCP : RTE_PTYPE_L4_TCP);
 522                 break;
 523         case PKT_TX_UDP_CKSUM:
 524                 ptype |= (tun ? RTE_PTYPE_INNER_L4_UDP : RTE_PTYPE_L4_UDP);
 525                 break;
 526         case PKT_TX_SCTP_CKSUM:
 527                 ptype |= (tun ? RTE_PTYPE_INNER_L4_SCTP : RTE_PTYPE_L4_SCTP);
 528                 break;
 529         }
 530
 531         if (oflags & PKT_TX_TCP_SEG)
 532                 ptype |= (tun ? RTE_PTYPE_INNER_L4_TCP : RTE_PTYPE_L4_TCP);
 533
 534         /* Tunnel */
 535         switch (oflags & PKT_TX_TUNNEL_MASK) {
 536         case PKT_TX_TUNNEL_VXLAN:
 537                 ptype |= RTE_PTYPE_L2_ETHER |
 538                          RTE_PTYPE_L3_IPV4 |
 539                          RTE_PTYPE_TUNNEL_VXLAN;
 540                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 541                 break;
 542         case PKT_TX_TUNNEL_GRE:
 543                 ptype |= RTE_PTYPE_L2_ETHER |
 544                          RTE_PTYPE_L3_IPV4 |
 545                          RTE_PTYPE_TUNNEL_GRE;
 546                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 547                 break;
 548         case PKT_TX_TUNNEL_GENEVE:
 549                 ptype |= RTE_PTYPE_L2_ETHER |
 550                          RTE_PTYPE_L3_IPV4 |
 551                          RTE_PTYPE_TUNNEL_GENEVE;
 552                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 553                 break;
 554         case PKT_TX_TUNNEL_VXLAN_GPE:
 555                 ptype |= RTE_PTYPE_L2_ETHER |
 556                          RTE_PTYPE_L3_IPV4 |
 557                          RTE_PTYPE_TUNNEL_VXLAN_GPE;
 558                 ptype |= RTE_PTYPE_INNER_L2_ETHER;
 559                 break;
 560         case PKT_TX_TUNNEL_IPIP:
 561         case PKT_TX_TUNNEL_IP:
 562                 ptype |= RTE_PTYPE_L2_ETHER |
 563                          RTE_PTYPE_L3_IPV4 |
 564                          RTE_PTYPE_TUNNEL_IP;
 565                 break;
 566         }
 567
 568         return txgbe_encode_ptype(ptype);
 569 }
 570
 571 #ifndef DEFAULT_TX_FREE_THRESH
 572 #define DEFAULT_TX_FREE_THRESH 32
 573 #endif
 574
 575 /* Reset transmit descriptors after they have been used */
 576 static inline int
 577 txgbe_xmit_cleanup(struct txgbe_tx_queue *txq)
 578 {
 579         struct txgbe_tx_entry *sw_ring = txq->sw_ring;
 580         volatile struct txgbe_tx_desc *txr = txq->tx_ring;
 581         uint16_t last_desc_cleaned = txq->last_desc_cleaned;
 582         uint16_t nb_tx_desc = txq->nb_tx_desc;
 583         uint16_t desc_to_clean_to;
 584         uint16_t nb_tx_to_clean;
 585         uint32_t status;
 586
 587         /* Determine the last descriptor needing to be cleaned */
 588         desc_to_clean_to = (uint16_t)(last_desc_cleaned + txq->tx_free_thresh);
 589         if (desc_to_clean_to >= nb_tx_desc)
 590                 desc_to_clean_to = (uint16_t)(desc_to_clean_to - nb_tx_desc);
 591
 592         /* Check to make sure the last descriptor to clean is done */
 593         desc_to_clean_to = sw_ring[desc_to_clean_to].last_id;
 594         status = txr[desc_to_clean_to].dw3;
 595         if (!(status & rte_cpu_to_le_32(TXGBE_TXD_DD))) {
 596                 PMD_TX_FREE_LOG(DEBUG,
 597                                 "TX descriptor %4u is not done"
 598                                 "(port=%d queue=%d)",
 599                                 desc_to_clean_to,
 600                                 txq->port_id, txq->queue_id);
 601                 if (txq->nb_tx_free >> 1 < txq->tx_free_thresh)
 602                         txgbe_set32_masked(txq->tdc_reg_addr,
 603                                 TXGBE_TXCFG_FLUSH, TXGBE_TXCFG_FLUSH);
 604                 /* Failed to clean any descriptors, better luck next time */
 605                 return -(1);
 606         }
 607
 608         /* Figure out how many descriptors will be cleaned */
 609         if (last_desc_cleaned > desc_to_clean_to)
 610                 nb_tx_to_clean = (uint16_t)((nb_tx_desc - last_desc_cleaned) +
 611                                                         desc_to_clean_to);
 612         else
 613                 nb_tx_to_clean = (uint16_t)(desc_to_clean_to -
 614                                                 last_desc_cleaned);
 615
 616         PMD_TX_FREE_LOG(DEBUG,
 617                         "Cleaning %4u TX descriptors: %4u to %4u "
 618                         "(port=%d queue=%d)",
 619                         nb_tx_to_clean, last_desc_cleaned, desc_to_clean_to,
 620                         txq->port_id, txq->queue_id);
 621
 622         /*
 623          * The last descriptor to clean is done, so that means all the
 624          * descriptors from the last descriptor that was cleaned
 625          * up to the last descriptor with the RS bit set
 626          * are done. Only reset the threshold descriptor.
 627          */
 628         txr[desc_to_clean_to].dw3 = 0;
 629
 630         /* Update the txq to reflect the last descriptor that was cleaned */
 631         txq->last_desc_cleaned = desc_to_clean_to;
 632         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + nb_tx_to_clean);
 633
 634         /* No Error */
 635         return 0;
 636 }
 637
 638 static inline uint8_t
 639 txgbe_get_tun_len(struct rte_mbuf *mbuf)
 640 {
 641         struct txgbe_genevehdr genevehdr;
 642         const struct txgbe_genevehdr *gh;
 643         uint8_t tun_len;
 644
 645         switch (mbuf->ol_flags & PKT_TX_TUNNEL_MASK) {
 646         case PKT_TX_TUNNEL_IPIP:
 647                 tun_len = 0;
 648                 break;
 649         case PKT_TX_TUNNEL_VXLAN:
 650         case PKT_TX_TUNNEL_VXLAN_GPE:
 651                 tun_len = sizeof(struct txgbe_udphdr)
 652                         + sizeof(struct txgbe_vxlanhdr);
 653                 break;
 654         case PKT_TX_TUNNEL_GRE:
 655                 tun_len = sizeof(struct txgbe_nvgrehdr);
 656                 break;
 657         case PKT_TX_TUNNEL_GENEVE:
 658                 gh = rte_pktmbuf_read(mbuf,
 659                         mbuf->outer_l2_len + mbuf->outer_l3_len,
 660                         sizeof(genevehdr), &genevehdr);
 661                 tun_len = sizeof(struct txgbe_udphdr)
 662                         + sizeof(struct txgbe_genevehdr)
 663                         + (gh->opt_len << 2);
 664                 break;
 665         default:
 666                 tun_len = 0;
 667         }
 668
 669         return tun_len;
 670 }
 671
 672 uint16_t
 673 txgbe_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 674                 uint16_t nb_pkts)
 675 {
 676         struct txgbe_tx_queue *txq;
 677         struct txgbe_tx_entry *sw_ring;
 678         struct txgbe_tx_entry *txe, *txn;
 679         volatile struct txgbe_tx_desc *txr;
 680         volatile struct txgbe_tx_desc *txd;
 681         struct rte_mbuf     *tx_pkt;
 682         struct rte_mbuf     *m_seg;
 683         uint64_t buf_dma_addr;
 684         uint32_t olinfo_status;
 685         uint32_t cmd_type_len;
 686         uint32_t pkt_len;
 687         uint16_t slen;
 688         uint64_t ol_flags;
 689         uint16_t tx_id;
 690         uint16_t tx_last;
 691         uint16_t nb_tx;
 692         uint16_t nb_used;
 693         uint64_t tx_ol_req;
 694         uint32_t ctx = 0;
 695         uint32_t new_ctx;
 696         union txgbe_tx_offload tx_offload;
 697
 698         tx_offload.data[0] = 0;
 699         tx_offload.data[1] = 0;
 700         txq = tx_queue;
 701         sw_ring = txq->sw_ring;
 702         txr     = txq->tx_ring;
 703         tx_id   = txq->tx_tail;
 704         txe = &sw_ring[tx_id];
 705
 706         /* Determine if the descriptor ring needs to be cleaned. */
 707         if (txq->nb_tx_free < txq->tx_free_thresh)
 708                 txgbe_xmit_cleanup(txq);
 709
 710         rte_prefetch0(&txe->mbuf->pool);
 711
 712         /* TX loop */
 713         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
 714                 new_ctx = 0;
 715                 tx_pkt = *tx_pkts++;
 716                 pkt_len = tx_pkt->pkt_len;
 717
 718                 /*
 719                  * Determine how many (if any) context descriptors
 720                  * are needed for offload functionality.
 721                  */
 722                 ol_flags = tx_pkt->ol_flags;
 723
 724                 /* If hardware offload required */
 725                 tx_ol_req = ol_flags & TXGBE_TX_OFFLOAD_MASK;
 726                 if (tx_ol_req) {
 727                         tx_offload.ptid = tx_desc_ol_flags_to_ptid(tx_ol_req,
 728                                         tx_pkt->packet_type);
 729                         tx_offload.l2_len = tx_pkt->l2_len;
 730                         tx_offload.l3_len = tx_pkt->l3_len;
 731                         tx_offload.l4_len = tx_pkt->l4_len;
 732                         tx_offload.vlan_tci = tx_pkt->vlan_tci;
 733                         tx_offload.tso_segsz = tx_pkt->tso_segsz;
 734                         tx_offload.outer_l2_len = tx_pkt->outer_l2_len;
 735                         tx_offload.outer_l3_len = tx_pkt->outer_l3_len;
 736                         tx_offload.outer_tun_len = txgbe_get_tun_len(tx_pkt);
 737
 738                         /* If new context need be built or reuse the exist ctx*/
 739                         ctx = what_ctx_update(txq, tx_ol_req, tx_offload);
 740                         /* Only allocate context descriptor if required */
 741                         new_ctx = (ctx == TXGBE_CTX_NUM);
 742                         ctx = txq->ctx_curr;
 743                 }
 744
 745                 /*
 746                  * Keep track of how many descriptors are used this loop
 747                  * This will always be the number of segments + the number of
 748                  * Context descriptors required to transmit the packet
 749                  */
 750                 nb_used = (uint16_t)(tx_pkt->nb_segs + new_ctx);
 751
 752                 /*
 753                  * The number of descriptors that must be allocated for a
 754                  * packet is the number of segments of that packet, plus 1
 755                  * Context Descriptor for the hardware offload, if any.
 756                  * Determine the last TX descriptor to allocate in the TX ring
 757                  * for the packet, starting from the current position (tx_id)
 758                  * in the ring.
 759                  */
 760                 tx_last = (uint16_t)(tx_id + nb_used - 1);
 761
 762                 /* Circular ring */
 763                 if (tx_last >= txq->nb_tx_desc)
 764                         tx_last = (uint16_t)(tx_last - txq->nb_tx_desc);
 765
 766                 PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u pktlen=%u"
 767                            " tx_first=%u tx_last=%u",
 768                            (uint16_t)txq->port_id,
 769                            (uint16_t)txq->queue_id,
 770                            (uint32_t)pkt_len,
 771                            (uint16_t)tx_id,
 772                            (uint16_t)tx_last);
 773
 774                 /*
 775                  * Make sure there are enough TX descriptors available to
 776                  * transmit the entire packet.
 777                  * nb_used better be less than or equal to txq->tx_free_thresh
 778                  */
 779                 if (nb_used > txq->nb_tx_free) {
 780                         PMD_TX_FREE_LOG(DEBUG,
 781                                         "Not enough free TX descriptors "
 782                                         "nb_used=%4u nb_free=%4u "
 783                                         "(port=%d queue=%d)",
 784                                         nb_used, txq->nb_tx_free,
 785                                         txq->port_id, txq->queue_id);
 786
 787                         if (txgbe_xmit_cleanup(txq) != 0) {
 788                                 /* Could not clean any descriptors */
 789                                 if (nb_tx == 0)
 790                                         return 0;
 791                                 goto end_of_tx;
 792                         }
 793
 794                         /* nb_used better be <= txq->tx_free_thresh */
 795                         if (unlikely(nb_used > txq->tx_free_thresh)) {
 796                                 PMD_TX_FREE_LOG(DEBUG,
 797                                         "The number of descriptors needed to "
 798                                         "transmit the packet exceeds the "
 799                                         "RS bit threshold. This will impact "
 800                                         "performance."
 801                                         "nb_used=%4u nb_free=%4u "
 802                                         "tx_free_thresh=%4u. "
 803                                         "(port=%d queue=%d)",
 804                                         nb_used, txq->nb_tx_free,
 805                                         txq->tx_free_thresh,
 806                                         txq->port_id, txq->queue_id);
 807                                 /*
 808                                  * Loop here until there are enough TX
 809                                  * descriptors or until the ring cannot be
 810                                  * cleaned.
 811                                  */
 812                                 while (nb_used > txq->nb_tx_free) {
 813                                         if (txgbe_xmit_cleanup(txq) != 0) {
 814                                                 /*
 815                                                  * Could not clean any
 816                                                  * descriptors
 817                                                  */
 818                                                 if (nb_tx == 0)
 819                                                         return 0;
 820                                                 goto end_of_tx;
 821                                         }
 822                                 }
 823                         }
 824                 }
 825
 826                 /*
 827                  * By now there are enough free TX descriptors to transmit
 828                  * the packet.
 829                  */
 830
 831                 /*
 832                  * Set common flags of all TX Data Descriptors.
 833                  *
 834                  * The following bits must be set in all Data Descriptors:
 835                  *   - TXGBE_TXD_DTYP_DATA
 836                  *   - TXGBE_TXD_DCMD_DEXT
 837                  *
 838                  * The following bits must be set in the first Data Descriptor
 839                  * and are ignored in the other ones:
 840                  *   - TXGBE_TXD_DCMD_IFCS
 841                  *   - TXGBE_TXD_MAC_1588
 842                  *   - TXGBE_TXD_DCMD_VLE
 843                  *
 844                  * The following bits must only be set in the last Data
 845                  * Descriptor:
 846                  *   - TXGBE_TXD_CMD_EOP
 847                  *
 848                  * The following bits can be set in any Data Descriptor, but
 849                  * are only set in the last Data Descriptor:
 850                  *   - TXGBE_TXD_CMD_RS
 851                  */
 852                 cmd_type_len = TXGBE_TXD_FCS;
 853
 854                 olinfo_status = 0;
 855                 if (tx_ol_req) {
 856                         if (ol_flags & PKT_TX_TCP_SEG) {
 857                                 /* when TSO is on, paylen in descriptor is the
 858                                  * not the packet len but the tcp payload len
 859                                  */
 860                                 pkt_len -= (tx_offload.l2_len +
 861                                         tx_offload.l3_len + tx_offload.l4_len);
 862                                 pkt_len -=
 863                                         (tx_pkt->ol_flags & PKT_TX_TUNNEL_MASK)
 864                                         ? tx_offload.outer_l2_len +
 865                                           tx_offload.outer_l3_len : 0;
 866                         }
 867
 868                         /*
 869                          * Setup the TX Advanced Context Descriptor if required
 870                          */
 871                         if (new_ctx) {
 872                                 volatile struct txgbe_tx_ctx_desc *ctx_txd;
 873
 874                                 ctx_txd = (volatile struct txgbe_tx_ctx_desc *)
 875                                     &txr[tx_id];
 876
 877                                 txn = &sw_ring[txe->next_id];
 878                                 rte_prefetch0(&txn->mbuf->pool);
 879
 880                                 if (txe->mbuf != NULL) {
 881                                         rte_pktmbuf_free_seg(txe->mbuf);
 882                                         txe->mbuf = NULL;
 883                                 }
 884
 885                                 txgbe_set_xmit_ctx(txq, ctx_txd, tx_ol_req,
 886                                         tx_offload);
 887
 888                                 txe->last_id = tx_last;
 889                                 tx_id = txe->next_id;
 890                                 txe = txn;
 891                         }
 892
 893                         /*
 894                          * Setup the TX Advanced Data Descriptor,
 895                          * This path will go through
 896                          * whatever new/reuse the context descriptor
 897                          */
 898                         cmd_type_len  |= tx_desc_ol_flags_to_cmdtype(ol_flags);
 899                         olinfo_status |=
 900                                 tx_desc_cksum_flags_to_olinfo(ol_flags);
 901                         olinfo_status |= TXGBE_TXD_IDX(ctx);
 902                 }
 903
 904                 olinfo_status |= TXGBE_TXD_PAYLEN(pkt_len);
 905
 906                 m_seg = tx_pkt;
 907                 do {
 908                         txd = &txr[tx_id];
 909                         txn = &sw_ring[txe->next_id];
 910                         rte_prefetch0(&txn->mbuf->pool);
 911
 912                         if (txe->mbuf != NULL)
 913                                 rte_pktmbuf_free_seg(txe->mbuf);
 914                         txe->mbuf = m_seg;
 915
 916                         /*
 917                          * Set up Transmit Data Descriptor.
 918                          */
 919                         slen = m_seg->data_len;
 920                         buf_dma_addr = rte_mbuf_data_iova(m_seg);
 921                         txd->qw0 = rte_cpu_to_le_64(buf_dma_addr);
 922                         txd->dw2 = rte_cpu_to_le_32(cmd_type_len | slen);
 923                         txd->dw3 = rte_cpu_to_le_32(olinfo_status);
 924                         txe->last_id = tx_last;
 925                         tx_id = txe->next_id;
 926                         txe = txn;
 927                         m_seg = m_seg->next;
 928                 } while (m_seg != NULL);
 929
 930                 /*
 931                  * The last packet data descriptor needs End Of Packet (EOP)
 932                  */
 933                 cmd_type_len |= TXGBE_TXD_EOP;
 934                 txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_used);
 935
 936                 txd->dw2 |= rte_cpu_to_le_32(cmd_type_len);
 937         }
 938
 939 end_of_tx:
 940
 941         rte_wmb();
 942
 943         /*
 944          * Set the Transmit Descriptor Tail (TDT)
 945          */
 946         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 947                    (uint16_t)txq->port_id, (uint16_t)txq->queue_id,
 948                    (uint16_t)tx_id, (uint16_t)nb_tx);
 949         txgbe_set32_relaxed(txq->tdt_reg_addr, tx_id);
 950         txq->tx_tail = tx_id;
 951
 952         return nb_tx;
 953 }
 954
 955 /*********************************************************************
 956  *
 957  *  TX prep functions
 958  *
 959  **********************************************************************/
 960 uint16_t
 961 txgbe_prep_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
 962 {
 963         int i, ret;
 964         uint64_t ol_flags;
 965         struct rte_mbuf *m;
 966         struct txgbe_tx_queue *txq = (struct txgbe_tx_queue *)tx_queue;
 967
 968         for (i = 0; i < nb_pkts; i++) {
 969                 m = tx_pkts[i];
 970                 ol_flags = m->ol_flags;
 971
 972                 /**
 973                  * Check if packet meets requirements for number of segments
 974                  *
 975                  * NOTE: for txgbe it's always (40 - WTHRESH) for both TSO and
 976                  *       non-TSO
 977                  */
 978
 979                 if (m->nb_segs > TXGBE_TX_MAX_SEG - txq->wthresh) {
 980                         rte_errno = -EINVAL;
 981                         return i;
 982                 }
 983
 984                 if (ol_flags & TXGBE_TX_OFFLOAD_NOTSUP_MASK) {
 985                         rte_errno = -ENOTSUP;
 986                         return i;
 987                 }
 988
 989 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
 990                 ret = rte_validate_tx_offload(m);
 991                 if (ret != 0) {
 992                         rte_errno = ret;
 993                         return i;
 994                 }
 995 #endif
 996                 ret = rte_net_intel_cksum_prepare(m);
 997                 if (ret != 0) {
 998                         rte_errno = ret;
 999                         return i;
1000                 }
1001         }
1002
1003         return i;
1004 }
1005
1006 /*********************************************************************
1007  *
1008  *  RX functions
1009  *
1010  **********************************************************************/
1011 /* @note: fix txgbe_dev_supported_ptypes_get() if any change here. */
1012 static inline uint32_t
1013 txgbe_rxd_pkt_info_to_pkt_type(uint32_t pkt_info, uint16_t ptid_mask)
1014 {
1015         uint16_t ptid = TXGBE_RXD_PTID(pkt_info);
1016
1017         ptid &= ptid_mask;
1018
1019         return txgbe_decode_ptype(ptid);
1020 }
1021
1022 static inline uint64_t
1023 txgbe_rxd_pkt_info_to_pkt_flags(uint32_t pkt_info)
1024 {
1025         static uint64_t ip_rss_types_map[16] __rte_cache_aligned = {
1026                 0, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH,
1027                 0, PKT_RX_RSS_HASH, 0, PKT_RX_RSS_HASH,
1028                 PKT_RX_RSS_HASH, 0, 0, 0,
1029                 0, 0, 0,  PKT_RX_FDIR,
1030         };
1031
1032         return ip_rss_types_map[TXGBE_RXD_RSSTYPE(pkt_info)];
1033 }
1034
1035 static inline uint64_t
1036 rx_desc_status_to_pkt_flags(uint32_t rx_status, uint64_t vlan_flags)
1037 {
1038         uint64_t pkt_flags;
1039
1040         /*
1041          * Check if VLAN present only.
1042          * Do not check whether L3/L4 rx checksum done by NIC or not,
1043          * That can be found from rte_eth_rxmode.offloads flag
1044          */
1045         pkt_flags = (rx_status & TXGBE_RXD_STAT_VLAN &&
1046                      vlan_flags & PKT_RX_VLAN_STRIPPED)
1047                     ? vlan_flags : 0;
1048
1049         return pkt_flags;
1050 }
1051
1052 static inline uint64_t
1053 rx_desc_error_to_pkt_flags(uint32_t rx_status)
1054 {
1055         uint64_t pkt_flags = 0;
1056
1057         /* checksum offload can't be disabled */
1058         if (rx_status & TXGBE_RXD_STAT_IPCS) {
1059                 pkt_flags |= (rx_status & TXGBE_RXD_ERR_IPCS
1060                                 ? PKT_RX_IP_CKSUM_BAD : PKT_RX_IP_CKSUM_GOOD);
1061         }
1062
1063         if (rx_status & TXGBE_RXD_STAT_L4CS) {
1064                 pkt_flags |= (rx_status & TXGBE_RXD_ERR_L4CS
1065                                 ? PKT_RX_L4_CKSUM_BAD : PKT_RX_L4_CKSUM_GOOD);
1066         }
1067
1068         if (rx_status & TXGBE_RXD_STAT_EIPCS &&
1069             rx_status & TXGBE_RXD_ERR_EIPCS) {
1070                 pkt_flags |= PKT_RX_EIP_CKSUM_BAD;
1071         }
1072
1073         return pkt_flags;
1074 }
1075
1076 /*
1077  * LOOK_AHEAD defines how many desc statuses to check beyond the
1078  * current descriptor.
1079  * It must be a pound define for optimal performance.
1080  * Do not change the value of LOOK_AHEAD, as the txgbe_rx_scan_hw_ring
1081  * function only works with LOOK_AHEAD=8.
1082  */
1083 #define LOOK_AHEAD 8
1084 #if (LOOK_AHEAD != 8)
1085 #error "PMD TXGBE: LOOK_AHEAD must be 8\n"
1086 #endif
1087 static inline int
1088 txgbe_rx_scan_hw_ring(struct txgbe_rx_queue *rxq)
1089 {
1090         volatile struct txgbe_rx_desc *rxdp;
1091         struct txgbe_rx_entry *rxep;
1092         struct rte_mbuf *mb;
1093         uint16_t pkt_len;
1094         uint64_t pkt_flags;
1095         int nb_dd;
1096         uint32_t s[LOOK_AHEAD];
1097         uint32_t pkt_info[LOOK_AHEAD];
1098         int i, j, nb_rx = 0;
1099         uint32_t status;
1100
1101         /* get references to current descriptor and S/W ring entry */
1102         rxdp = &rxq->rx_ring[rxq->rx_tail];
1103         rxep = &rxq->sw_ring[rxq->rx_tail];
1104
1105         status = rxdp->qw1.lo.status;
1106         /* check to make sure there is at least 1 packet to receive */
1107         if (!(status & rte_cpu_to_le_32(TXGBE_RXD_STAT_DD)))
1108                 return 0;
1109
1110         /*
1111          * Scan LOOK_AHEAD descriptors at a time to determine which descriptors
1112          * reference packets that are ready to be received.
1113          */
1114         for (i = 0; i < RTE_PMD_TXGBE_RX_MAX_BURST;
1115              i += LOOK_AHEAD, rxdp += LOOK_AHEAD, rxep += LOOK_AHEAD) {
1116                 /* Read desc statuses backwards to avoid race condition */
1117                 for (j = 0; j < LOOK_AHEAD; j++)
1118                         s[j] = rte_le_to_cpu_32(rxdp[j].qw1.lo.status);
1119
1120                 rte_smp_rmb();
1121
1122                 /* Compute how many status bits were set */
1123                 for (nb_dd = 0; nb_dd < LOOK_AHEAD &&
1124                                 (s[nb_dd] & TXGBE_RXD_STAT_DD); nb_dd++)
1125                         ;
1126
1127                 for (j = 0; j < nb_dd; j++)
1128                         pkt_info[j] = rte_le_to_cpu_32(rxdp[j].qw0.dw0);
1129
1130                 nb_rx += nb_dd;
1131
1132                 /* Translate descriptor info to mbuf format */
1133                 for (j = 0; j < nb_dd; ++j) {
1134                         mb = rxep[j].mbuf;
1135                         pkt_len = rte_le_to_cpu_16(rxdp[j].qw1.hi.len) -
1136                                   rxq->crc_len;
1137                         mb->data_len = pkt_len;
1138                         mb->pkt_len = pkt_len;
1139                         mb->vlan_tci = rte_le_to_cpu_16(rxdp[j].qw1.hi.tag);
1140
1141                         /* convert descriptor fields to rte mbuf flags */
1142                         pkt_flags = rx_desc_status_to_pkt_flags(s[j],
1143                                         rxq->vlan_flags);
1144                         pkt_flags |= rx_desc_error_to_pkt_flags(s[j]);
1145                         pkt_flags |=
1146                                 txgbe_rxd_pkt_info_to_pkt_flags(pkt_info[j]);
1147                         mb->ol_flags = pkt_flags;
1148                         mb->packet_type =
1149                                 txgbe_rxd_pkt_info_to_pkt_type(pkt_info[j],
1150                                 rxq->pkt_type_mask);
1151
1152                         if (likely(pkt_flags & PKT_RX_RSS_HASH))
1153                                 mb->hash.rss =
1154                                         rte_le_to_cpu_32(rxdp[j].qw0.dw1);
1155                         else if (pkt_flags & PKT_RX_FDIR) {
1156                                 mb->hash.fdir.hash =
1157                                         rte_le_to_cpu_16(rxdp[j].qw0.hi.csum) &
1158                                         TXGBE_ATR_HASH_MASK;
1159                                 mb->hash.fdir.id =
1160                                         rte_le_to_cpu_16(rxdp[j].qw0.hi.ipid);
1161                         }
1162                 }
1163
1164                 /* Move mbuf pointers from the S/W ring to the stage */
1165                 for (j = 0; j < LOOK_AHEAD; ++j)
1166                         rxq->rx_stage[i + j] = rxep[j].mbuf;
1167
1168                 /* stop if all requested packets could not be received */
1169                 if (nb_dd != LOOK_AHEAD)
1170                         break;
1171         }
1172
1173         /* clear software ring entries so we can cleanup correctly */
1174         for (i = 0; i < nb_rx; ++i)
1175                 rxq->sw_ring[rxq->rx_tail + i].mbuf = NULL;
1176
1177         return nb_rx;
1178 }
1179
1180 static inline int
1181 txgbe_rx_alloc_bufs(struct txgbe_rx_queue *rxq, bool reset_mbuf)
1182 {
1183         volatile struct txgbe_rx_desc *rxdp;
1184         struct txgbe_rx_entry *rxep;
1185         struct rte_mbuf *mb;
1186         uint16_t alloc_idx;
1187         __le64 dma_addr;
1188         int diag, i;
1189
1190         /* allocate buffers in bulk directly into the S/W ring */
1191         alloc_idx = rxq->rx_free_trigger - (rxq->rx_free_thresh - 1);
1192         rxep = &rxq->sw_ring[alloc_idx];
1193         diag = rte_mempool_get_bulk(rxq->mb_pool, (void *)rxep,
1194                                     rxq->rx_free_thresh);
1195         if (unlikely(diag != 0))
1196                 return -ENOMEM;
1197
1198         rxdp = &rxq->rx_ring[alloc_idx];
1199         for (i = 0; i < rxq->rx_free_thresh; ++i) {
1200                 /* populate the static rte mbuf fields */
1201                 mb = rxep[i].mbuf;
1202                 if (reset_mbuf)
1203                         mb->port = rxq->port_id;
1204
1205                 rte_mbuf_refcnt_set(mb, 1);
1206                 mb->data_off = RTE_PKTMBUF_HEADROOM;
1207
1208                 /* populate the descriptors */
1209                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(mb));
1210                 TXGBE_RXD_HDRADDR(&rxdp[i], 0);
1211                 TXGBE_RXD_PKTADDR(&rxdp[i], dma_addr);
1212         }
1213
1214         /* update state of internal queue structure */
1215         rxq->rx_free_trigger = rxq->rx_free_trigger + rxq->rx_free_thresh;
1216         if (rxq->rx_free_trigger >= rxq->nb_rx_desc)
1217                 rxq->rx_free_trigger = rxq->rx_free_thresh - 1;
1218
1219         /* no errors */
1220         return 0;
1221 }
1222
1223 static inline uint16_t
1224 txgbe_rx_fill_from_stage(struct txgbe_rx_queue *rxq, struct rte_mbuf **rx_pkts,
1225                          uint16_t nb_pkts)
1226 {
1227         struct rte_mbuf **stage = &rxq->rx_stage[rxq->rx_next_avail];
1228         int i;
1229
1230         /* how many packets are ready to return? */
1231         nb_pkts = (uint16_t)RTE_MIN(nb_pkts, rxq->rx_nb_avail);
1232
1233         /* copy mbuf pointers to the application's packet list */
1234         for (i = 0; i < nb_pkts; ++i)
1235                 rx_pkts[i] = stage[i];
1236
1237         /* update internal queue state */
1238         rxq->rx_nb_avail = (uint16_t)(rxq->rx_nb_avail - nb_pkts);
1239         rxq->rx_next_avail = (uint16_t)(rxq->rx_next_avail + nb_pkts);
1240
1241         return nb_pkts;
1242 }
1243
1244 static inline uint16_t
1245 txgbe_rx_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1246              uint16_t nb_pkts)
1247 {
1248         struct txgbe_rx_queue *rxq = (struct txgbe_rx_queue *)rx_queue;
1249         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1250         uint16_t nb_rx = 0;
1251
1252         /* Any previously recv'd pkts will be returned from the Rx stage */
1253         if (rxq->rx_nb_avail)
1254                 return txgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1255
1256         /* Scan the H/W ring for packets to receive */
1257         nb_rx = (uint16_t)txgbe_rx_scan_hw_ring(rxq);
1258
1259         /* update internal queue state */
1260         rxq->rx_next_avail = 0;
1261         rxq->rx_nb_avail = nb_rx;
1262         rxq->rx_tail = (uint16_t)(rxq->rx_tail + nb_rx);
1263
1264         /* if required, allocate new buffers to replenish descriptors */
1265         if (rxq->rx_tail > rxq->rx_free_trigger) {
1266                 uint16_t cur_free_trigger = rxq->rx_free_trigger;
1267
1268                 if (txgbe_rx_alloc_bufs(rxq, true) != 0) {
1269                         int i, j;
1270
1271                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1272                                    "queue_id=%u", (uint16_t)rxq->port_id,
1273                                    (uint16_t)rxq->queue_id);
1274
1275                         dev->data->rx_mbuf_alloc_failed +=
1276                                 rxq->rx_free_thresh;
1277
1278                         /*
1279                          * Need to rewind any previous receives if we cannot
1280                          * allocate new buffers to replenish the old ones.
1281                          */
1282                         rxq->rx_nb_avail = 0;
1283                         rxq->rx_tail = (uint16_t)(rxq->rx_tail - nb_rx);
1284                         for (i = 0, j = rxq->rx_tail; i < nb_rx; ++i, ++j)
1285                                 rxq->sw_ring[j].mbuf = rxq->rx_stage[i];
1286
1287                         return 0;
1288                 }
1289
1290                 /* update tail pointer */
1291                 rte_wmb();
1292                 txgbe_set32_relaxed(rxq->rdt_reg_addr, cur_free_trigger);
1293         }
1294
1295         if (rxq->rx_tail >= rxq->nb_rx_desc)
1296                 rxq->rx_tail = 0;
1297
1298         /* received any packets this loop? */
1299         if (rxq->rx_nb_avail)
1300                 return txgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1301
1302         return 0;
1303 }
1304
1305 /* split requests into chunks of size RTE_PMD_TXGBE_RX_MAX_BURST */
1306 uint16_t
1307 txgbe_recv_pkts_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1308                            uint16_t nb_pkts)
1309 {
1310         uint16_t nb_rx;
1311
1312         if (unlikely(nb_pkts == 0))
1313                 return 0;
1314
1315         if (likely(nb_pkts <= RTE_PMD_TXGBE_RX_MAX_BURST))
1316                 return txgbe_rx_recv_pkts(rx_queue, rx_pkts, nb_pkts);
1317
1318         /* request is relatively large, chunk it up */
1319         nb_rx = 0;
1320         while (nb_pkts) {
1321                 uint16_t ret, n;
1322
1323                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_TXGBE_RX_MAX_BURST);
1324                 ret = txgbe_rx_recv_pkts(rx_queue, &rx_pkts[nb_rx], n);
1325                 nb_rx = (uint16_t)(nb_rx + ret);
1326                 nb_pkts = (uint16_t)(nb_pkts - ret);
1327                 if (ret < n)
1328                         break;
1329         }
1330
1331         return nb_rx;
1332 }
1333
1334 uint16_t
1335 txgbe_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1336                 uint16_t nb_pkts)
1337 {
1338         struct txgbe_rx_queue *rxq;
1339         volatile struct txgbe_rx_desc *rx_ring;
1340         volatile struct txgbe_rx_desc *rxdp;
1341         struct txgbe_rx_entry *sw_ring;
1342         struct txgbe_rx_entry *rxe;
1343         struct rte_mbuf *rxm;
1344         struct rte_mbuf *nmb;
1345         struct txgbe_rx_desc rxd;
1346         uint64_t dma_addr;
1347         uint32_t staterr;
1348         uint32_t pkt_info;
1349         uint16_t pkt_len;
1350         uint16_t rx_id;
1351         uint16_t nb_rx;
1352         uint16_t nb_hold;
1353         uint64_t pkt_flags;
1354
1355         nb_rx = 0;
1356         nb_hold = 0;
1357         rxq = rx_queue;
1358         rx_id = rxq->rx_tail;
1359         rx_ring = rxq->rx_ring;
1360         sw_ring = rxq->sw_ring;
1361         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1362         while (nb_rx < nb_pkts) {
1363                 /*
1364                  * The order of operations here is important as the DD status
1365                  * bit must not be read after any other descriptor fields.
1366                  * rx_ring and rxdp are pointing to volatile data so the order
1367                  * of accesses cannot be reordered by the compiler. If they were
1368                  * not volatile, they could be reordered which could lead to
1369                  * using invalid descriptor fields when read from rxd.
1370                  */
1371                 rxdp = &rx_ring[rx_id];
1372                 staterr = rxdp->qw1.lo.status;
1373                 if (!(staterr & rte_cpu_to_le_32(TXGBE_RXD_STAT_DD)))
1374                         break;
1375                 rxd = *rxdp;
1376
1377                 /*
1378                  * End of packet.
1379                  *
1380                  * If the TXGBE_RXD_STAT_EOP flag is not set, the RX packet
1381                  * is likely to be invalid and to be dropped by the various
1382                  * validation checks performed by the network stack.
1383                  *
1384                  * Allocate a new mbuf to replenish the RX ring descriptor.
1385                  * If the allocation fails:
1386                  *    - arrange for that RX descriptor to be the first one
1387                  *      being parsed the next time the receive function is
1388                  *      invoked [on the same queue].
1389                  *
1390                  *    - Stop parsing the RX ring and return immediately.
1391                  *
1392                  * This policy do not drop the packet received in the RX
1393                  * descriptor for which the allocation of a new mbuf failed.
1394                  * Thus, it allows that packet to be later retrieved if
1395                  * mbuf have been freed in the mean time.
1396                  * As a side effect, holding RX descriptors instead of
1397                  * systematically giving them back to the NIC may lead to
1398                  * RX ring exhaustion situations.
1399                  * However, the NIC can gracefully prevent such situations
1400                  * to happen by sending specific "back-pressure" flow control
1401                  * frames to its peer(s).
1402                  */
1403                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1404                            "ext_err_stat=0x%08x pkt_len=%u",
1405                            (uint16_t)rxq->port_id, (uint16_t)rxq->queue_id,
1406                            (uint16_t)rx_id, (uint32_t)staterr,
1407                            (uint16_t)rte_le_to_cpu_16(rxd.qw1.hi.len));
1408
1409                 nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
1410                 if (nmb == NULL) {
1411                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1412                                    "queue_id=%u", (uint16_t)rxq->port_id,
1413                                    (uint16_t)rxq->queue_id);
1414                         dev->data->rx_mbuf_alloc_failed++;
1415                         break;
1416                 }
1417
1418                 nb_hold++;
1419                 rxe = &sw_ring[rx_id];
1420                 rx_id++;
1421                 if (rx_id == rxq->nb_rx_desc)
1422                         rx_id = 0;
1423
1424                 /* Prefetch next mbuf while processing current one. */
1425                 rte_txgbe_prefetch(sw_ring[rx_id].mbuf);
1426
1427                 /*
1428                  * When next RX descriptor is on a cache-line boundary,
1429                  * prefetch the next 4 RX descriptors and the next 8 pointers
1430                  * to mbufs.
1431                  */
1432                 if ((rx_id & 0x3) == 0) {
1433                         rte_txgbe_prefetch(&rx_ring[rx_id]);
1434                         rte_txgbe_prefetch(&sw_ring[rx_id]);
1435                 }
1436
1437                 rxm = rxe->mbuf;
1438                 rxe->mbuf = nmb;
1439                 dma_addr = rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
1440                 TXGBE_RXD_HDRADDR(rxdp, 0);
1441                 TXGBE_RXD_PKTADDR(rxdp, dma_addr);
1442
1443                 /*
1444                  * Initialize the returned mbuf.
1445                  * 1) setup generic mbuf fields:
1446                  *    - number of segments,
1447                  *    - next segment,
1448                  *    - packet length,
1449                  *    - RX port identifier.
1450                  * 2) integrate hardware offload data, if any:
1451                  *    - RSS flag & hash,
1452                  *    - IP checksum flag,
1453                  *    - VLAN TCI, if any,
1454                  *    - error flags.
1455                  */
1456                 pkt_len = (uint16_t)(rte_le_to_cpu_16(rxd.qw1.hi.len) -
1457                                       rxq->crc_len);
1458                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
1459                 rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
1460                 rxm->nb_segs = 1;
1461                 rxm->next = NULL;
1462                 rxm->pkt_len = pkt_len;
1463                 rxm->data_len = pkt_len;
1464                 rxm->port = rxq->port_id;
1465
1466                 pkt_info = rte_le_to_cpu_32(rxd.qw0.dw0);
1467                 /* Only valid if PKT_RX_VLAN set in pkt_flags */
1468                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.qw1.hi.tag);
1469
1470                 pkt_flags = rx_desc_status_to_pkt_flags(staterr,
1471                                         rxq->vlan_flags);
1472                 pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1473                 pkt_flags |= txgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1474                 rxm->ol_flags = pkt_flags;
1475                 rxm->packet_type = txgbe_rxd_pkt_info_to_pkt_type(pkt_info,
1476                                                        rxq->pkt_type_mask);
1477
1478                 if (likely(pkt_flags & PKT_RX_RSS_HASH)) {
1479                         rxm->hash.rss = rte_le_to_cpu_32(rxd.qw0.dw1);
1480                 } else if (pkt_flags & PKT_RX_FDIR) {
1481                         rxm->hash.fdir.hash =
1482                                 rte_le_to_cpu_16(rxd.qw0.hi.csum) &
1483                                 TXGBE_ATR_HASH_MASK;
1484                         rxm->hash.fdir.id = rte_le_to_cpu_16(rxd.qw0.hi.ipid);
1485                 }
1486                 /*
1487                  * Store the mbuf address into the next entry of the array
1488                  * of returned packets.
1489                  */
1490                 rx_pkts[nb_rx++] = rxm;
1491         }
1492         rxq->rx_tail = rx_id;
1493
1494         /*
1495          * If the number of free RX descriptors is greater than the RX free
1496          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1497          * register.
1498          * Update the RDT with the value of the last processed RX descriptor
1499          * minus 1, to guarantee that the RDT register is never equal to the
1500          * RDH register, which creates a "full" ring situation from the
1501          * hardware point of view...
1502          */
1503         nb_hold = (uint16_t)(nb_hold + rxq->nb_rx_hold);
1504         if (nb_hold > rxq->rx_free_thresh) {
1505                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1506                            "nb_hold=%u nb_rx=%u",
1507                            (uint16_t)rxq->port_id, (uint16_t)rxq->queue_id,
1508                            (uint16_t)rx_id, (uint16_t)nb_hold,
1509                            (uint16_t)nb_rx);
1510                 rx_id = (uint16_t)((rx_id == 0) ?
1511                                 (rxq->nb_rx_desc - 1) : (rx_id - 1));
1512                 txgbe_set32(rxq->rdt_reg_addr, rx_id);
1513                 nb_hold = 0;
1514         }
1515         rxq->nb_rx_hold = nb_hold;
1516         return nb_rx;
1517 }
1518
1519 /**
1520  * txgbe_fill_cluster_head_buf - fill the first mbuf of the returned packet
1521  *
1522  * Fill the following info in the HEAD buffer of the Rx cluster:
1523  *    - RX port identifier
1524  *    - hardware offload data, if any:
1525  *      - RSS flag & hash
1526  *      - IP checksum flag
1527  *      - VLAN TCI, if any
1528  *      - error flags
1529  * @head HEAD of the packet cluster
1530  * @desc HW descriptor to get data from
1531  * @rxq Pointer to the Rx queue
1532  */
1533 static inline void
1534 txgbe_fill_cluster_head_buf(struct rte_mbuf *head, struct txgbe_rx_desc *desc,
1535                 struct txgbe_rx_queue *rxq, uint32_t staterr)
1536 {
1537         uint32_t pkt_info;
1538         uint64_t pkt_flags;
1539
1540         head->port = rxq->port_id;
1541
1542         /* The vlan_tci field is only valid when PKT_RX_VLAN is
1543          * set in the pkt_flags field.
1544          */
1545         head->vlan_tci = rte_le_to_cpu_16(desc->qw1.hi.tag);
1546         pkt_info = rte_le_to_cpu_32(desc->qw0.dw0);
1547         pkt_flags = rx_desc_status_to_pkt_flags(staterr, rxq->vlan_flags);
1548         pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1549         pkt_flags |= txgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1550         head->ol_flags = pkt_flags;
1551         head->packet_type = txgbe_rxd_pkt_info_to_pkt_type(pkt_info,
1552                                                 rxq->pkt_type_mask);
1553
1554         if (likely(pkt_flags & PKT_RX_RSS_HASH)) {
1555                 head->hash.rss = rte_le_to_cpu_32(desc->qw0.dw1);
1556         } else if (pkt_flags & PKT_RX_FDIR) {
1557                 head->hash.fdir.hash = rte_le_to_cpu_16(desc->qw0.hi.csum)
1558                                 & TXGBE_ATR_HASH_MASK;
1559                 head->hash.fdir.id = rte_le_to_cpu_16(desc->qw0.hi.ipid);
1560         }
1561 }
1562
1563 /**
1564  * txgbe_recv_pkts_lro - receive handler for and LRO case.
1565  *
1566  * @rx_queue Rx queue handle
1567  * @rx_pkts table of received packets
1568  * @nb_pkts size of rx_pkts table
1569  * @bulk_alloc if TRUE bulk allocation is used for a HW ring refilling
1570  *
1571  * Handles the Rx HW ring completions when RSC feature is configured. Uses an
1572  * additional ring of txgbe_rsc_entry's that will hold the relevant RSC info.
1573  *
1574  * We use the same logic as in Linux and in FreeBSD txgbe drivers:
1575  * 1) When non-EOP RSC completion arrives:
1576  *    a) Update the HEAD of the current RSC aggregation cluster with the new
1577  *       segment's data length.
1578  *    b) Set the "next" pointer of the current segment to point to the segment
1579  *       at the NEXTP index.
1580  *    c) Pass the HEAD of RSC aggregation cluster on to the next NEXTP entry
1581  *       in the sw_rsc_ring.
1582  * 2) When EOP arrives we just update the cluster's total length and offload
1583  *    flags and deliver the cluster up to the upper layers. In our case - put it
1584  *    in the rx_pkts table.
1585  *
1586  * Returns the number of received packets/clusters (according to the "bulk
1587  * receive" interface).
1588  */
1589 static inline uint16_t
1590 txgbe_recv_pkts_lro(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts,
1591                     bool bulk_alloc)
1592 {
1593         struct txgbe_rx_queue *rxq = rx_queue;
1594         struct rte_eth_dev *dev = &rte_eth_devices[rxq->port_id];
1595         volatile struct txgbe_rx_desc *rx_ring = rxq->rx_ring;
1596         struct txgbe_rx_entry *sw_ring = rxq->sw_ring;
1597         struct txgbe_scattered_rx_entry *sw_sc_ring = rxq->sw_sc_ring;
1598         uint16_t rx_id = rxq->rx_tail;
1599         uint16_t nb_rx = 0;
1600         uint16_t nb_hold = rxq->nb_rx_hold;
1601         uint16_t prev_id = rxq->rx_tail;
1602
1603         while (nb_rx < nb_pkts) {
1604                 bool eop;
1605                 struct txgbe_rx_entry *rxe;
1606                 struct txgbe_scattered_rx_entry *sc_entry;
1607                 struct txgbe_scattered_rx_entry *next_sc_entry = NULL;
1608                 struct txgbe_rx_entry *next_rxe = NULL;
1609                 struct rte_mbuf *first_seg;
1610                 struct rte_mbuf *rxm;
1611                 struct rte_mbuf *nmb = NULL;
1612                 struct txgbe_rx_desc rxd;
1613                 uint16_t data_len;
1614                 uint16_t next_id;
1615                 volatile struct txgbe_rx_desc *rxdp;
1616                 uint32_t staterr;
1617
1618 next_desc:
1619                 /*
1620                  * The code in this whole file uses the volatile pointer to
1621                  * ensure the read ordering of the status and the rest of the
1622                  * descriptor fields (on the compiler level only!!!). This is so
1623                  * UGLY - why not to just use the compiler barrier instead? DPDK
1624                  * even has the rte_compiler_barrier() for that.
1625                  *
1626                  * But most importantly this is just wrong because this doesn't
1627                  * ensure memory ordering in a general case at all. For
1628                  * instance, DPDK is supposed to work on Power CPUs where
1629                  * compiler barrier may just not be enough!
1630                  *
1631                  * I tried to write only this function properly to have a
1632                  * starting point (as a part of an LRO/RSC series) but the
1633                  * compiler cursed at me when I tried to cast away the
1634                  * "volatile" from rx_ring (yes, it's volatile too!!!). So, I'm
1635                  * keeping it the way it is for now.
1636                  *
1637                  * The code in this file is broken in so many other places and
1638                  * will just not work on a big endian CPU anyway therefore the
1639                  * lines below will have to be revisited together with the rest
1640                  * of the txgbe PMD.
1641                  *
1642                  * TODO:
1643                  *    - Get rid of "volatile" and let the compiler do its job.
1644                  *    - Use the proper memory barrier (rte_rmb()) to ensure the
1645                  *      memory ordering below.
1646                  */
1647                 rxdp = &rx_ring[rx_id];
1648                 staterr = rte_le_to_cpu_32(rxdp->qw1.lo.status);
1649
1650                 if (!(staterr & TXGBE_RXD_STAT_DD))
1651                         break;
1652
1653                 rxd = *rxdp;
1654
1655                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1656                                   "staterr=0x%x data_len=%u",
1657                            rxq->port_id, rxq->queue_id, rx_id, staterr,
1658                            rte_le_to_cpu_16(rxd.qw1.hi.len));
1659
1660                 if (!bulk_alloc) {
1661                         nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
1662                         if (nmb == NULL) {
1663                                 PMD_RX_LOG(DEBUG, "RX mbuf alloc failed "
1664                                                   "port_id=%u queue_id=%u",
1665                                            rxq->port_id, rxq->queue_id);
1666
1667                                 dev->data->rx_mbuf_alloc_failed++;
1668                                 break;
1669                         }
1670                 } else if (nb_hold > rxq->rx_free_thresh) {
1671                         uint16_t next_rdt = rxq->rx_free_trigger;
1672
1673                         if (!txgbe_rx_alloc_bufs(rxq, false)) {
1674                                 rte_wmb();
1675                                 txgbe_set32_relaxed(rxq->rdt_reg_addr,
1676                                                             next_rdt);
1677                                 nb_hold -= rxq->rx_free_thresh;
1678                         } else {
1679                                 PMD_RX_LOG(DEBUG, "RX bulk alloc failed "
1680                                                   "port_id=%u queue_id=%u",
1681                                            rxq->port_id, rxq->queue_id);
1682
1683                                 dev->data->rx_mbuf_alloc_failed++;
1684                                 break;
1685                         }
1686                 }
1687
1688                 nb_hold++;
1689                 rxe = &sw_ring[rx_id];
1690                 eop = staterr & TXGBE_RXD_STAT_EOP;
1691
1692                 next_id = rx_id + 1;
1693                 if (next_id == rxq->nb_rx_desc)
1694                         next_id = 0;
1695
1696                 /* Prefetch next mbuf while processing current one. */
1697                 rte_txgbe_prefetch(sw_ring[next_id].mbuf);
1698
1699                 /*
1700                  * When next RX descriptor is on a cache-line boundary,
1701                  * prefetch the next 4 RX descriptors and the next 4 pointers
1702                  * to mbufs.
1703                  */
1704                 if ((next_id & 0x3) == 0) {
1705                         rte_txgbe_prefetch(&rx_ring[next_id]);
1706                         rte_txgbe_prefetch(&sw_ring[next_id]);
1707                 }
1708
1709                 rxm = rxe->mbuf;
1710
1711                 if (!bulk_alloc) {
1712                         __le64 dma =
1713                           rte_cpu_to_le_64(rte_mbuf_data_iova_default(nmb));
1714                         /*
1715                          * Update RX descriptor with the physical address of the
1716                          * new data buffer of the new allocated mbuf.
1717                          */
1718                         rxe->mbuf = nmb;
1719
1720                         rxm->data_off = RTE_PKTMBUF_HEADROOM;
1721                         TXGBE_RXD_HDRADDR(rxdp, 0);
1722                         TXGBE_RXD_PKTADDR(rxdp, dma);
1723                 } else {
1724                         rxe->mbuf = NULL;
1725                 }
1726
1727                 /*
1728                  * Set data length & data buffer address of mbuf.
1729                  */
1730                 data_len = rte_le_to_cpu_16(rxd.qw1.hi.len);
1731                 rxm->data_len = data_len;
1732
1733                 if (!eop) {
1734                         uint16_t nextp_id;
1735                         /*
1736                          * Get next descriptor index:
1737                          *  - For RSC it's in the NEXTP field.
1738                          *  - For a scattered packet - it's just a following
1739                          *    descriptor.
1740                          */
1741                         if (TXGBE_RXD_RSCCNT(rxd.qw0.dw0))
1742                                 nextp_id = TXGBE_RXD_NEXTP(staterr);
1743                         else
1744                                 nextp_id = next_id;
1745
1746                         next_sc_entry = &sw_sc_ring[nextp_id];
1747                         next_rxe = &sw_ring[nextp_id];
1748                         rte_txgbe_prefetch(next_rxe);
1749                 }
1750
1751                 sc_entry = &sw_sc_ring[rx_id];
1752                 first_seg = sc_entry->fbuf;
1753                 sc_entry->fbuf = NULL;
1754
1755                 /*
1756                  * If this is the first buffer of the received packet,
1757                  * set the pointer to the first mbuf of the packet and
1758                  * initialize its context.
1759                  * Otherwise, update the total length and the number of segments
1760                  * of the current scattered packet, and update the pointer to
1761                  * the last mbuf of the current packet.
1762                  */
1763                 if (first_seg == NULL) {
1764                         first_seg = rxm;
1765                         first_seg->pkt_len = data_len;
1766                         first_seg->nb_segs = 1;
1767                 } else {
1768                         first_seg->pkt_len += data_len;
1769                         first_seg->nb_segs++;
1770                 }
1771
1772                 prev_id = rx_id;
1773                 rx_id = next_id;
1774
1775                 /*
1776                  * If this is not the last buffer of the received packet, update
1777                  * the pointer to the first mbuf at the NEXTP entry in the
1778                  * sw_sc_ring and continue to parse the RX ring.
1779                  */
1780                 if (!eop && next_rxe) {
1781                         rxm->next = next_rxe->mbuf;
1782                         next_sc_entry->fbuf = first_seg;
1783                         goto next_desc;
1784                 }
1785
1786                 /* Initialize the first mbuf of the returned packet */
1787                 txgbe_fill_cluster_head_buf(first_seg, &rxd, rxq, staterr);
1788
1789                 /*
1790                  * Deal with the case, when HW CRC srip is disabled.
1791                  * That can't happen when LRO is enabled, but still could
1792                  * happen for scattered RX mode.
1793                  */
1794                 first_seg->pkt_len -= rxq->crc_len;
1795                 if (unlikely(rxm->data_len <= rxq->crc_len)) {
1796                         struct rte_mbuf *lp;
1797
1798                         for (lp = first_seg; lp->next != rxm; lp = lp->next)
1799                                 ;
1800
1801                         first_seg->nb_segs--;
1802                         lp->data_len -= rxq->crc_len - rxm->data_len;
1803                         lp->next = NULL;
1804                         rte_pktmbuf_free_seg(rxm);
1805                 } else {
1806                         rxm->data_len -= rxq->crc_len;
1807                 }
1808
1809                 /* Prefetch data of first segment, if configured to do so. */
1810                 rte_packet_prefetch((char *)first_seg->buf_addr +
1811                         first_seg->data_off);
1812
1813                 /*
1814                  * Store the mbuf address into the next entry of the array
1815                  * of returned packets.
1816                  */
1817                 rx_pkts[nb_rx++] = first_seg;
1818         }
1819
1820         /*
1821          * Record index of the next RX descriptor to probe.
1822          */
1823         rxq->rx_tail = rx_id;
1824
1825         /*
1826          * If the number of free RX descriptors is greater than the RX free
1827          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1828          * register.
1829          * Update the RDT with the value of the last processed RX descriptor
1830          * minus 1, to guarantee that the RDT register is never equal to the
1831          * RDH register, which creates a "full" ring situation from the
1832          * hardware point of view...
1833          */
1834         if (!bulk_alloc && nb_hold > rxq->rx_free_thresh) {
1835                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1836                            "nb_hold=%u nb_rx=%u",
1837                            rxq->port_id, rxq->queue_id, rx_id, nb_hold, nb_rx);
1838
1839                 rte_wmb();
1840                 txgbe_set32_relaxed(rxq->rdt_reg_addr, prev_id);
1841                 nb_hold = 0;
1842         }
1843
1844         rxq->nb_rx_hold = nb_hold;
1845         return nb_rx;
1846 }
1847
1848 uint16_t
1849 txgbe_recv_pkts_lro_single_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1850                                  uint16_t nb_pkts)
1851 {
1852         return txgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, false);
1853 }
1854
1855 uint16_t
1856 txgbe_recv_pkts_lro_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1857                                uint16_t nb_pkts)
1858 {
1859         return txgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, true);
1860 }
1861
1862 uint64_t
1863 txgbe_get_rx_queue_offloads(struct rte_eth_dev *dev __rte_unused)
1864 {
1865         return DEV_RX_OFFLOAD_VLAN_STRIP;
1866 }
1867
1868 uint64_t
1869 txgbe_get_rx_port_offloads(struct rte_eth_dev *dev)
1870 {
1871         uint64_t offloads;
1872         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
1873         struct rte_eth_dev_sriov *sriov = &RTE_ETH_DEV_SRIOV(dev);
1874
1875         offloads = DEV_RX_OFFLOAD_IPV4_CKSUM  |
1876                    DEV_RX_OFFLOAD_UDP_CKSUM   |
1877                    DEV_RX_OFFLOAD_TCP_CKSUM   |
1878                    DEV_RX_OFFLOAD_KEEP_CRC    |
1879                    DEV_RX_OFFLOAD_JUMBO_FRAME |
1880                    DEV_RX_OFFLOAD_VLAN_FILTER |
1881                    DEV_RX_OFFLOAD_RSS_HASH |
1882                    DEV_RX_OFFLOAD_SCATTER;
1883
1884         if (!txgbe_is_vf(dev))
1885                 offloads |= (DEV_RX_OFFLOAD_VLAN_FILTER |
1886                              DEV_RX_OFFLOAD_QINQ_STRIP |
1887                              DEV_RX_OFFLOAD_VLAN_EXTEND);
1888
1889         /*
1890          * RSC is only supported by PF devices in a non-SR-IOV
1891          * mode.
1892          */
1893         if (hw->mac.type == txgbe_mac_raptor && !sriov->active)
1894                 offloads |= DEV_RX_OFFLOAD_TCP_LRO;
1895
1896         if (hw->mac.type == txgbe_mac_raptor)
1897                 offloads |= DEV_RX_OFFLOAD_MACSEC_STRIP;
1898
1899         offloads |= DEV_RX_OFFLOAD_OUTER_IPV4_CKSUM;
1900
1901         return offloads;
1902 }
1903
1904 static void __rte_cold
1905 txgbe_tx_queue_release_mbufs(struct txgbe_tx_queue *txq)
1906 {
1907         unsigned int i;
1908
1909         if (txq->sw_ring != NULL) {
1910                 for (i = 0; i < txq->nb_tx_desc; i++) {
1911                         if (txq->sw_ring[i].mbuf != NULL) {
1912                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
1913                                 txq->sw_ring[i].mbuf = NULL;
1914                         }
1915                 }
1916         }
1917 }
1918
1919 static void __rte_cold
1920 txgbe_tx_free_swring(struct txgbe_tx_queue *txq)
1921 {
1922         if (txq != NULL &&
1923             txq->sw_ring != NULL)
1924                 rte_free(txq->sw_ring);
1925 }
1926
1927 static void __rte_cold
1928 txgbe_tx_queue_release(struct txgbe_tx_queue *txq)
1929 {
1930         if (txq != NULL && txq->ops != NULL) {
1931                 txq->ops->release_mbufs(txq);
1932                 txq->ops->free_swring(txq);
1933                 rte_free(txq);
1934         }
1935 }
1936
1937 void __rte_cold
1938 txgbe_dev_tx_queue_release(void *txq)
1939 {
1940         txgbe_tx_queue_release(txq);
1941 }
1942
1943 /* (Re)set dynamic txgbe_tx_queue fields to defaults */
1944 static void __rte_cold
1945 txgbe_reset_tx_queue(struct txgbe_tx_queue *txq)
1946 {
1947         static const struct txgbe_tx_desc zeroed_desc = {0};
1948         struct txgbe_tx_entry *txe = txq->sw_ring;
1949         uint16_t prev, i;
1950
1951         /* Zero out HW ring memory */
1952         for (i = 0; i < txq->nb_tx_desc; i++)
1953                 txq->tx_ring[i] = zeroed_desc;
1954
1955         /* Initialize SW ring entries */
1956         prev = (uint16_t)(txq->nb_tx_desc - 1);
1957         for (i = 0; i < txq->nb_tx_desc; i++) {
1958                 volatile struct txgbe_tx_desc *txd = &txq->tx_ring[i];
1959
1960                 txd->dw3 = rte_cpu_to_le_32(TXGBE_TXD_DD);
1961                 txe[i].mbuf = NULL;
1962                 txe[i].last_id = i;
1963                 txe[prev].next_id = i;
1964                 prev = i;
1965         }
1966
1967         txq->tx_next_dd = (uint16_t)(txq->tx_free_thresh - 1);
1968         txq->tx_tail = 0;
1969
1970         /*
1971          * Always allow 1 descriptor to be un-allocated to avoid
1972          * a H/W race condition
1973          */
1974         txq->last_desc_cleaned = (uint16_t)(txq->nb_tx_desc - 1);
1975         txq->nb_tx_free = (uint16_t)(txq->nb_tx_desc - 1);
1976         txq->ctx_curr = 0;
1977         memset((void *)&txq->ctx_cache, 0,
1978                 TXGBE_CTX_NUM * sizeof(struct txgbe_ctx_info));
1979 }
1980
1981 static const struct txgbe_txq_ops def_txq_ops = {
1982         .release_mbufs = txgbe_tx_queue_release_mbufs,
1983         .free_swring = txgbe_tx_free_swring,
1984         .reset = txgbe_reset_tx_queue,
1985 };
1986
1987 /* Takes an ethdev and a queue and sets up the tx function to be used based on
1988  * the queue parameters. Used in tx_queue_setup by primary process and then
1989  * in dev_init by secondary process when attaching to an existing ethdev.
1990  */
1991 void __rte_cold
1992 txgbe_set_tx_function(struct rte_eth_dev *dev, struct txgbe_tx_queue *txq)
1993 {
1994         /* Use a simple Tx queue (no offloads, no multi segs) if possible */
1995         if (txq->offloads == 0 &&
1996                         txq->tx_free_thresh >= RTE_PMD_TXGBE_TX_MAX_BURST) {
1997                 PMD_INIT_LOG(DEBUG, "Using simple tx code path");
1998                 dev->tx_pkt_burst = txgbe_xmit_pkts_simple;
1999                 dev->tx_pkt_prepare = NULL;
2000         } else {
2001                 PMD_INIT_LOG(DEBUG, "Using full-featured tx code path");
2002                 PMD_INIT_LOG(DEBUG,
2003                                 " - offloads = 0x%" PRIx64,
2004                                 txq->offloads);
2005                 PMD_INIT_LOG(DEBUG,
2006                                 " - tx_free_thresh = %lu [RTE_PMD_TXGBE_TX_MAX_BURST=%lu]",
2007                                 (unsigned long)txq->tx_free_thresh,
2008                                 (unsigned long)RTE_PMD_TXGBE_TX_MAX_BURST);
2009                 dev->tx_pkt_burst = txgbe_xmit_pkts;
2010                 dev->tx_pkt_prepare = txgbe_prep_pkts;
2011         }
2012 }
2013
2014 uint64_t
2015 txgbe_get_tx_queue_offloads(struct rte_eth_dev *dev)
2016 {
2017         RTE_SET_USED(dev);
2018
2019         return 0;
2020 }
2021
2022 uint64_t
2023 txgbe_get_tx_port_offloads(struct rte_eth_dev *dev)
2024 {
2025         uint64_t tx_offload_capa;
2026
2027         tx_offload_capa =
2028                 DEV_TX_OFFLOAD_VLAN_INSERT |
2029                 DEV_TX_OFFLOAD_IPV4_CKSUM  |
2030                 DEV_TX_OFFLOAD_UDP_CKSUM   |
2031                 DEV_TX_OFFLOAD_TCP_CKSUM   |
2032                 DEV_TX_OFFLOAD_SCTP_CKSUM  |
2033                 DEV_TX_OFFLOAD_TCP_TSO     |
2034                 DEV_TX_OFFLOAD_UDP_TSO     |
2035                 DEV_TX_OFFLOAD_UDP_TNL_TSO      |
2036                 DEV_TX_OFFLOAD_IP_TNL_TSO       |
2037                 DEV_TX_OFFLOAD_VXLAN_TNL_TSO    |
2038                 DEV_TX_OFFLOAD_GRE_TNL_TSO      |
2039                 DEV_TX_OFFLOAD_IPIP_TNL_TSO     |
2040                 DEV_TX_OFFLOAD_GENEVE_TNL_TSO   |
2041                 DEV_TX_OFFLOAD_MULTI_SEGS;
2042
2043         if (!txgbe_is_vf(dev))
2044                 tx_offload_capa |= DEV_TX_OFFLOAD_QINQ_INSERT;
2045
2046         tx_offload_capa |= DEV_TX_OFFLOAD_MACSEC_INSERT;
2047
2048         tx_offload_capa |= DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM;
2049
2050         return tx_offload_capa;
2051 }
2052
2053 int __rte_cold
2054 txgbe_dev_tx_queue_setup(struct rte_eth_dev *dev,
2055                          uint16_t queue_idx,
2056                          uint16_t nb_desc,
2057                          unsigned int socket_id,
2058                          const struct rte_eth_txconf *tx_conf)
2059 {
2060         const struct rte_memzone *tz;
2061         struct txgbe_tx_queue *txq;
2062         struct txgbe_hw     *hw;
2063         uint16_t tx_free_thresh;
2064         uint64_t offloads;
2065
2066         PMD_INIT_FUNC_TRACE();
2067         hw = TXGBE_DEV_HW(dev);
2068
2069         offloads = tx_conf->offloads | dev->data->dev_conf.txmode.offloads;
2070
2071         /*
2072          * Validate number of transmit descriptors.
2073          * It must not exceed hardware maximum, and must be multiple
2074          * of TXGBE_ALIGN.
2075          */
2076         if (nb_desc % TXGBE_TXD_ALIGN != 0 ||
2077             nb_desc > TXGBE_RING_DESC_MAX ||
2078             nb_desc < TXGBE_RING_DESC_MIN) {
2079                 return -EINVAL;
2080         }
2081
2082         /*
2083          * The TX descriptor ring will be cleaned after txq->tx_free_thresh
2084          * descriptors are used or if the number of descriptors required
2085          * to transmit a packet is greater than the number of free TX
2086          * descriptors.
2087          * One descriptor in the TX ring is used as a sentinel to avoid a
2088          * H/W race condition, hence the maximum threshold constraints.
2089          * When set to zero use default values.
2090          */
2091         tx_free_thresh = (uint16_t)((tx_conf->tx_free_thresh) ?
2092                         tx_conf->tx_free_thresh : DEFAULT_TX_FREE_THRESH);
2093         if (tx_free_thresh >= (nb_desc - 3)) {
2094                 PMD_INIT_LOG(ERR, "tx_free_thresh must be less than the number of "
2095                              "TX descriptors minus 3. (tx_free_thresh=%u "
2096                              "port=%d queue=%d)",
2097                              (unsigned int)tx_free_thresh,
2098                              (int)dev->data->port_id, (int)queue_idx);
2099                 return -(EINVAL);
2100         }
2101
2102         if ((nb_desc % tx_free_thresh) != 0) {
2103                 PMD_INIT_LOG(ERR, "tx_free_thresh must be a divisor of the "
2104                              "number of TX descriptors. (tx_free_thresh=%u "
2105                              "port=%d queue=%d)", (unsigned int)tx_free_thresh,
2106                              (int)dev->data->port_id, (int)queue_idx);
2107                 return -(EINVAL);
2108         }
2109
2110         /* Free memory prior to re-allocation if needed... */
2111         if (dev->data->tx_queues[queue_idx] != NULL) {
2112                 txgbe_tx_queue_release(dev->data->tx_queues[queue_idx]);
2113                 dev->data->tx_queues[queue_idx] = NULL;
2114         }
2115
2116         /* First allocate the tx queue data structure */
2117         txq = rte_zmalloc_socket("ethdev TX queue",
2118                                  sizeof(struct txgbe_tx_queue),
2119                                  RTE_CACHE_LINE_SIZE, socket_id);
2120         if (txq == NULL)
2121                 return -ENOMEM;
2122
2123         /*
2124          * Allocate TX ring hardware descriptors. A memzone large enough to
2125          * handle the maximum ring size is allocated in order to allow for
2126          * resizing in later calls to the queue setup function.
2127          */
2128         tz = rte_eth_dma_zone_reserve(dev, "tx_ring", queue_idx,
2129                         sizeof(struct txgbe_tx_desc) * TXGBE_RING_DESC_MAX,
2130                         TXGBE_ALIGN, socket_id);
2131         if (tz == NULL) {
2132                 txgbe_tx_queue_release(txq);
2133                 return -ENOMEM;
2134         }
2135
2136         txq->nb_tx_desc = nb_desc;
2137         txq->tx_free_thresh = tx_free_thresh;
2138         txq->pthresh = tx_conf->tx_thresh.pthresh;
2139         txq->hthresh = tx_conf->tx_thresh.hthresh;
2140         txq->wthresh = tx_conf->tx_thresh.wthresh;
2141         txq->queue_id = queue_idx;
2142         txq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2143                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2144         txq->port_id = dev->data->port_id;
2145         txq->offloads = offloads;
2146         txq->ops = &def_txq_ops;
2147         txq->tx_deferred_start = tx_conf->tx_deferred_start;
2148
2149         /* Modification to set tail pointer for virtual function
2150          * if vf is detected.
2151          */
2152         if (hw->mac.type == txgbe_mac_raptor_vf) {
2153                 txq->tdt_reg_addr = TXGBE_REG_ADDR(hw, TXGBE_TXWP(queue_idx));
2154                 txq->tdc_reg_addr = TXGBE_REG_ADDR(hw, TXGBE_TXCFG(queue_idx));
2155         } else {
2156                 txq->tdt_reg_addr = TXGBE_REG_ADDR(hw,
2157                                                 TXGBE_TXWP(txq->reg_idx));
2158                 txq->tdc_reg_addr = TXGBE_REG_ADDR(hw,
2159                                                 TXGBE_TXCFG(txq->reg_idx));
2160         }
2161
2162         txq->tx_ring_phys_addr = TMZ_PADDR(tz);
2163         txq->tx_ring = (struct txgbe_tx_desc *)TMZ_VADDR(tz);
2164
2165         /* Allocate software ring */
2166         txq->sw_ring = rte_zmalloc_socket("txq->sw_ring",
2167                                 sizeof(struct txgbe_tx_entry) * nb_desc,
2168                                 RTE_CACHE_LINE_SIZE, socket_id);
2169         if (txq->sw_ring == NULL) {
2170                 txgbe_tx_queue_release(txq);
2171                 return -ENOMEM;
2172         }
2173         PMD_INIT_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%" PRIx64,
2174                      txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr);
2175
2176         /* set up scalar TX function as appropriate */
2177         txgbe_set_tx_function(dev, txq);
2178
2179         txq->ops->reset(txq);
2180
2181         dev->data->tx_queues[queue_idx] = txq;
2182
2183         return 0;
2184 }
2185
2186 /**
2187  * txgbe_free_sc_cluster - free the not-yet-completed scattered cluster
2188  *
2189  * The "next" pointer of the last segment of (not-yet-completed) RSC clusters
2190  * in the sw_rsc_ring is not set to NULL but rather points to the next
2191  * mbuf of this RSC aggregation (that has not been completed yet and still
2192  * resides on the HW ring). So, instead of calling for rte_pktmbuf_free() we
2193  * will just free first "nb_segs" segments of the cluster explicitly by calling
2194  * an rte_pktmbuf_free_seg().
2195  *
2196  * @m scattered cluster head
2197  */
2198 static void __rte_cold
2199 txgbe_free_sc_cluster(struct rte_mbuf *m)
2200 {
2201         uint16_t i, nb_segs = m->nb_segs;
2202         struct rte_mbuf *next_seg;
2203
2204         for (i = 0; i < nb_segs; i++) {
2205                 next_seg = m->next;
2206                 rte_pktmbuf_free_seg(m);
2207                 m = next_seg;
2208         }
2209 }
2210
2211 static void __rte_cold
2212 txgbe_rx_queue_release_mbufs(struct txgbe_rx_queue *rxq)
2213 {
2214         unsigned int i;
2215
2216         if (rxq->sw_ring != NULL) {
2217                 for (i = 0; i < rxq->nb_rx_desc; i++) {
2218                         if (rxq->sw_ring[i].mbuf != NULL) {
2219                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
2220                                 rxq->sw_ring[i].mbuf = NULL;
2221                         }
2222                 }
2223                 if (rxq->rx_nb_avail) {
2224                         for (i = 0; i < rxq->rx_nb_avail; ++i) {
2225                                 struct rte_mbuf *mb;
2226
2227                                 mb = rxq->rx_stage[rxq->rx_next_avail + i];
2228                                 rte_pktmbuf_free_seg(mb);
2229                         }
2230                         rxq->rx_nb_avail = 0;
2231                 }
2232         }
2233
2234         if (rxq->sw_sc_ring)
2235                 for (i = 0; i < rxq->nb_rx_desc; i++)
2236                         if (rxq->sw_sc_ring[i].fbuf) {
2237                                 txgbe_free_sc_cluster(rxq->sw_sc_ring[i].fbuf);
2238                                 rxq->sw_sc_ring[i].fbuf = NULL;
2239                         }
2240 }
2241
2242 static void __rte_cold
2243 txgbe_rx_queue_release(struct txgbe_rx_queue *rxq)
2244 {
2245         if (rxq != NULL) {
2246                 txgbe_rx_queue_release_mbufs(rxq);
2247                 rte_free(rxq->sw_ring);
2248                 rte_free(rxq->sw_sc_ring);
2249                 rte_free(rxq);
2250         }
2251 }
2252
2253 void __rte_cold
2254 txgbe_dev_rx_queue_release(void *rxq)
2255 {
2256         txgbe_rx_queue_release(rxq);
2257 }
2258
2259 /*
2260  * Check if Rx Burst Bulk Alloc function can be used.
2261  * Return
2262  *        0: the preconditions are satisfied and the bulk allocation function
2263  *           can be used.
2264  *  -EINVAL: the preconditions are NOT satisfied and the default Rx burst
2265  *           function must be used.
2266  */
2267 static inline int __rte_cold
2268 check_rx_burst_bulk_alloc_preconditions(struct txgbe_rx_queue *rxq)
2269 {
2270         int ret = 0;
2271
2272         /*
2273          * Make sure the following pre-conditions are satisfied:
2274          *   rxq->rx_free_thresh >= RTE_PMD_TXGBE_RX_MAX_BURST
2275          *   rxq->rx_free_thresh < rxq->nb_rx_desc
2276          *   (rxq->nb_rx_desc % rxq->rx_free_thresh) == 0
2277          * Scattered packets are not supported.  This should be checked
2278          * outside of this function.
2279          */
2280         if (!(rxq->rx_free_thresh >= RTE_PMD_TXGBE_RX_MAX_BURST)) {
2281                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2282                              "rxq->rx_free_thresh=%d, "
2283                              "RTE_PMD_TXGBE_RX_MAX_BURST=%d",
2284                              rxq->rx_free_thresh, RTE_PMD_TXGBE_RX_MAX_BURST);
2285                 ret = -EINVAL;
2286         } else if (!(rxq->rx_free_thresh < rxq->nb_rx_desc)) {
2287                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2288                              "rxq->rx_free_thresh=%d, "
2289                              "rxq->nb_rx_desc=%d",
2290                              rxq->rx_free_thresh, rxq->nb_rx_desc);
2291                 ret = -EINVAL;
2292         } else if (!((rxq->nb_rx_desc % rxq->rx_free_thresh) == 0)) {
2293                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2294                              "rxq->nb_rx_desc=%d, "
2295                              "rxq->rx_free_thresh=%d",
2296                              rxq->nb_rx_desc, rxq->rx_free_thresh);
2297                 ret = -EINVAL;
2298         }
2299
2300         return ret;
2301 }
2302
2303 /* Reset dynamic txgbe_rx_queue fields back to defaults */
2304 static void __rte_cold
2305 txgbe_reset_rx_queue(struct txgbe_adapter *adapter, struct txgbe_rx_queue *rxq)
2306 {
2307         static const struct txgbe_rx_desc zeroed_desc = {
2308                                                 {{0}, {0} }, {{0}, {0} } };
2309         unsigned int i;
2310         uint16_t len = rxq->nb_rx_desc;
2311
2312         /*
2313          * By default, the Rx queue setup function allocates enough memory for
2314          * TXGBE_RING_DESC_MAX.  The Rx Burst bulk allocation function requires
2315          * extra memory at the end of the descriptor ring to be zero'd out.
2316          */
2317         if (adapter->rx_bulk_alloc_allowed)
2318                 /* zero out extra memory */
2319                 len += RTE_PMD_TXGBE_RX_MAX_BURST;
2320
2321         /*
2322          * Zero out HW ring memory. Zero out extra memory at the end of
2323          * the H/W ring so look-ahead logic in Rx Burst bulk alloc function
2324          * reads extra memory as zeros.
2325          */
2326         for (i = 0; i < len; i++)
2327                 rxq->rx_ring[i] = zeroed_desc;
2328
2329         /*
2330          * initialize extra software ring entries. Space for these extra
2331          * entries is always allocated
2332          */
2333         memset(&rxq->fake_mbuf, 0x0, sizeof(rxq->fake_mbuf));
2334         for (i = rxq->nb_rx_desc; i < len; ++i)
2335                 rxq->sw_ring[i].mbuf = &rxq->fake_mbuf;
2336
2337         rxq->rx_nb_avail = 0;
2338         rxq->rx_next_avail = 0;
2339         rxq->rx_free_trigger = (uint16_t)(rxq->rx_free_thresh - 1);
2340         rxq->rx_tail = 0;
2341         rxq->nb_rx_hold = 0;
2342         rxq->pkt_first_seg = NULL;
2343         rxq->pkt_last_seg = NULL;
2344 }
2345
2346 int __rte_cold
2347 txgbe_dev_rx_queue_setup(struct rte_eth_dev *dev,
2348                          uint16_t queue_idx,
2349                          uint16_t nb_desc,
2350                          unsigned int socket_id,
2351                          const struct rte_eth_rxconf *rx_conf,
2352                          struct rte_mempool *mp)
2353 {
2354         const struct rte_memzone *rz;
2355         struct txgbe_rx_queue *rxq;
2356         struct txgbe_hw     *hw;
2357         uint16_t len;
2358         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2359         uint64_t offloads;
2360
2361         PMD_INIT_FUNC_TRACE();
2362         hw = TXGBE_DEV_HW(dev);
2363
2364         offloads = rx_conf->offloads | dev->data->dev_conf.rxmode.offloads;
2365
2366         /*
2367          * Validate number of receive descriptors.
2368          * It must not exceed hardware maximum, and must be multiple
2369          * of TXGBE_ALIGN.
2370          */
2371         if (nb_desc % TXGBE_RXD_ALIGN != 0 ||
2372                         nb_desc > TXGBE_RING_DESC_MAX ||
2373                         nb_desc < TXGBE_RING_DESC_MIN) {
2374                 return -EINVAL;
2375         }
2376
2377         /* Free memory prior to re-allocation if needed... */
2378         if (dev->data->rx_queues[queue_idx] != NULL) {
2379                 txgbe_rx_queue_release(dev->data->rx_queues[queue_idx]);
2380                 dev->data->rx_queues[queue_idx] = NULL;
2381         }
2382
2383         /* First allocate the rx queue data structure */
2384         rxq = rte_zmalloc_socket("ethdev RX queue",
2385                                  sizeof(struct txgbe_rx_queue),
2386                                  RTE_CACHE_LINE_SIZE, socket_id);
2387         if (rxq == NULL)
2388                 return -ENOMEM;
2389         rxq->mb_pool = mp;
2390         rxq->nb_rx_desc = nb_desc;
2391         rxq->rx_free_thresh = rx_conf->rx_free_thresh;
2392         rxq->queue_id = queue_idx;
2393         rxq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2394                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2395         rxq->port_id = dev->data->port_id;
2396         if (dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_KEEP_CRC)
2397                 rxq->crc_len = RTE_ETHER_CRC_LEN;
2398         else
2399                 rxq->crc_len = 0;
2400         rxq->drop_en = rx_conf->rx_drop_en;
2401         rxq->rx_deferred_start = rx_conf->rx_deferred_start;
2402         rxq->offloads = offloads;
2403
2404         /*
2405          * The packet type in RX descriptor is different for different NICs.
2406          * So set different masks for different NICs.
2407          */
2408         rxq->pkt_type_mask = TXGBE_PTID_MASK;
2409
2410         /*
2411          * Allocate RX ring hardware descriptors. A memzone large enough to
2412          * handle the maximum ring size is allocated in order to allow for
2413          * resizing in later calls to the queue setup function.
2414          */
2415         rz = rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx,
2416                                       RX_RING_SZ, TXGBE_ALIGN, socket_id);
2417         if (rz == NULL) {
2418                 txgbe_rx_queue_release(rxq);
2419                 return -ENOMEM;
2420         }
2421
2422         /*
2423          * Zero init all the descriptors in the ring.
2424          */
2425         memset(rz->addr, 0, RX_RING_SZ);
2426
2427         /*
2428          * Modified to setup VFRDT for Virtual Function
2429          */
2430         if (hw->mac.type == txgbe_mac_raptor_vf) {
2431                 rxq->rdt_reg_addr =
2432                         TXGBE_REG_ADDR(hw, TXGBE_RXWP(queue_idx));
2433                 rxq->rdh_reg_addr =
2434                         TXGBE_REG_ADDR(hw, TXGBE_RXRP(queue_idx));
2435         } else {
2436                 rxq->rdt_reg_addr =
2437                         TXGBE_REG_ADDR(hw, TXGBE_RXWP(rxq->reg_idx));
2438                 rxq->rdh_reg_addr =
2439                         TXGBE_REG_ADDR(hw, TXGBE_RXRP(rxq->reg_idx));
2440         }
2441
2442         rxq->rx_ring_phys_addr = TMZ_PADDR(rz);
2443         rxq->rx_ring = (struct txgbe_rx_desc *)TMZ_VADDR(rz);
2444
2445         /*
2446          * Certain constraints must be met in order to use the bulk buffer
2447          * allocation Rx burst function. If any of Rx queues doesn't meet them
2448          * the feature should be disabled for the whole port.
2449          */
2450         if (check_rx_burst_bulk_alloc_preconditions(rxq)) {
2451                 PMD_INIT_LOG(DEBUG, "queue[%d] doesn't meet Rx Bulk Alloc "
2452                                     "preconditions - canceling the feature for "
2453                                     "the whole port[%d]",
2454                              rxq->queue_id, rxq->port_id);
2455                 adapter->rx_bulk_alloc_allowed = false;
2456         }
2457
2458         /*
2459          * Allocate software ring. Allow for space at the end of the
2460          * S/W ring to make sure look-ahead logic in bulk alloc Rx burst
2461          * function does not access an invalid memory region.
2462          */
2463         len = nb_desc;
2464         if (adapter->rx_bulk_alloc_allowed)
2465                 len += RTE_PMD_TXGBE_RX_MAX_BURST;
2466
2467         rxq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
2468                                           sizeof(struct txgbe_rx_entry) * len,
2469                                           RTE_CACHE_LINE_SIZE, socket_id);
2470         if (!rxq->sw_ring) {
2471                 txgbe_rx_queue_release(rxq);
2472                 return -ENOMEM;
2473         }
2474
2475         /*
2476          * Always allocate even if it's not going to be needed in order to
2477          * simplify the code.
2478          *
2479          * This ring is used in LRO and Scattered Rx cases and Scattered Rx may
2480          * be requested in txgbe_dev_rx_init(), which is called later from
2481          * dev_start() flow.
2482          */
2483         rxq->sw_sc_ring =
2484                 rte_zmalloc_socket("rxq->sw_sc_ring",
2485                                   sizeof(struct txgbe_scattered_rx_entry) * len,
2486                                   RTE_CACHE_LINE_SIZE, socket_id);
2487         if (!rxq->sw_sc_ring) {
2488                 txgbe_rx_queue_release(rxq);
2489                 return -ENOMEM;
2490         }
2491
2492         PMD_INIT_LOG(DEBUG, "sw_ring=%p sw_sc_ring=%p hw_ring=%p "
2493                             "dma_addr=0x%" PRIx64,
2494                      rxq->sw_ring, rxq->sw_sc_ring, rxq->rx_ring,
2495                      rxq->rx_ring_phys_addr);
2496
2497         dev->data->rx_queues[queue_idx] = rxq;
2498
2499         txgbe_reset_rx_queue(adapter, rxq);
2500
2501         return 0;
2502 }
2503
2504 void __rte_cold
2505 txgbe_dev_clear_queues(struct rte_eth_dev *dev)
2506 {
2507         unsigned int i;
2508         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2509
2510         PMD_INIT_FUNC_TRACE();
2511
2512         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2513                 struct txgbe_tx_queue *txq = dev->data->tx_queues[i];
2514
2515                 if (txq != NULL) {
2516                         txq->ops->release_mbufs(txq);
2517                         txq->ops->reset(txq);
2518                 }
2519         }
2520
2521         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2522                 struct txgbe_rx_queue *rxq = dev->data->rx_queues[i];
2523
2524                 if (rxq != NULL) {
2525                         txgbe_rx_queue_release_mbufs(rxq);
2526                         txgbe_reset_rx_queue(adapter, rxq);
2527                 }
2528         }
2529 }
2530
2531 void
2532 txgbe_dev_free_queues(struct rte_eth_dev *dev)
2533 {
2534         unsigned int i;
2535
2536         PMD_INIT_FUNC_TRACE();
2537
2538         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2539                 txgbe_dev_rx_queue_release(dev->data->rx_queues[i]);
2540                 dev->data->rx_queues[i] = NULL;
2541         }
2542         dev->data->nb_rx_queues = 0;
2543
2544         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2545                 txgbe_dev_tx_queue_release(dev->data->tx_queues[i]);
2546                 dev->data->tx_queues[i] = NULL;
2547         }
2548         dev->data->nb_tx_queues = 0;
2549 }
2550
2551 static int __rte_cold
2552 txgbe_alloc_rx_queue_mbufs(struct txgbe_rx_queue *rxq)
2553 {
2554         struct txgbe_rx_entry *rxe = rxq->sw_ring;
2555         uint64_t dma_addr;
2556         unsigned int i;
2557
2558         /* Initialize software ring entries */
2559         for (i = 0; i < rxq->nb_rx_desc; i++) {
2560                 volatile struct txgbe_rx_desc *rxd;
2561                 struct rte_mbuf *mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
2562
2563                 if (mbuf == NULL) {
2564                         PMD_INIT_LOG(ERR, "RX mbuf alloc failed queue_id=%u",
2565                                      (unsigned int)rxq->queue_id);
2566                         return -ENOMEM;
2567                 }
2568
2569                 mbuf->data_off = RTE_PKTMBUF_HEADROOM;
2570                 mbuf->port = rxq->port_id;
2571
2572                 dma_addr =
2573                         rte_cpu_to_le_64(rte_mbuf_data_iova_default(mbuf));
2574                 rxd = &rxq->rx_ring[i];
2575                 TXGBE_RXD_HDRADDR(rxd, 0);
2576                 TXGBE_RXD_PKTADDR(rxd, dma_addr);
2577                 rxe[i].mbuf = mbuf;
2578         }
2579
2580         return 0;
2581 }
2582
2583 /**
2584  * txgbe_get_rscctl_maxdesc
2585  *
2586  * @pool Memory pool of the Rx queue
2587  */
2588 static inline uint32_t
2589 txgbe_get_rscctl_maxdesc(struct rte_mempool *pool)
2590 {
2591         struct rte_pktmbuf_pool_private *mp_priv = rte_mempool_get_priv(pool);
2592
2593         uint16_t maxdesc =
2594                 RTE_IPV4_MAX_PKT_LEN /
2595                         (mp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM);
2596
2597         if (maxdesc >= 16)
2598                 return TXGBE_RXCFG_RSCMAX_16;
2599         else if (maxdesc >= 8)
2600                 return TXGBE_RXCFG_RSCMAX_8;
2601         else if (maxdesc >= 4)
2602                 return TXGBE_RXCFG_RSCMAX_4;
2603         else
2604                 return TXGBE_RXCFG_RSCMAX_1;
2605 }
2606
2607 /**
2608  * txgbe_set_rsc - configure RSC related port HW registers
2609  *
2610  * Configures the port's RSC related registers.
2611  *
2612  * @dev port handle
2613  *
2614  * Returns 0 in case of success or a non-zero error code
2615  */
2616 static int
2617 txgbe_set_rsc(struct rte_eth_dev *dev)
2618 {
2619         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
2620         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
2621         struct rte_eth_dev_info dev_info = { 0 };
2622         bool rsc_capable = false;
2623         uint16_t i;
2624         uint32_t rdrxctl;
2625         uint32_t rfctl;
2626
2627         /* Sanity check */
2628         dev->dev_ops->dev_infos_get(dev, &dev_info);
2629         if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_LRO)
2630                 rsc_capable = true;
2631
2632         if (!rsc_capable && (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO)) {
2633                 PMD_INIT_LOG(CRIT, "LRO is requested on HW that doesn't "
2634                                    "support it");
2635                 return -EINVAL;
2636         }
2637
2638         /* RSC global configuration */
2639
2640         if ((rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC) &&
2641              (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO)) {
2642                 PMD_INIT_LOG(CRIT, "LRO can't be enabled when HW CRC "
2643                                     "is disabled");
2644                 return -EINVAL;
2645         }
2646
2647         rfctl = rd32(hw, TXGBE_PSRCTL);
2648         if (rsc_capable && (rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO))
2649                 rfctl &= ~TXGBE_PSRCTL_RSCDIA;
2650         else
2651                 rfctl |= TXGBE_PSRCTL_RSCDIA;
2652         wr32(hw, TXGBE_PSRCTL, rfctl);
2653
2654         /* If LRO hasn't been requested - we are done here. */
2655         if (!(rx_conf->offloads & DEV_RX_OFFLOAD_TCP_LRO))
2656                 return 0;
2657
2658         /* Set PSRCTL.RSCACK bit */
2659         rdrxctl = rd32(hw, TXGBE_PSRCTL);
2660         rdrxctl |= TXGBE_PSRCTL_RSCACK;
2661         wr32(hw, TXGBE_PSRCTL, rdrxctl);
2662
2663         /* Per-queue RSC configuration */
2664         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2665                 struct txgbe_rx_queue *rxq = dev->data->rx_queues[i];
2666                 uint32_t srrctl =
2667                         rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
2668                 uint32_t psrtype =
2669                         rd32(hw, TXGBE_POOLRSS(rxq->reg_idx));
2670                 uint32_t eitr =
2671                         rd32(hw, TXGBE_ITR(rxq->reg_idx));
2672
2673                 /*
2674                  * txgbe PMD doesn't support header-split at the moment.
2675                  */
2676                 srrctl &= ~TXGBE_RXCFG_HDRLEN_MASK;
2677                 srrctl |= TXGBE_RXCFG_HDRLEN(128);
2678
2679                 /*
2680                  * TODO: Consider setting the Receive Descriptor Minimum
2681                  * Threshold Size for an RSC case. This is not an obviously
2682                  * beneficiary option but the one worth considering...
2683                  */
2684
2685                 srrctl |= TXGBE_RXCFG_RSCENA;
2686                 srrctl &= ~TXGBE_RXCFG_RSCMAX_MASK;
2687                 srrctl |= txgbe_get_rscctl_maxdesc(rxq->mb_pool);
2688                 psrtype |= TXGBE_POOLRSS_L4HDR;
2689
2690                 /*
2691                  * RSC: Set ITR interval corresponding to 2K ints/s.
2692                  *
2693                  * Full-sized RSC aggregations for a 10Gb/s link will
2694                  * arrive at about 20K aggregation/s rate.
2695                  *
2696                  * 2K inst/s rate will make only 10% of the
2697                  * aggregations to be closed due to the interrupt timer
2698                  * expiration for a streaming at wire-speed case.
2699                  *
2700                  * For a sparse streaming case this setting will yield
2701                  * at most 500us latency for a single RSC aggregation.
2702                  */
2703                 eitr &= ~TXGBE_ITR_IVAL_MASK;
2704                 eitr |= TXGBE_ITR_IVAL_10G(TXGBE_QUEUE_ITR_INTERVAL_DEFAULT);
2705                 eitr |= TXGBE_ITR_WRDSA;
2706
2707                 wr32(hw, TXGBE_RXCFG(rxq->reg_idx), srrctl);
2708                 wr32(hw, TXGBE_POOLRSS(rxq->reg_idx), psrtype);
2709                 wr32(hw, TXGBE_ITR(rxq->reg_idx), eitr);
2710
2711                 /*
2712                  * RSC requires the mapping of the queue to the
2713                  * interrupt vector.
2714                  */
2715                 txgbe_set_ivar_map(hw, 0, rxq->reg_idx, i);
2716         }
2717
2718         dev->data->lro = 1;
2719
2720         PMD_INIT_LOG(DEBUG, "enabling LRO mode");
2721
2722         return 0;
2723 }
2724
2725 void __rte_cold
2726 txgbe_set_rx_function(struct rte_eth_dev *dev)
2727 {
2728         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
2729
2730         /*
2731          * Initialize the appropriate LRO callback.
2732          *
2733          * If all queues satisfy the bulk allocation preconditions
2734          * (adapter->rx_bulk_alloc_allowed is TRUE) then we may use
2735          * bulk allocation. Otherwise use a single allocation version.
2736          */
2737         if (dev->data->lro) {
2738                 if (adapter->rx_bulk_alloc_allowed) {
2739                         PMD_INIT_LOG(DEBUG, "LRO is requested. Using a bulk "
2740                                            "allocation version");
2741                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_bulk_alloc;
2742                 } else {
2743                         PMD_INIT_LOG(DEBUG, "LRO is requested. Using a single "
2744                                            "allocation version");
2745                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_single_alloc;
2746                 }
2747         } else if (dev->data->scattered_rx) {
2748                 /*
2749                  * Set the non-LRO scattered callback: there are bulk and
2750                  * single allocation versions.
2751                  */
2752                 if (adapter->rx_bulk_alloc_allowed) {
2753                         PMD_INIT_LOG(DEBUG, "Using a Scattered with bulk "
2754                                            "allocation callback (port=%d).",
2755                                      dev->data->port_id);
2756                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_bulk_alloc;
2757                 } else {
2758                         PMD_INIT_LOG(DEBUG, "Using Regular (non-vector, "
2759                                             "single allocation) "
2760                                             "Scattered Rx callback "
2761                                             "(port=%d).",
2762                                      dev->data->port_id);
2763
2764                         dev->rx_pkt_burst = txgbe_recv_pkts_lro_single_alloc;
2765                 }
2766         /*
2767          * Below we set "simple" callbacks according to port/queues parameters.
2768          * If parameters allow we are going to choose between the following
2769          * callbacks:
2770          *    - Bulk Allocation
2771          *    - Single buffer allocation (the simplest one)
2772          */
2773         } else if (adapter->rx_bulk_alloc_allowed) {
2774                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are "
2775                                     "satisfied. Rx Burst Bulk Alloc function "
2776                                     "will be used on port=%d.",
2777                              dev->data->port_id);
2778
2779                 dev->rx_pkt_burst = txgbe_recv_pkts_bulk_alloc;
2780         } else {
2781                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are not "
2782                                     "satisfied, or Scattered Rx is requested "
2783                                     "(port=%d).",
2784                              dev->data->port_id);
2785
2786                 dev->rx_pkt_burst = txgbe_recv_pkts;
2787         }
2788 }
2789
2790 /*
2791  * Initializes Receive Unit.
2792  */
2793 int __rte_cold
2794 txgbe_dev_rx_init(struct rte_eth_dev *dev)
2795 {
2796         struct txgbe_hw *hw;
2797         struct txgbe_rx_queue *rxq;
2798         uint64_t bus_addr;
2799         uint32_t fctrl;
2800         uint32_t hlreg0;
2801         uint32_t srrctl;
2802         uint32_t rdrxctl;
2803         uint32_t rxcsum;
2804         uint16_t buf_size;
2805         uint16_t i;
2806         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
2807         int rc;
2808
2809         PMD_INIT_FUNC_TRACE();
2810         hw = TXGBE_DEV_HW(dev);
2811
2812         /*
2813          * Make sure receives are disabled while setting
2814          * up the RX context (registers, descriptor rings, etc.).
2815          */
2816         wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_ENA, 0);
2817         wr32m(hw, TXGBE_PBRXCTL, TXGBE_PBRXCTL_ENA, 0);
2818
2819         /* Enable receipt of broadcasted frames */
2820         fctrl = rd32(hw, TXGBE_PSRCTL);
2821         fctrl |= TXGBE_PSRCTL_BCA;
2822         wr32(hw, TXGBE_PSRCTL, fctrl);
2823
2824         /*
2825          * Configure CRC stripping, if any.
2826          */
2827         hlreg0 = rd32(hw, TXGBE_SECRXCTL);
2828         if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
2829                 hlreg0 &= ~TXGBE_SECRXCTL_CRCSTRIP;
2830         else
2831                 hlreg0 |= TXGBE_SECRXCTL_CRCSTRIP;
2832         wr32(hw, TXGBE_SECRXCTL, hlreg0);
2833
2834         /*
2835          * Configure jumbo frame support, if any.
2836          */
2837         if (rx_conf->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
2838                 wr32m(hw, TXGBE_FRMSZ, TXGBE_FRMSZ_MAX_MASK,
2839                         TXGBE_FRMSZ_MAX(rx_conf->max_rx_pkt_len));
2840         } else {
2841                 wr32m(hw, TXGBE_FRMSZ, TXGBE_FRMSZ_MAX_MASK,
2842                         TXGBE_FRMSZ_MAX(TXGBE_FRAME_SIZE_DFT));
2843         }
2844
2845         /*
2846          * If loopback mode is configured, set LPBK bit.
2847          */
2848         hlreg0 = rd32(hw, TXGBE_PSRCTL);
2849         if (hw->mac.type == txgbe_mac_raptor &&
2850             dev->data->dev_conf.lpbk_mode)
2851                 hlreg0 |= TXGBE_PSRCTL_LBENA;
2852         else
2853                 hlreg0 &= ~TXGBE_PSRCTL_LBENA;
2854
2855         wr32(hw, TXGBE_PSRCTL, hlreg0);
2856
2857         /*
2858          * Assume no header split and no VLAN strip support
2859          * on any Rx queue first .
2860          */
2861         rx_conf->offloads &= ~DEV_RX_OFFLOAD_VLAN_STRIP;
2862
2863         /* Setup RX queues */
2864         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2865                 rxq = dev->data->rx_queues[i];
2866
2867                 /*
2868                  * Reset crc_len in case it was changed after queue setup by a
2869                  * call to configure.
2870                  */
2871                 if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
2872                         rxq->crc_len = RTE_ETHER_CRC_LEN;
2873                 else
2874                         rxq->crc_len = 0;
2875
2876                 /* Setup the Base and Length of the Rx Descriptor Rings */
2877                 bus_addr = rxq->rx_ring_phys_addr;
2878                 wr32(hw, TXGBE_RXBAL(rxq->reg_idx),
2879                                 (uint32_t)(bus_addr & BIT_MASK32));
2880                 wr32(hw, TXGBE_RXBAH(rxq->reg_idx),
2881                                 (uint32_t)(bus_addr >> 32));
2882                 wr32(hw, TXGBE_RXRP(rxq->reg_idx), 0);
2883                 wr32(hw, TXGBE_RXWP(rxq->reg_idx), 0);
2884
2885                 srrctl = TXGBE_RXCFG_RNGLEN(rxq->nb_rx_desc);
2886
2887                 /* Set if packets are dropped when no descriptors available */
2888                 if (rxq->drop_en)
2889                         srrctl |= TXGBE_RXCFG_DROP;
2890
2891                 /*
2892                  * Configure the RX buffer size in the PKTLEN field of
2893                  * the RXCFG register of the queue.
2894                  * The value is in 1 KB resolution. Valid values can be from
2895                  * 1 KB to 16 KB.
2896                  */
2897                 buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rxq->mb_pool) -
2898                         RTE_PKTMBUF_HEADROOM);
2899                 buf_size = ROUND_UP(buf_size, 0x1 << 10);
2900                 srrctl |= TXGBE_RXCFG_PKTLEN(buf_size);
2901
2902                 wr32(hw, TXGBE_RXCFG(rxq->reg_idx), srrctl);
2903
2904                 /* It adds dual VLAN length for supporting dual VLAN */
2905                 if (dev->data->dev_conf.rxmode.max_rx_pkt_len +
2906                                             2 * TXGBE_VLAN_TAG_SIZE > buf_size)
2907                         dev->data->scattered_rx = 1;
2908                 if (rxq->offloads & DEV_RX_OFFLOAD_VLAN_STRIP)
2909                         rx_conf->offloads |= DEV_RX_OFFLOAD_VLAN_STRIP;
2910         }
2911
2912         if (rx_conf->offloads & DEV_RX_OFFLOAD_SCATTER)
2913                 dev->data->scattered_rx = 1;
2914
2915         /*
2916          * Setup the Checksum Register.
2917          * Disable Full-Packet Checksum which is mutually exclusive with RSS.
2918          * Enable IP/L4 checksum computation by hardware if requested to do so.
2919          */
2920         rxcsum = rd32(hw, TXGBE_PSRCTL);
2921         rxcsum |= TXGBE_PSRCTL_PCSD;
2922         if (rx_conf->offloads & DEV_RX_OFFLOAD_CHECKSUM)
2923                 rxcsum |= TXGBE_PSRCTL_L4CSUM;
2924         else
2925                 rxcsum &= ~TXGBE_PSRCTL_L4CSUM;
2926
2927         wr32(hw, TXGBE_PSRCTL, rxcsum);
2928
2929         if (hw->mac.type == txgbe_mac_raptor) {
2930                 rdrxctl = rd32(hw, TXGBE_SECRXCTL);
2931                 if (rx_conf->offloads & DEV_RX_OFFLOAD_KEEP_CRC)
2932                         rdrxctl &= ~TXGBE_SECRXCTL_CRCSTRIP;
2933                 else
2934                         rdrxctl |= TXGBE_SECRXCTL_CRCSTRIP;
2935                 wr32(hw, TXGBE_SECRXCTL, rdrxctl);
2936         }
2937
2938         rc = txgbe_set_rsc(dev);
2939         if (rc)
2940                 return rc;
2941
2942         txgbe_set_rx_function(dev);
2943
2944         return 0;
2945 }
2946
2947 /*
2948  * Initializes Transmit Unit.
2949  */
2950 void __rte_cold
2951 txgbe_dev_tx_init(struct rte_eth_dev *dev)
2952 {
2953         struct txgbe_hw     *hw;
2954         struct txgbe_tx_queue *txq;
2955         uint64_t bus_addr;
2956         uint16_t i;
2957
2958         PMD_INIT_FUNC_TRACE();
2959         hw = TXGBE_DEV_HW(dev);
2960
2961         /* Setup the Base and Length of the Tx Descriptor Rings */
2962         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2963                 txq = dev->data->tx_queues[i];
2964
2965                 bus_addr = txq->tx_ring_phys_addr;
2966                 wr32(hw, TXGBE_TXBAL(txq->reg_idx),
2967                                 (uint32_t)(bus_addr & BIT_MASK32));
2968                 wr32(hw, TXGBE_TXBAH(txq->reg_idx),
2969                                 (uint32_t)(bus_addr >> 32));
2970                 wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_BUFLEN_MASK,
2971                         TXGBE_TXCFG_BUFLEN(txq->nb_tx_desc));
2972                 /* Setup the HW Tx Head and TX Tail descriptor pointers */
2973                 wr32(hw, TXGBE_TXRP(txq->reg_idx), 0);
2974                 wr32(hw, TXGBE_TXWP(txq->reg_idx), 0);
2975         }
2976 }
2977
2978 /*
2979  * Set up link loopback mode Tx->Rx.
2980  */
2981 static inline void __rte_cold
2982 txgbe_setup_loopback_link_raptor(struct txgbe_hw *hw)
2983 {
2984         PMD_INIT_FUNC_TRACE();
2985
2986         wr32m(hw, TXGBE_MACRXCFG, TXGBE_MACRXCFG_LB, TXGBE_MACRXCFG_LB);
2987
2988         msec_delay(50);
2989 }
2990
2991 /*
2992  * Start Transmit and Receive Units.
2993  */
2994 int __rte_cold
2995 txgbe_dev_rxtx_start(struct rte_eth_dev *dev)
2996 {
2997         struct txgbe_hw     *hw;
2998         struct txgbe_tx_queue *txq;
2999         struct txgbe_rx_queue *rxq;
3000         uint32_t dmatxctl;
3001         uint32_t rxctrl;
3002         uint16_t i;
3003         int ret = 0;
3004
3005         PMD_INIT_FUNC_TRACE();
3006         hw = TXGBE_DEV_HW(dev);
3007
3008         for (i = 0; i < dev->data->nb_tx_queues; i++) {
3009                 txq = dev->data->tx_queues[i];
3010                 /* Setup Transmit Threshold Registers */
3011                 wr32m(hw, TXGBE_TXCFG(txq->reg_idx),
3012                       TXGBE_TXCFG_HTHRESH_MASK |
3013                       TXGBE_TXCFG_WTHRESH_MASK,
3014                       TXGBE_TXCFG_HTHRESH(txq->hthresh) |
3015                       TXGBE_TXCFG_WTHRESH(txq->wthresh));
3016         }
3017
3018         dmatxctl = rd32(hw, TXGBE_DMATXCTRL);
3019         dmatxctl |= TXGBE_DMATXCTRL_ENA;
3020         wr32(hw, TXGBE_DMATXCTRL, dmatxctl);
3021
3022         for (i = 0; i < dev->data->nb_tx_queues; i++) {
3023                 txq = dev->data->tx_queues[i];
3024                 if (!txq->tx_deferred_start) {
3025                         ret = txgbe_dev_tx_queue_start(dev, i);
3026                         if (ret < 0)
3027                                 return ret;
3028                 }
3029         }
3030
3031         for (i = 0; i < dev->data->nb_rx_queues; i++) {
3032                 rxq = dev->data->rx_queues[i];
3033                 if (!rxq->rx_deferred_start) {
3034                         ret = txgbe_dev_rx_queue_start(dev, i);
3035                         if (ret < 0)
3036                                 return ret;
3037                 }
3038         }
3039
3040         /* Enable Receive engine */
3041         rxctrl = rd32(hw, TXGBE_PBRXCTL);
3042         rxctrl |= TXGBE_PBRXCTL_ENA;
3043         hw->mac.enable_rx_dma(hw, rxctrl);
3044
3045         /* If loopback mode is enabled, set up the link accordingly */
3046         if (hw->mac.type == txgbe_mac_raptor &&
3047             dev->data->dev_conf.lpbk_mode)
3048                 txgbe_setup_loopback_link_raptor(hw);
3049
3050         return 0;
3051 }
3052
3053 void
3054 txgbe_dev_save_rx_queue(struct txgbe_hw *hw, uint16_t rx_queue_id)
3055 {
3056         u32 *reg = &hw->q_rx_regs[rx_queue_id * 8];
3057         *(reg++) = rd32(hw, TXGBE_RXBAL(rx_queue_id));
3058         *(reg++) = rd32(hw, TXGBE_RXBAH(rx_queue_id));
3059         *(reg++) = rd32(hw, TXGBE_RXCFG(rx_queue_id));
3060 }
3061
3062 void
3063 txgbe_dev_store_rx_queue(struct txgbe_hw *hw, uint16_t rx_queue_id)
3064 {
3065         u32 *reg = &hw->q_rx_regs[rx_queue_id * 8];
3066         wr32(hw, TXGBE_RXBAL(rx_queue_id), *(reg++));
3067         wr32(hw, TXGBE_RXBAH(rx_queue_id), *(reg++));
3068         wr32(hw, TXGBE_RXCFG(rx_queue_id), *(reg++) & ~TXGBE_RXCFG_ENA);
3069 }
3070
3071 void
3072 txgbe_dev_save_tx_queue(struct txgbe_hw *hw, uint16_t tx_queue_id)
3073 {
3074         u32 *reg = &hw->q_tx_regs[tx_queue_id * 8];
3075         *(reg++) = rd32(hw, TXGBE_TXBAL(tx_queue_id));
3076         *(reg++) = rd32(hw, TXGBE_TXBAH(tx_queue_id));
3077         *(reg++) = rd32(hw, TXGBE_TXCFG(tx_queue_id));
3078 }
3079
3080 void
3081 txgbe_dev_store_tx_queue(struct txgbe_hw *hw, uint16_t tx_queue_id)
3082 {
3083         u32 *reg = &hw->q_tx_regs[tx_queue_id * 8];
3084         wr32(hw, TXGBE_TXBAL(tx_queue_id), *(reg++));
3085         wr32(hw, TXGBE_TXBAH(tx_queue_id), *(reg++));
3086         wr32(hw, TXGBE_TXCFG(tx_queue_id), *(reg++) & ~TXGBE_TXCFG_ENA);
3087 }
3088
3089 /*
3090  * Start Receive Units for specified queue.
3091  */
3092 int __rte_cold
3093 txgbe_dev_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
3094 {
3095         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3096         struct txgbe_rx_queue *rxq;
3097         uint32_t rxdctl;
3098         int poll_ms;
3099
3100         PMD_INIT_FUNC_TRACE();
3101
3102         rxq = dev->data->rx_queues[rx_queue_id];
3103
3104         /* Allocate buffers for descriptor rings */
3105         if (txgbe_alloc_rx_queue_mbufs(rxq) != 0) {
3106                 PMD_INIT_LOG(ERR, "Could not alloc mbuf for queue:%d",
3107                              rx_queue_id);
3108                 return -1;
3109         }
3110         rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
3111         rxdctl |= TXGBE_RXCFG_ENA;
3112         wr32(hw, TXGBE_RXCFG(rxq->reg_idx), rxdctl);
3113
3114         /* Wait until RX Enable ready */
3115         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
3116         do {
3117                 rte_delay_ms(1);
3118                 rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
3119         } while (--poll_ms && !(rxdctl & TXGBE_RXCFG_ENA));
3120         if (!poll_ms)
3121                 PMD_INIT_LOG(ERR, "Could not enable Rx Queue %d", rx_queue_id);
3122         rte_wmb();
3123         wr32(hw, TXGBE_RXRP(rxq->reg_idx), 0);
3124         wr32(hw, TXGBE_RXWP(rxq->reg_idx), rxq->nb_rx_desc - 1);
3125         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
3126
3127         return 0;
3128 }
3129
3130 /*
3131  * Stop Receive Units for specified queue.
3132  */
3133 int __rte_cold
3134 txgbe_dev_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id)
3135 {
3136         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3137         struct txgbe_adapter *adapter = TXGBE_DEV_ADAPTER(dev);
3138         struct txgbe_rx_queue *rxq;
3139         uint32_t rxdctl;
3140         int poll_ms;
3141
3142         PMD_INIT_FUNC_TRACE();
3143
3144         rxq = dev->data->rx_queues[rx_queue_id];
3145
3146         txgbe_dev_save_rx_queue(hw, rxq->reg_idx);
3147         wr32m(hw, TXGBE_RXCFG(rxq->reg_idx), TXGBE_RXCFG_ENA, 0);
3148
3149         /* Wait until RX Enable bit clear */
3150         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
3151         do {
3152                 rte_delay_ms(1);
3153                 rxdctl = rd32(hw, TXGBE_RXCFG(rxq->reg_idx));
3154         } while (--poll_ms && (rxdctl & TXGBE_RXCFG_ENA));
3155         if (!poll_ms)
3156                 PMD_INIT_LOG(ERR, "Could not disable Rx Queue %d", rx_queue_id);
3157
3158         rte_delay_us(RTE_TXGBE_WAIT_100_US);
3159         txgbe_dev_store_rx_queue(hw, rxq->reg_idx);
3160
3161         txgbe_rx_queue_release_mbufs(rxq);
3162         txgbe_reset_rx_queue(adapter, rxq);
3163         dev->data->rx_queue_state[rx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
3164
3165         return 0;
3166 }
3167
3168 /*
3169  * Start Transmit Units for specified queue.
3170  */
3171 int __rte_cold
3172 txgbe_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
3173 {
3174         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3175         struct txgbe_tx_queue *txq;
3176         uint32_t txdctl;
3177         int poll_ms;
3178
3179         PMD_INIT_FUNC_TRACE();
3180
3181         txq = dev->data->tx_queues[tx_queue_id];
3182         wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_ENA, TXGBE_TXCFG_ENA);
3183
3184         /* Wait until TX Enable ready */
3185         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
3186         do {
3187                 rte_delay_ms(1);
3188                 txdctl = rd32(hw, TXGBE_TXCFG(txq->reg_idx));
3189         } while (--poll_ms && !(txdctl & TXGBE_TXCFG_ENA));
3190         if (!poll_ms)
3191                 PMD_INIT_LOG(ERR, "Could not enable "
3192                              "Tx Queue %d", tx_queue_id);
3193
3194         rte_wmb();
3195         wr32(hw, TXGBE_TXWP(txq->reg_idx), txq->tx_tail);
3196         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
3197
3198         return 0;
3199 }
3200
3201 /*
3202  * Stop Transmit Units for specified queue.
3203  */
3204 int __rte_cold
3205 txgbe_dev_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
3206 {
3207         struct txgbe_hw *hw = TXGBE_DEV_HW(dev);
3208         struct txgbe_tx_queue *txq;
3209         uint32_t txdctl;
3210         uint32_t txtdh, txtdt;
3211         int poll_ms;
3212
3213         PMD_INIT_FUNC_TRACE();
3214
3215         txq = dev->data->tx_queues[tx_queue_id];
3216
3217         /* Wait until TX queue is empty */
3218         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
3219         do {
3220                 rte_delay_us(RTE_TXGBE_WAIT_100_US);
3221                 txtdh = rd32(hw, TXGBE_TXRP(txq->reg_idx));
3222                 txtdt = rd32(hw, TXGBE_TXWP(txq->reg_idx));
3223         } while (--poll_ms && (txtdh != txtdt));
3224         if (!poll_ms)
3225                 PMD_INIT_LOG(ERR,
3226                         "Tx Queue %d is not empty when stopping.",
3227                         tx_queue_id);
3228
3229         txgbe_dev_save_tx_queue(hw, txq->reg_idx);
3230         wr32m(hw, TXGBE_TXCFG(txq->reg_idx), TXGBE_TXCFG_ENA, 0);
3231
3232         /* Wait until TX Enable bit clear */
3233         poll_ms = RTE_TXGBE_REGISTER_POLL_WAIT_10_MS;
3234         do {
3235                 rte_delay_ms(1);
3236                 txdctl = rd32(hw, TXGBE_TXCFG(txq->reg_idx));
3237         } while (--poll_ms && (txdctl & TXGBE_TXCFG_ENA));
3238         if (!poll_ms)
3239                 PMD_INIT_LOG(ERR, "Could not disable Tx Queue %d",
3240                         tx_queue_id);
3241
3242         rte_delay_us(RTE_TXGBE_WAIT_100_US);
3243         txgbe_dev_store_tx_queue(hw, txq->reg_idx);
3244
3245         if (txq->ops != NULL) {
3246                 txq->ops->release_mbufs(txq);
3247                 txq->ops->reset(txq);
3248         }
3249         dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STOPPED;
3250
3251         return 0;
3252 }
3253
3254 void
3255 txgbe_rxq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
3256         struct rte_eth_rxq_info *qinfo)
3257 {
3258         struct txgbe_rx_queue *rxq;
3259
3260         rxq = dev->data->rx_queues[queue_id];
3261
3262         qinfo->mp = rxq->mb_pool;
3263         qinfo->scattered_rx = dev->data->scattered_rx;
3264         qinfo->nb_desc = rxq->nb_rx_desc;
3265
3266         qinfo->conf.rx_free_thresh = rxq->rx_free_thresh;
3267         qinfo->conf.rx_drop_en = rxq->drop_en;
3268         qinfo->conf.rx_deferred_start = rxq->rx_deferred_start;
3269         qinfo->conf.offloads = rxq->offloads;
3270 }
3271
3272 void
3273 txgbe_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
3274         struct rte_eth_txq_info *qinfo)
3275 {
3276         struct txgbe_tx_queue *txq;
3277
3278         txq = dev->data->tx_queues[queue_id];
3279
3280         qinfo->nb_desc = txq->nb_tx_desc;
3281
3282         qinfo->conf.tx_thresh.pthresh = txq->pthresh;
3283         qinfo->conf.tx_thresh.hthresh = txq->hthresh;
3284         qinfo->conf.tx_thresh.wthresh = txq->wthresh;
3285
3286         qinfo->conf.tx_free_thresh = txq->tx_free_thresh;
3287         qinfo->conf.offloads = txq->offloads;
3288         qinfo->conf.tx_deferred_start = txq->tx_deferred_start;
3289 }
3290