net/bnxt: cleanup logs in session handling paths

[dpdk.git] / drivers / net / bnxt / bnxt_rxtx_vec_neon.c

diff --git a/drivers/net/bnxt/bnxt_rxtx_vec_neon.c b/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
index 3d54d9d..b4e9202 100644 (file)
--- a/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
+++ b/drivers/net/bnxt/bnxt_rxtx_vec_neon.c
@@ -71,8 +71,7 @@ descs_to_mbufs(uint32x4_t mm_rxcmp[4], uint32x4_t mm_rxcmp1[4],
        const uint32x4_t flags_type_mask =
                vdupq_n_u32(RX_PKT_CMPL_FLAGS_ITYPE_MASK);
        const uint32x4_t flags2_mask1 =
-               vdupq_n_u32(RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN |
-                           RX_PKT_CMPL_FLAGS2_T_IP_CS_CALC);
+               vdupq_n_u32(CMPL_FLAGS2_VLAN_TUN_MSK);
        const uint32x4_t flags2_mask2 =
                vdupq_n_u32(RX_PKT_CMPL_FLAGS2_IP_TYPE);
        const uint32x4_t rss_mask =
@@ -84,14 +83,18 @@ descs_to_mbufs(uint32x4_t mm_rxcmp[4], uint32x4_t mm_rxcmp1[4],
        uint64x2_t t0, t1;
        uint32_t ol_flags;
 
+       /* Validate ptype table indexing at build time. */
+       bnxt_check_ptype_constants();
+
        /* Compute packet type table indexes for four packets */
        t0 = vreinterpretq_u64_u32(vzip1q_u32(mm_rxcmp[0], mm_rxcmp[1]));
        t1 = vreinterpretq_u64_u32(vzip1q_u32(mm_rxcmp[2], mm_rxcmp[3]));
 
        flags_type = vreinterpretq_u32_u64(vcombine_u64(vget_low_u64(t0),
                                                        vget_low_u64(t1)));
-       ptype_idx =
-               vshrq_n_u32(vandq_u32(flags_type, flags_type_mask), 9);
+       ptype_idx = vshrq_n_u32(vandq_u32(flags_type, flags_type_mask),
+                               RX_PKT_CMPL_FLAGS_ITYPE_SFT -
+                               BNXT_PTYPE_TBL_TYPE_SFT);
 
        t0 = vreinterpretq_u64_u32(vzip1q_u32(mm_rxcmp1[0], mm_rxcmp1[1]));
        t1 = vreinterpretq_u64_u32(vzip1q_u32(mm_rxcmp1[2], mm_rxcmp1[3]));
@@ -100,9 +103,13 @@ descs_to_mbufs(uint32x4_t mm_rxcmp[4], uint32x4_t mm_rxcmp1[4],
                                                    vget_low_u64(t1)));
 
        ptype_idx = vorrq_u32(ptype_idx,
-                       vshrq_n_u32(vandq_u32(flags2, flags2_mask1), 2));
+                       vshrq_n_u32(vandq_u32(flags2, flags2_mask1),
+                                   RX_PKT_CMPL_FLAGS2_META_FORMAT_SFT -
+                                   BNXT_PTYPE_TBL_VLAN_SFT));
        ptype_idx = vorrq_u32(ptype_idx,
-                       vshrq_n_u32(vandq_u32(flags2, flags2_mask2), 7));
+                       vshrq_n_u32(vandq_u32(flags2, flags2_mask2),
+                                   RX_PKT_CMPL_FLAGS2_IP_TYPE_SFT -
+                                   BNXT_PTYPE_TBL_IP_VER_SFT));
 
        /* Extract RSS valid flags for four packets. */
        rss_flags = vshrq_n_u32(vandq_u32(flags_type, rss_mask), 9);
@@ -151,9 +158,8 @@ descs_to_mbufs(uint32x4_t mm_rxcmp[4], uint32x4_t mm_rxcmp1[4],
        vst1q_u32((uint32_t *)&mbuf[3]->rx_descriptor_fields1, tmp);
 }
 
