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