lib/librte_pmd_ixgbe/ixgbe_rxtx.c

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