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