-uint16_t
-bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
-                  uint16_t nb_pkts)
+static uint16_t
+recv_burst_vec_neon(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
 {
        struct bnxt_rx_queue *rxq = rx_queue;
        struct bnxt_cp_ring_info *cpr = rxq->cp_ring;
@@ -178,9 +184,6 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
        if (rxq->rxrearm_nb >= rxq->rx_free_thresh)
                bnxt_rxq_rearm(rxq, rxr);
 
-       /* Return no more than RTE_BNXT_MAX_RX_BURST per call. */
-       nb_pkts = RTE_MIN(nb_pkts, RTE_BNXT_MAX_RX_BURST);
-
        cons = raw_cons & (cp_ring_size - 1);
        mbcons = (raw_cons / 2) & (rx_ring_size - 1);
 
@@ -197,17 +200,20 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
         * maximum number of packets to receive to be a multiple of the per-
         * loop count.
         */
-       if (nb_pkts < RTE_BNXT_DESCS_PER_LOOP)
-               desc_valid_mask >>= 16 * (RTE_BNXT_DESCS_PER_LOOP - nb_pkts);
-       else
-               nb_pkts = RTE_ALIGN_FLOOR(nb_pkts, RTE_BNXT_DESCS_PER_LOOP);
+       if (nb_pkts < BNXT_RX_DESCS_PER_LOOP_VEC128) {
+               desc_valid_mask >>=
+                       16 * (BNXT_RX_DESCS_PER_LOOP_VEC128 - nb_pkts);
+       } else {
+               nb_pkts =
+                       RTE_ALIGN_FLOOR(nb_pkts, BNXT_RX_DESCS_PER_LOOP_VEC128);
+       }
 
        /* Handle RX burst request */
-       for (i = 0; i < nb_pkts; i += RTE_BNXT_DESCS_PER_LOOP,
-                                 cons += RTE_BNXT_DESCS_PER_LOOP * 2,
-                                 mbcons += RTE_BNXT_DESCS_PER_LOOP) {
-               uint32x4_t rxcmp1[RTE_BNXT_DESCS_PER_LOOP];
-               uint32x4_t rxcmp[RTE_BNXT_DESCS_PER_LOOP];
+       for (i = 0; i < nb_pkts; i += BNXT_RX_DESCS_PER_LOOP_VEC128,
+                                 cons += BNXT_RX_DESCS_PER_LOOP_VEC128 * 2,
+                                 mbcons += BNXT_RX_DESCS_PER_LOOP_VEC128) {
+               uint32x4_t rxcmp1[BNXT_RX_DESCS_PER_LOOP_VEC128];
+               uint32x4_t rxcmp[BNXT_RX_DESCS_PER_LOOP_VEC128];
                uint32x4_t info3_v;
                uint64x2_t t0, t1;
                uint32_t num_valid;
@@ -223,7 +229,7 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
 #endif
 
                /* Prefetch four descriptor pairs for next iteration. */
-               if (i + RTE_BNXT_DESCS_PER_LOOP < nb_pkts) {
+               if (i + BNXT_RX_DESCS_PER_LOOP_VEC128 < nb_pkts) {
                        rte_prefetch0(&cp_desc_ring[cons + 8]);
                        rte_prefetch0(&cp_desc_ring[cons + 12]);
                }
@@ -281,7 +287,7 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
                               rxr);
                nb_rx_pkts += num_valid;
 
-               if (num_valid < RTE_BNXT_DESCS_PER_LOOP)
+               if (num_valid < BNXT_RX_DESCS_PER_LOOP_VEC128)
                        break;
        }
 
@@ -298,6 +304,27 @@ bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
        return nb_rx_pkts;
 }
 
+uint16_t
+bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts, uint16_t nb_pkts)
+{
+       uint16_t cnt = 0;
+
+       while (nb_pkts > RTE_BNXT_MAX_RX_BURST) {
+               uint16_t burst;
+
+               burst = recv_burst_vec_neon(rx_queue, rx_pkts + cnt,
+                                           RTE_BNXT_MAX_RX_BURST);
+
+               cnt += burst;
+               nb_pkts -= burst;
+
+               if (burst < RTE_BNXT_MAX_RX_BURST)
+                       return cnt;
+       }
+
+       return cnt + recv_burst_vec_neon(rx_queue, rx_pkts + cnt, nb_pkts);
+}
+
 static void
 bnxt_handle_tx_cp_vec(struct bnxt_tx_queue *txq)
 {
@@ -346,7 +373,7 @@ bnxt_xmit_fixed_burst_vec(void *tx_queue, struct rte_mbuf **tx_pkts,
        uint16_t tx_prod, tx_raw_prod = txr->tx_raw_prod;
        struct rte_mbuf *tx_mbuf;
        struct tx_bd_long *txbd = NULL;
-       struct bnxt_sw_tx_bd *tx_buf;
+       struct rte_mbuf **tx_buf;
        uint16_t to_send;
 
        nb_pkts = RTE_MIN(nb_pkts, bnxt_tx_avail(txq));
@@ -362,8 +389,7 @@ bnxt_xmit_fixed_burst_vec(void *tx_queue, struct rte_mbuf **tx_pkts,
 
                tx_prod = RING_IDX(txr->tx_ring_struct, tx_raw_prod);
                tx_buf = &txr->tx_buf_ring[tx_prod];
-               tx_buf->mbuf = tx_mbuf;
-               tx_buf->nr_bds = 1;
+               *tx_buf = tx_mbuf;
 
                txbd = &txr->tx_desc_ring[tx_prod];
                txbd->address = tx_mbuf->buf_iova + tx_mbuf->data_off;