net/bnxt: use table based mbuf flags handling

Use table to translate receive descriptor status flags to
rte_mbuf ol_flags values.

Reviewed-by: Ajit Khaparde <ajit.khaparde@broadcom.com>
Signed-off-by: Lance Richardson <lance.richardson@broadcom.com>

diff --git a/drivers/net/bnxt/bnxt_rxr.c b/drivers/net/bnxt/bnxt_rxr.c
index a882dd2..33bd006 100644 (file)
--- a/drivers/net/bnxt/bnxt_rxr.c
+++ b/drivers/net/bnxt/bnxt_rxr.c
@@ -406,6 +406,95 @@ bnxt_parse_pkt_type(struct rx_pkt_cmpl *rxcmp, struct rx_pkt_cmpl_hi *rxcmp1)
        return bnxt_ptype_table[index];
 }
 
+uint32_t
+bnxt_ol_flags_table[BNXT_OL_FLAGS_TBL_DIM] __rte_cache_aligned;
+
+uint32_t
+bnxt_ol_flags_err_table[BNXT_OL_FLAGS_ERR_TBL_DIM] __rte_cache_aligned;
+
+static void __rte_cold
+bnxt_init_ol_flags_tables(void)
+{
+       static bool initialized;
+       uint32_t *pt;
+       int i;
+
+       if (initialized)
+               return;
+
+       /* Initialize ol_flags table. */
+       pt = bnxt_ol_flags_table;
+       for (i = 0; i < BNXT_OL_FLAGS_TBL_DIM; i++) {
+               pt[i] = 0;
+               if (i & RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN)
+                       pt[i] |= PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
+
+               if (i & RX_PKT_CMPL_FLAGS2_IP_CS_CALC)
+                       pt[i] |= PKT_RX_IP_CKSUM_GOOD;
+
+               if (i & RX_PKT_CMPL_FLAGS2_L4_CS_CALC)
+                       pt[i] |= PKT_RX_L4_CKSUM_GOOD;
+
+               if (i & RX_PKT_CMPL_FLAGS2_T_L4_CS_CALC)
+                       pt[i] |= PKT_RX_OUTER_L4_CKSUM_GOOD;
+       }
+
+       /* Initialize checksum error table. */
+       pt = bnxt_ol_flags_err_table;
+       for (i = 0; i < BNXT_OL_FLAGS_ERR_TBL_DIM; i++) {
+               pt[i] = 0;
+               if (i & (RX_PKT_CMPL_ERRORS_IP_CS_ERROR >> 4))
+                       pt[i] |= PKT_RX_IP_CKSUM_BAD;
+
+               if (i & (RX_PKT_CMPL_ERRORS_L4_CS_ERROR >> 4))
+                       pt[i] |= PKT_RX_L4_CKSUM_BAD;
+
+               if (i & (RX_PKT_CMPL_ERRORS_T_IP_CS_ERROR >> 4))
+                       pt[i] |= PKT_RX_EIP_CKSUM_BAD;
+
+               if (i & (RX_PKT_CMPL_ERRORS_T_L4_CS_ERROR >> 4))
+                       pt[i] |= PKT_RX_OUTER_L4_CKSUM_BAD;
+       }
+
+       initialized = true;
+}
+
+static void
+bnxt_set_ol_flags(struct rx_pkt_cmpl *rxcmp, struct rx_pkt_cmpl_hi *rxcmp1,
+                 struct rte_mbuf *mbuf)
+{
+       uint16_t flags_type, errors, flags;
+       uint64_t ol_flags;
+
+       flags_type = rte_le_to_cpu_16(rxcmp->flags_type);
+
+       flags = rte_le_to_cpu_32(rxcmp1->flags2) &
+                               (RX_PKT_CMPL_FLAGS2_IP_CS_CALC |
+                                RX_PKT_CMPL_FLAGS2_L4_CS_CALC |
+                                RX_PKT_CMPL_FLAGS2_T_IP_CS_CALC |
+                                RX_PKT_CMPL_FLAGS2_T_L4_CS_CALC |
+                                RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN);
+
+       errors = rte_le_to_cpu_16(rxcmp1->errors_v2) &
+                               (RX_PKT_CMPL_ERRORS_IP_CS_ERROR |
+                                RX_PKT_CMPL_ERRORS_L4_CS_ERROR |
+                                RX_PKT_CMPL_ERRORS_T_IP_CS_ERROR |
+                                RX_PKT_CMPL_ERRORS_T_L4_CS_ERROR);
+       errors = (errors >> 4) & flags;
+
+       ol_flags = bnxt_ol_flags_table[flags & ~errors];
+
+       if (errors)
+               ol_flags |= bnxt_ol_flags_err_table[errors];
+
+       if (flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID) {
+               mbuf->hash.rss = rte_le_to_cpu_32(rxcmp->rss_hash);
+               ol_flags |= PKT_RX_RSS_HASH;
+       }
+
+       mbuf->ol_flags = ol_flags;
+}
+
 #ifdef RTE_LIBRTE_IEEE1588
 static void
 bnxt_get_rx_ts_thor(struct bnxt *bp, uint32_t rx_ts_cmpl)
