Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2014-2023 Broadcom
       3                 :            :  * All rights reserved.
       4                 :            :  */
       5                 :            : 
       6                 :            : #ifndef _BNXT_RXR_H_
       7                 :            : #define _BNXT_RXR_H_
       8                 :            : #include "hsi_struct_def_dpdk.h"
       9                 :            : 
      10                 :            : #define BNXT_TPA_START_AGG_ID_PRE_TH(cmp) \
      11                 :            :         ((rte_le_to_cpu_16((cmp)->agg_id) & RX_TPA_START_CMPL_AGG_ID_MASK) >> \
      12                 :            :          RX_TPA_START_CMPL_AGG_ID_SFT)
      13                 :            : 
      14                 :            : #define BNXT_TPA_START_AGG_ID_TH(cmp) \
      15                 :            :         rte_le_to_cpu_16((cmp)->agg_id)
      16                 :            : 
      17                 :            : static inline uint16_t bnxt_tpa_start_agg_id(struct bnxt *bp,
      18                 :            :                                              struct rx_tpa_start_cmpl *cmp)
      19                 :            : {
      20         [ #  # ]:          0 :         if (BNXT_CHIP_P5_P7(bp))
      21                 :          0 :                 return BNXT_TPA_START_AGG_ID_TH(cmp);
      22                 :            :         else
      23                 :          0 :                 return BNXT_TPA_START_AGG_ID_PRE_TH(cmp);
      24                 :            : }
      25                 :            : 
      26                 :            : #define BNXT_TPA_END_AGG_BUFS(cmp) \
      27                 :            :         (((cmp)->agg_bufs_v1 & RX_TPA_END_CMPL_AGG_BUFS_MASK) \
      28                 :            :          >> RX_TPA_END_CMPL_AGG_BUFS_SFT)
      29                 :            : 
      30                 :            : #define BNXT_TPA_END_AGG_BUFS_TH(cmp) \
      31                 :            :         ((cmp)->tpa_agg_bufs)
      32                 :            : 
      33                 :            : #define BNXT_TPA_END_AGG_ID(cmp) \
      34                 :            :         (((cmp)->agg_id & RX_TPA_END_CMPL_AGG_ID_MASK) >> \
      35                 :            :          RX_TPA_END_CMPL_AGG_ID_SFT)
      36                 :            : 
      37                 :            : #define BNXT_TPA_END_AGG_ID_TH(cmp) \
      38                 :            :         rte_le_to_cpu_16((cmp)->agg_id)
      39                 :            : 
      40                 :            : #define BNXT_RX_L2_AGG_BUFS(cmp) \
      41                 :            :         (((cmp)->agg_bufs_v1 & RX_PKT_CMPL_AGG_BUFS_MASK) >> \
      42                 :            :                 RX_PKT_CMPL_AGG_BUFS_SFT)
      43                 :            : 
      44                 :            : /* Number of descriptors to process per inner loop in vector mode. */
      45                 :            : #define BNXT_RX_DESCS_PER_LOOP_VEC128   4U /* SSE, Neon */
      46                 :            : #define BNXT_RX_DESCS_PER_LOOP_VEC256   8U /* AVX2 */
      47                 :            : 
      48                 :            : /* Number of extra Rx mbuf ring entries to allocate for vector mode. */
      49                 :            : #define BNXT_RX_EXTRA_MBUF_ENTRIES \
      50                 :            :         RTE_MAX(BNXT_RX_DESCS_PER_LOOP_VEC128, BNXT_RX_DESCS_PER_LOOP_VEC256)
      51                 :            : 
      52                 :            : #define BNXT_OL_FLAGS_TBL_DIM   64
      53                 :            : #define BNXT_OL_FLAGS_ERR_TBL_DIM 32
      54                 :            : 
      55                 :            : #define BNXT_CRX_CQE_OPAQUE_MASK                \
      56                 :            :         RX_PKT_COMPRESS_CMPL_ERRORS_AGG_BUFS_OPAQUE_OPAQUE_MASK
      57                 :            : #define BNXT_CRX_CQE_AGG_BUF_MASK               \
      58                 :            :         RX_PKT_COMPRESS_CMPL_ERRORS_AGG_BUFS_OPAQUE_AGG_BUFS_MASK
      59                 :            : #define BNXT_CRX_CQE_AGG_BUF_SFT                \
      60                 :            :         RX_PKT_COMPRESS_CMPL_ERRORS_AGG_BUFS_OPAQUE_AGG_BUFS_SFT
      61                 :            : #define BNXT_CRX_CQE_AGG_BUFS(cmp)              \
      62                 :            :         (((cmp)->errors_agg_bufs_opaque & BNXT_CRX_CQE_AGG_BUF_MASK) >> \
      63                 :            :          BNXT_CRX_CQE_AGG_BUF_SFT)
      64                 :            : #define BNXT_CRX_CQE_CSUM_CALC_MASK             \
      65                 :            :         (RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_IP_CS_CALC | \
      66                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_L4_CS_CALC | \
      67                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_IP_CS_CALC | \
      68                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_L4_CS_CALC)
      69                 :            : #define BNXT_CRX_CQE_CSUM_CALC_SFT      8
      70                 :            : #define BNXT_PKT_CMPL_T_IP_CS_CALC      0x4
      71                 :            : 
      72                 :            : #define BNXT_CRX_TUN_CS_CALC                                  \
      73                 :            :         (!!(RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_IP_CS_CALC | \
      74                 :            :             RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_L4_CS_CALC))
      75                 :            : 
      76                 :            : # define BNXT_CRX_CQE_CSUM_ERROR_MASK           \
      77                 :            :         (RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_IP_CS_ERROR | \
      78                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_L4_CS_ERROR | \
      79                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_IP_CS_ERROR | \
      80                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_L4_CS_ERROR)
      81                 :            : 
      82                 :            : /* meta_format != 0 and bit3 is valid, the value in meta is VLAN.
      83                 :            :  * Use the bit as VLAN valid bit
      84                 :            :  */
      85                 :            : #define BNXT_RXC_METADATA1_VLAN_VALID           \
      86                 :            :         RX_PKT_COMPRESS_CMPL_METADATA1_VALID
      87                 :            : 
      88                 :            : static inline void bnxt_set_vlan_crx(struct rx_pkt_compress_cmpl *rxcmp,
      89                 :            :                                      struct rte_mbuf *mbuf)
      90                 :            : {
      91                 :            :         uint16_t metadata = rte_le_to_cpu_16(rxcmp->metadata1_cs_error_calc_v1);
      92                 :          0 :         uint16_t vlan_tci = rte_le_to_cpu_16(rxcmp->vlanc_tcid);
      93                 :            : 
      94         [ #  # ]:          0 :         if (metadata & RX_PKT_COMPRESS_CMPL_METADATA1_VALID)
      95                 :          0 :                 mbuf->vlan_tci =
      96                 :            :                         vlan_tci & (RX_PKT_COMPRESS_CMPL_VLANC_TCID_VID_MASK |
      97                 :            :                                     RX_PKT_COMPRESS_CMPL_VLANC_TCID_DE |
      98                 :            :                                     RX_PKT_COMPRESS_CMPL_VLANC_TCID_PRI_MASK);
      99                 :            : }
     100                 :            : 
     101                 :            : struct bnxt_tpa_info {
     102                 :            :         struct rte_mbuf                 *mbuf;
     103                 :            :         uint16_t                        len;
     104                 :            :         uint32_t                        agg_count;
     105                 :            :         struct rx_tpa_v2_abuf_cmpl      agg_arr[TPA_MAX_NUM_SEGS];
     106                 :            : 
     107                 :            :         uint32_t                        rss_hash;
     108                 :            :         uint32_t                        vlan;
     109                 :            :         uint16_t                        cfa_code;
     110                 :            :         uint8_t                         hash_valid:1;
     111                 :            :         uint8_t                         vlan_valid:1;
     112                 :            :         uint8_t                         cfa_code_valid:1;
     113                 :            :         uint8_t                         l4_csum_valid:1;
     114                 :            : };
     115                 :            : 
     116                 :            : struct bnxt_rx_ring_info {
     117                 :            :         uint16_t                rx_raw_prod;
     118                 :            :         uint16_t                ag_raw_prod;
     119                 :            :         uint16_t                ag_cons; /* Needed with compressed CQE */
     120                 :            :         uint16_t                rx_cons; /* Needed for representor */
     121                 :            :         uint16_t                rx_next_cons;
     122                 :            :         struct bnxt_db_info     rx_db;
     123                 :            :         struct bnxt_db_info     ag_db;
     124                 :            : 
     125                 :            :         struct rx_prod_pkt_bd   *rx_desc_ring;
     126                 :            :         struct rx_prod_pkt_bd   *ag_desc_ring;
     127                 :            :         struct rte_mbuf         **rx_buf_ring; /* sw ring */
     128                 :            :         struct rte_mbuf         **ag_buf_ring; /* sw ring */
     129                 :            : 
     130                 :            :         rte_iova_t              rx_desc_mapping;
     131                 :            :         rte_iova_t              ag_desc_mapping;
     132                 :            : 
     133                 :            :         struct bnxt_ring        *rx_ring_struct;
     134                 :            :         struct bnxt_ring        *ag_ring_struct;
     135                 :            : 
     136                 :            :         /*
     137                 :            :          * To deal with out of order return from TPA, use free buffer indicator
     138                 :            :          */
     139                 :            :         struct rte_bitmap       *ag_bitmap;
     140                 :            : 
     141                 :            :         struct bnxt_tpa_info *tpa_info;
     142                 :            : 
     143                 :            :         uint32_t ol_flags_table[BNXT_OL_FLAGS_TBL_DIM];
     144                 :            :         uint32_t ol_flags_err_table[BNXT_OL_FLAGS_ERR_TBL_DIM];
     145                 :            :         uint8_t                 dpi;  /* Doorbell page index for multi-doorbell support */
     146                 :            : };
     147                 :            : 
     148                 :            : uint16_t bnxt_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
     149                 :            :                                uint16_t nb_pkts);
     150                 :            : void bnxt_free_rx_rings(struct bnxt *bp);
     151                 :            : int bnxt_init_rx_ring_struct(struct bnxt_rx_queue *rxq, unsigned int socket_id);
     152                 :            : int bnxt_init_one_rx_ring(struct bnxt_rx_queue *rxq);
     153                 :            : int bnxt_rx_queue_start(struct rte_eth_dev *dev, uint16_t rx_queue_id);
     154                 :            : int bnxt_rx_queue_stop(struct rte_eth_dev *dev, uint16_t rx_queue_id);
     155                 :            : int bnxt_flush_rx_cmp(struct bnxt_cp_ring_info *cpr);
     156                 :            : 
     157                 :            : #if defined(RTE_ARCH_X86) || defined(RTE_ARCH_ARM64)
     158                 :            : uint16_t bnxt_recv_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
     159                 :            :                             uint16_t nb_pkts);
     160                 :            : uint16_t bnxt_crx_pkts_vec(void *rx_queue, struct rte_mbuf **rx_pkts,
     161                 :            :                            uint16_t nb_pkts);
     162                 :            : int bnxt_rxq_vec_setup(struct bnxt_rx_queue *rxq);
     163                 :            : #endif
     164                 :            : 
     165                 :            : #if defined(RTE_ARCH_X86)
     166                 :            : uint16_t bnxt_recv_pkts_vec_avx2(void *rx_queue, struct rte_mbuf **rx_pkts,
     167                 :            :                                  uint16_t nb_pkts);
     168                 :            : uint16_t bnxt_recv_pkts_vec_avx2_v3(void *rx_queue, struct rte_mbuf **rx_pkts,
     169                 :            :                                     uint16_t nb_pkts);
     170                 :            : uint16_t bnxt_crx_pkts_vec_avx2(void *rx_queue, struct rte_mbuf **rx_pkts,
     171                 :            :                                 uint16_t nb_pkts);
     172                 :            : #endif
     173                 :            : void bnxt_set_mark_in_mbuf(struct bnxt *bp,
     174                 :            :                            struct rx_pkt_cmpl_hi *rxcmp1,
     175                 :            :                            struct rte_mbuf *mbuf);
     176                 :            : 
     177                 :            : typedef uint32_t bnxt_cfa_code_dynfield_t;
     178                 :            : extern int bnxt_cfa_code_dynfield_offset;
     179                 :            : 
     180                 :            : static inline bnxt_cfa_code_dynfield_t *
     181                 :            : bnxt_cfa_code_dynfield(struct rte_mbuf *mbuf)
     182                 :            : {
     183                 :          0 :         return RTE_MBUF_DYNFIELD(mbuf,
     184                 :            :                 bnxt_cfa_code_dynfield_offset, bnxt_cfa_code_dynfield_t *);
     185                 :            : }
     186                 :            : 
     187                 :            : static __rte_always_inline void
     188                 :            : bnxt_timestamp_dynfield_set(struct rte_mbuf *mbuf, int offset,
     189                 :            :                             rte_mbuf_timestamp_t ts)
     190                 :            : {
     191                 :            :         *RTE_MBUF_DYNFIELD(mbuf, offset, rte_mbuf_timestamp_t *) = ts;
     192                 :            : }
     193                 :            : 
     194                 :            : #define BNXT_RX_META_CFA_CODE_SHIFT             19
     195                 :            : #define BNXT_CFA_CODE_META_SHIFT                16
     196                 :            : #define BNXT_RX_META_CFA_CODE_INT_ACT_REC_BIT   0x8000000
     197                 :            : #define BNXT_RX_META_CFA_CODE_EEM_BIT           0x4000000
     198                 :            : #define BNXT_CFA_META_FMT_MASK                  0x70
     199                 :            : #define BNXT_CFA_META_FMT_SHFT                  4
     200                 :            : #define BNXT_CFA_META_FMT_EM_EEM_SHFT           1
     201                 :            : #define BNXT_CFA_META_FMT_EEM                   3
     202                 :            : #define BNXT_CFA_META_EEM_TCAM_SHIFT            31
     203                 :            : #define BNXT_CFA_META_EM_TEST(x) ((x) >> BNXT_CFA_META_EEM_TCAM_SHIFT)
     204                 :            : 
     205                 :            : /* Definitions for translation of hardware packet type to mbuf ptype. */
     206                 :            : #define BNXT_PTYPE_TBL_DIM              128
     207                 :            : #define BNXT_PTYPE_TBL_TUN_SFT          0 /* Set if tunneled packet. */
     208                 :            : #define BNXT_PTYPE_TBL_TUN_MSK          BIT(BNXT_PTYPE_TBL_TUN_SFT)
     209                 :            : #define BNXT_PTYPE_TBL_IP_VER_SFT       1 /* Set if IPv6, clear if IPv4. */
     210                 :            : #define BNXT_PTYPE_TBL_IP_VER_MSK       BIT(BNXT_PTYPE_TBL_IP_VER_SFT)
     211                 :            : #define BNXT_PTYPE_TBL_VLAN_SFT         2 /* Set if VLAN encapsulated. */
     212                 :            : #define BNXT_PTYPE_TBL_VLAN_MSK         BIT(BNXT_PTYPE_TBL_VLAN_SFT)
     213                 :            : #define BNXT_PTYPE_TBL_TYPE_SFT         3 /* Hardware packet type field. */
     214                 :            : #define BNXT_PTYPE_TBL_TYPE_MSK         0x78 /* Hardware itype field mask. */
     215                 :            : #define BNXT_PTYPE_TBL_TYPE_IP          1
     216                 :            : #define BNXT_PTYPE_TBL_TYPE_TCP         2
     217                 :            : #define BNXT_PTYPE_TBL_TYPE_UDP         3
     218                 :            : #define BNXT_PTYPE_TBL_TYPE_ICMP        7
     219                 :            : 
     220                 :            : #define RX_PKT_CMPL_FLAGS2_IP_TYPE_SFT  8
     221                 :            : #define CMPL_FLAGS2_VLAN_TUN_MSK \
     222                 :            :         (RX_PKT_CMPL_FLAGS2_META_FORMAT_VLAN | RX_PKT_CMPL_FLAGS2_T_IP_CS_CALC)
     223                 :            : 
     224                 :            : #define CMPL_FLAGS2_VLAN_TUN_MSK_CRX \
     225                 :            :         (RX_PKT_COMPRESS_CMPL_METADATA1_VALID | \
     226                 :            :          RX_PKT_COMPRESS_CMPL_CS_ERROR_CALC_T_IP_CS_CALC)
     227                 :            : 
     228                 :            : #define BNXT_CMPL_ITYPE_TO_IDX(ft) \
     229                 :            :         (((ft) & RX_PKT_CMPL_FLAGS_ITYPE_MASK) >> \
     230                 :            :           (RX_PKT_CMPL_FLAGS_ITYPE_SFT - BNXT_PTYPE_TBL_TYPE_SFT))
     231                 :            : 
     232                 :            : #define BNXT_CMPL_VLAN_TUN_TO_IDX(f2) \
     233                 :            :         (((f2) & CMPL_FLAGS2_VLAN_TUN_MSK) >> \
     234                 :            :          (RX_PKT_CMPL_FLAGS2_META_FORMAT_SFT - BNXT_PTYPE_TBL_VLAN_SFT))
     235                 :            : 
     236                 :            : #define BNXT_CMPL_VLAN_TUN_TO_IDX_CRX(md) \
     237                 :            :         (((md) & CMPL_FLAGS2_VLAN_TUN_MSK_CRX) >> \
     238                 :            :          (RX_PKT_COMPRESS_CMPL_METADATA1_SFT - BNXT_PTYPE_TBL_VLAN_SFT))
     239                 :            : 
     240                 :            : #define BNXT_CMPL_IP_VER_TO_IDX(f2) \
     241                 :            :         (((f2) & RX_PKT_CMPL_FLAGS2_IP_TYPE) >> \
     242                 :            :          (RX_PKT_CMPL_FLAGS2_IP_TYPE_SFT - BNXT_PTYPE_TBL_IP_VER_SFT))
     243                 :            : 
     244                 :            : static inline void
     245                 :            : bnxt_check_ptype_constants(void)
     246                 :            : {
     247                 :            :         RTE_BUILD_BUG_ON(BNXT_CMPL_ITYPE_TO_IDX(RX_PKT_CMPL_FLAGS_ITYPE_MASK) !=
     248                 :            :                          BNXT_PTYPE_TBL_TYPE_MSK);
     249                 :            :         RTE_BUILD_BUG_ON(BNXT_CMPL_VLAN_TUN_TO_IDX(CMPL_FLAGS2_VLAN_TUN_MSK) !=
     250                 :            :                          (BNXT_PTYPE_TBL_VLAN_MSK | BNXT_PTYPE_TBL_TUN_MSK));
     251                 :            :         RTE_BUILD_BUG_ON(BNXT_CMPL_IP_VER_TO_IDX(RX_PKT_CMPL_FLAGS2_IP_TYPE) !=
     252                 :            :                          BNXT_PTYPE_TBL_IP_VER_MSK);
     253                 :            : }
     254                 :            : 
     255                 :            : extern uint32_t bnxt_ptype_table[BNXT_PTYPE_TBL_DIM];
     256                 :            : 
     257                 :            : static inline void bnxt_set_vlan(struct rx_pkt_cmpl_hi *rxcmp1,
     258                 :            :                                  struct rte_mbuf *mbuf)
     259                 :            : {
     260                 :          0 :         uint32_t metadata = rte_le_to_cpu_32(rxcmp1->metadata);
     261                 :            : 
     262         [ #  # ]:          0 :         mbuf->vlan_tci = metadata & (RX_PKT_CMPL_METADATA_VID_MASK |
     263                 :            :                                      RX_PKT_CMPL_METADATA_DE |
     264                 :            :                                      RX_PKT_CMPL_METADATA_PRI_MASK);
     265                 :            : }
     266                 :            : 
     267                 :            : /* Stingray2 specific code for RX completion parsing */
     268                 :            : #define RX_CMP_VLAN_VALID(rxcmp)        \
     269                 :            :         (((struct rx_pkt_v2_cmpl *)rxcmp)->metadata1_payload_offset &    \
     270                 :            :          RX_PKT_V2_CMPL_METADATA1_VALID)
     271                 :            : 
     272                 :            : #define RX_CMP_METADATA0_VID(rxcmp1)                            \
     273                 :            :         ((((struct rx_pkt_v2_cmpl_hi *)rxcmp1)->metadata0) &     \
     274                 :            :          (RX_PKT_V2_CMPL_HI_METADATA0_VID_MASK |                \
     275                 :            :           RX_PKT_V2_CMPL_HI_METADATA0_DE  |                     \
     276                 :            :           RX_PKT_V2_CMPL_HI_METADATA0_PRI_MASK))
     277                 :            : 
     278                 :            : static inline void bnxt_rx_vlan_v2(struct rte_mbuf *mbuf,
     279                 :            :                                    const struct bnxt *bp,
     280                 :            :                                    struct rx_pkt_cmpl *rxcmp,
     281                 :            :                                    struct rx_pkt_cmpl_hi *rxcmp1)
     282                 :            : {
     283         [ #  # ]:          0 :         if (RX_CMP_VLAN_VALID(rxcmp)) {
     284                 :          0 :                 mbuf->vlan_tci = RX_CMP_METADATA0_VID(rxcmp1);
     285                 :          0 :                 mbuf->ol_flags |= RTE_MBUF_F_RX_VLAN;
     286         [ #  # ]:          0 :                 if (BNXT_RX_VLAN_STRIP_EN(bp))
     287                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_VLAN_STRIPPED;
     288                 :            :         }
     289                 :            : }
     290                 :            : 
     291                 :            : #define RX_CMP_FLAGS2_CS_ALL_OK_MODE_MASK       (0x1 << 3)
     292                 :            : #define RX_CMP_FLAGS2_CS_OK_HDR_CNT_MASK        (0x7 << 10)
     293                 :            : #define RX_CMP_FLAGS2_IP_CSUM_ALL_OK_MASK       (0x1 << 13)
     294                 :            : #define RX_CMP_FLAGS2_L4_CSUM_ALL_OK_MASK       (0x1 << 14)
     295                 :            : 
     296                 :            : #define RX_CMP_V2_CS_OK_HDR_CNT(flags)                          \
     297                 :            :         (((flags) & RX_CMP_FLAGS2_CS_OK_HDR_CNT_MASK) >>      \
     298                 :            :          RX_PKT_V2_CMPL_HI_FLAGS2_CS_OK_SFT)
     299                 :            : 
     300                 :            : #define RX_CMP_V2_CS_ALL_OK_MODE(flags)                         \
     301                 :            :         (((flags) & RX_CMP_FLAGS2_CS_ALL_OK_MODE_MASK))
     302                 :            : 
     303                 :            : #define RX_CMP_FLAGS2_L3_CS_OK_MASK             (0x7 << 10)
     304                 :            : #define RX_CMP_FLAGS2_L4_CS_OK_MASK             (0x38 << 10)
     305                 :            : #define RX_CMP_FLAGS2_L3_CS_OK_SFT              10
     306                 :            : #define RX_CMP_FLAGS2_L4_CS_OK_SFT              13
     307                 :            : 
     308                 :            : #define RX_CMP_V2_L4_CS_OK(flags2)                      \
     309                 :            :         (((flags2) & RX_CMP_FLAGS2_L4_CS_OK_MASK) >>  \
     310                 :            :          RX_CMP_FLAGS2_L4_CS_OK_SFT)
     311                 :            : 
     312                 :            : #define RX_CMP_V2_L3_CS_OK(flags2)                      \
     313                 :            :         (((flags2) & RX_CMP_FLAGS2_L3_CS_OK_MASK) >>  \
     314                 :            :          RX_CMP_FLAGS2_L3_CS_OK_SFT)
     315                 :            : 
     316                 :            : #define RX_CMP_V2_L4_CS_ERR(err)                                \
     317                 :            :         (((err) & RX_PKT_V2_CMPL_HI_ERRORS_PKT_ERROR_MASK)  ==      \
     318                 :            :          RX_PKT_V2_CMPL_HI_ERRORS_PKT_ERROR_L4_CS_ERROR)
     319                 :            : 
     320                 :            : #define RX_CMP_V2_L3_CS_ERR(err)                                \
     321                 :            :         (((err) & RX_PKT_V2_CMPL_HI_ERRORS_PKT_ERROR_MASK) ==       \
     322                 :            :          RX_PKT_V2_CMPL_HI_ERRORS_PKT_ERROR_IP_CS_ERROR)
     323                 :            : 
     324                 :            : #define RX_CMP_V2_T_IP_CS_ERR(err)                              \
     325                 :            :         (((err) & RX_PKT_V2_CMPL_HI_ERRORS_T_PKT_ERROR_MASK) ==     \
     326                 :            :          RX_PKT_V2_CMPL_HI_ERRORS_T_PKT_ERROR_T_IP_CS_ERROR)
     327                 :            : 
     328                 :            : #define RX_CMP_V2_T_L4_CS_ERR(err)                              \
     329                 :            :         (((err) & RX_PKT_V2_CMPL_HI_ERRORS_T_PKT_ERROR_MASK) ==     \
     330                 :            :          RX_PKT_V2_CMPL_HI_ERRORS_T_PKT_ERROR_T_L4_CS_ERROR)
     331                 :            : 
     332                 :            : #define RX_CMP_V2_OT_L4_CS_ERR(err)                                     \
     333                 :            :         (((err) & RX_PKT_V2_CMPL_HI_ERRORS_OT_PKT_ERROR_MASK) ==    \
     334                 :            :          RX_PKT_V2_CMPL_HI_ERRORS_OT_PKT_ERROR_OT_L4_CS_ERROR)
     335                 :            : 
     336                 :          0 : static inline void bnxt_parse_csum_v2(struct rte_mbuf *mbuf,
     337                 :            :                                       struct rx_pkt_cmpl_hi *rxcmp1)
     338                 :            : {
     339                 :            :         struct rx_pkt_v2_cmpl_hi *v2_cmp =
     340                 :            :                 (struct rx_pkt_v2_cmpl_hi *)(rxcmp1);
     341                 :          0 :         uint16_t error_v2 = rte_le_to_cpu_16(v2_cmp->errors_v2);
     342                 :          0 :         uint32_t flags2 = rte_le_to_cpu_32(v2_cmp->flags2);
     343                 :            :         uint32_t hdr_cnt = 0, t_pkt = 0;
     344                 :            : 
     345         [ #  # ]:          0 :         if (RX_CMP_V2_CS_ALL_OK_MODE(flags2)) {
     346                 :          0 :                 hdr_cnt = RX_CMP_V2_CS_OK_HDR_CNT(flags2);
     347         [ #  # ]:          0 :                 if (hdr_cnt > 1)
     348                 :            :                         t_pkt = 1;
     349                 :            : 
     350         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V2_L4_CS_ERR(error_v2)))
     351                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
     352         [ #  # ]:          0 :                 else if (flags2 & RX_CMP_FLAGS2_L4_CSUM_ALL_OK_MASK)
     353                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     354                 :            :                 else
     355                 :            :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_UNKNOWN;
     356                 :            : 
     357         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V2_L3_CS_ERR(error_v2)))
     358                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     359         [ #  # ]:          0 :                 else if (flags2 & RX_CMP_FLAGS2_IP_CSUM_ALL_OK_MASK)
     360                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     361                 :            :                 else
     362                 :            :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN;
     363                 :            :         } else {
     364                 :          0 :                 hdr_cnt = RX_CMP_V2_L4_CS_OK(flags2);
     365         [ #  # ]:          0 :                 if (hdr_cnt > 1)
     366                 :            :                         t_pkt = 1;
     367                 :            : 
     368         [ #  # ]:          0 :                 if (RX_CMP_V2_L4_CS_OK(flags2))
     369                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     370         [ #  # ]:          0 :                 else if (RX_CMP_V2_L4_CS_ERR(error_v2))
     371                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
     372                 :            :                 else
     373                 :            :                         mbuf->ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_UNKNOWN;
     374                 :            : 
     375         [ #  # ]:          0 :                 if (RX_CMP_V2_L3_CS_OK(flags2))
     376                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     377         [ #  # ]:          0 :                 else if (RX_CMP_V2_L3_CS_ERR(error_v2))
     378                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     379                 :            :                 else
     380                 :            :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN;
     381                 :            :         }
     382                 :            : 
     383         [ #  # ]:          0 :         if (t_pkt) {
     384   [ #  #  #  # ]:          0 :                 if (unlikely(RX_CMP_V2_OT_L4_CS_ERR(error_v2) ||
     385                 :            :                                         RX_CMP_V2_T_L4_CS_ERR(error_v2)))
     386                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_BAD;
     387                 :            :                 else
     388                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_GOOD;
     389                 :            : 
     390         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V2_T_IP_CS_ERR(error_v2)))
     391                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     392                 :            :         }
     393                 :          0 : }
     394                 :            : 
     395                 :            : static inline void
     396                 :          0 : bnxt_parse_pkt_type_v2(struct rte_mbuf *mbuf,
     397                 :            :                        struct rx_pkt_cmpl *rxcmp,
     398                 :            :                        struct rx_pkt_cmpl_hi *rxcmp1)
     399                 :            : {
     400                 :            :         struct rx_pkt_v2_cmpl *v2_cmp =
     401                 :            :                 (struct rx_pkt_v2_cmpl *)(rxcmp);
     402                 :            :         struct rx_pkt_v2_cmpl_hi *v2_cmp1 =
     403                 :            :                 (struct rx_pkt_v2_cmpl_hi *)(rxcmp1);
     404                 :          0 :         uint16_t flags_type = v2_cmp->flags_type &
     405                 :            :                 rte_cpu_to_le_32(RX_PKT_V2_CMPL_FLAGS_ITYPE_MASK);
     406                 :          0 :         uint32_t flags2 = rte_le_to_cpu_32(v2_cmp1->flags2);
     407                 :            :         uint32_t l3, pkt_type = 0, vlan = 0;
     408                 :            :         uint32_t ip6 = 0, t_pkt = 0;
     409                 :            :         uint32_t hdr_cnt, csum_count;
     410                 :            : 
     411         [ #  # ]:          0 :         if (RX_CMP_V2_CS_ALL_OK_MODE(flags2)) {
     412                 :          0 :                 hdr_cnt = RX_CMP_V2_CS_OK_HDR_CNT(flags2);
     413         [ #  # ]:          0 :                 if (hdr_cnt > 1)
     414                 :            :                         t_pkt = 1;
     415                 :            :         } else {
     416                 :          0 :                 csum_count = RX_CMP_V2_L4_CS_OK(flags2);
     417         [ #  # ]:          0 :                 if (csum_count > 1)
     418                 :            :                         t_pkt = 1;
     419                 :            :         }
     420                 :            : 
     421                 :          0 :         vlan = !!RX_CMP_VLAN_VALID(rxcmp);
     422         [ #  # ]:          0 :         pkt_type |= vlan ? RTE_PTYPE_L2_ETHER_VLAN : RTE_PTYPE_L2_ETHER;
     423                 :            : 
     424                 :          0 :         ip6 = !!(flags2 & RX_PKT_V2_CMPL_HI_FLAGS2_IP_TYPE);
     425                 :            : 
     426         [ #  # ]:          0 :         if (!t_pkt && !ip6)
     427                 :            :                 l3 = RTE_PTYPE_L3_IPV4_EXT_UNKNOWN;
     428         [ #  # ]:          0 :         else if (!t_pkt && ip6)
     429                 :            :                 l3 = RTE_PTYPE_L3_IPV6_EXT_UNKNOWN;
     430         [ #  # ]:          0 :         else if (t_pkt && !ip6)
     431                 :            :                 l3 = RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN;
     432                 :            :         else
     433                 :            :                 l3 = RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN;
     434                 :            : 
     435   [ #  #  #  #  :          0 :         switch (flags_type) {
                      # ]
     436                 :          0 :         case RTE_LE32(RX_PKT_V2_CMPL_FLAGS_ITYPE_ICMP):
     437         [ #  # ]:          0 :                 if (!t_pkt)
     438                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_L4_ICMP;
     439                 :            :                 else
     440                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_ICMP;
     441                 :            :                 break;
     442                 :          0 :         case RTE_LE32(RX_PKT_V2_CMPL_FLAGS_ITYPE_TCP):
     443         [ #  # ]:          0 :                 if (!t_pkt)
     444                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_L4_TCP;
     445                 :            :                 else
     446                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_TCP;
     447                 :            :                 break;
     448                 :          0 :         case RTE_LE32(RX_PKT_V2_CMPL_FLAGS_ITYPE_UDP):
     449         [ #  # ]:          0 :                 if (!t_pkt)
     450                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_L4_UDP;
     451                 :            :                 else
     452                 :          0 :                         pkt_type |= l3 | RTE_PTYPE_INNER_L4_UDP;
     453                 :            :                 break;
     454                 :          0 :         case RTE_LE32(RX_PKT_V2_CMPL_FLAGS_ITYPE_IP):
     455                 :          0 :                 pkt_type |= l3;
     456                 :          0 :                 break;
     457                 :            :         }
     458                 :            : 
     459                 :          0 :         mbuf->packet_type = pkt_type;
     460                 :          0 : }
     461                 :            : 
     462                 :            : /* Thor2 specific code for RX completion parsing */
     463                 :            : #define RX_PKT_V3_CMPL_FLAGS2_IP_TYPE_SFT       8
     464                 :            : #define RX_PKT_V3_CMPL_METADATA1_VALID_SFT      15
     465                 :            : 
     466                 :            : #define BNXT_CMPL_V3_ITYPE_TO_IDX(ft) \
     467                 :            :         (((ft) & RX_PKT_V3_CMPL_FLAGS_ITYPE_MASK) >> \
     468                 :            :          (RX_PKT_V3_CMPL_FLAGS_ITYPE_SFT - BNXT_PTYPE_TBL_TYPE_SFT))
     469                 :            : 
     470                 :            : #define BNXT_CMPL_V3_VLAN_TO_IDX(meta) \
     471                 :            :         (((meta) & (1 << RX_PKT_V3_CMPL_METADATA1_VALID_SFT)) >> \
     472                 :            :          (RX_PKT_V3_CMPL_METADATA1_VALID_SFT - BNXT_PTYPE_TBL_VLAN_SFT))
     473                 :            : 
     474                 :            : #define BNXT_CMPL_V3_IP_VER_TO_IDX(f2) \
     475                 :            :         (((f2) & RX_PKT_V3_CMPL_HI_FLAGS2_IP_TYPE) >> \
     476                 :            :          (RX_PKT_V3_CMPL_FLAGS2_IP_TYPE_SFT - BNXT_PTYPE_TBL_IP_VER_SFT))
     477                 :            : 
     478                 :            : #define RX_CMP_V3_VLAN_VALID(rxcmp)        \
     479                 :            :         (((struct rx_pkt_v3_cmpl *)rxcmp)->metadata1_payload_offset &    \
     480                 :            :          RX_PKT_V3_CMPL_METADATA1_VALID)
     481                 :            : 
     482                 :            : #define RX_CMP_V3_METADATA0_VID(rxcmp1)                         \
     483                 :            :         ((((struct rx_pkt_v3_cmpl_hi *)rxcmp1)->metadata0) &     \
     484                 :            :          (RX_PKT_V3_CMPL_HI_METADATA0_VID_MASK |                \
     485                 :            :           RX_PKT_V3_CMPL_HI_METADATA0_DE  |                     \
     486                 :            :           RX_PKT_V3_CMPL_HI_METADATA0_PRI_MASK))
     487                 :            : 
     488                 :            : static inline void bnxt_rx_vlan_v3(struct rte_mbuf *mbuf,
     489                 :            :                                    struct rx_pkt_cmpl *rxcmp,
     490                 :            :                                    struct rx_pkt_cmpl_hi *rxcmp1)
     491                 :            : {
     492         [ #  # ]:          0 :         if (RX_CMP_V3_VLAN_VALID(rxcmp)) {
     493                 :          0 :                 mbuf->vlan_tci = RX_CMP_V3_METADATA0_VID(rxcmp1);
     494                 :          0 :                 mbuf->ol_flags |= RTE_MBUF_F_RX_VLAN;
     495         [ #  # ]:          0 :                 if (rxcmp1->flags2 & RX_PKT_V3_CMPL_HI_FLAGS2_META_FORMAT_MASK)
     496                 :          0 :                         mbuf->ol_flags |= RTE_MBUF_F_RX_VLAN_STRIPPED;
     497                 :            :         }
     498                 :            : }
     499                 :            : 
     500                 :            : #define RX_CMP_V3_L4_CS_ERR(err)                \
     501                 :            :         (((err) & RX_PKT_CMPL_ERRORS_MASK)  \
     502                 :            :          & (RX_PKT_CMPL_ERRORS_L4_CS_ERROR))
     503                 :            : #define RX_CMP_V3_L3_CS_ERR(err)                \
     504                 :            :         (((err) & RX_PKT_CMPL_ERRORS_MASK)  \
     505                 :            :          & (RX_PKT_CMPL_ERRORS_IP_CS_ERROR))
     506                 :            : #define RX_CMP_V3_T_IP_CS_ERR(err)              \
     507                 :            :         (((err) & RX_PKT_CMPL_ERRORS_MASK)  \
     508                 :            :          & (RX_PKT_CMPL_ERRORS_T_IP_CS_ERROR))
     509                 :            : #define RX_CMP_V3_T_L4_CS_ERR(err)              \
     510                 :            :         (((err) & RX_PKT_CMPL_ERRORS_MASK)  \
     511                 :            :          & (RX_PKT_CMPL_ERRORS_T_L4_CS_ERROR))
     512                 :            : #define RX_PKT_CMPL_CALC                        \
     513                 :            :         (RX_PKT_CMPL_FLAGS2_IP_CS_CALC |        \
     514                 :            :          RX_PKT_CMPL_FLAGS2_L4_CS_CALC |        \
     515                 :            :          RX_PKT_CMPL_FLAGS2_T_IP_CS_CALC |      \
     516                 :            :          RX_PKT_CMPL_FLAGS2_T_L4_CS_CALC)
     517                 :            : 
     518                 :            : static inline uint64_t
     519                 :          0 : bnxt_parse_csum_fields_v3(uint32_t flags2, uint32_t error_v2)
     520                 :            : {
     521                 :            :         uint64_t ol_flags = 0;
     522                 :            : 
     523         [ #  # ]:          0 :         if (flags2 & RX_PKT_CMPL_CALC) {
     524         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V3_L4_CS_ERR(error_v2)))
     525                 :            :                         ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_BAD;
     526                 :            :                 else
     527                 :            :                         ol_flags |= RTE_MBUF_F_RX_L4_CKSUM_GOOD;
     528         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V3_L3_CS_ERR(error_v2)))
     529                 :          0 :                         ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_BAD;
     530         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V3_T_L4_CS_ERR(error_v2)))
     531                 :          0 :                         ol_flags |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_BAD;
     532                 :            :                 else
     533                 :          0 :                         ol_flags |= RTE_MBUF_F_RX_OUTER_L4_CKSUM_GOOD;
     534         [ #  # ]:          0 :                 if (unlikely(RX_CMP_V3_T_IP_CS_ERR(error_v2)))
     535                 :          0 :                         ol_flags |= RTE_MBUF_F_RX_OUTER_IP_CKSUM_BAD;
     536         [ #  # ]:          0 :                 if (!(ol_flags & (RTE_MBUF_F_RX_IP_CKSUM_BAD | RTE_MBUF_F_RX_OUTER_IP_CKSUM_BAD)))
     537                 :          0 :                         ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_GOOD;
     538                 :            :         } else {
     539                 :            :                 /* Unknown is defined as 0 for all packets types hence using below for all */
     540                 :            :                 ol_flags |= RTE_MBUF_F_RX_IP_CKSUM_UNKNOWN;
     541                 :            :         }
     542                 :          0 :         return ol_flags;
     543                 :            : }
     544                 :            : 
     545                 :            : static inline void
     546                 :            : bnxt_parse_csum_v3(struct rte_mbuf *mbuf, struct rx_pkt_cmpl_hi *rxcmp1)
     547                 :            : {
     548                 :            :         struct rx_pkt_v3_cmpl_hi *v3_cmp =
     549                 :            :                 (struct rx_pkt_v3_cmpl_hi *)(rxcmp1);
     550                 :          0 :         uint16_t error_v2 = rte_le_to_cpu_16(v3_cmp->errors_v2);
     551                 :          0 :         uint32_t flags2 = rte_le_to_cpu_32(v3_cmp->flags2);
     552                 :            : 
     553         [ #  # ]:          0 :         mbuf->ol_flags |= bnxt_parse_csum_fields_v3(flags2, error_v2);
     554                 :            : }
     555                 :            : #endif /*  _BNXT_RXR_H_ */