d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

net/bnxt: use table based mbuf flags handling

Browse Source 
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>
This commit is contained in:
Lance Richardson 2020-09-09 11:53:02 -04:00 committed by Ferruh Yigit
parent 97b1db288d
commit c1b33d4031
4 changed files with 181 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

166
drivers/net/bnxt/bnxt_rxr.c
View File

@ -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);

6
drivers/net/bnxt/bnxt_rxr.h
View File

@ -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

99
drivers/net/bnxt/bnxt_rxtx_vec_neon.c
View File

@ -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);
/* 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);
/* Store descriptor fields. */
vst1q_u32((uint32_t *)&mbuf->rx_descriptor_fields1, pkt_mb);
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;
}
bnxt_parse_csum(mbuf, rxcmp1);
rx_pkts[nb_rx_pkts++] = mbuf;
}

96
drivers/net/bnxt/bnxt_rxtx_vec_sse.c
View File

@ -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);
/*
* 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);
/* Store descriptor fields. */
_mm_storeu_si128((void *)&mbuf->rx_descriptor_fields1, pkt_mb);
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;
}
bnxt_parse_csum(mbuf, rxcmp1);
rx_pkts[nb_rx_pkts++] = mbuf;
}