@@ -583,8 +672,7 @@ static int bnxt_rx_pkt(struct rte_mbuf **rx_pkt,
        int rc = 0;
        uint8_t agg_buf = 0;
        uint16_t cmp_type;
-       uint32_t flags2_f = 0, vfr_flag = 0, mark_id = 0;
-       uint16_t flags_type;
+       uint32_t vfr_flag = 0, mark_id = 0;
        struct bnxt *bp = rxq->bp;
 
        rxcmp = (struct rx_pkt_cmpl *)
@@ -653,13 +741,17 @@ static int bnxt_rx_pkt(struct rte_mbuf **rx_pkt,
        mbuf->pkt_len = rxcmp->len;
        mbuf->data_len = mbuf->pkt_len;
        mbuf->port = rxq->port_id;
-       mbuf->ol_flags = 0;
 
-       flags_type = rte_le_to_cpu_16(rxcmp->flags_type);
-       if (flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID) {
-               mbuf->hash.rss = rxcmp->rss_hash;
-               mbuf->ol_flags |= PKT_RX_RSS_HASH;
+       bnxt_set_ol_flags(rxcmp, rxcmp1, mbuf);
+
+#ifdef RTE_LIBRTE_IEEE1588
+       if (unlikely((rte_le_to_cpu_16(rxcmp->flags_type) &
+                     RX_PKT_CMPL_FLAGS_MASK) ==
+                     RX_PKT_CMPL_FLAGS_ITYPE_PTP_W_TIMESTAMP)) {
+               mbuf->ol_flags |= PKT_RX_IEEE1588_PTP | PKT_RX_IEEE1588_TMST;
+               bnxt_get_rx_ts_thor(rxq->bp, rxcmp1->reorder);
        }
+#endif
 
        if (BNXT_TRUFLOW_EN(bp))
                mark_id = bnxt_ulp_set_mark_in_mbuf(rxq->bp, rxcmp1, mbuf,
@@ -667,66 +759,9 @@ static int bnxt_rx_pkt(struct rte_mbuf **rx_pkt,
        else
                bnxt_set_mark_in_mbuf(rxq->bp, rxcmp1, mbuf);
 
-#ifdef RTE_LIBRTE_IEEE1588
-       if (unlikely((flags_type & RX_PKT_CMPL_FLAGS_MASK) ==
-                    RX_PKT_CMPL_FLAGS_ITYPE_PTP_W_TIMESTAMP)) {
-               mbuf->ol_flags |= PKT_RX_IEEE1588_PTP | PKT_RX_IEEE1588_TMST;
-               bnxt_get_rx_ts_thor(rxq->bp, rxcmp1->reorder);
-       }
-#endif
        if (agg_buf)
                bnxt_rx_pages(rxq, mbuf, &tmp_raw_cons, agg_buf, NULL);
 
-       if (rxcmp1->flags2 & RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN) {
-               mbuf->vlan_tci = rxcmp1->metadata &
-                       (RX_PKT_CMPL_METADATA_VID_MASK |
-                       RX_PKT_CMPL_METADATA_DE |
-                       RX_PKT_CMPL_METADATA_PRI_MASK);
-               mbuf->ol_flags |= PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
-       }
-
-       flags2_f = flags2_0xf(rxcmp1);
-       /* IP Checksum */
-       if (likely(IS_IP_NONTUNNEL_PKT(flags2_f))) {
-               if (unlikely(RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else if (unlikely(RX_CMP_IP_CS_UNKNOWN(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       } else if (IS_IP_TUNNEL_PKT(flags2_f)) {
-               if (unlikely(RX_CMP_IP_OUTER_CS_ERROR(rxcmp1) ||
-                            RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else if (unlikely(RX_CMP_IP_CS_UNKNOWN(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       }
-
-       /* L4 Checksum */
-       if (likely(IS_L4_NONTUNNEL_PKT(flags2_f))) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-       } else if (IS_L4_TUNNEL_PKT(flags2_f)) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-               if (unlikely(RX_CMP_L4_OUTER_CS_ERR2(rxcmp1))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
-               } else if (unlikely(IS_L4_TUNNEL_PKT_ONLY_INNER_L4_CS
-                                   (flags2_f))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_UNKNOWN;
-               } else {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_GOOD;
-               }
-       } else if (unlikely(RX_CMP_L4_CS_UNKNOWN(rxcmp1))) {
-               mbuf->ol_flags |= PKT_RX_L4_CKSUM_UNKNOWN;
-       }
-
        mbuf->packet_type = bnxt_parse_pkt_type(rxcmp, rxcmp1);
 
 #ifdef BNXT_DEBUG
@@ -1075,6 +1110,9 @@ int bnxt_init_one_rx_ring(struct bnxt_rx_queue *rxq)
        /* Initialize packet type table. */
        bnxt_init_ptype_table();
 
+       /* Initialize offload flags parsing table. */
+       bnxt_init_ol_flags_tables();
+
        size = rte_pktmbuf_data_room_size(rxq->mb_pool) - RTE_PKTMBUF_HEADROOM;
        size = RTE_MIN(BNXT_MAX_PKT_LEN, size);
 

diff --git a/drivers/net/bnxt/bnxt_rxr.h b/drivers/net/bnxt/bnxt_rxr.h
index 0e21c8f..4f5e23b 100644 (file)
--- a/drivers/net/bnxt/bnxt_rxr.h
+++ b/drivers/net/bnxt/bnxt_rxr.h
@@ -240,4 +240,10 @@ void bnxt_set_mark_in_mbuf(struct bnxt *bp,
 
 #define BNXT_PTYPE_TBL_DIM     128
 extern uint32_t bnxt_ptype_table[BNXT_PTYPE_TBL_DIM];
+
+#define BNXT_OL_FLAGS_TBL_DIM  32
+extern uint32_t bnxt_ol_flags_table[BNXT_OL_FLAGS_TBL_DIM];
+
+#define BNXT_OL_FLAGS_ERR_TBL_DIM 16
+extern uint32_t bnxt_ol_flags_err_table[BNXT_OL_FLAGS_ERR_TBL_DIM];
 #endif

diff --git a/drivers/net/bnxt/bnxt_rxtx_vec_neon.c b/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
index fade67e..37b8c83 100644 (file)
--- a/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
+++ b/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
@@ -116,50 +116,28 @@ bnxt_parse_pkt_type(uint32x4_t mm_rxcmp, uint32x4_t mm_rxcmp1)
        return bnxt_ptype_table[index];
 }
 
-static void
-bnxt_parse_csum(struct rte_mbuf *mbuf, struct rx_pkt_cmpl_hi *rxcmp1)
+static uint32_t
+bnxt_set_ol_flags(uint32x4_t mm_rxcmp, uint32x4_t mm_rxcmp1)
 {
-       uint32_t flags;
+       uint16_t flags_type, errors, flags;
+       uint32_t ol_flags;
 
-       flags = flags2_0xf(rxcmp1);
-       /* IP Checksum */
-       if (likely(IS_IP_NONTUNNEL_PKT(flags))) {
-               if (unlikely(RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       } else if (IS_IP_TUNNEL_PKT(flags)) {
-               if (unlikely(RX_CMP_IP_OUTER_CS_ERROR(rxcmp1) ||
-                            RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       } else if (unlikely(RX_CMP_IP_CS_UNKNOWN(rxcmp1))) {
-               mbuf->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
-       }
+       /* Extract rxcmp1->flags2. */
+       flags = vgetq_lane_u32(mm_rxcmp1, 0) & 0x1F;
+       /* Extract rxcmp->flags_type. */
+       flags_type = vgetq_lane_u32(mm_rxcmp, 0);
+       /* Extract rxcmp1->errors_v2. */
+       errors = (vgetq_lane_u32(mm_rxcmp1, 2) >> 4) & flags & 0xF;
 
-       /* L4 Checksum */
-       if (likely(IS_L4_NONTUNNEL_PKT(flags))) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-       } else if (IS_L4_TUNNEL_PKT(flags)) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-               if (unlikely(RX_CMP_L4_OUTER_CS_ERR2(rxcmp1))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
-               } else if (unlikely(IS_L4_TUNNEL_PKT_ONLY_INNER_L4_CS
-                                   (flags))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_UNKNOWN;
-               } else {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_GOOD;
-               }
-       } else if (unlikely(RX_CMP_L4_CS_UNKNOWN(rxcmp1))) {
-               mbuf->ol_flags |= PKT_RX_L4_CKSUM_UNKNOWN;
-       }
+       ol_flags = bnxt_ol_flags_table[flags & ~errors];
+
+       if (flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID)
+               ol_flags |= PKT_RX_RSS_HASH;
+
+       if (errors)
+               ol_flags |= bnxt_ol_flags_err_table[errors];
+
+       return ol_flags;
 }
 
 uint16_t
@@ -202,10 +180,12 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
        for (i = 0; i < nb_pkts; i++) {
                uint32x4_t mm_rxcmp, mm_rxcmp1;
                struct rx_pkt_cmpl_hi *rxcmp1;
+               uint32x4_t pkt_mb, rearm;
+               uint32_t ptype, ol_flags;
                struct rte_mbuf *mbuf;
-               uint32x4_t pkt_mb;
+               uint16_t vlan_tci;
+               uint16x8_t tmp16;
                uint8x16_t tmp;
-               uint32_t ptype;
 
                cons = RING_CMP(cpr->cp_ring_struct, raw_cons);
 
@@ -224,33 +204,30 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
                rte_prefetch0(mbuf);
                rxr->rx_buf_ring[cons] = NULL;
 
-               /* Set constant fields from mbuf initializer. */
-               vst1q_u64((uint64_t *)&mbuf->rearm_data, mbuf_init);
+               /* Set fields from mbuf initializer and ol_flags. */
+               ol_flags = bnxt_set_ol_flags(mm_rxcmp, mm_rxcmp1);
+               rearm = vsetq_lane_u32(ol_flags,
+                                      vreinterpretq_u32_u64(mbuf_init), 2);
+               vst1q_u32((uint32_t *)&mbuf->rearm_data, rearm);
 
                /* Set mbuf pkt_len, data_len, and rss_hash fields. */
                tmp = vqtbl1q_u8(vreinterpretq_u8_u32(mm_rxcmp), shuf_msk);
                pkt_mb = vreinterpretq_u32_u8(tmp);
+
+               /* Set packet type. */
                ptype = bnxt_parse_pkt_type(mm_rxcmp, mm_rxcmp1);
                pkt_mb = vsetq_lane_u32(ptype, pkt_mb, 0);
 
-               vst1q_u32((uint32_t *)&mbuf->rx_descriptor_fields1, pkt_mb);
+               /* Set vlan_tci. */
+               vlan_tci = vgetq_lane_u32(mm_rxcmp1, 1);
+               tmp16 = vsetq_lane_u16(vlan_tci,
+                                      vreinterpretq_u16_u32(pkt_mb),
+                                      5);
+               pkt_mb = vreinterpretq_u32_u16(tmp16);
 
-               rte_compiler_barrier();
-
-               if (rxcmp->flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID)
-                       mbuf->ol_flags |= PKT_RX_RSS_HASH;
-
-               if (rxcmp1->flags2 &
-                   RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN) {
-                       mbuf->vlan_tci = rxcmp1->metadata &
-                               (RX_PKT_CMPL_METADATA_VID_MASK |
-                               RX_PKT_CMPL_METADATA_DE |
-                               RX_PKT_CMPL_METADATA_PRI_MASK);
-                       mbuf->ol_flags |=
-                               PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
-               }
+               /* Store descriptor fields. */
+               vst1q_u32((uint32_t *)&mbuf->rx_descriptor_fields1, pkt_mb);
 
-               bnxt_parse_csum(mbuf, rxcmp1);
                rx_pkts[nb_rx_pkts++] = mbuf;
        }
 

diff --git a/drivers/net/bnxt/bnxt_rxtx_vec_sse.c b/drivers/net/bnxt/bnxt_rxtx_vec_sse.c
index 69ffbe4..761d835 100644 (file)
--- a/drivers/net/bnxt/bnxt_rxtx_vec_sse.c
+++ b/drivers/net/bnxt/bnxt_rxtx_vec_sse.c
@@ -120,50 +120,28 @@ bnxt_parse_pkt_type(__m128i mm_rxcmp, __m128i mm_rxcmp1)
        return _mm_set_epi32(0, 0, 0, bnxt_ptype_table[index]);
 }
 
-static void
-bnxt_parse_csum(struct rte_mbuf *mbuf, struct rx_pkt_cmpl_hi *rxcmp1)
+static __m128i
+bnxt_set_ol_flags(__m128i mm_rxcmp, __m128i mm_rxcmp1)
 {
-       uint32_t flags;
+       uint16_t flags_type, errors, flags;
+       uint32_t ol_flags;
 
-       flags = flags2_0xf(rxcmp1);
-       /* IP Checksum */
-       if (likely(IS_IP_NONTUNNEL_PKT(flags))) {
-               if (unlikely(RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       } else if (IS_IP_TUNNEL_PKT(flags)) {
-               if (unlikely(RX_CMP_IP_OUTER_CS_ERROR(rxcmp1) ||
-                            RX_CMP_IP_CS_ERROR(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
-       } else if (unlikely(RX_CMP_IP_CS_UNKNOWN(rxcmp1))) {
-               mbuf->ol_flags |= PKT_RX_IP_CKSUM_UNKNOWN;
-       }
+       /* Extract rxcmp1->flags2. */
+       flags = _mm_extract_epi32(mm_rxcmp1, 0) & 0x1F;
+       /* Extract rxcmp->flags_type. */
+       flags_type = _mm_extract_epi16(mm_rxcmp, 0);
+       /* Extract rxcmp1->errors_v2. */
+       errors = (_mm_extract_epi16(mm_rxcmp1, 4) >> 4) & flags & 0xF;
 
-       /* L4 Checksum */
-       if (likely(IS_L4_NONTUNNEL_PKT(flags))) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-       } else if (IS_L4_TUNNEL_PKT(flags)) {
-               if (unlikely(RX_CMP_L4_INNER_CS_ERR2(rxcmp1)))
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-               else
-                       mbuf->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
-               if (unlikely(RX_CMP_L4_OUTER_CS_ERR2(rxcmp1))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_BAD;
-               } else if (unlikely(IS_L4_TUNNEL_PKT_ONLY_INNER_L4_CS
-                                   (flags))) {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_UNKNOWN;
-               } else {
-                       mbuf->ol_flags |= PKT_RX_OUTER_L4_CKSUM_GOOD;
-               }
-       } else if (unlikely(RX_CMP_L4_CS_UNKNOWN(rxcmp1))) {
-               mbuf->ol_flags |= PKT_RX_L4_CKSUM_UNKNOWN;
-       }
+       ol_flags = bnxt_ol_flags_table[flags & ~errors];
+
+       if (flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID)
+               ol_flags |= PKT_RX_RSS_HASH;
+
+       if (errors)
+               ol_flags |= bnxt_ol_flags_err_table[errors];
+
+       return _mm_set_epi64x(ol_flags, 0);
 }
 
 uint16_t
@@ -208,7 +186,7 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
        for (i = 0; i < nb_pkts; i++) {
                struct rx_pkt_cmpl_hi *rxcmp1;
                struct rte_mbuf *mbuf;
-               __m128i mm_rxcmp, mm_rxcmp1, pkt_mb, ptype;
+               __m128i mm_rxcmp, mm_rxcmp1, pkt_mb, ptype, rearm;
 
                cons = RING_CMP(cpr->cp_ring_struct, raw_cons);
 
@@ -225,35 +203,31 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
                cons = rxcmp->opaque;
 
                mbuf = rxr->rx_buf_ring[cons];
-               rte_prefetch0(mbuf);
                rxr->rx_buf_ring[cons] = NULL;
 
-               /* Set constant fields from mbuf initializer. */
-               _mm_store_si128((__m128i *)&mbuf->rearm_data, mbuf_init);
+               /* Set fields from mbuf initializer and ol_flags. */
+               rearm = _mm_or_si128(mbuf_init,
+                                    bnxt_set_ol_flags(mm_rxcmp, mm_rxcmp1));
+               _mm_store_si128((__m128i *)&mbuf->rearm_data, rearm);
 
                /* Set mbuf pkt_len, data_len, and rss_hash fields. */
                pkt_mb = _mm_shuffle_epi8(mm_rxcmp, shuf_msk);
+
+               /* Set packet type. */
                ptype = bnxt_parse_pkt_type(mm_rxcmp, mm_rxcmp1);
                pkt_mb = _mm_blend_epi16(pkt_mb, ptype, 0x3);
 
-               _mm_storeu_si128((void *)&mbuf->rx_descriptor_fields1, pkt_mb);
+               /*
+                * Shift vlan_tci from completion metadata field left six
+                * bytes and blend into mbuf->rx_descriptor_fields1 to set
+                * mbuf->vlan_tci.
+                */
+               pkt_mb = _mm_blend_epi16(pkt_mb,
+                                        _mm_slli_si128(mm_rxcmp1, 6), 0x20);
 
-               rte_compiler_barrier();
-
-               if (rxcmp->flags_type & RX_PKT_CMPL_FLAGS_RSS_VALID)
-                       mbuf->ol_flags |= PKT_RX_RSS_HASH;
-
-               if (rxcmp1->flags2 &
-                   RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN) {
-                       mbuf->vlan_tci = rxcmp1->metadata &
-                               (RX_PKT_CMPL_METADATA_VID_MASK |
-                               RX_PKT_CMPL_METADATA_DE |
-                               RX_PKT_CMPL_METADATA_PRI_MASK);
-                       mbuf->ol_flags |=
-                               PKT_RX_VLAN | PKT_RX_VLAN_STRIPPED;
-               }
+               /* Store descriptor fields. */
+               _mm_storeu_si128((void *)&mbuf->rx_descriptor_fields1, pkt_mb);
 
-               bnxt_parse_csum(mbuf, rxcmp1);
                rx_pkts[nb_rx_pkts++] = mbuf;
        }