* [v4, net-next 1/7] bng_en: Extend bnge_set_ring_params() for rx-copybreak
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 2/7] bng_en: Add RX support Bhargava Marreddy
` (5 subsequent siblings)
6 siblings, 0 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Add rx-copybreak support in bnge_set_ring_params()
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 19 +++++++++++++++++--
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 5 +++--
2 files changed, 20 insertions(+), 4 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 832eeb960bd2..8bd019ea55a2 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -13,6 +13,7 @@
#include <linux/etherdevice.h>
#include <linux/if.h>
#include <net/ip.h>
+#include <net/netdev_queues.h>
#include <linux/skbuff.h>
#include <net/page_pool/helpers.h>
@@ -2295,7 +2296,6 @@ void bnge_set_ring_params(struct bnge_dev *bd)
rx_space = rx_size + ALIGN(NET_SKB_PAD, 8) +
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
- bn->rx_copy_thresh = BNGE_RX_COPY_THRESH;
ring_size = bn->rx_ring_size;
bn->rx_agg_ring_size = 0;
bn->rx_agg_nr_pages = 0;
@@ -2334,7 +2334,10 @@ void bnge_set_ring_params(struct bnge_dev *bd)
bn->rx_agg_ring_size = agg_ring_size;
bn->rx_agg_ring_mask = (bn->rx_agg_nr_pages * RX_DESC_CNT) - 1;
- rx_size = SKB_DATA_ALIGN(BNGE_RX_COPY_THRESH + NET_IP_ALIGN);
+ rx_size = max3(BNGE_DEFAULT_RX_COPYBREAK,
+ bn->rx_copybreak,
+ bn->netdev->cfg_pending->hds_thresh);
+ rx_size = SKB_DATA_ALIGN(rx_size + NET_IP_ALIGN);
rx_space = rx_size + NET_SKB_PAD +
SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
}
@@ -2367,6 +2370,17 @@ void bnge_set_ring_params(struct bnge_dev *bd)
bn->cp_ring_mask = bn->cp_bit - 1;
}
+static void bnge_init_ring_params(struct bnge_net *bn)
+{
+ u32 rx_size;
+
+ bn->rx_copybreak = BNGE_DEFAULT_RX_COPYBREAK;
+ /* Try to fit 4 chunks into a 4k page */
+ rx_size = SZ_1K -
+ NET_SKB_PAD - SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
+ bn->netdev->cfg->hds_thresh = max(BNGE_DEFAULT_RX_COPYBREAK, rx_size);
+}
+
int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
{
struct net_device *netdev;
@@ -2456,6 +2470,7 @@ int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
bn->rx_dir = DMA_FROM_DEVICE;
bnge_set_tpa_flags(bd);
+ bnge_init_ring_params(bn);
bnge_set_ring_params(bd);
bnge_init_l2_fltr_tbl(bn);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index fb3b961536ba..557cca472db6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -135,7 +135,8 @@ struct bnge_ring_grp_info {
u16 nq_fw_ring_id;
};
-#define BNGE_RX_COPY_THRESH 256
+#define BNGE_DEFAULT_RX_COPYBREAK 256
+#define BNGE_MAX_RX_COPYBREAK 1024
#define BNGE_HW_FEATURE_VLAN_ALL_RX \
(NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_HW_VLAN_STAG_RX)
@@ -186,7 +187,7 @@ struct bnge_net {
u32 rx_buf_size;
u32 rx_buf_use_size; /* usable size */
u32 rx_agg_ring_size;
- u32 rx_copy_thresh;
+ u32 rx_copybreak;
u32 rx_ring_mask;
u32 rx_agg_ring_mask;
u16 rx_nr_pages;
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* [v4, net-next 2/7] bng_en: Add RX support
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 1/7] bng_en: Extend bnge_set_ring_params() for rx-copybreak Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-08 9:45 ` Paolo Abeni
2026-01-16 17:06 ` ALOK TIWARI
2026-01-05 7:21 ` [v4, net-next 3/7] bng_en: Handle an HWRM completion request Bhargava Marreddy
` (4 subsequent siblings)
6 siblings, 2 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Add support to receive packet using NAPI, build and deliver the skb
to stack. With help of meta data available in completions, fill the
appropriate information in skb.
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
drivers/net/ethernet/broadcom/bnge/Makefile | 3 +-
.../net/ethernet/broadcom/bnge/bnge_hw_def.h | 198 ++++++
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 113 +++-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 60 +-
.../net/ethernet/broadcom/bnge/bnge_txrx.c | 573 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_txrx.h | 90 +++
6 files changed, 1016 insertions(+), 21 deletions(-)
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
diff --git a/drivers/net/ethernet/broadcom/bnge/Makefile b/drivers/net/ethernet/broadcom/bnge/Makefile
index ea6596854e5c..fa604ee20264 100644
--- a/drivers/net/ethernet/broadcom/bnge/Makefile
+++ b/drivers/net/ethernet/broadcom/bnge/Makefile
@@ -10,4 +10,5 @@ bng_en-y := bnge_core.o \
bnge_resc.o \
bnge_netdev.o \
bnge_ethtool.o \
- bnge_auxr.o
+ bnge_auxr.o \
+ bnge_txrx.o
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
new file mode 100644
index 000000000000..4da4259095fa
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
@@ -0,0 +1,198 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2025 Broadcom */
+
+#ifndef _BNGE_HW_DEF_H_
+#define _BNGE_HW_DEF_H_
+
+struct tx_bd_ext {
+ __le32 tx_bd_hsize_lflags;
+ #define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
+ #define TX_BD_FLAGS_IP_CKSUM (1 << 1)
+ #define TX_BD_FLAGS_NO_CRC (1 << 2)
+ #define TX_BD_FLAGS_STAMP (1 << 3)
+ #define TX_BD_FLAGS_T_IP_CHKSUM (1 << 4)
+ #define TX_BD_FLAGS_LSO (1 << 5)
+ #define TX_BD_FLAGS_IPID_FMT (1 << 6)
+ #define TX_BD_FLAGS_T_IPID (1 << 7)
+ #define TX_BD_HSIZE (0xff << 16)
+ #define TX_BD_HSIZE_SHIFT 16
+
+ __le32 tx_bd_mss;
+ __le32 tx_bd_cfa_action;
+ #define TX_BD_CFA_ACTION (0xffff << 16)
+ #define TX_BD_CFA_ACTION_SHIFT 16
+
+ __le32 tx_bd_cfa_meta;
+ #define TX_BD_CFA_META_MASK 0xfffffff
+ #define TX_BD_CFA_META_VID_MASK 0xfff
+ #define TX_BD_CFA_META_PRI_MASK (0xf << 12)
+ #define TX_BD_CFA_META_PRI_SHIFT 12
+ #define TX_BD_CFA_META_TPID_MASK (3 << 16)
+ #define TX_BD_CFA_META_TPID_SHIFT 16
+ #define TX_BD_CFA_META_KEY (0xf << 28)
+ #define TX_BD_CFA_META_KEY_SHIFT 28
+ #define TX_BD_CFA_META_KEY_VLAN (1 << 28)
+};
+
+#define TX_CMP_SQ_CONS_IDX(txcmp) \
+ (le32_to_cpu((txcmp)->sq_cons_idx) & TX_CMP_SQ_CONS_IDX_MASK)
+
+struct rx_cmp {
+ __le32 rx_cmp_len_flags_type;
+ #define RX_CMP_CMP_TYPE (0x3f << 0)
+ #define RX_CMP_FLAGS_ERROR (1 << 6)
+ #define RX_CMP_FLAGS_PLACEMENT (7 << 7)
+ #define RX_CMP_FLAGS_RSS_VALID (1 << 10)
+ #define RX_CMP_FLAGS_PKT_METADATA_PRESENT (1 << 11)
+ #define RX_CMP_FLAGS_ITYPES_SHIFT 12
+ #define RX_CMP_FLAGS_ITYPES_MASK 0xf000
+ #define RX_CMP_FLAGS_ITYPE_UNKNOWN (0 << 12)
+ #define RX_CMP_FLAGS_ITYPE_IP (1 << 12)
+ #define RX_CMP_FLAGS_ITYPE_TCP (2 << 12)
+ #define RX_CMP_FLAGS_ITYPE_UDP (3 << 12)
+ #define RX_CMP_FLAGS_ITYPE_FCOE (4 << 12)
+ #define RX_CMP_FLAGS_ITYPE_ROCE (5 << 12)
+ #define RX_CMP_FLAGS_ITYPE_PTP_WO_TS (8 << 12)
+ #define RX_CMP_FLAGS_ITYPE_PTP_W_TS (9 << 12)
+ #define RX_CMP_LEN (0xffff << 16)
+ #define RX_CMP_LEN_SHIFT 16
+
+ u32 rx_cmp_opaque;
+ __le32 rx_cmp_misc_v1;
+ #define RX_CMP_V1 (1 << 0)
+ #define RX_CMP_AGG_BUFS (0x1f << 1)
+ #define RX_CMP_AGG_BUFS_SHIFT 1
+ #define RX_CMP_RSS_HASH_TYPE (0x7f << 9)
+ #define RX_CMP_RSS_HASH_TYPE_SHIFT 9
+ #define RX_CMP_V3_RSS_EXT_OP_LEGACY (0xf << 12)
+ #define RX_CMP_V3_RSS_EXT_OP_LEGACY_SHIFT 12
+ #define RX_CMP_V3_RSS_EXT_OP_NEW (0xf << 8)
+ #define RX_CMP_V3_RSS_EXT_OP_NEW_SHIFT 8
+ #define RX_CMP_PAYLOAD_OFFSET (0xff << 16)
+ #define RX_CMP_PAYLOAD_OFFSET_SHIFT 16
+ #define RX_CMP_SUB_NS_TS (0xf << 16)
+ #define RX_CMP_SUB_NS_TS_SHIFT 16
+ #define RX_CMP_METADATA1 (0xf << 28)
+ #define RX_CMP_METADATA1_SHIFT 28
+ #define RX_CMP_METADATA1_TPID_SEL (0x7 << 28)
+ #define RX_CMP_METADATA1_TPID_8021Q (0x1 << 28)
+ #define RX_CMP_METADATA1_TPID_8021AD (0x0 << 28)
+ #define RX_CMP_METADATA1_VALID (0x8 << 28)
+
+ __le32 rx_cmp_rss_hash;
+};
+
+struct rx_cmp_ext {
+ __le32 rx_cmp_flags2;
+ #define RX_CMP_FLAGS2_IP_CS_CALC 0x1
+ #define RX_CMP_FLAGS2_L4_CS_CALC (0x1 << 1)
+ #define RX_CMP_FLAGS2_T_IP_CS_CALC (0x1 << 2)
+ #define RX_CMP_FLAGS2_T_L4_CS_CALC (0x1 << 3)
+ #define RX_CMP_FLAGS2_META_FORMAT_VLAN (0x1 << 4)
+ __le32 rx_cmp_meta_data;
+ #define RX_CMP_FLAGS2_METADATA_TCI_MASK 0xffff
+ #define RX_CMP_FLAGS2_METADATA_VID_MASK 0xfff
+ #define RX_CMP_FLAGS2_METADATA_TPID_MASK 0xffff0000
+ #define RX_CMP_FLAGS2_METADATA_TPID_SFT 16
+ __le32 rx_cmp_cfa_code_errors_v2;
+ #define RX_CMP_V (1 << 0)
+ #define RX_CMPL_ERRORS_MASK (0x7fff << 1)
+ #define RX_CMPL_ERRORS_SFT 1
+ #define RX_CMPL_ERRORS_BUFFER_ERROR_MASK (0x7 << 1)
+ #define RX_CMPL_ERRORS_BUFFER_ERROR_NO_BUFFER (0x0 << 1)
+ #define RX_CMPL_ERRORS_BUFFER_ERROR_DID_NOT_FIT (0x1 << 1)
+ #define RX_CMPL_ERRORS_BUFFER_ERROR_NOT_ON_CHIP (0x2 << 1)
+ #define RX_CMPL_ERRORS_BUFFER_ERROR_BAD_FORMAT (0x3 << 1)
+ #define RX_CMPL_ERRORS_IP_CS_ERROR (0x1 << 4)
+ #define RX_CMPL_ERRORS_L4_CS_ERROR (0x1 << 5)
+ #define RX_CMPL_ERRORS_T_IP_CS_ERROR (0x1 << 6)
+ #define RX_CMPL_ERRORS_T_L4_CS_ERROR (0x1 << 7)
+ #define RX_CMPL_ERRORS_CRC_ERROR (0x1 << 8)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_MASK (0x7 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_NO_ERROR (0x0 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_T_L3_BAD_VERSION (0x1 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_T_L3_BAD_HDR_LEN (0x2 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_TUNNEL_TOTAL_ERROR (0x3 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_T_IP_TOTAL_ERROR (0x4 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_T_UDP_TOTAL_ERROR (0x5 << 9)
+ #define RX_CMPL_ERRORS_T_PKT_ERROR_T_L3_BAD_TTL (0x6 << 9)
+ #define RX_CMPL_ERRORS_PKT_ERROR_MASK (0xf << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_NO_ERROR (0x0 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L3_BAD_VERSION (0x1 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L3_BAD_HDR_LEN (0x2 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L3_BAD_TTL (0x3 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_IP_TOTAL_ERROR (0x4 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_UDP_TOTAL_ERROR (0x5 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L4_BAD_HDR_LEN (0x6 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L4_BAD_HDR_LEN_TOO_SMALL (0x7 << 12)
+ #define RX_CMPL_ERRORS_PKT_ERROR_L4_BAD_OPT_LEN (0x8 << 12)
+
+ #define RX_CMPL_CFA_CODE_MASK (0xffff << 16)
+ #define RX_CMPL_CFA_CODE_SFT 16
+ #define RX_CMPL_METADATA0_TCI_MASK (0xffff << 16)
+ #define RX_CMPL_METADATA0_VID_MASK (0x0fff << 16)
+ #define RX_CMPL_METADATA0_SFT 16
+
+ __le32 rx_cmp_timestamp;
+};
+
+#define RX_CMP_L2_ERRORS \
+ cpu_to_le32(RX_CMPL_ERRORS_BUFFER_ERROR_MASK | RX_CMPL_ERRORS_CRC_ERROR)
+
+#define RX_CMP_L4_CS_BITS \
+ (cpu_to_le32(RX_CMP_FLAGS2_L4_CS_CALC | RX_CMP_FLAGS2_T_L4_CS_CALC))
+
+#define RX_CMP_L4_CS_ERR_BITS \
+ (cpu_to_le32(RX_CMPL_ERRORS_L4_CS_ERROR | RX_CMPL_ERRORS_T_L4_CS_ERROR))
+
+#define RX_CMP_L4_CS_OK(rxcmp1) \
+ (((rxcmp1)->rx_cmp_flags2 & RX_CMP_L4_CS_BITS) && \
+ !((rxcmp1)->rx_cmp_cfa_code_errors_v2 & RX_CMP_L4_CS_ERR_BITS))
+
+#define RX_CMP_METADATA0_TCI(rxcmp1) \
+ ((le32_to_cpu((rxcmp1)->rx_cmp_cfa_code_errors_v2) & \
+ RX_CMPL_METADATA0_TCI_MASK) >> RX_CMPL_METADATA0_SFT)
+
+#define RX_CMP_ENCAP(rxcmp1) \
+ ((le32_to_cpu((rxcmp1)->rx_cmp_flags2) & \
+ RX_CMP_FLAGS2_T_L4_CS_CALC) >> 3)
+
+#define RX_CMP_V3_HASH_TYPE_LEGACY(rxcmp) \
+ ((le32_to_cpu((rxcmp)->rx_cmp_misc_v1) & \
+ RX_CMP_V3_RSS_EXT_OP_LEGACY) >> RX_CMP_V3_RSS_EXT_OP_LEGACY_SHIFT)
+
+#define RX_CMP_V3_HASH_TYPE_NEW(rxcmp) \
+ ((le32_to_cpu((rxcmp)->rx_cmp_misc_v1) & RX_CMP_V3_RSS_EXT_OP_NEW) >>\
+ RX_CMP_V3_RSS_EXT_OP_NEW_SHIFT)
+
+#define RX_CMP_V3_HASH_TYPE(bd, rxcmp) \
+ (((bd)->rss_cap & BNGE_RSS_CAP_RSS_TCAM) ? \
+ RX_CMP_V3_HASH_TYPE_NEW(rxcmp) : \
+ RX_CMP_V3_HASH_TYPE_LEGACY(rxcmp))
+
+#define EXT_OP_INNER_4 0x0
+#define EXT_OP_OUTER_4 0x2
+#define EXT_OP_INNFL_3 0x8
+#define EXT_OP_OUTFL_3 0xa
+
+#define RX_CMP_VLAN_VALID(rxcmp) \
+ ((rxcmp)->rx_cmp_misc_v1 & cpu_to_le32(RX_CMP_METADATA1_VALID))
+
+#define RX_CMP_VLAN_TPID_SEL(rxcmp) \
+ (le32_to_cpu((rxcmp)->rx_cmp_misc_v1) & RX_CMP_METADATA1_TPID_SEL)
+
+#define RSS_PROFILE_ID_MASK 0x1f
+
+#define RX_CMP_HASH_TYPE(rxcmp) \
+ (((le32_to_cpu((rxcmp)->rx_cmp_misc_v1) & RX_CMP_RSS_HASH_TYPE) >>\
+ RX_CMP_RSS_HASH_TYPE_SHIFT) & RSS_PROFILE_ID_MASK)
+
+#define RX_CMP_HASH_VALID(rxcmp) \
+ ((rxcmp)->rx_cmp_len_flags_type & cpu_to_le32(RX_CMP_FLAGS_RSS_VALID))
+
+#define HWRM_RING_ALLOC_TX 0x1
+#define HWRM_RING_ALLOC_RX 0x2
+#define HWRM_RING_ALLOC_AGG 0x4
+#define HWRM_RING_ALLOC_CMPL 0x8
+#define HWRM_RING_ALLOC_NQ 0x10
+#endif /* _BNGE_HW_DEF_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 8bd019ea55a2..7533c382714e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -21,6 +21,7 @@
#include "bnge_hwrm_lib.h"
#include "bnge_ethtool.h"
#include "bnge_rmem.h"
+#include "bnge_txrx.h"
#define BNGE_RING_TO_TC_OFF(bd, tx) \
((tx) % (bd)->tx_nr_rings_per_tc)
@@ -857,6 +858,13 @@ u16 bnge_cp_ring_for_tx(struct bnge_tx_ring_info *txr)
return txr->tx_cpr->ring_struct.fw_ring_id;
}
+static void bnge_db_nq_arm(struct bnge_net *bn,
+ struct bnge_db_info *db, u32 idx)
+{
+ bnge_writeq(bn->bd, db->db_key64 | DBR_TYPE_NQ_ARM |
+ DB_RING_IDX(db, idx), db->doorbell);
+}
+
static void bnge_db_nq(struct bnge_net *bn, struct bnge_db_info *db, u32 idx)
{
bnge_writeq(bn->bd, db->db_key64 | DBR_TYPE_NQ_MASK |
@@ -879,12 +887,6 @@ static int bnge_cp_num_to_irq_num(struct bnge_net *bn, int n)
return nqr->ring_struct.map_idx;
}
-static irqreturn_t bnge_msix(int irq, void *dev_instance)
-{
- /* NAPI scheduling to be added in a future patch */
- return IRQ_HANDLED;
-}
-
static void bnge_init_nq_tree(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
@@ -942,9 +944,8 @@ static u8 *__bnge_alloc_rx_frag(struct bnge_net *bn, dma_addr_t *mapping,
return page_address(page) + offset;
}
-static int bnge_alloc_rx_data(struct bnge_net *bn,
- struct bnge_rx_ring_info *rxr,
- u16 prod, gfp_t gfp)
+int bnge_alloc_rx_data(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
+ u16 prod, gfp_t gfp)
{
struct bnge_sw_rx_bd *rx_buf = &rxr->rx_buf_ring[RING_RX(bn, prod)];
struct rx_bd *rxbd;
@@ -1756,6 +1757,78 @@ static int bnge_cfg_def_vnic(struct bnge_net *bn)
return rc;
}
+static void bnge_disable_int(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i;
+
+ if (!bn->bnapi)
+ return;
+
+ for (i = 0; i < bd->nq_nr_rings; i++) {
+ struct bnge_napi *bnapi = bn->bnapi[i];
+ struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
+ struct bnge_ring_struct *ring = &nqr->ring_struct;
+
+ if (ring->fw_ring_id != INVALID_HW_RING_ID)
+ bnge_db_nq(bn, &nqr->nq_db, nqr->nq_raw_cons);
+ }
+}
+
+static void bnge_disable_int_sync(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i;
+
+ bnge_disable_int(bn);
+ for (i = 0; i < bd->nq_nr_rings; i++) {
+ int map_idx = bnge_cp_num_to_irq_num(bn, i);
+
+ synchronize_irq(bd->irq_tbl[map_idx].vector);
+ }
+}
+
+static void bnge_enable_int(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i;
+
+ for (i = 0; i < bd->nq_nr_rings; i++) {
+ struct bnge_napi *bnapi = bn->bnapi[i];
+ struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
+
+ bnge_db_nq_arm(bn, &nqr->nq_db, nqr->nq_raw_cons);
+ }
+}
+
+static void bnge_disable_napi(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i;
+
+ if (test_and_set_bit(BNGE_STATE_NAPI_DISABLED, &bn->state))
+ return;
+
+ for (i = 0; i < bd->nq_nr_rings; i++) {
+ struct bnge_napi *bnapi = bn->bnapi[i];
+
+ napi_disable_locked(&bnapi->napi);
+ }
+}
+
+static void bnge_enable_napi(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i;
+
+ clear_bit(BNGE_STATE_NAPI_DISABLED, &bn->state);
+ for (i = 0; i < bd->nq_nr_rings; i++) {
+ struct bnge_napi *bnapi = bn->bnapi[i];
+
+ napi_enable_locked(&bnapi->napi);
+ }
+}
+
static void bnge_hwrm_vnic_free(struct bnge_net *bn)
{
int i;
@@ -1887,6 +1960,12 @@ static void bnge_hwrm_ring_free(struct bnge_net *bn, bool close_path)
bnge_hwrm_rx_agg_ring_free(bn, &bn->rx_ring[i], close_path);
}
+ /* The completion rings are about to be freed. After that the
+ * IRQ doorbell will not work anymore. So we need to disable
+ * IRQ here.
+ */
+ bnge_disable_int_sync(bn);
+
for (i = 0; i < bd->nq_nr_rings; i++) {
struct bnge_napi *bnapi = bn->bnapi[i];
struct bnge_nq_ring_info *nqr;
@@ -2086,16 +2165,6 @@ static int bnge_init_chip(struct bnge_net *bn)
return rc;
}
-static int bnge_napi_poll(struct napi_struct *napi, int budget)
-{
- int work_done = 0;
-
- /* defer NAPI implementation to next patch series */
- napi_complete_done(napi, work_done);
-
- return work_done;
-}
-
static void bnge_init_napi(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
@@ -2193,7 +2262,12 @@ static int bnge_open_core(struct bnge_net *bn)
netdev_err(bn->netdev, "bnge_init_nic err: %d\n", rc);
goto err_free_irq;
}
+
+ bnge_enable_napi(bn);
+
set_bit(BNGE_STATE_OPEN, &bd->state);
+
+ bnge_enable_int(bn);
return 0;
err_free_irq:
@@ -2236,6 +2310,7 @@ static void bnge_close_core(struct bnge_net *bn)
clear_bit(BNGE_STATE_OPEN, &bd->state);
bnge_shutdown_nic(bn);
+ bnge_disable_napi(bn);
bnge_free_all_rings_bufs(bn);
bnge_free_irq(bn);
bnge_del_napi(bn);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 557cca472db6..04989908b133 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -8,6 +8,7 @@
#include <linux/io-64-nonatomic-lo-hi.h>
#include <linux/refcount.h>
#include "bnge_db.h"
+#include "bnge_hw_def.h"
struct tx_bd {
__le32 tx_bd_len_flags_type;
@@ -173,10 +174,16 @@ enum {
#define RING_RX_AGG(bn, idx) ((idx) & (bn)->rx_agg_ring_mask)
#define NEXT_RX_AGG(idx) ((idx) + 1)
+#define BNGE_NQ_HDL_IDX_MASK 0x00ffffff
+#define BNGE_NQ_HDL_TYPE_MASK 0xff000000
#define BNGE_NQ_HDL_TYPE_SHIFT 24
#define BNGE_NQ_HDL_TYPE_RX 0x00
#define BNGE_NQ_HDL_TYPE_TX 0x01
+#define BNGE_NQ_HDL_IDX(hdl) ((hdl) & BNGE_NQ_HDL_IDX_MASK)
+#define BNGE_NQ_HDL_TYPE(hdl) (((hdl) & BNGE_NQ_HDL_TYPE_MASK) >> \
+ BNGE_NQ_HDL_TYPE_SHIFT)
+
struct bnge_net {
struct bnge_dev *bd;
struct net_device *netdev;
@@ -232,6 +239,9 @@ struct bnge_net {
u8 rss_hash_key_updated:1;
int rsscos_nr_ctxs;
u32 stats_coal_ticks;
+
+ unsigned long state;
+#define BNGE_STATE_NAPI_DISABLED 0
};
#define BNGE_DEFAULT_RX_RING_SIZE 511
@@ -278,9 +288,25 @@ void bnge_set_ring_params(struct bnge_dev *bd);
txr = (iter < BNGE_MAX_TXR_PER_NAPI - 1) ? \
(bnapi)->tx_ring[++iter] : NULL)
+#define DB_EPOCH(db, idx) (((idx) & (db)->db_epoch_mask) << \
+ ((db)->db_epoch_shift))
+
+#define DB_TOGGLE(tgl) ((tgl) << DBR_TOGGLE_SFT)
+
+#define DB_RING_IDX(db, idx) (((idx) & (db)->db_ring_mask) | \
+ DB_EPOCH(db, idx))
+
#define BNGE_SET_NQ_HDL(cpr) \
(((cpr)->cp_ring_type << BNGE_NQ_HDL_TYPE_SHIFT) | (cpr)->cp_idx)
+#define BNGE_DB_NQ(bd, db, idx) \
+ bnge_writeq(bd, (db)->db_key64 | DBR_TYPE_NQ | DB_RING_IDX(db, idx),\
+ (db)->doorbell)
+
+#define BNGE_DB_NQ_ARM(bd, db, idx) \
+ bnge_writeq(bd, (db)->db_key64 | DBR_TYPE_NQ_ARM | \
+ DB_RING_IDX(db, idx), (db)->doorbell)
+
struct bnge_stats_mem {
u64 *sw_stats;
u64 *hw_masks;
@@ -289,6 +315,25 @@ struct bnge_stats_mem {
int len;
};
+struct nqe_cn {
+ __le16 type;
+ #define NQ_CN_TYPE_MASK 0x3fUL
+ #define NQ_CN_TYPE_SFT 0
+ #define NQ_CN_TYPE_CQ_NOTIFICATION 0x30UL
+ #define NQ_CN_TYPE_LAST NQ_CN_TYPE_CQ_NOTIFICATION
+ #define NQ_CN_TOGGLE_MASK 0xc0UL
+ #define NQ_CN_TOGGLE_SFT 6
+ __le16 reserved16;
+ __le32 cq_handle_low;
+ __le32 v;
+ #define NQ_CN_V 0x1UL
+ __le32 cq_handle_high;
+};
+
+#define NQE_CN_TYPE(type) ((type) & NQ_CN_TYPE_MASK)
+#define NQE_CN_TOGGLE(type) (((type) & NQ_CN_TOGGLE_MASK) >> \
+ NQ_CN_TOGGLE_SFT)
+
struct bnge_cp_ring_info {
struct bnge_napi *bnapi;
dma_addr_t *desc_mapping;
@@ -298,6 +343,10 @@ struct bnge_cp_ring_info {
u8 cp_idx;
u32 cp_raw_cons;
struct bnge_db_info cp_db;
+ u8 had_work_done:1;
+ u8 has_more_work:1;
+ u8 had_nqe_notify:1;
+ u8 toggle;
};
struct bnge_nq_ring_info {
@@ -310,8 +359,9 @@ struct bnge_nq_ring_info {
struct bnge_stats_mem stats;
u32 hw_stats_ctx_id;
+ u8 has_more_work:1;
- int cp_ring_count;
+ u16 cp_ring_count;
struct bnge_cp_ring_info *cp_ring_arr;
};
@@ -374,6 +424,12 @@ struct bnge_napi {
struct bnge_nq_ring_info nq_ring;
struct bnge_rx_ring_info *rx_ring;
struct bnge_tx_ring_info *tx_ring[BNGE_MAX_TXR_PER_NAPI];
+ u8 events;
+#define BNGE_RX_EVENT 1
+#define BNGE_AGG_EVENT 2
+#define BNGE_TX_EVENT 4
+#define BNGE_REDIRECT_EVENT 8
+#define BNGE_TX_CMP_EVENT 0x10
};
#define INVALID_STATS_CTX_ID -1
@@ -452,4 +508,6 @@ struct bnge_l2_filter {
u16 bnge_cp_ring_for_rx(struct bnge_rx_ring_info *rxr);
u16 bnge_cp_ring_for_tx(struct bnge_tx_ring_info *txr);
void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic);
+int bnge_alloc_rx_data(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
+ u16 prod, gfp_t gfp);
#endif /* _BNGE_NETDEV_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
new file mode 100644
index 000000000000..db49a92542c0
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
@@ -0,0 +1,573 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2025 Broadcom.
+
+#include <asm/byteorder.h>
+#include <linux/dma-mapping.h>
+#include <linux/dmapool.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/pci.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/if.h>
+#include <net/ip.h>
+#include <linux/skbuff.h>
+#include <net/page_pool/helpers.h>
+#include <linux/if_vlan.h>
+#include <net/udp_tunnel.h>
+#include <net/dst_metadata.h>
+#include <net/netdev_queues.h>
+
+#include "bnge.h"
+#include "bnge_hwrm.h"
+#include "bnge_hwrm_lib.h"
+#include "bnge_netdev.h"
+#include "bnge_rmem.h"
+#include "bnge_txrx.h"
+
+irqreturn_t bnge_msix(int irq, void *dev_instance)
+{
+ struct bnge_napi *bnapi = dev_instance;
+ struct bnge_nq_ring_info *nqr;
+ struct bnge_net *bn;
+ u32 cons;
+
+ bn = bnapi->bn;
+ nqr = &bnapi->nq_ring;
+ cons = RING_CMP(bn, nqr->nq_raw_cons);
+
+ prefetch(&nqr->desc_ring[CP_RING(cons)][CP_IDX(cons)]);
+ napi_schedule(&bnapi->napi);
+ return IRQ_HANDLED;
+}
+
+static void bnge_sched_reset_rxr(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr)
+{
+ /* TODO: Initiate reset task */
+ rxr->rx_next_cons = 0xffff;
+}
+
+void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data)
+{
+ struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
+ struct bnge_net *bn = rxr->bnapi->bn;
+ struct rx_bd *cons_bd, *prod_bd;
+ u16 prod = rxr->rx_prod;
+
+ prod_rx_buf = &rxr->rx_buf_ring[RING_RX(bn, prod)];
+ cons_rx_buf = &rxr->rx_buf_ring[cons];
+
+ prod_rx_buf->data = data;
+ prod_rx_buf->data_ptr = cons_rx_buf->data_ptr;
+
+ prod_rx_buf->mapping = cons_rx_buf->mapping;
+
+ prod_bd = &rxr->rx_desc_ring[RX_RING(bn, prod)][RX_IDX(prod)];
+ cons_bd = &rxr->rx_desc_ring[RX_RING(bn, cons)][RX_IDX(cons)];
+
+ prod_bd->rx_bd_haddr = cons_bd->rx_bd_haddr;
+}
+
+static void bnge_deliver_skb(struct bnge_net *bn, struct bnge_napi *bnapi,
+ struct sk_buff *skb)
+{
+ skb_mark_for_recycle(skb);
+ skb_record_rx_queue(skb, bnapi->index);
+ napi_gro_receive(&bnapi->napi, skb);
+}
+
+static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
+ unsigned int len, dma_addr_t mapping)
+{
+ struct bnge_net *bn = bnapi->bn;
+ struct bnge_dev *bd = bn->bd;
+ struct sk_buff *skb;
+
+ skb = napi_alloc_skb(&bnapi->napi, len);
+ if (!skb)
+ return NULL;
+
+ dma_sync_single_for_cpu(bd->dev, mapping, bn->rx_copybreak,
+ bn->rx_dir);
+
+ memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
+ len + NET_IP_ALIGN);
+
+ dma_sync_single_for_device(bd->dev, mapping, bn->rx_copybreak,
+ bn->rx_dir);
+
+ skb_put(skb, len);
+
+ return skb;
+}
+
+static enum pkt_hash_types bnge_rss_ext_op(struct bnge_net *bn,
+ struct rx_cmp *rxcmp)
+{
+ u8 ext_op = RX_CMP_V3_HASH_TYPE(bn->bd, rxcmp);
+
+ switch (ext_op) {
+ case EXT_OP_INNER_4:
+ case EXT_OP_OUTER_4:
+ case EXT_OP_INNFL_3:
+ case EXT_OP_OUTFL_3:
+ return PKT_HASH_TYPE_L4;
+ default:
+ return PKT_HASH_TYPE_L3;
+ }
+}
+
+static struct sk_buff *bnge_rx_vlan(struct sk_buff *skb, u8 cmp_type,
+ struct rx_cmp *rxcmp,
+ struct rx_cmp_ext *rxcmp1)
+{
+ __be16 vlan_proto;
+ u16 vtag;
+
+ if (cmp_type == CMP_TYPE_RX_L2_CMP) {
+ __le32 flags2 = rxcmp1->rx_cmp_flags2;
+ u32 meta_data;
+
+ if (!(flags2 & cpu_to_le32(RX_CMP_FLAGS2_META_FORMAT_VLAN)))
+ return skb;
+
+ meta_data = le32_to_cpu(rxcmp1->rx_cmp_meta_data);
+ vtag = meta_data & RX_CMP_FLAGS2_METADATA_TCI_MASK;
+ vlan_proto =
+ htons(meta_data >> RX_CMP_FLAGS2_METADATA_TPID_SFT);
+ if (eth_type_vlan(vlan_proto))
+ __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
+ else
+ goto vlan_err;
+ } else if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
+ if (RX_CMP_VLAN_VALID(rxcmp)) {
+ u32 tpid_sel = RX_CMP_VLAN_TPID_SEL(rxcmp);
+
+ if (tpid_sel == RX_CMP_METADATA1_TPID_8021Q)
+ vlan_proto = htons(ETH_P_8021Q);
+ else if (tpid_sel == RX_CMP_METADATA1_TPID_8021AD)
+ vlan_proto = htons(ETH_P_8021AD);
+ else
+ goto vlan_err;
+ vtag = RX_CMP_METADATA0_TCI(rxcmp1);
+ __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
+ }
+ }
+ return skb;
+
+vlan_err:
+ skb_mark_for_recycle(skb);
+ dev_kfree_skb(skb);
+ return NULL;
+}
+
+static struct sk_buff *bnge_rx_skb(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr, u16 cons,
+ void *data, u8 *data_ptr,
+ dma_addr_t dma_addr,
+ unsigned int offset_and_len)
+{
+ struct bnge_dev *bd = bn->bd;
+ u16 prod = rxr->rx_prod;
+ struct sk_buff *skb;
+ int err;
+
+ err = bnge_alloc_rx_data(bn, rxr, prod, GFP_ATOMIC);
+ if (unlikely(err)) {
+ bnge_reuse_rx_data(rxr, cons, data);
+ return NULL;
+ }
+
+ skb = napi_build_skb(data, bn->rx_buf_size);
+ dma_sync_single_for_cpu(bd->dev, dma_addr, bn->rx_buf_use_size,
+ bn->rx_dir);
+ if (!skb) {
+ page_pool_free_va(rxr->head_pool, data, true);
+ return NULL;
+ }
+
+ skb_mark_for_recycle(skb);
+ skb_reserve(skb, bn->rx_offset);
+ skb_put(skb, offset_and_len & 0xffff);
+ return skb;
+}
+
+/* returns the following:
+ * 1 - 1 packet successfully received
+ * -EBUSY - completion ring does not have all the agg buffers yet
+ * -ENOMEM - packet aborted due to out of memory
+ * -EIO - packet aborted due to hw error indicated in BD
+ */
+static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
+ u32 *raw_cons, u8 *event)
+{
+ struct bnge_napi *bnapi = cpr->bnapi;
+ struct net_device *dev = bn->netdev;
+ struct bnge_rx_ring_info *rxr;
+ u32 tmp_raw_cons, flags, misc;
+ struct bnge_sw_rx_bd *rx_buf;
+ struct rx_cmp_ext *rxcmp1;
+ u16 cons, prod, cp_cons;
+ u8 *data_ptr, cmp_type;
+ struct rx_cmp *rxcmp;
+ dma_addr_t dma_addr;
+ struct sk_buff *skb;
+ unsigned int len;
+ void *data;
+ int rc = 0;
+
+ rxr = bnapi->rx_ring;
+
+ tmp_raw_cons = *raw_cons;
+ cp_cons = RING_CMP(bn, tmp_raw_cons);
+ rxcmp = (struct rx_cmp *)
+ &cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
+
+ cmp_type = RX_CMP_TYPE(rxcmp);
+
+ tmp_raw_cons = NEXT_RAW_CMP(tmp_raw_cons);
+ cp_cons = RING_CMP(bn, tmp_raw_cons);
+ rxcmp1 = (struct rx_cmp_ext *)
+ &cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
+
+ if (!RX_CMP_VALID(rxcmp1, tmp_raw_cons))
+ return -EBUSY;
+
+ /* The valid test of the entry must be done first before
+ * reading any further.
+ */
+ dma_rmb();
+ prod = rxr->rx_prod;
+
+ cons = rxcmp->rx_cmp_opaque;
+ if (unlikely(cons != rxr->rx_next_cons)) {
+ /* 0xffff is forced error, don't print it */
+ if (rxr->rx_next_cons != 0xffff)
+ netdev_warn(bn->netdev, "RX cons %x != expected cons %x\n",
+ cons, rxr->rx_next_cons);
+ bnge_sched_reset_rxr(bn, rxr);
+ goto next_rx_no_prod_no_len;
+ }
+ rx_buf = &rxr->rx_buf_ring[cons];
+ data = rx_buf->data;
+ data_ptr = rx_buf->data_ptr;
+ prefetch(data_ptr);
+
+ misc = le32_to_cpu(rxcmp->rx_cmp_misc_v1);
+ *event |= BNGE_RX_EVENT;
+
+ rx_buf->data = NULL;
+ if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) {
+ bnge_reuse_rx_data(rxr, cons, data);
+ rc = -EIO;
+ goto next_rx_no_len;
+ }
+
+ flags = le32_to_cpu(rxcmp->rx_cmp_len_flags_type);
+ len = flags >> RX_CMP_LEN_SHIFT;
+ dma_addr = rx_buf->mapping;
+
+ if (len <= bn->rx_copybreak) {
+ skb = bnge_copy_skb(bnapi, data_ptr, len, dma_addr);
+ bnge_reuse_rx_data(rxr, cons, data);
+ if (!skb)
+ goto oom_next_rx;
+ } else {
+ u32 payload;
+
+ if (rx_buf->data_ptr == data_ptr)
+ payload = misc & RX_CMP_PAYLOAD_OFFSET;
+ else
+ payload = 0;
+ skb = bnge_rx_skb(bn, rxr, cons, data, data_ptr, dma_addr,
+ payload | len);
+ if (!skb)
+ goto oom_next_rx;
+ }
+
+ if (RX_CMP_HASH_VALID(rxcmp)) {
+ enum pkt_hash_types type;
+
+ if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
+ type = bnge_rss_ext_op(bn, rxcmp);
+ } else {
+ u32 itypes = RX_CMP_ITYPES(rxcmp);
+
+ if (itypes == RX_CMP_FLAGS_ITYPE_TCP ||
+ itypes == RX_CMP_FLAGS_ITYPE_UDP)
+ type = PKT_HASH_TYPE_L4;
+ else
+ type = PKT_HASH_TYPE_L3;
+ }
+ skb_set_hash(skb, le32_to_cpu(rxcmp->rx_cmp_rss_hash), type);
+ }
+
+ skb->protocol = eth_type_trans(skb, dev);
+
+ if (skb->dev->features & BNGE_HW_FEATURE_VLAN_ALL_RX) {
+ skb = bnge_rx_vlan(skb, cmp_type, rxcmp, rxcmp1);
+ if (!skb)
+ goto next_rx;
+ }
+
+ skb_checksum_none_assert(skb);
+ if (RX_CMP_L4_CS_OK(rxcmp1)) {
+ if (dev->features & NETIF_F_RXCSUM) {
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ skb->csum_level = RX_CMP_ENCAP(rxcmp1);
+ }
+ }
+
+ bnge_deliver_skb(bn, bnapi, skb);
+ rc = 1;
+
+next_rx:
+ /* Update Stats */
+next_rx_no_len:
+ rxr->rx_prod = NEXT_RX(prod);
+ rxr->rx_next_cons = RING_RX(bn, NEXT_RX(cons));
+
+next_rx_no_prod_no_len:
+ *raw_cons = tmp_raw_cons;
+ return rc;
+
+oom_next_rx:
+ rc = -ENOMEM;
+ goto next_rx;
+}
+
+/* In netpoll mode, if we are using a combined completion ring, we need to
+ * discard the rx packets and recycle the buffers.
+ */
+static int bnge_force_rx_discard(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ u32 *raw_cons, u8 *event)
+{
+ u32 tmp_raw_cons = *raw_cons;
+ struct rx_cmp_ext *rxcmp1;
+ struct rx_cmp *rxcmp;
+ u16 cp_cons;
+ u8 cmp_type;
+ int rc;
+
+ cp_cons = RING_CMP(bn, tmp_raw_cons);
+ rxcmp = (struct rx_cmp *)
+ &cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
+
+ tmp_raw_cons = NEXT_RAW_CMP(tmp_raw_cons);
+ cp_cons = RING_CMP(bn, tmp_raw_cons);
+ rxcmp1 = (struct rx_cmp_ext *)
+ &cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
+
+ if (!RX_CMP_VALID(rxcmp1, tmp_raw_cons))
+ return -EBUSY;
+
+ /* The valid test of the entry must be done first before
+ * reading any further.
+ */
+ dma_rmb();
+ cmp_type = RX_CMP_TYPE(rxcmp);
+ if (cmp_type == CMP_TYPE_RX_L2_CMP ||
+ cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
+ rxcmp1->rx_cmp_cfa_code_errors_v2 |=
+ cpu_to_le32(RX_CMPL_ERRORS_CRC_ERROR);
+ }
+ rc = bnge_rx_pkt(bn, cpr, raw_cons, event);
+ return rc;
+}
+
+static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
+ int budget)
+{
+ struct bnge_rx_ring_info *rxr = bnapi->rx_ring;
+
+ if ((bnapi->events & BNGE_RX_EVENT)) {
+ bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
+ bnapi->events &= ~BNGE_RX_EVENT;
+ }
+}
+
+static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
+ int budget)
+{
+ struct bnge_napi *bnapi = cpr->bnapi;
+ u32 raw_cons = cpr->cp_raw_cons;
+ struct tx_cmp *txcmp;
+ int rx_pkts = 0;
+ u8 event = 0;
+ u32 cons;
+
+ cpr->has_more_work = 0;
+ cpr->had_work_done = 1;
+ while (1) {
+ u8 cmp_type;
+ int rc;
+
+ cons = RING_CMP(bn, raw_cons);
+ txcmp = &cpr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
+
+ if (!TX_CMP_VALID(bn, txcmp, raw_cons))
+ break;
+
+ /* The valid test of the entry must be done first before
+ * reading any further.
+ */
+ dma_rmb();
+ cmp_type = TX_CMP_TYPE(txcmp);
+ if (cmp_type == CMP_TYPE_TX_L2_CMP ||
+ cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
+ /*
+ * Tx Compl Processng
+ */
+ } else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
+ cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
+ if (likely(budget))
+ rc = bnge_rx_pkt(bn, cpr, &raw_cons, &event);
+ else
+ rc = bnge_force_rx_discard(bn, cpr, &raw_cons,
+ &event);
+ if (likely(rc >= 0))
+ rx_pkts += rc;
+ /* Increment rx_pkts when rc is -ENOMEM to count towards
+ * the NAPI budget. Otherwise, we may potentially loop
+ * here forever if we consistently cannot allocate
+ * buffers.
+ */
+ else if (rc == -ENOMEM && budget)
+ rx_pkts++;
+ else if (rc == -EBUSY) /* partial completion */
+ break;
+ }
+
+ raw_cons = NEXT_RAW_CMP(raw_cons);
+
+ if (rx_pkts && rx_pkts == budget) {
+ cpr->has_more_work = 1;
+ break;
+ }
+ }
+
+ cpr->cp_raw_cons = raw_cons;
+ bnapi->events |= event;
+ return rx_pkts;
+}
+
+static void __bnge_poll_cqs_done(struct bnge_net *bn, struct bnge_napi *bnapi,
+ u64 dbr_type, int budget)
+{
+ struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
+ int i;
+
+ for (i = 0; i < nqr->cp_ring_count; i++) {
+ struct bnge_cp_ring_info *cpr = &nqr->cp_ring_arr[i];
+ struct bnge_db_info *db;
+
+ if (cpr->had_work_done) {
+ u32 tgl = 0;
+
+ if (dbr_type == DBR_TYPE_CQ_ARMALL) {
+ cpr->had_nqe_notify = 0;
+ tgl = cpr->toggle;
+ }
+ db = &cpr->cp_db;
+ bnge_writeq(bn->bd,
+ db->db_key64 | dbr_type | DB_TOGGLE(tgl) |
+ DB_RING_IDX(db, cpr->cp_raw_cons),
+ db->doorbell);
+ cpr->had_work_done = 0;
+ }
+ }
+ __bnge_poll_work_done(bn, bnapi, budget);
+}
+
+static int __bnge_poll_cqs(struct bnge_net *bn, struct bnge_napi *bnapi,
+ int budget)
+{
+ struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
+ int i, work_done = 0;
+
+ for (i = 0; i < nqr->cp_ring_count; i++) {
+ struct bnge_cp_ring_info *cpr = &nqr->cp_ring_arr[i];
+
+ if (cpr->had_nqe_notify) {
+ work_done += __bnge_poll_work(bn, cpr,
+ budget - work_done);
+ nqr->has_more_work |= cpr->has_more_work;
+ }
+ }
+ return work_done;
+}
+
+int bnge_napi_poll(struct napi_struct *napi, int budget)
+{
+ struct bnge_napi *bnapi = container_of(napi, struct bnge_napi, napi);
+ struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
+ u32 raw_cons = nqr->nq_raw_cons;
+ struct bnge_net *bn = bnapi->bn;
+ struct bnge_dev *bd = bn->bd;
+ struct nqe_cn *nqcmp;
+ int work_done = 0;
+ u32 cons;
+
+ if (nqr->has_more_work) {
+ nqr->has_more_work = 0;
+ work_done = __bnge_poll_cqs(bn, bnapi, budget);
+ }
+
+ while (1) {
+ u16 type;
+
+ cons = RING_CMP(bn, raw_cons);
+ nqcmp = &nqr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
+
+ if (!NQ_CMP_VALID(bn, nqcmp, raw_cons)) {
+ if (nqr->has_more_work)
+ break;
+
+ __bnge_poll_cqs_done(bn, bnapi, DBR_TYPE_CQ_ARMALL,
+ budget);
+ nqr->nq_raw_cons = raw_cons;
+ if (napi_complete_done(napi, work_done))
+ BNGE_DB_NQ_ARM(bd, &nqr->nq_db,
+ nqr->nq_raw_cons);
+ goto poll_done;
+ }
+
+ /* The valid test of the entry must be done first before
+ * reading any further.
+ */
+ dma_rmb();
+
+ type = le16_to_cpu(nqcmp->type);
+ if (NQE_CN_TYPE(type) == NQ_CN_TYPE_CQ_NOTIFICATION) {
+ u32 idx = le32_to_cpu(nqcmp->cq_handle_low);
+ u32 cq_type = BNGE_NQ_HDL_TYPE(idx);
+ struct bnge_cp_ring_info *cpr;
+
+ /* No more budget for RX work */
+ if (budget && work_done >= budget &&
+ cq_type == BNGE_NQ_HDL_TYPE_RX)
+ break;
+
+ idx = BNGE_NQ_HDL_IDX(idx);
+ cpr = &nqr->cp_ring_arr[idx];
+ cpr->had_nqe_notify = 1;
+ cpr->toggle = NQE_CN_TOGGLE(type);
+ work_done += __bnge_poll_work(bn, cpr,
+ budget - work_done);
+ nqr->has_more_work |= cpr->has_more_work;
+ }
+ raw_cons = NEXT_RAW_CMP(raw_cons);
+ }
+
+ __bnge_poll_cqs_done(bn, bnapi, DBR_TYPE_CQ, budget);
+ if (raw_cons != nqr->nq_raw_cons) {
+ nqr->nq_raw_cons = raw_cons;
+ BNGE_DB_NQ(bd, &nqr->nq_db, raw_cons);
+ }
+poll_done:
+ return work_done;
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
new file mode 100644
index 000000000000..b13081b0eb79
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
@@ -0,0 +1,90 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2025 Broadcom */
+
+#ifndef _BNGE_TXRX_H_
+#define _BNGE_TXRX_H_
+
+#include <linux/bnxt/hsi.h>
+#include "bnge_netdev.h"
+
+#define BNGE_MIN_PKT_SIZE 52
+
+#define TX_OPAQUE_IDX_MASK 0x0000ffff
+#define TX_OPAQUE_BDS_MASK 0x00ff0000
+#define TX_OPAQUE_BDS_SHIFT 16
+#define TX_OPAQUE_RING_MASK 0xff000000
+#define TX_OPAQUE_RING_SHIFT 24
+
+#define SET_TX_OPAQUE(bn, txr, idx, bds) \
+ (((txr)->tx_napi_idx << TX_OPAQUE_RING_SHIFT) | \
+ ((bds) << TX_OPAQUE_BDS_SHIFT) | ((idx) & (bn)->tx_ring_mask))
+
+#define TX_OPAQUE_IDX(opq) ((opq) & TX_OPAQUE_IDX_MASK)
+#define TX_OPAQUE_RING(opq) (((opq) & TX_OPAQUE_RING_MASK) >> \
+ TX_OPAQUE_RING_SHIFT)
+#define TX_OPAQUE_BDS(opq) (((opq) & TX_OPAQUE_BDS_MASK) >> \
+ TX_OPAQUE_BDS_SHIFT)
+#define TX_OPAQUE_PROD(bn, opq) ((TX_OPAQUE_IDX(opq) + TX_OPAQUE_BDS(opq)) &\
+ (bn)->tx_ring_mask)
+
+/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1. We need one extra
+ * BD because the first TX BD is always a long BD.
+ */
+#define BNGE_MIN_TX_DESC_CNT (MAX_SKB_FRAGS + 2)
+
+#define RX_RING(bn, x) (((x) & (bn)->rx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
+#define RX_AGG_RING(bn, x) (((x) & (bn)->rx_agg_ring_mask) >> \
+ (BNGE_PAGE_SHIFT - 4))
+#define RX_IDX(x) ((x) & (RX_DESC_CNT - 1))
+
+#define TX_RING(bn, x) (((x) & (bn)->tx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
+#define TX_IDX(x) ((x) & (TX_DESC_CNT - 1))
+
+#define CP_RING(x) (((x) & ~(CP_DESC_CNT - 1)) >> (BNGE_PAGE_SHIFT - 4))
+#define CP_IDX(x) ((x) & (CP_DESC_CNT - 1))
+
+#define TX_CMP_VALID(bn, txcmp, raw_cons) \
+ (!!((txcmp)->tx_cmp_errors_v & cpu_to_le32(TX_CMP_V)) == \
+ !((raw_cons) & (bn)->cp_bit))
+
+#define RX_CMP_VALID(rxcmp1, raw_cons) \
+ (!!((rxcmp1)->rx_cmp_cfa_code_errors_v2 & cpu_to_le32(RX_CMP_V)) ==\
+ !((raw_cons) & (bn)->cp_bit))
+
+#define RX_AGG_CMP_VALID(bn, agg, raw_cons) \
+ (!!((agg)->rx_agg_cmp_v & cpu_to_le32(RX_AGG_CMP_V)) == \
+ !((raw_cons) & (bn)->cp_bit))
+
+#define NQ_CMP_VALID(bn, nqcmp, raw_cons) \
+ (!!((nqcmp)->v & cpu_to_le32(NQ_CN_V)) == !((raw_cons) & (bn)->cp_bit))
+
+#define TX_CMP_TYPE(txcmp) \
+ (le32_to_cpu((txcmp)->tx_cmp_flags_type) & CMP_TYPE)
+
+#define RX_CMP_TYPE(rxcmp) \
+ (le32_to_cpu((rxcmp)->rx_cmp_len_flags_type) & RX_CMP_CMP_TYPE)
+
+#define RING_RX(bn, idx) ((idx) & (bn)->rx_ring_mask)
+#define NEXT_RX(idx) ((idx) + 1)
+
+#define RING_RX_AGG(bn, idx) ((idx) & (bn)->rx_agg_ring_mask)
+#define NEXT_RX_AGG(idx) ((idx) + 1)
+
+#define RING_TX(bn, idx) ((idx) & (bn)->tx_ring_mask)
+#define NEXT_TX(idx) ((idx) + 1)
+
+#define ADV_RAW_CMP(idx, n) ((idx) + (n))
+#define NEXT_RAW_CMP(idx) ADV_RAW_CMP(idx, 1)
+#define RING_CMP(bn, idx) ((idx) & (bn)->cp_ring_mask)
+
+#define RX_CMP_ITYPES(rxcmp) \
+ (le32_to_cpu((rxcmp)->rx_cmp_len_flags_type) & RX_CMP_FLAGS_ITYPES_MASK)
+
+#define RX_CMP_CFA_CODE(rxcmpl1) \
+ ((le32_to_cpu((rxcmpl1)->rx_cmp_cfa_code_errors_v2) & \
+ RX_CMPL_CFA_CODE_MASK) >> RX_CMPL_CFA_CODE_SFT)
+
+irqreturn_t bnge_msix(int irq, void *dev_instance);
+void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data);
+int bnge_napi_poll(struct napi_struct *napi, int budget);
+#endif /* _BNGE_TXRX_H_ */
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-05 7:21 ` [v4, net-next 2/7] bng_en: Add RX support Bhargava Marreddy
@ 2026-01-08 9:45 ` Paolo Abeni
2026-01-12 19:44 ` Bhargava Chenna Marreddy
2026-01-16 17:06 ` ALOK TIWARI
1 sibling, 1 reply; 18+ messages in thread
From: Paolo Abeni @ 2026-01-08 9:45 UTC (permalink / raw)
To: Bhargava Marreddy, davem, edumazet, kuba, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Rajashekar Hudumula
On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> new file mode 100644
> index 000000000000..4da4259095fa
> --- /dev/null
> +++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> @@ -0,0 +1,198 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/* Copyright (c) 2025 Broadcom */
> +
> +#ifndef _BNGE_HW_DEF_H_
> +#define _BNGE_HW_DEF_H_
> +
> +struct tx_bd_ext {
> + __le32 tx_bd_hsize_lflags;
> + #define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
Please use BIT()
> + #define TX_BD_FLAGS_IP_CKSUM (1 << 1)
> + #define TX_BD_FLAGS_NO_CRC (1 << 2)
> + #define TX_BD_FLAGS_STAMP (1 << 3)
> + #define TX_BD_FLAGS_T_IP_CHKSUM (1 << 4)
> + #define TX_BD_FLAGS_LSO (1 << 5)
> + #define TX_BD_FLAGS_IPID_FMT (1 << 6)
> + #define TX_BD_FLAGS_T_IPID (1 << 7)
> + #define TX_BD_HSIZE (0xff << 16)
> + #define TX_BD_HSIZE_SHIFT 16
I'm quite suprised checkpatch does not complain, but the above
indentation is IMHO quite messy.
please move the macro definition before the struct and avoid mixing
whitespaces and tabs.
[...]
> @@ -1756,6 +1757,78 @@ static int bnge_cfg_def_vnic(struct bnge_net *bn)
> return rc;
> }
>
> +static void bnge_disable_int(struct bnge_net *bn)
> +{
> + struct bnge_dev *bd = bn->bd;
> + int i;
> +
> + if (!bn->bnapi)
> + return;
> +
> + for (i = 0; i < bd->nq_nr_rings; i++) {
> + struct bnge_napi *bnapi = bn->bnapi[i];
> + struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
> + struct bnge_ring_struct *ring = &nqr->ring_struct;
Please respect the reverse christmas tree above.
> +
> + if (ring->fw_ring_id != INVALID_HW_RING_ID)
> + bnge_db_nq(bn, &nqr->nq_db, nqr->nq_raw_cons);
> + }
> +}
> +
> +static void bnge_disable_int_sync(struct bnge_net *bn)
> +{
> + struct bnge_dev *bd = bn->bd;
> + int i;
> +
> + bnge_disable_int(bn);
> + for (i = 0; i < bd->nq_nr_rings; i++) {
> + int map_idx = bnge_cp_num_to_irq_num(bn, i);
> +
> + synchronize_irq(bd->irq_tbl[map_idx].vector);
> + }
> +}
> +
> +static void bnge_enable_int(struct bnge_net *bn)
> +{
> + struct bnge_dev *bd = bn->bd;
> + int i;
> +
> + for (i = 0; i < bd->nq_nr_rings; i++) {
> + struct bnge_napi *bnapi = bn->bnapi[i];
> + struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
Same here
> @@ -298,6 +343,10 @@ struct bnge_cp_ring_info {
> u8 cp_idx;
> u32 cp_raw_cons;
> struct bnge_db_info cp_db;
> + u8 had_work_done:1;
> + u8 has_more_work:1;
> + u8 had_nqe_notify:1;
Any special reasons to use bitfields here? `bool` will generate better
code, and will not change the struct size.
[...]
> +static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
> + unsigned int len, dma_addr_t mapping)
> +{
> + struct bnge_net *bn = bnapi->bn;
> + struct bnge_dev *bd = bn->bd;
> + struct sk_buff *skb;
> +
> + skb = napi_alloc_skb(&bnapi->napi, len);
> + if (!skb)
> + return NULL;
> +
> + dma_sync_single_for_cpu(bd->dev, mapping, bn->rx_copybreak,
> + bn->rx_dir);
> +
> + memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
> + len + NET_IP_ALIGN);
This works under the assumption that len <= bn->rx_copybreak; why
syncing the whole 'rx_copybreak' instead of 'len' ?
> +
> + dma_sync_single_for_device(bd->dev, mapping, bn->rx_copybreak,
> + bn->rx_dir);
Why is the above needed?
> +
> + skb_put(skb, len);
> +
> + return skb;
> +}
> +
> +static enum pkt_hash_types bnge_rss_ext_op(struct bnge_net *bn,
> + struct rx_cmp *rxcmp)
> +{
> + u8 ext_op = RX_CMP_V3_HASH_TYPE(bn->bd, rxcmp);
> +
> + switch (ext_op) {
> + case EXT_OP_INNER_4:
> + case EXT_OP_OUTER_4:
> + case EXT_OP_INNFL_3:
> + case EXT_OP_OUTFL_3:
> + return PKT_HASH_TYPE_L4;
> + default:
> + return PKT_HASH_TYPE_L3;
> + }
> +}
> +
> +static struct sk_buff *bnge_rx_vlan(struct sk_buff *skb, u8 cmp_type,
> + struct rx_cmp *rxcmp,
> + struct rx_cmp_ext *rxcmp1)
> +{
> + __be16 vlan_proto;
> + u16 vtag;
> +
> + if (cmp_type == CMP_TYPE_RX_L2_CMP) {
> + __le32 flags2 = rxcmp1->rx_cmp_flags2;
> + u32 meta_data;
> +
> + if (!(flags2 & cpu_to_le32(RX_CMP_FLAGS2_META_FORMAT_VLAN)))
> + return skb;
> +
> + meta_data = le32_to_cpu(rxcmp1->rx_cmp_meta_data);
> + vtag = meta_data & RX_CMP_FLAGS2_METADATA_TCI_MASK;
> + vlan_proto =
> + htons(meta_data >> RX_CMP_FLAGS2_METADATA_TPID_SFT);
> + if (eth_type_vlan(vlan_proto))
> + __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
> + else
> + goto vlan_err;
> + } else if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
> + if (RX_CMP_VLAN_VALID(rxcmp)) {
> + u32 tpid_sel = RX_CMP_VLAN_TPID_SEL(rxcmp);
> +
> + if (tpid_sel == RX_CMP_METADATA1_TPID_8021Q)
> + vlan_proto = htons(ETH_P_8021Q);
> + else if (tpid_sel == RX_CMP_METADATA1_TPID_8021AD)
> + vlan_proto = htons(ETH_P_8021AD);
> + else
> + goto vlan_err;
> + vtag = RX_CMP_METADATA0_TCI(rxcmp1);
> + __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
> + }
> + }
> + return skb;
> +
> +vlan_err:
> + skb_mark_for_recycle(skb);
> + dev_kfree_skb(skb);
> + return NULL;
> +}
> +
> +static struct sk_buff *bnge_rx_skb(struct bnge_net *bn,
> + struct bnge_rx_ring_info *rxr, u16 cons,
> + void *data, u8 *data_ptr,
> + dma_addr_t dma_addr,
> + unsigned int offset_and_len)
> +{
> + struct bnge_dev *bd = bn->bd;
> + u16 prod = rxr->rx_prod;
> + struct sk_buff *skb;
> + int err;
> +
> + err = bnge_alloc_rx_data(bn, rxr, prod, GFP_ATOMIC);
> + if (unlikely(err)) {
> + bnge_reuse_rx_data(rxr, cons, data);
> + return NULL;
> + }
> +
> + skb = napi_build_skb(data, bn->rx_buf_size);
> + dma_sync_single_for_cpu(bd->dev, dma_addr, bn->rx_buf_use_size,
> + bn->rx_dir);
Why you need to sync the whole `rx_buf_use_size` instead of the actual
packet len?
> + if (!skb) {
> + page_pool_free_va(rxr->head_pool, data, true);
> + return NULL;
> + }
> +
> + skb_mark_for_recycle(skb);
> + skb_reserve(skb, bn->rx_offset);
> + skb_put(skb, offset_and_len & 0xffff);
It's unclear why you pass 2 different values mangled together and than
extract only one of them.
/P
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-08 9:45 ` Paolo Abeni
@ 2026-01-12 19:44 ` Bhargava Chenna Marreddy
2026-01-12 21:11 ` Andrew Lunn
2026-01-16 16:58 ` Bhargava Chenna Marreddy
0 siblings, 2 replies; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-12 19:44 UTC (permalink / raw)
To: Paolo Abeni
Cc: davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 9545 bytes --]
On Thu, Jan 8, 2026 at 3:15 PM Paolo Abeni <pabeni@redhat.com> wrote:
>
> On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > new file mode 100644
> > index 000000000000..4da4259095fa
> > --- /dev/null
> > +++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > @@ -0,0 +1,198 @@
> > +/* SPDX-License-Identifier: GPL-2.0 */
> > +/* Copyright (c) 2025 Broadcom */
> > +
> > +#ifndef _BNGE_HW_DEF_H_
> > +#define _BNGE_HW_DEF_H_
> > +
> > +struct tx_bd_ext {
> > + __le32 tx_bd_hsize_lflags;
> > + #define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
>
> Please use BIT()
Simon Horman raised a similar point. However, some hardware BD values
use non-contiguous bits that make BIT() and GENMASK() overly complex.
We believe the current definitions better reflect the hardware spec.
Please let us know if you’d still prefer a different approach.
>
> > + #define TX_BD_FLAGS_IP_CKSUM (1 << 1)
> > + #define TX_BD_FLAGS_NO_CRC (1 << 2)
> > + #define TX_BD_FLAGS_STAMP (1 << 3)
> > + #define TX_BD_FLAGS_T_IP_CHKSUM (1 << 4)
> > + #define TX_BD_FLAGS_LSO (1 << 5)
> > + #define TX_BD_FLAGS_IPID_FMT (1 << 6)
> > + #define TX_BD_FLAGS_T_IPID (1 << 7)
> > + #define TX_BD_HSIZE (0xff << 16)
> > + #define TX_BD_HSIZE_SHIFT 16
>
> I'm quite suprised checkpatch does not complain, but the above
> indentation is IMHO quite messy.
Thanks, I’ll fix the indentation (mixing whitespaces and tabs) in the
next version.
>
> please move the macro definition before the struct and avoid mixing
> whitespaces and tabs.
Since these are hardware-defined structs, we kept the #defines with
their members to make the mapping clear.
Any concerns with this?
>
> [...]
> > @@ -1756,6 +1757,78 @@ static int bnge_cfg_def_vnic(struct bnge_net *bn)
> > return rc;
> > }
> >
> > +static void bnge_disable_int(struct bnge_net *bn)
> > +{
> > + struct bnge_dev *bd = bn->bd;
> > + int i;
> > +
> > + if (!bn->bnapi)
> > + return;
> > +
> > + for (i = 0; i < bd->nq_nr_rings; i++) {
> > + struct bnge_napi *bnapi = bn->bnapi[i];
> > + struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
> > + struct bnge_ring_struct *ring = &nqr->ring_struct;
>
> Please respect the reverse christmas tree above.
Thanks! I’ll fix it in the next revision.
>
> > +
> > + if (ring->fw_ring_id != INVALID_HW_RING_ID)
> > + bnge_db_nq(bn, &nqr->nq_db, nqr->nq_raw_cons);
> > + }
> > +}
> > +
> > +static void bnge_disable_int_sync(struct bnge_net *bn)
> > +{
> > + struct bnge_dev *bd = bn->bd;
> > + int i;
> > +
> > + bnge_disable_int(bn);
> > + for (i = 0; i < bd->nq_nr_rings; i++) {
> > + int map_idx = bnge_cp_num_to_irq_num(bn, i);
> > +
> > + synchronize_irq(bd->irq_tbl[map_idx].vector);
> > + }
> > +}
> > +
> > +static void bnge_enable_int(struct bnge_net *bn)
> > +{
> > + struct bnge_dev *bd = bn->bd;
> > + int i;
> > +
> > + for (i = 0; i < bd->nq_nr_rings; i++) {
> > + struct bnge_napi *bnapi = bn->bnapi[i];
> > + struct bnge_nq_ring_info *nqr = &bnapi->nq_ring;
>
> Same here
Thanks! I’ll fix it in the next revision.
> > @@ -298,6 +343,10 @@ struct bnge_cp_ring_info {
> > u8 cp_idx;
> > u32 cp_raw_cons;
> > struct bnge_db_info cp_db;
> > + u8 had_work_done:1;
> > + u8 has_more_work:1;
> > + u8 had_nqe_notify:1;
>
> Any special reasons to use bitfields here? `bool` will generate better
> code, and will not change the struct size.
Thanks, I’ll switch these to bool as suggested.
>
> [...]
> > +static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
> > + unsigned int len, dma_addr_t mapping)
> > +{
> > + struct bnge_net *bn = bnapi->bn;
> > + struct bnge_dev *bd = bn->bd;
> > + struct sk_buff *skb;
> > +
> > + skb = napi_alloc_skb(&bnapi->napi, len);
> > + if (!skb)
> > + return NULL;
> > +
> > + dma_sync_single_for_cpu(bd->dev, mapping, bn->rx_copybreak,
> > + bn->rx_dir);
> > +
> > + memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
> > + len + NET_IP_ALIGN);
>
> This works under the assumption that len <= bn->rx_copybreak; why
> syncing the whole 'rx_copybreak' instead of 'len' ?
Good point. syncing the actual packet length is more precise and
avoids unnecessary cache maintenance.
Let us test this on our hardware and get back to you.
>
> > +
> > + dma_sync_single_for_device(bd->dev, mapping, bn->rx_copybreak,
> > + bn->rx_dir);
>
> Why is the above needed?
Since the buffer is being reused, the for_device sync hands ownership
back to the hardware.
This ensures the memory is ready for the next DMA transfer and
maintains consistency on non-coherent architectures.
Any concerns with this?
>
> > +
> > + skb_put(skb, len);
> > +
> > + return skb;
> > +}
> > +
> > +static enum pkt_hash_types bnge_rss_ext_op(struct bnge_net *bn,
> > + struct rx_cmp *rxcmp)
> > +{
> > + u8 ext_op = RX_CMP_V3_HASH_TYPE(bn->bd, rxcmp);
> > +
> > + switch (ext_op) {
> > + case EXT_OP_INNER_4:
> > + case EXT_OP_OUTER_4:
> > + case EXT_OP_INNFL_3:
> > + case EXT_OP_OUTFL_3:
> > + return PKT_HASH_TYPE_L4;
> > + default:
> > + return PKT_HASH_TYPE_L3;
> > + }
> > +}
> > +
> > +static struct sk_buff *bnge_rx_vlan(struct sk_buff *skb, u8 cmp_type,
> > + struct rx_cmp *rxcmp,
> > + struct rx_cmp_ext *rxcmp1)
> > +{
> > + __be16 vlan_proto;
> > + u16 vtag;
> > +
> > + if (cmp_type == CMP_TYPE_RX_L2_CMP) {
> > + __le32 flags2 = rxcmp1->rx_cmp_flags2;
> > + u32 meta_data;
> > +
> > + if (!(flags2 & cpu_to_le32(RX_CMP_FLAGS2_META_FORMAT_VLAN)))
> > + return skb;
> > +
> > + meta_data = le32_to_cpu(rxcmp1->rx_cmp_meta_data);
> > + vtag = meta_data & RX_CMP_FLAGS2_METADATA_TCI_MASK;
> > + vlan_proto =
> > + htons(meta_data >> RX_CMP_FLAGS2_METADATA_TPID_SFT);
> > + if (eth_type_vlan(vlan_proto))
> > + __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
> > + else
> > + goto vlan_err;
> > + } else if (cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
> > + if (RX_CMP_VLAN_VALID(rxcmp)) {
> > + u32 tpid_sel = RX_CMP_VLAN_TPID_SEL(rxcmp);
> > +
> > + if (tpid_sel == RX_CMP_METADATA1_TPID_8021Q)
> > + vlan_proto = htons(ETH_P_8021Q);
> > + else if (tpid_sel == RX_CMP_METADATA1_TPID_8021AD)
> > + vlan_proto = htons(ETH_P_8021AD);
> > + else
> > + goto vlan_err;
> > + vtag = RX_CMP_METADATA0_TCI(rxcmp1);
> > + __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
> > + }
> > + }
> > + return skb;
> > +
> > +vlan_err:
> > + skb_mark_for_recycle(skb);
> > + dev_kfree_skb(skb);
> > + return NULL;
> > +}
> > +
> > +static struct sk_buff *bnge_rx_skb(struct bnge_net *bn,
> > + struct bnge_rx_ring_info *rxr, u16 cons,
> > + void *data, u8 *data_ptr,
> > + dma_addr_t dma_addr,
> > + unsigned int offset_and_len)
> > +{
> > + struct bnge_dev *bd = bn->bd;
> > + u16 prod = rxr->rx_prod;
> > + struct sk_buff *skb;
> > + int err;
> > +
> > + err = bnge_alloc_rx_data(bn, rxr, prod, GFP_ATOMIC);
> > + if (unlikely(err)) {
> > + bnge_reuse_rx_data(rxr, cons, data);
> > + return NULL;
> > + }
> > +
> > + skb = napi_build_skb(data, bn->rx_buf_size);
> > + dma_sync_single_for_cpu(bd->dev, dma_addr, bn->rx_buf_use_size,
> > + bn->rx_dir);
>
> Why you need to sync the whole `rx_buf_use_size` instead of the actual
> packet len?
Good point. Let us test this on our hardware and get back to you.
>
> > + if (!skb) {
> > + page_pool_free_va(rxr->head_pool, data, true);
> > + return NULL;
> > + }
> > +
> > + skb_mark_for_recycle(skb);
> > + skb_reserve(skb, bn->rx_offset);
> > + skb_put(skb, offset_and_len & 0xffff);
>
> It's unclear why you pass 2 different values mangled together and than
> extract only one of them.
Thanks! I’ll fix it in the next revision.
Thanks,
Bhargava Marreddy
>
> /P
>
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-12 19:44 ` Bhargava Chenna Marreddy
@ 2026-01-12 21:11 ` Andrew Lunn
2026-01-16 16:47 ` Bhargava Chenna Marreddy
2026-01-16 16:58 ` Bhargava Chenna Marreddy
1 sibling, 1 reply; 18+ messages in thread
From: Andrew Lunn @ 2026-01-12 21:11 UTC (permalink / raw)
To: Bhargava Chenna Marreddy
Cc: Paolo Abeni, davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
On Tue, Jan 13, 2026 at 01:14:33AM +0530, Bhargava Chenna Marreddy wrote:
> On Thu, Jan 8, 2026 at 3:15 PM Paolo Abeni <pabeni@redhat.com> wrote:
> >
> > On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > > diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > > new file mode 100644
> > > index 000000000000..4da4259095fa
> > > --- /dev/null
> > > +++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > > @@ -0,0 +1,198 @@
> > > +/* SPDX-License-Identifier: GPL-2.0 */
> > > +/* Copyright (c) 2025 Broadcom */
> > > +
> > > +#ifndef _BNGE_HW_DEF_H_
> > > +#define _BNGE_HW_DEF_H_
> > > +
> > > +struct tx_bd_ext {
> > > + __le32 tx_bd_hsize_lflags;
> > > + #define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
> >
> > Please use BIT()
>
> Simon Horman raised a similar point. However, some hardware BD values
> use non-contiguous bits that make BIT() and GENMASK() overly complex.
> We believe the current definitions better reflect the hardware spec.
> Please let us know if you’d still prefer a different approach.
You probably want to use BIT() for all fields which are
contiguous. Doing something different then marks the other fields are
somehow special and need treating with care.
> > > + #define TX_BD_FLAGS_IP_CKSUM (1 << 1)
> > > + #define TX_BD_FLAGS_NO_CRC (1 << 2)
> > > + #define TX_BD_FLAGS_STAMP (1 << 3)
> > > + #define TX_BD_FLAGS_T_IP_CHKSUM (1 << 4)
> > > + #define TX_BD_FLAGS_LSO (1 << 5)
> > > + #define TX_BD_FLAGS_IPID_FMT (1 << 6)
> > > + #define TX_BD_FLAGS_T_IPID (1 << 7)
> > > + #define TX_BD_HSIZE (0xff << 16)
> > > + #define TX_BD_HSIZE_SHIFT 16
> >
> > I'm quite suprised checkpatch does not complain, but the above
> > indentation is IMHO quite messy.
> > please move the macro definition before the struct and avoid mixing
> > whitespaces and tabs.
>
> Since these are hardware-defined structs, we kept the #defines with
> their members to make the mapping clear.
> Any concerns with this?
The names should make it clear. The structure member can be called
tx_bd_flags, and the bits are TX_BD_FLAGS_IP_CKSUM etc.
> > > +static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
> > > + unsigned int len, dma_addr_t mapping)
> > > +{
> > > + struct bnge_net *bn = bnapi->bn;
> > > + struct bnge_dev *bd = bn->bd;
> > > + struct sk_buff *skb;
> > > +
> > > + skb = napi_alloc_skb(&bnapi->napi, len);
> > > + if (!skb)
> > > + return NULL;
> > > +
> > > + dma_sync_single_for_cpu(bd->dev, mapping, bn->rx_copybreak,
> > > + bn->rx_dir);
> > > +
> > > + memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
> > > + len + NET_IP_ALIGN);
> >
> > This works under the assumption that len <= bn->rx_copybreak; why
> > syncing the whole 'rx_copybreak' instead of 'len' ?
>
> Good point. syncing the actual packet length is more precise and
> avoids unnecessary cache maintenance.
> Let us test this on our hardware and get back to you.
When i did this for the FEC, i got a nice performance boost.
Andrew
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-12 21:11 ` Andrew Lunn
@ 2026-01-16 16:47 ` Bhargava Chenna Marreddy
0 siblings, 0 replies; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-16 16:47 UTC (permalink / raw)
To: Andrew Lunn
Cc: Paolo Abeni, davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 3959 bytes --]
On Tue, Jan 13, 2026 at 2:41 AM Andrew Lunn <andrew@lunn.ch> wrote:
>
> On Tue, Jan 13, 2026 at 01:14:33AM +0530, Bhargava Chenna Marreddy wrote:
> > On Thu, Jan 8, 2026 at 3:15 PM Paolo Abeni <pabeni@redhat.com> wrote:
> > >
> > > On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > > > diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > > > new file mode 100644
> > > > index 000000000000..4da4259095fa
> > > > --- /dev/null
> > > > +++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > > > @@ -0,0 +1,198 @@
> > > > +/* SPDX-License-Identifier: GPL-2.0 */
> > > > +/* Copyright (c) 2025 Broadcom */
> > > > +
> > > > +#ifndef _BNGE_HW_DEF_H_
> > > > +#define _BNGE_HW_DEF_H_
> > > > +
> > > > +struct tx_bd_ext {
> > > > + __le32 tx_bd_hsize_lflags;
> > > > + #define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
> > >
> > > Please use BIT()
> >
> > Simon Horman raised a similar point. However, some hardware BD values
> > use non-contiguous bits that make BIT() and GENMASK() overly complex.
> > We believe the current definitions better reflect the hardware spec.
> > Please let us know if you’d still prefer a different approach.
>
> You probably want to use BIT() for all fields which are
> contiguous. Doing something different then marks the other fields are
> somehow special and need treating with care.
Thanks, Andrew. Will address in the next version.
>
> > > > + #define TX_BD_FLAGS_IP_CKSUM (1 << 1)
> > > > + #define TX_BD_FLAGS_NO_CRC (1 << 2)
> > > > + #define TX_BD_FLAGS_STAMP (1 << 3)
> > > > + #define TX_BD_FLAGS_T_IP_CHKSUM (1 << 4)
> > > > + #define TX_BD_FLAGS_LSO (1 << 5)
> > > > + #define TX_BD_FLAGS_IPID_FMT (1 << 6)
> > > > + #define TX_BD_FLAGS_T_IPID (1 << 7)
> > > > + #define TX_BD_HSIZE (0xff << 16)
> > > > + #define TX_BD_HSIZE_SHIFT 16
> > >
> > > I'm quite suprised checkpatch does not complain, but the above
> > > indentation is IMHO quite messy.
>
> > > please move the macro definition before the struct and avoid mixing
> > > whitespaces and tabs.
> >
> > Since these are hardware-defined structs, we kept the #defines with
> > their members to make the mapping clear.
> > Any concerns with this?
Ack. Will fix it in the next spin.
>
> The names should make it clear. The structure member can be called
> tx_bd_flags, and the bits are TX_BD_FLAGS_IP_CKSUM etc.
>
> > > > +static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
> > > > + unsigned int len, dma_addr_t mapping)
> > > > +{
> > > > + struct bnge_net *bn = bnapi->bn;
> > > > + struct bnge_dev *bd = bn->bd;
> > > > + struct sk_buff *skb;
> > > > +
> > > > + skb = napi_alloc_skb(&bnapi->napi, len);
> > > > + if (!skb)
> > > > + return NULL;
> > > > +
> > > > + dma_sync_single_for_cpu(bd->dev, mapping, bn->rx_copybreak,
> > > > + bn->rx_dir);
> > > > +
> > > > + memcpy(skb->data - NET_IP_ALIGN, data - NET_IP_ALIGN,
> > > > + len + NET_IP_ALIGN);
> > >
> > > This works under the assumption that len <= bn->rx_copybreak; why
> > > syncing the whole 'rx_copybreak' instead of 'len' ?
> >
> > Good point. syncing the actual packet length is more precise and
> > avoids unnecessary cache maintenance.
> > Let us test this on our hardware and get back to you.
>
> When i did this for the FEC, i got a nice performance boost.
Thanks for sharing the results, will fix it in next spin.
Thanks,
Bhargava Marreddy
>
> Andrew
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-12 19:44 ` Bhargava Chenna Marreddy
2026-01-12 21:11 ` Andrew Lunn
@ 2026-01-16 16:58 ` Bhargava Chenna Marreddy
1 sibling, 0 replies; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-16 16:58 UTC (permalink / raw)
To: Paolo Abeni
Cc: davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 1006 bytes --]
On Tue, Jan 13, 2026 at 1:14 AM Bhargava Chenna Marreddy
<bhargava.marreddy@broadcom.com> wrote:
>
> On Thu, Jan 8, 2026 at 3:15 PM Paolo Abeni <pabeni@redhat.com> wrote:
> >
> > On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > > +
> > > + dma_sync_single_for_device(bd->dev, mapping, bn->rx_copybreak,
> > > + bn->rx_dir);
> >
> > Why is the above needed?
>
> Since the buffer is being reused, the for_device sync hands ownership
> back to the hardware.
> This ensures the memory is ready for the next DMA transfer and
> maintains consistency on non-coherent architectures.
> Any concerns with this?
Thanks, Paolo. You're correct. I took another look and realized the
for_device sync
is redundant here since the CPU only reads the data and hasn't written
to the buffer.
I'll remove this in the next revision.
Thanks,
Bhargava Marreddy
>
> >
> > > +
> > > + skb_put(skb, len);
> > > +
> > > + return skb;
> > > +}
> > > +
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread
* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-05 7:21 ` [v4, net-next 2/7] bng_en: Add RX support Bhargava Marreddy
2026-01-08 9:45 ` Paolo Abeni
@ 2026-01-16 17:06 ` ALOK TIWARI
2026-01-16 18:28 ` Bhargava Chenna Marreddy
1 sibling, 1 reply; 18+ messages in thread
From: ALOK TIWARI @ 2026-01-16 17:06 UTC (permalink / raw)
To: Bhargava Marreddy, davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Rajashekar Hudumula
On 1/5/2026 12:51 PM, Bhargava Marreddy wrote:
> Add support to receive packet using NAPI, build and deliver the skb
> to stack. With help of meta data available in completions, fill the
> appropriate information in skb.
>
> Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
> Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
> Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
> ---
> drivers/net/ethernet/broadcom/bnge/Makefile | 3 +-
> .../net/ethernet/broadcom/bnge/bnge_hw_def.h | 198 ++++++
> .../net/ethernet/broadcom/bnge/bnge_netdev.c | 113 +++-
> .../net/ethernet/broadcom/bnge/bnge_netdev.h | 60 +-
> .../net/ethernet/broadcom/bnge/bnge_txrx.c | 573 ++++++++++++++++++
> .../net/ethernet/broadcom/bnge/bnge_txrx.h | 90 +++
> 6 files changed, 1016 insertions(+), 21 deletions(-)
> create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
> create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
>
> +
> +static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
> + int budget)
> +{
> + struct bnge_napi *bnapi = cpr->bnapi;
> + u32 raw_cons = cpr->cp_raw_cons;
> + struct tx_cmp *txcmp;
> + int rx_pkts = 0;
> + u8 event = 0;
> + u32 cons;
> +
> + cpr->has_more_work = 0;
> + cpr->had_work_done = 1;
> + while (1) {
> + u8 cmp_type;
> + int rc;
> +
> + cons = RING_CMP(bn, raw_cons);
> + txcmp = &cpr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
> +
> + if (!TX_CMP_VALID(bn, txcmp, raw_cons))
> + break;
> +
> + /* The valid test of the entry must be done first before
> + * reading any further.
> + */
> + dma_rmb();
> + cmp_type = TX_CMP_TYPE(txcmp);
> + if (cmp_type == CMP_TYPE_TX_L2_CMP ||
> + cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
> + /*
> + * Tx Compl Processng
typo -> Processng
> + */
> + } else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
> + cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
> + if (likely(budget))
> + rc = bnge_rx_pkt(bn, cpr, &raw_cons, &event);
> + else
> + rc = bnge_force_rx_discard(bn, cpr, &raw_cons,
> + &event);
> + if (likely(rc >= 0))
> + rx_pkts += rc;
> + /* Increment rx_pkts when rc is -ENOMEM to count towards
> + * the NAPI budget. Otherwise, we may potentially loop
> + * here forever if we consistently cannot allocate
> + * buffers.
> + */
> + else if (rc == -ENOMEM && budget)
> + rx_pkts++;
> + else if (rc == -EBUSY) /* partial completion */
> + break;
> + }
> +
> + raw_cons = NEXT_RAW_CMP(raw_cons);
> +
> + if (rx_pkts && rx_pkts == budget) {
> + cpr->has_more_work = 1;
> + break;
> + }
> + }
> +
> + cpr->cp_raw_cons = raw_cons;
> + bnapi->events |= event;
> + return rx_pkts;
> +}
> diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
> new file mode 100644
> index 000000000000..b13081b0eb79
> --- /dev/null
> +++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
> @@ -0,0 +1,90 @@
> +/* SPDX-License-Identifier: GPL-2.0 */
> +/* Copyright (c) 2025 Broadcom */
> +
> +#ifndef _BNGE_TXRX_H_
> +#define _BNGE_TXRX_H_
> +
> +#include <linux/bnxt/hsi.h>
> +#include "bnge_netdev.h"
> +
> +#define BNGE_MIN_PKT_SIZE 52
> +
> +#define TX_OPAQUE_IDX_MASK 0x0000ffff
> +#define TX_OPAQUE_BDS_MASK 0x00ff0000
> +#define TX_OPAQUE_BDS_SHIFT 16
> +#define TX_OPAQUE_RING_MASK 0xff000000
> +#define TX_OPAQUE_RING_SHIFT 24
> +
> +#define SET_TX_OPAQUE(bn, txr, idx, bds) \
> + (((txr)->tx_napi_idx << TX_OPAQUE_RING_SHIFT) | \
> + ((bds) << TX_OPAQUE_BDS_SHIFT) | ((idx) & (bn)->tx_ring_mask))
> +
> +#define TX_OPAQUE_IDX(opq) ((opq) & TX_OPAQUE_IDX_MASK)
> +#define TX_OPAQUE_RING(opq) (((opq) & TX_OPAQUE_RING_MASK) >> \
> + TX_OPAQUE_RING_SHIFT)
> +#define TX_OPAQUE_BDS(opq) (((opq) & TX_OPAQUE_BDS_MASK) >> \
> + TX_OPAQUE_BDS_SHIFT)
> +#define TX_OPAQUE_PROD(bn, opq) ((TX_OPAQUE_IDX(opq) + TX_OPAQUE_BDS(opq)) &\
> + (bn)->tx_ring_mask)
> +
> +/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1. We need one extra
> + * BD because the first TX BD is always a long BD.
> + */
> +#define BNGE_MIN_TX_DESC_CNT (MAX_SKB_FRAGS + 2)
> +
> +#define RX_RING(bn, x) (((x) & (bn)->rx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
> +#define RX_AGG_RING(bn, x) (((x) & (bn)->rx_agg_ring_mask) >> \
> + (BNGE_PAGE_SHIFT - 4))
> +#define RX_IDX(x) ((x) & (RX_DESC_CNT - 1))
> +
> +#define TX_RING(bn, x) (((x) & (bn)->tx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
> +#define TX_IDX(x) ((x) & (TX_DESC_CNT - 1))
> +
> +#define CP_RING(x) (((x) & ~(CP_DESC_CNT - 1)) >> (BNGE_PAGE_SHIFT - 4))
> +#define CP_IDX(x) ((x) & (CP_DESC_CNT - 1))
> +
> +#define TX_CMP_VALID(bn, txcmp, raw_cons) \
> + (!!((txcmp)->tx_cmp_errors_v & cpu_to_le32(TX_CMP_V)) == \
> + !((raw_cons) & (bn)->cp_bit))
> +
> +#define RX_CMP_VALID(rxcmp1, raw_cons) \
> + (!!((rxcmp1)->rx_cmp_cfa_code_errors_v2 & cpu_to_le32(RX_CMP_V)) ==\
> + !((raw_cons) & (bn)->cp_bit))
bn is not defined in macro
> +
> +#define RX_AGG_CMP_VALID(bn, agg, raw_cons) \
> + (!!((agg)->rx_agg_cmp_v & cpu_to_le32(RX_AGG_CMP_V)) == \
> + !((raw_cons) & (bn)->cp_bit))
> +
> +#define NQ_CMP_VALID(bn, nqcmp, raw_cons) \
> + (!!((nqcmp)->v & cpu_to_le32(NQ_CN_V)) == !((raw_cons) & (bn)->cp_bit))
> +
> +#define TX_CMP_TYPE(txcmp) \
> + (le32_to_cpu((txcmp)->tx_cmp_flags_type) & CMP_TYPE)
> +
Thanks,
Alok
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 2/7] bng_en: Add RX support
2026-01-16 17:06 ` ALOK TIWARI
@ 2026-01-16 18:28 ` Bhargava Chenna Marreddy
0 siblings, 0 replies; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-16 18:28 UTC (permalink / raw)
To: ALOK TIWARI
Cc: davem, edumazet, kuba, pabeni, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 7294 bytes --]
On Fri, Jan 16, 2026 at 10:36 PM ALOK TIWARI <alok.a.tiwari@oracle.com> wrote:
>
>
>
> On 1/5/2026 12:51 PM, Bhargava Marreddy wrote:
> > Add support to receive packet using NAPI, build and deliver the skb
> > to stack. With help of meta data available in completions, fill the
> > appropriate information in skb.
> >
> > Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
> > Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
> > Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
> > ---
> > drivers/net/ethernet/broadcom/bnge/Makefile | 3 +-
> > .../net/ethernet/broadcom/bnge/bnge_hw_def.h | 198 ++++++
> > .../net/ethernet/broadcom/bnge/bnge_netdev.c | 113 +++-
> > .../net/ethernet/broadcom/bnge/bnge_netdev.h | 60 +-
> > .../net/ethernet/broadcom/bnge/bnge_txrx.c | 573 ++++++++++++++++++
> > .../net/ethernet/broadcom/bnge/bnge_txrx.h | 90 +++
> > 6 files changed, 1016 insertions(+), 21 deletions(-)
> > create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
> > create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
> > create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
> >
> > +
> > +static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
> > + int budget)
> > +{
> > + struct bnge_napi *bnapi = cpr->bnapi;
> > + u32 raw_cons = cpr->cp_raw_cons;
> > + struct tx_cmp *txcmp;
> > + int rx_pkts = 0;
> > + u8 event = 0;
> > + u32 cons;
> > +
> > + cpr->has_more_work = 0;
> > + cpr->had_work_done = 1;
> > + while (1) {
> > + u8 cmp_type;
> > + int rc;
> > +
> > + cons = RING_CMP(bn, raw_cons);
> > + txcmp = &cpr->desc_ring[CP_RING(cons)][CP_IDX(cons)];
> > +
> > + if (!TX_CMP_VALID(bn, txcmp, raw_cons))
> > + break;
> > +
> > + /* The valid test of the entry must be done first before
> > + * reading any further.
> > + */
> > + dma_rmb();
> > + cmp_type = TX_CMP_TYPE(txcmp);
> > + if (cmp_type == CMP_TYPE_TX_L2_CMP ||
> > + cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
> > + /*
> > + * Tx Compl Processng
>
> typo -> Processng
Thanks, Alok. I will fix the typo in the next spin.
>
> > + */
> > + } else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
> > + cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
> > + if (likely(budget))
> > + rc = bnge_rx_pkt(bn, cpr, &raw_cons, &event);
> > + else
> > + rc = bnge_force_rx_discard(bn, cpr, &raw_cons,
> > + &event);
> > + if (likely(rc >= 0))
> > + rx_pkts += rc;
> > + /* Increment rx_pkts when rc is -ENOMEM to count towards
> > + * the NAPI budget. Otherwise, we may potentially loop
> > + * here forever if we consistently cannot allocate
> > + * buffers.
> > + */
> > + else if (rc == -ENOMEM && budget)
> > + rx_pkts++;
> > + else if (rc == -EBUSY) /* partial completion */
> > + break;
> > + }
> > +
> > + raw_cons = NEXT_RAW_CMP(raw_cons);
> > +
> > + if (rx_pkts && rx_pkts == budget) {
> > + cpr->has_more_work = 1;
> > + break;
> > + }
> > + }
> > +
> > + cpr->cp_raw_cons = raw_cons;
> > + bnapi->events |= event;
> > + return rx_pkts;
> > +}
> > diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
> > new file mode 100644
> > index 000000000000..b13081b0eb79
> > --- /dev/null
> > +++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
> > @@ -0,0 +1,90 @@
> > +/* SPDX-License-Identifier: GPL-2.0 */
> > +/* Copyright (c) 2025 Broadcom */
> > +
> > +#ifndef _BNGE_TXRX_H_
> > +#define _BNGE_TXRX_H_
> > +
> > +#include <linux/bnxt/hsi.h>
> > +#include "bnge_netdev.h"
> > +
> > +#define BNGE_MIN_PKT_SIZE 52
> > +
> > +#define TX_OPAQUE_IDX_MASK 0x0000ffff
> > +#define TX_OPAQUE_BDS_MASK 0x00ff0000
> > +#define TX_OPAQUE_BDS_SHIFT 16
> > +#define TX_OPAQUE_RING_MASK 0xff000000
> > +#define TX_OPAQUE_RING_SHIFT 24
> > +
> > +#define SET_TX_OPAQUE(bn, txr, idx, bds) \
> > + (((txr)->tx_napi_idx << TX_OPAQUE_RING_SHIFT) | \
> > + ((bds) << TX_OPAQUE_BDS_SHIFT) | ((idx) & (bn)->tx_ring_mask))
> > +
> > +#define TX_OPAQUE_IDX(opq) ((opq) & TX_OPAQUE_IDX_MASK)
> > +#define TX_OPAQUE_RING(opq) (((opq) & TX_OPAQUE_RING_MASK) >> \
> > + TX_OPAQUE_RING_SHIFT)
> > +#define TX_OPAQUE_BDS(opq) (((opq) & TX_OPAQUE_BDS_MASK) >> \
> > + TX_OPAQUE_BDS_SHIFT)
> > +#define TX_OPAQUE_PROD(bn, opq) ((TX_OPAQUE_IDX(opq) + TX_OPAQUE_BDS(opq)) &\
> > + (bn)->tx_ring_mask)
> > +
> > +/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1. We need one extra
> > + * BD because the first TX BD is always a long BD.
> > + */
> > +#define BNGE_MIN_TX_DESC_CNT (MAX_SKB_FRAGS + 2)
> > +
> > +#define RX_RING(bn, x) (((x) & (bn)->rx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
> > +#define RX_AGG_RING(bn, x) (((x) & (bn)->rx_agg_ring_mask) >> \
> > + (BNGE_PAGE_SHIFT - 4))
> > +#define RX_IDX(x) ((x) & (RX_DESC_CNT - 1))
> > +
> > +#define TX_RING(bn, x) (((x) & (bn)->tx_ring_mask) >> (BNGE_PAGE_SHIFT - 4))
> > +#define TX_IDX(x) ((x) & (TX_DESC_CNT - 1))
> > +
> > +#define CP_RING(x) (((x) & ~(CP_DESC_CNT - 1)) >> (BNGE_PAGE_SHIFT - 4))
> > +#define CP_IDX(x) ((x) & (CP_DESC_CNT - 1))
> > +
> > +#define TX_CMP_VALID(bn, txcmp, raw_cons) \
> > + (!!((txcmp)->tx_cmp_errors_v & cpu_to_le32(TX_CMP_V)) == \
> > + !((raw_cons) & (bn)->cp_bit))
> > +
> > +#define RX_CMP_VALID(rxcmp1, raw_cons) \
> > + (!!((rxcmp1)->rx_cmp_cfa_code_errors_v2 & cpu_to_le32(RX_CMP_V)) ==\
> > + !((raw_cons) & (bn)->cp_bit))
>
> bn is not defined in macro
Ack, I will fix it in the next spin.
Thanks,
Bhargava Marreddy
>
> > +
> > +#define RX_AGG_CMP_VALID(bn, agg, raw_cons) \
> > + (!!((agg)->rx_agg_cmp_v & cpu_to_le32(RX_AGG_CMP_V)) == \
> > + !((raw_cons) & (bn)->cp_bit))
> > +
> > +#define NQ_CMP_VALID(bn, nqcmp, raw_cons) \
> > + (!!((nqcmp)->v & cpu_to_le32(NQ_CN_V)) == !((raw_cons) & (bn)->cp_bit))
> > +
> > +#define TX_CMP_TYPE(txcmp) \
> > + (le32_to_cpu((txcmp)->tx_cmp_flags_type) & CMP_TYPE)
> > +
>
> Thanks,
> Alok
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread
* [v4, net-next 3/7] bng_en: Handle an HWRM completion request
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 1/7] bng_en: Extend bnge_set_ring_params() for rx-copybreak Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 2/7] bng_en: Add RX support Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 4/7] bng_en: Add TX support Bhargava Marreddy
` (3 subsequent siblings)
6 siblings, 0 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Since the HWRM completion for a sent request lands on the NQ,
add functions to handle the HWRM completion event.
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 3 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 1 +
.../net/ethernet/broadcom/bnge/bnge_txrx.c | 44 ++++++++++++++++++-
3 files changed, 45 insertions(+), 3 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 7533c382714e..ad29c489cc88 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -2299,8 +2299,7 @@ static int bnge_open(struct net_device *dev)
static int bnge_shutdown_nic(struct bnge_net *bn)
{
- /* TODO: close_path = 0 until we make NAPI functional */
- bnge_hwrm_resource_free(bn, 0);
+ bnge_hwrm_resource_free(bn, 1);
return 0;
}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 04989908b133..b5c3284ee0b6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -77,6 +77,7 @@ struct tx_cmp {
#define CMPL_BASE_TYPE_HWRM_FWD_REQ 0x22UL
#define CMPL_BASE_TYPE_HWRM_FWD_RESP 0x24UL
#define CMPL_BASE_TYPE_HWRM_ASYNC_EVENT 0x2eUL
+ #define CMPL_BA_TY_HWRM_ASY_EVT CMPL_BASE_TYPE_HWRM_ASYNC_EVENT
#define TX_CMP_FLAGS_ERROR (1 << 6)
#define TX_CMP_FLAGS_PUSH (1 << 7)
u32 tx_cmp_opaque;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
index db49a92542c0..fb29465f3c72 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
@@ -390,6 +390,43 @@ static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
}
}
+static void
+bnge_hwrm_update_token(struct bnge_dev *bd, u16 seq_id,
+ enum bnge_hwrm_wait_state state)
+{
+ struct bnge_hwrm_wait_token *token;
+
+ rcu_read_lock();
+ hlist_for_each_entry_rcu(token, &bd->hwrm_pending_list, node) {
+ if (token->seq_id == seq_id) {
+ WRITE_ONCE(token->state, state);
+ rcu_read_unlock();
+ return;
+ }
+ }
+ rcu_read_unlock();
+ dev_err(bd->dev, "Invalid hwrm seq id %d\n", seq_id);
+}
+
+static int bnge_hwrm_handler(struct bnge_dev *bd, struct tx_cmp *txcmp)
+{
+ struct hwrm_cmpl *h_cmpl = (struct hwrm_cmpl *)txcmp;
+ u16 cmpl_type = TX_CMP_TYPE(txcmp), seq_id;
+
+ switch (cmpl_type) {
+ case CMPL_BASE_TYPE_HWRM_DONE:
+ seq_id = le16_to_cpu(h_cmpl->sequence_id);
+ bnge_hwrm_update_token(bd, seq_id, BNGE_HWRM_COMPLETE);
+ break;
+
+ case CMPL_BASE_TYPE_HWRM_ASYNC_EVENT:
+ default:
+ break;
+ }
+
+ return 0;
+}
+
static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
int budget)
{
@@ -440,8 +477,11 @@ static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
rx_pkts++;
else if (rc == -EBUSY) /* partial completion */
break;
+ } else if (unlikely(cmp_type == CMPL_BASE_TYPE_HWRM_DONE ||
+ cmp_type == CMPL_BASE_TYPE_HWRM_FWD_REQ ||
+ cmp_type == CMPL_BA_TY_HWRM_ASY_EVT)) {
+ bnge_hwrm_handler(bn->bd, txcmp);
}
-
raw_cons = NEXT_RAW_CMP(raw_cons);
if (rx_pkts && rx_pkts == budget) {
@@ -559,6 +599,8 @@ int bnge_napi_poll(struct napi_struct *napi, int budget)
work_done += __bnge_poll_work(bn, cpr,
budget - work_done);
nqr->has_more_work |= cpr->has_more_work;
+ } else {
+ bnge_hwrm_handler(bn->bd, (struct tx_cmp *)nqcmp);
}
raw_cons = NEXT_RAW_CMP(raw_cons);
}
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* [v4, net-next 4/7] bng_en: Add TX support
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
` (2 preceding siblings ...)
2026-01-05 7:21 ` [v4, net-next 3/7] bng_en: Handle an HWRM completion request Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-08 10:09 ` Paolo Abeni
2026-01-05 7:21 ` [v4, net-next 5/7] bng_en: Add support to handle AGG events Bhargava Marreddy
` (2 subsequent siblings)
6 siblings, 1 reply; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Add functions to support xmit along with TSO/GSO.
Also, add functions to handle TX completion events in the NAPI context.
This commit introduces the fundamental transmit data path
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 100 ++++-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 3 +
.../net/ethernet/broadcom/bnge/bnge_txrx.c | 389 +++++++++++++++++-
.../net/ethernet/broadcom/bnge/bnge_txrx.h | 34 ++
4 files changed, 516 insertions(+), 10 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index ad29c489cc88..54b487204f17 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -393,9 +393,60 @@ static void bnge_free_rx_ring_pair_bufs(struct bnge_net *bn)
bnge_free_one_rx_ring_pair_bufs(bn, &bn->rx_ring[i]);
}
+static void bnge_free_tx_skbs(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ u16 max_idx;
+ int i;
+
+ max_idx = bn->tx_nr_pages * TX_DESC_CNT;
+ for (i = 0; i < bd->tx_nr_rings; i++) {
+ struct bnge_tx_ring_info *txr = &bn->tx_ring[i];
+ int j;
+
+ if (!txr->tx_buf_ring)
+ continue;
+
+ for (j = 0; j < max_idx;) {
+ struct bnge_sw_tx_bd *tx_buf = &txr->tx_buf_ring[j];
+ struct sk_buff *skb;
+ int k, last;
+
+ skb = tx_buf->skb;
+ if (!skb) {
+ j++;
+ continue;
+ }
+
+ tx_buf->skb = NULL;
+
+ dma_unmap_single(bd->dev,
+ dma_unmap_addr(tx_buf, mapping),
+ skb_headlen(skb),
+ DMA_TO_DEVICE);
+
+ last = tx_buf->nr_frags;
+ j += 2;
+ for (k = 0; k < last; k++, j++) {
+ int ring_idx = j & bn->tx_ring_mask;
+ skb_frag_t *frag = &skb_shinfo(skb)->frags[k];
+
+ tx_buf = &txr->tx_buf_ring[ring_idx];
+ dma_unmap_page(bd->dev,
+ dma_unmap_addr(tx_buf, mapping),
+ skb_frag_size(frag),
+ DMA_TO_DEVICE);
+ }
+ dev_kfree_skb(skb);
+ }
+ netdev_tx_reset_queue(netdev_get_tx_queue(bd->netdev, i));
+ }
+}
+
static void bnge_free_all_rings_bufs(struct bnge_net *bn)
{
bnge_free_rx_ring_pair_bufs(bn);
+ bnge_free_tx_skbs(bn);
}
static void bnge_free_rx_rings(struct bnge_net *bn)
@@ -1825,6 +1876,8 @@ static void bnge_enable_napi(struct bnge_net *bn)
for (i = 0; i < bd->nq_nr_rings; i++) {
struct bnge_napi *bnapi = bn->bnapi[i];
+ bnapi->tx_fault = 0;
+
napi_enable_locked(&bnapi->napi);
}
}
@@ -2231,6 +2284,42 @@ static int bnge_init_nic(struct bnge_net *bn)
return rc;
}
+static void bnge_tx_disable(struct bnge_net *bn)
+{
+ struct bnge_tx_ring_info *txr;
+ int i;
+
+ if (bn->tx_ring) {
+ for (i = 0; i < bn->bd->tx_nr_rings; i++) {
+ txr = &bn->tx_ring[i];
+ WRITE_ONCE(txr->dev_state, BNGE_DEV_STATE_CLOSING);
+ }
+ }
+ /* Make sure napi polls see @dev_state change */
+ synchronize_net();
+
+ if (!bn->netdev)
+ return;
+ /* Drop carrier first to prevent TX timeout */
+ netif_carrier_off(bn->netdev);
+ /* Stop all TX queues */
+ netif_tx_disable(bn->netdev);
+}
+
+static void bnge_tx_enable(struct bnge_net *bn)
+{
+ struct bnge_tx_ring_info *txr;
+ int i;
+
+ for (i = 0; i < bn->bd->tx_nr_rings; i++) {
+ txr = &bn->tx_ring[i];
+ WRITE_ONCE(txr->dev_state, 0);
+ }
+ /* Make sure napi polls see @dev_state change */
+ synchronize_net();
+ netif_tx_wake_all_queues(bn->netdev);
+}
+
static int bnge_open_core(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
@@ -2268,6 +2357,8 @@ static int bnge_open_core(struct bnge_net *bn)
set_bit(BNGE_STATE_OPEN, &bd->state);
bnge_enable_int(bn);
+
+ bnge_tx_enable(bn);
return 0;
err_free_irq:
@@ -2278,13 +2369,6 @@ static int bnge_open_core(struct bnge_net *bn)
return rc;
}
-static netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev)
-{
- dev_kfree_skb_any(skb);
-
- return NETDEV_TX_OK;
-}
-
static int bnge_open(struct net_device *dev)
{
struct bnge_net *bn = netdev_priv(dev);
@@ -2307,6 +2391,8 @@ static void bnge_close_core(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
+ bnge_tx_disable(bn);
+
clear_bit(BNGE_STATE_OPEN, &bd->state);
bnge_shutdown_nic(bn);
bnge_disable_napi(bn);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index b5c3284ee0b6..fba758cc8b04 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -243,6 +243,8 @@ struct bnge_net {
unsigned long state;
#define BNGE_STATE_NAPI_DISABLED 0
+
+ u32 msg_enable;
};
#define BNGE_DEFAULT_RX_RING_SIZE 511
@@ -431,6 +433,7 @@ struct bnge_napi {
#define BNGE_TX_EVENT 4
#define BNGE_REDIRECT_EVENT 8
#define BNGE_TX_CMP_EVENT 0x10
+ u8 tx_fault:1;
};
#define INVALID_STATS_CTX_ID -1
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
index fb29465f3c72..c7b89b1635a2 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
@@ -50,6 +50,23 @@ static void bnge_sched_reset_rxr(struct bnge_net *bn,
rxr->rx_next_cons = 0xffff;
}
+static void bnge_sched_reset_txr(struct bnge_net *bn,
+ struct bnge_tx_ring_info *txr,
+ u16 curr)
+{
+ struct bnge_napi *bnapi = txr->bnapi;
+
+ if (bnapi->tx_fault)
+ return;
+
+ netdev_err(bn->netdev, "Invalid Tx completion (ring:%d tx_hw_cons:%u cons:%u prod:%u curr:%u)",
+ txr->txq_index, txr->tx_hw_cons,
+ txr->tx_cons, txr->tx_prod, curr);
+ WARN_ON_ONCE(1);
+ bnapi->tx_fault = 1;
+ /* TODO: Initiate reset task */
+}
+
void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data)
{
struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
@@ -379,11 +396,86 @@ static int bnge_force_rx_discard(struct bnge_net *bn,
return rc;
}
+static void __bnge_tx_int(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
+ int budget)
+{
+ u16 hw_cons = txr->tx_hw_cons;
+ struct bnge_dev *bd = bn->bd;
+ unsigned int tx_bytes = 0;
+ unsigned int tx_pkts = 0;
+ struct netdev_queue *txq;
+ u16 cons = txr->tx_cons;
+ skb_frag_t *frag;
+
+ txq = netdev_get_tx_queue(bn->netdev, txr->txq_index);
+
+ while (RING_TX(bn, cons) != hw_cons) {
+ struct bnge_sw_tx_bd *tx_buf;
+ struct sk_buff *skb;
+ int j, last;
+
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
+ skb = tx_buf->skb;
+ if (unlikely(!skb)) {
+ bnge_sched_reset_txr(bn, txr, cons);
+ return;
+ }
+
+ cons = NEXT_TX(cons);
+ tx_pkts++;
+ tx_bytes += skb->len;
+ tx_buf->skb = NULL;
+
+ dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
+ skb_headlen(skb), DMA_TO_DEVICE);
+ last = tx_buf->nr_frags;
+
+ for (j = 0; j < last; j++) {
+ frag = &skb_shinfo(skb)->frags[j];
+ cons = NEXT_TX(cons);
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
+ netmem_dma_unmap_page_attrs(bd->dev,
+ dma_unmap_addr(tx_buf,
+ mapping),
+ skb_frag_size(frag),
+ DMA_TO_DEVICE, 0);
+ }
+
+ cons = NEXT_TX(cons);
+
+ napi_consume_skb(skb, budget);
+ }
+
+ WRITE_ONCE(txr->tx_cons, cons);
+
+ __netif_txq_completed_wake(txq, tx_pkts, tx_bytes,
+ bnge_tx_avail(bn, txr), bn->tx_wake_thresh,
+ (READ_ONCE(txr->dev_state) ==
+ BNGE_DEV_STATE_CLOSING));
+}
+
+static void bnge_tx_int(struct bnge_net *bn, struct bnge_napi *bnapi,
+ int budget)
+{
+ struct bnge_tx_ring_info *txr;
+ int i;
+
+ bnge_for_each_napi_tx(i, bnapi, txr) {
+ if (txr->tx_hw_cons != RING_TX(bn, txr->tx_cons))
+ __bnge_tx_int(bn, txr, budget);
+ }
+
+ bnapi->events &= ~BNGE_TX_CMP_EVENT;
+}
+
static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
int budget)
{
struct bnge_rx_ring_info *rxr = bnapi->rx_ring;
+ if ((bnapi->events & BNGE_TX_CMP_EVENT) && !bnapi->tx_fault)
+ bnge_tx_int(bn, bnapi, budget);
+
if ((bnapi->events & BNGE_RX_EVENT)) {
bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
bnapi->events &= ~BNGE_RX_EVENT;
@@ -456,9 +548,26 @@ static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
cmp_type = TX_CMP_TYPE(txcmp);
if (cmp_type == CMP_TYPE_TX_L2_CMP ||
cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
- /*
- * Tx Compl Processng
- */
+ u32 opaque = txcmp->tx_cmp_opaque;
+ struct bnge_tx_ring_info *txr;
+ u16 tx_freed;
+
+ txr = bnapi->tx_ring[TX_OPAQUE_RING(opaque)];
+ event |= BNGE_TX_CMP_EVENT;
+ if (cmp_type == CMP_TYPE_TX_L2_COAL_CMP)
+ txr->tx_hw_cons = TX_CMP_SQ_CONS_IDX(txcmp);
+ else
+ txr->tx_hw_cons = TX_OPAQUE_PROD(bn, opaque);
+ tx_freed = ((txr->tx_hw_cons - txr->tx_cons) &
+ bn->tx_ring_mask);
+ /* return full budget so NAPI will complete. */
+ if (unlikely(tx_freed >= bn->tx_wake_thresh)) {
+ rx_pkts = budget;
+ raw_cons = NEXT_RAW_CMP(raw_cons);
+ if (budget)
+ cpr->has_more_work = 1;
+ break;
+ }
} else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
if (likely(budget))
@@ -613,3 +722,277 @@ int bnge_napi_poll(struct napi_struct *napi, int budget)
poll_done:
return work_done;
}
+
+static u16 bnge_xmit_get_cfa_action(struct sk_buff *skb)
+{
+ struct metadata_dst *md_dst = skb_metadata_dst(skb);
+
+ if (!md_dst || md_dst->type != METADATA_HW_PORT_MUX)
+ return 0;
+
+ return md_dst->u.port_info.port_id;
+}
+
+static const u16 bnge_lhint_arr[] = {
+ TX_BD_FLAGS_LHINT_512_AND_SMALLER,
+ TX_BD_FLAGS_LHINT_512_TO_1023,
+ TX_BD_FLAGS_LHINT_1024_TO_2047,
+ TX_BD_FLAGS_LHINT_1024_TO_2047,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+ TX_BD_FLAGS_LHINT_2048_AND_LARGER,
+};
+
+static void bnge_txr_db_kick(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
+ u16 prod)
+{
+ /* Sync BD data before updating doorbell */
+ wmb();
+ bnge_db_write(bn->bd, &txr->tx_db, prod);
+ txr->kick_pending = 0;
+}
+
+netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+ u32 len, free_size, vlan_tag_flags, cfa_action, flags;
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_tx_ring_info *txr;
+ struct bnge_dev *bd = bn->bd;
+ unsigned int length, pad = 0;
+ struct bnge_sw_tx_bd *tx_buf;
+ struct tx_bd *txbd, *txbd0;
+ struct netdev_queue *txq;
+ struct tx_bd_ext *txbd1;
+ u16 prod, last_frag;
+ dma_addr_t mapping;
+ __le32 lflags = 0;
+ skb_frag_t *frag;
+ int i;
+
+ i = skb_get_queue_mapping(skb);
+ if (unlikely(i >= bd->tx_nr_rings)) {
+ dev_kfree_skb_any(skb);
+ dev_core_stats_tx_dropped_inc(dev);
+ return NETDEV_TX_OK;
+ }
+
+ txq = netdev_get_tx_queue(dev, i);
+ txr = &bn->tx_ring[bn->tx_ring_map[i]];
+ prod = txr->tx_prod;
+
+#if (MAX_SKB_FRAGS > TX_MAX_FRAGS)
+ if (skb_shinfo(skb)->nr_frags > TX_MAX_FRAGS) {
+ netdev_warn_once(dev, "SKB has too many (%d) fragments, max supported is %d. SKB will be linearized.\n",
+ skb_shinfo(skb)->nr_frags, TX_MAX_FRAGS);
+ if (skb_linearize(skb)) {
+ dev_kfree_skb_any(skb);
+ dev_core_stats_tx_dropped_inc(dev);
+ return NETDEV_TX_OK;
+ }
+ }
+#endif
+ free_size = bnge_tx_avail(bn, txr);
+ if (unlikely(free_size < skb_shinfo(skb)->nr_frags + 2)) {
+ /* We must have raced with NAPI cleanup */
+ if (net_ratelimit() && txr->kick_pending)
+ netif_warn(bn, tx_err, dev,
+ "bnge: ring busy w/ flush pending!\n");
+ if (!netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
+ bn->tx_wake_thresh))
+ return NETDEV_TX_BUSY;
+ }
+
+ if (unlikely(ipv6_hopopt_jumbo_remove(skb)))
+ goto tx_free;
+
+ length = skb->len;
+ len = skb_headlen(skb);
+ last_frag = skb_shinfo(skb)->nr_frags;
+
+ txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
+
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
+ tx_buf->skb = skb;
+ tx_buf->nr_frags = last_frag;
+
+ vlan_tag_flags = 0;
+ cfa_action = bnge_xmit_get_cfa_action(skb);
+ if (skb_vlan_tag_present(skb)) {
+ vlan_tag_flags = TX_BD_CFA_META_KEY_VLAN |
+ skb_vlan_tag_get(skb);
+ /* Currently supports 8021Q, 8021AD vlan offloads
+ * QINQ1, QINQ2, QINQ3 vlan headers are deprecated
+ */
+ if (skb->vlan_proto == htons(ETH_P_8021Q))
+ vlan_tag_flags |= 1 << TX_BD_CFA_META_TPID_SHIFT;
+ }
+
+ if (unlikely(skb->no_fcs))
+ lflags |= cpu_to_le32(TX_BD_FLAGS_NO_CRC);
+
+ if (length < BNGE_MIN_PKT_SIZE) {
+ pad = BNGE_MIN_PKT_SIZE - length;
+ if (skb_pad(skb, pad))
+ /* SKB already freed. */
+ goto tx_kick_pending;
+ length = BNGE_MIN_PKT_SIZE;
+ }
+
+ mapping = dma_map_single(bd->dev, skb->data, len, DMA_TO_DEVICE);
+
+ if (unlikely(dma_mapping_error(bd->dev, mapping)))
+ goto tx_free;
+
+ dma_unmap_addr_set(tx_buf, mapping, mapping);
+ flags = (len << TX_BD_LEN_SHIFT) | TX_BD_TYPE_LONG_TX_BD |
+ TX_BD_CNT(last_frag + 2);
+
+ txbd->tx_bd_haddr = cpu_to_le64(mapping);
+ txbd->tx_bd_opaque = SET_TX_OPAQUE(bn, txr, prod, 2 + last_frag);
+
+ prod = NEXT_TX(prod);
+ txbd1 = (struct tx_bd_ext *)
+ &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
+
+ txbd1->tx_bd_hsize_lflags = lflags;
+ if (skb_is_gso(skb)) {
+ bool udp_gso = !!(skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4);
+ u32 hdr_len;
+
+ if (skb->encapsulation) {
+ if (udp_gso)
+ hdr_len = skb_inner_transport_offset(skb) +
+ sizeof(struct udphdr);
+ else
+ hdr_len = skb_inner_tcp_all_headers(skb);
+ } else if (udp_gso) {
+ hdr_len = skb_transport_offset(skb) +
+ sizeof(struct udphdr);
+ } else {
+ hdr_len = skb_tcp_all_headers(skb);
+ }
+
+ txbd1->tx_bd_hsize_lflags |= cpu_to_le32(TX_BD_FLAGS_LSO |
+ TX_BD_FLAGS_T_IPID |
+ (hdr_len << (TX_BD_HSIZE_SHIFT - 1)));
+ length = skb_shinfo(skb)->gso_size;
+ txbd1->tx_bd_mss = cpu_to_le32(length);
+ length += hdr_len;
+ } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
+ txbd1->tx_bd_hsize_lflags |=
+ cpu_to_le32(TX_BD_FLAGS_TCP_UDP_CHKSUM);
+ txbd1->tx_bd_mss = 0;
+ }
+
+ length >>= 9;
+ if (unlikely(length >= ARRAY_SIZE(bnge_lhint_arr))) {
+ dev_warn_ratelimited(bd->dev, "Dropped oversize %d bytes TX packet.\n",
+ skb->len);
+ i = 0;
+ goto tx_dma_error;
+ }
+ flags |= bnge_lhint_arr[length];
+ txbd->tx_bd_len_flags_type = cpu_to_le32(flags);
+
+ txbd1->tx_bd_cfa_meta = cpu_to_le32(vlan_tag_flags);
+ txbd1->tx_bd_cfa_action =
+ cpu_to_le32(cfa_action << TX_BD_CFA_ACTION_SHIFT);
+ txbd0 = txbd;
+ for (i = 0; i < last_frag; i++) {
+ frag = &skb_shinfo(skb)->frags[i];
+
+ prod = NEXT_TX(prod);
+ txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
+
+ len = skb_frag_size(frag);
+ mapping = skb_frag_dma_map(bd->dev, frag, 0, len,
+ DMA_TO_DEVICE);
+
+ if (unlikely(dma_mapping_error(bd->dev, mapping)))
+ goto tx_dma_error;
+
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
+ netmem_dma_unmap_addr_set(skb_frag_netmem(frag), tx_buf,
+ mapping, mapping);
+
+ txbd->tx_bd_haddr = cpu_to_le64(mapping);
+
+ flags = len << TX_BD_LEN_SHIFT;
+ txbd->tx_bd_len_flags_type = cpu_to_le32(flags);
+ }
+
+ flags &= ~TX_BD_LEN;
+ txbd->tx_bd_len_flags_type =
+ cpu_to_le32(((len + pad) << TX_BD_LEN_SHIFT) | flags |
+ TX_BD_FLAGS_PACKET_END);
+
+ netdev_tx_sent_queue(txq, skb->len);
+
+ prod = NEXT_TX(prod);
+ WRITE_ONCE(txr->tx_prod, prod);
+
+ if (!netdev_xmit_more() || netif_xmit_stopped(txq)) {
+ bnge_txr_db_kick(bn, txr, prod);
+ } else {
+ if (free_size >= bn->tx_wake_thresh)
+ txbd0->tx_bd_len_flags_type |=
+ cpu_to_le32(TX_BD_FLAGS_NO_CMPL);
+ txr->kick_pending = 1;
+ }
+
+ if (unlikely(bnge_tx_avail(bn, txr) <= MAX_SKB_FRAGS + 1)) {
+ if (netdev_xmit_more()) {
+ txbd0->tx_bd_len_flags_type &=
+ cpu_to_le32(~TX_BD_FLAGS_NO_CMPL);
+ bnge_txr_db_kick(bn, txr, prod);
+ }
+
+ netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
+ bn->tx_wake_thresh);
+ }
+ return NETDEV_TX_OK;
+
+tx_dma_error:
+ last_frag = i;
+
+ /* start back at beginning and unmap skb */
+ prod = txr->tx_prod;
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
+ dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
+ skb_headlen(skb), DMA_TO_DEVICE);
+ prod = NEXT_TX(prod);
+
+ /* unmap remaining mapped pages */
+ for (i = 0; i < last_frag; i++) {
+ prod = NEXT_TX(prod);
+ tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
+ frag = &skb_shinfo(skb)->frags[i];
+ netmem_dma_unmap_page_attrs(bd->dev,
+ dma_unmap_addr(tx_buf, mapping),
+ skb_frag_size(frag),
+ DMA_TO_DEVICE, 0);
+ }
+
+tx_free:
+ dev_kfree_skb_any(skb);
+
+tx_kick_pending:
+ if (txr->kick_pending)
+ bnge_txr_db_kick(bn, txr, txr->tx_prod);
+ txr->tx_buf_ring[RING_TX(bn, txr->tx_prod)].skb = NULL;
+ dev_core_stats_tx_dropped_inc(dev);
+ return NETDEV_TX_OK;
+}
+
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
index b13081b0eb79..8cd980875a3b 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
@@ -7,6 +7,34 @@
#include <linux/bnxt/hsi.h>
#include "bnge_netdev.h"
+static inline u32 bnge_tx_avail(struct bnge_net *bn,
+ const struct bnge_tx_ring_info *txr)
+{
+ u32 used = READ_ONCE(txr->tx_prod) - READ_ONCE(txr->tx_cons);
+
+ return bn->tx_ring_size - (used & bn->tx_ring_mask);
+}
+
+static inline void bnge_writeq_relaxed(struct bnge_dev *bd, u64 val,
+ void __iomem *addr)
+{
+#if BITS_PER_LONG == 32
+ spin_lock(&bd->db_lock);
+ lo_hi_writeq_relaxed(val, addr);
+ spin_unlock(&bd->db_lock);
+#else
+ writeq_relaxed(val, addr);
+#endif
+}
+
+/* For TX and RX ring doorbells with no ordering guarantee*/
+static inline void bnge_db_write_relaxed(struct bnge_net *bn,
+ struct bnge_db_info *db, u32 idx)
+{
+ bnge_writeq_relaxed(bn->bd, db->db_key64 | DB_RING_IDX(db, idx),
+ db->doorbell);
+}
+
#define BNGE_MIN_PKT_SIZE 52
#define TX_OPAQUE_IDX_MASK 0x0000ffff
@@ -26,6 +54,11 @@
TX_OPAQUE_BDS_SHIFT)
#define TX_OPAQUE_PROD(bn, opq) ((TX_OPAQUE_IDX(opq) + TX_OPAQUE_BDS(opq)) &\
(bn)->tx_ring_mask)
+#define TX_BD_CNT(n) (((n) << TX_BD_FLAGS_BD_CNT_SHIFT) & TX_BD_FLAGS_BD_CNT)
+
+#define TX_MAX_BD_CNT 32
+
+#define TX_MAX_FRAGS (TX_MAX_BD_CNT - 2)
/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1. We need one extra
* BD because the first TX BD is always a long BD.
@@ -85,6 +118,7 @@
RX_CMPL_CFA_CODE_MASK) >> RX_CMPL_CFA_CODE_SFT)
irqreturn_t bnge_msix(int irq, void *dev_instance);
+netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev);
void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data);
int bnge_napi_poll(struct napi_struct *napi, int budget);
#endif /* _BNGE_TXRX_H_ */
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 4/7] bng_en: Add TX support
2026-01-05 7:21 ` [v4, net-next 4/7] bng_en: Add TX support Bhargava Marreddy
@ 2026-01-08 10:09 ` Paolo Abeni
2026-01-12 21:16 ` Bhargava Chenna Marreddy
0 siblings, 1 reply; 18+ messages in thread
From: Paolo Abeni @ 2026-01-08 10:09 UTC (permalink / raw)
To: Bhargava Marreddy, davem, edumazet, kuba, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Rajashekar Hudumula
On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> +static void __bnge_tx_int(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
> + int budget)
> +{
> + u16 hw_cons = txr->tx_hw_cons;
> + struct bnge_dev *bd = bn->bd;
> + unsigned int tx_bytes = 0;
> + unsigned int tx_pkts = 0;
> + struct netdev_queue *txq;
> + u16 cons = txr->tx_cons;
> + skb_frag_t *frag;
> +
> + txq = netdev_get_tx_queue(bn->netdev, txr->txq_index);
> +
> + while (RING_TX(bn, cons) != hw_cons) {
> + struct bnge_sw_tx_bd *tx_buf;
> + struct sk_buff *skb;
> + int j, last;
> +
> + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> + skb = tx_buf->skb;
> + if (unlikely(!skb)) {
> + bnge_sched_reset_txr(bn, txr, cons);
> + return;
> + }
> +
> + cons = NEXT_TX(cons);
> + tx_pkts++;
> + tx_bytes += skb->len;
> + tx_buf->skb = NULL;
> +
> + dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
> + skb_headlen(skb), DMA_TO_DEVICE);
> + last = tx_buf->nr_frags;
> +
> + for (j = 0; j < last; j++) {
> + frag = &skb_shinfo(skb)->frags[j];
> + cons = NEXT_TX(cons);
> + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> + netmem_dma_unmap_page_attrs(bd->dev,
> + dma_unmap_addr(tx_buf,
> + mapping),
> + skb_frag_size(frag),
> + DMA_TO_DEVICE, 0);
> + }
There is a similar chunk in bnge_free_tx_skbs(), you could avoid
douplication factoring that out in common helper.
> +
> + cons = NEXT_TX(cons);
> +
> + napi_consume_skb(skb, budget);
> + }
> +
> + WRITE_ONCE(txr->tx_cons, cons);
> +
> + __netif_txq_completed_wake(txq, tx_pkts, tx_bytes,
> + bnge_tx_avail(bn, txr), bn->tx_wake_thresh,
> + (READ_ONCE(txr->dev_state) ==
> + BNGE_DEV_STATE_CLOSING));
> +}
> +
> +static void bnge_tx_int(struct bnge_net *bn, struct bnge_napi *bnapi,
> + int budget)
> +{
> + struct bnge_tx_ring_info *txr;
> + int i;
> +
> + bnge_for_each_napi_tx(i, bnapi, txr) {
> + if (txr->tx_hw_cons != RING_TX(bn, txr->tx_cons))
> + __bnge_tx_int(bn, txr, budget);
The above looks strange to me: there are multiple tx ring, but they are
all served by the same irq?!?
> + }
> +
> + bnapi->events &= ~BNGE_TX_CMP_EVENT;
> +}
> +
> static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
> int budget)
> {
> struct bnge_rx_ring_info *rxr = bnapi->rx_ring;
>
> + if ((bnapi->events & BNGE_TX_CMP_EVENT) && !bnapi->tx_fault)
> + bnge_tx_int(bn, bnapi, budget);
> +
> if ((bnapi->events & BNGE_RX_EVENT)) {
> bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
> bnapi->events &= ~BNGE_RX_EVENT;
> @@ -456,9 +548,26 @@ static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
> cmp_type = TX_CMP_TYPE(txcmp);
> if (cmp_type == CMP_TYPE_TX_L2_CMP ||
> cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
> - /*
> - * Tx Compl Processng
> - */
> + u32 opaque = txcmp->tx_cmp_opaque;
> + struct bnge_tx_ring_info *txr;
> + u16 tx_freed;
> +
> + txr = bnapi->tx_ring[TX_OPAQUE_RING(opaque)];
> + event |= BNGE_TX_CMP_EVENT;
> + if (cmp_type == CMP_TYPE_TX_L2_COAL_CMP)
> + txr->tx_hw_cons = TX_CMP_SQ_CONS_IDX(txcmp);
> + else
> + txr->tx_hw_cons = TX_OPAQUE_PROD(bn, opaque);
> + tx_freed = ((txr->tx_hw_cons - txr->tx_cons) &
> + bn->tx_ring_mask);
> + /* return full budget so NAPI will complete. */
> + if (unlikely(tx_freed >= bn->tx_wake_thresh)) {
> + rx_pkts = budget;
> + raw_cons = NEXT_RAW_CMP(raw_cons);
> + if (budget)
> + cpr->has_more_work = 1;
> + break;
> + }
> } else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
> cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
> if (likely(budget))
> @@ -613,3 +722,277 @@ int bnge_napi_poll(struct napi_struct *napi, int budget)
> poll_done:
> return work_done;
> }
> +
> +static u16 bnge_xmit_get_cfa_action(struct sk_buff *skb)
> +{
> + struct metadata_dst *md_dst = skb_metadata_dst(skb);
> +
> + if (!md_dst || md_dst->type != METADATA_HW_PORT_MUX)
> + return 0;
> +
> + return md_dst->u.port_info.port_id;
> +}
> +
> +static const u16 bnge_lhint_arr[] = {
> + TX_BD_FLAGS_LHINT_512_AND_SMALLER,
> + TX_BD_FLAGS_LHINT_512_TO_1023,
> + TX_BD_FLAGS_LHINT_1024_TO_2047,
> + TX_BD_FLAGS_LHINT_1024_TO_2047,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> +};
> +
> +static void bnge_txr_db_kick(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
> + u16 prod)
> +{
> + /* Sync BD data before updating doorbell */
> + wmb();
> + bnge_db_write(bn->bd, &txr->tx_db, prod);
> + txr->kick_pending = 0;
> +}
> +
> +netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev)
> +{
> + u32 len, free_size, vlan_tag_flags, cfa_action, flags;
> + struct bnge_net *bn = netdev_priv(dev);
> + struct bnge_tx_ring_info *txr;
> + struct bnge_dev *bd = bn->bd;
> + unsigned int length, pad = 0;
> + struct bnge_sw_tx_bd *tx_buf;
> + struct tx_bd *txbd, *txbd0;
> + struct netdev_queue *txq;
> + struct tx_bd_ext *txbd1;
> + u16 prod, last_frag;
> + dma_addr_t mapping;
> + __le32 lflags = 0;
> + skb_frag_t *frag;
> + int i;
> +
> + i = skb_get_queue_mapping(skb);
> + if (unlikely(i >= bd->tx_nr_rings)) {
Under which conditions the above statement can be true?
> + dev_kfree_skb_any(skb);
> + dev_core_stats_tx_dropped_inc(dev);
> + return NETDEV_TX_OK;
> + }
> +
> + txq = netdev_get_tx_queue(dev, i);
> + txr = &bn->tx_ring[bn->tx_ring_map[i]];
> + prod = txr->tx_prod;
> +
> +#if (MAX_SKB_FRAGS > TX_MAX_FRAGS)
> + if (skb_shinfo(skb)->nr_frags > TX_MAX_FRAGS) {
You should probably implement ndo_features_check() and ensure the above
condition will never happen.
> + netdev_warn_once(dev, "SKB has too many (%d) fragments, max supported is %d. SKB will be linearized.\n",
> + skb_shinfo(skb)->nr_frags, TX_MAX_FRAGS);
> + if (skb_linearize(skb)) {
> + dev_kfree_skb_any(skb);
> + dev_core_stats_tx_dropped_inc(dev);
> + return NETDEV_TX_OK;
> + }
> + }
> +#endif
> + free_size = bnge_tx_avail(bn, txr);
> + if (unlikely(free_size < skb_shinfo(skb)->nr_frags + 2)) {
> + /* We must have raced with NAPI cleanup */
> + if (net_ratelimit() && txr->kick_pending)
> + netif_warn(bn, tx_err, dev,
> + "bnge: ring busy w/ flush pending!\n");
> + if (!netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
> + bn->tx_wake_thresh))
> + return NETDEV_TX_BUSY;
> + }
> +
> + if (unlikely(ipv6_hopopt_jumbo_remove(skb)))
> + goto tx_free;
> +
> + length = skb->len;
> + len = skb_headlen(skb);
> + last_frag = skb_shinfo(skb)->nr_frags;
> +
> + txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
> +
> + tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
The naming (TX_RING() vs RING_TX() with quite different meaning) is IMHO
prone to errors.
> + tx_buf->skb = skb;
> + tx_buf->nr_frags = last_frag;
> +
> + vlan_tag_flags = 0;
> + cfa_action = bnge_xmit_get_cfa_action(skb);
> + if (skb_vlan_tag_present(skb)) {
> + vlan_tag_flags = TX_BD_CFA_META_KEY_VLAN |
> + skb_vlan_tag_get(skb);
> + /* Currently supports 8021Q, 8021AD vlan offloads
> + * QINQ1, QINQ2, QINQ3 vlan headers are deprecated
> + */
> + if (skb->vlan_proto == htons(ETH_P_8021Q))
> + vlan_tag_flags |= 1 << TX_BD_CFA_META_TPID_SHIFT;
> + }
> +
> + if (unlikely(skb->no_fcs))
> + lflags |= cpu_to_le32(TX_BD_FLAGS_NO_CRC);
> +
> + if (length < BNGE_MIN_PKT_SIZE) {
> + pad = BNGE_MIN_PKT_SIZE - length;
> + if (skb_pad(skb, pad))
> + /* SKB already freed. */
> + goto tx_kick_pending;
> + length = BNGE_MIN_PKT_SIZE;
> + }
> +
> + mapping = dma_map_single(bd->dev, skb->data, len, DMA_TO_DEVICE);
> +
> + if (unlikely(dma_mapping_error(bd->dev, mapping)))
> + goto tx_free;
> +
> + dma_unmap_addr_set(tx_buf, mapping, mapping);
> + flags = (len << TX_BD_LEN_SHIFT) | TX_BD_TYPE_LONG_TX_BD |
> + TX_BD_CNT(last_frag + 2);
> +
> + txbd->tx_bd_haddr = cpu_to_le64(mapping);
> + txbd->tx_bd_opaque = SET_TX_OPAQUE(bn, txr, prod, 2 + last_frag);
> +
> + prod = NEXT_TX(prod);
> + txbd1 = (struct tx_bd_ext *)
> + &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
> +
> + txbd1->tx_bd_hsize_lflags = lflags;
> + if (skb_is_gso(skb)) {
> + bool udp_gso = !!(skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4);
> + u32 hdr_len;
> +
> + if (skb->encapsulation) {
> + if (udp_gso)
> + hdr_len = skb_inner_transport_offset(skb) +
> + sizeof(struct udphdr);
> + else
> + hdr_len = skb_inner_tcp_all_headers(skb);
> + } else if (udp_gso) {
> + hdr_len = skb_transport_offset(skb) +
> + sizeof(struct udphdr);
> + } else {
> + hdr_len = skb_tcp_all_headers(skb);
> + }
> +
> + txbd1->tx_bd_hsize_lflags |= cpu_to_le32(TX_BD_FLAGS_LSO |
> + TX_BD_FLAGS_T_IPID |
> + (hdr_len << (TX_BD_HSIZE_SHIFT - 1)));
> + length = skb_shinfo(skb)->gso_size;
> + txbd1->tx_bd_mss = cpu_to_le32(length);
> + length += hdr_len;
> + } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
> + txbd1->tx_bd_hsize_lflags |=
> + cpu_to_le32(TX_BD_FLAGS_TCP_UDP_CHKSUM);
> + txbd1->tx_bd_mss = 0;
> + }
> +
> + length >>= 9;
> + if (unlikely(length >= ARRAY_SIZE(bnge_lhint_arr))) {
a proper ndo_features_check() should avoid the above check.
/P
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 4/7] bng_en: Add TX support
2026-01-08 10:09 ` Paolo Abeni
@ 2026-01-12 21:16 ` Bhargava Chenna Marreddy
2026-01-16 18:43 ` Bhargava Chenna Marreddy
0 siblings, 1 reply; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-12 21:16 UTC (permalink / raw)
To: Paolo Abeni
Cc: davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 13904 bytes --]
On Thu, Jan 8, 2026 at 3:39 PM Paolo Abeni <pabeni@redhat.com> wrote:
>
> On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > +static void __bnge_tx_int(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
> > + int budget)
> > +{
> > + u16 hw_cons = txr->tx_hw_cons;
> > + struct bnge_dev *bd = bn->bd;
> > + unsigned int tx_bytes = 0;
> > + unsigned int tx_pkts = 0;
> > + struct netdev_queue *txq;
> > + u16 cons = txr->tx_cons;
> > + skb_frag_t *frag;
> > +
> > + txq = netdev_get_tx_queue(bn->netdev, txr->txq_index);
> > +
> > + while (RING_TX(bn, cons) != hw_cons) {
> > + struct bnge_sw_tx_bd *tx_buf;
> > + struct sk_buff *skb;
> > + int j, last;
> > +
> > + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> > + skb = tx_buf->skb;
> > + if (unlikely(!skb)) {
> > + bnge_sched_reset_txr(bn, txr, cons);
> > + return;
> > + }
> > +
> > + cons = NEXT_TX(cons);
> > + tx_pkts++;
> > + tx_bytes += skb->len;
> > + tx_buf->skb = NULL;
> > +
> > + dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
> > + skb_headlen(skb), DMA_TO_DEVICE);
> > + last = tx_buf->nr_frags;
> > +
> > + for (j = 0; j < last; j++) {
> > + frag = &skb_shinfo(skb)->frags[j];
> > + cons = NEXT_TX(cons);
> > + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> > + netmem_dma_unmap_page_attrs(bd->dev,
> > + dma_unmap_addr(tx_buf,
> > + mapping),
> > + skb_frag_size(frag),
> > + DMA_TO_DEVICE, 0);
> > + }
>
> There is a similar chunk in bnge_free_tx_skbs(), you could avoid
> douplication factoring that out in common helper.
Agreed. I'll address this in the next revision.
>
> > +
> > + cons = NEXT_TX(cons);
> > +
> > + napi_consume_skb(skb, budget);
> > + }
> > +
> > + WRITE_ONCE(txr->tx_cons, cons);
> > +
> > + __netif_txq_completed_wake(txq, tx_pkts, tx_bytes,
> > + bnge_tx_avail(bn, txr), bn->tx_wake_thresh,
> > + (READ_ONCE(txr->dev_state) ==
> > + BNGE_DEV_STATE_CLOSING));
> > +}
> > +
> > +static void bnge_tx_int(struct bnge_net *bn, struct bnge_napi *bnapi,
> > + int budget)
> > +{
> > + struct bnge_tx_ring_info *txr;
> > + int i;
> > +
> > + bnge_for_each_napi_tx(i, bnapi, txr) {
> > + if (txr->tx_hw_cons != RING_TX(bn, txr->tx_cons))
> > + __bnge_tx_int(bn, txr, budget);
>
> The above looks strange to me: there are multiple tx ring, but they are
> all served by the same irq?!?
The design allows multiple TX rings per NAPI instance, so the loop is
required to service all rings associated with that IRQ vector.
>
> > + }
> > +
> > + bnapi->events &= ~BNGE_TX_CMP_EVENT;
> > +}
> > +
> > static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
> > int budget)
> > {
> > struct bnge_rx_ring_info *rxr = bnapi->rx_ring;
> >
> > + if ((bnapi->events & BNGE_TX_CMP_EVENT) && !bnapi->tx_fault)
> > + bnge_tx_int(bn, bnapi, budget);
> > +
> > if ((bnapi->events & BNGE_RX_EVENT)) {
> > bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
> > bnapi->events &= ~BNGE_RX_EVENT;
> > @@ -456,9 +548,26 @@ static int __bnge_poll_work(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
> > cmp_type = TX_CMP_TYPE(txcmp);
> > if (cmp_type == CMP_TYPE_TX_L2_CMP ||
> > cmp_type == CMP_TYPE_TX_L2_COAL_CMP) {
> > - /*
> > - * Tx Compl Processng
> > - */
> > + u32 opaque = txcmp->tx_cmp_opaque;
> > + struct bnge_tx_ring_info *txr;
> > + u16 tx_freed;
> > +
> > + txr = bnapi->tx_ring[TX_OPAQUE_RING(opaque)];
> > + event |= BNGE_TX_CMP_EVENT;
> > + if (cmp_type == CMP_TYPE_TX_L2_COAL_CMP)
> > + txr->tx_hw_cons = TX_CMP_SQ_CONS_IDX(txcmp);
> > + else
> > + txr->tx_hw_cons = TX_OPAQUE_PROD(bn, opaque);
> > + tx_freed = ((txr->tx_hw_cons - txr->tx_cons) &
> > + bn->tx_ring_mask);
> > + /* return full budget so NAPI will complete. */
> > + if (unlikely(tx_freed >= bn->tx_wake_thresh)) {
> > + rx_pkts = budget;
> > + raw_cons = NEXT_RAW_CMP(raw_cons);
> > + if (budget)
> > + cpr->has_more_work = 1;
> > + break;
> > + }
> > } else if (cmp_type >= CMP_TYPE_RX_L2_CMP &&
> > cmp_type <= CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
> > if (likely(budget))
> > @@ -613,3 +722,277 @@ int bnge_napi_poll(struct napi_struct *napi, int budget)
> > poll_done:
> > return work_done;
> > }
> > +
> > +static u16 bnge_xmit_get_cfa_action(struct sk_buff *skb)
> > +{
> > + struct metadata_dst *md_dst = skb_metadata_dst(skb);
> > +
> > + if (!md_dst || md_dst->type != METADATA_HW_PORT_MUX)
> > + return 0;
> > +
> > + return md_dst->u.port_info.port_id;
> > +}
> > +
> > +static const u16 bnge_lhint_arr[] = {
> > + TX_BD_FLAGS_LHINT_512_AND_SMALLER,
> > + TX_BD_FLAGS_LHINT_512_TO_1023,
> > + TX_BD_FLAGS_LHINT_1024_TO_2047,
> > + TX_BD_FLAGS_LHINT_1024_TO_2047,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > + TX_BD_FLAGS_LHINT_2048_AND_LARGER,
> > +};
> > +
> > +static void bnge_txr_db_kick(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
> > + u16 prod)
> > +{
> > + /* Sync BD data before updating doorbell */
> > + wmb();
> > + bnge_db_write(bn->bd, &txr->tx_db, prod);
> > + txr->kick_pending = 0;
> > +}
> > +
> > +netdev_tx_t bnge_start_xmit(struct sk_buff *skb, struct net_device *dev)
> > +{
> > + u32 len, free_size, vlan_tag_flags, cfa_action, flags;
> > + struct bnge_net *bn = netdev_priv(dev);
> > + struct bnge_tx_ring_info *txr;
> > + struct bnge_dev *bd = bn->bd;
> > + unsigned int length, pad = 0;
> > + struct bnge_sw_tx_bd *tx_buf;
> > + struct tx_bd *txbd, *txbd0;
> > + struct netdev_queue *txq;
> > + struct tx_bd_ext *txbd1;
> > + u16 prod, last_frag;
> > + dma_addr_t mapping;
> > + __le32 lflags = 0;
> > + skb_frag_t *frag;
> > + int i;
> > +
> > + i = skb_get_queue_mapping(skb);
> > + if (unlikely(i >= bd->tx_nr_rings)) {
>
> Under which conditions the above statement can be true?
This is a defensive check to prevent out-of-bounds access during rare
races, such as an
ethtool -L reconfiguration where an in-flight skb might carry a stale
queue mapping.
Does this approach seem reasonable, or should I remove the check and
rely on the
stack's quiescence during reconfiguration?
>
> > + dev_kfree_skb_any(skb);
> > + dev_core_stats_tx_dropped_inc(dev);
> > + return NETDEV_TX_OK;
> > + }
> > +
> > + txq = netdev_get_tx_queue(dev, i);
> > + txr = &bn->tx_ring[bn->tx_ring_map[i]];
> > + prod = txr->tx_prod;
> > +
> > +#if (MAX_SKB_FRAGS > TX_MAX_FRAGS)
> > + if (skb_shinfo(skb)->nr_frags > TX_MAX_FRAGS) {
>
> You should probably implement ndo_features_check() and ensure the above
> condition will never happen.
Thanks, I'll address this in the next revision.
>
> > + netdev_warn_once(dev, "SKB has too many (%d) fragments, max supported is %d. SKB will be linearized.\n",
> > + skb_shinfo(skb)->nr_frags, TX_MAX_FRAGS);
> > + if (skb_linearize(skb)) {
> > + dev_kfree_skb_any(skb);
> > + dev_core_stats_tx_dropped_inc(dev);
> > + return NETDEV_TX_OK;
> > + }
> > + }
> > +#endif
> > + free_size = bnge_tx_avail(bn, txr);
> > + if (unlikely(free_size < skb_shinfo(skb)->nr_frags + 2)) {
> > + /* We must have raced with NAPI cleanup */
> > + if (net_ratelimit() && txr->kick_pending)
> > + netif_warn(bn, tx_err, dev,
> > + "bnge: ring busy w/ flush pending!\n");
> > + if (!netif_txq_try_stop(txq, bnge_tx_avail(bn, txr),
> > + bn->tx_wake_thresh))
> > + return NETDEV_TX_BUSY;
> > + }
> > +
> > + if (unlikely(ipv6_hopopt_jumbo_remove(skb)))
> > + goto tx_free;
> > +
> > + length = skb->len;
> > + len = skb_headlen(skb);
> > + last_frag = skb_shinfo(skb)->nr_frags;
> > +
> > + txbd = &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
> > +
> > + tx_buf = &txr->tx_buf_ring[RING_TX(bn, prod)];
>
> The naming (TX_RING() vs RING_TX() with quite different meaning) is IMHO
> prone to errors.
Thanks, I'll address this in the next revision.
>
> > + tx_buf->skb = skb;
> > + tx_buf->nr_frags = last_frag;
> > +
> > + vlan_tag_flags = 0;
> > + cfa_action = bnge_xmit_get_cfa_action(skb);
> > + if (skb_vlan_tag_present(skb)) {
> > + vlan_tag_flags = TX_BD_CFA_META_KEY_VLAN |
> > + skb_vlan_tag_get(skb);
> > + /* Currently supports 8021Q, 8021AD vlan offloads
> > + * QINQ1, QINQ2, QINQ3 vlan headers are deprecated
> > + */
> > + if (skb->vlan_proto == htons(ETH_P_8021Q))
> > + vlan_tag_flags |= 1 << TX_BD_CFA_META_TPID_SHIFT;
> > + }
> > +
> > + if (unlikely(skb->no_fcs))
> > + lflags |= cpu_to_le32(TX_BD_FLAGS_NO_CRC);
> > +
> > + if (length < BNGE_MIN_PKT_SIZE) {
> > + pad = BNGE_MIN_PKT_SIZE - length;
> > + if (skb_pad(skb, pad))
> > + /* SKB already freed. */
> > + goto tx_kick_pending;
> > + length = BNGE_MIN_PKT_SIZE;
> > + }
> > +
> > + mapping = dma_map_single(bd->dev, skb->data, len, DMA_TO_DEVICE);
> > +
> > + if (unlikely(dma_mapping_error(bd->dev, mapping)))
> > + goto tx_free;
> > +
> > + dma_unmap_addr_set(tx_buf, mapping, mapping);
> > + flags = (len << TX_BD_LEN_SHIFT) | TX_BD_TYPE_LONG_TX_BD |
> > + TX_BD_CNT(last_frag + 2);
> > +
> > + txbd->tx_bd_haddr = cpu_to_le64(mapping);
> > + txbd->tx_bd_opaque = SET_TX_OPAQUE(bn, txr, prod, 2 + last_frag);
> > +
> > + prod = NEXT_TX(prod);
> > + txbd1 = (struct tx_bd_ext *)
> > + &txr->tx_desc_ring[TX_RING(bn, prod)][TX_IDX(prod)];
> > +
> > + txbd1->tx_bd_hsize_lflags = lflags;
> > + if (skb_is_gso(skb)) {
> > + bool udp_gso = !!(skb_shinfo(skb)->gso_type & SKB_GSO_UDP_L4);
> > + u32 hdr_len;
> > +
> > + if (skb->encapsulation) {
> > + if (udp_gso)
> > + hdr_len = skb_inner_transport_offset(skb) +
> > + sizeof(struct udphdr);
> > + else
> > + hdr_len = skb_inner_tcp_all_headers(skb);
> > + } else if (udp_gso) {
> > + hdr_len = skb_transport_offset(skb) +
> > + sizeof(struct udphdr);
> > + } else {
> > + hdr_len = skb_tcp_all_headers(skb);
> > + }
> > +
> > + txbd1->tx_bd_hsize_lflags |= cpu_to_le32(TX_BD_FLAGS_LSO |
> > + TX_BD_FLAGS_T_IPID |
> > + (hdr_len << (TX_BD_HSIZE_SHIFT - 1)));
> > + length = skb_shinfo(skb)->gso_size;
> > + txbd1->tx_bd_mss = cpu_to_le32(length);
> > + length += hdr_len;
> > + } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
> > + txbd1->tx_bd_hsize_lflags |=
> > + cpu_to_le32(TX_BD_FLAGS_TCP_UDP_CHKSUM);
> > + txbd1->tx_bd_mss = 0;
> > + }
> > +
> > + length >>= 9;
> > + if (unlikely(length >= ARRAY_SIZE(bnge_lhint_arr))) {
>
> a proper ndo_features_check() should avoid the above check.
Thanks, I'll address this in the next revision.
Thanks,
Bhargava Marreddy
>
> /P
>
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread* Re: [v4, net-next 4/7] bng_en: Add TX support
2026-01-12 21:16 ` Bhargava Chenna Marreddy
@ 2026-01-16 18:43 ` Bhargava Chenna Marreddy
0 siblings, 0 replies; 18+ messages in thread
From: Bhargava Chenna Marreddy @ 2026-01-16 18:43 UTC (permalink / raw)
To: Paolo Abeni
Cc: davem, edumazet, kuba, andrew+netdev, horms, netdev,
linux-kernel, michael.chan, pavan.chebbi, vsrama-krishna.nemani,
vikas.gupta, Rajashekar Hudumula
[-- Attachment #1: Type: text/plain, Size: 2656 bytes --]
On Tue, Jan 13, 2026 at 2:46 AM Bhargava Chenna Marreddy
<bhargava.marreddy@broadcom.com> wrote:
>
> On Thu, Jan 8, 2026 at 3:39 PM Paolo Abeni <pabeni@redhat.com> wrote:
> >
> > On 1/5/26 8:21 AM, Bhargava Marreddy wrote:
> > > +static void __bnge_tx_int(struct bnge_net *bn, struct bnge_tx_ring_info *txr,
> > > + int budget)
> > > +{
> > > + u16 hw_cons = txr->tx_hw_cons;
> > > + struct bnge_dev *bd = bn->bd;
> > > + unsigned int tx_bytes = 0;
> > > + unsigned int tx_pkts = 0;
> > > + struct netdev_queue *txq;
> > > + u16 cons = txr->tx_cons;
> > > + skb_frag_t *frag;
> > > +
> > > + txq = netdev_get_tx_queue(bn->netdev, txr->txq_index);
> > > +
> > > + while (RING_TX(bn, cons) != hw_cons) {
> > > + struct bnge_sw_tx_bd *tx_buf;
> > > + struct sk_buff *skb;
> > > + int j, last;
> > > +
> > > + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> > > + skb = tx_buf->skb;
> > > + if (unlikely(!skb)) {
> > > + bnge_sched_reset_txr(bn, txr, cons);
> > > + return;
> > > + }
> > > +
> > > + cons = NEXT_TX(cons);
> > > + tx_pkts++;
> > > + tx_bytes += skb->len;
> > > + tx_buf->skb = NULL;
> > > +
> > > + dma_unmap_single(bd->dev, dma_unmap_addr(tx_buf, mapping),
> > > + skb_headlen(skb), DMA_TO_DEVICE);
> > > + last = tx_buf->nr_frags;
> > > +
> > > + for (j = 0; j < last; j++) {
> > > + frag = &skb_shinfo(skb)->frags[j];
> > > + cons = NEXT_TX(cons);
> > > + tx_buf = &txr->tx_buf_ring[RING_TX(bn, cons)];
> > > + netmem_dma_unmap_page_attrs(bd->dev,
> > > + dma_unmap_addr(tx_buf,
> > > + mapping),
> > > + skb_frag_size(frag),
> > > + DMA_TO_DEVICE, 0);
> > > + }
> >
> > There is a similar chunk in bnge_free_tx_skbs(), you could avoid
> > douplication factoring that out in common helper.
>
> Agreed. I'll address this in the next revision.
Hi Paolo,
Re-thinking this: the refactoring is non-trivial and we need to
restructure this part for
PTP/XDP soon anyway. I'll skip it for this series and include it in
the future updates instead.
Thanks,
Bhargava Marreddy
>
> >
[-- Attachment #2: S/MIME Cryptographic Signature --]
[-- Type: application/pkcs7-signature, Size: 5496 bytes --]
^ permalink raw reply [flat|nested] 18+ messages in thread
* [v4, net-next 5/7] bng_en: Add support to handle AGG events
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
` (3 preceding siblings ...)
2026-01-05 7:21 ` [v4, net-next 4/7] bng_en: Add TX support Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 6/7] bng_en: Add TPA related functions Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 7/7] bng_en: Add support for TPA events Bhargava Marreddy
6 siblings, 0 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Add AGG event handling in the RX path to receive packet data
on AGG rings. This enables Jumbo and HDS functionality.
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_hw_def.h | 13 ++
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 17 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 5 +
.../net/ethernet/broadcom/bnge/bnge_txrx.c | 220 +++++++++++++++++-
.../net/ethernet/broadcom/bnge/bnge_txrx.h | 1 +
5 files changed, 248 insertions(+), 8 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
index 4da4259095fa..cfc888a7f9ee 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
@@ -4,6 +4,19 @@
#ifndef _BNGE_HW_DEF_H_
#define _BNGE_HW_DEF_H_
+struct rx_agg_cmp {
+ __le32 rx_agg_cmp_len_flags_type;
+ #define RX_AGG_CMP_TYPE (0x3f << 0)
+ #define RX_AGG_CMP_LEN (0xffff << 16)
+ #define RX_AGG_CMP_LEN_SHIFT 16
+ u32 rx_agg_cmp_opaque;
+ __le32 rx_agg_cmp_v;
+ #define RX_AGG_CMP_V (1 << 0)
+ #define RX_AGG_CMP_AGG_ID (0xffff << 16)
+ #define RX_AGG_CMP_AGG_ID_SHIFT 16
+ __le32 rx_agg_cmp_unused;
+};
+
struct tx_bd_ext {
__le32 tx_bd_hsize_lflags;
#define TX_BD_FLAGS_TCP_UDP_CHKSUM (1 << 0)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 54b487204f17..0f2700131237 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -10,6 +10,9 @@
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
+#include <net/netdev_lock.h>
+#include <net/netdev_queues.h>
+#include <net/netdev_rx_queue.h>
#include <linux/etherdevice.h>
#include <linux/if.h>
#include <net/ip.h>
@@ -979,9 +982,9 @@ static netmem_ref __bnge_alloc_rx_netmem(struct bnge_net *bn,
return netmem;
}
-static u8 *__bnge_alloc_rx_frag(struct bnge_net *bn, dma_addr_t *mapping,
- struct bnge_rx_ring_info *rxr,
- gfp_t gfp)
+u8 *__bnge_alloc_rx_frag(struct bnge_net *bn, dma_addr_t *mapping,
+ struct bnge_rx_ring_info *rxr,
+ gfp_t gfp)
{
unsigned int offset;
struct page *page;
@@ -1048,7 +1051,7 @@ static int bnge_alloc_one_rx_ring_bufs(struct bnge_net *bn,
return 0;
}
-static u16 bnge_find_next_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx)
+u16 bnge_find_next_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx)
{
u16 next, max = rxr->rx_agg_bmap_size;
@@ -1058,9 +1061,9 @@ static u16 bnge_find_next_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx)
return next;
}
-static int bnge_alloc_rx_netmem(struct bnge_net *bn,
- struct bnge_rx_ring_info *rxr,
- u16 prod, gfp_t gfp)
+int bnge_alloc_rx_netmem(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr,
+ u16 prod, gfp_t gfp)
{
struct bnge_sw_rx_agg_bd *rx_agg_buf;
u16 sw_prod = rxr->rx_sw_agg_prod;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index fba758cc8b04..8451d35d7b7e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -514,4 +514,9 @@ u16 bnge_cp_ring_for_tx(struct bnge_tx_ring_info *txr);
void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic);
int bnge_alloc_rx_data(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
u16 prod, gfp_t gfp);
+u16 bnge_find_next_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx);
+u8 *__bnge_alloc_rx_frag(struct bnge_net *bn, dma_addr_t *mapping,
+ struct bnge_rx_ring_info *rxr, gfp_t gfp);
+int bnge_alloc_rx_netmem(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
+ u16 prod, gfp_t gfp);
#endif /* _BNGE_NETDEV_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
index c7b89b1635a2..fb54a9b14a8d 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
@@ -13,6 +13,7 @@
#include <linux/etherdevice.h>
#include <linux/if.h>
#include <net/ip.h>
+#include <net/tcp.h>
#include <linux/skbuff.h>
#include <net/page_pool/helpers.h>
#include <linux/if_vlan.h>
@@ -43,6 +44,191 @@ irqreturn_t bnge_msix(int irq, void *dev_instance)
return IRQ_HANDLED;
}
+static struct rx_agg_cmp *bnge_get_agg(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ u16 cp_cons, u16 curr)
+{
+ struct rx_agg_cmp *agg;
+
+ cp_cons = RING_CMP(bn, ADV_RAW_CMP(cp_cons, curr));
+ agg = (struct rx_agg_cmp *)
+ &cpr->desc_ring[CP_RING(cp_cons)][CP_IDX(cp_cons)];
+ return agg;
+}
+
+static void bnge_reuse_rx_agg_bufs(struct bnge_cp_ring_info *cpr, u16 idx,
+ u16 start, u32 agg_bufs)
+{
+ struct bnge_napi *bnapi = cpr->bnapi;
+ struct bnge_net *bn = bnapi->bn;
+ struct bnge_rx_ring_info *rxr;
+ u16 prod, sw_prod;
+ u32 i;
+
+ rxr = bnapi->rx_ring;
+ sw_prod = rxr->rx_sw_agg_prod;
+ prod = rxr->rx_agg_prod;
+
+ for (i = 0; i < agg_bufs; i++) {
+ struct bnge_sw_rx_agg_bd *cons_rx_buf, *prod_rx_buf;
+ struct rx_agg_cmp *agg;
+ struct rx_bd *prod_bd;
+ netmem_ref netmem;
+ u16 cons;
+
+ agg = bnge_get_agg(bn, cpr, idx, start + i);
+ cons = agg->rx_agg_cmp_opaque;
+ __clear_bit(cons, rxr->rx_agg_bmap);
+
+ if (unlikely(test_bit(sw_prod, rxr->rx_agg_bmap)))
+ sw_prod = bnge_find_next_agg_idx(rxr, sw_prod);
+
+ __set_bit(sw_prod, rxr->rx_agg_bmap);
+ prod_rx_buf = &rxr->rx_agg_buf_ring[sw_prod];
+ cons_rx_buf = &rxr->rx_agg_buf_ring[cons];
+
+ /* It is possible for sw_prod to be equal to cons, so
+ * set cons_rx_buf->netmem to 0 first.
+ */
+ netmem = cons_rx_buf->netmem;
+ cons_rx_buf->netmem = 0;
+ prod_rx_buf->netmem = netmem;
+ prod_rx_buf->offset = cons_rx_buf->offset;
+
+ prod_rx_buf->mapping = cons_rx_buf->mapping;
+
+ prod_bd = &rxr->rx_agg_desc_ring[RX_AGG_RING(bn, prod)]
+ [RX_IDX(prod)];
+
+ prod_bd->rx_bd_haddr = cpu_to_le64(cons_rx_buf->mapping);
+ prod_bd->rx_bd_opaque = sw_prod;
+
+ prod = NEXT_RX_AGG(prod);
+ sw_prod = RING_RX_AGG(bn, NEXT_RX_AGG(sw_prod));
+ }
+ rxr->rx_agg_prod = prod;
+ rxr->rx_sw_agg_prod = sw_prod;
+}
+
+static int bnge_agg_bufs_valid(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ u8 agg_bufs, u32 *raw_cons)
+{
+ struct rx_agg_cmp *agg;
+ u16 last;
+
+ *raw_cons = ADV_RAW_CMP(*raw_cons, agg_bufs);
+ last = RING_CMP(bn, *raw_cons);
+ agg = (struct rx_agg_cmp *)
+ &cpr->desc_ring[CP_RING(last)][CP_IDX(last)];
+ return RX_AGG_CMP_VALID(bn, agg, *raw_cons);
+}
+
+static int bnge_discard_rx(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
+ u32 *raw_cons, void *cmp)
+{
+ u32 tmp_raw_cons = *raw_cons;
+ struct rx_cmp *rxcmp = cmp;
+ u8 cmp_type, agg_bufs = 0;
+
+ cmp_type = RX_CMP_TYPE(rxcmp);
+
+ if (cmp_type == CMP_TYPE_RX_L2_CMP) {
+ agg_bufs = (le32_to_cpu(rxcmp->rx_cmp_misc_v1) &
+ RX_CMP_AGG_BUFS) >>
+ RX_CMP_AGG_BUFS_SHIFT;
+ }
+
+ if (agg_bufs) {
+ if (!bnge_agg_bufs_valid(bn, cpr, agg_bufs, &tmp_raw_cons))
+ return -EBUSY;
+ }
+ *raw_cons = tmp_raw_cons;
+ return 0;
+}
+
+static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ u16 idx, u32 agg_bufs,
+ struct sk_buff *skb)
+{
+ struct bnge_napi *bnapi = cpr->bnapi;
+ struct skb_shared_info *shinfo;
+ struct bnge_rx_ring_info *rxr;
+ u32 i, total_frag_len = 0;
+ u16 prod;
+
+ rxr = bnapi->rx_ring;
+ prod = rxr->rx_agg_prod;
+ shinfo = skb_shinfo(skb);
+
+ for (i = 0; i < agg_bufs; i++) {
+ struct bnge_sw_rx_agg_bd *cons_rx_buf;
+ struct rx_agg_cmp *agg;
+ u16 cons, frag_len;
+ netmem_ref netmem;
+
+ agg = bnge_get_agg(bn, cpr, idx, i);
+ cons = agg->rx_agg_cmp_opaque;
+ frag_len = (le32_to_cpu(agg->rx_agg_cmp_len_flags_type) &
+ RX_AGG_CMP_LEN) >> RX_AGG_CMP_LEN_SHIFT;
+
+ cons_rx_buf = &rxr->rx_agg_buf_ring[cons];
+ skb_add_rx_frag_netmem(skb, i, cons_rx_buf->netmem,
+ cons_rx_buf->offset,
+ frag_len, BNGE_RX_PAGE_SIZE);
+ __clear_bit(cons, rxr->rx_agg_bmap);
+
+ /* It is possible for bnge_alloc_rx_netmem() to allocate
+ * a sw_prod index that equals the cons index, so we
+ * need to clear the cons entry now.
+ */
+ netmem = cons_rx_buf->netmem;
+ cons_rx_buf->netmem = 0;
+
+ if (bnge_alloc_rx_netmem(bn, rxr, prod, GFP_ATOMIC) != 0) {
+ skb->len -= frag_len;
+ skb->data_len -= frag_len;
+ skb->truesize -= BNGE_RX_PAGE_SIZE;
+
+ --shinfo->nr_frags;
+ cons_rx_buf->netmem = netmem;
+
+ /* Update prod since possibly some netmems have been
+ * allocated already.
+ */
+ rxr->rx_agg_prod = prod;
+ bnge_reuse_rx_agg_bufs(cpr, idx, i, agg_bufs - i);
+ return 0;
+ }
+
+ page_pool_dma_sync_netmem_for_cpu(rxr->page_pool, netmem, 0,
+ BNGE_RX_PAGE_SIZE);
+
+ total_frag_len += frag_len;
+ prod = NEXT_RX_AGG(prod);
+ }
+ rxr->rx_agg_prod = prod;
+ return total_frag_len;
+}
+
+static struct sk_buff *bnge_rx_agg_netmems_skb(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ struct sk_buff *skb, u16 idx,
+ u32 agg_bufs)
+{
+ u32 total_frag_len;
+
+ total_frag_len = __bnge_rx_agg_netmems(bn, cpr, idx, agg_bufs, skb);
+ if (!total_frag_len) {
+ skb_mark_for_recycle(skb);
+ dev_kfree_skb(skb);
+ return NULL;
+ }
+
+ return skb;
+}
+
static void bnge_sched_reset_rxr(struct bnge_net *bn,
struct bnge_rx_ring_info *rxr)
{
@@ -233,6 +419,7 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
dma_addr_t dma_addr;
struct sk_buff *skb;
unsigned int len;
+ u8 agg_bufs;
void *data;
int rc = 0;
@@ -261,11 +448,15 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
cons = rxcmp->rx_cmp_opaque;
if (unlikely(cons != rxr->rx_next_cons)) {
+ int rc1 = bnge_discard_rx(bn, cpr, &tmp_raw_cons, rxcmp);
+
/* 0xffff is forced error, don't print it */
if (rxr->rx_next_cons != 0xffff)
netdev_warn(bn->netdev, "RX cons %x != expected cons %x\n",
cons, rxr->rx_next_cons);
bnge_sched_reset_rxr(bn, rxr);
+ if (rc1)
+ return rc1;
goto next_rx_no_prod_no_len;
}
rx_buf = &rxr->rx_buf_ring[cons];
@@ -274,11 +465,22 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
prefetch(data_ptr);
misc = le32_to_cpu(rxcmp->rx_cmp_misc_v1);
+ agg_bufs = (misc & RX_CMP_AGG_BUFS) >> RX_CMP_AGG_BUFS_SHIFT;
+
+ if (agg_bufs) {
+ if (!bnge_agg_bufs_valid(bn, cpr, agg_bufs, &tmp_raw_cons))
+ return -EBUSY;
+
+ cp_cons = NEXT_CMP(bn, cp_cons);
+ *event |= BNGE_AGG_EVENT;
+ }
*event |= BNGE_RX_EVENT;
rx_buf->data = NULL;
if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) {
bnge_reuse_rx_data(rxr, cons, data);
+ if (agg_bufs)
+ bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0, agg_bufs);
rc = -EIO;
goto next_rx_no_len;
}
@@ -290,8 +492,12 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
if (len <= bn->rx_copybreak) {
skb = bnge_copy_skb(bnapi, data_ptr, len, dma_addr);
bnge_reuse_rx_data(rxr, cons, data);
- if (!skb)
+ if (!skb) {
+ if (agg_bufs)
+ bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0,
+ agg_bufs);
goto oom_next_rx;
+ }
} else {
u32 payload;
@@ -305,6 +511,13 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
goto oom_next_rx;
}
+ if (agg_bufs) {
+ skb = bnge_rx_agg_netmems_skb(bn, cpr, skb, cp_cons,
+ agg_bufs);
+ if (!skb)
+ goto oom_next_rx;
+ }
+
if (RX_CMP_HASH_VALID(rxcmp)) {
enum pkt_hash_types type;
@@ -480,6 +693,11 @@ static void __bnge_poll_work_done(struct bnge_net *bn, struct bnge_napi *bnapi,
bnge_db_write(bn->bd, &rxr->rx_db, rxr->rx_prod);
bnapi->events &= ~BNGE_RX_EVENT;
}
+
+ if (bnapi->events & BNGE_AGG_EVENT) {
+ bnge_db_write(bn->bd, &rxr->rx_agg_db, rxr->rx_agg_prod);
+ bnapi->events &= ~BNGE_AGG_EVENT;
+ }
}
static void
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
index 8cd980875a3b..7de718898181 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.h
@@ -109,6 +109,7 @@ static inline void bnge_db_write_relaxed(struct bnge_net *bn,
#define ADV_RAW_CMP(idx, n) ((idx) + (n))
#define NEXT_RAW_CMP(idx) ADV_RAW_CMP(idx, 1)
#define RING_CMP(bn, idx) ((idx) & (bn)->cp_ring_mask)
+#define NEXT_CMP(bn, idx) RING_CMP(bn, ADV_RAW_CMP(idx, 1))
#define RX_CMP_ITYPES(rxcmp) \
(le32_to_cpu((rxcmp)->rx_cmp_len_flags_type) & RX_CMP_FLAGS_ITYPES_MASK)
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* [v4, net-next 6/7] bng_en: Add TPA related functions
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
` (4 preceding siblings ...)
2026-01-05 7:21 ` [v4, net-next 5/7] bng_en: Add support to handle AGG events Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
2026-01-05 7:21 ` [v4, net-next 7/7] bng_en: Add support for TPA events Bhargava Marreddy
6 siblings, 0 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Add the functions to handle TPA events in RX path.
This helps the next patch enable TPA functionality.
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_hw_def.h | 248 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 123 +++++++++
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 47 ++++
3 files changed, 418 insertions(+)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
index cfc888a7f9ee..a824e0566bef 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hw_def.h
@@ -208,4 +208,252 @@ struct rx_cmp_ext {
#define HWRM_RING_ALLOC_AGG 0x4
#define HWRM_RING_ALLOC_CMPL 0x8
#define HWRM_RING_ALLOC_NQ 0x10
+
+#define TPA_AGG_AGG_ID(rx_agg) \
+ ((le32_to_cpu((rx_agg)->rx_agg_cmp_v) & \
+ RX_AGG_CMP_AGG_ID) >> RX_AGG_CMP_AGG_ID_SHIFT)
+
+struct rx_tpa_start_cmp {
+ __le32 rx_tpa_start_cmp_len_flags_type;
+ #define RX_TPA_START_CMP_TYPE (0x3f << 0)
+ #define RX_TPA_START_CMP_FLAGS (0x3ff << 6)
+ #define RX_TPA_START_CMP_FLAGS_SHIFT 6
+ #define RX_TPA_START_CMP_FLAGS_ERROR (0x1 << 6)
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT (0x7 << 7)
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT_SHIFT 7
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT_JUMBO (0x1 << 7)
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT_HDS (0x2 << 7)
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT_GRO_JUMBO (0x5 << 7)
+ #define RX_TPA_START_CMP_FLAGS_PLACEMENT_GRO_HDS (0x6 << 7)
+ #define RX_TPA_START_CMP_FLAGS_RSS_VALID (0x1 << 10)
+ #define RX_TPA_START_CMP_FLAGS_TIMESTAMP (0x1 << 11)
+ #define RX_TPA_START_CMP_FLAGS_ITYPES (0xf << 12)
+ #define RX_TPA_START_CMP_FLAGS_ITYPES_SHIFT 12
+ #define RX_TPA_START_CMP_FLAGS_ITYPE_TCP (0x2 << 12)
+ #define RX_TPA_START_CMP_LEN (0xffff << 16)
+ #define RX_TPA_START_CMP_LEN_SHIFT 16
+
+ u32 rx_tpa_start_cmp_opaque;
+ __le32 rx_tpa_start_cmp_misc_v1;
+ #define RX_TPA_START_CMP_V1 (0x1 << 0)
+ #define RX_TPA_START_CMP_RSS_HASH_TYPE (0x7f << 9)
+ #define RX_TPA_START_CMP_RSS_HASH_TYPE_SHIFT 9
+ #define RX_TPA_START_CMP_V3_RSS_HASH_TYPE (0x1ff << 7)
+ #define RX_TPA_START_CMP_V3_RSS_HASH_TYPE_SHIFT 7
+ #define RX_TPA_START_CMP_AGG_ID (0x7f << 25)
+ #define RX_TPA_START_CMP_AGG_ID_SHIFT 25
+ #define RX_TPA_START_CMP_AGG_ID_P5 (0xffff << 16)
+ #define RX_TPA_START_CMP_AGG_ID_SHIFT_P5 16
+ #define RX_TPA_START_CMP_METADATA1 (0xf << 28)
+ #define RX_TPA_START_CMP_METADATA1_SHIFT 28
+ #define RX_TPA_START_METADATA1_TPID_SEL (0x7 << 28)
+ #define RX_TPA_START_METADATA1_TPID_8021Q (0x1 << 28)
+ #define RX_TPA_START_METADATA1_TPID_8021AD (0x0 << 28)
+ #define RX_TPA_START_METADATA1_VALID (0x8 << 28)
+
+ __le32 rx_tpa_start_cmp_rss_hash;
+};
+
+#define TPA_START_HASH_VALID(rx_tpa_start) \
+ ((rx_tpa_start)->rx_tpa_start_cmp_len_flags_type & \
+ cpu_to_le32(RX_TPA_START_CMP_FLAGS_RSS_VALID))
+
+#define TPA_START_HASH_TYPE(rx_tpa_start) \
+ (((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_misc_v1) & \
+ RX_TPA_START_CMP_RSS_HASH_TYPE) >> \
+ RX_TPA_START_CMP_RSS_HASH_TYPE_SHIFT) & RSS_PROFILE_ID_MASK)
+
+#define TPA_START_V3_HASH_TYPE(rx_tpa_start) \
+ (((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_misc_v1) & \
+ RX_TPA_START_CMP_V3_RSS_HASH_TYPE) >> \
+ RX_TPA_START_CMP_V3_RSS_HASH_TYPE_SHIFT) & RSS_PROFILE_ID_MASK)
+
+#define TPA_START_AGG_ID(rx_tpa_start) \
+ ((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_misc_v1) & \
+ RX_TPA_START_CMP_AGG_ID_P5) >> RX_TPA_START_CMP_AGG_ID_SHIFT_P5)
+
+#define TPA_START_ERROR(rx_tpa_start) \
+ ((rx_tpa_start)->rx_tpa_start_cmp_len_flags_type & \
+ cpu_to_le32(RX_TPA_START_CMP_FLAGS_ERROR))
+
+#define TPA_START_VLAN_VALID(rx_tpa_start) \
+ ((rx_tpa_start)->rx_tpa_start_cmp_misc_v1 & \
+ cpu_to_le32(RX_TPA_START_METADATA1_VALID))
+
+#define TPA_START_VLAN_TPID_SEL(rx_tpa_start) \
+ (le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_misc_v1) & \
+ RX_TPA_START_METADATA1_TPID_SEL)
+
+struct rx_tpa_start_cmp_ext {
+ __le32 rx_tpa_start_cmp_flags2;
+ #define RX_TPA_START_CMP_FLAGS2_IP_CS_CALC (0x1 << 0)
+ #define RX_TPA_START_CMP_FLAGS2_L4_CS_CALC (0x1 << 1)
+ #define RX_TPA_START_CMP_FLAGS2_T_IP_CS_CALC (0x1 << 2)
+ #define RX_TPA_START_CMP_FLAGS2_T_L4_CS_CALC (0x1 << 3)
+ #define RX_TPA_START_CMP_FLAGS2_IP_TYPE (0x1 << 8)
+ #define RX_TPA_START_CMP_FLAGS2_CSUM_CMPL_VALID (0x1 << 9)
+ #define RX_TPA_START_CMP_FLAGS2_EXT_META_FORMAT (0x3 << 10)
+ #define RX_TPA_START_CMP_FLAGS2_EXT_META_FORMAT_SHIFT 10
+ #define RX_TPA_START_CMP_V3_FLAGS2_T_IP_TYPE (0x1 << 10)
+ #define RX_TPA_START_CMP_V3_FLAGS2_AGG_GRO (0x1 << 11)
+ #define RX_TPA_START_CMP_FLAGS2_CSUM_CMPL (0xffff << 16)
+ #define RX_TPA_START_CMP_FLAGS2_CSUM_CMPL_SHIFT 16
+
+ __le32 rx_tpa_start_cmp_metadata;
+ __le32 rx_tpa_start_cmp_cfa_code_v2;
+ #define RX_TPA_START_CMP_V2 (0x1 << 0)
+ #define RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_MASK (0x7 << 1)
+ #define RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_SHIFT 1
+ #define RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_NO_BUFFER (0x0 << 1)
+ #define RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_BAD_FORMAT (0x3 << 1)
+ #define RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_FLUSH (0x5 << 1)
+ #define RX_TPA_START_CMP_CFA_CODE (0xffff << 16)
+ #define RX_TPA_START_CMPL_CFA_CODE_SHIFT 16
+ #define RX_TPA_START_CMP_METADATA0_TCI_MASK (0xffff << 16)
+ #define RX_TPA_START_CMP_METADATA0_VID_MASK (0x0fff << 16)
+ #define RX_TPA_START_CMP_METADATA0_SFT 16
+ __le32 rx_tpa_start_cmp_hdr_info;
+};
+
+#define TPA_START_CFA_CODE(rx_tpa_start) \
+ ((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_cfa_code_v2) & \
+ RX_TPA_START_CMP_CFA_CODE) >> RX_TPA_START_CMPL_CFA_CODE_SHIFT)
+
+#define TPA_START_IS_IPV6(rx_tpa_start) \
+ (!!((rx_tpa_start)->rx_tpa_start_cmp_flags2 & \
+ cpu_to_le32(RX_TPA_START_CMP_FLAGS2_IP_TYPE)))
+
+#define TPA_START_ERROR_CODE(rx_tpa_start) \
+ ((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_cfa_code_v2) & \
+ RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_MASK) >> \
+ RX_TPA_START_CMP_ERRORS_BUFFER_ERROR_SHIFT)
+
+#define TPA_START_METADATA0_TCI(rx_tpa_start) \
+ ((le32_to_cpu((rx_tpa_start)->rx_tpa_start_cmp_cfa_code_v2) & \
+ RX_TPA_START_CMP_METADATA0_TCI_MASK) >> \
+ RX_TPA_START_CMP_METADATA0_SFT)
+
+struct rx_tpa_end_cmp {
+ __le32 rx_tpa_end_cmp_len_flags_type;
+ #define RX_TPA_END_CMP_TYPE (0x3f << 0)
+ #define RX_TPA_END_CMP_FLAGS (0x3ff << 6)
+ #define RX_TPA_END_CMP_FLAGS_SHIFT 6
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT (0x7 << 7)
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT_SHIFT 7
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT_JUMBO (0x1 << 7)
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT_HDS (0x2 << 7)
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT_GRO_JUMBO (0x5 << 7)
+ #define RX_TPA_END_CMP_FLAGS_PLACEMENT_GRO_HDS (0x6 << 7)
+ #define RX_TPA_END_CMP_FLAGS_RSS_VALID (0x1 << 10)
+ #define RX_TPA_END_CMP_FLAGS_ITYPES (0xf << 12)
+ #define RX_TPA_END_CMP_FLAGS_ITYPES_SHIFT 12
+ #define RX_TPA_END_CMP_FLAGS_ITYPE_TCP (0x2 << 12)
+ #define RX_TPA_END_CMP_LEN (0xffff << 16)
+ #define RX_TPA_END_CMP_LEN_SHIFT 16
+
+ u32 rx_tpa_end_cmp_opaque;
+ __le32 rx_tpa_end_cmp_misc_v1;
+ #define RX_TPA_END_CMP_V1 (0x1 << 0)
+ #define RX_TPA_END_CMP_AGG_BUFS (0x3f << 1)
+ #define RX_TPA_END_CMP_AGG_BUFS_SHIFT 1
+ #define RX_TPA_END_CMP_TPA_SEGS (0xff << 8)
+ #define RX_TPA_END_CMP_TPA_SEGS_SHIFT 8
+ #define RX_TPA_END_CMP_PAYLOAD_OFFSET (0xff << 16)
+ #define RX_TPA_END_CMP_PAYLOAD_OFFSET_SHIFT 16
+ #define RX_TPA_END_CMP_AGG_ID (0xffff << 16)
+ #define RX_TPA_END_CMP_AGG_ID_SHIFT 16
+
+ __le32 rx_tpa_end_cmp_tsdelta;
+ #define RX_TPA_END_GRO_TS (0x1 << 31)
+};
+
+#define TPA_END_AGG_ID(rx_tpa_end) \
+ ((le32_to_cpu((rx_tpa_end)->rx_tpa_end_cmp_misc_v1) & \
+ RX_TPA_END_CMP_AGG_ID) >> RX_TPA_END_CMP_AGG_ID_SHIFT)
+
+#define TPA_END_TPA_SEGS(rx_tpa_end) \
+ ((le32_to_cpu((rx_tpa_end)->rx_tpa_end_cmp_misc_v1) & \
+ RX_TPA_END_CMP_TPA_SEGS) >> RX_TPA_END_CMP_TPA_SEGS_SHIFT)
+
+#define RX_TPA_END_CMP_FLAGS_PLACEMENT_ANY_GRO \
+ cpu_to_le32(RX_TPA_END_CMP_FLAGS_PLACEMENT_GRO_JUMBO & \
+ RX_TPA_END_CMP_FLAGS_PLACEMENT_GRO_HDS)
+
+#define TPA_END_GRO(rx_tpa_end) \
+ ((rx_tpa_end)->rx_tpa_end_cmp_len_flags_type & \
+ RX_TPA_END_CMP_FLAGS_PLACEMENT_ANY_GRO)
+
+#define TPA_END_GRO_TS(rx_tpa_end) \
+ (!!((rx_tpa_end)->rx_tpa_end_cmp_tsdelta & \
+ cpu_to_le32(RX_TPA_END_GRO_TS)))
+
+struct rx_tpa_end_cmp_ext {
+ __le32 rx_tpa_end_cmp_dup_acks;
+ #define RX_TPA_END_CMP_TPA_DUP_ACKS (0xf << 0)
+ #define RX_TPA_END_CMP_PAYLOAD_OFFSET_P5 (0xff << 16)
+ #define RX_TPA_END_CMP_PAYLOAD_OFFSET_SHIFT_P5 16
+ #define RX_TPA_END_CMP_AGG_BUFS_P5 (0xff << 24)
+ #define RX_TPA_END_CMP_AGG_BUFS_SHIFT_P5 24
+
+ __le32 rx_tpa_end_cmp_seg_len;
+ #define RX_TPA_END_CMP_TPA_SEG_LEN (0xffff << 0)
+
+ __le32 rx_tpa_end_cmp_errors_v2;
+ #define RX_TPA_END_CMP_V2 (0x1 << 0)
+ #define RX_TPA_END_CMP_ERRORS (0x3 << 1)
+ #define RX_TPA_END_CMP_ERRORS_P5 (0x7 << 1)
+ #define RX_TPA_END_CMPL_ERRORS_SHIFT 1
+ #define RX_TPA_END_CMP_ERRORS_BUFFER_ERROR_NO_BUFFER (0x0 << 1)
+ #define RX_TPA_END_CMP_ERRORS_BUFFER_ERROR_NOT_ON_CHIP (0x2 << 1)
+ #define RX_TPA_END_CMP_ERRORS_BUFFER_ERROR_BAD_FORMAT (0x3 << 1)
+ #define RX_TPA_END_CMP_ERRORS_BUFFER_ERROR_RSV_ERROR (0x4 << 1)
+ #define RX_TPA_END_CMP_ERRORS_BUFFER_ERROR_FLUSH (0x5 << 1)
+
+ u32 rx_tpa_end_cmp_start_opaque;
+};
+
+#define TPA_END_ERRORS(rx_tpa_end_ext) \
+ ((rx_tpa_end_ext)->rx_tpa_end_cmp_errors_v2 & \
+ cpu_to_le32(RX_TPA_END_CMP_ERRORS))
+
+#define TPA_END_PAYLOAD_OFF(rx_tpa_end_ext) \
+ ((le32_to_cpu((rx_tpa_end_ext)->rx_tpa_end_cmp_dup_acks) & \
+ RX_TPA_END_CMP_PAYLOAD_OFFSET_P5) >> \
+ RX_TPA_END_CMP_PAYLOAD_OFFSET_SHIFT_P5)
+
+#define TPA_END_AGG_BUFS(rx_tpa_end_ext) \
+ ((le32_to_cpu((rx_tpa_end_ext)->rx_tpa_end_cmp_dup_acks) & \
+ RX_TPA_END_CMP_AGG_BUFS_P5) >> RX_TPA_END_CMP_AGG_BUFS_SHIFT_P5)
+
+#define EVENT_DATA1_RESET_NOTIFY_FATAL(data1) \
+ (((data1) & \
+ ASYNC_EVENT_CMPL_RESET_NOTIFY_EVENT_DATA1_REASON_CODE_MASK) ==\
+ ASYNC_EVENT_CMPL_RESET_NOTIFY_EVENT_DATA1_REASON_CODE_FW_EXCEPTION_FATAL)
+
+#define EVENT_DATA1_RESET_NOTIFY_FW_ACTIVATION(data1) \
+ (((data1) & \
+ ASYNC_EVENT_CMPL_RESET_NOTIFY_EVENT_DATA1_REASON_CODE_MASK) ==\
+ ASYNC_EVENT_CMPL_RESET_NOTIFY_EVENT_DATA1_REASON_CODE_FW_ACTIVATION)
+
+#define EVENT_DATA2_RESET_NOTIFY_FW_STATUS_CODE(data2) \
+ ((data2) & \
+ ASYNC_EVENT_CMPL_RESET_NOTIFY_EVENT_DATA2_FW_STATUS_CODE_MASK)
+
+#define EVENT_DATA1_RECOVERY_MASTER_FUNC(data1) \
+ (!!((data1) & \
+ ASYNC_EVENT_CMPL_ERROR_RECOVERY_EVENT_DATA1_FLAGS_MASTER_FUNC))
+
+#define EVENT_DATA1_RECOVERY_ENABLED(data1) \
+ (!!((data1) & \
+ ASYNC_EVENT_CMPL_ERROR_RECOVERY_EVENT_DATA1_FLAGS_RECOVERY_ENABLED))
+
+#define BNGE_EVENT_ERROR_REPORT_TYPE(data1) \
+ (((data1) & \
+ ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_MASK) >>\
+ ASYNC_EVENT_CMPL_ERROR_REPORT_BASE_EVENT_DATA1_ERROR_TYPE_SFT)
+
+#define BNGE_EVENT_INVALID_SIGNAL_DATA(data2) \
+ (((data2) & \
+ ASYNC_EVENT_CMPL_ERROR_REPORT_INVALID_SIGNAL_EVENT_DATA2_PIN_ID_MASK) >>\
+ ASYNC_EVENT_CMPL_ERROR_REPORT_INVALID_SIGNAL_EVENT_DATA2_PIN_ID_SFT)
#endif /* _BNGE_HW_DEF_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 0f2700131237..16b062d7688a 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -377,11 +377,37 @@ static void bnge_free_one_agg_ring_bufs(struct bnge_net *bn,
}
}
+static void bnge_free_one_tpa_info_data(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr)
+{
+ int i;
+
+ for (i = 0; i < bn->max_tpa; i++) {
+ struct bnge_tpa_info *tpa_info = &rxr->rx_tpa[i];
+ u8 *data = tpa_info->data;
+
+ if (!data)
+ continue;
+
+ tpa_info->data = NULL;
+ page_pool_free_va(rxr->head_pool, data, false);
+ }
+}
+
static void bnge_free_one_rx_ring_pair_bufs(struct bnge_net *bn,
struct bnge_rx_ring_info *rxr)
{
+ struct bnge_tpa_idx_map *map;
+
+ if (rxr->rx_tpa)
+ bnge_free_one_tpa_info_data(bn, rxr);
+
bnge_free_one_rx_ring_bufs(bn, rxr);
bnge_free_one_agg_ring_bufs(bn, rxr);
+
+ map = rxr->rx_tpa_idx_map;
+ if (map)
+ memset(map->agg_idx_bmap, 0, sizeof(map->agg_idx_bmap));
}
static void bnge_free_rx_ring_pair_bufs(struct bnge_net *bn)
@@ -452,11 +478,70 @@ static void bnge_free_all_rings_bufs(struct bnge_net *bn)
bnge_free_tx_skbs(bn);
}
+static void bnge_free_tpa_info(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i, j;
+
+ for (i = 0; i < bd->rx_nr_rings; i++) {
+ struct bnge_rx_ring_info *rxr = &bn->rx_ring[i];
+
+ kfree(rxr->rx_tpa_idx_map);
+ rxr->rx_tpa_idx_map = NULL;
+ if (rxr->rx_tpa) {
+ for (j = 0; j < bn->max_tpa; j++) {
+ kfree(rxr->rx_tpa[j].agg_arr);
+ rxr->rx_tpa[j].agg_arr = NULL;
+ }
+ }
+ kfree(rxr->rx_tpa);
+ rxr->rx_tpa = NULL;
+ }
+}
+
+static int bnge_alloc_tpa_info(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i, j;
+
+ if (!bd->max_tpa_v2)
+ return 0;
+
+ bn->max_tpa = max_t(u16, bd->max_tpa_v2, MAX_TPA);
+ for (i = 0; i < bd->rx_nr_rings; i++) {
+ struct bnge_rx_ring_info *rxr = &bn->rx_ring[i];
+
+ rxr->rx_tpa = kcalloc(bn->max_tpa, sizeof(struct bnge_tpa_info),
+ GFP_KERNEL);
+ if (!rxr->rx_tpa)
+ goto err_free_tpa_info;
+
+ for (j = 0; j < bn->max_tpa; j++) {
+ struct rx_agg_cmp *agg;
+
+ agg = kcalloc(MAX_SKB_FRAGS, sizeof(*agg), GFP_KERNEL);
+ if (!agg)
+ goto err_free_tpa_info;
+ rxr->rx_tpa[j].agg_arr = agg;
+ }
+ rxr->rx_tpa_idx_map = kzalloc(sizeof(*rxr->rx_tpa_idx_map),
+ GFP_KERNEL);
+ if (!rxr->rx_tpa_idx_map)
+ goto err_free_tpa_info;
+ }
+ return 0;
+
+err_free_tpa_info:
+ bnge_free_tpa_info(bn);
+ return -ENOMEM;
+}
+
static void bnge_free_rx_rings(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
int i;
+ bnge_free_tpa_info(bn);
for (i = 0; i < bd->rx_nr_rings; i++) {
struct bnge_rx_ring_info *rxr = &bn->rx_ring[i];
struct bnge_ring_struct *ring;
@@ -581,6 +666,12 @@ static int bnge_alloc_rx_rings(struct bnge_net *bn)
goto err_free_rx_rings;
}
}
+
+ if (bn->priv_flags & BNGE_NET_EN_TPA) {
+ rc = bnge_alloc_tpa_info(bn);
+ if (rc)
+ goto err_free_rx_rings;
+ }
return rc;
err_free_rx_rings:
@@ -1126,6 +1217,29 @@ static int bnge_alloc_one_agg_ring_bufs(struct bnge_net *bn,
return -ENOMEM;
}
+static int bnge_alloc_one_tpa_info_data(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr)
+{
+ dma_addr_t mapping;
+ u8 *data;
+ int i;
+
+ for (i = 0; i < bn->max_tpa; i++) {
+ data = __bnge_alloc_rx_frag(bn, &mapping, rxr,
+ GFP_KERNEL);
+ if (!data)
+ goto err_free_tpa_info_data;
+
+ rxr->rx_tpa[i].data = data;
+ rxr->rx_tpa[i].data_ptr = data + bn->rx_offset;
+ rxr->rx_tpa[i].mapping = mapping;
+ }
+ return 0;
+err_free_tpa_info_data:
+ bnge_free_one_tpa_info_data(bn, rxr);
+ return -ENOMEM;
+}
+
static int bnge_alloc_one_rx_ring_pair_bufs(struct bnge_net *bn, int ring_nr)
{
struct bnge_rx_ring_info *rxr = &bn->rx_ring[ring_nr];
@@ -1140,8 +1254,17 @@ static int bnge_alloc_one_rx_ring_pair_bufs(struct bnge_net *bn, int ring_nr)
if (rc)
goto err_free_one_rx_ring_bufs;
}
+
+ if (rxr->rx_tpa) {
+ rc = bnge_alloc_one_tpa_info_data(bn, rxr);
+ if (rc)
+ goto err_free_one_agg_ring_bufs;
+ }
+
return 0;
+err_free_one_agg_ring_bufs:
+ bnge_free_one_agg_ring_bufs(bn, rxr);
err_free_one_rx_ring_bufs:
bnge_free_one_rx_ring_bufs(bn, rxr);
return rc;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 8451d35d7b7e..335785041369 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -153,6 +153,46 @@ enum {
#define BNGE_NET_EN_TPA (BNGE_NET_EN_GRO | BNGE_NET_EN_LRO)
+#define BNGE_NO_FW_ACCESS(bd) (pci_channel_offline((bd)->pdev))
+
+#define MAX_TPA 256
+#define MAX_TPA_MASK (MAX_TPA - 1)
+#define MAX_TPA_SEGS 0x3f
+
+#define BNGE_AGG_IDX_BMAP_SIZE (MAX_TPA / BITS_PER_LONG)
+struct bnge_tpa_idx_map {
+ u16 agg_id_tbl[1024];
+ unsigned long agg_idx_bmap[BNGE_AGG_IDX_BMAP_SIZE];
+};
+
+struct bnge_tpa_info {
+ void *data;
+ u8 *data_ptr;
+ dma_addr_t mapping;
+ u16 len;
+ unsigned short gso_type;
+ u32 flags2;
+ u32 metadata;
+ enum pkt_hash_types hash_type;
+ u32 rss_hash;
+ u32 hdr_info;
+
+#define BNGE_TPA_INNER_L3_OFF(hdr_info) \
+ (((hdr_info) >> 18) & 0x1ff)
+
+#define BNGE_TPA_INNER_L2_OFF(hdr_info) \
+ (((hdr_info) >> 9) & 0x1ff)
+
+#define BNGE_TPA_OUTER_L3_OFF(hdr_info) \
+ ((hdr_info) & 0x1ff)
+
+ u16 cfa_code; /* cfa_code in TPA start compl */
+ u8 agg_count;
+ u8 vlan_valid:1;
+ u8 cfa_code_valid:1;
+ struct rx_agg_cmp *agg_arr;
+};
+
/* Minimum TX BDs for a TX packet with MAX_SKB_FRAGS + 1. We need one extra
* BD because the first TX BD is always a long BD.
*/
@@ -245,6 +285,10 @@ struct bnge_net {
#define BNGE_STATE_NAPI_DISABLED 0
u32 msg_enable;
+ u16 max_tpa;
+ __be16 vxlan_port;
+ __be16 nge_port;
+ __be16 vxlan_gpe_port;
};
#define BNGE_DEFAULT_RX_RING_SIZE 511
@@ -390,6 +434,9 @@ struct bnge_rx_ring_info {
dma_addr_t rx_desc_mapping[MAX_RX_PAGES];
dma_addr_t rx_agg_desc_mapping[MAX_RX_AGG_PAGES];
+ struct bnge_tpa_info *rx_tpa;
+ struct bnge_tpa_idx_map *rx_tpa_idx_map;
+
struct bnge_ring_struct rx_ring_struct;
struct bnge_ring_struct rx_agg_ring_struct;
struct page_pool *page_pool;
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread* [v4, net-next 7/7] bng_en: Add support for TPA events
2026-01-05 7:21 [v4, net-next 0/7] bng_en: enhancements for RX and TX datapath Bhargava Marreddy
` (5 preceding siblings ...)
2026-01-05 7:21 ` [v4, net-next 6/7] bng_en: Add TPA related functions Bhargava Marreddy
@ 2026-01-05 7:21 ` Bhargava Marreddy
6 siblings, 0 replies; 18+ messages in thread
From: Bhargava Marreddy @ 2026-01-05 7:21 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, michael.chan, pavan.chebbi,
vsrama-krishna.nemani, vikas.gupta, Bhargava Marreddy,
Rajashekar Hudumula
Enable TPA functionality in the VNIC and add functions
to handle TPA events, which help in processing LRO/GRO.
Signed-off-by: Bhargava Marreddy <bhargava.marreddy@broadcom.com>
Reviewed-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Rajashekar Hudumula <rajashekar.hudumula@broadcom.com>
---
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 65 +++
.../ethernet/broadcom/bnge/bnge_hwrm_lib.h | 2 +
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 27 ++
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 3 +-
.../net/ethernet/broadcom/bnge/bnge_txrx.c | 435 +++++++++++++++++-
5 files changed, 520 insertions(+), 12 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index 2994f10446a6..34a7fed92cc0 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -1183,3 +1183,68 @@ int bnge_hwrm_set_async_event_cr(struct bnge_dev *bd, int idx)
req->async_event_cr = cpu_to_le16(idx);
return bnge_hwrm_req_send(bd, req);
}
+
+#define BNGE_DFLT_TUNL_TPA_BMAP \
+ (VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_GRE | \
+ VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_IPV4 | \
+ VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_IPV6)
+
+static void bnge_hwrm_vnic_update_tunl_tpa(struct bnge_dev *bd,
+ struct hwrm_vnic_tpa_cfg_input *req)
+{
+ struct bnge_net *bn = netdev_priv(bd->netdev);
+ u32 tunl_tpa_bmap = BNGE_DFLT_TUNL_TPA_BMAP;
+
+ if (!(bd->fw_cap & BNGE_FW_CAP_VNIC_TUNNEL_TPA))
+ return;
+
+ if (bn->vxlan_port)
+ tunl_tpa_bmap |= VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_VXLAN;
+ if (bn->vxlan_gpe_port)
+ tunl_tpa_bmap |= VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_VXLAN_GPE;
+ if (bn->nge_port)
+ tunl_tpa_bmap |= VNIC_TPA_CFG_REQ_TNL_TPA_EN_BITMAP_GENEVE;
+
+ req->enables |= cpu_to_le32(VNIC_TPA_CFG_REQ_ENABLES_TNL_TPA_EN);
+ req->tnl_tpa_en_bitmap = cpu_to_le32(tunl_tpa_bmap);
+}
+
+int bnge_hwrm_vnic_set_tpa(struct bnge_dev *bd, struct bnge_vnic_info *vnic,
+ u32 tpa_flags)
+{
+ struct bnge_net *bn = netdev_priv(bd->netdev);
+ struct hwrm_vnic_tpa_cfg_input *req;
+ int rc;
+
+ if (vnic->fw_vnic_id == INVALID_HW_RING_ID)
+ return 0;
+
+ rc = bnge_hwrm_req_init(bd, req, HWRM_VNIC_TPA_CFG);
+ if (rc)
+ return rc;
+
+ if (tpa_flags) {
+ u32 flags;
+
+ flags = VNIC_TPA_CFG_REQ_FLAGS_TPA |
+ VNIC_TPA_CFG_REQ_FLAGS_ENCAP_TPA |
+ VNIC_TPA_CFG_REQ_FLAGS_RSC_WND_UPDATE |
+ VNIC_TPA_CFG_REQ_FLAGS_AGG_WITH_ECN |
+ VNIC_TPA_CFG_REQ_FLAGS_AGG_WITH_SAME_GRE_SEQ;
+ if (tpa_flags & BNGE_NET_EN_GRO)
+ flags |= VNIC_TPA_CFG_REQ_FLAGS_GRO;
+
+ req->flags = cpu_to_le32(flags);
+ req->enables =
+ cpu_to_le32(VNIC_TPA_CFG_REQ_ENABLES_MAX_AGG_SEGS |
+ VNIC_TPA_CFG_REQ_ENABLES_MAX_AGGS |
+ VNIC_TPA_CFG_REQ_ENABLES_MIN_AGG_LEN);
+ req->max_agg_segs = cpu_to_le16(MAX_TPA_SEGS);
+ req->max_aggs = cpu_to_le16(bn->max_tpa);
+ req->min_agg_len = cpu_to_le32(512);
+ bnge_hwrm_vnic_update_tunl_tpa(bd, req);
+ }
+ req->vnic_id = cpu_to_le16(vnic->fw_vnic_id);
+
+ return bnge_hwrm_req_send(bd, req);
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
index 042f28e84a05..38b046237feb 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
@@ -55,4 +55,6 @@ int hwrm_ring_alloc_send_msg(struct bnge_net *bn,
struct bnge_ring_struct *ring,
u32 ring_type, u32 map_index);
int bnge_hwrm_set_async_event_cr(struct bnge_dev *bd, int idx);
+int bnge_hwrm_vnic_set_tpa(struct bnge_dev *bd, struct bnge_vnic_info *vnic,
+ u32 tpa_flags);
#endif /* _BNGE_HWRM_LIB_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 16b062d7688a..2f8e98a0c2d4 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -2274,6 +2274,27 @@ static int bnge_request_irq(struct bnge_net *bn)
return rc;
}
+static int bnge_set_tpa(struct bnge_net *bn, bool set_tpa)
+{
+ u32 tpa_flags = 0;
+ int rc, i;
+
+ if (set_tpa)
+ tpa_flags = bn->priv_flags & BNGE_NET_EN_TPA;
+ else if (BNGE_NO_FW_ACCESS(bn->bd))
+ return 0;
+ for (i = 0; i < bn->nr_vnics; i++) {
+ rc = bnge_hwrm_vnic_set_tpa(bn->bd, &bn->vnic_info[i],
+ tpa_flags);
+ if (rc) {
+ netdev_err(bn->netdev, "hwrm vnic set tpa failure rc for vnic %d: %x\n",
+ i, rc);
+ return rc;
+ }
+ }
+ return 0;
+}
+
static int bnge_init_chip(struct bnge_net *bn)
{
struct bnge_vnic_info *vnic = &bn->vnic_info[BNGE_VNIC_DEFAULT];
@@ -2308,6 +2329,12 @@ static int bnge_init_chip(struct bnge_net *bn)
if (bd->rss_cap & BNGE_RSS_CAP_RSS_HASH_TYPE_DELTA)
bnge_hwrm_update_rss_hash_cfg(bn);
+ if (bn->priv_flags & BNGE_NET_EN_TPA) {
+ rc = bnge_set_tpa(bn, true);
+ if (rc)
+ goto err_out;
+ }
+
/* Filter for default vnic 0 */
rc = bnge_hwrm_set_vnic_filter(bn, 0, 0, bn->netdev->dev_addr);
if (rc) {
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 335785041369..6c206e6ff96c 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -159,10 +159,9 @@ enum {
#define MAX_TPA_MASK (MAX_TPA - 1)
#define MAX_TPA_SEGS 0x3f
-#define BNGE_AGG_IDX_BMAP_SIZE (MAX_TPA / BITS_PER_LONG)
struct bnge_tpa_idx_map {
u16 agg_id_tbl[1024];
- unsigned long agg_idx_bmap[BNGE_AGG_IDX_BMAP_SIZE];
+ DECLARE_BITMAP(agg_idx_bmap, MAX_TPA);
};
struct bnge_tpa_info {
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
index fb54a9b14a8d..6586ba3d47d6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_txrx.c
@@ -14,6 +14,7 @@
#include <linux/if.h>
#include <net/ip.h>
#include <net/tcp.h>
+#include <net/gro.h>
#include <linux/skbuff.h>
#include <net/page_pool/helpers.h>
#include <linux/if_vlan.h>
@@ -44,6 +45,15 @@ irqreturn_t bnge_msix(int irq, void *dev_instance)
return IRQ_HANDLED;
}
+static struct rx_agg_cmp *bnge_get_tpa_agg(struct bnge_net *bn,
+ struct bnge_rx_ring_info *rxr,
+ u16 agg_id, u16 curr)
+{
+ struct bnge_tpa_info *tpa_info = &rxr->rx_tpa[agg_id];
+
+ return &tpa_info->agg_arr[curr];
+}
+
static struct rx_agg_cmp *bnge_get_agg(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
u16 cp_cons, u16 curr)
@@ -57,7 +67,7 @@ static struct rx_agg_cmp *bnge_get_agg(struct bnge_net *bn,
}
static void bnge_reuse_rx_agg_bufs(struct bnge_cp_ring_info *cpr, u16 idx,
- u16 start, u32 agg_bufs)
+ u16 start, u32 agg_bufs, bool tpa)
{
struct bnge_napi *bnapi = cpr->bnapi;
struct bnge_net *bn = bnapi->bn;
@@ -76,7 +86,10 @@ static void bnge_reuse_rx_agg_bufs(struct bnge_cp_ring_info *cpr, u16 idx,
netmem_ref netmem;
u16 cons;
- agg = bnge_get_agg(bn, cpr, idx, start + i);
+ if (tpa)
+ agg = bnge_get_tpa_agg(bn, rxr, idx, start + i);
+ else
+ agg = bnge_get_agg(bn, cpr, idx, start + i);
cons = agg->rx_agg_cmp_opaque;
__clear_bit(cons, rxr->rx_agg_bmap);
@@ -137,6 +150,8 @@ static int bnge_discard_rx(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
agg_bufs = (le32_to_cpu(rxcmp->rx_cmp_misc_v1) &
RX_CMP_AGG_BUFS) >>
RX_CMP_AGG_BUFS_SHIFT;
+ } else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
+ return 0;
}
if (agg_bufs) {
@@ -149,7 +164,7 @@ static int bnge_discard_rx(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
- u16 idx, u32 agg_bufs,
+ u16 idx, u32 agg_bufs, bool tpa,
struct sk_buff *skb)
{
struct bnge_napi *bnapi = cpr->bnapi;
@@ -168,7 +183,10 @@ static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
u16 cons, frag_len;
netmem_ref netmem;
- agg = bnge_get_agg(bn, cpr, idx, i);
+ if (tpa)
+ agg = bnge_get_tpa_agg(bn, rxr, idx, i);
+ else
+ agg = bnge_get_agg(bn, cpr, idx, i);
cons = agg->rx_agg_cmp_opaque;
frag_len = (le32_to_cpu(agg->rx_agg_cmp_len_flags_type) &
RX_AGG_CMP_LEN) >> RX_AGG_CMP_LEN_SHIFT;
@@ -198,7 +216,7 @@ static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
* allocated already.
*/
rxr->rx_agg_prod = prod;
- bnge_reuse_rx_agg_bufs(cpr, idx, i, agg_bufs - i);
+ bnge_reuse_rx_agg_bufs(cpr, idx, i, agg_bufs - i, tpa);
return 0;
}
@@ -215,11 +233,12 @@ static u32 __bnge_rx_agg_netmems(struct bnge_net *bn,
static struct sk_buff *bnge_rx_agg_netmems_skb(struct bnge_net *bn,
struct bnge_cp_ring_info *cpr,
struct sk_buff *skb, u16 idx,
- u32 agg_bufs)
+ u32 agg_bufs, bool tpa)
{
u32 total_frag_len;
- total_frag_len = __bnge_rx_agg_netmems(bn, cpr, idx, agg_bufs, skb);
+ total_frag_len = __bnge_rx_agg_netmems(bn, cpr, idx, agg_bufs,
+ tpa, skb);
if (!total_frag_len) {
skb_mark_for_recycle(skb);
dev_kfree_skb(skb);
@@ -253,6 +272,165 @@ static void bnge_sched_reset_txr(struct bnge_net *bn,
/* TODO: Initiate reset task */
}
+static u16 bnge_tpa_alloc_agg_idx(struct bnge_rx_ring_info *rxr, u16 agg_id)
+{
+ struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
+ u16 idx = agg_id & MAX_TPA_MASK;
+
+ if (test_bit(idx, map->agg_idx_bmap)) {
+ idx = find_first_zero_bit(map->agg_idx_bmap, MAX_TPA);
+ if (idx >= MAX_TPA)
+ return INVALID_HW_RING_ID;
+ }
+ __set_bit(idx, map->agg_idx_bmap);
+ map->agg_id_tbl[agg_id] = idx;
+ return idx;
+}
+
+static void bnge_free_agg_idx(struct bnge_rx_ring_info *rxr, u16 idx)
+{
+ struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
+
+ __clear_bit(idx, map->agg_idx_bmap);
+}
+
+static u16 bnge_lookup_agg_idx(struct bnge_rx_ring_info *rxr, u16 agg_id)
+{
+ struct bnge_tpa_idx_map *map = rxr->rx_tpa_idx_map;
+
+ return map->agg_id_tbl[agg_id];
+}
+
+static void bnge_tpa_metadata(struct bnge_tpa_info *tpa_info,
+ struct rx_tpa_start_cmp *tpa_start,
+ struct rx_tpa_start_cmp_ext *tpa_start1)
+{
+ tpa_info->cfa_code_valid = 1;
+ tpa_info->cfa_code = TPA_START_CFA_CODE(tpa_start1);
+ tpa_info->vlan_valid = 0;
+ if (tpa_info->flags2 & RX_CMP_FLAGS2_META_FORMAT_VLAN) {
+ tpa_info->vlan_valid = 1;
+ tpa_info->metadata =
+ le32_to_cpu(tpa_start1->rx_tpa_start_cmp_metadata);
+ }
+}
+
+static void bnge_tpa_metadata_v2(struct bnge_tpa_info *tpa_info,
+ struct rx_tpa_start_cmp *tpa_start,
+ struct rx_tpa_start_cmp_ext *tpa_start1)
+{
+ tpa_info->vlan_valid = 0;
+ if (TPA_START_VLAN_VALID(tpa_start)) {
+ u32 tpid_sel = TPA_START_VLAN_TPID_SEL(tpa_start);
+ u32 vlan_proto = ETH_P_8021Q;
+
+ tpa_info->vlan_valid = 1;
+ if (tpid_sel == RX_TPA_START_METADATA1_TPID_8021AD)
+ vlan_proto = ETH_P_8021AD;
+ tpa_info->metadata = vlan_proto << 16 |
+ TPA_START_METADATA0_TCI(tpa_start1);
+ }
+}
+
+static void bnge_tpa_start(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
+ u8 cmp_type, struct rx_tpa_start_cmp *tpa_start,
+ struct rx_tpa_start_cmp_ext *tpa_start1)
+{
+ struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
+ struct bnge_tpa_info *tpa_info;
+ u16 cons, prod, agg_id;
+ struct rx_bd *prod_bd;
+ dma_addr_t mapping;
+
+ agg_id = TPA_START_AGG_ID(tpa_start);
+ agg_id = bnge_tpa_alloc_agg_idx(rxr, agg_id);
+ if (unlikely(agg_id == INVALID_HW_RING_ID)) {
+ netdev_warn(bn->netdev, "Unable to allocate agg ID for ring %d, agg 0x%x\n",
+ rxr->bnapi->index, TPA_START_AGG_ID(tpa_start));
+ bnge_sched_reset_rxr(bn, rxr);
+ return;
+ }
+ cons = tpa_start->rx_tpa_start_cmp_opaque;
+ prod = rxr->rx_prod;
+ cons_rx_buf = &rxr->rx_buf_ring[cons];
+ prod_rx_buf = &rxr->rx_buf_ring[RING_RX(bn, prod)];
+ tpa_info = &rxr->rx_tpa[agg_id];
+
+ if (unlikely(cons != rxr->rx_next_cons ||
+ TPA_START_ERROR(tpa_start))) {
+ netdev_warn(bn->netdev, "TPA cons %x, expected cons %x, error code %x\n",
+ cons, rxr->rx_next_cons,
+ TPA_START_ERROR_CODE(tpa_start1));
+ bnge_sched_reset_rxr(bn, rxr);
+ return;
+ }
+ prod_rx_buf->data = tpa_info->data;
+ prod_rx_buf->data_ptr = tpa_info->data_ptr;
+
+ mapping = tpa_info->mapping;
+ prod_rx_buf->mapping = mapping;
+
+ prod_bd = &rxr->rx_desc_ring[RX_RING(bn, prod)][RX_IDX(prod)];
+
+ prod_bd->rx_bd_haddr = cpu_to_le64(mapping);
+
+ tpa_info->data = cons_rx_buf->data;
+ tpa_info->data_ptr = cons_rx_buf->data_ptr;
+ cons_rx_buf->data = NULL;
+ tpa_info->mapping = cons_rx_buf->mapping;
+
+ tpa_info->len =
+ le32_to_cpu(tpa_start->rx_tpa_start_cmp_len_flags_type) >>
+ RX_TPA_START_CMP_LEN_SHIFT;
+ if (likely(TPA_START_HASH_VALID(tpa_start))) {
+ tpa_info->hash_type = PKT_HASH_TYPE_L4;
+ if (TPA_START_IS_IPV6(tpa_start1))
+ tpa_info->gso_type = SKB_GSO_TCPV6;
+ else
+ tpa_info->gso_type = SKB_GSO_TCPV4;
+ tpa_info->rss_hash =
+ le32_to_cpu(tpa_start->rx_tpa_start_cmp_rss_hash);
+ } else {
+ tpa_info->hash_type = PKT_HASH_TYPE_NONE;
+ tpa_info->gso_type = 0;
+ netif_warn(bn, rx_err, bn->netdev, "TPA packet without valid hash\n");
+ }
+ tpa_info->flags2 = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_flags2);
+ tpa_info->hdr_info = le32_to_cpu(tpa_start1->rx_tpa_start_cmp_hdr_info);
+ if (cmp_type == CMP_TYPE_RX_L2_TPA_START_CMP)
+ bnge_tpa_metadata(tpa_info, tpa_start, tpa_start1);
+ else
+ bnge_tpa_metadata_v2(tpa_info, tpa_start, tpa_start1);
+ tpa_info->agg_count = 0;
+
+ rxr->rx_prod = NEXT_RX(prod);
+ cons = RING_RX(bn, NEXT_RX(cons));
+ rxr->rx_next_cons = RING_RX(bn, NEXT_RX(cons));
+ cons_rx_buf = &rxr->rx_buf_ring[cons];
+
+ bnge_reuse_rx_data(rxr, cons, cons_rx_buf->data);
+ rxr->rx_prod = NEXT_RX(rxr->rx_prod);
+ cons_rx_buf->data = NULL;
+}
+
+static void bnge_abort_tpa(struct bnge_cp_ring_info *cpr, u16 idx, u32 agg_bufs)
+{
+ if (agg_bufs)
+ bnge_reuse_rx_agg_bufs(cpr, idx, 0, agg_bufs, true);
+}
+
+static void bnge_tpa_agg(struct bnge_net *bn, struct bnge_rx_ring_info *rxr,
+ struct rx_agg_cmp *rx_agg)
+{
+ u16 agg_id = TPA_AGG_AGG_ID(rx_agg);
+ struct bnge_tpa_info *tpa_info;
+
+ agg_id = bnge_lookup_agg_idx(rxr, agg_id);
+ tpa_info = &rxr->rx_tpa[agg_id];
+
+ tpa_info->agg_arr[tpa_info->agg_count++] = *rx_agg;
+}
+
void bnge_reuse_rx_data(struct bnge_rx_ring_info *rxr, u16 cons, void *data)
{
struct bnge_sw_rx_bd *cons_rx_buf, *prod_rx_buf;
@@ -307,6 +485,208 @@ static struct sk_buff *bnge_copy_skb(struct bnge_napi *bnapi, u8 *data,
return skb;
}
+#ifdef CONFIG_INET
+static void bnge_gro_tunnel(struct sk_buff *skb, __be16 ip_proto)
+{
+ struct udphdr *uh = NULL;
+
+ if (ip_proto == htons(ETH_P_IP)) {
+ struct iphdr *iph = (struct iphdr *)skb->data;
+
+ if (iph->protocol == IPPROTO_UDP)
+ uh = (struct udphdr *)(iph + 1);
+ } else {
+ struct ipv6hdr *iph = (struct ipv6hdr *)skb->data;
+
+ if (iph->nexthdr == IPPROTO_UDP)
+ uh = (struct udphdr *)(iph + 1);
+ }
+ if (uh) {
+ if (uh->check)
+ skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL_CSUM;
+ else
+ skb_shinfo(skb)->gso_type |= SKB_GSO_UDP_TUNNEL;
+ }
+}
+
+static struct sk_buff *bnge_gro_func(struct bnge_tpa_info *tpa_info,
+ int payload_off, int tcp_ts,
+ struct sk_buff *skb)
+{
+ u16 outer_ip_off, inner_ip_off, inner_mac_off;
+ u32 hdr_info = tpa_info->hdr_info;
+ int iphdr_len, nw_off;
+
+ inner_ip_off = BNGE_TPA_INNER_L3_OFF(hdr_info);
+ inner_mac_off = BNGE_TPA_INNER_L2_OFF(hdr_info);
+ outer_ip_off = BNGE_TPA_OUTER_L3_OFF(hdr_info);
+
+ nw_off = inner_ip_off - ETH_HLEN;
+ skb_set_network_header(skb, nw_off);
+ iphdr_len = (tpa_info->flags2 & RX_TPA_START_CMP_FLAGS2_IP_TYPE) ?
+ sizeof(struct ipv6hdr) : sizeof(struct iphdr);
+ skb_set_transport_header(skb, nw_off + iphdr_len);
+
+ if (inner_mac_off) { /* tunnel */
+ __be16 proto = *((__be16 *)(skb->data + outer_ip_off -
+ ETH_HLEN - 2));
+
+ bnge_gro_tunnel(skb, proto);
+ }
+
+ return skb;
+}
+
+static struct sk_buff *bnge_gro_skb(struct bnge_net *bn,
+ struct bnge_tpa_info *tpa_info,
+ struct rx_tpa_end_cmp *tpa_end,
+ struct rx_tpa_end_cmp_ext *tpa_end1,
+ struct sk_buff *skb)
+{
+ int payload_off;
+ u16 segs;
+
+ segs = TPA_END_TPA_SEGS(tpa_end);
+ if (segs == 1)
+ return skb;
+
+ NAPI_GRO_CB(skb)->count = segs;
+ skb_shinfo(skb)->gso_size =
+ le32_to_cpu(tpa_end1->rx_tpa_end_cmp_seg_len);
+ skb_shinfo(skb)->gso_type = tpa_info->gso_type;
+ payload_off = TPA_END_PAYLOAD_OFF(tpa_end1);
+ skb = bnge_gro_func(tpa_info, payload_off,
+ TPA_END_GRO_TS(tpa_end), skb);
+ if (likely(skb))
+ tcp_gro_complete(skb);
+
+ return skb;
+}
+#endif
+
+static struct sk_buff *bnge_tpa_end(struct bnge_net *bn,
+ struct bnge_cp_ring_info *cpr,
+ u32 *raw_cons,
+ struct rx_tpa_end_cmp *tpa_end,
+ struct rx_tpa_end_cmp_ext *tpa_end1,
+ u8 *event)
+{
+ struct bnge_napi *bnapi = cpr->bnapi;
+ struct net_device *dev = bn->netdev;
+ struct bnge_tpa_info *tpa_info;
+ struct bnge_rx_ring_info *rxr;
+ u8 *data_ptr, agg_bufs;
+ struct sk_buff *skb;
+ u16 idx = 0, agg_id;
+ dma_addr_t mapping;
+ unsigned int len;
+ void *data;
+
+ rxr = bnapi->rx_ring;
+ agg_id = TPA_END_AGG_ID(tpa_end);
+ agg_id = bnge_lookup_agg_idx(rxr, agg_id);
+ agg_bufs = TPA_END_AGG_BUFS(tpa_end1);
+ tpa_info = &rxr->rx_tpa[agg_id];
+ if (unlikely(agg_bufs != tpa_info->agg_count)) {
+ netdev_warn(bn->netdev, "TPA end agg_buf %d != expected agg_bufs %d\n",
+ agg_bufs, tpa_info->agg_count);
+ agg_bufs = tpa_info->agg_count;
+ }
+ tpa_info->agg_count = 0;
+ *event |= BNGE_AGG_EVENT;
+ bnge_free_agg_idx(rxr, agg_id);
+ idx = agg_id;
+ data = tpa_info->data;
+ data_ptr = tpa_info->data_ptr;
+ prefetch(data_ptr);
+ len = tpa_info->len;
+ mapping = tpa_info->mapping;
+
+ if (unlikely(agg_bufs > MAX_SKB_FRAGS || TPA_END_ERRORS(tpa_end1))) {
+ bnge_abort_tpa(cpr, idx, agg_bufs);
+ if (agg_bufs > MAX_SKB_FRAGS)
+ netdev_warn(bn->netdev, "TPA frags %d exceeded MAX_SKB_FRAGS %d\n",
+ agg_bufs, (int)MAX_SKB_FRAGS);
+ return NULL;
+ }
+
+ if (len <= bn->rx_copybreak) {
+ skb = bnge_copy_skb(bnapi, data_ptr, len, mapping);
+ if (!skb) {
+ bnge_abort_tpa(cpr, idx, agg_bufs);
+ return NULL;
+ }
+ } else {
+ dma_addr_t new_mapping;
+ u8 *new_data;
+
+ new_data = __bnge_alloc_rx_frag(bn, &new_mapping, rxr,
+ GFP_ATOMIC);
+ if (!new_data) {
+ bnge_abort_tpa(cpr, idx, agg_bufs);
+ return NULL;
+ }
+
+ tpa_info->data = new_data;
+ tpa_info->data_ptr = new_data + bn->rx_offset;
+ tpa_info->mapping = new_mapping;
+
+ skb = napi_build_skb(data, bn->rx_buf_size);
+ dma_sync_single_for_cpu(bn->bd->dev, mapping,
+ bn->rx_buf_use_size, bn->rx_dir);
+
+ if (!skb) {
+ page_pool_free_va(rxr->head_pool, data, true);
+ bnge_abort_tpa(cpr, idx, agg_bufs);
+ return NULL;
+ }
+ skb_mark_for_recycle(skb);
+ skb_reserve(skb, bn->rx_offset);
+ skb_put(skb, len);
+ }
+
+ if (agg_bufs) {
+ skb = bnge_rx_agg_netmems_skb(bn, cpr, skb, idx, agg_bufs,
+ true);
+ /* Page reuse already handled by bnge_rx_agg_netmems_skb(). */
+ if (!skb)
+ return NULL;
+ }
+
+ skb->protocol = eth_type_trans(skb, dev);
+
+ if (tpa_info->hash_type != PKT_HASH_TYPE_NONE)
+ skb_set_hash(skb, tpa_info->rss_hash, tpa_info->hash_type);
+
+ if (tpa_info->vlan_valid &&
+ (dev->features & BNGE_HW_FEATURE_VLAN_ALL_RX)) {
+ __be16 vlan_proto = htons(tpa_info->metadata >>
+ RX_CMP_FLAGS2_METADATA_TPID_SFT);
+ u16 vtag = tpa_info->metadata & RX_CMP_FLAGS2_METADATA_TCI_MASK;
+
+ if (eth_type_vlan(vlan_proto)) {
+ __vlan_hwaccel_put_tag(skb, vlan_proto, vtag);
+ } else {
+ dev_kfree_skb(skb);
+ return NULL;
+ }
+ }
+
+ skb_checksum_none_assert(skb);
+ if (likely(tpa_info->flags2 & RX_TPA_START_CMP_FLAGS2_L4_CS_CALC)) {
+ skb->ip_summed = CHECKSUM_UNNECESSARY;
+ skb->csum_level =
+ (tpa_info->flags2 & RX_CMP_FLAGS2_T_L4_CS_CALC) >> 3;
+ }
+
+#ifdef CONFIG_INET
+ if (bn->priv_flags & BNGE_NET_EN_GRO)
+ skb = bnge_gro_skb(bn, tpa_info, tpa_end, tpa_end1, skb);
+#endif
+
+ return skb;
+}
+
static enum pkt_hash_types bnge_rss_ext_op(struct bnge_net *bn,
struct rx_cmp *rxcmp)
{
@@ -400,6 +780,7 @@ static struct sk_buff *bnge_rx_skb(struct bnge_net *bn,
/* returns the following:
* 1 - 1 packet successfully received
+ * 0 - successful TPA_START, packet not completed yet
* -EBUSY - completion ring does not have all the agg buffers yet
* -ENOMEM - packet aborted due to out of memory
* -EIO - packet aborted due to hw error indicated in BD
@@ -432,6 +813,11 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
cmp_type = RX_CMP_TYPE(rxcmp);
+ if (cmp_type == CMP_TYPE_RX_TPA_AGG_CMP) {
+ bnge_tpa_agg(bn, rxr, (struct rx_agg_cmp *)rxcmp);
+ goto next_rx_no_prod_no_len;
+ }
+
tmp_raw_cons = NEXT_RAW_CMP(tmp_raw_cons);
cp_cons = RING_CMP(bn, tmp_raw_cons);
rxcmp1 = (struct rx_cmp_ext *)
@@ -446,6 +832,28 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
dma_rmb();
prod = rxr->rx_prod;
+ if (cmp_type == CMP_TYPE_RX_L2_TPA_START_CMP ||
+ cmp_type == CMP_TYPE_RX_L2_TPA_START_V3_CMP) {
+ bnge_tpa_start(bn, rxr, cmp_type,
+ (struct rx_tpa_start_cmp *)rxcmp,
+ (struct rx_tpa_start_cmp_ext *)rxcmp1);
+
+ *event |= BNGE_RX_EVENT;
+ goto next_rx_no_prod_no_len;
+
+ } else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
+ skb = bnge_tpa_end(bn, cpr, &tmp_raw_cons,
+ (struct rx_tpa_end_cmp *)rxcmp,
+ (struct rx_tpa_end_cmp_ext *)rxcmp1, event);
+ rc = -ENOMEM;
+ if (likely(skb)) {
+ bnge_deliver_skb(bn, bnapi, skb);
+ rc = 1;
+ }
+ *event |= BNGE_RX_EVENT;
+ goto next_rx_no_prod_no_len;
+ }
+
cons = rxcmp->rx_cmp_opaque;
if (unlikely(cons != rxr->rx_next_cons)) {
int rc1 = bnge_discard_rx(bn, cpr, &tmp_raw_cons, rxcmp);
@@ -480,7 +888,8 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
if (rxcmp1->rx_cmp_cfa_code_errors_v2 & RX_CMP_L2_ERRORS) {
bnge_reuse_rx_data(rxr, cons, data);
if (agg_bufs)
- bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0, agg_bufs);
+ bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0, agg_bufs,
+ false);
rc = -EIO;
goto next_rx_no_len;
}
@@ -495,7 +904,7 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
if (!skb) {
if (agg_bufs)
bnge_reuse_rx_agg_bufs(cpr, cp_cons, 0,
- agg_bufs);
+ agg_bufs, false);
goto oom_next_rx;
}
} else {
@@ -513,7 +922,7 @@ static int bnge_rx_pkt(struct bnge_net *bn, struct bnge_cp_ring_info *cpr,
if (agg_bufs) {
skb = bnge_rx_agg_netmems_skb(bn, cpr, skb, cp_cons,
- agg_bufs);
+ agg_bufs, false);
if (!skb)
goto oom_next_rx;
}
@@ -604,6 +1013,12 @@ static int bnge_force_rx_discard(struct bnge_net *bn,
cmp_type == CMP_TYPE_RX_L2_V3_CMP) {
rxcmp1->rx_cmp_cfa_code_errors_v2 |=
cpu_to_le32(RX_CMPL_ERRORS_CRC_ERROR);
+ } else if (cmp_type == CMP_TYPE_RX_L2_TPA_END_CMP) {
+ struct rx_tpa_end_cmp_ext *tpa_end1;
+
+ tpa_end1 = (struct rx_tpa_end_cmp_ext *)rxcmp1;
+ tpa_end1->rx_tpa_end_cmp_errors_v2 |=
+ cpu_to_le32(RX_TPA_END_CMP_ERRORS);
}
rc = bnge_rx_pkt(bn, cpr, raw_cons, event);
return rc;
--
2.47.3
^ permalink raw reply [flat|nested] 18+ messages in thread