drivers/net/ixgbe/ixgbe_rxtx.c

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