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