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