lib/librte_pmd_ixgbe/ixgbe_rxtx.c

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