drivers/net/ixgbe/ixgbe_rxtx.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
   5  *   Copyright 2014 6WIND S.A.
   6  *   All rights reserved.
   7  *
   8  *   Redistribution and use in source and binary forms, with or without
   9  *   modification, are permitted provided that the following conditions
  10  *   are met:
  11  *
  12  *     * Redistributions of source code must retain the above copyright
  13  *       notice, this list of conditions and the following disclaimer.
  14  *     * Redistributions in binary form must reproduce the above copyright
  15  *       notice, this list of conditions and the following disclaimer in
  16  *       the documentation and/or other materials provided with the
  17  *       distribution.
  18  *     * Neither the name of Intel Corporation nor the names of its
  19  *       contributors may be used to endorse or promote products derived
  20  *       from this software without specific prior written permission.
  21  *
  22  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  26  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  27  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  28  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  29  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  30  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  31  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  32  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35 #include <sys/queue.h>
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <errno.h>
  41 #include <stdint.h>
  42 #include <stdarg.h>
  43 #include <unistd.h>
  44 #include <inttypes.h>
  45
  46 #include <rte_byteorder.h>
  47 #include <rte_common.h>
  48 #include <rte_cycles.h>
  49 #include <rte_log.h>
  50 #include <rte_debug.h>
  51 #include <rte_interrupts.h>
  52 #include <rte_pci.h>
  53 #include <rte_memory.h>
  54 #include <rte_memzone.h>
  55 #include <rte_launch.h>
  56 #include <rte_eal.h>
  57 #include <rte_per_lcore.h>
  58 #include <rte_lcore.h>
  59 #include <rte_atomic.h>
  60 #include <rte_branch_prediction.h>
  61 #include <rte_ring.h>
  62 #include <rte_mempool.h>
  63 #include <rte_malloc.h>
  64 #include <rte_mbuf.h>
  65 #include <rte_ether.h>
  66 #include <rte_ethdev.h>
  67 #include <rte_prefetch.h>
  68 #include <rte_udp.h>
  69 #include <rte_tcp.h>
  70 #include <rte_sctp.h>
  71 #include <rte_string_fns.h>
  72 #include <rte_errno.h>
  73 #include <rte_ip.h>
  74
  75 #include "ixgbe_logs.h"
  76 #include "base/ixgbe_api.h"
  77 #include "base/ixgbe_vf.h"
  78 #include "ixgbe_ethdev.h"
  79 #include "base/ixgbe_dcb.h"
  80 #include "base/ixgbe_common.h"
  81 #include "ixgbe_rxtx.h"
  82
  83 /* Bit Mask to indicate what bits required for building TX context */
  84 #define IXGBE_TX_OFFLOAD_MASK (                  \
  85                 PKT_TX_VLAN_PKT |                \
  86                 PKT_TX_IP_CKSUM |                \
  87                 PKT_TX_L4_MASK |                 \
  88                 PKT_TX_TCP_SEG)
  89
  90 static inline struct rte_mbuf *
  91 rte_rxmbuf_alloc(struct rte_mempool *mp)
  92 {
  93         struct rte_mbuf *m;
  94
  95         m = __rte_mbuf_raw_alloc(mp);
  96         __rte_mbuf_sanity_check_raw(m, 0);
  97         return (m);
  98 }
  99
 100
 101 #if 1
 102 #define RTE_PMD_USE_PREFETCH
 103 #endif
 104
 105 #ifdef RTE_PMD_USE_PREFETCH
 106 /*
 107  * Prefetch a cache line into all cache levels.
 108  */
 109 #define rte_ixgbe_prefetch(p)   rte_prefetch0(p)
 110 #else
 111 #define rte_ixgbe_prefetch(p)   do {} while(0)
 112 #endif
 113
 114 /*********************************************************************
 115  *
 116  *  TX functions
 117  *
 118  **********************************************************************/
 119
 120 /*
 121  * Check for descriptors with their DD bit set and free mbufs.
 122  * Return the total number of buffers freed.
 123  */
 124 static inline int __attribute__((always_inline))
 125 ixgbe_tx_free_bufs(struct ixgbe_tx_queue *txq)
 126 {
 127         struct ixgbe_tx_entry *txep;
 128         uint32_t status;
 129         int i;
 130
 131         /* check DD bit on threshold descriptor */
 132         status = txq->tx_ring[txq->tx_next_dd].wb.status;
 133         if (! (status & IXGBE_ADVTXD_STAT_DD))
 134                 return 0;
 135
 136         /*
 137          * first buffer to free from S/W ring is at index
 138          * tx_next_dd - (tx_rs_thresh-1)
 139          */
 140         txep = &(txq->sw_ring[txq->tx_next_dd - (txq->tx_rs_thresh - 1)]);
 141
 142         /* free buffers one at a time */
 143         if ((txq->txq_flags & (uint32_t)ETH_TXQ_FLAGS_NOREFCOUNT) != 0) {
 144                 for (i = 0; i < txq->tx_rs_thresh; ++i, ++txep) {
 145                         txep->mbuf->next = NULL;
 146                         rte_mempool_put(txep->mbuf->pool, txep->mbuf);
 147                         txep->mbuf = NULL;
 148                 }
 149         } else {
 150                 for (i = 0; i < txq->tx_rs_thresh; ++i, ++txep) {
 151                         rte_pktmbuf_free_seg(txep->mbuf);
 152                         txep->mbuf = NULL;
 153                 }
 154         }
 155
 156         /* buffers were freed, update counters */
 157         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + txq->tx_rs_thresh);
 158         txq->tx_next_dd = (uint16_t)(txq->tx_next_dd + txq->tx_rs_thresh);
 159         if (txq->tx_next_dd >= txq->nb_tx_desc)
 160                 txq->tx_next_dd = (uint16_t)(txq->tx_rs_thresh - 1);
 161
 162         return txq->tx_rs_thresh;
 163 }
 164
 165 /* Populate 4 descriptors with data from 4 mbufs */
 166 static inline void
 167 tx4(volatile union ixgbe_adv_tx_desc *txdp, struct rte_mbuf **pkts)
 168 {
 169         uint64_t buf_dma_addr;
 170         uint32_t pkt_len;
 171         int i;
 172
 173         for (i = 0; i < 4; ++i, ++txdp, ++pkts) {
 174                 buf_dma_addr = RTE_MBUF_DATA_DMA_ADDR(*pkts);
 175                 pkt_len = (*pkts)->data_len;
 176
 177                 /* write data to descriptor */
 178                 txdp->read.buffer_addr = buf_dma_addr;
 179                 txdp->read.cmd_type_len =
 180                                 ((uint32_t)DCMD_DTYP_FLAGS | pkt_len);
 181                 txdp->read.olinfo_status =
 182                                 (pkt_len << IXGBE_ADVTXD_PAYLEN_SHIFT);
 183                 rte_prefetch0(&(*pkts)->pool);
 184         }
 185 }
 186
 187 /* Populate 1 descriptor with data from 1 mbuf */
 188 static inline void
 189 tx1(volatile union ixgbe_adv_tx_desc *txdp, struct rte_mbuf **pkts)
 190 {
 191         uint64_t buf_dma_addr;
 192         uint32_t pkt_len;
 193
 194         buf_dma_addr = RTE_MBUF_DATA_DMA_ADDR(*pkts);
 195         pkt_len = (*pkts)->data_len;
 196
 197         /* write data to descriptor */
 198         txdp->read.buffer_addr = buf_dma_addr;
 199         txdp->read.cmd_type_len =
 200                         ((uint32_t)DCMD_DTYP_FLAGS | pkt_len);
 201         txdp->read.olinfo_status =
 202                         (pkt_len << IXGBE_ADVTXD_PAYLEN_SHIFT);
 203         rte_prefetch0(&(*pkts)->pool);
 204 }
 205
 206 /*
 207  * Fill H/W descriptor ring with mbuf data.
 208  * Copy mbuf pointers to the S/W ring.
 209  */
 210 static inline void
 211 ixgbe_tx_fill_hw_ring(struct ixgbe_tx_queue *txq, struct rte_mbuf **pkts,
 212                       uint16_t nb_pkts)
 213 {
 214         volatile union ixgbe_adv_tx_desc *txdp = &(txq->tx_ring[txq->tx_tail]);
 215         struct ixgbe_tx_entry *txep = &(txq->sw_ring[txq->tx_tail]);
 216         const int N_PER_LOOP = 4;
 217         const int N_PER_LOOP_MASK = N_PER_LOOP-1;
 218         int mainpart, leftover;
 219         int i, j;
 220
 221         /*
 222          * Process most of the packets in chunks of N pkts.  Any
 223          * leftover packets will get processed one at a time.
 224          */
 225         mainpart = (nb_pkts & ((uint32_t) ~N_PER_LOOP_MASK));
 226         leftover = (nb_pkts & ((uint32_t)  N_PER_LOOP_MASK));
 227         for (i = 0; i < mainpart; i += N_PER_LOOP) {
 228                 /* Copy N mbuf pointers to the S/W ring */
 229                 for (j = 0; j < N_PER_LOOP; ++j) {
 230                         (txep + i + j)->mbuf = *(pkts + i + j);
 231                 }
 232                 tx4(txdp + i, pkts + i);
 233         }
 234
 235         if (unlikely(leftover > 0)) {
 236                 for (i = 0; i < leftover; ++i) {
 237                         (txep + mainpart + i)->mbuf = *(pkts + mainpart + i);
 238                         tx1(txdp + mainpart + i, pkts + mainpart + i);
 239                 }
 240         }
 241 }
 242
 243 static inline uint16_t
 244 tx_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 245              uint16_t nb_pkts)
 246 {
 247         struct ixgbe_tx_queue *txq = (struct ixgbe_tx_queue *)tx_queue;
 248         volatile union ixgbe_adv_tx_desc *tx_r = txq->tx_ring;
 249         uint16_t n = 0;
 250
 251         /*
 252          * Begin scanning the H/W ring for done descriptors when the
 253          * number of available descriptors drops below tx_free_thresh.  For
 254          * each done descriptor, free the associated buffer.
 255          */
 256         if (txq->nb_tx_free < txq->tx_free_thresh)
 257                 ixgbe_tx_free_bufs(txq);
 258
 259         /* Only use descriptors that are available */
 260         nb_pkts = (uint16_t)RTE_MIN(txq->nb_tx_free, nb_pkts);
 261         if (unlikely(nb_pkts == 0))
 262                 return 0;
 263
 264         /* Use exactly nb_pkts descriptors */
 265         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_pkts);
 266
 267         /*
 268          * At this point, we know there are enough descriptors in the
 269          * ring to transmit all the packets.  This assumes that each
 270          * mbuf contains a single segment, and that no new offloads
 271          * are expected, which would require a new context descriptor.
 272          */
 273
 274         /*
 275          * See if we're going to wrap-around. If so, handle the top
 276          * of the descriptor ring first, then do the bottom.  If not,
 277          * the processing looks just like the "bottom" part anyway...
 278          */
 279         if ((txq->tx_tail + nb_pkts) > txq->nb_tx_desc) {
 280                 n = (uint16_t)(txq->nb_tx_desc - txq->tx_tail);
 281                 ixgbe_tx_fill_hw_ring(txq, tx_pkts, n);
 282
 283                 /*
 284                  * We know that the last descriptor in the ring will need to
 285                  * have its RS bit set because tx_rs_thresh has to be
 286                  * a divisor of the ring size
 287                  */
 288                 tx_r[txq->tx_next_rs].read.cmd_type_len |=
 289                         rte_cpu_to_le_32(IXGBE_ADVTXD_DCMD_RS);
 290                 txq->tx_next_rs = (uint16_t)(txq->tx_rs_thresh - 1);
 291
 292                 txq->tx_tail = 0;
 293         }
 294
 295         /* Fill H/W descriptor ring with mbuf data */
 296         ixgbe_tx_fill_hw_ring(txq, tx_pkts + n, (uint16_t)(nb_pkts - n));
 297         txq->tx_tail = (uint16_t)(txq->tx_tail + (nb_pkts - n));
 298
 299         /*
 300          * Determine if RS bit should be set
 301          * This is what we actually want:
 302          *   if ((txq->tx_tail - 1) >= txq->tx_next_rs)
 303          * but instead of subtracting 1 and doing >=, we can just do
 304          * greater than without subtracting.
 305          */
 306         if (txq->tx_tail > txq->tx_next_rs) {
 307                 tx_r[txq->tx_next_rs].read.cmd_type_len |=
 308                         rte_cpu_to_le_32(IXGBE_ADVTXD_DCMD_RS);
 309                 txq->tx_next_rs = (uint16_t)(txq->tx_next_rs +
 310                                                 txq->tx_rs_thresh);
 311                 if (txq->tx_next_rs >= txq->nb_tx_desc)
 312                         txq->tx_next_rs = (uint16_t)(txq->tx_rs_thresh - 1);
 313         }
 314
 315         /*
 316          * Check for wrap-around. This would only happen if we used
 317          * up to the last descriptor in the ring, no more, no less.
 318          */
 319         if (txq->tx_tail >= txq->nb_tx_desc)
 320                 txq->tx_tail = 0;
 321
 322         /* update tail pointer */
 323         rte_wmb();
 324         IXGBE_PCI_REG_WRITE(txq->tdt_reg_addr, txq->tx_tail);
 325
 326         return nb_pkts;
 327 }
 328
 329 uint16_t
 330 ixgbe_xmit_pkts_simple(void *tx_queue, struct rte_mbuf **tx_pkts,
 331                        uint16_t nb_pkts)
 332 {
 333         uint16_t nb_tx;
 334
 335         /* Try to transmit at least chunks of TX_MAX_BURST pkts */
 336         if (likely(nb_pkts <= RTE_PMD_IXGBE_TX_MAX_BURST))
 337                 return tx_xmit_pkts(tx_queue, tx_pkts, nb_pkts);
 338
 339         /* transmit more than the max burst, in chunks of TX_MAX_BURST */
 340         nb_tx = 0;
 341         while (nb_pkts) {
 342                 uint16_t ret, n;
 343                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_IXGBE_TX_MAX_BURST);
 344                 ret = tx_xmit_pkts(tx_queue, &(tx_pkts[nb_tx]), n);
 345                 nb_tx = (uint16_t)(nb_tx + ret);
 346                 nb_pkts = (uint16_t)(nb_pkts - ret);
 347                 if (ret < n)
 348                         break;
 349         }
 350
 351         return nb_tx;
 352 }
 353
 354 static inline void
 355 ixgbe_set_xmit_ctx(struct ixgbe_tx_queue *txq,
 356                 volatile struct ixgbe_adv_tx_context_desc *ctx_txd,
 357                 uint64_t ol_flags, union ixgbe_tx_offload tx_offload)
 358 {
 359         uint32_t type_tucmd_mlhl;
 360         uint32_t mss_l4len_idx = 0;
 361         uint32_t ctx_idx;
 362         uint32_t vlan_macip_lens;
 363         union ixgbe_tx_offload tx_offload_mask;
 364
 365         ctx_idx = txq->ctx_curr;
 366         tx_offload_mask.data = 0;
 367         type_tucmd_mlhl = 0;
 368
 369         /* Specify which HW CTX to upload. */
 370         mss_l4len_idx |= (ctx_idx << IXGBE_ADVTXD_IDX_SHIFT);
 371
 372         if (ol_flags & PKT_TX_VLAN_PKT) {
 373                 tx_offload_mask.vlan_tci |= ~0;
 374         }
 375
 376         /* check if TCP segmentation required for this packet */
 377         if (ol_flags & PKT_TX_TCP_SEG) {
 378                 /* implies IP cksum in IPv4 */
 379                 if (ol_flags & PKT_TX_IP_CKSUM)
 380                         type_tucmd_mlhl = IXGBE_ADVTXD_TUCMD_IPV4 |
 381                                 IXGBE_ADVTXD_TUCMD_L4T_TCP |
 382                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 383                 else
 384                         type_tucmd_mlhl = IXGBE_ADVTXD_TUCMD_IPV6 |
 385                                 IXGBE_ADVTXD_TUCMD_L4T_TCP |
 386                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 387
 388                 tx_offload_mask.l2_len |= ~0;
 389                 tx_offload_mask.l3_len |= ~0;
 390                 tx_offload_mask.l4_len |= ~0;
 391                 tx_offload_mask.tso_segsz |= ~0;
 392                 mss_l4len_idx |= tx_offload.tso_segsz << IXGBE_ADVTXD_MSS_SHIFT;
 393                 mss_l4len_idx |= tx_offload.l4_len << IXGBE_ADVTXD_L4LEN_SHIFT;
 394         } else { /* no TSO, check if hardware checksum is needed */
 395                 if (ol_flags & PKT_TX_IP_CKSUM) {
 396                         type_tucmd_mlhl = IXGBE_ADVTXD_TUCMD_IPV4;
 397                         tx_offload_mask.l2_len |= ~0;
 398                         tx_offload_mask.l3_len |= ~0;
 399                 }
 400
 401                 switch (ol_flags & PKT_TX_L4_MASK) {
 402                 case PKT_TX_UDP_CKSUM:
 403                         type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_UDP |
 404                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 405                         mss_l4len_idx |= sizeof(struct udp_hdr) << IXGBE_ADVTXD_L4LEN_SHIFT;
 406                         tx_offload_mask.l2_len |= ~0;
 407                         tx_offload_mask.l3_len |= ~0;
 408                         break;
 409                 case PKT_TX_TCP_CKSUM:
 410                         type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_TCP |
 411                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 412                         mss_l4len_idx |= sizeof(struct tcp_hdr) << IXGBE_ADVTXD_L4LEN_SHIFT;
 413                         tx_offload_mask.l2_len |= ~0;
 414                         tx_offload_mask.l3_len |= ~0;
 415                         tx_offload_mask.l4_len |= ~0;
 416                         break;
 417                 case PKT_TX_SCTP_CKSUM:
 418                         type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_SCTP |
 419                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 420                         mss_l4len_idx |= sizeof(struct sctp_hdr) << IXGBE_ADVTXD_L4LEN_SHIFT;
 421                         tx_offload_mask.l2_len |= ~0;
 422                         tx_offload_mask.l3_len |= ~0;
 423                         break;
 424                 default:
 425                         type_tucmd_mlhl |= IXGBE_ADVTXD_TUCMD_L4T_RSV |
 426                                 IXGBE_ADVTXD_DTYP_CTXT | IXGBE_ADVTXD_DCMD_DEXT;
 427                         break;
 428                 }
 429         }
 430
 431         txq->ctx_cache[ctx_idx].flags = ol_flags;
 432         txq->ctx_cache[ctx_idx].tx_offload.data  =
 433                 tx_offload_mask.data & tx_offload.data;
 434         txq->ctx_cache[ctx_idx].tx_offload_mask    = tx_offload_mask;
 435
 436         ctx_txd->type_tucmd_mlhl = rte_cpu_to_le_32(type_tucmd_mlhl);
 437         vlan_macip_lens = tx_offload.l3_len;
 438         vlan_macip_lens |= (tx_offload.l2_len << IXGBE_ADVTXD_MACLEN_SHIFT);
 439         vlan_macip_lens |= ((uint32_t)tx_offload.vlan_tci << IXGBE_ADVTXD_VLAN_SHIFT);
 440         ctx_txd->vlan_macip_lens = rte_cpu_to_le_32(vlan_macip_lens);
 441         ctx_txd->mss_l4len_idx   = rte_cpu_to_le_32(mss_l4len_idx);
 442         ctx_txd->seqnum_seed     = 0;
 443 }
 444
 445 /*
 446  * Check which hardware context can be used. Use the existing match
 447  * or create a new context descriptor.
 448  */
 449 static inline uint32_t
 450 what_advctx_update(struct ixgbe_tx_queue *txq, uint64_t flags,
 451                 union ixgbe_tx_offload tx_offload)
 452 {
 453         /* If match with the current used context */
 454         if (likely((txq->ctx_cache[txq->ctx_curr].flags == flags) &&
 455                 (txq->ctx_cache[txq->ctx_curr].tx_offload.data ==
 456                 (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data & tx_offload.data)))) {
 457                         return txq->ctx_curr;
 458         }
 459
 460         /* What if match with the next context  */
 461         txq->ctx_curr ^= 1;
 462         if (likely((txq->ctx_cache[txq->ctx_curr].flags == flags) &&
 463                 (txq->ctx_cache[txq->ctx_curr].tx_offload.data ==
 464                 (txq->ctx_cache[txq->ctx_curr].tx_offload_mask.data & tx_offload.data)))) {
 465                         return txq->ctx_curr;
 466         }
 467
 468         /* Mismatch, use the previous context */
 469         return (IXGBE_CTX_NUM);
 470 }
 471
 472 static inline uint32_t
 473 tx_desc_cksum_flags_to_olinfo(uint64_t ol_flags)
 474 {
 475         uint32_t tmp = 0;
 476         if ((ol_flags & PKT_TX_L4_MASK) != PKT_TX_L4_NO_CKSUM)
 477                 tmp |= IXGBE_ADVTXD_POPTS_TXSM;
 478         if (ol_flags & PKT_TX_IP_CKSUM)
 479                 tmp |= IXGBE_ADVTXD_POPTS_IXSM;
 480         if (ol_flags & PKT_TX_TCP_SEG)
 481                 tmp |= IXGBE_ADVTXD_POPTS_TXSM;
 482         return tmp;
 483 }
 484
 485 static inline uint32_t
 486 tx_desc_ol_flags_to_cmdtype(uint64_t ol_flags)
 487 {
 488         uint32_t cmdtype = 0;
 489         if (ol_flags & PKT_TX_VLAN_PKT)
 490                 cmdtype |= IXGBE_ADVTXD_DCMD_VLE;
 491         if (ol_flags & PKT_TX_TCP_SEG)
 492                 cmdtype |= IXGBE_ADVTXD_DCMD_TSE;
 493         return cmdtype;
 494 }
 495
 496 /* Default RS bit threshold values */
 497 #ifndef DEFAULT_TX_RS_THRESH
 498 #define DEFAULT_TX_RS_THRESH   32
 499 #endif
 500 #ifndef DEFAULT_TX_FREE_THRESH
 501 #define DEFAULT_TX_FREE_THRESH 32
 502 #endif
 503
 504 /* Reset transmit descriptors after they have been used */
 505 static inline int
 506 ixgbe_xmit_cleanup(struct ixgbe_tx_queue *txq)
 507 {
 508         struct ixgbe_tx_entry *sw_ring = txq->sw_ring;
 509         volatile union ixgbe_adv_tx_desc *txr = txq->tx_ring;
 510         uint16_t last_desc_cleaned = txq->last_desc_cleaned;
 511         uint16_t nb_tx_desc = txq->nb_tx_desc;
 512         uint16_t desc_to_clean_to;
 513         uint16_t nb_tx_to_clean;
 514
 515         /* Determine the last descriptor needing to be cleaned */
 516         desc_to_clean_to = (uint16_t)(last_desc_cleaned + txq->tx_rs_thresh);
 517         if (desc_to_clean_to >= nb_tx_desc)
 518                 desc_to_clean_to = (uint16_t)(desc_to_clean_to - nb_tx_desc);
 519
 520         /* Check to make sure the last descriptor to clean is done */
 521         desc_to_clean_to = sw_ring[desc_to_clean_to].last_id;
 522         if (! (txr[desc_to_clean_to].wb.status & IXGBE_TXD_STAT_DD))
 523         {
 524                 PMD_TX_FREE_LOG(DEBUG,
 525                                 "TX descriptor %4u is not done"
 526                                 "(port=%d queue=%d)",
 527                                 desc_to_clean_to,
 528                                 txq->port_id, txq->queue_id);
 529                 /* Failed to clean any descriptors, better luck next time */
 530                 return -(1);
 531         }
 532
 533         /* Figure out how many descriptors will be cleaned */
 534         if (last_desc_cleaned > desc_to_clean_to)
 535                 nb_tx_to_clean = (uint16_t)((nb_tx_desc - last_desc_cleaned) +
 536                                                         desc_to_clean_to);
 537         else
 538                 nb_tx_to_clean = (uint16_t)(desc_to_clean_to -
 539                                                 last_desc_cleaned);
 540
 541         PMD_TX_FREE_LOG(DEBUG,
 542                         "Cleaning %4u TX descriptors: %4u to %4u "
 543                         "(port=%d queue=%d)",
 544                         nb_tx_to_clean, last_desc_cleaned, desc_to_clean_to,
 545                         txq->port_id, txq->queue_id);
 546
 547         /*
 548          * The last descriptor to clean is done, so that means all the
 549          * descriptors from the last descriptor that was cleaned
 550          * up to the last descriptor with the RS bit set
 551          * are done. Only reset the threshold descriptor.
 552          */
 553         txr[desc_to_clean_to].wb.status = 0;
 554
 555         /* Update the txq to reflect the last descriptor that was cleaned */
 556         txq->last_desc_cleaned = desc_to_clean_to;
 557         txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + nb_tx_to_clean);
 558
 559         /* No Error */
 560         return (0);
 561 }
 562
 563 uint16_t
 564 ixgbe_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts,
 565                 uint16_t nb_pkts)
 566 {
 567         struct ixgbe_tx_queue *txq;
 568         struct ixgbe_tx_entry *sw_ring;
 569         struct ixgbe_tx_entry *txe, *txn;
 570         volatile union ixgbe_adv_tx_desc *txr;
 571         volatile union ixgbe_adv_tx_desc *txd;
 572         struct rte_mbuf     *tx_pkt;
 573         struct rte_mbuf     *m_seg;
 574         uint64_t buf_dma_addr;
 575         uint32_t olinfo_status;
 576         uint32_t cmd_type_len;
 577         uint32_t pkt_len;
 578         uint16_t slen;
 579         uint64_t ol_flags;
 580         uint16_t tx_id;
 581         uint16_t tx_last;
 582         uint16_t nb_tx;
 583         uint16_t nb_used;
 584         uint64_t tx_ol_req;
 585         uint32_t ctx = 0;
 586         uint32_t new_ctx;
 587         union ixgbe_tx_offload tx_offload = {0};
 588
 589         txq = tx_queue;
 590         sw_ring = txq->sw_ring;
 591         txr     = txq->tx_ring;
 592         tx_id   = txq->tx_tail;
 593         txe = &sw_ring[tx_id];
 594
 595         /* Determine if the descriptor ring needs to be cleaned. */
 596         if (txq->nb_tx_free < txq->tx_free_thresh)
 597                 ixgbe_xmit_cleanup(txq);
 598
 599         rte_prefetch0(&txe->mbuf->pool);
 600
 601         /* TX loop */
 602         for (nb_tx = 0; nb_tx < nb_pkts; nb_tx++) {
 603                 new_ctx = 0;
 604                 tx_pkt = *tx_pkts++;
 605                 pkt_len = tx_pkt->pkt_len;
 606
 607                 /*
 608                  * Determine how many (if any) context descriptors
 609                  * are needed for offload functionality.
 610                  */
 611                 ol_flags = tx_pkt->ol_flags;
 612
 613                 /* If hardware offload required */
 614                 tx_ol_req = ol_flags & IXGBE_TX_OFFLOAD_MASK;
 615                 if (tx_ol_req) {
 616                         tx_offload.l2_len = tx_pkt->l2_len;
 617                         tx_offload.l3_len = tx_pkt->l3_len;
 618                         tx_offload.l4_len = tx_pkt->l4_len;
 619                         tx_offload.vlan_tci = tx_pkt->vlan_tci;
 620                         tx_offload.tso_segsz = tx_pkt->tso_segsz;
 621
 622                         /* If new context need be built or reuse the exist ctx. */
 623                         ctx = what_advctx_update(txq, tx_ol_req,
 624                                 tx_offload);
 625                         /* Only allocate context descriptor if required*/
 626                         new_ctx = (ctx == IXGBE_CTX_NUM);
 627                         ctx = txq->ctx_curr;
 628                 }
 629
 630                 /*
 631                  * Keep track of how many descriptors are used this loop
 632                  * This will always be the number of segments + the number of
 633                  * Context descriptors required to transmit the packet
 634                  */
 635                 nb_used = (uint16_t)(tx_pkt->nb_segs + new_ctx);
 636
 637                 /*
 638                  * The number of descriptors that must be allocated for a
 639                  * packet is the number of segments of that packet, plus 1
 640                  * Context Descriptor for the hardware offload, if any.
 641                  * Determine the last TX descriptor to allocate in the TX ring
 642                  * for the packet, starting from the current position (tx_id)
 643                  * in the ring.
 644                  */
 645                 tx_last = (uint16_t) (tx_id + nb_used - 1);
 646
 647                 /* Circular ring */
 648                 if (tx_last >= txq->nb_tx_desc)
 649                         tx_last = (uint16_t) (tx_last - txq->nb_tx_desc);
 650
 651                 PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u pktlen=%u"
 652                            " tx_first=%u tx_last=%u",
 653                            (unsigned) txq->port_id,
 654                            (unsigned) txq->queue_id,
 655                            (unsigned) pkt_len,
 656                            (unsigned) tx_id,
 657                            (unsigned) tx_last);
 658
 659                 /*
 660                  * Make sure there are enough TX descriptors available to
 661                  * transmit the entire packet.
 662                  * nb_used better be less than or equal to txq->tx_rs_thresh
 663                  */
 664                 if (nb_used > txq->nb_tx_free) {
 665                         PMD_TX_FREE_LOG(DEBUG,
 666                                         "Not enough free TX descriptors "
 667                                         "nb_used=%4u nb_free=%4u "
 668                                         "(port=%d queue=%d)",
 669                                         nb_used, txq->nb_tx_free,
 670                                         txq->port_id, txq->queue_id);
 671
 672                         if (ixgbe_xmit_cleanup(txq) != 0) {
 673                                 /* Could not clean any descriptors */
 674                                 if (nb_tx == 0)
 675                                         return (0);
 676                                 goto end_of_tx;
 677                         }
 678
 679                         /* nb_used better be <= txq->tx_rs_thresh */
 680                         if (unlikely(nb_used > txq->tx_rs_thresh)) {
 681                                 PMD_TX_FREE_LOG(DEBUG,
 682                                         "The number of descriptors needed to "
 683                                         "transmit the packet exceeds the "
 684                                         "RS bit threshold. This will impact "
 685                                         "performance."
 686                                         "nb_used=%4u nb_free=%4u "
 687                                         "tx_rs_thresh=%4u. "
 688                                         "(port=%d queue=%d)",
 689                                         nb_used, txq->nb_tx_free,
 690                                         txq->tx_rs_thresh,
 691                                         txq->port_id, txq->queue_id);
 692                                 /*
 693                                  * Loop here until there are enough TX
 694                                  * descriptors or until the ring cannot be
 695                                  * cleaned.
 696                                  */
 697                                 while (nb_used > txq->nb_tx_free) {
 698                                         if (ixgbe_xmit_cleanup(txq) != 0) {
 699                                                 /*
 700                                                  * Could not clean any
 701                                                  * descriptors
 702                                                  */
 703                                                 if (nb_tx == 0)
 704                                                         return (0);
 705                                                 goto end_of_tx;
 706                                         }
 707                                 }
 708                         }
 709                 }
 710
 711                 /*
 712                  * By now there are enough free TX descriptors to transmit
 713                  * the packet.
 714                  */
 715
 716                 /*
 717                  * Set common flags of all TX Data Descriptors.
 718                  *
 719                  * The following bits must be set in all Data Descriptors:
 720                  *   - IXGBE_ADVTXD_DTYP_DATA
 721                  *   - IXGBE_ADVTXD_DCMD_DEXT
 722                  *
 723                  * The following bits must be set in the first Data Descriptor
 724                  * and are ignored in the other ones:
 725                  *   - IXGBE_ADVTXD_DCMD_IFCS
 726                  *   - IXGBE_ADVTXD_MAC_1588
 727                  *   - IXGBE_ADVTXD_DCMD_VLE
 728                  *
 729                  * The following bits must only be set in the last Data
 730                  * Descriptor:
 731                  *   - IXGBE_TXD_CMD_EOP
 732                  *
 733                  * The following bits can be set in any Data Descriptor, but
 734                  * are only set in the last Data Descriptor:
 735                  *   - IXGBE_TXD_CMD_RS
 736                  */
 737                 cmd_type_len = IXGBE_ADVTXD_DTYP_DATA |
 738                         IXGBE_ADVTXD_DCMD_IFCS | IXGBE_ADVTXD_DCMD_DEXT;
 739
 740 #ifdef RTE_LIBRTE_IEEE1588
 741                 if (ol_flags & PKT_TX_IEEE1588_TMST)
 742                         cmd_type_len |= IXGBE_ADVTXD_MAC_1588;
 743 #endif
 744
 745                 olinfo_status = 0;
 746                 if (tx_ol_req) {
 747
 748                         if (ol_flags & PKT_TX_TCP_SEG) {
 749                                 /* when TSO is on, paylen in descriptor is the
 750                                  * not the packet len but the tcp payload len */
 751                                 pkt_len -= (tx_offload.l2_len +
 752                                         tx_offload.l3_len + tx_offload.l4_len);
 753                         }
 754
 755                         /*
 756                          * Setup the TX Advanced Context Descriptor if required
 757                          */
 758                         if (new_ctx) {
 759                                 volatile struct ixgbe_adv_tx_context_desc *
 760                                     ctx_txd;
 761
 762                                 ctx_txd = (volatile struct
 763                                     ixgbe_adv_tx_context_desc *)
 764                                     &txr[tx_id];
 765
 766                                 txn = &sw_ring[txe->next_id];
 767                                 rte_prefetch0(&txn->mbuf->pool);
 768
 769                                 if (txe->mbuf != NULL) {
 770                                         rte_pktmbuf_free_seg(txe->mbuf);
 771                                         txe->mbuf = NULL;
 772                                 }
 773
 774                                 ixgbe_set_xmit_ctx(txq, ctx_txd, tx_ol_req,
 775                                         tx_offload);
 776
 777                                 txe->last_id = tx_last;
 778                                 tx_id = txe->next_id;
 779                                 txe = txn;
 780                         }
 781
 782                         /*
 783                          * Setup the TX Advanced Data Descriptor,
 784                          * This path will go through
 785                          * whatever new/reuse the context descriptor
 786                          */
 787                         cmd_type_len  |= tx_desc_ol_flags_to_cmdtype(ol_flags);
 788                         olinfo_status |= tx_desc_cksum_flags_to_olinfo(ol_flags);
 789                         olinfo_status |= ctx << IXGBE_ADVTXD_IDX_SHIFT;
 790                 }
 791
 792                 olinfo_status |= (pkt_len << IXGBE_ADVTXD_PAYLEN_SHIFT);
 793
 794                 m_seg = tx_pkt;
 795                 do {
 796                         txd = &txr[tx_id];
 797                         txn = &sw_ring[txe->next_id];
 798                         rte_prefetch0(&txn->mbuf->pool);
 799
 800                         if (txe->mbuf != NULL)
 801                                 rte_pktmbuf_free_seg(txe->mbuf);
 802                         txe->mbuf = m_seg;
 803
 804                         /*
 805                          * Set up Transmit Data Descriptor.
 806                          */
 807                         slen = m_seg->data_len;
 808                         buf_dma_addr = RTE_MBUF_DATA_DMA_ADDR(m_seg);
 809                         txd->read.buffer_addr =
 810                                 rte_cpu_to_le_64(buf_dma_addr);
 811                         txd->read.cmd_type_len =
 812                                 rte_cpu_to_le_32(cmd_type_len | slen);
 813                         txd->read.olinfo_status =
 814                                 rte_cpu_to_le_32(olinfo_status);
 815                         txe->last_id = tx_last;
 816                         tx_id = txe->next_id;
 817                         txe = txn;
 818                         m_seg = m_seg->next;
 819                 } while (m_seg != NULL);
 820
 821                 /*
 822                  * The last packet data descriptor needs End Of Packet (EOP)
 823                  */
 824                 cmd_type_len |= IXGBE_TXD_CMD_EOP;
 825                 txq->nb_tx_used = (uint16_t)(txq->nb_tx_used + nb_used);
 826                 txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_used);
 827
 828                 /* Set RS bit only on threshold packets' last descriptor */
 829                 if (txq->nb_tx_used >= txq->tx_rs_thresh) {
 830                         PMD_TX_FREE_LOG(DEBUG,
 831                                         "Setting RS bit on TXD id="
 832                                         "%4u (port=%d queue=%d)",
 833                                         tx_last, txq->port_id, txq->queue_id);
 834
 835                         cmd_type_len |= IXGBE_TXD_CMD_RS;
 836
 837                         /* Update txq RS bit counters */
 838                         txq->nb_tx_used = 0;
 839                 }
 840                 txd->read.cmd_type_len |= rte_cpu_to_le_32(cmd_type_len);
 841         }
 842 end_of_tx:
 843         rte_wmb();
 844
 845         /*
 846          * Set the Transmit Descriptor Tail (TDT)
 847          */
 848         PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
 849                    (unsigned) txq->port_id, (unsigned) txq->queue_id,
 850                    (unsigned) tx_id, (unsigned) nb_tx);
 851         IXGBE_PCI_REG_WRITE(txq->tdt_reg_addr, tx_id);
 852         txq->tx_tail = tx_id;
 853
 854         return (nb_tx);
 855 }
 856
 857 /*********************************************************************
 858  *
 859  *  RX functions
 860  *
 861  **********************************************************************/
 862 #ifdef RTE_NEXT_ABI
 863 #define IXGBE_PACKET_TYPE_IPV4              0X01
 864 #define IXGBE_PACKET_TYPE_IPV4_TCP          0X11
 865 #define IXGBE_PACKET_TYPE_IPV4_UDP          0X21
 866 #define IXGBE_PACKET_TYPE_IPV4_SCTP         0X41
 867 #define IXGBE_PACKET_TYPE_IPV4_EXT          0X03
 868 #define IXGBE_PACKET_TYPE_IPV4_EXT_SCTP     0X43
 869 #define IXGBE_PACKET_TYPE_IPV6              0X04
 870 #define IXGBE_PACKET_TYPE_IPV6_TCP          0X14
 871 #define IXGBE_PACKET_TYPE_IPV6_UDP          0X24
 872 #define IXGBE_PACKET_TYPE_IPV6_EXT          0X0C
 873 #define IXGBE_PACKET_TYPE_IPV6_EXT_TCP      0X1C
 874 #define IXGBE_PACKET_TYPE_IPV6_EXT_UDP      0X2C
 875 #define IXGBE_PACKET_TYPE_IPV4_IPV6         0X05
 876 #define IXGBE_PACKET_TYPE_IPV4_IPV6_TCP     0X15
 877 #define IXGBE_PACKET_TYPE_IPV4_IPV6_UDP     0X25
 878 #define IXGBE_PACKET_TYPE_IPV4_IPV6_EXT     0X0D
 879 #define IXGBE_PACKET_TYPE_IPV4_IPV6_EXT_TCP 0X1D
 880 #define IXGBE_PACKET_TYPE_IPV4_IPV6_EXT_UDP 0X2D
 881 #define IXGBE_PACKET_TYPE_MAX               0X80
 882 #define IXGBE_PACKET_TYPE_MASK              0X7F
 883 #define IXGBE_PACKET_TYPE_SHIFT             0X04
 884 static inline uint32_t
 885 ixgbe_rxd_pkt_info_to_pkt_type(uint16_t pkt_info)
 886 {
 887         static const uint32_t
 888                 ptype_table[IXGBE_PACKET_TYPE_MAX] __rte_cache_aligned = {
 889                 [IXGBE_PACKET_TYPE_IPV4] = RTE_PTYPE_L2_ETHER |
 890                         RTE_PTYPE_L3_IPV4,
 891                 [IXGBE_PACKET_TYPE_IPV4_EXT] = RTE_PTYPE_L2_ETHER |
 892                         RTE_PTYPE_L3_IPV4_EXT,
 893                 [IXGBE_PACKET_TYPE_IPV6] = RTE_PTYPE_L2_ETHER |
 894                         RTE_PTYPE_L3_IPV6,
 895                 [IXGBE_PACKET_TYPE_IPV4_IPV6] = RTE_PTYPE_L2_ETHER |
 896                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 897                         RTE_PTYPE_INNER_L3_IPV6,
 898                 [IXGBE_PACKET_TYPE_IPV6_EXT] = RTE_PTYPE_L2_ETHER |
 899                         RTE_PTYPE_L3_IPV6_EXT,
 900                 [IXGBE_PACKET_TYPE_IPV4_IPV6_EXT] = RTE_PTYPE_L2_ETHER |
 901                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 902                         RTE_PTYPE_INNER_L3_IPV6_EXT,
 903                 [IXGBE_PACKET_TYPE_IPV4_TCP] = RTE_PTYPE_L2_ETHER |
 904                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_TCP,
 905                 [IXGBE_PACKET_TYPE_IPV6_TCP] = RTE_PTYPE_L2_ETHER |
 906                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_TCP,
 907                 [IXGBE_PACKET_TYPE_IPV4_IPV6_TCP] = RTE_PTYPE_L2_ETHER |
 908                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 909                         RTE_PTYPE_INNER_L3_IPV6 | RTE_PTYPE_INNER_L4_TCP,
 910                 [IXGBE_PACKET_TYPE_IPV6_EXT_TCP] = RTE_PTYPE_L2_ETHER |
 911                         RTE_PTYPE_L3_IPV6_EXT | RTE_PTYPE_L4_TCP,
 912                 [IXGBE_PACKET_TYPE_IPV4_IPV6_EXT_TCP] = RTE_PTYPE_L2_ETHER |
 913                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 914                         RTE_PTYPE_INNER_L3_IPV6_EXT | RTE_PTYPE_INNER_L4_TCP,
 915                 [IXGBE_PACKET_TYPE_IPV4_UDP] = RTE_PTYPE_L2_ETHER |
 916                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_UDP,
 917                 [IXGBE_PACKET_TYPE_IPV6_UDP] = RTE_PTYPE_L2_ETHER |
 918                         RTE_PTYPE_L3_IPV6 | RTE_PTYPE_L4_UDP,
 919                 [IXGBE_PACKET_TYPE_IPV4_IPV6_UDP] = RTE_PTYPE_L2_ETHER |
 920                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 921                         RTE_PTYPE_INNER_L3_IPV6 | RTE_PTYPE_INNER_L4_UDP,
 922                 [IXGBE_PACKET_TYPE_IPV6_EXT_UDP] = RTE_PTYPE_L2_ETHER |
 923                         RTE_PTYPE_L3_IPV6_EXT | RTE_PTYPE_L4_UDP,
 924                 [IXGBE_PACKET_TYPE_IPV4_IPV6_EXT_UDP] = RTE_PTYPE_L2_ETHER |
 925                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_TUNNEL_IP |
 926                         RTE_PTYPE_INNER_L3_IPV6_EXT | RTE_PTYPE_INNER_L4_UDP,
 927                 [IXGBE_PACKET_TYPE_IPV4_SCTP] = RTE_PTYPE_L2_ETHER |
 928                         RTE_PTYPE_L3_IPV4 | RTE_PTYPE_L4_SCTP,
 929                 [IXGBE_PACKET_TYPE_IPV4_EXT_SCTP] = RTE_PTYPE_L2_ETHER |
 930                         RTE_PTYPE_L3_IPV4_EXT | RTE_PTYPE_L4_SCTP,
 931         };
 932         if (unlikely(pkt_info & IXGBE_RXDADV_PKTTYPE_ETQF))
 933                 return RTE_PTYPE_UNKNOWN;
 934
 935         pkt_info = (pkt_info >> IXGBE_PACKET_TYPE_SHIFT) &
 936                                 IXGBE_PACKET_TYPE_MASK;
 937
 938         return ptype_table[pkt_info];
 939 }
 940
 941 static inline uint64_t
 942 ixgbe_rxd_pkt_info_to_pkt_flags(uint16_t pkt_info)
 943 {
 944         static uint64_t ip_rss_types_map[16] __rte_cache_aligned = {
 945                 0, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH,
 946                 0, PKT_RX_RSS_HASH, 0, PKT_RX_RSS_HASH,
 947                 PKT_RX_RSS_HASH, 0, 0, 0,
 948                 0, 0, 0,  PKT_RX_FDIR,
 949         };
 950 #ifdef RTE_LIBRTE_IEEE1588
 951         static uint64_t ip_pkt_etqf_map[8] = {
 952                 0, 0, 0, PKT_RX_IEEE1588_PTP,
 953                 0, 0, 0, 0,
 954         };
 955
 956         if (likely(pkt_info & IXGBE_RXDADV_PKTTYPE_ETQF))
 957                 return ip_pkt_etqf_map[(pkt_info >> 4) & 0X07] |
 958                                 ip_rss_types_map[pkt_info & 0XF];
 959         else
 960                 return ip_rss_types_map[pkt_info & 0XF];
 961 #else
 962         return ip_rss_types_map[pkt_info & 0XF];
 963 #endif
 964 }
 965 #else /* RTE_NEXT_ABI */
 966 static inline uint64_t
 967 rx_desc_hlen_type_rss_to_pkt_flags(uint32_t hl_tp_rs)
 968 {
 969         uint64_t pkt_flags;
 970
 971         static const uint64_t ip_pkt_types_map[16] = {
 972                 0, PKT_RX_IPV4_HDR, PKT_RX_IPV4_HDR_EXT, PKT_RX_IPV4_HDR_EXT,
 973                 PKT_RX_IPV6_HDR, 0, 0, 0,
 974                 PKT_RX_IPV6_HDR_EXT, 0, 0, 0,
 975                 PKT_RX_IPV6_HDR_EXT, 0, 0, 0,
 976         };
 977
 978         static const uint64_t ip_rss_types_map[16] = {
 979                 0, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH, PKT_RX_RSS_HASH,
 980                 0, PKT_RX_RSS_HASH, 0, PKT_RX_RSS_HASH,
 981                 PKT_RX_RSS_HASH, 0, 0, 0,
 982                 0, 0, 0,  PKT_RX_FDIR,
 983         };
 984
 985 #ifdef RTE_LIBRTE_IEEE1588
 986         static uint64_t ip_pkt_etqf_map[8] = {
 987                 0, 0, 0, PKT_RX_IEEE1588_PTP,
 988                 0, 0, 0, 0,
 989         };
 990
 991         pkt_flags = (hl_tp_rs & IXGBE_RXDADV_PKTTYPE_ETQF) ?
 992                         ip_pkt_etqf_map[(hl_tp_rs >> 4) & 0x07] :
 993                         ip_pkt_types_map[(hl_tp_rs >> 4) & 0x0F];
 994 #else
 995         pkt_flags = (hl_tp_rs & IXGBE_RXDADV_PKTTYPE_ETQF) ? 0 :
 996                         ip_pkt_types_map[(hl_tp_rs >> 4) & 0x0F];
 997
 998 #endif
 999         return pkt_flags | ip_rss_types_map[hl_tp_rs & 0xF];
1000 }
1001 #endif /* RTE_NEXT_ABI */
1002
1003 static inline uint64_t
1004 rx_desc_status_to_pkt_flags(uint32_t rx_status)
1005 {
1006         uint64_t pkt_flags;
1007
1008         /*
1009          * Check if VLAN present only.
1010          * Do not check whether L3/L4 rx checksum done by NIC or not,
1011          * That can be found from rte_eth_rxmode.hw_ip_checksum flag
1012          */
1013         pkt_flags = (rx_status & IXGBE_RXD_STAT_VP) ?  PKT_RX_VLAN_PKT : 0;
1014
1015 #ifdef RTE_LIBRTE_IEEE1588
1016         if (rx_status & IXGBE_RXD_STAT_TMST)
1017                 pkt_flags = pkt_flags | PKT_RX_IEEE1588_TMST;
1018 #endif
1019         return pkt_flags;
1020 }
1021
1022 static inline uint64_t
1023 rx_desc_error_to_pkt_flags(uint32_t rx_status)
1024 {
1025         /*
1026          * Bit 31: IPE, IPv4 checksum error
1027          * Bit 30: L4I, L4I integrity error
1028          */
1029         static uint64_t error_to_pkt_flags_map[4] = {
1030                 0,  PKT_RX_L4_CKSUM_BAD, PKT_RX_IP_CKSUM_BAD,
1031                 PKT_RX_IP_CKSUM_BAD | PKT_RX_L4_CKSUM_BAD
1032         };
1033         return error_to_pkt_flags_map[(rx_status >>
1034                 IXGBE_RXDADV_ERR_CKSUM_BIT) & IXGBE_RXDADV_ERR_CKSUM_MSK];
1035 }
1036
1037 /*
1038  * LOOK_AHEAD defines how many desc statuses to check beyond the
1039  * current descriptor.
1040  * It must be a pound define for optimal performance.
1041  * Do not change the value of LOOK_AHEAD, as the ixgbe_rx_scan_hw_ring
1042  * function only works with LOOK_AHEAD=8.
1043  */
1044 #define LOOK_AHEAD 8
1045 #if (LOOK_AHEAD != 8)
1046 #error "PMD IXGBE: LOOK_AHEAD must be 8\n"
1047 #endif
1048 static inline int
1049 ixgbe_rx_scan_hw_ring(struct ixgbe_rx_queue *rxq)
1050 {
1051         volatile union ixgbe_adv_rx_desc *rxdp;
1052         struct ixgbe_rx_entry *rxep;
1053         struct rte_mbuf *mb;
1054         uint16_t pkt_len;
1055         uint64_t pkt_flags;
1056 #ifdef RTE_NEXT_ABI
1057         int nb_dd;
1058         uint32_t s[LOOK_AHEAD];
1059         uint16_t pkt_info[LOOK_AHEAD];
1060 #else
1061         int s[LOOK_AHEAD], nb_dd;
1062 #endif /* RTE_NEXT_ABI */
1063         int i, j, nb_rx = 0;
1064
1065
1066         /* get references to current descriptor and S/W ring entry */
1067         rxdp = &rxq->rx_ring[rxq->rx_tail];
1068         rxep = &rxq->sw_ring[rxq->rx_tail];
1069
1070         /* check to make sure there is at least 1 packet to receive */
1071         if (! (rxdp->wb.upper.status_error & IXGBE_RXDADV_STAT_DD))
1072                 return 0;
1073
1074         /*
1075          * Scan LOOK_AHEAD descriptors at a time to determine which descriptors
1076          * reference packets that are ready to be received.
1077          */
1078         for (i = 0; i < RTE_PMD_IXGBE_RX_MAX_BURST;
1079              i += LOOK_AHEAD, rxdp += LOOK_AHEAD, rxep += LOOK_AHEAD)
1080         {
1081                 /* Read desc statuses backwards to avoid race condition */
1082                 for (j = LOOK_AHEAD-1; j >= 0; --j)
1083                         s[j] = rxdp[j].wb.upper.status_error;
1084
1085 #ifdef RTE_NEXT_ABI
1086                 for (j = LOOK_AHEAD - 1; j >= 0; --j)
1087                         pkt_info[j] = rxdp[j].wb.lower.lo_dword.
1088                                                 hs_rss.pkt_info;
1089 #endif /* RTE_NEXT_ABI */
1090
1091                 /* Compute how many status bits were set */
1092                 nb_dd = 0;
1093                 for (j = 0; j < LOOK_AHEAD; ++j)
1094                         nb_dd += s[j] & IXGBE_RXDADV_STAT_DD;
1095
1096                 nb_rx += nb_dd;
1097
1098                 /* Translate descriptor info to mbuf format */
1099                 for (j = 0; j < nb_dd; ++j) {
1100                         mb = rxep[j].mbuf;
1101                         pkt_len = (uint16_t)(rxdp[j].wb.upper.length - rxq->crc_len);
1102                         mb->data_len = pkt_len;
1103                         mb->pkt_len = pkt_len;
1104                         mb->vlan_tci = rte_le_to_cpu_16(rxdp[j].wb.upper.vlan);
1105
1106                         /* convert descriptor fields to rte mbuf flags */
1107 #ifdef RTE_NEXT_ABI
1108                         pkt_flags = rx_desc_status_to_pkt_flags(s[j]);
1109                         pkt_flags |= rx_desc_error_to_pkt_flags(s[j]);
1110                         pkt_flags |=
1111                                 ixgbe_rxd_pkt_info_to_pkt_flags(pkt_info[j]);
1112                         mb->ol_flags = pkt_flags;
1113                         mb->packet_type =
1114                                 ixgbe_rxd_pkt_info_to_pkt_type(pkt_info[j]);
1115 #else /* RTE_NEXT_ABI */
1116                         pkt_flags  = rx_desc_hlen_type_rss_to_pkt_flags(
1117                                         rxdp[j].wb.lower.lo_dword.data);
1118                         /* reuse status field from scan list */
1119                         pkt_flags |= rx_desc_status_to_pkt_flags(s[j]);
1120                         pkt_flags |= rx_desc_error_to_pkt_flags(s[j]);
1121                         mb->ol_flags = pkt_flags;
1122 #endif /* RTE_NEXT_ABI */
1123
1124                         if (likely(pkt_flags & PKT_RX_RSS_HASH))
1125                                 mb->hash.rss = rxdp[j].wb.lower.hi_dword.rss;
1126                         else if (pkt_flags & PKT_RX_FDIR) {
1127                                 mb->hash.fdir.hash =
1128                                         (uint16_t)((rxdp[j].wb.lower.hi_dword.csum_ip.csum)
1129                                                 & IXGBE_ATR_HASH_MASK);
1130                                 mb->hash.fdir.id = rxdp[j].wb.lower.hi_dword.csum_ip.ip_id;
1131                         }
1132                 }
1133
1134                 /* Move mbuf pointers from the S/W ring to the stage */
1135                 for (j = 0; j < LOOK_AHEAD; ++j) {
1136                         rxq->rx_stage[i + j] = rxep[j].mbuf;
1137                 }
1138
1139                 /* stop if all requested packets could not be received */
1140                 if (nb_dd != LOOK_AHEAD)
1141                         break;
1142         }
1143
1144         /* clear software ring entries so we can cleanup correctly */
1145         for (i = 0; i < nb_rx; ++i) {
1146                 rxq->sw_ring[rxq->rx_tail + i].mbuf = NULL;
1147         }
1148
1149
1150         return nb_rx;
1151 }
1152
1153 static inline int
1154 ixgbe_rx_alloc_bufs(struct ixgbe_rx_queue *rxq, bool reset_mbuf)
1155 {
1156         volatile union ixgbe_adv_rx_desc *rxdp;
1157         struct ixgbe_rx_entry *rxep;
1158         struct rte_mbuf *mb;
1159         uint16_t alloc_idx;
1160         __le64 dma_addr;
1161         int diag, i;
1162
1163         /* allocate buffers in bulk directly into the S/W ring */
1164         alloc_idx = rxq->rx_free_trigger - (rxq->rx_free_thresh - 1);
1165         rxep = &rxq->sw_ring[alloc_idx];
1166         diag = rte_mempool_get_bulk(rxq->mb_pool, (void *)rxep,
1167                                     rxq->rx_free_thresh);
1168         if (unlikely(diag != 0))
1169                 return (-ENOMEM);
1170
1171         rxdp = &rxq->rx_ring[alloc_idx];
1172         for (i = 0; i < rxq->rx_free_thresh; ++i) {
1173                 /* populate the static rte mbuf fields */
1174                 mb = rxep[i].mbuf;
1175                 if (reset_mbuf) {
1176                         mb->next = NULL;
1177                         mb->nb_segs = 1;
1178                         mb->port = rxq->port_id;
1179                 }
1180
1181                 rte_mbuf_refcnt_set(mb, 1);
1182                 mb->data_off = RTE_PKTMBUF_HEADROOM;
1183
1184                 /* populate the descriptors */
1185                 dma_addr = rte_cpu_to_le_64(RTE_MBUF_DATA_DMA_ADDR_DEFAULT(mb));
1186                 rxdp[i].read.hdr_addr = dma_addr;
1187                 rxdp[i].read.pkt_addr = dma_addr;
1188         }
1189
1190         /* update state of internal queue structure */
1191         rxq->rx_free_trigger = rxq->rx_free_trigger + rxq->rx_free_thresh;
1192         if (rxq->rx_free_trigger >= rxq->nb_rx_desc)
1193                 rxq->rx_free_trigger = rxq->rx_free_thresh - 1;
1194
1195         /* no errors */
1196         return 0;
1197 }
1198
1199 static inline uint16_t
1200 ixgbe_rx_fill_from_stage(struct ixgbe_rx_queue *rxq, struct rte_mbuf **rx_pkts,
1201                          uint16_t nb_pkts)
1202 {
1203         struct rte_mbuf **stage = &rxq->rx_stage[rxq->rx_next_avail];
1204         int i;
1205
1206         /* how many packets are ready to return? */
1207         nb_pkts = (uint16_t)RTE_MIN(nb_pkts, rxq->rx_nb_avail);
1208
1209         /* copy mbuf pointers to the application's packet list */
1210         for (i = 0; i < nb_pkts; ++i)
1211                 rx_pkts[i] = stage[i];
1212
1213         /* update internal queue state */
1214         rxq->rx_nb_avail = (uint16_t)(rxq->rx_nb_avail - nb_pkts);
1215         rxq->rx_next_avail = (uint16_t)(rxq->rx_next_avail + nb_pkts);
1216
1217         return nb_pkts;
1218 }
1219
1220 static inline uint16_t
1221 rx_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1222              uint16_t nb_pkts)
1223 {
1224         struct ixgbe_rx_queue *rxq = (struct ixgbe_rx_queue *)rx_queue;
1225         uint16_t nb_rx = 0;
1226
1227         /* Any previously recv'd pkts will be returned from the Rx stage */
1228         if (rxq->rx_nb_avail)
1229                 return ixgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1230
1231         /* Scan the H/W ring for packets to receive */
1232         nb_rx = (uint16_t)ixgbe_rx_scan_hw_ring(rxq);
1233
1234         /* update internal queue state */
1235         rxq->rx_next_avail = 0;
1236         rxq->rx_nb_avail = nb_rx;
1237         rxq->rx_tail = (uint16_t)(rxq->rx_tail + nb_rx);
1238
1239         /* if required, allocate new buffers to replenish descriptors */
1240         if (rxq->rx_tail > rxq->rx_free_trigger) {
1241                 uint16_t cur_free_trigger = rxq->rx_free_trigger;
1242
1243                 if (ixgbe_rx_alloc_bufs(rxq, true) != 0) {
1244                         int i, j;
1245                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1246                                    "queue_id=%u", (unsigned) rxq->port_id,
1247                                    (unsigned) rxq->queue_id);
1248
1249                         rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed +=
1250                                 rxq->rx_free_thresh;
1251
1252                         /*
1253                          * Need to rewind any previous receives if we cannot
1254                          * allocate new buffers to replenish the old ones.
1255                          */
1256                         rxq->rx_nb_avail = 0;
1257                         rxq->rx_tail = (uint16_t)(rxq->rx_tail - nb_rx);
1258                         for (i = 0, j = rxq->rx_tail; i < nb_rx; ++i, ++j)
1259                                 rxq->sw_ring[j].mbuf = rxq->rx_stage[i];
1260
1261                         return 0;
1262                 }
1263
1264                 /* update tail pointer */
1265                 rte_wmb();
1266                 IXGBE_PCI_REG_WRITE(rxq->rdt_reg_addr, cur_free_trigger);
1267         }
1268
1269         if (rxq->rx_tail >= rxq->nb_rx_desc)
1270                 rxq->rx_tail = 0;
1271
1272         /* received any packets this loop? */
1273         if (rxq->rx_nb_avail)
1274                 return ixgbe_rx_fill_from_stage(rxq, rx_pkts, nb_pkts);
1275
1276         return 0;
1277 }
1278
1279 /* split requests into chunks of size RTE_PMD_IXGBE_RX_MAX_BURST */
1280 static uint16_t
1281 ixgbe_recv_pkts_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1282                            uint16_t nb_pkts)
1283 {
1284         uint16_t nb_rx;
1285
1286         if (unlikely(nb_pkts == 0))
1287                 return 0;
1288
1289         if (likely(nb_pkts <= RTE_PMD_IXGBE_RX_MAX_BURST))
1290                 return rx_recv_pkts(rx_queue, rx_pkts, nb_pkts);
1291
1292         /* request is relatively large, chunk it up */
1293         nb_rx = 0;
1294         while (nb_pkts) {
1295                 uint16_t ret, n;
1296                 n = (uint16_t)RTE_MIN(nb_pkts, RTE_PMD_IXGBE_RX_MAX_BURST);
1297                 ret = rx_recv_pkts(rx_queue, &rx_pkts[nb_rx], n);
1298                 nb_rx = (uint16_t)(nb_rx + ret);
1299                 nb_pkts = (uint16_t)(nb_pkts - ret);
1300                 if (ret < n)
1301                         break;
1302         }
1303
1304         return nb_rx;
1305 }
1306
1307 uint16_t
1308 ixgbe_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
1309                 uint16_t nb_pkts)
1310 {
1311         struct ixgbe_rx_queue *rxq;
1312         volatile union ixgbe_adv_rx_desc *rx_ring;
1313         volatile union ixgbe_adv_rx_desc *rxdp;
1314         struct ixgbe_rx_entry *sw_ring;
1315         struct ixgbe_rx_entry *rxe;
1316         struct rte_mbuf *rxm;
1317         struct rte_mbuf *nmb;
1318         union ixgbe_adv_rx_desc rxd;
1319         uint64_t dma_addr;
1320         uint32_t staterr;
1321 #ifdef RTE_NEXT_ABI
1322         uint32_t pkt_info;
1323 #else
1324         uint32_t hlen_type_rss;
1325 #endif
1326         uint16_t pkt_len;
1327         uint16_t rx_id;
1328         uint16_t nb_rx;
1329         uint16_t nb_hold;
1330         uint64_t pkt_flags;
1331
1332         nb_rx = 0;
1333         nb_hold = 0;
1334         rxq = rx_queue;
1335         rx_id = rxq->rx_tail;
1336         rx_ring = rxq->rx_ring;
1337         sw_ring = rxq->sw_ring;
1338         while (nb_rx < nb_pkts) {
1339                 /*
1340                  * The order of operations here is important as the DD status
1341                  * bit must not be read after any other descriptor fields.
1342                  * rx_ring and rxdp are pointing to volatile data so the order
1343                  * of accesses cannot be reordered by the compiler. If they were
1344                  * not volatile, they could be reordered which could lead to
1345                  * using invalid descriptor fields when read from rxd.
1346                  */
1347                 rxdp = &rx_ring[rx_id];
1348                 staterr = rxdp->wb.upper.status_error;
1349                 if (! (staterr & rte_cpu_to_le_32(IXGBE_RXDADV_STAT_DD)))
1350                         break;
1351                 rxd = *rxdp;
1352
1353                 /*
1354                  * End of packet.
1355                  *
1356                  * If the IXGBE_RXDADV_STAT_EOP flag is not set, the RX packet
1357                  * is likely to be invalid and to be dropped by the various
1358                  * validation checks performed by the network stack.
1359                  *
1360                  * Allocate a new mbuf to replenish the RX ring descriptor.
1361                  * If the allocation fails:
1362                  *    - arrange for that RX descriptor to be the first one
1363                  *      being parsed the next time the receive function is
1364                  *      invoked [on the same queue].
1365                  *
1366                  *    - Stop parsing the RX ring and return immediately.
1367                  *
1368                  * This policy do not drop the packet received in the RX
1369                  * descriptor for which the allocation of a new mbuf failed.
1370                  * Thus, it allows that packet to be later retrieved if
1371                  * mbuf have been freed in the mean time.
1372                  * As a side effect, holding RX descriptors instead of
1373                  * systematically giving them back to the NIC may lead to
1374                  * RX ring exhaustion situations.
1375                  * However, the NIC can gracefully prevent such situations
1376                  * to happen by sending specific "back-pressure" flow control
1377                  * frames to its peer(s).
1378                  */
1379                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1380                            "ext_err_stat=0x%08x pkt_len=%u",
1381                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
1382                            (unsigned) rx_id, (unsigned) staterr,
1383                            (unsigned) rte_le_to_cpu_16(rxd.wb.upper.length));
1384
1385                 nmb = rte_rxmbuf_alloc(rxq->mb_pool);
1386                 if (nmb == NULL) {
1387                         PMD_RX_LOG(DEBUG, "RX mbuf alloc failed port_id=%u "
1388                                    "queue_id=%u", (unsigned) rxq->port_id,
1389                                    (unsigned) rxq->queue_id);
1390                         rte_eth_devices[rxq->port_id].data->rx_mbuf_alloc_failed++;
1391                         break;
1392                 }
1393
1394                 nb_hold++;
1395                 rxe = &sw_ring[rx_id];
1396                 rx_id++;
1397                 if (rx_id == rxq->nb_rx_desc)
1398                         rx_id = 0;
1399
1400                 /* Prefetch next mbuf while processing current one. */
1401                 rte_ixgbe_prefetch(sw_ring[rx_id].mbuf);
1402
1403                 /*
1404                  * When next RX descriptor is on a cache-line boundary,
1405                  * prefetch the next 4 RX descriptors and the next 8 pointers
1406                  * to mbufs.
1407                  */
1408                 if ((rx_id & 0x3) == 0) {
1409                         rte_ixgbe_prefetch(&rx_ring[rx_id]);
1410                         rte_ixgbe_prefetch(&sw_ring[rx_id]);
1411                 }
1412
1413                 rxm = rxe->mbuf;
1414                 rxe->mbuf = nmb;
1415                 dma_addr =
1416                         rte_cpu_to_le_64(RTE_MBUF_DATA_DMA_ADDR_DEFAULT(nmb));
1417                 rxdp->read.hdr_addr = dma_addr;
1418                 rxdp->read.pkt_addr = dma_addr;
1419
1420                 /*
1421                  * Initialize the returned mbuf.
1422                  * 1) setup generic mbuf fields:
1423                  *    - number of segments,
1424                  *    - next segment,
1425                  *    - packet length,
1426                  *    - RX port identifier.
1427                  * 2) integrate hardware offload data, if any:
1428                  *    - RSS flag & hash,
1429                  *    - IP checksum flag,
1430                  *    - VLAN TCI, if any,
1431                  *    - error flags.
1432                  */
1433                 pkt_len = (uint16_t) (rte_le_to_cpu_16(rxd.wb.upper.length) -
1434                                       rxq->crc_len);
1435                 rxm->data_off = RTE_PKTMBUF_HEADROOM;
1436                 rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
1437                 rxm->nb_segs = 1;
1438                 rxm->next = NULL;
1439                 rxm->pkt_len = pkt_len;
1440                 rxm->data_len = pkt_len;
1441                 rxm->port = rxq->port_id;
1442
1443 #ifdef RTE_NEXT_ABI
1444                 pkt_info = rte_le_to_cpu_32(rxd.wb.lower.lo_dword.hs_rss.
1445                                                                 pkt_info);
1446                 /* Only valid if PKT_RX_VLAN_PKT set in pkt_flags */
1447                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.wb.upper.vlan);
1448
1449                 pkt_flags = rx_desc_status_to_pkt_flags(staterr);
1450                 pkt_flags = pkt_flags | rx_desc_error_to_pkt_flags(staterr);
1451                 pkt_flags = pkt_flags |
1452                         ixgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1453                 rxm->ol_flags = pkt_flags;
1454                 rxm->packet_type = ixgbe_rxd_pkt_info_to_pkt_type(pkt_info);
1455 #else /* RTE_NEXT_ABI */
1456                 hlen_type_rss = rte_le_to_cpu_32(rxd.wb.lower.lo_dword.data);
1457                 /* Only valid if PKT_RX_VLAN_PKT set in pkt_flags */
1458                 rxm->vlan_tci = rte_le_to_cpu_16(rxd.wb.upper.vlan);
1459
1460                 pkt_flags = rx_desc_hlen_type_rss_to_pkt_flags(hlen_type_rss);
1461                 pkt_flags = pkt_flags | rx_desc_status_to_pkt_flags(staterr);
1462                 pkt_flags = pkt_flags | rx_desc_error_to_pkt_flags(staterr);
1463                 rxm->ol_flags = pkt_flags;
1464 #endif /* RTE_NEXT_ABI */
1465
1466                 if (likely(pkt_flags & PKT_RX_RSS_HASH))
1467                         rxm->hash.rss = rxd.wb.lower.hi_dword.rss;
1468                 else if (pkt_flags & PKT_RX_FDIR) {
1469                         rxm->hash.fdir.hash =
1470                                 (uint16_t)((rxd.wb.lower.hi_dword.csum_ip.csum)
1471                                            & IXGBE_ATR_HASH_MASK);
1472                         rxm->hash.fdir.id = rxd.wb.lower.hi_dword.csum_ip.ip_id;
1473                 }
1474                 /*
1475                  * Store the mbuf address into the next entry of the array
1476                  * of returned packets.
1477                  */
1478                 rx_pkts[nb_rx++] = rxm;
1479         }
1480         rxq->rx_tail = rx_id;
1481
1482         /*
1483          * If the number of free RX descriptors is greater than the RX free
1484          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1485          * register.
1486          * Update the RDT with the value of the last processed RX descriptor
1487          * minus 1, to guarantee that the RDT register is never equal to the
1488          * RDH register, which creates a "full" ring situtation from the
1489          * hardware point of view...
1490          */
1491         nb_hold = (uint16_t) (nb_hold + rxq->nb_rx_hold);
1492         if (nb_hold > rxq->rx_free_thresh) {
1493                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1494                            "nb_hold=%u nb_rx=%u",
1495                            (unsigned) rxq->port_id, (unsigned) rxq->queue_id,
1496                            (unsigned) rx_id, (unsigned) nb_hold,
1497                            (unsigned) nb_rx);
1498                 rx_id = (uint16_t) ((rx_id == 0) ?
1499                                      (rxq->nb_rx_desc - 1) : (rx_id - 1));
1500                 IXGBE_PCI_REG_WRITE(rxq->rdt_reg_addr, rx_id);
1501                 nb_hold = 0;
1502         }
1503         rxq->nb_rx_hold = nb_hold;
1504         return (nb_rx);
1505 }
1506
1507 /**
1508  * Detect an RSC descriptor.
1509  */
1510 static inline uint32_t
1511 ixgbe_rsc_count(union ixgbe_adv_rx_desc *rx)
1512 {
1513         return (rte_le_to_cpu_32(rx->wb.lower.lo_dword.data) &
1514                 IXGBE_RXDADV_RSCCNT_MASK) >> IXGBE_RXDADV_RSCCNT_SHIFT;
1515 }
1516
1517 /**
1518  * ixgbe_fill_cluster_head_buf - fill the first mbuf of the returned packet
1519  *
1520  * Fill the following info in the HEAD buffer of the Rx cluster:
1521  *    - RX port identifier
1522  *    - hardware offload data, if any:
1523  *      - RSS flag & hash
1524  *      - IP checksum flag
1525  *      - VLAN TCI, if any
1526  *      - error flags
1527  * @head HEAD of the packet cluster
1528  * @desc HW descriptor to get data from
1529  * @port_id Port ID of the Rx queue
1530  */
1531 static inline void
1532 ixgbe_fill_cluster_head_buf(
1533         struct rte_mbuf *head,
1534         union ixgbe_adv_rx_desc *desc,
1535         uint8_t port_id,
1536         uint32_t staterr)
1537 {
1538 #ifdef RTE_NEXT_ABI
1539         uint16_t pkt_info;
1540         uint64_t pkt_flags;
1541
1542         head->port = port_id;
1543
1544         /* The vlan_tci field is only valid when PKT_RX_VLAN_PKT is
1545          * set in the pkt_flags field.
1546          */
1547         head->vlan_tci = rte_le_to_cpu_16(desc->wb.upper.vlan);
1548         pkt_info = rte_le_to_cpu_32(desc->wb.lower.lo_dword.hs_rss.pkt_info);
1549         pkt_flags = rx_desc_status_to_pkt_flags(staterr);
1550         pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1551         pkt_flags |= ixgbe_rxd_pkt_info_to_pkt_flags(pkt_info);
1552         head->ol_flags = pkt_flags;
1553         head->packet_type = ixgbe_rxd_pkt_info_to_pkt_type(pkt_info);
1554 #else /* RTE_NEXT_ABI */
1555         uint32_t hlen_type_rss;
1556         uint64_t pkt_flags;
1557
1558         head->port = port_id;
1559
1560         /*
1561          * The vlan_tci field is only valid when PKT_RX_VLAN_PKT is
1562          * set in the pkt_flags field.
1563          */
1564         head->vlan_tci = rte_le_to_cpu_16(desc->wb.upper.vlan);
1565         hlen_type_rss = rte_le_to_cpu_32(desc->wb.lower.lo_dword.data);
1566         pkt_flags = rx_desc_hlen_type_rss_to_pkt_flags(hlen_type_rss);
1567         pkt_flags |= rx_desc_status_to_pkt_flags(staterr);
1568         pkt_flags |= rx_desc_error_to_pkt_flags(staterr);
1569         head->ol_flags = pkt_flags;
1570 #endif /* RTE_NEXT_ABI */
1571
1572         if (likely(pkt_flags & PKT_RX_RSS_HASH))
1573                 head->hash.rss = rte_le_to_cpu_32(desc->wb.lower.hi_dword.rss);
1574         else if (pkt_flags & PKT_RX_FDIR) {
1575                 head->hash.fdir.hash =
1576                         rte_le_to_cpu_16(desc->wb.lower.hi_dword.csum_ip.csum)
1577                                                           & IXGBE_ATR_HASH_MASK;
1578                 head->hash.fdir.id =
1579                         rte_le_to_cpu_16(desc->wb.lower.hi_dword.csum_ip.ip_id);
1580         }
1581 }
1582
1583 /**
1584  * ixgbe_recv_pkts_lro - receive handler for and LRO case.
1585  *
1586  * @rx_queue Rx queue handle
1587  * @rx_pkts table of received packets
1588  * @nb_pkts size of rx_pkts table
1589  * @bulk_alloc if TRUE bulk allocation is used for a HW ring refilling
1590  *
1591  * Handles the Rx HW ring completions when RSC feature is configured. Uses an
1592  * additional ring of ixgbe_rsc_entry's that will hold the relevant RSC info.
1593  *
1594  * We use the same logic as in Linux and in FreeBSD ixgbe drivers:
1595  * 1) When non-EOP RSC completion arrives:
1596  *    a) Update the HEAD of the current RSC aggregation cluster with the new
1597  *       segment's data length.
1598  *    b) Set the "next" pointer of the current segment to point to the segment
1599  *       at the NEXTP index.
1600  *    c) Pass the HEAD of RSC aggregation cluster on to the next NEXTP entry
1601  *       in the sw_rsc_ring.
1602  * 2) When EOP arrives we just update the cluster's total length and offload
1603  *    flags and deliver the cluster up to the upper layers. In our case - put it
1604  *    in the rx_pkts table.
1605  *
1606  * Returns the number of received packets/clusters (according to the "bulk
1607  * receive" interface).
1608  */
1609 static inline uint16_t
1610 ixgbe_recv_pkts_lro(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts,
1611                     bool bulk_alloc)
1612 {
1613         struct ixgbe_rx_queue *rxq = rx_queue;
1614         volatile union ixgbe_adv_rx_desc *rx_ring = rxq->rx_ring;
1615         struct ixgbe_rx_entry *sw_ring = rxq->sw_ring;
1616         struct ixgbe_scattered_rx_entry *sw_sc_ring = rxq->sw_sc_ring;
1617         uint16_t rx_id = rxq->rx_tail;
1618         uint16_t nb_rx = 0;
1619         uint16_t nb_hold = rxq->nb_rx_hold;
1620         uint16_t prev_id = rxq->rx_tail;
1621
1622         while (nb_rx < nb_pkts) {
1623                 bool eop;
1624                 struct ixgbe_rx_entry *rxe;
1625                 struct ixgbe_scattered_rx_entry *sc_entry;
1626                 struct ixgbe_scattered_rx_entry *next_sc_entry;
1627                 struct ixgbe_rx_entry *next_rxe;
1628                 struct rte_mbuf *first_seg;
1629                 struct rte_mbuf *rxm;
1630                 struct rte_mbuf *nmb;
1631                 union ixgbe_adv_rx_desc rxd;
1632                 uint16_t data_len;
1633                 uint16_t next_id;
1634                 volatile union ixgbe_adv_rx_desc *rxdp;
1635                 uint32_t staterr;
1636
1637 next_desc:
1638                 /*
1639                  * The code in this whole file uses the volatile pointer to
1640                  * ensure the read ordering of the status and the rest of the
1641                  * descriptor fields (on the compiler level only!!!). This is so
1642                  * UGLY - why not to just use the compiler barrier instead? DPDK
1643                  * even has the rte_compiler_barrier() for that.
1644                  *
1645                  * But most importantly this is just wrong because this doesn't
1646                  * ensure memory ordering in a general case at all. For
1647                  * instance, DPDK is supposed to work on Power CPUs where
1648                  * compiler barrier may just not be enough!
1649                  *
1650                  * I tried to write only this function properly to have a
1651                  * starting point (as a part of an LRO/RSC series) but the
1652                  * compiler cursed at me when I tried to cast away the
1653                  * "volatile" from rx_ring (yes, it's volatile too!!!). So, I'm
1654                  * keeping it the way it is for now.
1655                  *
1656                  * The code in this file is broken in so many other places and
1657                  * will just not work on a big endian CPU anyway therefore the
1658                  * lines below will have to be revisited together with the rest
1659                  * of the ixgbe PMD.
1660                  *
1661                  * TODO:
1662                  *    - Get rid of "volatile" crap and let the compiler do its
1663                  *      job.
1664                  *    - Use the proper memory barrier (rte_rmb()) to ensure the
1665                  *      memory ordering below.
1666                  */
1667                 rxdp = &rx_ring[rx_id];
1668                 staterr = rte_le_to_cpu_32(rxdp->wb.upper.status_error);
1669
1670                 if (!(staterr & IXGBE_RXDADV_STAT_DD))
1671                         break;
1672
1673                 rxd = *rxdp;
1674
1675                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_id=%u "
1676                                   "staterr=0x%x data_len=%u",
1677                            rxq->port_id, rxq->queue_id, rx_id, staterr,
1678                            rte_le_to_cpu_16(rxd.wb.upper.length));
1679
1680                 if (!bulk_alloc) {
1681                         nmb = rte_rxmbuf_alloc(rxq->mb_pool);
1682                         if (nmb == NULL) {
1683                                 PMD_RX_LOG(DEBUG, "RX mbuf alloc failed "
1684                                                   "port_id=%u queue_id=%u",
1685                                            rxq->port_id, rxq->queue_id);
1686
1687                                 rte_eth_devices[rxq->port_id].data->
1688                                                         rx_mbuf_alloc_failed++;
1689                                 break;
1690                         }
1691                 }
1692                 else if (nb_hold > rxq->rx_free_thresh) {
1693                         uint16_t next_rdt = rxq->rx_free_trigger;
1694
1695                         if (!ixgbe_rx_alloc_bufs(rxq, false)) {
1696                                 rte_wmb();
1697                                 IXGBE_PCI_REG_WRITE(rxq->rdt_reg_addr,
1698                                                     next_rdt);
1699                                 nb_hold -= rxq->rx_free_thresh;
1700                         } else {
1701                                 PMD_RX_LOG(DEBUG, "RX bulk alloc failed "
1702                                                   "port_id=%u queue_id=%u",
1703                                            rxq->port_id, rxq->queue_id);
1704
1705                                 rte_eth_devices[rxq->port_id].data->
1706                                                         rx_mbuf_alloc_failed++;
1707                                 break;
1708                         }
1709                 }
1710
1711                 nb_hold++;
1712                 rxe = &sw_ring[rx_id];
1713                 eop = staterr & IXGBE_RXDADV_STAT_EOP;
1714
1715                 next_id = rx_id + 1;
1716                 if (next_id == rxq->nb_rx_desc)
1717                         next_id = 0;
1718
1719                 /* Prefetch next mbuf while processing current one. */
1720                 rte_ixgbe_prefetch(sw_ring[next_id].mbuf);
1721
1722                 /*
1723                  * When next RX descriptor is on a cache-line boundary,
1724                  * prefetch the next 4 RX descriptors and the next 4 pointers
1725                  * to mbufs.
1726                  */
1727                 if ((next_id & 0x3) == 0) {
1728                         rte_ixgbe_prefetch(&rx_ring[next_id]);
1729                         rte_ixgbe_prefetch(&sw_ring[next_id]);
1730                 }
1731
1732                 rxm = rxe->mbuf;
1733
1734                 if (!bulk_alloc) {
1735                         __le64 dma =
1736                           rte_cpu_to_le_64(RTE_MBUF_DATA_DMA_ADDR_DEFAULT(nmb));
1737                         /*
1738                          * Update RX descriptor with the physical address of the
1739                          * new data buffer of the new allocated mbuf.
1740                          */
1741                         rxe->mbuf = nmb;
1742
1743                         rxm->data_off = RTE_PKTMBUF_HEADROOM;
1744                         rxdp->read.hdr_addr = dma;
1745                         rxdp->read.pkt_addr = dma;
1746                 } else
1747                         rxe->mbuf = NULL;
1748
1749                 /*
1750                  * Set data length & data buffer address of mbuf.
1751                  */
1752                 data_len = rte_le_to_cpu_16(rxd.wb.upper.length);
1753                 rxm->data_len = data_len;
1754
1755                 if (!eop) {
1756                         uint16_t nextp_id;
1757                         /*
1758                          * Get next descriptor index:
1759                          *  - For RSC it's in the NEXTP field.
1760                          *  - For a scattered packet - it's just a following
1761                          *    descriptor.
1762                          */
1763                         if (ixgbe_rsc_count(&rxd))
1764                                 nextp_id =
1765                                         (staterr & IXGBE_RXDADV_NEXTP_MASK) >>
1766                                                        IXGBE_RXDADV_NEXTP_SHIFT;
1767                         else
1768                                 nextp_id = next_id;
1769
1770                         next_sc_entry = &sw_sc_ring[nextp_id];
1771                         next_rxe = &sw_ring[nextp_id];
1772                         rte_ixgbe_prefetch(next_rxe);
1773                 }
1774
1775                 sc_entry = &sw_sc_ring[rx_id];
1776                 first_seg = sc_entry->fbuf;
1777                 sc_entry->fbuf = NULL;
1778
1779                 /*
1780                  * If this is the first buffer of the received packet,
1781                  * set the pointer to the first mbuf of the packet and
1782                  * initialize its context.
1783                  * Otherwise, update the total length and the number of segments
1784                  * of the current scattered packet, and update the pointer to
1785                  * the last mbuf of the current packet.
1786                  */
1787                 if (first_seg == NULL) {
1788                         first_seg = rxm;
1789                         first_seg->pkt_len = data_len;
1790                         first_seg->nb_segs = 1;
1791                 } else {
1792                         first_seg->pkt_len += data_len;
1793                         first_seg->nb_segs++;
1794                 }
1795
1796                 prev_id = rx_id;
1797                 rx_id = next_id;
1798
1799                 /*
1800                  * If this is not the last buffer of the received packet, update
1801                  * the pointer to the first mbuf at the NEXTP entry in the
1802                  * sw_sc_ring and continue to parse the RX ring.
1803                  */
1804                 if (!eop) {
1805                         rxm->next = next_rxe->mbuf;
1806                         next_sc_entry->fbuf = first_seg;
1807                         goto next_desc;
1808                 }
1809
1810                 /*
1811                  * This is the last buffer of the received packet - return
1812                  * the current cluster to the user.
1813                  */
1814                 rxm->next = NULL;
1815
1816                 /* Initialize the first mbuf of the returned packet */
1817                 ixgbe_fill_cluster_head_buf(first_seg, &rxd, rxq->port_id,
1818                                             staterr);
1819
1820                 /* Prefetch data of first segment, if configured to do so. */
1821                 rte_packet_prefetch((char *)first_seg->buf_addr +
1822                         first_seg->data_off);
1823
1824                 /*
1825                  * Store the mbuf address into the next entry of the array
1826                  * of returned packets.
1827                  */
1828                 rx_pkts[nb_rx++] = first_seg;
1829         }
1830
1831         /*
1832          * Record index of the next RX descriptor to probe.
1833          */
1834         rxq->rx_tail = rx_id;
1835
1836         /*
1837          * If the number of free RX descriptors is greater than the RX free
1838          * threshold of the queue, advance the Receive Descriptor Tail (RDT)
1839          * register.
1840          * Update the RDT with the value of the last processed RX descriptor
1841          * minus 1, to guarantee that the RDT register is never equal to the
1842          * RDH register, which creates a "full" ring situtation from the
1843          * hardware point of view...
1844          */
1845         if (!bulk_alloc && nb_hold > rxq->rx_free_thresh) {
1846                 PMD_RX_LOG(DEBUG, "port_id=%u queue_id=%u rx_tail=%u "
1847                            "nb_hold=%u nb_rx=%u",
1848                            rxq->port_id, rxq->queue_id, rx_id, nb_hold, nb_rx);
1849
1850                 rte_wmb();
1851                 IXGBE_PCI_REG_WRITE(rxq->rdt_reg_addr, prev_id);
1852                 nb_hold = 0;
1853         }
1854
1855         rxq->nb_rx_hold = nb_hold;
1856         return nb_rx;
1857 }
1858
1859 uint16_t
1860 ixgbe_recv_pkts_lro_single_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1861                                  uint16_t nb_pkts)
1862 {
1863         return ixgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, false);
1864 }
1865
1866 uint16_t
1867 ixgbe_recv_pkts_lro_bulk_alloc(void *rx_queue, struct rte_mbuf **rx_pkts,
1868                                uint16_t nb_pkts)
1869 {
1870         return ixgbe_recv_pkts_lro(rx_queue, rx_pkts, nb_pkts, true);
1871 }
1872
1873 /*********************************************************************
1874  *
1875  *  Queue management functions
1876  *
1877  **********************************************************************/
1878
1879 /*
1880  * Rings setup and release.
1881  *
1882  * TDBA/RDBA should be aligned on 16 byte boundary. But TDLEN/RDLEN should be
1883  * multiple of 128 bytes. So we align TDBA/RDBA on 128 byte boundary. This will
1884  * also optimize cache line size effect. H/W supports up to cache line size 128.
1885  */
1886 #define IXGBE_ALIGN 128
1887
1888 /*
1889  * Maximum number of Ring Descriptors.
1890  *
1891  * Since RDLEN/TDLEN should be multiple of 128 bytes, the number of ring
1892  * descriptors should meet the following condition:
1893  *      (num_ring_desc * sizeof(rx/tx descriptor)) % 128 == 0
1894  */
1895 #define IXGBE_MIN_RING_DESC 32
1896 #define IXGBE_MAX_RING_DESC 4096
1897
1898 /*
1899  * Create memzone for HW rings. malloc can't be used as the physical address is
1900  * needed. If the memzone is already created, then this function returns a ptr
1901  * to the old one.
1902  */
1903 static const struct rte_memzone * __attribute__((cold))
1904 ring_dma_zone_reserve(struct rte_eth_dev *dev, const char *ring_name,
1905                       uint16_t queue_id, uint32_t ring_size, int socket_id)
1906 {
1907         char z_name[RTE_MEMZONE_NAMESIZE];
1908         const struct rte_memzone *mz;
1909
1910         snprintf(z_name, sizeof(z_name), "%s_%s_%d_%d",
1911                         dev->driver->pci_drv.name, ring_name,
1912                         dev->data->port_id, queue_id);
1913
1914         mz = rte_memzone_lookup(z_name);
1915         if (mz)
1916                 return mz;
1917
1918 #ifdef RTE_LIBRTE_XEN_DOM0
1919         return rte_memzone_reserve_bounded(z_name, ring_size,
1920                 socket_id, 0, IXGBE_ALIGN, RTE_PGSIZE_2M);
1921 #else
1922         return rte_memzone_reserve_aligned(z_name, ring_size,
1923                 socket_id, 0, IXGBE_ALIGN);
1924 #endif
1925 }
1926
1927 static void __attribute__((cold))
1928 ixgbe_tx_queue_release_mbufs(struct ixgbe_tx_queue *txq)
1929 {
1930         unsigned i;
1931
1932         if (txq->sw_ring != NULL) {
1933                 for (i = 0; i < txq->nb_tx_desc; i++) {
1934                         if (txq->sw_ring[i].mbuf != NULL) {
1935                                 rte_pktmbuf_free_seg(txq->sw_ring[i].mbuf);
1936                                 txq->sw_ring[i].mbuf = NULL;
1937                         }
1938                 }
1939         }
1940 }
1941
1942 static void __attribute__((cold))
1943 ixgbe_tx_free_swring(struct ixgbe_tx_queue *txq)
1944 {
1945         if (txq != NULL &&
1946             txq->sw_ring != NULL)
1947                 rte_free(txq->sw_ring);
1948 }
1949
1950 static void __attribute__((cold))
1951 ixgbe_tx_queue_release(struct ixgbe_tx_queue *txq)
1952 {
1953         if (txq != NULL && txq->ops != NULL) {
1954                 txq->ops->release_mbufs(txq);
1955                 txq->ops->free_swring(txq);
1956                 rte_free(txq);
1957         }
1958 }
1959
1960 void __attribute__((cold))
1961 ixgbe_dev_tx_queue_release(void *txq)
1962 {
1963         ixgbe_tx_queue_release(txq);
1964 }
1965
1966 /* (Re)set dynamic ixgbe_tx_queue fields to defaults */
1967 static void __attribute__((cold))
1968 ixgbe_reset_tx_queue(struct ixgbe_tx_queue *txq)
1969 {
1970         static const union ixgbe_adv_tx_desc zeroed_desc = {{0}};
1971         struct ixgbe_tx_entry *txe = txq->sw_ring;
1972         uint16_t prev, i;
1973
1974         /* Zero out HW ring memory */
1975         for (i = 0; i < txq->nb_tx_desc; i++) {
1976                 txq->tx_ring[i] = zeroed_desc;
1977         }
1978
1979         /* Initialize SW ring entries */
1980         prev = (uint16_t) (txq->nb_tx_desc - 1);
1981         for (i = 0; i < txq->nb_tx_desc; i++) {
1982                 volatile union ixgbe_adv_tx_desc *txd = &txq->tx_ring[i];
1983                 txd->wb.status = IXGBE_TXD_STAT_DD;
1984                 txe[i].mbuf = NULL;
1985                 txe[i].last_id = i;
1986                 txe[prev].next_id = i;
1987                 prev = i;
1988         }
1989
1990         txq->tx_next_dd = (uint16_t)(txq->tx_rs_thresh - 1);
1991         txq->tx_next_rs = (uint16_t)(txq->tx_rs_thresh - 1);
1992
1993         txq->tx_tail = 0;
1994         txq->nb_tx_used = 0;
1995         /*
1996          * Always allow 1 descriptor to be un-allocated to avoid
1997          * a H/W race condition
1998          */
1999         txq->last_desc_cleaned = (uint16_t)(txq->nb_tx_desc - 1);
2000         txq->nb_tx_free = (uint16_t)(txq->nb_tx_desc - 1);
2001         txq->ctx_curr = 0;
2002         memset((void*)&txq->ctx_cache, 0,
2003                 IXGBE_CTX_NUM * sizeof(struct ixgbe_advctx_info));
2004 }
2005
2006 static const struct ixgbe_txq_ops def_txq_ops = {
2007         .release_mbufs = ixgbe_tx_queue_release_mbufs,
2008         .free_swring = ixgbe_tx_free_swring,
2009         .reset = ixgbe_reset_tx_queue,
2010 };
2011
2012 /* Takes an ethdev and a queue and sets up the tx function to be used based on
2013  * the queue parameters. Used in tx_queue_setup by primary process and then
2014  * in dev_init by secondary process when attaching to an existing ethdev.
2015  */
2016 void __attribute__((cold))
2017 ixgbe_set_tx_function(struct rte_eth_dev *dev, struct ixgbe_tx_queue *txq)
2018 {
2019         /* Use a simple Tx queue (no offloads, no multi segs) if possible */
2020         if (((txq->txq_flags & IXGBE_SIMPLE_FLAGS) == IXGBE_SIMPLE_FLAGS)
2021                         && (txq->tx_rs_thresh >= RTE_PMD_IXGBE_TX_MAX_BURST)) {
2022                 PMD_INIT_LOG(INFO, "Using simple tx code path");
2023 #ifdef RTE_IXGBE_INC_VECTOR
2024                 if (txq->tx_rs_thresh <= RTE_IXGBE_TX_MAX_FREE_BUF_SZ &&
2025                                 (rte_eal_process_type() != RTE_PROC_PRIMARY ||
2026                                         ixgbe_txq_vec_setup(txq) == 0)) {
2027                         PMD_INIT_LOG(INFO, "Vector tx enabled.");
2028                         dev->tx_pkt_burst = ixgbe_xmit_pkts_vec;
2029                 } else
2030 #endif
2031                 dev->tx_pkt_burst = ixgbe_xmit_pkts_simple;
2032         } else {
2033                 PMD_INIT_LOG(INFO, "Using full-featured tx code path");
2034                 PMD_INIT_LOG(INFO,
2035                                 " - txq_flags = %lx " "[IXGBE_SIMPLE_FLAGS=%lx]",
2036                                 (unsigned long)txq->txq_flags,
2037                                 (unsigned long)IXGBE_SIMPLE_FLAGS);
2038                 PMD_INIT_LOG(INFO,
2039                                 " - tx_rs_thresh = %lu " "[RTE_PMD_IXGBE_TX_MAX_BURST=%lu]",
2040                                 (unsigned long)txq->tx_rs_thresh,
2041                                 (unsigned long)RTE_PMD_IXGBE_TX_MAX_BURST);
2042                 dev->tx_pkt_burst = ixgbe_xmit_pkts;
2043         }
2044 }
2045
2046 int __attribute__((cold))
2047 ixgbe_dev_tx_queue_setup(struct rte_eth_dev *dev,
2048                          uint16_t queue_idx,
2049                          uint16_t nb_desc,
2050                          unsigned int socket_id,
2051                          const struct rte_eth_txconf *tx_conf)
2052 {
2053         const struct rte_memzone *tz;
2054         struct ixgbe_tx_queue *txq;
2055         struct ixgbe_hw     *hw;
2056         uint16_t tx_rs_thresh, tx_free_thresh;
2057
2058         PMD_INIT_FUNC_TRACE();
2059         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2060
2061         /*
2062          * Validate number of transmit descriptors.
2063          * It must not exceed hardware maximum, and must be multiple
2064          * of IXGBE_ALIGN.
2065          */
2066         if (((nb_desc * sizeof(union ixgbe_adv_tx_desc)) % IXGBE_ALIGN) != 0 ||
2067             (nb_desc > IXGBE_MAX_RING_DESC) ||
2068             (nb_desc < IXGBE_MIN_RING_DESC)) {
2069                 return -EINVAL;
2070         }
2071
2072         /*
2073          * The following two parameters control the setting of the RS bit on
2074          * transmit descriptors.
2075          * TX descriptors will have their RS bit set after txq->tx_rs_thresh
2076          * descriptors have been used.
2077          * The TX descriptor ring will be cleaned after txq->tx_free_thresh
2078          * descriptors are used or if the number of descriptors required
2079          * to transmit a packet is greater than the number of free TX
2080          * descriptors.
2081          * The following constraints must be satisfied:
2082          *  tx_rs_thresh must be greater than 0.
2083          *  tx_rs_thresh must be less than the size of the ring minus 2.
2084          *  tx_rs_thresh must be less than or equal to tx_free_thresh.
2085          *  tx_rs_thresh must be a divisor of the ring size.
2086          *  tx_free_thresh must be greater than 0.
2087          *  tx_free_thresh must be less than the size of the ring minus 3.
2088          * One descriptor in the TX ring is used as a sentinel to avoid a
2089          * H/W race condition, hence the maximum threshold constraints.
2090          * When set to zero use default values.
2091          */
2092         tx_rs_thresh = (uint16_t)((tx_conf->tx_rs_thresh) ?
2093                         tx_conf->tx_rs_thresh : DEFAULT_TX_RS_THRESH);
2094         tx_free_thresh = (uint16_t)((tx_conf->tx_free_thresh) ?
2095                         tx_conf->tx_free_thresh : DEFAULT_TX_FREE_THRESH);
2096         if (tx_rs_thresh >= (nb_desc - 2)) {
2097                 PMD_INIT_LOG(ERR, "tx_rs_thresh must be less than the number "
2098                              "of TX descriptors minus 2. (tx_rs_thresh=%u "
2099                              "port=%d queue=%d)", (unsigned int)tx_rs_thresh,
2100                              (int)dev->data->port_id, (int)queue_idx);
2101                 return -(EINVAL);
2102         }
2103         if (tx_free_thresh >= (nb_desc - 3)) {
2104                 PMD_INIT_LOG(ERR, "tx_rs_thresh must be less than the "
2105                              "tx_free_thresh must be less than the number of "
2106                              "TX descriptors minus 3. (tx_free_thresh=%u "
2107                              "port=%d queue=%d)",
2108                              (unsigned int)tx_free_thresh,
2109                              (int)dev->data->port_id, (int)queue_idx);
2110                 return -(EINVAL);
2111         }
2112         if (tx_rs_thresh > tx_free_thresh) {
2113                 PMD_INIT_LOG(ERR, "tx_rs_thresh must be less than or equal to "
2114                              "tx_free_thresh. (tx_free_thresh=%u "
2115                              "tx_rs_thresh=%u port=%d queue=%d)",
2116                              (unsigned int)tx_free_thresh,
2117                              (unsigned int)tx_rs_thresh,
2118                              (int)dev->data->port_id,
2119                              (int)queue_idx);
2120                 return -(EINVAL);
2121         }
2122         if ((nb_desc % tx_rs_thresh) != 0) {
2123                 PMD_INIT_LOG(ERR, "tx_rs_thresh must be a divisor of the "
2124                              "number of TX descriptors. (tx_rs_thresh=%u "
2125                              "port=%d queue=%d)", (unsigned int)tx_rs_thresh,
2126                              (int)dev->data->port_id, (int)queue_idx);
2127                 return -(EINVAL);
2128         }
2129
2130         /*
2131          * If rs_bit_thresh is greater than 1, then TX WTHRESH should be
2132          * set to 0. If WTHRESH is greater than zero, the RS bit is ignored
2133          * by the NIC and all descriptors are written back after the NIC
2134          * accumulates WTHRESH descriptors.
2135          */
2136         if ((tx_rs_thresh > 1) && (tx_conf->tx_thresh.wthresh != 0)) {
2137                 PMD_INIT_LOG(ERR, "TX WTHRESH must be set to 0 if "
2138                              "tx_rs_thresh is greater than 1. (tx_rs_thresh=%u "
2139                              "port=%d queue=%d)", (unsigned int)tx_rs_thresh,
2140                              (int)dev->data->port_id, (int)queue_idx);
2141                 return -(EINVAL);
2142         }
2143
2144         /* Free memory prior to re-allocation if needed... */
2145         if (dev->data->tx_queues[queue_idx] != NULL) {
2146                 ixgbe_tx_queue_release(dev->data->tx_queues[queue_idx]);
2147                 dev->data->tx_queues[queue_idx] = NULL;
2148         }
2149
2150         /* First allocate the tx queue data structure */
2151         txq = rte_zmalloc_socket("ethdev TX queue", sizeof(struct ixgbe_tx_queue),
2152                                  RTE_CACHE_LINE_SIZE, socket_id);
2153         if (txq == NULL)
2154                 return (-ENOMEM);
2155
2156         /*
2157          * Allocate TX ring hardware descriptors. A memzone large enough to
2158          * handle the maximum ring size is allocated in order to allow for
2159          * resizing in later calls to the queue setup function.
2160          */
2161         tz = ring_dma_zone_reserve(dev, "tx_ring", queue_idx,
2162                         sizeof(union ixgbe_adv_tx_desc) * IXGBE_MAX_RING_DESC,
2163                         socket_id);
2164         if (tz == NULL) {
2165                 ixgbe_tx_queue_release(txq);
2166                 return (-ENOMEM);
2167         }
2168
2169         txq->nb_tx_desc = nb_desc;
2170         txq->tx_rs_thresh = tx_rs_thresh;
2171         txq->tx_free_thresh = tx_free_thresh;
2172         txq->pthresh = tx_conf->tx_thresh.pthresh;
2173         txq->hthresh = tx_conf->tx_thresh.hthresh;
2174         txq->wthresh = tx_conf->tx_thresh.wthresh;
2175         txq->queue_id = queue_idx;
2176         txq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2177                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2178         txq->port_id = dev->data->port_id;
2179         txq->txq_flags = tx_conf->txq_flags;
2180         txq->ops = &def_txq_ops;
2181         txq->tx_deferred_start = tx_conf->tx_deferred_start;
2182
2183         /*
2184          * Modification to set VFTDT for virtual function if vf is detected
2185          */
2186         if (hw->mac.type == ixgbe_mac_82599_vf ||
2187             hw->mac.type == ixgbe_mac_X540_vf ||
2188             hw->mac.type == ixgbe_mac_X550_vf ||
2189             hw->mac.type == ixgbe_mac_X550EM_x_vf)
2190                 txq->tdt_reg_addr = IXGBE_PCI_REG_ADDR(hw, IXGBE_VFTDT(queue_idx));
2191         else
2192                 txq->tdt_reg_addr = IXGBE_PCI_REG_ADDR(hw, IXGBE_TDT(txq->reg_idx));
2193 #ifndef RTE_LIBRTE_XEN_DOM0
2194         txq->tx_ring_phys_addr = (uint64_t) tz->phys_addr;
2195 #else
2196         txq->tx_ring_phys_addr = rte_mem_phy2mch(tz->memseg_id, tz->phys_addr);
2197 #endif
2198         txq->tx_ring = (union ixgbe_adv_tx_desc *) tz->addr;
2199
2200         /* Allocate software ring */
2201         txq->sw_ring = rte_zmalloc_socket("txq->sw_ring",
2202                                 sizeof(struct ixgbe_tx_entry) * nb_desc,
2203                                 RTE_CACHE_LINE_SIZE, socket_id);
2204         if (txq->sw_ring == NULL) {
2205                 ixgbe_tx_queue_release(txq);
2206                 return (-ENOMEM);
2207         }
2208         PMD_INIT_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
2209                      txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr);
2210
2211         /* set up vector or scalar TX function as appropriate */
2212         ixgbe_set_tx_function(dev, txq);
2213
2214         txq->ops->reset(txq);
2215
2216         dev->data->tx_queues[queue_idx] = txq;
2217
2218
2219         return (0);
2220 }
2221
2222 /**
2223  * ixgbe_free_sc_cluster - free the not-yet-completed scattered cluster
2224  *
2225  * The "next" pointer of the last segment of (not-yet-completed) RSC clusters
2226  * in the sw_rsc_ring is not set to NULL but rather points to the next
2227  * mbuf of this RSC aggregation (that has not been completed yet and still
2228  * resides on the HW ring). So, instead of calling for rte_pktmbuf_free() we
2229  * will just free first "nb_segs" segments of the cluster explicitly by calling
2230  * an rte_pktmbuf_free_seg().
2231  *
2232  * @m scattered cluster head
2233  */
2234 static void __attribute__((cold))
2235 ixgbe_free_sc_cluster(struct rte_mbuf *m)
2236 {
2237         uint8_t i, nb_segs = m->nb_segs;
2238         struct rte_mbuf *next_seg;
2239
2240         for (i = 0; i < nb_segs; i++) {
2241                 next_seg = m->next;
2242                 rte_pktmbuf_free_seg(m);
2243                 m = next_seg;
2244         }
2245 }
2246
2247 static void __attribute__((cold))
2248 ixgbe_rx_queue_release_mbufs(struct ixgbe_rx_queue *rxq)
2249 {
2250         unsigned i;
2251
2252 #ifdef RTE_IXGBE_INC_VECTOR
2253         /* SSE Vector driver has a different way of releasing mbufs. */
2254         if (rxq->rx_using_sse) {
2255                 ixgbe_rx_queue_release_mbufs_vec(rxq);
2256                 return;
2257         }
2258 #endif
2259
2260         if (rxq->sw_ring != NULL) {
2261                 for (i = 0; i < rxq->nb_rx_desc; i++) {
2262                         if (rxq->sw_ring[i].mbuf != NULL) {
2263                                 rte_pktmbuf_free_seg(rxq->sw_ring[i].mbuf);
2264                                 rxq->sw_ring[i].mbuf = NULL;
2265                         }
2266                 }
2267                 if (rxq->rx_nb_avail) {
2268                         for (i = 0; i < rxq->rx_nb_avail; ++i) {
2269                                 struct rte_mbuf *mb;
2270                                 mb = rxq->rx_stage[rxq->rx_next_avail + i];
2271                                 rte_pktmbuf_free_seg(mb);
2272                         }
2273                         rxq->rx_nb_avail = 0;
2274                 }
2275         }
2276
2277         if (rxq->sw_sc_ring)
2278                 for (i = 0; i < rxq->nb_rx_desc; i++)
2279                         if (rxq->sw_sc_ring[i].fbuf) {
2280                                 ixgbe_free_sc_cluster(rxq->sw_sc_ring[i].fbuf);
2281                                 rxq->sw_sc_ring[i].fbuf = NULL;
2282                         }
2283 }
2284
2285 static void __attribute__((cold))
2286 ixgbe_rx_queue_release(struct ixgbe_rx_queue *rxq)
2287 {
2288         if (rxq != NULL) {
2289                 ixgbe_rx_queue_release_mbufs(rxq);
2290                 rte_free(rxq->sw_ring);
2291                 rte_free(rxq->sw_sc_ring);
2292                 rte_free(rxq);
2293         }
2294 }
2295
2296 void __attribute__((cold))
2297 ixgbe_dev_rx_queue_release(void *rxq)
2298 {
2299         ixgbe_rx_queue_release(rxq);
2300 }
2301
2302 /*
2303  * Check if Rx Burst Bulk Alloc function can be used.
2304  * Return
2305  *        0: the preconditions are satisfied and the bulk allocation function
2306  *           can be used.
2307  *  -EINVAL: the preconditions are NOT satisfied and the default Rx burst
2308  *           function must be used.
2309  */
2310 static inline int __attribute__((cold))
2311 check_rx_burst_bulk_alloc_preconditions(struct ixgbe_rx_queue *rxq)
2312 {
2313         int ret = 0;
2314
2315         /*
2316          * Make sure the following pre-conditions are satisfied:
2317          *   rxq->rx_free_thresh >= RTE_PMD_IXGBE_RX_MAX_BURST
2318          *   rxq->rx_free_thresh < rxq->nb_rx_desc
2319          *   (rxq->nb_rx_desc % rxq->rx_free_thresh) == 0
2320          *   rxq->nb_rx_desc<(IXGBE_MAX_RING_DESC-RTE_PMD_IXGBE_RX_MAX_BURST)
2321          * Scattered packets are not supported.  This should be checked
2322          * outside of this function.
2323          */
2324         if (!(rxq->rx_free_thresh >= RTE_PMD_IXGBE_RX_MAX_BURST)) {
2325                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2326                              "rxq->rx_free_thresh=%d, "
2327                              "RTE_PMD_IXGBE_RX_MAX_BURST=%d",
2328                              rxq->rx_free_thresh, RTE_PMD_IXGBE_RX_MAX_BURST);
2329                 ret = -EINVAL;
2330         } else if (!(rxq->rx_free_thresh < rxq->nb_rx_desc)) {
2331                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2332                              "rxq->rx_free_thresh=%d, "
2333                              "rxq->nb_rx_desc=%d",
2334                              rxq->rx_free_thresh, rxq->nb_rx_desc);
2335                 ret = -EINVAL;
2336         } else if (!((rxq->nb_rx_desc % rxq->rx_free_thresh) == 0)) {
2337                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2338                              "rxq->nb_rx_desc=%d, "
2339                              "rxq->rx_free_thresh=%d",
2340                              rxq->nb_rx_desc, rxq->rx_free_thresh);
2341                 ret = -EINVAL;
2342         } else if (!(rxq->nb_rx_desc <
2343                (IXGBE_MAX_RING_DESC - RTE_PMD_IXGBE_RX_MAX_BURST))) {
2344                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions: "
2345                              "rxq->nb_rx_desc=%d, "
2346                              "IXGBE_MAX_RING_DESC=%d, "
2347                              "RTE_PMD_IXGBE_RX_MAX_BURST=%d",
2348                              rxq->nb_rx_desc, IXGBE_MAX_RING_DESC,
2349                              RTE_PMD_IXGBE_RX_MAX_BURST);
2350                 ret = -EINVAL;
2351         }
2352
2353         return ret;
2354 }
2355
2356 /* Reset dynamic ixgbe_rx_queue fields back to defaults */
2357 static void __attribute__((cold))
2358 ixgbe_reset_rx_queue(struct ixgbe_adapter *adapter, struct ixgbe_rx_queue *rxq)
2359 {
2360         static const union ixgbe_adv_rx_desc zeroed_desc = {{0}};
2361         unsigned i;
2362         uint16_t len = rxq->nb_rx_desc;
2363
2364         /*
2365          * By default, the Rx queue setup function allocates enough memory for
2366          * IXGBE_MAX_RING_DESC.  The Rx Burst bulk allocation function requires
2367          * extra memory at the end of the descriptor ring to be zero'd out. A
2368          * pre-condition for using the Rx burst bulk alloc function is that the
2369          * number of descriptors is less than or equal to
2370          * (IXGBE_MAX_RING_DESC - RTE_PMD_IXGBE_RX_MAX_BURST). Check all the
2371          * constraints here to see if we need to zero out memory after the end
2372          * of the H/W descriptor ring.
2373          */
2374         if (adapter->rx_bulk_alloc_allowed)
2375                 /* zero out extra memory */
2376                 len += RTE_PMD_IXGBE_RX_MAX_BURST;
2377
2378         /*
2379          * Zero out HW ring memory. Zero out extra memory at the end of
2380          * the H/W ring so look-ahead logic in Rx Burst bulk alloc function
2381          * reads extra memory as zeros.
2382          */
2383         for (i = 0; i < len; i++) {
2384                 rxq->rx_ring[i] = zeroed_desc;
2385         }
2386
2387         /*
2388          * initialize extra software ring entries. Space for these extra
2389          * entries is always allocated
2390          */
2391         memset(&rxq->fake_mbuf, 0x0, sizeof(rxq->fake_mbuf));
2392         for (i = rxq->nb_rx_desc; i < len; ++i) {
2393                 rxq->sw_ring[i].mbuf = &rxq->fake_mbuf;
2394         }
2395
2396         rxq->rx_nb_avail = 0;
2397         rxq->rx_next_avail = 0;
2398         rxq->rx_free_trigger = (uint16_t)(rxq->rx_free_thresh - 1);
2399         rxq->rx_tail = 0;
2400         rxq->nb_rx_hold = 0;
2401         rxq->pkt_first_seg = NULL;
2402         rxq->pkt_last_seg = NULL;
2403 }
2404
2405 int __attribute__((cold))
2406 ixgbe_dev_rx_queue_setup(struct rte_eth_dev *dev,
2407                          uint16_t queue_idx,
2408                          uint16_t nb_desc,
2409                          unsigned int socket_id,
2410                          const struct rte_eth_rxconf *rx_conf,
2411                          struct rte_mempool *mp)
2412 {
2413         const struct rte_memzone *rz;
2414         struct ixgbe_rx_queue *rxq;
2415         struct ixgbe_hw     *hw;
2416         uint16_t len;
2417         struct ixgbe_adapter *adapter =
2418                 (struct ixgbe_adapter *)dev->data->dev_private;
2419
2420         PMD_INIT_FUNC_TRACE();
2421         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2422
2423         /*
2424          * Validate number of receive descriptors.
2425          * It must not exceed hardware maximum, and must be multiple
2426          * of IXGBE_ALIGN.
2427          */
2428         if (((nb_desc * sizeof(union ixgbe_adv_rx_desc)) % IXGBE_ALIGN) != 0 ||
2429             (nb_desc > IXGBE_MAX_RING_DESC) ||
2430             (nb_desc < IXGBE_MIN_RING_DESC)) {
2431                 return (-EINVAL);
2432         }
2433
2434         /* Free memory prior to re-allocation if needed... */
2435         if (dev->data->rx_queues[queue_idx] != NULL) {
2436                 ixgbe_rx_queue_release(dev->data->rx_queues[queue_idx]);
2437                 dev->data->rx_queues[queue_idx] = NULL;
2438         }
2439
2440         /* First allocate the rx queue data structure */
2441         rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct ixgbe_rx_queue),
2442                                  RTE_CACHE_LINE_SIZE, socket_id);
2443         if (rxq == NULL)
2444                 return (-ENOMEM);
2445         rxq->mb_pool = mp;
2446         rxq->nb_rx_desc = nb_desc;
2447         rxq->rx_free_thresh = rx_conf->rx_free_thresh;
2448         rxq->queue_id = queue_idx;
2449         rxq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
2450                 queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
2451         rxq->port_id = dev->data->port_id;
2452         rxq->crc_len = (uint8_t) ((dev->data->dev_conf.rxmode.hw_strip_crc) ?
2453                                                         0 : ETHER_CRC_LEN);
2454         rxq->drop_en = rx_conf->rx_drop_en;
2455         rxq->rx_deferred_start = rx_conf->rx_deferred_start;
2456
2457         /*
2458          * Allocate RX ring hardware descriptors. A memzone large enough to
2459          * handle the maximum ring size is allocated in order to allow for
2460          * resizing in later calls to the queue setup function.
2461          */
2462         rz = ring_dma_zone_reserve(dev, "rx_ring", queue_idx,
2463                                    RX_RING_SZ, socket_id);
2464         if (rz == NULL) {
2465                 ixgbe_rx_queue_release(rxq);
2466                 return (-ENOMEM);
2467         }
2468
2469         /*
2470          * Zero init all the descriptors in the ring.
2471          */
2472         memset (rz->addr, 0, RX_RING_SZ);
2473
2474         /*
2475          * Modified to setup VFRDT for Virtual Function
2476          */
2477         if (hw->mac.type == ixgbe_mac_82599_vf ||
2478             hw->mac.type == ixgbe_mac_X540_vf ||
2479             hw->mac.type == ixgbe_mac_X550_vf ||
2480             hw->mac.type == ixgbe_mac_X550EM_x_vf) {
2481                 rxq->rdt_reg_addr =
2482                         IXGBE_PCI_REG_ADDR(hw, IXGBE_VFRDT(queue_idx));
2483                 rxq->rdh_reg_addr =
2484                         IXGBE_PCI_REG_ADDR(hw, IXGBE_VFRDH(queue_idx));
2485         }
2486         else {
2487                 rxq->rdt_reg_addr =
2488                         IXGBE_PCI_REG_ADDR(hw, IXGBE_RDT(rxq->reg_idx));
2489                 rxq->rdh_reg_addr =
2490                         IXGBE_PCI_REG_ADDR(hw, IXGBE_RDH(rxq->reg_idx));
2491         }
2492 #ifndef RTE_LIBRTE_XEN_DOM0
2493         rxq->rx_ring_phys_addr = (uint64_t) rz->phys_addr;
2494 #else
2495         rxq->rx_ring_phys_addr = rte_mem_phy2mch(rz->memseg_id, rz->phys_addr);
2496 #endif
2497         rxq->rx_ring = (union ixgbe_adv_rx_desc *) rz->addr;
2498
2499         /*
2500          * Certain constraints must be met in order to use the bulk buffer
2501          * allocation Rx burst function. If any of Rx queues doesn't meet them
2502          * the feature should be disabled for the whole port.
2503          */
2504         if (check_rx_burst_bulk_alloc_preconditions(rxq)) {
2505                 PMD_INIT_LOG(DEBUG, "queue[%d] doesn't meet Rx Bulk Alloc "
2506                                     "preconditions - canceling the feature for "
2507                                     "the whole port[%d]",
2508                              rxq->queue_id, rxq->port_id);
2509                 adapter->rx_bulk_alloc_allowed = false;
2510         }
2511
2512         /*
2513          * Allocate software ring. Allow for space at the end of the
2514          * S/W ring to make sure look-ahead logic in bulk alloc Rx burst
2515          * function does not access an invalid memory region.
2516          */
2517         len = nb_desc;
2518         if (adapter->rx_bulk_alloc_allowed)
2519                 len += RTE_PMD_IXGBE_RX_MAX_BURST;
2520
2521         rxq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
2522                                           sizeof(struct ixgbe_rx_entry) * len,
2523                                           RTE_CACHE_LINE_SIZE, socket_id);
2524         if (!rxq->sw_ring) {
2525                 ixgbe_rx_queue_release(rxq);
2526                 return (-ENOMEM);
2527         }
2528
2529         /*
2530          * Always allocate even if it's not going to be needed in order to
2531          * simplify the code.
2532          *
2533          * This ring is used in LRO and Scattered Rx cases and Scattered Rx may
2534          * be requested in ixgbe_dev_rx_init(), which is called later from
2535          * dev_start() flow.
2536          */
2537         rxq->sw_sc_ring =
2538                 rte_zmalloc_socket("rxq->sw_sc_ring",
2539                                    sizeof(struct ixgbe_scattered_rx_entry) * len,
2540                                    RTE_CACHE_LINE_SIZE, socket_id);
2541         if (!rxq->sw_sc_ring) {
2542                 ixgbe_rx_queue_release(rxq);
2543                 return (-ENOMEM);
2544         }
2545
2546         PMD_INIT_LOG(DEBUG, "sw_ring=%p sw_sc_ring=%p hw_ring=%p "
2547                             "dma_addr=0x%"PRIx64,
2548                      rxq->sw_ring, rxq->sw_sc_ring, rxq->rx_ring,
2549                      rxq->rx_ring_phys_addr);
2550
2551         if (!rte_is_power_of_2(nb_desc)) {
2552                 PMD_INIT_LOG(DEBUG, "queue[%d] doesn't meet Vector Rx "
2553                                     "preconditions - canceling the feature for "
2554                                     "the whole port[%d]",
2555                              rxq->queue_id, rxq->port_id);
2556                 adapter->rx_vec_allowed = false;
2557         } else
2558                 ixgbe_rxq_vec_setup(rxq);
2559
2560         dev->data->rx_queues[queue_idx] = rxq;
2561
2562         ixgbe_reset_rx_queue(adapter, rxq);
2563
2564         return 0;
2565 }
2566
2567 uint32_t
2568 ixgbe_dev_rx_queue_count(struct rte_eth_dev *dev, uint16_t rx_queue_id)
2569 {
2570 #define IXGBE_RXQ_SCAN_INTERVAL 4
2571         volatile union ixgbe_adv_rx_desc *rxdp;
2572         struct ixgbe_rx_queue *rxq;
2573         uint32_t desc = 0;
2574
2575         if (rx_queue_id >= dev->data->nb_rx_queues) {
2576                 PMD_RX_LOG(ERR, "Invalid RX queue id=%d", rx_queue_id);
2577                 return 0;
2578         }
2579
2580         rxq = dev->data->rx_queues[rx_queue_id];
2581         rxdp = &(rxq->rx_ring[rxq->rx_tail]);
2582
2583         while ((desc < rxq->nb_rx_desc) &&
2584                 (rxdp->wb.upper.status_error & IXGBE_RXDADV_STAT_DD)) {
2585                 desc += IXGBE_RXQ_SCAN_INTERVAL;
2586                 rxdp += IXGBE_RXQ_SCAN_INTERVAL;
2587                 if (rxq->rx_tail + desc >= rxq->nb_rx_desc)
2588                         rxdp = &(rxq->rx_ring[rxq->rx_tail +
2589                                 desc - rxq->nb_rx_desc]);
2590         }
2591
2592         return desc;
2593 }
2594
2595 int
2596 ixgbe_dev_rx_descriptor_done(void *rx_queue, uint16_t offset)
2597 {
2598         volatile union ixgbe_adv_rx_desc *rxdp;
2599         struct ixgbe_rx_queue *rxq = rx_queue;
2600         uint32_t desc;
2601
2602         if (unlikely(offset >= rxq->nb_rx_desc))
2603                 return 0;
2604         desc = rxq->rx_tail + offset;
2605         if (desc >= rxq->nb_rx_desc)
2606                 desc -= rxq->nb_rx_desc;
2607
2608         rxdp = &rxq->rx_ring[desc];
2609         return !!(rxdp->wb.upper.status_error & IXGBE_RXDADV_STAT_DD);
2610 }
2611
2612 void __attribute__((cold))
2613 ixgbe_dev_clear_queues(struct rte_eth_dev *dev)
2614 {
2615         unsigned i;
2616         struct ixgbe_adapter *adapter =
2617                 (struct ixgbe_adapter *)dev->data->dev_private;
2618
2619         PMD_INIT_FUNC_TRACE();
2620
2621         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2622                 struct ixgbe_tx_queue *txq = dev->data->tx_queues[i];
2623                 if (txq != NULL) {
2624                         txq->ops->release_mbufs(txq);
2625                         txq->ops->reset(txq);
2626                 }
2627         }
2628
2629         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2630                 struct ixgbe_rx_queue *rxq = dev->data->rx_queues[i];
2631                 if (rxq != NULL) {
2632                         ixgbe_rx_queue_release_mbufs(rxq);
2633                         ixgbe_reset_rx_queue(adapter, rxq);
2634                 }
2635         }
2636 }
2637
2638 void
2639 ixgbe_dev_free_queues(struct rte_eth_dev *dev)
2640 {
2641         unsigned i;
2642
2643         PMD_INIT_FUNC_TRACE();
2644
2645         for (i = 0; i < dev->data->nb_rx_queues; i++) {
2646                 ixgbe_dev_rx_queue_release(dev->data->rx_queues[i]);
2647                 dev->data->rx_queues[i] = NULL;
2648         }
2649         dev->data->nb_rx_queues = 0;
2650
2651         for (i = 0; i < dev->data->nb_tx_queues; i++) {
2652                 ixgbe_dev_tx_queue_release(dev->data->tx_queues[i]);
2653                 dev->data->tx_queues[i] = NULL;
2654         }
2655         dev->data->nb_tx_queues = 0;
2656 }
2657
2658 /*********************************************************************
2659  *
2660  *  Device RX/TX init functions
2661  *
2662  **********************************************************************/
2663
2664 /**
2665  * Receive Side Scaling (RSS)
2666  * See section 7.1.2.8 in the following document:
2667  *     "Intel 82599 10 GbE Controller Datasheet" - Revision 2.1 October 2009
2668  *
2669  * Principles:
2670  * The source and destination IP addresses of the IP header and the source
2671  * and destination ports of TCP/UDP headers, if any, of received packets are
2672  * hashed against a configurable random key to compute a 32-bit RSS hash result.
2673  * The seven (7) LSBs of the 32-bit hash result are used as an index into a
2674  * 128-entry redirection table (RETA).  Each entry of the RETA provides a 3-bit
2675  * RSS output index which is used as the RX queue index where to store the
2676  * received packets.
2677  * The following output is supplied in the RX write-back descriptor:
2678  *     - 32-bit result of the Microsoft RSS hash function,
2679  *     - 4-bit RSS type field.
2680  */
2681
2682 /*
2683  * RSS random key supplied in section 7.1.2.8.3 of the Intel 82599 datasheet.
2684  * Used as the default key.
2685  */
2686 static uint8_t rss_intel_key[40] = {
2687         0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2,
2688         0x41, 0x67, 0x25, 0x3D, 0x43, 0xA3, 0x8F, 0xB0,
2689         0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
2690         0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C,
2691         0x6A, 0x42, 0xB7, 0x3B, 0xBE, 0xAC, 0x01, 0xFA,
2692 };
2693
2694 static void
2695 ixgbe_rss_disable(struct rte_eth_dev *dev)
2696 {
2697         struct ixgbe_hw *hw;
2698         uint32_t mrqc;
2699
2700         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2701         mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC);
2702         mrqc &= ~IXGBE_MRQC_RSSEN;
2703         IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
2704 }
2705
2706 static void
2707 ixgbe_hw_rss_hash_set(struct ixgbe_hw *hw, struct rte_eth_rss_conf *rss_conf)
2708 {
2709         uint8_t  *hash_key;
2710         uint32_t mrqc;
2711         uint32_t rss_key;
2712         uint64_t rss_hf;
2713         uint16_t i;
2714
2715         hash_key = rss_conf->rss_key;
2716         if (hash_key != NULL) {
2717                 /* Fill in RSS hash key */
2718                 for (i = 0; i < 10; i++) {
2719                         rss_key  = hash_key[(i * 4)];
2720                         rss_key |= hash_key[(i * 4) + 1] << 8;
2721                         rss_key |= hash_key[(i * 4) + 2] << 16;
2722                         rss_key |= hash_key[(i * 4) + 3] << 24;
2723                         IXGBE_WRITE_REG_ARRAY(hw, IXGBE_RSSRK(0), i, rss_key);
2724                 }
2725         }
2726
2727         /* Set configured hashing protocols in MRQC register */
2728         rss_hf = rss_conf->rss_hf;
2729         mrqc = IXGBE_MRQC_RSSEN; /* Enable RSS */
2730         if (rss_hf & ETH_RSS_IPV4)
2731                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4;
2732         if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
2733                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_TCP;
2734         if (rss_hf & ETH_RSS_IPV6)
2735                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6;
2736         if (rss_hf & ETH_RSS_IPV6_EX)
2737                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX;
2738         if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP)
2739                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_TCP;
2740         if (rss_hf & ETH_RSS_IPV6_TCP_EX)
2741                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP;
2742         if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
2743                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV4_UDP;
2744         if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP)
2745                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_UDP;
2746         if (rss_hf & ETH_RSS_IPV6_UDP_EX)
2747                 mrqc |= IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP;
2748         IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
2749 }
2750
2751 int
2752 ixgbe_dev_rss_hash_update(struct rte_eth_dev *dev,
2753                           struct rte_eth_rss_conf *rss_conf)
2754 {
2755         struct ixgbe_hw *hw;
2756         uint32_t mrqc;
2757         uint64_t rss_hf;
2758
2759         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2760
2761         /*
2762          * Excerpt from section 7.1.2.8 Receive-Side Scaling (RSS):
2763          *     "RSS enabling cannot be done dynamically while it must be
2764          *      preceded by a software reset"
2765          * Before changing anything, first check that the update RSS operation
2766          * does not attempt to disable RSS, if RSS was enabled at
2767          * initialization time, or does not attempt to enable RSS, if RSS was
2768          * disabled at initialization time.
2769          */
2770         rss_hf = rss_conf->rss_hf & IXGBE_RSS_OFFLOAD_ALL;
2771         mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC);
2772         if (!(mrqc & IXGBE_MRQC_RSSEN)) { /* RSS disabled */
2773                 if (rss_hf != 0) /* Enable RSS */
2774                         return -(EINVAL);
2775                 return 0; /* Nothing to do */
2776         }
2777         /* RSS enabled */
2778         if (rss_hf == 0) /* Disable RSS */
2779                 return -(EINVAL);
2780         ixgbe_hw_rss_hash_set(hw, rss_conf);
2781         return 0;
2782 }
2783
2784 int
2785 ixgbe_dev_rss_hash_conf_get(struct rte_eth_dev *dev,
2786                             struct rte_eth_rss_conf *rss_conf)
2787 {
2788         struct ixgbe_hw *hw;
2789         uint8_t *hash_key;
2790         uint32_t mrqc;
2791         uint32_t rss_key;
2792         uint64_t rss_hf;
2793         uint16_t i;
2794
2795         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2796         hash_key = rss_conf->rss_key;
2797         if (hash_key != NULL) {
2798                 /* Return RSS hash key */
2799                 for (i = 0; i < 10; i++) {
2800                         rss_key = IXGBE_READ_REG_ARRAY(hw, IXGBE_RSSRK(0), i);
2801                         hash_key[(i * 4)] = rss_key & 0x000000FF;
2802                         hash_key[(i * 4) + 1] = (rss_key >> 8) & 0x000000FF;
2803                         hash_key[(i * 4) + 2] = (rss_key >> 16) & 0x000000FF;
2804                         hash_key[(i * 4) + 3] = (rss_key >> 24) & 0x000000FF;
2805                 }
2806         }
2807
2808         /* Get RSS functions configured in MRQC register */
2809         mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC);
2810         if ((mrqc & IXGBE_MRQC_RSSEN) == 0) { /* RSS is disabled */
2811                 rss_conf->rss_hf = 0;
2812                 return 0;
2813         }
2814         rss_hf = 0;
2815         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV4)
2816                 rss_hf |= ETH_RSS_IPV4;
2817         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV4_TCP)
2818                 rss_hf |= ETH_RSS_NONFRAG_IPV4_TCP;
2819         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6)
2820                 rss_hf |= ETH_RSS_IPV6;
2821         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6_EX)
2822                 rss_hf |= ETH_RSS_IPV6_EX;
2823         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6_TCP)
2824                 rss_hf |= ETH_RSS_NONFRAG_IPV6_TCP;
2825         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6_EX_TCP)
2826                 rss_hf |= ETH_RSS_IPV6_TCP_EX;
2827         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV4_UDP)
2828                 rss_hf |= ETH_RSS_NONFRAG_IPV4_UDP;
2829         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6_UDP)
2830                 rss_hf |= ETH_RSS_NONFRAG_IPV6_UDP;
2831         if (mrqc & IXGBE_MRQC_RSS_FIELD_IPV6_EX_UDP)
2832                 rss_hf |= ETH_RSS_IPV6_UDP_EX;
2833         rss_conf->rss_hf = rss_hf;
2834         return 0;
2835 }
2836
2837 static void
2838 ixgbe_rss_configure(struct rte_eth_dev *dev)
2839 {
2840         struct rte_eth_rss_conf rss_conf;
2841         struct ixgbe_hw *hw;
2842         uint32_t reta;
2843         uint16_t i;
2844         uint16_t j;
2845
2846         PMD_INIT_FUNC_TRACE();
2847         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2848
2849         /*
2850          * Fill in redirection table
2851          * The byte-swap is needed because NIC registers are in
2852          * little-endian order.
2853          */
2854         reta = 0;
2855         for (i = 0, j = 0; i < 128; i++, j++) {
2856                 if (j == dev->data->nb_rx_queues)
2857                         j = 0;
2858                 reta = (reta << 8) | j;
2859                 if ((i & 3) == 3)
2860                         IXGBE_WRITE_REG(hw, IXGBE_RETA(i >> 2),
2861                                         rte_bswap32(reta));
2862         }
2863
2864         /*
2865          * Configure the RSS key and the RSS protocols used to compute
2866          * the RSS hash of input packets.
2867          */
2868         rss_conf = dev->data->dev_conf.rx_adv_conf.rss_conf;
2869         if ((rss_conf.rss_hf & IXGBE_RSS_OFFLOAD_ALL) == 0) {
2870                 ixgbe_rss_disable(dev);
2871                 return;
2872         }
2873         if (rss_conf.rss_key == NULL)
2874                 rss_conf.rss_key = rss_intel_key; /* Default hash key */
2875         ixgbe_hw_rss_hash_set(hw, &rss_conf);
2876 }
2877
2878 #define NUM_VFTA_REGISTERS 128
2879 #define NIC_RX_BUFFER_SIZE 0x200
2880
2881 static void
2882 ixgbe_vmdq_dcb_configure(struct rte_eth_dev *dev)
2883 {
2884         struct rte_eth_vmdq_dcb_conf *cfg;
2885         struct ixgbe_hw *hw;
2886         enum rte_eth_nb_pools num_pools;
2887         uint32_t mrqc, vt_ctl, queue_mapping, vlanctrl;
2888         uint16_t pbsize;
2889         uint8_t nb_tcs; /* number of traffic classes */
2890         int i;
2891
2892         PMD_INIT_FUNC_TRACE();
2893         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
2894         cfg = &dev->data->dev_conf.rx_adv_conf.vmdq_dcb_conf;
2895         num_pools = cfg->nb_queue_pools;
2896         /* Check we have a valid number of pools */
2897         if (num_pools != ETH_16_POOLS && num_pools != ETH_32_POOLS) {
2898                 ixgbe_rss_disable(dev);
2899                 return;
2900         }
2901         /* 16 pools -> 8 traffic classes, 32 pools -> 4 traffic classes */
2902         nb_tcs = (uint8_t)(ETH_VMDQ_DCB_NUM_QUEUES / (int)num_pools);
2903
2904         /*
2905          * RXPBSIZE
2906          * split rx buffer up into sections, each for 1 traffic class
2907          */
2908         pbsize = (uint16_t)(NIC_RX_BUFFER_SIZE / nb_tcs);
2909         for (i = 0 ; i < nb_tcs; i++) {
2910                 uint32_t rxpbsize = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i));
2911                 rxpbsize &= (~(0x3FF << IXGBE_RXPBSIZE_SHIFT));
2912                 /* clear 10 bits. */
2913                 rxpbsize |= (pbsize << IXGBE_RXPBSIZE_SHIFT); /* set value */
2914                 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpbsize);
2915         }
2916         /* zero alloc all unused TCs */
2917         for (i = nb_tcs; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
2918                 uint32_t rxpbsize = IXGBE_READ_REG(hw, IXGBE_RXPBSIZE(i));
2919                 rxpbsize &= (~( 0x3FF << IXGBE_RXPBSIZE_SHIFT ));
2920                 /* clear 10 bits. */
2921                 IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpbsize);
2922         }
2923
2924         /* MRQC: enable vmdq and dcb */
2925         mrqc = ((num_pools == ETH_16_POOLS) ? \
2926                 IXGBE_MRQC_VMDQRT8TCEN : IXGBE_MRQC_VMDQRT4TCEN );
2927         IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
2928
2929         /* PFVTCTL: turn on virtualisation and set the default pool */
2930         vt_ctl = IXGBE_VT_CTL_VT_ENABLE | IXGBE_VT_CTL_REPLEN;
2931         if (cfg->enable_default_pool) {
2932                 vt_ctl |= (cfg->default_pool << IXGBE_VT_CTL_POOL_SHIFT);
2933         } else {
2934                 vt_ctl |= IXGBE_VT_CTL_DIS_DEFPL;
2935         }
2936
2937         IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vt_ctl);
2938
2939         /* RTRUP2TC: mapping user priorities to traffic classes (TCs) */
2940         queue_mapping = 0;
2941         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++)
2942                 /*
2943                  * mapping is done with 3 bits per priority,
2944                  * so shift by i*3 each time
2945                  */
2946                 queue_mapping |= ((cfg->dcb_queue[i] & 0x07) << (i * 3));
2947
2948         IXGBE_WRITE_REG(hw, IXGBE_RTRUP2TC, queue_mapping);
2949
2950         /* RTRPCS: DCB related */
2951         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, IXGBE_RMCS_RRM);
2952
2953         /* VLNCTRL: enable vlan filtering and allow all vlan tags through */
2954         vlanctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
2955         vlanctrl |= IXGBE_VLNCTRL_VFE ; /* enable vlan filters */
2956         IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlanctrl);
2957
2958         /* VFTA - enable all vlan filters */
2959         for (i = 0; i < NUM_VFTA_REGISTERS; i++) {
2960                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 0xFFFFFFFF);
2961         }
2962
2963         /* VFRE: pool enabling for receive - 16 or 32 */
2964         IXGBE_WRITE_REG(hw, IXGBE_VFRE(0), \
2965                         num_pools == ETH_16_POOLS ? 0xFFFF : 0xFFFFFFFF);
2966
2967         /*
2968          * MPSAR - allow pools to read specific mac addresses
2969          * In this case, all pools should be able to read from mac addr 0
2970          */
2971         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(0), 0xFFFFFFFF);
2972         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(0), 0xFFFFFFFF);
2973
2974         /* PFVLVF, PFVLVFB: set up filters for vlan tags as configured */
2975         for (i = 0; i < cfg->nb_pool_maps; i++) {
2976                 /* set vlan id in VF register and set the valid bit */
2977                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(i), (IXGBE_VLVF_VIEN | \
2978                                 (cfg->pool_map[i].vlan_id & 0xFFF)));
2979                 /*
2980                  * Put the allowed pools in VFB reg. As we only have 16 or 32
2981                  * pools, we only need to use the first half of the register
2982                  * i.e. bits 0-31
2983                  */
2984                 IXGBE_WRITE_REG(hw, IXGBE_VLVFB(i*2), cfg->pool_map[i].pools);
2985         }
2986 }
2987
2988 /**
2989  * ixgbe_dcb_config_tx_hw_config - Configure general DCB TX parameters
2990  * @hw: pointer to hardware structure
2991  * @dcb_config: pointer to ixgbe_dcb_config structure
2992  */
2993 static void
2994 ixgbe_dcb_tx_hw_config(struct ixgbe_hw *hw,
2995                struct ixgbe_dcb_config *dcb_config)
2996 {
2997         uint32_t reg;
2998         uint32_t q;
2999
3000         PMD_INIT_FUNC_TRACE();
3001         if (hw->mac.type != ixgbe_mac_82598EB) {
3002                 /* Disable the Tx desc arbiter so that MTQC can be changed */
3003                 reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
3004                 reg |= IXGBE_RTTDCS_ARBDIS;
3005                 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
3006
3007                 /* Enable DCB for Tx with 8 TCs */
3008                 if (dcb_config->num_tcs.pg_tcs == 8) {
3009                         reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_8TC_8TQ;
3010                 }
3011                 else {
3012                         reg = IXGBE_MTQC_RT_ENA | IXGBE_MTQC_4TC_4TQ;
3013                 }
3014                 if (dcb_config->vt_mode)
3015                     reg |= IXGBE_MTQC_VT_ENA;
3016                 IXGBE_WRITE_REG(hw, IXGBE_MTQC, reg);
3017
3018                 /* Disable drop for all queues */
3019                 for (q = 0; q < 128; q++)
3020                         IXGBE_WRITE_REG(hw, IXGBE_QDE,
3021                      (IXGBE_QDE_WRITE | (q << IXGBE_QDE_IDX_SHIFT)));
3022
3023                 /* Enable the Tx desc arbiter */
3024                 reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
3025                 reg &= ~IXGBE_RTTDCS_ARBDIS;
3026                 IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
3027
3028                 /* Enable Security TX Buffer IFG for DCB */
3029                 reg = IXGBE_READ_REG(hw, IXGBE_SECTXMINIFG);
3030                 reg |= IXGBE_SECTX_DCB;
3031                 IXGBE_WRITE_REG(hw, IXGBE_SECTXMINIFG, reg);
3032         }
3033         return;
3034 }
3035
3036 /**
3037  * ixgbe_vmdq_dcb_hw_tx_config - Configure general VMDQ+DCB TX parameters
3038  * @dev: pointer to rte_eth_dev structure
3039  * @dcb_config: pointer to ixgbe_dcb_config structure
3040  */
3041 static void
3042 ixgbe_vmdq_dcb_hw_tx_config(struct rte_eth_dev *dev,
3043                         struct ixgbe_dcb_config *dcb_config)
3044 {
3045         struct rte_eth_vmdq_dcb_tx_conf *vmdq_tx_conf =
3046                         &dev->data->dev_conf.tx_adv_conf.vmdq_dcb_tx_conf;
3047         struct ixgbe_hw *hw =
3048                         IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3049
3050         PMD_INIT_FUNC_TRACE();
3051         if (hw->mac.type != ixgbe_mac_82598EB)
3052                 /*PF VF Transmit Enable*/
3053                 IXGBE_WRITE_REG(hw, IXGBE_VFTE(0),
3054                         vmdq_tx_conf->nb_queue_pools == ETH_16_POOLS ? 0xFFFF : 0xFFFFFFFF);
3055
3056         /*Configure general DCB TX parameters*/
3057         ixgbe_dcb_tx_hw_config(hw,dcb_config);
3058         return;
3059 }
3060
3061 static void
3062 ixgbe_vmdq_dcb_rx_config(struct rte_eth_dev *dev,
3063                         struct ixgbe_dcb_config *dcb_config)
3064 {
3065         struct rte_eth_vmdq_dcb_conf *vmdq_rx_conf =
3066                         &dev->data->dev_conf.rx_adv_conf.vmdq_dcb_conf;
3067         struct ixgbe_dcb_tc_config *tc;
3068         uint8_t i,j;
3069
3070         /* convert rte_eth_conf.rx_adv_conf to struct ixgbe_dcb_config */
3071         if (vmdq_rx_conf->nb_queue_pools == ETH_16_POOLS ) {
3072                 dcb_config->num_tcs.pg_tcs = ETH_8_TCS;
3073                 dcb_config->num_tcs.pfc_tcs = ETH_8_TCS;
3074         }
3075         else {
3076                 dcb_config->num_tcs.pg_tcs = ETH_4_TCS;
3077                 dcb_config->num_tcs.pfc_tcs = ETH_4_TCS;
3078         }
3079         /* User Priority to Traffic Class mapping */
3080         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3081                 j = vmdq_rx_conf->dcb_queue[i];
3082                 tc = &dcb_config->tc_config[j];
3083                 tc->path[IXGBE_DCB_RX_CONFIG].up_to_tc_bitmap =
3084                                                 (uint8_t)(1 << j);
3085         }
3086 }
3087
3088 static void
3089 ixgbe_dcb_vt_tx_config(struct rte_eth_dev *dev,
3090                         struct ixgbe_dcb_config *dcb_config)
3091 {
3092         struct rte_eth_vmdq_dcb_tx_conf *vmdq_tx_conf =
3093                         &dev->data->dev_conf.tx_adv_conf.vmdq_dcb_tx_conf;
3094         struct ixgbe_dcb_tc_config *tc;
3095         uint8_t i,j;
3096
3097         /* convert rte_eth_conf.rx_adv_conf to struct ixgbe_dcb_config */
3098         if (vmdq_tx_conf->nb_queue_pools == ETH_16_POOLS ) {
3099                 dcb_config->num_tcs.pg_tcs = ETH_8_TCS;
3100                 dcb_config->num_tcs.pfc_tcs = ETH_8_TCS;
3101         }
3102         else {
3103                 dcb_config->num_tcs.pg_tcs = ETH_4_TCS;
3104                 dcb_config->num_tcs.pfc_tcs = ETH_4_TCS;
3105         }
3106
3107         /* User Priority to Traffic Class mapping */
3108         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3109                 j = vmdq_tx_conf->dcb_queue[i];
3110                 tc = &dcb_config->tc_config[j];
3111                 tc->path[IXGBE_DCB_TX_CONFIG].up_to_tc_bitmap =
3112                                                 (uint8_t)(1 << j);
3113         }
3114         return;
3115 }
3116
3117 static void
3118 ixgbe_dcb_rx_config(struct rte_eth_dev *dev,
3119                 struct ixgbe_dcb_config *dcb_config)
3120 {
3121         struct rte_eth_dcb_rx_conf *rx_conf =
3122                         &dev->data->dev_conf.rx_adv_conf.dcb_rx_conf;
3123         struct ixgbe_dcb_tc_config *tc;
3124         uint8_t i,j;
3125
3126         dcb_config->num_tcs.pg_tcs = (uint8_t)rx_conf->nb_tcs;
3127         dcb_config->num_tcs.pfc_tcs = (uint8_t)rx_conf->nb_tcs;
3128
3129         /* User Priority to Traffic Class mapping */
3130         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3131                 j = rx_conf->dcb_queue[i];
3132                 tc = &dcb_config->tc_config[j];
3133                 tc->path[IXGBE_DCB_RX_CONFIG].up_to_tc_bitmap =
3134                                                 (uint8_t)(1 << j);
3135         }
3136 }
3137
3138 static void
3139 ixgbe_dcb_tx_config(struct rte_eth_dev *dev,
3140                 struct ixgbe_dcb_config *dcb_config)
3141 {
3142         struct rte_eth_dcb_tx_conf *tx_conf =
3143                         &dev->data->dev_conf.tx_adv_conf.dcb_tx_conf;
3144         struct ixgbe_dcb_tc_config *tc;
3145         uint8_t i,j;
3146
3147         dcb_config->num_tcs.pg_tcs = (uint8_t)tx_conf->nb_tcs;
3148         dcb_config->num_tcs.pfc_tcs = (uint8_t)tx_conf->nb_tcs;
3149
3150         /* User Priority to Traffic Class mapping */
3151         for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3152                 j = tx_conf->dcb_queue[i];
3153                 tc = &dcb_config->tc_config[j];
3154                 tc->path[IXGBE_DCB_TX_CONFIG].up_to_tc_bitmap =
3155                                                 (uint8_t)(1 << j);
3156         }
3157 }
3158
3159 /**
3160  * ixgbe_dcb_rx_hw_config - Configure general DCB RX HW parameters
3161  * @hw: pointer to hardware structure
3162  * @dcb_config: pointer to ixgbe_dcb_config structure
3163  */
3164 static void
3165 ixgbe_dcb_rx_hw_config(struct ixgbe_hw *hw,
3166                struct ixgbe_dcb_config *dcb_config)
3167 {
3168         uint32_t reg;
3169         uint32_t vlanctrl;
3170         uint8_t i;
3171
3172         PMD_INIT_FUNC_TRACE();
3173         /*
3174          * Disable the arbiter before changing parameters
3175          * (always enable recycle mode; WSP)
3176          */
3177         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC | IXGBE_RTRPCS_ARBDIS;
3178         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
3179
3180         if (hw->mac.type != ixgbe_mac_82598EB) {
3181                 reg = IXGBE_READ_REG(hw, IXGBE_MRQC);
3182                 if (dcb_config->num_tcs.pg_tcs == 4) {
3183                         if (dcb_config->vt_mode)
3184                                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
3185                                         IXGBE_MRQC_VMDQRT4TCEN;
3186                         else {
3187                                 IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, 0);
3188                                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
3189                                         IXGBE_MRQC_RT4TCEN;
3190                         }
3191                 }
3192                 if (dcb_config->num_tcs.pg_tcs == 8) {
3193                         if (dcb_config->vt_mode)
3194                                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
3195                                         IXGBE_MRQC_VMDQRT8TCEN;
3196                         else {
3197                                 IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, 0);
3198                                 reg = (reg & ~IXGBE_MRQC_MRQE_MASK) |
3199                                         IXGBE_MRQC_RT8TCEN;
3200                         }
3201                 }
3202
3203                 IXGBE_WRITE_REG(hw, IXGBE_MRQC, reg);
3204         }
3205
3206         /* VLNCTRL: enable vlan filtering and allow all vlan tags through */
3207         vlanctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
3208         vlanctrl |= IXGBE_VLNCTRL_VFE ; /* enable vlan filters */
3209         IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlanctrl);
3210
3211         /* VFTA - enable all vlan filters */
3212         for (i = 0; i < NUM_VFTA_REGISTERS; i++) {
3213                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), 0xFFFFFFFF);
3214         }
3215
3216         /*
3217          * Configure Rx packet plane (recycle mode; WSP) and
3218          * enable arbiter
3219          */
3220         reg = IXGBE_RTRPCS_RRM | IXGBE_RTRPCS_RAC;
3221         IXGBE_WRITE_REG(hw, IXGBE_RTRPCS, reg);
3222
3223         return;
3224 }
3225
3226 static void
3227 ixgbe_dcb_hw_arbite_rx_config(struct ixgbe_hw *hw, uint16_t *refill,
3228                         uint16_t *max,uint8_t *bwg_id, uint8_t *tsa, uint8_t *map)
3229 {
3230         switch (hw->mac.type) {
3231         case ixgbe_mac_82598EB:
3232                 ixgbe_dcb_config_rx_arbiter_82598(hw, refill, max, tsa);
3233                 break;
3234         case ixgbe_mac_82599EB:
3235         case ixgbe_mac_X540:
3236         case ixgbe_mac_X550:
3237         case ixgbe_mac_X550EM_x:
3238                 ixgbe_dcb_config_rx_arbiter_82599(hw, refill, max, bwg_id,
3239                                                   tsa, map);
3240                 break;
3241         default:
3242                 break;
3243         }
3244 }
3245
3246 static void
3247 ixgbe_dcb_hw_arbite_tx_config(struct ixgbe_hw *hw, uint16_t *refill, uint16_t *max,
3248                             uint8_t *bwg_id, uint8_t *tsa, uint8_t *map)
3249 {
3250         switch (hw->mac.type) {
3251         case ixgbe_mac_82598EB:
3252                 ixgbe_dcb_config_tx_desc_arbiter_82598(hw, refill, max, bwg_id,tsa);
3253                 ixgbe_dcb_config_tx_data_arbiter_82598(hw, refill, max, bwg_id,tsa);
3254                 break;
3255         case ixgbe_mac_82599EB:
3256         case ixgbe_mac_X540:
3257         case ixgbe_mac_X550:
3258         case ixgbe_mac_X550EM_x:
3259                 ixgbe_dcb_config_tx_desc_arbiter_82599(hw, refill, max, bwg_id,tsa);
3260                 ixgbe_dcb_config_tx_data_arbiter_82599(hw, refill, max, bwg_id,tsa, map);
3261                 break;
3262         default:
3263                 break;
3264         }
3265 }
3266
3267 #define DCB_RX_CONFIG  1
3268 #define DCB_TX_CONFIG  1
3269 #define DCB_TX_PB      1024
3270 /**
3271  * ixgbe_dcb_hw_configure - Enable DCB and configure
3272  * general DCB in VT mode and non-VT mode parameters
3273  * @dev: pointer to rte_eth_dev structure
3274  * @dcb_config: pointer to ixgbe_dcb_config structure
3275  */
3276 static int
3277 ixgbe_dcb_hw_configure(struct rte_eth_dev *dev,
3278                         struct ixgbe_dcb_config *dcb_config)
3279 {
3280         int     ret = 0;
3281         uint8_t i,pfc_en,nb_tcs;
3282         uint16_t pbsize;
3283         uint8_t config_dcb_rx = 0;
3284         uint8_t config_dcb_tx = 0;
3285         uint8_t tsa[IXGBE_DCB_MAX_TRAFFIC_CLASS] = {0};
3286         uint8_t bwgid[IXGBE_DCB_MAX_TRAFFIC_CLASS] = {0};
3287         uint16_t refill[IXGBE_DCB_MAX_TRAFFIC_CLASS] = {0};
3288         uint16_t max[IXGBE_DCB_MAX_TRAFFIC_CLASS] = {0};
3289         uint8_t map[IXGBE_DCB_MAX_TRAFFIC_CLASS] = {0};
3290         struct ixgbe_dcb_tc_config *tc;
3291         uint32_t max_frame = dev->data->mtu + ETHER_HDR_LEN + ETHER_CRC_LEN;
3292         struct ixgbe_hw *hw =
3293                         IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3294
3295         switch(dev->data->dev_conf.rxmode.mq_mode){
3296         case ETH_MQ_RX_VMDQ_DCB:
3297                 dcb_config->vt_mode = true;
3298                 if (hw->mac.type != ixgbe_mac_82598EB) {
3299                         config_dcb_rx = DCB_RX_CONFIG;
3300                         /*
3301                          *get dcb and VT rx configuration parameters
3302                          *from rte_eth_conf
3303                          */
3304                         ixgbe_vmdq_dcb_rx_config(dev,dcb_config);
3305                         /*Configure general VMDQ and DCB RX parameters*/
3306                         ixgbe_vmdq_dcb_configure(dev);
3307                 }
3308                 break;
3309         case ETH_MQ_RX_DCB:
3310                 dcb_config->vt_mode = false;
3311                 config_dcb_rx = DCB_RX_CONFIG;
3312                 /* Get dcb TX configuration parameters from rte_eth_conf */
3313                 ixgbe_dcb_rx_config(dev,dcb_config);
3314                 /*Configure general DCB RX parameters*/
3315                 ixgbe_dcb_rx_hw_config(hw, dcb_config);
3316                 break;
3317         default:
3318                 PMD_INIT_LOG(ERR, "Incorrect DCB RX mode configuration");
3319                 break;
3320         }
3321         switch (dev->data->dev_conf.txmode.mq_mode) {
3322         case ETH_MQ_TX_VMDQ_DCB:
3323                 dcb_config->vt_mode = true;
3324                 config_dcb_tx = DCB_TX_CONFIG;
3325                 /* get DCB and VT TX configuration parameters from rte_eth_conf */
3326                 ixgbe_dcb_vt_tx_config(dev,dcb_config);
3327                 /*Configure general VMDQ and DCB TX parameters*/
3328                 ixgbe_vmdq_dcb_hw_tx_config(dev,dcb_config);
3329                 break;
3330
3331         case ETH_MQ_TX_DCB:
3332                 dcb_config->vt_mode = false;
3333                 config_dcb_tx = DCB_TX_CONFIG;
3334                 /*get DCB TX configuration parameters from rte_eth_conf*/
3335                 ixgbe_dcb_tx_config(dev,dcb_config);
3336                 /*Configure general DCB TX parameters*/
3337                 ixgbe_dcb_tx_hw_config(hw, dcb_config);
3338                 break;
3339         default:
3340                 PMD_INIT_LOG(ERR, "Incorrect DCB TX mode configuration");
3341                 break;
3342         }
3343
3344         nb_tcs = dcb_config->num_tcs.pfc_tcs;
3345         /* Unpack map */
3346         ixgbe_dcb_unpack_map_cee(dcb_config, IXGBE_DCB_RX_CONFIG, map);
3347         if(nb_tcs == ETH_4_TCS) {
3348                 /* Avoid un-configured priority mapping to TC0 */
3349                 uint8_t j = 4;
3350                 uint8_t mask = 0xFF;
3351                 for (i = 0; i < ETH_DCB_NUM_USER_PRIORITIES - 4; i++)
3352                         mask = (uint8_t)(mask & (~ (1 << map[i])));
3353                 for (i = 0; mask && (i < IXGBE_DCB_MAX_TRAFFIC_CLASS); i++) {
3354                         if ((mask & 0x1) && (j < ETH_DCB_NUM_USER_PRIORITIES))
3355                                 map[j++] = i;
3356                         mask >>= 1;
3357                 }
3358                 /* Re-configure 4 TCs BW */
3359                 for (i = 0; i < nb_tcs; i++) {
3360                         tc = &dcb_config->tc_config[i];
3361                         tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent =
3362                                                 (uint8_t)(100 / nb_tcs);
3363                         tc->path[IXGBE_DCB_RX_CONFIG].bwg_percent =
3364                                                 (uint8_t)(100 / nb_tcs);
3365                 }
3366                 for (; i < IXGBE_DCB_MAX_TRAFFIC_CLASS; i++) {
3367                         tc = &dcb_config->tc_config[i];
3368                         tc->path[IXGBE_DCB_TX_CONFIG].bwg_percent = 0;
3369                         tc->path[IXGBE_DCB_RX_CONFIG].bwg_percent = 0;
3370                 }
3371         }
3372
3373         if(config_dcb_rx) {
3374                 /* Set RX buffer size */
3375                 pbsize = (uint16_t)(NIC_RX_BUFFER_SIZE / nb_tcs);
3376                 uint32_t rxpbsize = pbsize << IXGBE_RXPBSIZE_SHIFT;
3377                 for (i = 0 ; i < nb_tcs; i++) {
3378                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), rxpbsize);
3379                 }
3380                 /* zero alloc all unused TCs */
3381                 for (; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3382                         IXGBE_WRITE_REG(hw, IXGBE_RXPBSIZE(i), 0);
3383                 }
3384         }
3385         if(config_dcb_tx) {
3386                 /* Only support an equally distributed Tx packet buffer strategy. */
3387                 uint32_t txpktsize = IXGBE_TXPBSIZE_MAX / nb_tcs;
3388                 uint32_t txpbthresh = (txpktsize / DCB_TX_PB) - IXGBE_TXPKT_SIZE_MAX;
3389                 for (i = 0; i < nb_tcs; i++) {
3390                         IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), txpktsize);
3391                         IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), txpbthresh);
3392                 }
3393                 /* Clear unused TCs, if any, to zero buffer size*/
3394                 for (; i < ETH_DCB_NUM_USER_PRIORITIES; i++) {
3395                         IXGBE_WRITE_REG(hw, IXGBE_TXPBSIZE(i), 0);
3396                         IXGBE_WRITE_REG(hw, IXGBE_TXPBTHRESH(i), 0);
3397                 }
3398         }
3399
3400         /*Calculates traffic class credits*/
3401         ixgbe_dcb_calculate_tc_credits_cee(hw, dcb_config,max_frame,
3402                                 IXGBE_DCB_TX_CONFIG);
3403         ixgbe_dcb_calculate_tc_credits_cee(hw, dcb_config,max_frame,
3404                                 IXGBE_DCB_RX_CONFIG);
3405
3406         if(config_dcb_rx) {
3407                 /* Unpack CEE standard containers */
3408                 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_RX_CONFIG, refill);
3409                 ixgbe_dcb_unpack_max_cee(dcb_config, max);
3410                 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_RX_CONFIG, bwgid);
3411                 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_RX_CONFIG, tsa);
3412                 /* Configure PG(ETS) RX */
3413                 ixgbe_dcb_hw_arbite_rx_config(hw,refill,max,bwgid,tsa,map);
3414         }
3415
3416         if(config_dcb_tx) {
3417                 /* Unpack CEE standard containers */
3418                 ixgbe_dcb_unpack_refill_cee(dcb_config, IXGBE_DCB_TX_CONFIG, refill);
3419                 ixgbe_dcb_unpack_max_cee(dcb_config, max);
3420                 ixgbe_dcb_unpack_bwgid_cee(dcb_config, IXGBE_DCB_TX_CONFIG, bwgid);
3421                 ixgbe_dcb_unpack_tsa_cee(dcb_config, IXGBE_DCB_TX_CONFIG, tsa);
3422                 /* Configure PG(ETS) TX */
3423                 ixgbe_dcb_hw_arbite_tx_config(hw,refill,max,bwgid,tsa,map);
3424         }
3425
3426         /*Configure queue statistics registers*/
3427         ixgbe_dcb_config_tc_stats_82599(hw, dcb_config);
3428
3429         /* Check if the PFC is supported */
3430         if(dev->data->dev_conf.dcb_capability_en & ETH_DCB_PFC_SUPPORT) {
3431                 pbsize = (uint16_t) (NIC_RX_BUFFER_SIZE / nb_tcs);
3432                 for (i = 0; i < nb_tcs; i++) {
3433                         /*
3434                         * If the TC count is 8,and the default high_water is 48,
3435                         * the low_water is 16 as default.
3436                         */
3437                         hw->fc.high_water[i] = (pbsize * 3 ) / 4;
3438                         hw->fc.low_water[i] = pbsize / 4;
3439                         /* Enable pfc for this TC */
3440                         tc = &dcb_config->tc_config[i];
3441                         tc->pfc = ixgbe_dcb_pfc_enabled;
3442                 }
3443                 ixgbe_dcb_unpack_pfc_cee(dcb_config, map, &pfc_en);
3444                 if(dcb_config->num_tcs.pfc_tcs == ETH_4_TCS)
3445                         pfc_en &= 0x0F;
3446                 ret = ixgbe_dcb_config_pfc(hw, pfc_en, map);
3447         }
3448
3449         return ret;
3450 }
3451
3452 /**
3453  * ixgbe_configure_dcb - Configure DCB  Hardware
3454  * @dev: pointer to rte_eth_dev
3455  */
3456 void ixgbe_configure_dcb(struct rte_eth_dev *dev)
3457 {
3458         struct ixgbe_dcb_config *dcb_cfg =
3459                         IXGBE_DEV_PRIVATE_TO_DCB_CFG(dev->data->dev_private);
3460         struct rte_eth_conf *dev_conf = &(dev->data->dev_conf);
3461
3462         PMD_INIT_FUNC_TRACE();
3463
3464         /* check support mq_mode for DCB */
3465         if ((dev_conf->rxmode.mq_mode != ETH_MQ_RX_VMDQ_DCB) &&
3466             (dev_conf->rxmode.mq_mode != ETH_MQ_RX_DCB))
3467                 return;
3468
3469         if (dev->data->nb_rx_queues != ETH_DCB_NUM_QUEUES)
3470                 return;
3471
3472         /** Configure DCB hardware **/
3473         ixgbe_dcb_hw_configure(dev,dcb_cfg);
3474
3475         return;
3476 }
3477
3478 /*
3479  * VMDq only support for 10 GbE NIC.
3480  */
3481 static void
3482 ixgbe_vmdq_rx_hw_configure(struct rte_eth_dev *dev)
3483 {
3484         struct rte_eth_vmdq_rx_conf *cfg;
3485         struct ixgbe_hw *hw;
3486         enum rte_eth_nb_pools num_pools;
3487         uint32_t mrqc, vt_ctl, vlanctrl;
3488         uint32_t vmolr = 0;
3489         int i;
3490
3491         PMD_INIT_FUNC_TRACE();
3492         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3493         cfg = &dev->data->dev_conf.rx_adv_conf.vmdq_rx_conf;
3494         num_pools = cfg->nb_queue_pools;
3495
3496         ixgbe_rss_disable(dev);
3497
3498         /* MRQC: enable vmdq */
3499         mrqc = IXGBE_MRQC_VMDQEN;
3500         IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
3501
3502         /* PFVTCTL: turn on virtualisation and set the default pool */
3503         vt_ctl = IXGBE_VT_CTL_VT_ENABLE | IXGBE_VT_CTL_REPLEN;
3504         if (cfg->enable_default_pool)
3505                 vt_ctl |= (cfg->default_pool << IXGBE_VT_CTL_POOL_SHIFT);
3506         else
3507                 vt_ctl |= IXGBE_VT_CTL_DIS_DEFPL;
3508
3509         IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vt_ctl);
3510
3511         for (i = 0; i < (int)num_pools; i++) {
3512                 vmolr = ixgbe_convert_vm_rx_mask_to_val(cfg->rx_mode, vmolr);
3513                 IXGBE_WRITE_REG(hw, IXGBE_VMOLR(i), vmolr);
3514         }
3515
3516         /* VLNCTRL: enable vlan filtering and allow all vlan tags through */
3517         vlanctrl = IXGBE_READ_REG(hw, IXGBE_VLNCTRL);
3518         vlanctrl |= IXGBE_VLNCTRL_VFE ; /* enable vlan filters */
3519         IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlanctrl);
3520
3521         /* VFTA - enable all vlan filters */
3522         for (i = 0; i < NUM_VFTA_REGISTERS; i++)
3523                 IXGBE_WRITE_REG(hw, IXGBE_VFTA(i), UINT32_MAX);
3524
3525         /* VFRE: pool enabling for receive - 64 */
3526         IXGBE_WRITE_REG(hw, IXGBE_VFRE(0), UINT32_MAX);
3527         if (num_pools == ETH_64_POOLS)
3528                 IXGBE_WRITE_REG(hw, IXGBE_VFRE(1), UINT32_MAX);
3529
3530         /*
3531          * MPSAR - allow pools to read specific mac addresses
3532          * In this case, all pools should be able to read from mac addr 0
3533          */
3534         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_LO(0), UINT32_MAX);
3535         IXGBE_WRITE_REG(hw, IXGBE_MPSAR_HI(0), UINT32_MAX);
3536
3537         /* PFVLVF, PFVLVFB: set up filters for vlan tags as configured */
3538         for (i = 0; i < cfg->nb_pool_maps; i++) {
3539                 /* set vlan id in VF register and set the valid bit */
3540                 IXGBE_WRITE_REG(hw, IXGBE_VLVF(i), (IXGBE_VLVF_VIEN | \
3541                                 (cfg->pool_map[i].vlan_id & IXGBE_RXD_VLAN_ID_MASK)));
3542                 /*
3543                  * Put the allowed pools in VFB reg. As we only have 16 or 64
3544                  * pools, we only need to use the first half of the register
3545                  * i.e. bits 0-31
3546                  */
3547                 if (((cfg->pool_map[i].pools >> 32) & UINT32_MAX) == 0)
3548                         IXGBE_WRITE_REG(hw, IXGBE_VLVFB(i*2), \
3549                                         (cfg->pool_map[i].pools & UINT32_MAX));
3550                 else
3551                         IXGBE_WRITE_REG(hw, IXGBE_VLVFB((i*2+1)), \
3552                                         ((cfg->pool_map[i].pools >> 32) \
3553                                         & UINT32_MAX));
3554
3555         }
3556
3557         /* PFDMA Tx General Switch Control Enables VMDQ loopback */
3558         if (cfg->enable_loop_back) {
3559                 IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
3560                 for (i = 0; i < RTE_IXGBE_VMTXSW_REGISTER_COUNT; i++)
3561                         IXGBE_WRITE_REG(hw, IXGBE_VMTXSW(i), UINT32_MAX);
3562         }
3563
3564         IXGBE_WRITE_FLUSH(hw);
3565 }
3566
3567 /*
3568  * ixgbe_dcb_config_tx_hw_config - Configure general VMDq TX parameters
3569  * @hw: pointer to hardware structure
3570  */
3571 static void
3572 ixgbe_vmdq_tx_hw_configure(struct ixgbe_hw *hw)
3573 {
3574         uint32_t reg;
3575         uint32_t q;
3576
3577         PMD_INIT_FUNC_TRACE();
3578         /*PF VF Transmit Enable*/
3579         IXGBE_WRITE_REG(hw, IXGBE_VFTE(0), UINT32_MAX);
3580         IXGBE_WRITE_REG(hw, IXGBE_VFTE(1), UINT32_MAX);
3581
3582         /* Disable the Tx desc arbiter so that MTQC can be changed */
3583         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
3584         reg |= IXGBE_RTTDCS_ARBDIS;
3585         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
3586
3587         reg = IXGBE_MTQC_VT_ENA | IXGBE_MTQC_64VF;
3588         IXGBE_WRITE_REG(hw, IXGBE_MTQC, reg);
3589
3590         /* Disable drop for all queues */
3591         for (q = 0; q < IXGBE_MAX_RX_QUEUE_NUM; q++)
3592                 IXGBE_WRITE_REG(hw, IXGBE_QDE,
3593                   (IXGBE_QDE_WRITE | (q << IXGBE_QDE_IDX_SHIFT)));
3594
3595         /* Enable the Tx desc arbiter */
3596         reg = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
3597         reg &= ~IXGBE_RTTDCS_ARBDIS;
3598         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, reg);
3599
3600         IXGBE_WRITE_FLUSH(hw);
3601
3602         return;
3603 }
3604
3605 static int __attribute__((cold))
3606 ixgbe_alloc_rx_queue_mbufs(struct ixgbe_rx_queue *rxq)
3607 {
3608         struct ixgbe_rx_entry *rxe = rxq->sw_ring;
3609         uint64_t dma_addr;
3610         unsigned i;
3611
3612         /* Initialize software ring entries */
3613         for (i = 0; i < rxq->nb_rx_desc; i++) {
3614                 volatile union ixgbe_adv_rx_desc *rxd;
3615                 struct rte_mbuf *mbuf = rte_rxmbuf_alloc(rxq->mb_pool);
3616                 if (mbuf == NULL) {
3617                         PMD_INIT_LOG(ERR, "RX mbuf alloc failed queue_id=%u",
3618                                      (unsigned) rxq->queue_id);
3619                         return (-ENOMEM);
3620                 }
3621
3622                 rte_mbuf_refcnt_set(mbuf, 1);
3623                 mbuf->next = NULL;
3624                 mbuf->data_off = RTE_PKTMBUF_HEADROOM;
3625                 mbuf->nb_segs = 1;
3626                 mbuf->port = rxq->port_id;
3627
3628                 dma_addr =
3629                         rte_cpu_to_le_64(RTE_MBUF_DATA_DMA_ADDR_DEFAULT(mbuf));
3630                 rxd = &rxq->rx_ring[i];
3631                 rxd->read.hdr_addr = dma_addr;
3632                 rxd->read.pkt_addr = dma_addr;
3633                 rxe[i].mbuf = mbuf;
3634         }
3635
3636         return 0;
3637 }
3638
3639 static int
3640 ixgbe_config_vf_rss(struct rte_eth_dev *dev)
3641 {
3642         struct ixgbe_hw *hw;
3643         uint32_t mrqc;
3644
3645         ixgbe_rss_configure(dev);
3646
3647         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3648
3649         /* MRQC: enable VF RSS */
3650         mrqc = IXGBE_READ_REG(hw, IXGBE_MRQC);
3651         mrqc &= ~IXGBE_MRQC_MRQE_MASK;
3652         switch (RTE_ETH_DEV_SRIOV(dev).active) {
3653         case ETH_64_POOLS:
3654                 mrqc |= IXGBE_MRQC_VMDQRSS64EN;
3655                 break;
3656
3657         case ETH_32_POOLS:
3658                 mrqc |= IXGBE_MRQC_VMDQRSS32EN;
3659                 break;
3660
3661         default:
3662                 PMD_INIT_LOG(ERR, "Invalid pool number in IOV mode with VMDQ RSS");
3663                 return -EINVAL;
3664         }
3665
3666         IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
3667
3668         return 0;
3669 }
3670
3671 static int
3672 ixgbe_config_vf_default(struct rte_eth_dev *dev)
3673 {
3674         struct ixgbe_hw *hw =
3675                 IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3676
3677         switch (RTE_ETH_DEV_SRIOV(dev).active) {
3678         case ETH_64_POOLS:
3679                 IXGBE_WRITE_REG(hw, IXGBE_MRQC,
3680                         IXGBE_MRQC_VMDQEN);
3681                 break;
3682
3683         case ETH_32_POOLS:
3684                 IXGBE_WRITE_REG(hw, IXGBE_MRQC,
3685                         IXGBE_MRQC_VMDQRT4TCEN);
3686                 break;
3687
3688         case ETH_16_POOLS:
3689                 IXGBE_WRITE_REG(hw, IXGBE_MRQC,
3690                         IXGBE_MRQC_VMDQRT8TCEN);
3691                 break;
3692         default:
3693                 PMD_INIT_LOG(ERR,
3694                         "invalid pool number in IOV mode");
3695                 break;
3696         }
3697         return 0;
3698 }
3699
3700 static int
3701 ixgbe_dev_mq_rx_configure(struct rte_eth_dev *dev)
3702 {
3703         struct ixgbe_hw *hw =
3704                 IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3705
3706         if (hw->mac.type == ixgbe_mac_82598EB)
3707                 return 0;
3708
3709         if (RTE_ETH_DEV_SRIOV(dev).active == 0) {
3710                 /*
3711                  * SRIOV inactive scheme
3712                  * any DCB/RSS w/o VMDq multi-queue setting
3713                  */
3714                 switch (dev->data->dev_conf.rxmode.mq_mode) {
3715                         case ETH_MQ_RX_RSS:
3716                                 ixgbe_rss_configure(dev);
3717                                 break;
3718
3719                         case ETH_MQ_RX_VMDQ_DCB:
3720                                 ixgbe_vmdq_dcb_configure(dev);
3721                                 break;
3722
3723                         case ETH_MQ_RX_VMDQ_ONLY:
3724                                 ixgbe_vmdq_rx_hw_configure(dev);
3725                                 break;
3726
3727                         case ETH_MQ_RX_NONE:
3728                                 /* if mq_mode is none, disable rss mode.*/
3729                         default: ixgbe_rss_disable(dev);
3730                 }
3731         } else {
3732                 /*
3733                  * SRIOV active scheme
3734                  * Support RSS together with VMDq & SRIOV
3735                  */
3736                 switch (dev->data->dev_conf.rxmode.mq_mode) {
3737                 case ETH_MQ_RX_RSS:
3738                 case ETH_MQ_RX_VMDQ_RSS:
3739                         ixgbe_config_vf_rss(dev);
3740                         break;
3741
3742                 /* FIXME if support DCB/RSS together with VMDq & SRIOV */
3743                 case ETH_MQ_RX_VMDQ_DCB:
3744                 case ETH_MQ_RX_VMDQ_DCB_RSS:
3745                         PMD_INIT_LOG(ERR,
3746                                 "Could not support DCB with VMDq & SRIOV");
3747                         return -1;
3748                 default:
3749                         ixgbe_config_vf_default(dev);
3750                         break;
3751                 }
3752         }
3753
3754         return 0;
3755 }
3756
3757 static int
3758 ixgbe_dev_mq_tx_configure(struct rte_eth_dev *dev)
3759 {
3760         struct ixgbe_hw *hw =
3761                 IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3762         uint32_t mtqc;
3763         uint32_t rttdcs;
3764
3765         if (hw->mac.type == ixgbe_mac_82598EB)
3766                 return 0;
3767
3768         /* disable arbiter before setting MTQC */
3769         rttdcs = IXGBE_READ_REG(hw, IXGBE_RTTDCS);
3770         rttdcs |= IXGBE_RTTDCS_ARBDIS;
3771         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs);
3772
3773         if (RTE_ETH_DEV_SRIOV(dev).active == 0) {
3774                 /*
3775                  * SRIOV inactive scheme
3776                  * any DCB w/o VMDq multi-queue setting
3777                  */
3778                 if (dev->data->dev_conf.txmode.mq_mode == ETH_MQ_TX_VMDQ_ONLY)
3779                         ixgbe_vmdq_tx_hw_configure(hw);
3780                 else {
3781                         mtqc = IXGBE_MTQC_64Q_1PB;
3782                         IXGBE_WRITE_REG(hw, IXGBE_MTQC, mtqc);
3783                 }
3784         } else {
3785                 switch (RTE_ETH_DEV_SRIOV(dev).active) {
3786
3787                 /*
3788                  * SRIOV active scheme
3789                  * FIXME if support DCB together with VMDq & SRIOV
3790                  */
3791                 case ETH_64_POOLS:
3792                         mtqc = IXGBE_MTQC_VT_ENA | IXGBE_MTQC_64VF;
3793                         break;
3794                 case ETH_32_POOLS:
3795                         mtqc = IXGBE_MTQC_VT_ENA | IXGBE_MTQC_32VF;
3796                         break;
3797                 case ETH_16_POOLS:
3798                         mtqc = IXGBE_MTQC_VT_ENA | IXGBE_MTQC_RT_ENA |
3799                                 IXGBE_MTQC_8TC_8TQ;
3800                         break;
3801                 default:
3802                         mtqc = IXGBE_MTQC_64Q_1PB;
3803                         PMD_INIT_LOG(ERR, "invalid pool number in IOV mode");
3804                 }
3805                 IXGBE_WRITE_REG(hw, IXGBE_MTQC, mtqc);
3806         }
3807
3808         /* re-enable arbiter */
3809         rttdcs &= ~IXGBE_RTTDCS_ARBDIS;
3810         IXGBE_WRITE_REG(hw, IXGBE_RTTDCS, rttdcs);
3811
3812         return 0;
3813 }
3814
3815 /**
3816  * ixgbe_get_rscctl_maxdesc - Calculate the RSCCTL[n].MAXDESC for PF
3817  *
3818  * Return the RSCCTL[n].MAXDESC for 82599 and x540 PF devices according to the
3819  * spec rev. 3.0 chapter 8.2.3.8.13.
3820  *
3821  * @pool Memory pool of the Rx queue
3822  */
3823 static inline uint32_t
3824 ixgbe_get_rscctl_maxdesc(struct rte_mempool *pool)
3825 {
3826         struct rte_pktmbuf_pool_private *mp_priv = rte_mempool_get_priv(pool);
3827
3828         /* MAXDESC * SRRCTL.BSIZEPKT must not exceed 64 KB minus one */
3829         uint16_t maxdesc =
3830                 IPV4_MAX_PKT_LEN /
3831                         (mp_priv->mbuf_data_room_size - RTE_PKTMBUF_HEADROOM);
3832
3833         if (maxdesc >= 16)
3834                 return IXGBE_RSCCTL_MAXDESC_16;
3835         else if (maxdesc >= 8)
3836                 return IXGBE_RSCCTL_MAXDESC_8;
3837         else if (maxdesc >= 4)
3838                 return IXGBE_RSCCTL_MAXDESC_4;
3839         else
3840                 return IXGBE_RSCCTL_MAXDESC_1;
3841 }
3842
3843 /**
3844  * ixgbe_set_ivar - Setup the correct IVAR register for a particular MSIX
3845  * interrupt
3846  *
3847  * (Taken from FreeBSD tree)
3848  * (yes this is all very magic and confusing :)
3849  *
3850  * @dev port handle
3851  * @entry the register array entry
3852  * @vector the MSIX vector for this queue
3853  * @type RX/TX/MISC
3854  */
3855 static void
3856 ixgbe_set_ivar(struct rte_eth_dev *dev, u8 entry, u8 vector, s8 type)
3857 {
3858         struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
3859         u32 ivar, index;
3860
3861         vector |= IXGBE_IVAR_ALLOC_VAL;
3862
3863         switch (hw->mac.type) {
3864
3865         case ixgbe_mac_82598EB:
3866                 if (type == -1)
3867                         entry = IXGBE_IVAR_OTHER_CAUSES_INDEX;
3868                 else
3869                         entry += (type * 64);
3870                 index = (entry >> 2) & 0x1F;
3871                 ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(index));
3872                 ivar &= ~(0xFF << (8 * (entry & 0x3)));
3873                 ivar |= (vector << (8 * (entry & 0x3)));
3874                 IXGBE_WRITE_REG(hw, IXGBE_IVAR(index), ivar);
3875                 break;
3876
3877         case ixgbe_mac_82599EB:
3878         case ixgbe_mac_X540:
3879                 if (type == -1) { /* MISC IVAR */
3880                         index = (entry & 1) * 8;
3881                         ivar = IXGBE_READ_REG(hw, IXGBE_IVAR_MISC);
3882                         ivar &= ~(0xFF << index);
3883                         ivar |= (vector << index);
3884                         IXGBE_WRITE_REG(hw, IXGBE_IVAR_MISC, ivar);
3885                 } else {        /* RX/TX IVARS */
3886                         index = (16 * (entry & 1)) + (8 * type);
3887                         ivar = IXGBE_READ_REG(hw, IXGBE_IVAR(entry >> 1));
3888                         ivar &= ~(0xFF << index);
3889                         ivar |= (vector << index);
3890                         IXGBE_WRITE_REG(hw, IXGBE_IVAR(entry >> 1), ivar);
3891                 }
3892
3893                 break;
3894
3895         default:
3896                 break;
3897         }
3898 }
3899
3900 void __attribute__((cold))
3901 ixgbe_set_rx_function(struct rte_eth_dev *dev)
3902 {
3903         uint16_t i, rx_using_sse;
3904         struct ixgbe_adapter *adapter =
3905                 (struct ixgbe_adapter *)dev->data->dev_private;
3906
3907         /*
3908          * In order to allow Vector Rx there are a few configuration
3909          * conditions to be met and Rx Bulk Allocation should be allowed.
3910          */
3911         if (ixgbe_rx_vec_dev_conf_condition_check(dev) ||
3912             !adapter->rx_bulk_alloc_allowed) {
3913                 PMD_INIT_LOG(DEBUG, "Port[%d] doesn't meet Vector Rx "
3914                                     "preconditions or RTE_IXGBE_INC_VECTOR is "
3915                                     "not enabled",
3916                              dev->data->port_id);
3917
3918                 adapter->rx_vec_allowed = false;
3919         }
3920
3921         /*
3922          * Initialize the appropriate LRO callback.
3923          *
3924          * If all queues satisfy the bulk allocation preconditions
3925          * (hw->rx_bulk_alloc_allowed is TRUE) then we may use bulk allocation.
3926          * Otherwise use a single allocation version.
3927          */
3928         if (dev->data->lro) {
3929                 if (adapter->rx_bulk_alloc_allowed) {
3930                         PMD_INIT_LOG(INFO, "LRO is requested. Using a bulk "
3931                                            "allocation version");
3932                         dev->rx_pkt_burst = ixgbe_recv_pkts_lro_bulk_alloc;
3933                 } else {
3934                         PMD_INIT_LOG(INFO, "LRO is requested. Using a single "
3935                                            "allocation version");
3936                         dev->rx_pkt_burst = ixgbe_recv_pkts_lro_single_alloc;
3937                 }
3938         } else if (dev->data->scattered_rx) {
3939                 /*
3940                  * Set the non-LRO scattered callback: there are Vector and
3941                  * single allocation versions.
3942                  */
3943                 if (adapter->rx_vec_allowed) {
3944                         PMD_INIT_LOG(DEBUG, "Using Vector Scattered Rx "
3945                                             "callback (port=%d).",
3946                                      dev->data->port_id);
3947
3948                         dev->rx_pkt_burst = ixgbe_recv_scattered_pkts_vec;
3949                 } else if (adapter->rx_bulk_alloc_allowed) {
3950                         PMD_INIT_LOG(INFO, "Using a Scattered with bulk "
3951                                            "allocation callback (port=%d).",
3952                                      dev->data->port_id);
3953                         dev->rx_pkt_burst = ixgbe_recv_pkts_lro_bulk_alloc;
3954                 } else {
3955                         PMD_INIT_LOG(DEBUG, "Using Regualr (non-vector, "
3956                                             "single allocation) "
3957                                             "Scattered Rx callback "
3958                                             "(port=%d).",
3959                                      dev->data->port_id);
3960
3961                         dev->rx_pkt_burst = ixgbe_recv_pkts_lro_single_alloc;
3962                 }
3963         /*
3964          * Below we set "simple" callbacks according to port/queues parameters.
3965          * If parameters allow we are going to choose between the following
3966          * callbacks:
3967          *    - Vector
3968          *    - Bulk Allocation
3969          *    - Single buffer allocation (the simplest one)
3970          */
3971         } else if (adapter->rx_vec_allowed) {
3972                 PMD_INIT_LOG(INFO, "Vector rx enabled, please make sure RX "
3973                                    "burst size no less than 32.");
3974
3975                 dev->rx_pkt_burst = ixgbe_recv_pkts_vec;
3976         } else if (adapter->rx_bulk_alloc_allowed) {
3977                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are "
3978                                     "satisfied. Rx Burst Bulk Alloc function "
3979                                     "will be used on port=%d.",
3980                              dev->data->port_id);
3981
3982                 dev->rx_pkt_burst = ixgbe_recv_pkts_bulk_alloc;
3983         } else {
3984                 PMD_INIT_LOG(DEBUG, "Rx Burst Bulk Alloc Preconditions are not "
3985                                     "satisfied, or Scattered Rx is requested "
3986                                     "(port=%d).",
3987                              dev->data->port_id);
3988
3989                 dev->rx_pkt_burst = ixgbe_recv_pkts;
3990         }
3991
3992         /* Propagate information about RX function choice through all queues. */
3993
3994         rx_using_sse =
3995                 (dev->rx_pkt_burst == ixgbe_recv_scattered_pkts_vec ||
3996                 dev->rx_pkt_burst == ixgbe_recv_pkts_vec);
3997
3998         for (i = 0; i < dev->data->nb_rx_queues; i++) {
3999                 struct ixgbe_rx_queue *rxq = dev->data->rx_queues[i];
4000                 rxq->rx_using_sse = rx_using_sse;
4001         }
4002 }
4003
4004 /**
4005  * ixgbe_set_rsc - configure RSC related port HW registers
4006  *
4007  * Configures the port's RSC related registers according to the 4.6.7.2 chapter
4008  * of 82599 Spec (x540 configuration is virtually the same).
4009  *
4010  * @dev port handle
4011  *
4012  * Returns 0 in case of success or a non-zero error code
4013  */
4014 static int
4015 ixgbe_set_rsc(struct rte_eth_dev *dev)
4016 {
4017         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
4018         struct ixgbe_hw *hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4019         struct rte_eth_dev_info dev_info = { 0 };
4020         bool rsc_capable = false;
4021         uint16_t i;
4022         uint32_t rdrxctl;
4023
4024         /* Sanity check */
4025         dev->dev_ops->dev_infos_get(dev, &dev_info);
4026         if (dev_info.rx_offload_capa & DEV_RX_OFFLOAD_TCP_LRO)
4027                 rsc_capable = true;
4028
4029         if (!rsc_capable && rx_conf->enable_lro) {
4030                 PMD_INIT_LOG(CRIT, "LRO is requested on HW that doesn't "
4031                                    "support it");
4032                 return -EINVAL;
4033         }
4034
4035         /* RSC global configuration (chapter 4.6.7.2.1 of 82599 Spec) */
4036
4037         if (!rx_conf->hw_strip_crc && rx_conf->enable_lro) {
4038                 /*
4039                  * According to chapter of 4.6.7.2.1 of the Spec Rev.
4040                  * 3.0 RSC configuration requires HW CRC stripping being
4041                  * enabled. If user requested both HW CRC stripping off
4042                  * and RSC on - return an error.
4043                  */
4044                 PMD_INIT_LOG(CRIT, "LRO can't be enabled when HW CRC "
4045                                     "is disabled");
4046                 return -EINVAL;
4047         }
4048
4049         /* RFCTL configuration  */
4050         if (rsc_capable) {
4051                 uint32_t rfctl = IXGBE_READ_REG(hw, IXGBE_RFCTL);
4052                 if (rx_conf->enable_lro)
4053                         /*
4054                          * Since NFS packets coalescing is not supported - clear
4055                          * RFCTL.NFSW_DIS and RFCTL.NFSR_DIS when RSC is
4056                          * enabled.
4057                          */
4058                         rfctl &= ~(IXGBE_RFCTL_RSC_DIS | IXGBE_RFCTL_NFSW_DIS |
4059                                    IXGBE_RFCTL_NFSR_DIS);
4060                 else
4061                         rfctl |= IXGBE_RFCTL_RSC_DIS;
4062
4063                 IXGBE_WRITE_REG(hw, IXGBE_RFCTL, rfctl);
4064         }
4065
4066         /* If LRO hasn't been requested - we are done here. */
4067         if (!rx_conf->enable_lro)
4068                 return 0;
4069
4070         /* Set RDRXCTL.RSCACKC bit */
4071         rdrxctl = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
4072         rdrxctl |= IXGBE_RDRXCTL_RSCACKC;
4073         IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rdrxctl);
4074
4075         /* Per-queue RSC configuration (chapter 4.6.7.2.2 of 82599 Spec) */
4076         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4077                 struct ixgbe_rx_queue *rxq = dev->data->rx_queues[i];
4078                 uint32_t srrctl =
4079                         IXGBE_READ_REG(hw, IXGBE_SRRCTL(rxq->reg_idx));
4080                 uint32_t rscctl =
4081                         IXGBE_READ_REG(hw, IXGBE_RSCCTL(rxq->reg_idx));
4082                 uint32_t psrtype =
4083                         IXGBE_READ_REG(hw, IXGBE_PSRTYPE(rxq->reg_idx));
4084                 uint32_t eitr =
4085                         IXGBE_READ_REG(hw, IXGBE_EITR(rxq->reg_idx));
4086
4087                 /*
4088                  * ixgbe PMD doesn't support header-split at the moment.
4089                  *
4090                  * Following the 4.6.7.2.1 chapter of the 82599/x540
4091                  * Spec if RSC is enabled the SRRCTL[n].BSIZEHEADER
4092                  * should be configured even if header split is not
4093                  * enabled. We will configure it 128 bytes following the
4094                  * recommendation in the spec.
4095                  */
4096                 srrctl &= ~IXGBE_SRRCTL_BSIZEHDR_MASK;
4097                 srrctl |= (128 << IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT) &
4098                                             IXGBE_SRRCTL_BSIZEHDR_MASK;
4099
4100                 /*
4101                  * TODO: Consider setting the Receive Descriptor Minimum
4102                  * Threshold Size for an RSC case. This is not an obviously
4103                  * beneficiary option but the one worth considering...
4104                  */
4105
4106                 rscctl |= IXGBE_RSCCTL_RSCEN;
4107                 rscctl |= ixgbe_get_rscctl_maxdesc(rxq->mb_pool);
4108                 psrtype |= IXGBE_PSRTYPE_TCPHDR;
4109
4110                 /*
4111                  * RSC: Set ITR interval corresponding to 2K ints/s.
4112                  *
4113                  * Full-sized RSC aggregations for a 10Gb/s link will
4114                  * arrive at about 20K aggregation/s rate.
4115                  *
4116                  * 2K inst/s rate will make only 10% of the
4117                  * aggregations to be closed due to the interrupt timer
4118                  * expiration for a streaming at wire-speed case.
4119                  *
4120                  * For a sparse streaming case this setting will yield
4121                  * at most 500us latency for a single RSC aggregation.
4122                  */
4123                 eitr &= ~IXGBE_EITR_ITR_INT_MASK;
4124                 eitr |= IXGBE_EITR_INTERVAL_US(500) | IXGBE_EITR_CNT_WDIS;
4125
4126                 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxq->reg_idx), srrctl);
4127                 IXGBE_WRITE_REG(hw, IXGBE_RSCCTL(rxq->reg_idx), rscctl);
4128                 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(rxq->reg_idx), psrtype);
4129                 IXGBE_WRITE_REG(hw, IXGBE_EITR(rxq->reg_idx), eitr);
4130
4131                 /*
4132                  * RSC requires the mapping of the queue to the
4133                  * interrupt vector.
4134                  */
4135                 ixgbe_set_ivar(dev, rxq->reg_idx, i, 0);
4136         }
4137
4138         dev->data->lro = 1;
4139
4140         PMD_INIT_LOG(INFO, "enabling LRO mode");
4141
4142         return 0;
4143 }
4144
4145 /*
4146  * Initializes Receive Unit.
4147  */
4148 int __attribute__((cold))
4149 ixgbe_dev_rx_init(struct rte_eth_dev *dev)
4150 {
4151         struct ixgbe_hw     *hw;
4152         struct ixgbe_rx_queue *rxq;
4153         uint64_t bus_addr;
4154         uint32_t rxctrl;
4155         uint32_t fctrl;
4156         uint32_t hlreg0;
4157         uint32_t maxfrs;
4158         uint32_t srrctl;
4159         uint32_t rdrxctl;
4160         uint32_t rxcsum;
4161         uint16_t buf_size;
4162         uint16_t i;
4163         struct rte_eth_rxmode *rx_conf = &dev->data->dev_conf.rxmode;
4164         int rc;
4165
4166         PMD_INIT_FUNC_TRACE();
4167         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4168
4169         /*
4170          * Make sure receives are disabled while setting
4171          * up the RX context (registers, descriptor rings, etc.).
4172          */
4173         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4174         IXGBE_WRITE_REG(hw, IXGBE_RXCTRL, rxctrl & ~IXGBE_RXCTRL_RXEN);
4175
4176         /* Enable receipt of broadcasted frames */
4177         fctrl = IXGBE_READ_REG(hw, IXGBE_FCTRL);
4178         fctrl |= IXGBE_FCTRL_BAM;
4179         fctrl |= IXGBE_FCTRL_DPF;
4180         fctrl |= IXGBE_FCTRL_PMCF;
4181         IXGBE_WRITE_REG(hw, IXGBE_FCTRL, fctrl);
4182
4183         /*
4184          * Configure CRC stripping, if any.
4185          */
4186         hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
4187         if (rx_conf->hw_strip_crc)
4188                 hlreg0 |= IXGBE_HLREG0_RXCRCSTRP;
4189         else
4190                 hlreg0 &= ~IXGBE_HLREG0_RXCRCSTRP;
4191
4192         /*
4193          * Configure jumbo frame support, if any.
4194          */
4195         if (rx_conf->jumbo_frame == 1) {
4196                 hlreg0 |= IXGBE_HLREG0_JUMBOEN;
4197                 maxfrs = IXGBE_READ_REG(hw, IXGBE_MAXFRS);
4198                 maxfrs &= 0x0000FFFF;
4199                 maxfrs |= (rx_conf->max_rx_pkt_len << 16);
4200                 IXGBE_WRITE_REG(hw, IXGBE_MAXFRS, maxfrs);
4201         } else
4202                 hlreg0 &= ~IXGBE_HLREG0_JUMBOEN;
4203
4204         /*
4205          * If loopback mode is configured for 82599, set LPBK bit.
4206          */
4207         if (hw->mac.type == ixgbe_mac_82599EB &&
4208                         dev->data->dev_conf.lpbk_mode == IXGBE_LPBK_82599_TX_RX)
4209                 hlreg0 |= IXGBE_HLREG0_LPBK;
4210         else
4211                 hlreg0 &= ~IXGBE_HLREG0_LPBK;
4212
4213         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
4214
4215         /* Setup RX queues */
4216         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4217                 rxq = dev->data->rx_queues[i];
4218
4219                 /*
4220                  * Reset crc_len in case it was changed after queue setup by a
4221                  * call to configure.
4222                  */
4223                 rxq->crc_len = rx_conf->hw_strip_crc ? 0 : ETHER_CRC_LEN;
4224
4225                 /* Setup the Base and Length of the Rx Descriptor Rings */
4226                 bus_addr = rxq->rx_ring_phys_addr;
4227                 IXGBE_WRITE_REG(hw, IXGBE_RDBAL(rxq->reg_idx),
4228                                 (uint32_t)(bus_addr & 0x00000000ffffffffULL));
4229                 IXGBE_WRITE_REG(hw, IXGBE_RDBAH(rxq->reg_idx),
4230                                 (uint32_t)(bus_addr >> 32));
4231                 IXGBE_WRITE_REG(hw, IXGBE_RDLEN(rxq->reg_idx),
4232                                 rxq->nb_rx_desc * sizeof(union ixgbe_adv_rx_desc));
4233                 IXGBE_WRITE_REG(hw, IXGBE_RDH(rxq->reg_idx), 0);
4234                 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxq->reg_idx), 0);
4235
4236                 /* Configure the SRRCTL register */
4237 #ifdef RTE_HEADER_SPLIT_ENABLE
4238                 /*
4239                  * Configure Header Split
4240                  */
4241                 if (rx_conf->header_split) {
4242                         if (hw->mac.type == ixgbe_mac_82599EB) {
4243                                 /* Must setup the PSRTYPE register */
4244                                 uint32_t psrtype;
4245                                 psrtype = IXGBE_PSRTYPE_TCPHDR |
4246                                         IXGBE_PSRTYPE_UDPHDR   |
4247                                         IXGBE_PSRTYPE_IPV4HDR  |
4248                                         IXGBE_PSRTYPE_IPV6HDR;
4249                                 IXGBE_WRITE_REG(hw, IXGBE_PSRTYPE(rxq->reg_idx), psrtype);
4250                         }
4251                         srrctl = ((rx_conf->split_hdr_size <<
4252                                 IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT) &
4253                                 IXGBE_SRRCTL_BSIZEHDR_MASK);
4254                         srrctl |= IXGBE_SRRCTL_DESCTYPE_HDR_SPLIT_ALWAYS;
4255                 } else
4256 #endif
4257                         srrctl = IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
4258
4259                 /* Set if packets are dropped when no descriptors available */
4260                 if (rxq->drop_en)
4261                         srrctl |= IXGBE_SRRCTL_DROP_EN;
4262
4263                 /*
4264                  * Configure the RX buffer size in the BSIZEPACKET field of
4265                  * the SRRCTL register of the queue.
4266                  * The value is in 1 KB resolution. Valid values can be from
4267                  * 1 KB to 16 KB.
4268                  */
4269                 buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rxq->mb_pool) -
4270                         RTE_PKTMBUF_HEADROOM);
4271                 srrctl |= ((buf_size >> IXGBE_SRRCTL_BSIZEPKT_SHIFT) &
4272                            IXGBE_SRRCTL_BSIZEPKT_MASK);
4273
4274                 IXGBE_WRITE_REG(hw, IXGBE_SRRCTL(rxq->reg_idx), srrctl);
4275
4276                 buf_size = (uint16_t) ((srrctl & IXGBE_SRRCTL_BSIZEPKT_MASK) <<
4277                                        IXGBE_SRRCTL_BSIZEPKT_SHIFT);
4278
4279                 /* It adds dual VLAN length for supporting dual VLAN */
4280                 if (dev->data->dev_conf.rxmode.max_rx_pkt_len +
4281                                             2 * IXGBE_VLAN_TAG_SIZE > buf_size)
4282                         dev->data->scattered_rx = 1;
4283         }
4284
4285         if (rx_conf->enable_scatter)
4286                 dev->data->scattered_rx = 1;
4287
4288         /*
4289          * Device configured with multiple RX queues.
4290          */
4291         ixgbe_dev_mq_rx_configure(dev);
4292
4293         /*
4294          * Setup the Checksum Register.
4295          * Disable Full-Packet Checksum which is mutually exclusive with RSS.
4296          * Enable IP/L4 checkum computation by hardware if requested to do so.
4297          */
4298         rxcsum = IXGBE_READ_REG(hw, IXGBE_RXCSUM);
4299         rxcsum |= IXGBE_RXCSUM_PCSD;
4300         if (rx_conf->hw_ip_checksum)
4301                 rxcsum |= IXGBE_RXCSUM_IPPCSE;
4302         else
4303                 rxcsum &= ~IXGBE_RXCSUM_IPPCSE;
4304
4305         IXGBE_WRITE_REG(hw, IXGBE_RXCSUM, rxcsum);
4306
4307         if (hw->mac.type == ixgbe_mac_82599EB ||
4308             hw->mac.type == ixgbe_mac_X540) {
4309                 rdrxctl = IXGBE_READ_REG(hw, IXGBE_RDRXCTL);
4310                 if (rx_conf->hw_strip_crc)
4311                         rdrxctl |= IXGBE_RDRXCTL_CRCSTRIP;
4312                 else
4313                         rdrxctl &= ~IXGBE_RDRXCTL_CRCSTRIP;
4314                 rdrxctl &= ~IXGBE_RDRXCTL_RSCFRSTSIZE;
4315                 IXGBE_WRITE_REG(hw, IXGBE_RDRXCTL, rdrxctl);
4316         }
4317
4318         rc = ixgbe_set_rsc(dev);
4319         if (rc)
4320                 return rc;
4321
4322         ixgbe_set_rx_function(dev);
4323
4324         return 0;
4325 }
4326
4327 /*
4328  * Initializes Transmit Unit.
4329  */
4330 void __attribute__((cold))
4331 ixgbe_dev_tx_init(struct rte_eth_dev *dev)
4332 {
4333         struct ixgbe_hw     *hw;
4334         struct ixgbe_tx_queue *txq;
4335         uint64_t bus_addr;
4336         uint32_t hlreg0;
4337         uint32_t txctrl;
4338         uint16_t i;
4339
4340         PMD_INIT_FUNC_TRACE();
4341         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4342
4343         /* Enable TX CRC (checksum offload requirement) and hw padding
4344          * (TSO requirement) */
4345         hlreg0 = IXGBE_READ_REG(hw, IXGBE_HLREG0);
4346         hlreg0 |= (IXGBE_HLREG0_TXCRCEN | IXGBE_HLREG0_TXPADEN);
4347         IXGBE_WRITE_REG(hw, IXGBE_HLREG0, hlreg0);
4348
4349         /* Setup the Base and Length of the Tx Descriptor Rings */
4350         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4351                 txq = dev->data->tx_queues[i];
4352
4353                 bus_addr = txq->tx_ring_phys_addr;
4354                 IXGBE_WRITE_REG(hw, IXGBE_TDBAL(txq->reg_idx),
4355                                 (uint32_t)(bus_addr & 0x00000000ffffffffULL));
4356                 IXGBE_WRITE_REG(hw, IXGBE_TDBAH(txq->reg_idx),
4357                                 (uint32_t)(bus_addr >> 32));
4358                 IXGBE_WRITE_REG(hw, IXGBE_TDLEN(txq->reg_idx),
4359                                 txq->nb_tx_desc * sizeof(union ixgbe_adv_tx_desc));
4360                 /* Setup the HW Tx Head and TX Tail descriptor pointers */
4361                 IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
4362                 IXGBE_WRITE_REG(hw, IXGBE_TDT(txq->reg_idx), 0);
4363
4364                 /*
4365                  * Disable Tx Head Writeback RO bit, since this hoses
4366                  * bookkeeping if things aren't delivered in order.
4367                  */
4368                 switch (hw->mac.type) {
4369                         case ixgbe_mac_82598EB:
4370                                 txctrl = IXGBE_READ_REG(hw,
4371                                                         IXGBE_DCA_TXCTRL(txq->reg_idx));
4372                                 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
4373                                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL(txq->reg_idx),
4374                                                 txctrl);
4375                                 break;
4376
4377                         case ixgbe_mac_82599EB:
4378                         case ixgbe_mac_X540:
4379                         case ixgbe_mac_X550:
4380                         case ixgbe_mac_X550EM_x:
4381                         default:
4382                                 txctrl = IXGBE_READ_REG(hw,
4383                                                 IXGBE_DCA_TXCTRL_82599(txq->reg_idx));
4384                                 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
4385                                 IXGBE_WRITE_REG(hw, IXGBE_DCA_TXCTRL_82599(txq->reg_idx),
4386                                                 txctrl);
4387                                 break;
4388                 }
4389         }
4390
4391         /* Device configured with multiple TX queues. */
4392         ixgbe_dev_mq_tx_configure(dev);
4393 }
4394
4395 /*
4396  * Set up link for 82599 loopback mode Tx->Rx.
4397  */
4398 static inline void __attribute__((cold))
4399 ixgbe_setup_loopback_link_82599(struct ixgbe_hw *hw)
4400 {
4401         PMD_INIT_FUNC_TRACE();
4402
4403         if (ixgbe_verify_lesm_fw_enabled_82599(hw)) {
4404                 if (hw->mac.ops.acquire_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM) !=
4405                                 IXGBE_SUCCESS) {
4406                         PMD_INIT_LOG(ERR, "Could not enable loopback mode");
4407                         /* ignore error */
4408                         return;
4409                 }
4410         }
4411
4412         /* Restart link */
4413         IXGBE_WRITE_REG(hw,
4414                         IXGBE_AUTOC,
4415                         IXGBE_AUTOC_LMS_10G_LINK_NO_AN | IXGBE_AUTOC_FLU);
4416         ixgbe_reset_pipeline_82599(hw);
4417
4418         hw->mac.ops.release_swfw_sync(hw, IXGBE_GSSR_MAC_CSR_SM);
4419         msec_delay(50);
4420 }
4421
4422
4423 /*
4424  * Start Transmit and Receive Units.
4425  */
4426 int __attribute__((cold))
4427 ixgbe_dev_rxtx_start(struct rte_eth_dev *dev)
4428 {
4429         struct ixgbe_hw     *hw;
4430         struct ixgbe_tx_queue *txq;
4431         struct ixgbe_rx_queue *rxq;
4432         uint32_t txdctl;
4433         uint32_t dmatxctl;
4434         uint32_t rxctrl;
4435         uint16_t i;
4436         int ret = 0;
4437
4438         PMD_INIT_FUNC_TRACE();
4439         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4440
4441         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4442                 txq = dev->data->tx_queues[i];
4443                 /* Setup Transmit Threshold Registers */
4444                 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txq->reg_idx));
4445                 txdctl |= txq->pthresh & 0x7F;
4446                 txdctl |= ((txq->hthresh & 0x7F) << 8);
4447                 txdctl |= ((txq->wthresh & 0x7F) << 16);
4448                 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txq->reg_idx), txdctl);
4449         }
4450
4451         if (hw->mac.type != ixgbe_mac_82598EB) {
4452                 dmatxctl = IXGBE_READ_REG(hw, IXGBE_DMATXCTL);
4453                 dmatxctl |= IXGBE_DMATXCTL_TE;
4454                 IXGBE_WRITE_REG(hw, IXGBE_DMATXCTL, dmatxctl);
4455         }
4456
4457         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4458                 txq = dev->data->tx_queues[i];
4459                 if (!txq->tx_deferred_start) {
4460                         ret = ixgbe_dev_tx_queue_start(dev, i);
4461                         if (ret < 0)
4462                                 return ret;
4463                 }
4464         }
4465
4466         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4467                 rxq = dev->data->rx_queues[i];
4468                 if (!rxq->rx_deferred_start) {
4469                         ret = ixgbe_dev_rx_queue_start(dev, i);
4470                         if (ret < 0)
4471                                 return ret;
4472                 }
4473         }
4474
4475         /* Enable Receive engine */
4476         rxctrl = IXGBE_READ_REG(hw, IXGBE_RXCTRL);
4477         if (hw->mac.type == ixgbe_mac_82598EB)
4478                 rxctrl |= IXGBE_RXCTRL_DMBYPS;
4479         rxctrl |= IXGBE_RXCTRL_RXEN;
4480         hw->mac.ops.enable_rx_dma(hw, rxctrl);
4481
4482         /* If loopback mode is enabled for 82599, set up the link accordingly */
4483         if (hw->mac.type == ixgbe_mac_82599EB &&
4484                         dev->data->dev_conf.lpbk_mode == IXGBE_LPBK_82599_TX_RX)
4485                 ixgbe_setup_loopback_link_82599(hw);
4486
4487         return 0;
4488 }
4489
4490 /*
4491  * Start Receive Units for specified queue.
4492  */
4493 int __attribute__((cold))
4494 ixgbe_dev_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id)
4495 {
4496         struct ixgbe_hw     *hw;
4497         struct ixgbe_rx_queue *rxq;
4498         uint32_t rxdctl;
4499         int poll_ms;
4500
4501         PMD_INIT_FUNC_TRACE();
4502         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4503
4504         if (rx_queue_id < dev->data->nb_rx_queues) {
4505                 rxq = dev->data->rx_queues[rx_queue_id];
4506
4507                 /* Allocate buffers for descriptor rings */
4508                 if (ixgbe_alloc_rx_queue_mbufs(rxq) != 0) {
4509                         PMD_INIT_LOG(ERR, "Could not alloc mbuf for queue:%d",
4510                                      rx_queue_id);
4511                         return -1;
4512                 }
4513                 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxq->reg_idx));
4514                 rxdctl |= IXGBE_RXDCTL_ENABLE;
4515                 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxq->reg_idx), rxdctl);
4516
4517                 /* Wait until RX Enable ready */
4518                 poll_ms = RTE_IXGBE_REGISTER_POLL_WAIT_10_MS;
4519                 do {
4520                         rte_delay_ms(1);
4521                         rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxq->reg_idx));
4522                 } while (--poll_ms && !(rxdctl & IXGBE_RXDCTL_ENABLE));
4523                 if (!poll_ms)
4524                         PMD_INIT_LOG(ERR, "Could not enable Rx Queue %d",
4525                                      rx_queue_id);
4526                 rte_wmb();
4527                 IXGBE_WRITE_REG(hw, IXGBE_RDH(rxq->reg_idx), 0);
4528                 IXGBE_WRITE_REG(hw, IXGBE_RDT(rxq->reg_idx), rxq->nb_rx_desc - 1);
4529         } else
4530                 return -1;
4531
4532         return 0;
4533 }
4534
4535 /*
4536  * Stop Receive Units for specified queue.
4537  */
4538 int __attribute__((cold))
4539 ixgbe_dev_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id)
4540 {
4541         struct ixgbe_hw     *hw;
4542         struct ixgbe_adapter *adapter =
4543                 (struct ixgbe_adapter *)dev->data->dev_private;
4544         struct ixgbe_rx_queue *rxq;
4545         uint32_t rxdctl;
4546         int poll_ms;
4547
4548         PMD_INIT_FUNC_TRACE();
4549         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4550
4551         if (rx_queue_id < dev->data->nb_rx_queues) {
4552                 rxq = dev->data->rx_queues[rx_queue_id];
4553
4554                 rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxq->reg_idx));
4555                 rxdctl &= ~IXGBE_RXDCTL_ENABLE;
4556                 IXGBE_WRITE_REG(hw, IXGBE_RXDCTL(rxq->reg_idx), rxdctl);
4557
4558                 /* Wait until RX Enable ready */
4559                 poll_ms = RTE_IXGBE_REGISTER_POLL_WAIT_10_MS;
4560                 do {
4561                         rte_delay_ms(1);
4562                         rxdctl = IXGBE_READ_REG(hw, IXGBE_RXDCTL(rxq->reg_idx));
4563                 } while (--poll_ms && (rxdctl | IXGBE_RXDCTL_ENABLE));
4564                 if (!poll_ms)
4565                         PMD_INIT_LOG(ERR, "Could not disable Rx Queue %d",
4566                                      rx_queue_id);
4567
4568                 rte_delay_us(RTE_IXGBE_WAIT_100_US);
4569
4570                 ixgbe_rx_queue_release_mbufs(rxq);
4571                 ixgbe_reset_rx_queue(adapter, rxq);
4572         } else
4573                 return -1;
4574
4575         return 0;
4576 }
4577
4578
4579 /*
4580  * Start Transmit Units for specified queue.
4581  */
4582 int __attribute__((cold))
4583 ixgbe_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
4584 {
4585         struct ixgbe_hw     *hw;
4586         struct ixgbe_tx_queue *txq;
4587         uint32_t txdctl;
4588         int poll_ms;
4589
4590         PMD_INIT_FUNC_TRACE();
4591         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4592
4593         if (tx_queue_id < dev->data->nb_tx_queues) {
4594                 txq = dev->data->tx_queues[tx_queue_id];
4595                 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txq->reg_idx));
4596                 txdctl |= IXGBE_TXDCTL_ENABLE;
4597                 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txq->reg_idx), txdctl);
4598
4599                 /* Wait until TX Enable ready */
4600                 if (hw->mac.type == ixgbe_mac_82599EB) {
4601                         poll_ms = RTE_IXGBE_REGISTER_POLL_WAIT_10_MS;
4602                         do {
4603                                 rte_delay_ms(1);
4604                                 txdctl = IXGBE_READ_REG(hw,
4605                                         IXGBE_TXDCTL(txq->reg_idx));
4606                         } while (--poll_ms && !(txdctl & IXGBE_TXDCTL_ENABLE));
4607                         if (!poll_ms)
4608                                 PMD_INIT_LOG(ERR, "Could not enable "
4609                                              "Tx Queue %d", tx_queue_id);
4610                 }
4611                 rte_wmb();
4612                 IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
4613                 IXGBE_WRITE_REG(hw, IXGBE_TDT(txq->reg_idx), 0);
4614         } else
4615                 return -1;
4616
4617         return 0;
4618 }
4619
4620 /*
4621  * Stop Transmit Units for specified queue.
4622  */
4623 int __attribute__((cold))
4624 ixgbe_dev_tx_queue_stop(struct rte_eth_dev *dev, uint16_t tx_queue_id)
4625 {
4626         struct ixgbe_hw     *hw;
4627         struct ixgbe_tx_queue *txq;
4628         uint32_t txdctl;
4629         uint32_t txtdh, txtdt;
4630         int poll_ms;
4631
4632         PMD_INIT_FUNC_TRACE();
4633         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4634
4635         if (tx_queue_id < dev->data->nb_tx_queues) {
4636                 txq = dev->data->tx_queues[tx_queue_id];
4637
4638                 /* Wait until TX queue is empty */
4639                 if (hw->mac.type == ixgbe_mac_82599EB) {
4640                         poll_ms = RTE_IXGBE_REGISTER_POLL_WAIT_10_MS;
4641                         do {
4642                                 rte_delay_us(RTE_IXGBE_WAIT_100_US);
4643                                 txtdh = IXGBE_READ_REG(hw,
4644                                                 IXGBE_TDH(txq->reg_idx));
4645                                 txtdt = IXGBE_READ_REG(hw,
4646                                                 IXGBE_TDT(txq->reg_idx));
4647                         } while (--poll_ms && (txtdh != txtdt));
4648                         if (!poll_ms)
4649                                 PMD_INIT_LOG(ERR, "Tx Queue %d is not empty "
4650                                              "when stopping.", tx_queue_id);
4651                 }
4652
4653                 txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txq->reg_idx));
4654                 txdctl &= ~IXGBE_TXDCTL_ENABLE;
4655                 IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txq->reg_idx), txdctl);
4656
4657                 /* Wait until TX Enable ready */
4658                 if (hw->mac.type == ixgbe_mac_82599EB) {
4659                         poll_ms = RTE_IXGBE_REGISTER_POLL_WAIT_10_MS;
4660                         do {
4661                                 rte_delay_ms(1);
4662                                 txdctl = IXGBE_READ_REG(hw,
4663                                                 IXGBE_TXDCTL(txq->reg_idx));
4664                         } while (--poll_ms && (txdctl | IXGBE_TXDCTL_ENABLE));
4665                         if (!poll_ms)
4666                                 PMD_INIT_LOG(ERR, "Could not disable "
4667                                              "Tx Queue %d", tx_queue_id);
4668                 }
4669
4670                 if (txq->ops != NULL) {
4671                         txq->ops->release_mbufs(txq);
4672                         txq->ops->reset(txq);
4673                 }
4674         } else
4675                 return -1;
4676
4677         return 0;
4678 }
4679
4680 /*
4681  * [VF] Initializes Receive Unit.
4682  */
4683 int __attribute__((cold))
4684 ixgbevf_dev_rx_init(struct rte_eth_dev *dev)
4685 {
4686         struct ixgbe_hw     *hw;
4687         struct ixgbe_rx_queue *rxq;
4688         uint64_t bus_addr;
4689         uint32_t srrctl, psrtype = 0;
4690         uint16_t buf_size;
4691         uint16_t i;
4692         int ret;
4693
4694         PMD_INIT_FUNC_TRACE();
4695         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4696
4697         if (rte_is_power_of_2(dev->data->nb_rx_queues) == 0) {
4698                 PMD_INIT_LOG(ERR, "The number of Rx queue invalid, "
4699                         "it should be power of 2");
4700                 return -1;
4701         }
4702
4703         if (dev->data->nb_rx_queues > hw->mac.max_rx_queues) {
4704                 PMD_INIT_LOG(ERR, "The number of Rx queue invalid, "
4705                         "it should be equal to or less than %d",
4706                         hw->mac.max_rx_queues);
4707                 return -1;
4708         }
4709
4710         /*
4711          * When the VF driver issues a IXGBE_VF_RESET request, the PF driver
4712          * disables the VF receipt of packets if the PF MTU is > 1500.
4713          * This is done to deal with 82599 limitations that imposes
4714          * the PF and all VFs to share the same MTU.
4715          * Then, the PF driver enables again the VF receipt of packet when
4716          * the VF driver issues a IXGBE_VF_SET_LPE request.
4717          * In the meantime, the VF device cannot be used, even if the VF driver
4718          * and the Guest VM network stack are ready to accept packets with a
4719          * size up to the PF MTU.
4720          * As a work-around to this PF behaviour, force the call to
4721          * ixgbevf_rlpml_set_vf even if jumbo frames are not used. This way,
4722          * VF packets received can work in all cases.
4723          */
4724         ixgbevf_rlpml_set_vf(hw,
4725                 (uint16_t)dev->data->dev_conf.rxmode.max_rx_pkt_len);
4726
4727         /* Setup RX queues */
4728         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4729                 rxq = dev->data->rx_queues[i];
4730
4731                 /* Allocate buffers for descriptor rings */
4732                 ret = ixgbe_alloc_rx_queue_mbufs(rxq);
4733                 if (ret)
4734                         return ret;
4735
4736                 /* Setup the Base and Length of the Rx Descriptor Rings */
4737                 bus_addr = rxq->rx_ring_phys_addr;
4738
4739                 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAL(i),
4740                                 (uint32_t)(bus_addr & 0x00000000ffffffffULL));
4741                 IXGBE_WRITE_REG(hw, IXGBE_VFRDBAH(i),
4742                                 (uint32_t)(bus_addr >> 32));
4743                 IXGBE_WRITE_REG(hw, IXGBE_VFRDLEN(i),
4744                                 rxq->nb_rx_desc * sizeof(union ixgbe_adv_rx_desc));
4745                 IXGBE_WRITE_REG(hw, IXGBE_VFRDH(i), 0);
4746                 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(i), 0);
4747
4748
4749                 /* Configure the SRRCTL register */
4750 #ifdef RTE_HEADER_SPLIT_ENABLE
4751                 /*
4752                  * Configure Header Split
4753                  */
4754                 if (dev->data->dev_conf.rxmode.header_split) {
4755                         srrctl = ((dev->data->dev_conf.rxmode.split_hdr_size <<
4756                                 IXGBE_SRRCTL_BSIZEHDRSIZE_SHIFT) &
4757                                 IXGBE_SRRCTL_BSIZEHDR_MASK);
4758                         srrctl |= IXGBE_SRRCTL_DESCTYPE_HDR_SPLIT_ALWAYS;
4759                 } else
4760 #endif
4761                         srrctl = IXGBE_SRRCTL_DESCTYPE_ADV_ONEBUF;
4762
4763                 /* Set if packets are dropped when no descriptors available */
4764                 if (rxq->drop_en)
4765                         srrctl |= IXGBE_SRRCTL_DROP_EN;
4766
4767                 /*
4768                  * Configure the RX buffer size in the BSIZEPACKET field of
4769                  * the SRRCTL register of the queue.
4770                  * The value is in 1 KB resolution. Valid values can be from
4771                  * 1 KB to 16 KB.
4772                  */
4773                 buf_size = (uint16_t)(rte_pktmbuf_data_room_size(rxq->mb_pool) -
4774                         RTE_PKTMBUF_HEADROOM);
4775                 srrctl |= ((buf_size >> IXGBE_SRRCTL_BSIZEPKT_SHIFT) &
4776                            IXGBE_SRRCTL_BSIZEPKT_MASK);
4777
4778                 /*
4779                  * VF modification to write virtual function SRRCTL register
4780                  */
4781                 IXGBE_WRITE_REG(hw, IXGBE_VFSRRCTL(i), srrctl);
4782
4783                 buf_size = (uint16_t) ((srrctl & IXGBE_SRRCTL_BSIZEPKT_MASK) <<
4784                                        IXGBE_SRRCTL_BSIZEPKT_SHIFT);
4785
4786                 if (dev->data->dev_conf.rxmode.enable_scatter ||
4787                     /* It adds dual VLAN length for supporting dual VLAN */
4788                     (dev->data->dev_conf.rxmode.max_rx_pkt_len +
4789                                 2 * IXGBE_VLAN_TAG_SIZE) > buf_size) {
4790                         if (!dev->data->scattered_rx)
4791                                 PMD_INIT_LOG(DEBUG, "forcing scatter mode");
4792                         dev->data->scattered_rx = 1;
4793                 }
4794         }
4795
4796 #ifdef RTE_HEADER_SPLIT_ENABLE
4797         if (dev->data->dev_conf.rxmode.header_split)
4798                 /* Must setup the PSRTYPE register */
4799                 psrtype = IXGBE_PSRTYPE_TCPHDR |
4800                         IXGBE_PSRTYPE_UDPHDR   |
4801                         IXGBE_PSRTYPE_IPV4HDR  |
4802                         IXGBE_PSRTYPE_IPV6HDR;
4803 #endif
4804
4805         /* Set RQPL for VF RSS according to max Rx queue */
4806         psrtype |= (dev->data->nb_rx_queues >> 1) <<
4807                 IXGBE_PSRTYPE_RQPL_SHIFT;
4808         IXGBE_WRITE_REG(hw, IXGBE_VFPSRTYPE, psrtype);
4809
4810         ixgbe_set_rx_function(dev);
4811
4812         return 0;
4813 }
4814
4815 /*
4816  * [VF] Initializes Transmit Unit.
4817  */
4818 void __attribute__((cold))
4819 ixgbevf_dev_tx_init(struct rte_eth_dev *dev)
4820 {
4821         struct ixgbe_hw     *hw;
4822         struct ixgbe_tx_queue *txq;
4823         uint64_t bus_addr;
4824         uint32_t txctrl;
4825         uint16_t i;
4826
4827         PMD_INIT_FUNC_TRACE();
4828         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4829
4830         /* Setup the Base and Length of the Tx Descriptor Rings */
4831         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4832                 txq = dev->data->tx_queues[i];
4833                 bus_addr = txq->tx_ring_phys_addr;
4834                 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAL(i),
4835                                 (uint32_t)(bus_addr & 0x00000000ffffffffULL));
4836                 IXGBE_WRITE_REG(hw, IXGBE_VFTDBAH(i),
4837                                 (uint32_t)(bus_addr >> 32));
4838                 IXGBE_WRITE_REG(hw, IXGBE_VFTDLEN(i),
4839                                 txq->nb_tx_desc * sizeof(union ixgbe_adv_tx_desc));
4840                 /* Setup the HW Tx Head and TX Tail descriptor pointers */
4841                 IXGBE_WRITE_REG(hw, IXGBE_VFTDH(i), 0);
4842                 IXGBE_WRITE_REG(hw, IXGBE_VFTDT(i), 0);
4843
4844                 /*
4845                  * Disable Tx Head Writeback RO bit, since this hoses
4846                  * bookkeeping if things aren't delivered in order.
4847                  */
4848                 txctrl = IXGBE_READ_REG(hw,
4849                                 IXGBE_VFDCA_TXCTRL(i));
4850                 txctrl &= ~IXGBE_DCA_TXCTRL_DESC_WRO_EN;
4851                 IXGBE_WRITE_REG(hw, IXGBE_VFDCA_TXCTRL(i),
4852                                 txctrl);
4853         }
4854 }
4855
4856 /*
4857  * [VF] Start Transmit and Receive Units.
4858  */
4859 void __attribute__((cold))
4860 ixgbevf_dev_rxtx_start(struct rte_eth_dev *dev)
4861 {
4862         struct ixgbe_hw     *hw;
4863         struct ixgbe_tx_queue *txq;
4864         struct ixgbe_rx_queue *rxq;
4865         uint32_t txdctl;
4866         uint32_t rxdctl;
4867         uint16_t i;
4868         int poll_ms;
4869
4870         PMD_INIT_FUNC_TRACE();
4871         hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
4872
4873         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4874                 txq = dev->data->tx_queues[i];
4875                 /* Setup Transmit Threshold Registers */
4876                 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
4877                 txdctl |= txq->pthresh & 0x7F;
4878                 txdctl |= ((txq->hthresh & 0x7F) << 8);
4879                 txdctl |= ((txq->wthresh & 0x7F) << 16);
4880                 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), txdctl);
4881         }
4882
4883         for (i = 0; i < dev->data->nb_tx_queues; i++) {
4884
4885                 txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
4886                 txdctl |= IXGBE_TXDCTL_ENABLE;
4887                 IXGBE_WRITE_REG(hw, IXGBE_VFTXDCTL(i), txdctl);
4888
4889                 poll_ms = 10;
4890                 /* Wait until TX Enable ready */
4891                 do {
4892                         rte_delay_ms(1);
4893                         txdctl = IXGBE_READ_REG(hw, IXGBE_VFTXDCTL(i));
4894                 } while (--poll_ms && !(txdctl & IXGBE_TXDCTL_ENABLE));
4895                 if (!poll_ms)
4896                         PMD_INIT_LOG(ERR, "Could not enable Tx Queue %d", i);
4897         }
4898         for (i = 0; i < dev->data->nb_rx_queues; i++) {
4899
4900                 rxq = dev->data->rx_queues[i];
4901
4902                 rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
4903                 rxdctl |= IXGBE_RXDCTL_ENABLE;
4904                 IXGBE_WRITE_REG(hw, IXGBE_VFRXDCTL(i), rxdctl);
4905
4906                 /* Wait until RX Enable ready */
4907                 poll_ms = 10;
4908                 do {
4909                         rte_delay_ms(1);
4910                         rxdctl = IXGBE_READ_REG(hw, IXGBE_VFRXDCTL(i));
4911                 } while (--poll_ms && !(rxdctl & IXGBE_RXDCTL_ENABLE));
4912                 if (!poll_ms)
4913                         PMD_INIT_LOG(ERR, "Could not enable Rx Queue %d", i);
4914                 rte_wmb();
4915                 IXGBE_WRITE_REG(hw, IXGBE_VFRDT(i), rxq->nb_rx_desc - 1);
4916
4917         }
4918 }
4919
4920 /* Stubs needed for linkage when CONFIG_RTE_IXGBE_INC_VECTOR is set to 'n' */
4921 int __attribute__((weak))
4922 ixgbe_rx_vec_dev_conf_condition_check(struct rte_eth_dev __rte_unused *dev)
4923 {
4924         return -1;
4925 }
4926
4927 uint16_t __attribute__((weak))
4928 ixgbe_recv_pkts_vec(
4929         void __rte_unused *rx_queue,
4930         struct rte_mbuf __rte_unused **rx_pkts,
4931         uint16_t __rte_unused nb_pkts)
4932 {
4933         return 0;
4934 }
4935
4936 uint16_t __attribute__((weak))
4937 ixgbe_recv_scattered_pkts_vec(
4938         void __rte_unused *rx_queue,
4939         struct rte_mbuf __rte_unused **rx_pkts,
4940         uint16_t __rte_unused nb_pkts)
4941 {
4942         return 0;
4943 }
4944
4945 int __attribute__((weak))
4946 ixgbe_rxq_vec_setup(struct ixgbe_rx_queue __rte_unused *rxq)
4947 {
4948         return -1;
4949 }