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