drivers/net/ixgbe/ixgbe_rxtx.c

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