* [PATCH net-next v5 00/10] add features to bnge
@ 2026-11-03 12:36 Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 01/10] bnge: restructure VNIC and filter code Vikas Gupta
` (9 more replies)
0 siblings, 10 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Hi,
This series adds ntuple filter, RSS context, and flow steering
support to bnge driver.
Patch 1 is a pure refactor (no functional change) that relocates the
filter and VNIC related code into the appropriate files. Patch 7 drops
the refcount usage from L2 filters, also with no functional change.
The subsequent patches then add the ethtool commands for configuring
ntuple flows and RSS contexts.
Thanks,
Vikas
v4->v5:
- Addressed comments from Sashiko
https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260928061307.1172344-1-vikas.gupta%40broadcom.com
v3->v4:
- Addressed comments from Sashiko
https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20260917064548.773334-1-vikas.gupta%40broadcom.com
https://sashiko.dev/#/patchset/20260917064548.773334-1-vikas.gupta%40broadcom.com
- The patch count drops to 10 now that the HSI patches have been merged.
v2->v3:
- Build fix.
- Addressed comments from Sashiko
https://sashiko.dev/#/patchset/20260908093053.2596020-1-vikas.gupta%40broadcom.com
Below Sashiko comments are not valid:
Patch-8:
Comment under bnge_toeplitz().
Explanation: bnge_toeplitz() is not used for aRFS.
Patch-9:
Comment regarding bnge_clear_usr_fltrs().
Explanation:
Both bnge_clear_usr_fltrs() (only invoked while the
interface is down) and bnge_grxclsrule() execute
under the netdev instance lock, so they are
serialized and never touch the filter list at the
same time.
Patch-10:
Comment "Does this direct dereference of the MAC
header need a linearization ...".
Explanation: ndo_rx_flow_steer runs on the RX path
after eth_type_trans(), which already accesses and
pulls the Ethernet header.
Comment Related to bnge_cfg_ntp_filters().
Explanation:
bnge_cfg_ntp_filters() runs from bnge_sp_task(),
which holds the netdev instance lock while executing.
v1->v2:
- Build fixes.
- Addressed comments from Sashiko
https://sashiko.dev/#/patchset/20260814011435.194631-1-vikas.gupta%40broadcom.com
Vikas Gupta (10):
bnge: restructure VNIC and filter code
bnge: add NTUPLE/ARFS VNIC
bnge: add helper functions for multi RSS contexts
bnge: add RXFH ethtool support
bnge: add ethtool support to manage RSS contexts
bnge: remove refcount from L2 filter
bnge: add NTUPLE filter infrastructure
bnge: add NTUPLE filter support in ethtool
bnge: add aRFS flow steering ndo support
bnge: add cpu_rmap support for IRQ affinity
drivers/net/ethernet/broadcom/bnge/Makefile | 4 +-
drivers/net/ethernet/broadcom/bnge/bnge.h | 13 +-
.../net/ethernet/broadcom/bnge/bnge_ethtool.c | 1126 +++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_filter.c | 775 ++++++++++++
.../net/ethernet/broadcom/bnge/bnge_filter.h | 129 ++
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 170 ++-
.../ethernet/broadcom/bnge/bnge_hwrm_lib.h | 8 +
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 513 +++++---
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 94 +-
.../net/ethernet/broadcom/bnge/bnge_resc.c | 128 +-
.../net/ethernet/broadcom/bnge/bnge_resc.h | 1 +
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 378 ++++++
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 96 ++
13 files changed, 3115 insertions(+), 320 deletions(-)
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_filter.c
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_filter.h
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 01/10] bnge: restructure VNIC and filter code
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 02/10] bnge: add NTUPLE/ARFS VNIC Vikas Gupta
` (8 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Move VNIC and L2 filter code out of bnge_netdev.c into dedicated
bnge_vnic.c/h and bnge_filter.c/h files in preparation for multi-VNIC,
RSS context, and NTUPLE filter support.
This is a code reorganization with no functional change, which helps
centralize the functions into their respective modules.
The move comes with a few small cleanups:
- The BNGE_FLTR_TYPE_*, BNGE_FLTR_* state and BNGE_VNIC_*_FLAG macros
become enums with new values. None of them reaches firmware, and all
users are inside the driver.
- struct bnge_filter_base members hash and list are renamed to hlist
and list_node.
- bnge_rss_ctxs_in_use() is renamed to bnge_get_total_rss_ctxs(), and
bnge_get_total_vnics() no longer takes the rx_rings argument.
- bnge_fill_hw_rss_tbl() and bnge_set_dflt_rss_indir_tbl() use u16
indexes and temporaries; the values fit.
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
---
drivers/net/ethernet/broadcom/bnge/Makefile | 4 +-
drivers/net/ethernet/broadcom/bnge/bnge.h | 7 -
.../net/ethernet/broadcom/bnge/bnge_filter.c | 113 ++++++++++++
.../net/ethernet/broadcom/bnge/bnge_filter.h | 58 ++++++
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 2 +
.../ethernet/broadcom/bnge/bnge_hwrm_lib.h | 2 +
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 170 +-----------------
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 72 --------
.../net/ethernet/broadcom/bnge/bnge_resc.c | 31 +---
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 100 +++++++++++
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 63 +++++++
11 files changed, 350 insertions(+), 272 deletions(-)
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_filter.c
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_filter.h
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
create mode 100644 drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
diff --git a/drivers/net/ethernet/broadcom/bnge/Makefile b/drivers/net/ethernet/broadcom/bnge/Makefile
index 8e07cb307d21..d0a3cb24dc1d 100644
--- a/drivers/net/ethernet/broadcom/bnge/Makefile
+++ b/drivers/net/ethernet/broadcom/bnge/Makefile
@@ -12,4 +12,6 @@ bng_en-y := bnge_core.o \
bnge_ethtool.o \
bnge_auxr.o \
bnge_txrx.o \
- bnge_link.o
+ bnge_link.o \
+ bnge_vnic.o \
+ bnge_filter.o
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge.h b/drivers/net/ethernet/broadcom/bnge/bnge.h
index 4479ccd071f5..bde54ba5d50f 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge.h
@@ -163,13 +163,6 @@ struct bnge_dev {
#define BNGE_L2_FLTR_MAX_FLTR 1024
u32 *rss_indir_tbl;
-#define BNGE_RSS_TABLE_ENTRIES 64
-#define BNGE_RSS_TABLE_SIZE (BNGE_RSS_TABLE_ENTRIES * 4)
-#define BNGE_RSS_TABLE_MAX_TBL 8
-#define BNGE_MAX_RSS_TABLE_SIZE \
- (BNGE_RSS_TABLE_SIZE * BNGE_RSS_TABLE_MAX_TBL)
-#define BNGE_MAX_RSS_TABLE_ENTRIES \
- (BNGE_RSS_TABLE_ENTRIES * BNGE_RSS_TABLE_MAX_TBL)
u16 rss_indir_tbl_entries;
u32 rss_cap;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
new file mode 100644
index 000000000000..a8bb441ebef9
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2026 Broadcom.
+
+#include <linux/kernel.h>
+#include <linux/dma-mapping.h>
+#include <linux/jhash.h>
+
+#include "bnge.h"
+#include "bnge_netdev.h"
+#include "bnge_vnic.h"
+#include "bnge_hwrm_lib.h"
+#include "bnge_filter.h"
+
+void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr)
+{
+ if (!refcount_dec_and_test(&fltr->refcnt))
+ return;
+ hlist_del_rcu(&fltr->base.hlist);
+ kfree_rcu(fltr, base.rcu);
+}
+
+static void bnge_init_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_filter *fltr,
+ struct bnge_l2_key *key, u32 idx)
+{
+ struct hlist_head *head;
+
+ ether_addr_copy(fltr->l2_key.dst_mac_addr, key->dst_mac_addr);
+ fltr->l2_key.vlan = key->vlan;
+ fltr->base.type = BNGE_FLTR_TYPE_L2;
+
+ head = &bn->l2_fltr_hash_tbl[idx];
+ hlist_add_head_rcu(&fltr->base.hlist, head);
+ refcount_set(&fltr->refcnt, 1);
+}
+
+static struct bnge_l2_filter *__bnge_lookup_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u32 idx)
+{
+ struct bnge_l2_filter *fltr;
+ struct hlist_head *head;
+
+ head = &bn->l2_fltr_hash_tbl[idx];
+ hlist_for_each_entry_rcu(fltr, head, base.hlist) {
+ struct bnge_l2_key *l2_key = &fltr->l2_key;
+
+ if (ether_addr_equal(l2_key->dst_mac_addr, key->dst_mac_addr) &&
+ l2_key->vlan == key->vlan)
+ return fltr;
+ }
+ return NULL;
+}
+
+static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u32 idx)
+{
+ struct bnge_l2_filter *fltr;
+
+ rcu_read_lock();
+ fltr = __bnge_lookup_l2_filter(bn, key, idx);
+ if (fltr)
+ refcount_inc(&fltr->refcnt);
+ rcu_read_unlock();
+ return fltr;
+}
+
+static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ gfp_t gfp)
+{
+ struct bnge_l2_filter *fltr;
+ u32 idx;
+
+ idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
+ BNGE_L2_FLTR_HASH_MASK;
+ fltr = bnge_lookup_l2_filter(bn, key, idx);
+ if (fltr)
+ return fltr;
+
+ fltr = kzalloc_obj(*fltr, gfp);
+ if (!fltr)
+ return ERR_PTR(-ENOMEM);
+
+ bnge_init_l2_filter(bn, fltr, key, idx);
+ return fltr;
+}
+
+int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
+ const u8 *mac_addr)
+{
+ struct bnge_l2_filter *fltr;
+ struct bnge_l2_key key;
+ int rc;
+
+ ether_addr_copy(key.dst_mac_addr, mac_addr);
+ key.vlan = 0;
+ fltr = bnge_alloc_l2_filter(bn, &key, GFP_KERNEL);
+ if (IS_ERR(fltr))
+ return PTR_ERR(fltr);
+
+ fltr->base.fw_vnic_id = bn->vnic_info[vnic_id].fw_vnic_id;
+ rc = bnge_hwrm_l2_filter_alloc(bn->bd, fltr);
+ if (rc)
+ goto err_del_l2_filter;
+ bn->vnic_info[vnic_id].l2_filters[idx] = fltr;
+ return rc;
+
+err_del_l2_filter:
+ bnge_del_l2_filter(bn, fltr);
+ return rc;
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
new file mode 100644
index 000000000000..ea1acefd70b4
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
@@ -0,0 +1,58 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2026 Broadcom */
+
+#ifndef _BNGE_FILTER_H_
+#define _BNGE_FILTER_H_
+
+#include <linux/types.h>
+#include <linux/if_ether.h>
+#include <linux/refcount.h>
+#include <linux/jhash.h>
+
+struct bnge_net;
+
+enum {
+ BNGE_FLTR_TYPE_L2 = 1
+};
+
+enum {
+ BNGE_FLTR_VALID,
+ BNGE_FLTR_FW_DELETED
+};
+
+struct bnge_filter_base {
+ struct hlist_node hlist;
+ struct list_head list_node;
+ __le64 filter_id;
+ u8 type;
+ u8 flags;
+ u16 rxq;
+ u16 fw_vnic_id;
+ u16 vf_idx;
+ unsigned long state;
+
+ struct rcu_head rcu;
+};
+
+struct bnge_l2_key {
+ union {
+ struct {
+ u8 dst_mac_addr[ETH_ALEN];
+ u16 vlan;
+ };
+ u32 filter_key;
+ };
+};
+
+#define BNGE_L2_KEY_SIZE (sizeof(struct bnge_l2_key) / 4)
+struct bnge_l2_filter {
+ /* base filter must be the first member */
+ struct bnge_filter_base base;
+ struct bnge_l2_key l2_key;
+ refcount_t refcnt;
+};
+
+void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr);
+int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
+ const u8 *mac_addr);
+#endif /* _BNGE_FILTER_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index 651c5e783516..91d246c8dcf2 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -15,6 +15,8 @@
#include "bnge_rmem.h"
#include "bnge_resc.h"
#include "bnge_netdev.h"
+#include "bnge_vnic.h"
+#include "bnge_filter.h"
static const u16 bnge_async_events_arr[] = {
ASYNC_EVENT_CMPL_EVENT_ID_LINK_STATUS_CHANGE,
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
index bf452e390d5b..ae03041c36ac 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
@@ -4,6 +4,8 @@
#ifndef _BNGE_HWRM_LIB_H_
#define _BNGE_HWRM_LIB_H_
+struct bnge_l2_filter;
+
#define BNGE_PLC_EN_JUMBO_THRES_VALID \
VNIC_PLCMODES_CFG_REQ_ENABLES_JUMBO_THRESH_VALID
#define BNGE_PLC_EN_HDS_THRES_VALID \
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 25f844e6f6d3..31ca314fd52b 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -25,6 +25,8 @@
#include "bnge_ethtool.h"
#include "bnge_rmem.h"
#include "bnge_txrx.h"
+#include "bnge_vnic.h"
+#include "bnge_filter.h"
#define BNGE_RING_TO_TC_OFF(bd, tx) \
((tx) % (bd)->tx_nr_rings_per_tc)
@@ -1999,174 +2001,6 @@ static int bnge_hwrm_ring_alloc(struct bnge_net *bn)
return rc;
}
-void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic)
-{
- __le16 *ring_tbl = vnic->rss_table;
- struct bnge_rx_ring_info *rxr;
- struct bnge_dev *bd = bn->bd;
- u16 tbl_size, i;
-
- tbl_size = bnge_get_rxfh_indir_size(bd);
-
- for (i = 0; i < tbl_size; i++) {
- u32 j;
-
- j = bd->rss_indir_tbl[i];
- rxr = &bn->rx_ring[j];
-
- *ring_tbl++ = cpu_to_le16(rxr->rx_ring_struct.fw_ring_id);
- *ring_tbl++ = cpu_to_le16(bnge_cp_ring_for_rx(rxr));
- }
-}
-
-static int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
- struct bnge_vnic_info *vnic)
-{
- int rc;
-
- rc = bnge_hwrm_vnic_set_rss(bn, vnic, true);
- if (rc) {
- netdev_err(bn->netdev, "hwrm vnic %d set rss failure rc: %d\n",
- vnic->vnic_id, rc);
- return rc;
- }
- rc = bnge_hwrm_vnic_cfg(bn, vnic);
- if (rc)
- netdev_err(bn->netdev, "hwrm vnic %d cfg failure rc: %d\n",
- vnic->vnic_id, rc);
- return rc;
-}
-
-static int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic)
-{
- struct bnge_dev *bd = bn->bd;
- int rc, i, nr_ctxs;
-
- nr_ctxs = bnge_cal_nr_rss_ctxs(bd->rx_nr_rings);
- for (i = 0; i < nr_ctxs; i++) {
- rc = bnge_hwrm_vnic_ctx_alloc(bd, vnic, i);
- if (rc) {
- netdev_err(bn->netdev, "hwrm vnic %d ctx %d alloc failure rc: %d\n",
- vnic->vnic_id, i, rc);
- return -ENOMEM;
- }
- bn->rsscos_nr_ctxs++;
- }
-
- rc = bnge_hwrm_vnic_rss_cfg(bn, vnic);
- if (rc)
- return rc;
-
- if (bnge_is_agg_reqd(bd)) {
- rc = bnge_hwrm_vnic_set_hds(bn, vnic);
- if (rc)
- netdev_err(bn->netdev, "hwrm vnic %d set hds failure rc: %d\n",
- vnic->vnic_id, rc);
- }
- return rc;
-}
-
-static void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr)
-{
- if (!refcount_dec_and_test(&fltr->refcnt))
- return;
- hlist_del_rcu(&fltr->base.hash);
- kfree_rcu(fltr, base.rcu);
-}
-
-static void bnge_init_l2_filter(struct bnge_net *bn,
- struct bnge_l2_filter *fltr,
- struct bnge_l2_key *key, u32 idx)
-{
- struct hlist_head *head;
-
- ether_addr_copy(fltr->l2_key.dst_mac_addr, key->dst_mac_addr);
- fltr->l2_key.vlan = key->vlan;
- fltr->base.type = BNGE_FLTR_TYPE_L2;
-
- head = &bn->l2_fltr_hash_tbl[idx];
- hlist_add_head_rcu(&fltr->base.hash, head);
- refcount_set(&fltr->refcnt, 1);
-}
-
-static struct bnge_l2_filter *__bnge_lookup_l2_filter(struct bnge_net *bn,
- struct bnge_l2_key *key,
- u32 idx)
-{
- struct bnge_l2_filter *fltr;
- struct hlist_head *head;
-
- head = &bn->l2_fltr_hash_tbl[idx];
- hlist_for_each_entry_rcu(fltr, head, base.hash) {
- struct bnge_l2_key *l2_key = &fltr->l2_key;
-
- if (ether_addr_equal(l2_key->dst_mac_addr, key->dst_mac_addr) &&
- l2_key->vlan == key->vlan)
- return fltr;
- }
- return NULL;
-}
-
-static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
- struct bnge_l2_key *key,
- u32 idx)
-{
- struct bnge_l2_filter *fltr;
-
- rcu_read_lock();
- fltr = __bnge_lookup_l2_filter(bn, key, idx);
- if (fltr)
- refcount_inc(&fltr->refcnt);
- rcu_read_unlock();
- return fltr;
-}
-
-static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
- struct bnge_l2_key *key,
- gfp_t gfp)
-{
- struct bnge_l2_filter *fltr;
- u32 idx;
-
- idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
- BNGE_L2_FLTR_HASH_MASK;
- fltr = bnge_lookup_l2_filter(bn, key, idx);
- if (fltr)
- return fltr;
-
- fltr = kzalloc_obj(*fltr, gfp);
- if (!fltr)
- return ERR_PTR(-ENOMEM);
-
- bnge_init_l2_filter(bn, fltr, key, idx);
- return fltr;
-}
-
-static int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
- const u8 *mac_addr)
-{
- struct bnge_l2_filter *fltr;
- struct bnge_l2_key key;
- int rc;
-
- ether_addr_copy(key.dst_mac_addr, mac_addr);
- key.vlan = 0;
- fltr = bnge_alloc_l2_filter(bn, &key, GFP_KERNEL);
- if (IS_ERR(fltr))
- return PTR_ERR(fltr);
-
- fltr->base.fw_vnic_id = bn->vnic_info[vnic_id].fw_vnic_id;
- rc = bnge_hwrm_l2_filter_alloc(bn->bd, fltr);
- if (rc)
- goto err_del_l2_filter;
- bn->vnic_info[vnic_id].l2_filters[idx] = fltr;
- return rc;
-
-err_del_l2_filter:
- bnge_del_l2_filter(bn, fltr);
- return rc;
-}
-
static bool bnge_mc_list_updated(struct bnge_net *bn, u32 *rx_mask,
const struct netdev_hw_addr_list *mc)
{
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 476b5bab96fe..ee649cc644db 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -558,8 +558,6 @@ struct bnge_napi {
};
#define INVALID_STATS_CTX_ID -1
-#define BNGE_VNIC_DEFAULT 0
-#define BNGE_MAX_UC_ADDRS 4
#define BNGE_RX_MASK_CFG_FLAGS \
(CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS | \
@@ -567,78 +565,8 @@ struct bnge_napi {
CFA_L2_SET_RX_MASK_REQ_MASK_ALL_MCAST | \
CFA_L2_SET_RX_MASK_REQ_MASK_BCAST)
-struct bnge_vnic_info {
- u16 fw_vnic_id;
-#define BNGE_MAX_CTX_PER_VNIC 8
- u16 fw_rss_cos_lb_ctx[BNGE_MAX_CTX_PER_VNIC];
- u16 mru;
- /* index 0 always dev_addr */
- struct bnge_l2_filter *l2_filters[BNGE_MAX_UC_ADDRS];
- u16 uc_filter_count;
- u8 *uc_list;
- dma_addr_t rss_table_dma_addr;
- __le16 *rss_table;
- dma_addr_t rss_hash_key_dma_addr;
- u64 *rss_hash_key;
- int rss_table_size;
-#define BNGE_RSS_TABLE_ENTRIES 64
-#define BNGE_RSS_TABLE_SIZE (BNGE_RSS_TABLE_ENTRIES * 4)
-#define BNGE_RSS_TABLE_MAX_TBL 8
-#define BNGE_MAX_RSS_TABLE_SIZE \
- (BNGE_RSS_TABLE_SIZE * BNGE_RSS_TABLE_MAX_TBL)
- u32 rx_mask;
-
- u8 *mc_list;
- int mc_list_size;
- int mc_list_count;
- dma_addr_t mc_list_mapping;
-#define BNGE_MAX_MC_ADDRS 16
-
- u32 flags;
-#define BNGE_VNIC_RSS_FLAG 1
-#define BNGE_VNIC_MCAST_FLAG 4
-#define BNGE_VNIC_UCAST_FLAG 8
- u32 vnic_id;
-};
-
-struct bnge_filter_base {
- struct hlist_node hash;
- struct list_head list;
- __le64 filter_id;
- u8 type;
-#define BNGE_FLTR_TYPE_L2 2
- u8 flags;
- u16 rxq;
- u16 fw_vnic_id;
- u16 vf_idx;
- unsigned long state;
-#define BNGE_FLTR_VALID 0
-#define BNGE_FLTR_FW_DELETED 2
-
- struct rcu_head rcu;
-};
-
-struct bnge_l2_key {
- union {
- struct {
- u8 dst_mac_addr[ETH_ALEN];
- u16 vlan;
- };
- u32 filter_key;
- };
-};
-
-#define BNGE_L2_KEY_SIZE (sizeof(struct bnge_l2_key) / 4)
-struct bnge_l2_filter {
- /* base filter must be the first member */
- struct bnge_filter_base base;
- struct bnge_l2_key l2_key;
- refcount_t refcnt;
-};
-
u32 bnge_cp_ring_for_rx(struct bnge_rx_ring_info *rxr);
u32 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);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
index 65ef34536e36..21f55ea056f4 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
@@ -11,6 +11,7 @@
#include "bnge_hwrm.h"
#include "bnge_hwrm_lib.h"
#include "bnge_resc.h"
+#include "bnge_vnic.h"
static u16 bnge_num_tx_to_cp(struct bnge_dev *bd, u16 tx)
{
@@ -187,13 +188,13 @@ int bnge_cal_nr_rss_ctxs(u16 rx_rings)
BNGE_RSS_TABLE_MAX_TBL);
}
-static u16 bnge_rss_ctxs_in_use(struct bnge_dev *bd,
- struct bnge_hw_rings *hwr)
+static u16 bnge_get_total_rss_ctxs(struct bnge_dev *bd,
+ struct bnge_hw_rings *hwr)
{
return bnge_cal_nr_rss_ctxs(hwr->grp);
}
-static u16 bnge_get_total_vnics(struct bnge_dev *bd, u16 rx_rings)
+static u16 bnge_get_total_vnics(struct bnge_dev *bd)
{
return 1;
}
@@ -204,24 +205,6 @@ u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd)
BNGE_RSS_TABLE_ENTRIES;
}
-static void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd)
-{
- u16 max_entries, pad;
- u32 *rss_indir_tbl;
- int i;
-
- max_entries = bnge_get_rxfh_indir_size(bd);
- rss_indir_tbl = &bd->rss_indir_tbl[0];
-
- for (i = 0; i < max_entries; i++)
- rss_indir_tbl[i] = ethtool_rxfh_indir_default(i,
- bd->rx_nr_rings);
-
- pad = bd->rss_indir_tbl_entries - max_entries;
- if (pad)
- memset(&rss_indir_tbl[i], 0, pad * sizeof(*rss_indir_tbl));
-}
-
static void bnge_copy_reserved_rings(struct bnge_dev *bd,
struct bnge_hw_rings *hwr)
{
@@ -254,7 +237,7 @@ static bool bnge_need_reserve_rings(struct bnge_dev *bd)
if (hw_resc->resv_tx_rings != bd->tx_nr_rings)
return true;
- vnic = bnge_get_total_vnics(bd, rx);
+ vnic = bnge_get_total_vnics(bd);
if (bnge_is_agg_reqd(bd))
rx <<= 1;
@@ -300,12 +283,12 @@ int bnge_reserve_rings(struct bnge_dev *bd)
sh = true;
hwr.cmpl = hwr.rx + hwr.tx;
- hwr.vnic = bnge_get_total_vnics(bd, hwr.rx);
+ hwr.vnic = bnge_get_total_vnics(bd);
if (bnge_is_agg_reqd(bd))
hwr.rx <<= 1;
hwr.grp = bd->rx_nr_rings;
- hwr.rss_ctx = bnge_rss_ctxs_in_use(bd, &hwr);
+ hwr.rss_ctx = bnge_get_total_rss_ctxs(bd, &hwr);
hwr.stat = bnge_func_stat_ctxs_demand(bd);
old_rx_rings = bd->hw_resc.resv_rx_rings;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
new file mode 100644
index 000000000000..3a6c8f0a5954
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: GPL-2.0
+// Copyright (c) 2026 Broadcom.
+
+#include <linux/kernel.h>
+#include <linux/dma-mapping.h>
+#include <linux/ethtool.h>
+
+#include "bnge.h"
+#include "bnge_netdev.h"
+#include "bnge_vnic.h"
+#include "bnge_hwrm_lib.h"
+#include "bnge_filter.h"
+#include "bnge_resc.h"
+
+void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd)
+{
+ u16 max_entries, pad;
+ u32 *rss_indir_tbl;
+ u16 i;
+
+ max_entries = bnge_get_rxfh_indir_size(bd);
+ rss_indir_tbl = &bd->rss_indir_tbl[0];
+
+ for (i = 0; i < max_entries; i++)
+ rss_indir_tbl[i] = ethtool_rxfh_indir_default(i,
+ bd->rx_nr_rings);
+
+ pad = bd->rss_indir_tbl_entries - max_entries;
+ if (pad)
+ memset(&rss_indir_tbl[i], 0, pad * sizeof(*rss_indir_tbl));
+}
+
+void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic)
+{
+ __le16 *ring_tbl = vnic->rss_table;
+ struct bnge_rx_ring_info *rxr;
+ struct bnge_dev *bd = bn->bd;
+ u16 tbl_size, i;
+
+ tbl_size = bnge_get_rxfh_indir_size(bd);
+
+ for (i = 0; i < tbl_size; i++) {
+ u16 ring_id, j;
+
+ j = bd->rss_indir_tbl[i];
+ rxr = &bn->rx_ring[j];
+
+ ring_id = rxr->rx_ring_struct.fw_ring_id;
+ *ring_tbl++ = cpu_to_le16(ring_id);
+ ring_id = bnge_cp_ring_for_rx(rxr);
+ *ring_tbl++ = cpu_to_le16(ring_id);
+ }
+}
+
+int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
+ struct bnge_vnic_info *vnic)
+{
+ int rc;
+
+ rc = bnge_hwrm_vnic_set_rss(bn, vnic, true);
+ if (rc) {
+ netdev_err(bn->netdev, "hwrm vnic %d set rss failure rc: %d\n",
+ vnic->vnic_id, rc);
+ return rc;
+ }
+ rc = bnge_hwrm_vnic_cfg(bn, vnic);
+ if (rc)
+ netdev_err(bn->netdev, "hwrm vnic %d cfg failure rc: %d\n",
+ vnic->vnic_id, rc);
+ return rc;
+}
+
+int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic)
+{
+ struct bnge_dev *bd = bn->bd;
+ int rc, i, nr_ctxs;
+
+ nr_ctxs = bnge_cal_nr_rss_ctxs(bd->rx_nr_rings);
+ for (i = 0; i < nr_ctxs; i++) {
+ rc = bnge_hwrm_vnic_ctx_alloc(bd, vnic, i);
+ if (rc) {
+ netdev_err(bn->netdev, "hwrm vnic %d ctx %d alloc failure rc: %d\n",
+ vnic->vnic_id, i, rc);
+ return -ENOMEM;
+ }
+ bn->rsscos_nr_ctxs++;
+ }
+
+ rc = bnge_hwrm_vnic_rss_cfg(bn, vnic);
+ if (rc)
+ return rc;
+
+ if (bnge_is_agg_reqd(bd)) {
+ rc = bnge_hwrm_vnic_set_hds(bn, vnic);
+ if (rc)
+ netdev_err(bn->netdev, "hwrm vnic %d set hds failure rc: %d\n",
+ vnic->vnic_id, rc);
+ }
+ return rc;
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
new file mode 100644
index 000000000000..c81d3a64561e
--- /dev/null
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -0,0 +1,63 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2026 Broadcom */
+
+#ifndef _BNGE_VNIC_H_
+#define _BNGE_VNIC_H_
+
+struct bnge_net;
+struct bnge_dev;
+struct bnge_l2_filter;
+
+#define BNGE_RSS_TABLE_ENTRIES 64
+#define BNGE_RSS_TABLE_SIZE (BNGE_RSS_TABLE_ENTRIES * 4)
+#define BNGE_RSS_TABLE_MAX_TBL 8
+#define BNGE_MAX_RSS_TABLE_SIZE \
+ (BNGE_RSS_TABLE_SIZE * BNGE_RSS_TABLE_MAX_TBL)
+#define BNGE_MAX_RSS_TABLE_ENTRIES \
+ (BNGE_RSS_TABLE_ENTRIES * BNGE_RSS_TABLE_MAX_TBL)
+
+#define BNGE_MAX_CTX_PER_VNIC 8
+
+#define BNGE_MAX_MC_ADDRS 16
+#define BNGE_MAX_UC_ADDRS 4
+
+enum {
+ BNGE_VNIC_DEFAULT = 0
+};
+
+enum {
+ BNGE_VNIC_RSS_FLAG = BIT(0),
+ BNGE_VNIC_MCAST_FLAG = BIT(1),
+ BNGE_VNIC_UCAST_FLAG = BIT(2)
+};
+
+struct bnge_vnic_info {
+ u16 fw_vnic_id;
+ u16 fw_rss_cos_lb_ctx[BNGE_MAX_CTX_PER_VNIC];
+ u16 mru;
+ /* index 0 always dev_addr */
+ struct bnge_l2_filter *l2_filters[BNGE_MAX_UC_ADDRS];
+ u16 uc_filter_count;
+ u8 *uc_list;
+ dma_addr_t rss_table_dma_addr;
+ __le16 *rss_table;
+ dma_addr_t rss_hash_key_dma_addr;
+ u64 *rss_hash_key;
+ int rss_table_size;
+ u32 rx_mask;
+
+ u8 *mc_list;
+ int mc_list_size;
+ int mc_list_count;
+ dma_addr_t mc_list_mapping;
+
+ u32 flags;
+ u32 vnic_id;
+};
+
+void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic);
+int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
+ struct bnge_vnic_info *vnic);
+int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic);
+void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd);
+#endif /* _BNGE_VNIC_H_ */
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 02/10] bnge: add NTUPLE/ARFS VNIC
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 01/10] bnge: restructure VNIC and filter code Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 03/10] bnge: add helper functions for multi RSS contexts Vikas Gupta
` (7 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Initialize the second VNIC, which is specifically used for the
NTUPLE/ARFS feature. This VNIC helps support the aRFS/NTUPLE
functionality. With this change, the total number of VNICs becomes 2.
Add bnge_set_dflt_rfs() to configure the default NTUPLE feature state
at netdev allocation time.
The NTUPLE/aRFS VNIC is always allocated, so the function needs at
least BNGE_BASE_VNICS (2) VNICs and the matching RSS contexts.
Firmware grants these to every supported function. If it grants fewer,
bnge_reserve_rings() fails with -ENOMEM and the device does not probe,
as it would for any other missing ring resource.
The patch also removes BNGE_FW_CAP_CFA_NTUPLE_RX_EXT_IP_PROTO and
BNGE_FW_CAP_CFA_RFS_RING_TBL_IDX_V3, which nothing uses, and renumbers
BNGE_FW_CAP_VNIC_RE_FLUSH from BIT_ULL(26) to BIT_ULL(24).
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
drivers/net/ethernet/broadcom/bnge/bnge.h | 4 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 58 +++++++++++++++++--
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 1 +
.../net/ethernet/broadcom/bnge/bnge_resc.c | 21 ++++---
.../net/ethernet/broadcom/bnge/bnge_resc.h | 1 +
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 33 ++++++++++-
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 8 ++-
7 files changed, 107 insertions(+), 19 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge.h b/drivers/net/ethernet/broadcom/bnge/bnge.h
index bde54ba5d50f..3e8210626062 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge.h
@@ -63,9 +63,7 @@ enum {
BNGE_FW_CAP_THRESHOLD_TEMP_SUPPORTED = BIT_ULL(21),
BNGE_FW_CAP_DFLT_VLAN_TPID_PCP = BIT_ULL(22),
BNGE_FW_CAP_VNIC_TUNNEL_TPA = BIT_ULL(23),
- BNGE_FW_CAP_CFA_NTUPLE_RX_EXT_IP_PROTO = BIT_ULL(24),
- BNGE_FW_CAP_CFA_RFS_RING_TBL_IDX_V3 = BIT_ULL(25),
- BNGE_FW_CAP_VNIC_RE_FLUSH = BIT_ULL(26),
+ BNGE_FW_CAP_VNIC_RE_FLUSH = BIT_ULL(24),
};
enum {
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 31ca314fd52b..3248aae88c8d 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -1149,12 +1149,7 @@ static int bnge_alloc_vnic_attributes(struct bnge_net *bn)
static int bnge_alloc_vnics(struct bnge_net *bn)
{
- int num_vnics;
-
- /* Allocate only 1 VNIC for now
- * Additional VNICs will be added based on RFS/NTUPLE in future patches
- */
- num_vnics = 1;
+ int num_vnics = BNGE_BASE_VNICS;
bn->vnic_info = kzalloc_objs(struct bnge_vnic_info, num_vnics);
if (!bn->vnic_info)
@@ -1320,6 +1315,9 @@ static int bnge_alloc_core(struct bnge_net *bn)
bn->vnic_info[BNGE_VNIC_DEFAULT].flags |= BNGE_VNIC_RSS_FLAG |
BNGE_VNIC_MCAST_FLAG |
BNGE_VNIC_UCAST_FLAG;
+ bn->vnic_info[BNGE_VNIC_NTUPLE].flags |= BNGE_VNIC_RSS_FLAG |
+ BNGE_VNIC_NTUPLE_FLAG;
+
rc = bnge_alloc_vnic_attributes(bn);
if (rc)
goto err_free_nq_tree;
@@ -2578,6 +2576,13 @@ static int bnge_init_chip(struct bnge_net *bn)
if (rc)
goto err_out;
+ rc = bnge_alloc_rfs_vnic(bn);
+ if (rc) {
+ netdev_err(bn->netdev,
+ "hwrm aRFS vnic alloc failure rc: %d\n", rc);
+ goto err_out;
+ }
+
if (bd->rss_cap & BNGE_RSS_CAP_RSS_HASH_TYPE_DELTA)
bnge_hwrm_update_rss_hash_cfg(bn);
@@ -3133,6 +3138,36 @@ static const struct netdev_stat_ops bnge_stat_ops = {
.get_base_stats = bnge_get_base_stats,
};
+static netdev_features_t bnge_fix_features(struct net_device *dev,
+ netdev_features_t features)
+{
+ /* NTUPLE can only be changed while the interface is down. */
+ if (netif_running(dev)) {
+ if (dev->features & NETIF_F_NTUPLE)
+ features |= NETIF_F_NTUPLE;
+ else
+ features &= ~NETIF_F_NTUPLE;
+ }
+ return features;
+}
+
+static int bnge_set_features(struct net_device *dev, netdev_features_t features)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ u32 flags = bn->priv_flags;
+
+ flags &= ~BNGE_NET_EN_NTUPLE;
+ if (features & NETIF_F_NTUPLE)
+ flags |= BNGE_NET_EN_NTUPLE;
+
+ if (flags == bn->priv_flags)
+ return 0;
+
+ bn->priv_flags = flags;
+
+ return 0;
+}
+
static const struct net_device_ops bnge_netdev_ops = {
.ndo_open = bnge_open,
.ndo_stop = bnge_close,
@@ -3140,6 +3175,8 @@ static const struct net_device_ops bnge_netdev_ops = {
.ndo_get_stats64 = bnge_get_stats64,
.ndo_set_rx_mode_async = bnge_set_rx_mode,
.ndo_features_check = bnge_features_check,
+ .ndo_fix_features = bnge_fix_features,
+ .ndo_set_features = bnge_set_features,
};
static void bnge_init_mac_addr(struct bnge_dev *bd)
@@ -3265,6 +3302,13 @@ static void bnge_init_ring_params(struct bnge_net *bn)
bn->netdev->cfg->hds_thresh = max(BNGE_DEFAULT_RX_COPYBREAK, rx_size);
}
+static void bnge_set_dflt_rfs(struct bnge_net *bn)
+{
+ bn->netdev->hw_features |= NETIF_F_NTUPLE;
+ bn->netdev->features |= NETIF_F_NTUPLE;
+ bn->priv_flags |= BNGE_NET_EN_NTUPLE;
+}
+
int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
{
struct net_device *netdev;
@@ -3371,6 +3415,8 @@ int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
bnge_set_ring_params(bd);
bnge_init_l2_fltr_tbl(bn);
+ bnge_set_dflt_rfs(bn);
+
bnge_init_mac_addr(bd);
rc = bnge_probe_phy(bn, true);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index ee649cc644db..c47a874df4ba 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -152,6 +152,7 @@ enum {
BNGE_NET_EN_GRO = BIT(0),
BNGE_NET_EN_LRO = BIT(1),
BNGE_NET_EN_JUMBO = BIT(2),
+ BNGE_NET_EN_NTUPLE = BIT(3),
};
#define BNGE_NET_EN_TPA (BNGE_NET_EN_GRO | BNGE_NET_EN_LRO)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
index 21f55ea056f4..ef5e235a7cdd 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
@@ -191,12 +191,16 @@ int bnge_cal_nr_rss_ctxs(u16 rx_rings)
static u16 bnge_get_total_rss_ctxs(struct bnge_dev *bd,
struct bnge_hw_rings *hwr)
{
- return bnge_cal_nr_rss_ctxs(hwr->grp);
+ u16 rss_ctx = bnge_cal_nr_rss_ctxs(hwr->grp);
+
+ rss_ctx *= hwr->vnic;
+
+ return rss_ctx;
}
static u16 bnge_get_total_vnics(struct bnge_dev *bd)
{
- return 1;
+ return BNGE_BASE_VNICS;
}
u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd)
@@ -222,8 +226,8 @@ static void bnge_copy_reserved_rings(struct bnge_dev *bd,
static bool bnge_rings_ok(struct bnge_hw_rings *hwr)
{
- return hwr->tx && hwr->rx && hwr->nq && hwr->grp && hwr->vnic &&
- hwr->stat && hwr->cmpl;
+ return hwr->tx && hwr->rx && hwr->nq && hwr->grp &&
+ hwr->vnic >= BNGE_BASE_VNICS && hwr->stat && hwr->cmpl;
}
static bool bnge_need_reserve_rings(struct bnge_dev *bd)
@@ -232,18 +236,21 @@ static bool bnge_need_reserve_rings(struct bnge_dev *bd)
u16 cprs = bnge_cprs_demand(bd);
u16 rx = bd->rx_nr_rings, stat;
u16 nqs = bnge_nqs_demand(bd);
- u16 vnic;
+ struct bnge_hw_rings hwr = {};
if (hw_resc->resv_tx_rings != bd->tx_nr_rings)
return true;
- vnic = bnge_get_total_vnics(bd);
+ hwr.grp = bd->rx_nr_rings;
+ hwr.vnic = bnge_get_total_vnics(bd);
if (bnge_is_agg_reqd(bd))
rx <<= 1;
stat = bnge_func_stat_ctxs_demand(bd);
if (hw_resc->resv_rx_rings != rx || hw_resc->resv_cp_rings != cprs ||
- hw_resc->resv_vnics != vnic || hw_resc->resv_stat_ctxs != stat)
+ hw_resc->resv_vnics != hwr.vnic ||
+ hw_resc->resv_rsscos_ctxs != bnge_get_total_rss_ctxs(bd, &hwr) ||
+ hw_resc->resv_stat_ctxs != stat)
return true;
if (hw_resc->resv_irqs != nqs)
return true;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.h b/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
index c0b6992d7f82..97e8ef08974c 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
@@ -75,6 +75,7 @@ void bnge_aux_init_dflt_config(struct bnge_dev *bd);
u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd);
int bnge_cal_nr_rss_ctxs(u16 rx_rings);
bool bnge_aux_has_enough_resources(struct bnge_dev *bd);
+bool bnge_arfs_capable(struct bnge_dev *bd, bool new_rss_ctx);
static inline u32
bnge_adjust_pow_two(u32 total_ent, u16 ent_per_blk)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
index 3a6c8f0a5954..d98a6196c859 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
@@ -42,7 +42,11 @@ void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic)
for (i = 0; i < tbl_size; i++) {
u16 ring_id, j;
- j = bd->rss_indir_tbl[i];
+ if (vnic->flags & BNGE_VNIC_NTUPLE_FLAG)
+ j = ethtool_rxfh_indir_default(i, bd->rx_nr_rings);
+ else
+ j = bd->rss_indir_tbl[i];
+
rxr = &bn->rx_ring[j];
ring_id = rxr->rx_ring_struct.fw_ring_id;
@@ -98,3 +102,30 @@ int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic)
}
return rc;
}
+
+static int bnge_alloc_and_setup_vnic(struct bnge_net *bn,
+ struct bnge_vnic_info *vnic,
+ u16 rx_rings)
+{
+ int rc;
+
+ rc = bnge_hwrm_vnic_alloc(bn->bd, vnic, rx_rings);
+ if (rc) {
+ netdev_err(bn->netdev, "hwrm vnic %u alloc failure rc: %d\n",
+ vnic->vnic_id, rc);
+ return rc;
+ }
+
+ /* If bnge_setup_vnic() fails, the VNIC allocated above is not freed
+ * here; the caller (bnge_init_chip) unwinds via its err_out path.
+ */
+ return bnge_setup_vnic(bn, vnic);
+}
+
+int bnge_alloc_rfs_vnic(struct bnge_net *bn)
+{
+ struct bnge_vnic_info *vnic;
+
+ vnic = &bn->vnic_info[BNGE_VNIC_NTUPLE];
+ return bnge_alloc_and_setup_vnic(bn, vnic, bn->bd->rx_nr_rings);
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
index c81d3a64561e..72357e0b37ac 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -22,13 +22,16 @@ struct bnge_l2_filter;
#define BNGE_MAX_UC_ADDRS 4
enum {
- BNGE_VNIC_DEFAULT = 0
+ BNGE_VNIC_DEFAULT = 0,
+ BNGE_VNIC_NTUPLE = 1,
+ BNGE_BASE_VNICS = 2
};
enum {
BNGE_VNIC_RSS_FLAG = BIT(0),
BNGE_VNIC_MCAST_FLAG = BIT(1),
- BNGE_VNIC_UCAST_FLAG = BIT(2)
+ BNGE_VNIC_UCAST_FLAG = BIT(2),
+ BNGE_VNIC_NTUPLE_FLAG = BIT(3)
};
struct bnge_vnic_info {
@@ -60,4 +63,5 @@ int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
struct bnge_vnic_info *vnic);
int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic);
void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd);
+int bnge_alloc_rfs_vnic(struct bnge_net *bn);
#endif /* _BNGE_VNIC_H_ */
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 03/10] bnge: add helper functions for multi RSS contexts
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 01/10] bnge: restructure VNIC and filter code Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 02/10] bnge: add NTUPLE/ARFS VNIC Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 04/10] bnge: add RXFH ethtool support Vikas Gupta
` (6 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Add infrastructure for creating, modifying, and deleting user-defined
RSS contexts. This helps the next patch implement commands for ethtool.
For each user RSS context, a VNIC is allocated.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 14 +--
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 2 +
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 113 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 15 +++
4 files changed, 132 insertions(+), 12 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 3248aae88c8d..e81c7b8634c2 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -1102,7 +1102,7 @@ static int bnge_alloc_vnic_attributes(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
struct bnge_vnic_info *vnic;
- int i, size;
+ int i;
for (i = 0; i < bn->nr_vnics; i++) {
vnic = &bn->vnic_info[i];
@@ -1127,18 +1127,8 @@ static int bnge_alloc_vnic_attributes(struct bnge_net *bn)
}
/* Allocate rss table and hash key */
- size = L1_CACHE_ALIGN(BNGE_MAX_RSS_TABLE_SIZE);
-
- vnic->rss_table_size = size + HW_HASH_KEY_SIZE;
- vnic->rss_table = dma_alloc_coherent(bd->dev,
- vnic->rss_table_size,
- &vnic->rss_table_dma_addr,
- GFP_KERNEL);
- if (!vnic->rss_table)
+ if (bnge_alloc_vnic_rss_table(bn, vnic))
goto err_free_vnic_attributes;
-
- vnic->rss_hash_key = ((void *)vnic->rss_table) + size;
- vnic->rss_hash_key_dma_addr = vnic->rss_table_dma_addr + size;
}
return 0;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index c47a874df4ba..3c0fea0a7608 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -371,6 +371,8 @@ struct bnge_net {
u8 pri2cos_idx[8];
bool pri2cos_valid;
+
+ u16 num_rss_ctx;
};
#define BNGE_DEFAULT_RX_RING_SIZE 511
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
index d98a6196c859..a44971a7c74d 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
@@ -129,3 +129,116 @@ int bnge_alloc_rfs_vnic(struct bnge_net *bn)
vnic = &bn->vnic_info[BNGE_VNIC_NTUPLE];
return bnge_alloc_and_setup_vnic(bn, vnic, bn->bd->rx_nr_rings);
}
+
+void bnge_modify_rss(struct bnge_net *bn, struct ethtool_rxfh_context *ctx,
+ struct bnge_rss_ctx *rss_ctx,
+ const struct ethtool_rxfh_param *rxfh)
+{
+ struct bnge_dev *bd = bn->bd;
+
+ if (rxfh->key) {
+ if (rss_ctx) {
+ memcpy(rss_ctx->vnic.rss_hash_key, rxfh->key,
+ HW_HASH_KEY_SIZE);
+ } else {
+ memcpy(bn->rss_hash_key, rxfh->key, HW_HASH_KEY_SIZE);
+ bn->rss_hash_key_updated = true;
+ }
+ }
+
+ if (rxfh->indir) {
+ u32 i, pad, tbl_size = bnge_get_rxfh_indir_size(bd);
+ u32 *indir_tbl = bd->rss_indir_tbl;
+
+ if (rss_ctx)
+ indir_tbl = ethtool_rxfh_context_indir(ctx);
+ for (i = 0; i < tbl_size; i++)
+ indir_tbl[i] = rxfh->indir[i];
+ pad = bd->rss_indir_tbl_entries - tbl_size;
+ if (pad)
+ memset(&indir_tbl[i], 0, pad * sizeof(*indir_tbl));
+ }
+}
+
+void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
+ bool all)
+{
+ struct bnge_vnic_info *vnic = &rss_ctx->vnic;
+ int i;
+
+ bnge_hwrm_vnic_free_one(bn->bd, &rss_ctx->vnic);
+ for (i = 0; i < BNGE_MAX_CTX_PER_VNIC; i++) {
+ if (vnic->fw_rss_cos_lb_ctx[i] != INVALID_HW_RING_ID)
+ bnge_hwrm_vnic_ctx_free_one(bn->bd, vnic, i);
+ }
+
+ if (!all)
+ return;
+
+ if (vnic->rss_table)
+ dma_free_coherent(bn->bd->dev, vnic->rss_table_size,
+ vnic->rss_table,
+ vnic->rss_table_dma_addr);
+ bn->num_rss_ctx--;
+}
+
+void bnge_hwrm_realloc_rss_ctx_vnic(struct bnge_net *bn)
+{
+ u32 tpa_flags = bn->priv_flags & BNGE_NET_EN_TPA;
+ struct ethtool_rxfh_context *ctx;
+ unsigned long context;
+
+ xa_for_each(&bn->netdev->ethtool->rss_ctx, context, ctx) {
+ struct bnge_rss_ctx *rss_ctx = ethtool_rxfh_context_priv(ctx);
+ struct bnge_vnic_info *vnic = &rss_ctx->vnic;
+
+ if (bnge_hwrm_vnic_alloc(bn->bd, vnic, bn->bd->rx_nr_rings) ||
+ bnge_hwrm_vnic_set_tpa(bn->bd, vnic, tpa_flags) ||
+ bnge_setup_vnic(bn, vnic)) {
+ netdev_err(bn->netdev, "Failed to restore RSS ctx %d\n",
+ rss_ctx->index);
+ bnge_del_one_rss_ctx(bn, rss_ctx, true);
+ ethtool_rxfh_context_lost(bn->netdev, rss_ctx->index);
+ }
+ }
+}
+
+void bnge_clear_rss_ctxs(struct bnge_net *bn)
+{
+ struct ethtool_rxfh_context *ctx;
+ unsigned long context;
+
+ xa_for_each(&bn->netdev->ethtool->rss_ctx, context, ctx) {
+ struct bnge_rss_ctx *rss_ctx = ethtool_rxfh_context_priv(ctx);
+
+ bnge_del_one_rss_ctx(bn, rss_ctx, false);
+ }
+}
+
+struct bnge_rss_ctx *bnge_get_rss_ctx_from_index(struct bnge_net *bn, u32 idx)
+{
+ struct ethtool_rxfh_context *ctx;
+
+ ctx = xa_load(&bn->netdev->ethtool->rss_ctx, idx);
+ if (!ctx)
+ return NULL;
+ return ethtool_rxfh_context_priv(ctx);
+}
+
+int bnge_alloc_vnic_rss_table(struct bnge_net *bn,
+ struct bnge_vnic_info *vnic)
+{
+ unsigned int size = L1_CACHE_ALIGN(BNGE_MAX_RSS_TABLE_SIZE);
+
+ vnic->rss_table_size = size + HW_HASH_KEY_SIZE;
+ vnic->rss_table = dma_alloc_coherent(bn->bd->dev,
+ vnic->rss_table_size,
+ &vnic->rss_table_dma_addr,
+ GFP_KERNEL);
+ if (!vnic->rss_table)
+ return -ENOMEM;
+
+ vnic->rss_hash_key = ((void *)vnic->rss_table) + size;
+ vnic->rss_hash_key_dma_addr = vnic->rss_table_dma_addr + size;
+ return 0;
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
index 72357e0b37ac..382df442789e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -58,10 +58,25 @@ struct bnge_vnic_info {
u32 vnic_id;
};
+struct bnge_rss_ctx {
+ struct bnge_vnic_info vnic;
+ u32 index;
+};
+
void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic);
int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
struct bnge_vnic_info *vnic);
int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic);
void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd);
int bnge_alloc_rfs_vnic(struct bnge_net *bn);
+int bnge_alloc_vnic_rss_table(struct bnge_net *bn,
+ struct bnge_vnic_info *vnic);
+struct bnge_rss_ctx *bnge_get_rss_ctx_from_index(struct bnge_net *bn, u32 idx);
+void bnge_modify_rss(struct bnge_net *bn, struct ethtool_rxfh_context *ctx,
+ struct bnge_rss_ctx *rss_ctx,
+ const struct ethtool_rxfh_param *rxfh);
+void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
+ bool all);
+void bnge_hwrm_realloc_rss_ctx_vnic(struct bnge_net *bn);
+void bnge_clear_rss_ctxs(struct bnge_net *bn);
#endif /* _BNGE_VNIC_H_ */
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 04/10] bnge: add RXFH ethtool support
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (2 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 03/10] bnge: add helper functions for multi RSS contexts Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 05/10] bnge: add ethtool support to manage RSS contexts Vikas Gupta
` (5 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Introduce ethtool RXFH operations including get/set_rxfh for
reading and programming the RSS hash key and indirection table.
Currently set_rxfh and set_rxfh_fields are supported only while the
device is down. A future patch series will rework
bnge_close_core()/bnge_open_core() so they can be driven safely
from the ethtool path, adding full functionality by applying the
configuration on a live device.
The default RSS key changes. It used to be a per-device
get_random_bytes() key created on first open in bnge_init_vnics().
It is now the system-wide netdev_rss_key_fill() key set in
bnge_netdev_alloc(), and rss_hash_key_valid is removed.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
drivers/net/ethernet/broadcom/bnge/bnge.h | 1 +
.../net/ethernet/broadcom/bnge/bnge_ethtool.c | 345 ++++++++++++++++++
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 2 +
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 11 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 1 -
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 1 +
6 files changed, 352 insertions(+), 9 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge.h b/drivers/net/ethernet/broadcom/bnge/bnge.h
index 3e8210626062..aeb4b1ef628a 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge.h
@@ -85,6 +85,7 @@ enum {
BNGE_RSS_CAP_AH_V6_RSS_CAP = BIT(5),
BNGE_RSS_CAP_ESP_V4_RSS_CAP = BIT(6),
BNGE_RSS_CAP_ESP_V6_RSS_CAP = BIT(7),
+ BNGE_RSS_CAP_IPV6_FLOW_LABEL_RSS_CAP = BIT(8),
};
#define BNGE_MAX_QUEUE 8
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
index 2467e44de291..878fe4888160 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
@@ -10,6 +10,9 @@
#include <linux/ethtool_netlink.h>
#include "bnge.h"
+#include "bnge_netdev.h"
+#include "bnge_vnic.h"
+#include "bnge_resc.h"
#include "bnge_ethtool.h"
#include "bnge_hwrm_lib.h"
@@ -740,6 +743,336 @@ static int bnge_set_pauseparam(struct net_device *dev,
return rc;
}
+static u64 bnge_get_ethtool_ipv4_rss(struct bnge_dev *bd)
+{
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV4)
+ return RXH_IP_SRC | RXH_IP_DST;
+ return 0;
+}
+
+static u64 bnge_get_ethtool_ipv6_rss(struct bnge_dev *bd)
+{
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6)
+ return RXH_IP_SRC | RXH_IP_DST;
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL)
+ return RXH_IP_SRC | RXH_IP_DST | RXH_IP6_FL;
+ return 0;
+}
+
+static int bnge_get_rxfh_fields(struct net_device *dev,
+ struct ethtool_rxfh_fields *cmd)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+
+ cmd->data = 0;
+ switch (cmd->flow_type) {
+ case TCP_V4_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV4)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case UDP_V4_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV4)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case AH_ESP_V4_FLOW:
+ if ((bd->rss_hash_cfg &
+ (VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4)) ==
+ (VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4))
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case AH_V4_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case ESP_V4_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case SCTP_V4_FLOW:
+ case IPV4_FLOW:
+ cmd->data |= bnge_get_ethtool_ipv4_rss(bd);
+ break;
+ case TCP_V6_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV6)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ case UDP_V6_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV6)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ case AH_ESP_V6_FLOW:
+ if ((bd->rss_hash_cfg &
+ (VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6)) ==
+ (VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6))
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ case AH_V6_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ case ESP_V6_FLOW:
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6)
+ cmd->data |= RXH_IP_SRC | RXH_IP_DST |
+ RXH_L4_B_0_1 | RXH_L4_B_2_3;
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ case SCTP_V6_FLOW:
+ case IPV6_FLOW:
+ cmd->data |= bnge_get_ethtool_ipv6_rss(bd);
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ return 0;
+}
+
+#define RXH_4TUPLE (RXH_IP_SRC | RXH_IP_DST | RXH_L4_B_0_1 | RXH_L4_B_2_3)
+#define RXH_2TUPLE (RXH_IP_SRC | RXH_IP_DST)
+
+static int bnge_set_rxfh_fields(struct net_device *dev,
+ const struct ethtool_rxfh_fields *cmd,
+ struct netlink_ext_ack *extack)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+ u32 rss_hash_cfg;
+ int tuple;
+
+ rss_hash_cfg = bd->rss_hash_cfg;
+
+ if (cmd->data == RXH_4TUPLE ||
+ cmd->data == (RXH_4TUPLE | RXH_IP6_FL))
+ tuple = 4;
+ else if (cmd->data == RXH_2TUPLE ||
+ cmd->data == (RXH_2TUPLE | RXH_IP6_FL))
+ tuple = 2;
+ else if (!cmd->data)
+ tuple = 0;
+ else
+ return -EINVAL;
+
+ if (cmd->data & RXH_IP6_FL &&
+ !(bd->rss_cap & BNGE_RSS_CAP_IPV6_FLOW_LABEL_RSS_CAP))
+ return -EINVAL;
+
+ if (cmd->flow_type == TCP_V4_FLOW) {
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV4;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV4;
+ } else if (cmd->flow_type == UDP_V4_FLOW) {
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV4;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV4;
+ } else if (cmd->flow_type == TCP_V6_FLOW) {
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV6;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV6;
+ } else if (cmd->flow_type == UDP_V6_FLOW) {
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV6;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV6;
+ } else if (cmd->flow_type == AH_ESP_V4_FLOW) {
+ if (tuple == 4 &&
+ (!(bd->rss_cap & BNGE_RSS_CAP_AH_V4_RSS_CAP) ||
+ !(bd->rss_cap & BNGE_RSS_CAP_ESP_V4_RSS_CAP)))
+ return -EINVAL;
+ rss_hash_cfg &= ~(VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4);
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4;
+ } else if (cmd->flow_type == AH_ESP_V6_FLOW) {
+ if (tuple == 4 &&
+ (!(bd->rss_cap & BNGE_RSS_CAP_AH_V6_RSS_CAP) ||
+ !(bd->rss_cap & BNGE_RSS_CAP_ESP_V6_RSS_CAP)))
+ return -EINVAL;
+ rss_hash_cfg &= ~(VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6);
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6;
+ } else if (cmd->flow_type == AH_V4_FLOW) {
+ if (tuple == 4 && !(bd->rss_cap & BNGE_RSS_CAP_AH_V4_RSS_CAP))
+ return -EINVAL;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV4;
+ } else if (cmd->flow_type == ESP_V4_FLOW) {
+ if (tuple == 4 && !(bd->rss_cap & BNGE_RSS_CAP_ESP_V4_RSS_CAP))
+ return -EINVAL;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV4;
+ } else if (cmd->flow_type == AH_V6_FLOW) {
+ if (tuple == 4 && !(bd->rss_cap & BNGE_RSS_CAP_AH_V6_RSS_CAP))
+ return -EINVAL;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_AH_SPI_IPV6;
+ } else if (cmd->flow_type == ESP_V6_FLOW) {
+ if (tuple == 4 && !(bd->rss_cap & BNGE_RSS_CAP_ESP_V6_RSS_CAP))
+ return -EINVAL;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6;
+ if (tuple == 4)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_ESP_SPI_IPV6;
+ } else if (tuple == 4) {
+ return -EINVAL;
+ }
+
+ switch (cmd->flow_type) {
+ case TCP_V4_FLOW:
+ case UDP_V4_FLOW:
+ case SCTP_V4_FLOW:
+ case AH_ESP_V4_FLOW:
+ case AH_V4_FLOW:
+ case ESP_V4_FLOW:
+ case IPV4_FLOW:
+ if (tuple == 2)
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_IPV4;
+ else if (!tuple && cmd->flow_type == IPV4_FLOW)
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_IPV4;
+ else if (!tuple &&
+ (rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV4))
+ goto err_l3_shared;
+ break;
+
+ case TCP_V6_FLOW:
+ case UDP_V6_FLOW:
+ case SCTP_V6_FLOW:
+ case AH_ESP_V6_FLOW:
+ case AH_V6_FLOW:
+ case ESP_V6_FLOW:
+ case IPV6_FLOW:
+ if (cmd->data & RXH_IP6_FL) {
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6;
+ } else if (tuple == 2 ||
+ (tuple == 4 &&
+ (rss_hash_cfg &
+ VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL))) {
+ rss_hash_cfg |= VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6;
+ rss_hash_cfg &= ~VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL;
+ } else if (!tuple && cmd->flow_type == IPV6_FLOW) {
+ rss_hash_cfg &= ~(VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL);
+ } else if (!tuple &&
+ (rss_hash_cfg &
+ (VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6 |
+ VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6_FLOW_LABEL))) {
+ goto err_l3_shared;
+ }
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ if (bd->rss_hash_cfg == rss_hash_cfg)
+ return 0;
+
+ if (netif_running(dev)) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "RSS configuration can only be changed while the interface is down");
+ return -EBUSY;
+ }
+
+ bd->rss_hash_cfg = rss_hash_cfg;
+
+ return 0;
+
+err_l3_shared:
+ NL_SET_ERR_MSG_MOD(extack,
+ "2-tuple hashing is shared by all flows of an IP version, use ip4/ip6 to disable it");
+ return -EINVAL;
+}
+
+static u32 bnge_get_rxfh_indir_size_eth(struct net_device *dev)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+
+ return bnge_get_rxfh_indir_size(bd);
+}
+
+static u32 bnge_get_rxfh_key_size(struct net_device *dev)
+{
+ return HW_HASH_KEY_SIZE;
+}
+
+static int bnge_get_rxfh(struct net_device *dev,
+ struct ethtool_rxfh_param *rxfh)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+ u32 i, tbl_size;
+ u32 *indir_tbl;
+
+ indir_tbl = bd->rss_indir_tbl;
+ rxfh->hfunc = ETH_RSS_HASH_TOP;
+
+ if (rxfh->indir && indir_tbl) {
+ tbl_size = bnge_get_rxfh_indir_size(bd);
+ for (i = 0; i < tbl_size; i++)
+ rxfh->indir[i] = indir_tbl[i];
+ }
+
+ if (rxfh->key)
+ memcpy(rxfh->key, bn->rss_hash_key, HW_HASH_KEY_SIZE);
+
+ return 0;
+}
+
+static int bnge_set_rxfh(struct net_device *dev,
+ struct ethtool_rxfh_param *rxfh,
+ struct netlink_ext_ack *extack)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+
+ if (rxfh->hfunc && rxfh->hfunc != ETH_RSS_HASH_TOP)
+ return -EOPNOTSUPP;
+
+ if (netif_running(dev)) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "RSS configuration can only be changed while the interface is down");
+ return -EBUSY;
+ }
+
+ bnge_modify_rss(bn, NULL, NULL, rxfh);
+
+ return 0;
+}
+
+static u32 bnge_get_rx_ring_count(struct net_device *dev)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+
+ return bd->rx_nr_rings;
+}
+
static const struct ethtool_ops bnge_ethtool_ops = {
.cap_link_lanes_supported = 1,
.get_link_ksettings = bnge_get_link_ksettings,
@@ -757,6 +1090,18 @@ static const struct ethtool_ops bnge_ethtool_ops = {
.get_eth_ctrl_stats = bnge_get_eth_ctrl_stats,
.get_pause_stats = bnge_get_pause_stats,
.get_rmon_stats = bnge_get_rmon_stats,
+ /* RXFH */
+ .rxfh_per_ctx_key = 1,
+ .rxfh_max_num_contexts = BNGE_MAX_ETH_RSS_CTX + 1,
+ .rxfh_indir_space = BNGE_MAX_RSS_TABLE_ENTRIES,
+ .rxfh_priv_size = sizeof(struct bnge_rss_ctx),
+ .get_rx_ring_count = bnge_get_rx_ring_count,
+ .get_rxfh_indir_size = bnge_get_rxfh_indir_size_eth,
+ .get_rxfh_key_size = bnge_get_rxfh_key_size,
+ .get_rxfh = bnge_get_rxfh,
+ .set_rxfh = bnge_set_rxfh,
+ .get_rxfh_fields = bnge_get_rxfh_fields,
+ .set_rxfh_fields = bnge_set_rxfh_fields,
};
void bnge_set_ethtool_ops(struct net_device *dev)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index 91d246c8dcf2..86edb70d323e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -676,6 +676,8 @@ int bnge_hwrm_vnic_qcaps(struct bnge_dev *bd)
bd->rss_cap |= BNGE_RSS_CAP_ESP_V4_RSS_CAP;
if (flags & VNIC_QCAPS_RESP_FLAGS_RSS_IPSEC_ESP_SPI_IPV6_CAP)
bd->rss_cap |= BNGE_RSS_CAP_ESP_V6_RSS_CAP;
+ if (flags & VNIC_QCAPS_RESP_FLAGS_RSS_IPV6_FLOW_LABEL_CAP)
+ bd->rss_cap |= BNGE_RSS_CAP_IPV6_FLOW_LABEL_RSS_CAP;
}
bnge_hwrm_req_drop(bd, req);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index e81c7b8634c2..2e39b12a3323 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -1747,13 +1747,6 @@ static void bnge_init_vnics(struct bnge_net *bn)
u8 *key = (void *)vnic->rss_hash_key;
int k;
- if (!bn->rss_hash_key_valid &&
- !bn->rss_hash_key_updated) {
- get_random_bytes(bn->rss_hash_key,
- HW_HASH_KEY_SIZE);
- bn->rss_hash_key_updated = true;
- }
-
memcpy(vnic->rss_hash_key, bn->rss_hash_key,
HW_HASH_KEY_SIZE);
@@ -1761,7 +1754,6 @@ static void bnge_init_vnics(struct bnge_net *bn)
continue;
bn->rss_hash_key_updated = false;
- bn->rss_hash_key_valid = true;
bn->toeplitz_prefix = 0;
for (k = 0; k < 8; k++) {
@@ -3400,6 +3392,9 @@ int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
bn->tx_ring_size = BNGE_DEFAULT_TX_RING_SIZE;
bn->rx_dir = DMA_FROM_DEVICE;
+ netdev_rss_key_fill(bn->rss_hash_key, sizeof(bn->rss_hash_key));
+ bn->rss_hash_key_updated = true;
+
bnge_set_tpa_flags(bd);
bnge_init_ring_params(bn);
bnge_set_ring_params(bd);
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 3c0fea0a7608..0512d983519e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -335,7 +335,6 @@ struct bnge_net {
u16 rx_dma_offset;
u8 rss_hash_key[HW_HASH_KEY_SIZE];
- u8 rss_hash_key_valid:1;
u8 rss_hash_key_updated:1;
int rsscos_nr_ctxs;
u32 stats_coal_ticks;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
index 382df442789e..d11bd33fe254 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -16,6 +16,7 @@ struct bnge_l2_filter;
#define BNGE_MAX_RSS_TABLE_ENTRIES \
(BNGE_RSS_TABLE_ENTRIES * BNGE_RSS_TABLE_MAX_TBL)
+#define BNGE_MAX_ETH_RSS_CTX 32
#define BNGE_MAX_CTX_PER_VNIC 8
#define BNGE_MAX_MC_ADDRS 16
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 05/10] bnge: add ethtool support to manage RSS contexts
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (3 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 04/10] bnge: add RXFH ethtool support Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 06/10] bnge: remove refcount from L2 filter Vikas Gupta
` (4 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Introduce ethtool callbacks to manage RSS contexts.
Each context allocates a dedicated VNIC with its own RSS indirection
table and hash key, configured with TPA settings matching those of the
default VNIC.
The patch also changes existing behaviour:
- bnge_reserve_rings() no longer always resets bd->rss_indir_tbl when
the RX ring count drops. A user-configured default table is kept,
and ethtool_rxfh_indir_lost() is called when it no longer fits.
- bnge_fill_hw_rss_tbl() remaps out-of-range entries for every VNIC,
including the default one.
- bnge_del_one_rss_ctx() resets fw_rss_cos_lb_ctx[] and decrements
rsscos_nr_ctxs, and bnge_hwrm_realloc_rss_ctx_vnic() takes rss_lock.
- bnge_set_features() fails with -EBUSY when NTUPLE is cleared while
RSS contexts exist.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_ethtool.c | 173 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 9 +
.../net/ethernet/broadcom/bnge/bnge_resc.c | 84 ++++++++-
.../net/ethernet/broadcom/bnge/bnge_resc.h | 2 +-
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 124 ++++++++++++-
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 16 +-
6 files changed, 396 insertions(+), 12 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
index 878fe4888160..c370686e2b38 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
@@ -1073,6 +1073,176 @@ static u32 bnge_get_rx_ring_count(struct net_device *dev)
return bd->rx_nr_rings;
}
+static int bnge_rxfh_context_check(struct bnge_net *bn,
+ const struct ethtool_rxfh_param *rxfh,
+ struct netlink_ext_ack *extack)
+{
+ if (rxfh->hfunc && rxfh->hfunc != ETH_RSS_HASH_TOP) {
+ NL_SET_ERR_MSG_MOD(extack, "RSS hash function not supported");
+ return -EOPNOTSUPP;
+ }
+
+ if (!(bn->priv_flags & BNGE_NET_EN_NTUPLE)) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Enable ntuple filtering before adding RSS contexts");
+ return -EOPNOTSUPP;
+ }
+
+ if (!netif_running(bn->netdev)) {
+ NL_SET_ERR_MSG_MOD(extack, "Unable to set RSS contexts when interface is down");
+ return -EAGAIN;
+ }
+
+ return 0;
+}
+
+static int bnge_create_rxfh_context(struct net_device *dev,
+ struct ethtool_rxfh_context *ctx,
+ const struct ethtool_rxfh_param *rxfh,
+ struct netlink_ext_ack *extack)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_rss_ctx *rss_ctx;
+ struct bnge_vnic_info *vnic;
+ int rc;
+
+ rc = bnge_rxfh_context_check(bn, rxfh, extack);
+ if (rc)
+ return rc;
+
+ if (bn->num_rss_ctx >= BNGE_MAX_ETH_RSS_CTX) {
+ NL_SET_ERR_MSG_FMT_MOD(extack, "Out of RSS contexts, maximum %u",
+ BNGE_MAX_ETH_RSS_CTX);
+ return -EINVAL;
+ }
+
+ if (!bnge_rss_ctx_capable(bn->bd)) {
+ NL_SET_ERR_MSG_MOD(extack, "Out of hardware resources");
+ return -ENOMEM;
+ }
+
+ rss_ctx = ethtool_rxfh_context_priv(ctx);
+
+ bn->num_rss_ctx++;
+
+ vnic = &rss_ctx->vnic;
+
+ bnge_init_vnic_mem(vnic);
+
+ vnic->rss_ctx = ctx;
+ vnic->flags |= BNGE_VNIC_RSSCTX_FLAG;
+ rc = bnge_alloc_vnic_rss_table(bn, vnic);
+ if (rc)
+ goto err_del_rss_ctx;
+
+ /* Populate defaults in the context */
+ bnge_set_dflt_rss_indir_tbl(bn->bd, ctx);
+ ctx->hfunc = ETH_RSS_HASH_TOP;
+ memcpy(vnic->rss_hash_key, bn->rss_hash_key, HW_HASH_KEY_SIZE);
+ memcpy(ethtool_rxfh_context_key(ctx),
+ bn->rss_hash_key, HW_HASH_KEY_SIZE);
+
+ rc = bnge_hwrm_vnic_alloc(bn->bd, vnic, bn->bd->rx_nr_rings);
+ if (rc) {
+ NL_SET_ERR_MSG_MOD(extack, "Unable to allocate VNIC");
+ goto err_del_rss_ctx;
+ }
+
+ rc = bnge_hwrm_vnic_set_tpa(bn->bd, vnic,
+ bn->priv_flags & BNGE_NET_EN_TPA);
+ if (rc) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "Unable to set TPA settings to vnic");
+ goto err_del_rss_ctx;
+ }
+ bnge_modify_rss(bn, ctx, rss_ctx, rxfh);
+
+ rc = bnge_setup_vnic(bn, vnic);
+ if (rc) {
+ NL_SET_ERR_MSG_MOD(extack, "Unable to setup vnic");
+ goto err_del_rss_ctx;
+ }
+
+ rss_ctx->index = rxfh->rss_context;
+ return 0;
+
+err_del_rss_ctx:
+ bnge_del_one_rss_ctx(bn, rss_ctx, true);
+ return rc;
+}
+
+static int bnge_modify_rxfh_context(struct net_device *dev,
+ struct ethtool_rxfh_context *ctx,
+ const struct ethtool_rxfh_param *rxfh,
+ struct netlink_ext_ack *extack)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ u8 old_key[HW_HASH_KEY_SIZE];
+ struct bnge_rss_ctx *rss_ctx;
+ u32 *old_indir = NULL;
+ u32 tbl_size;
+ int rc;
+
+ rc = bnge_rxfh_context_check(bn, rxfh, extack);
+ if (rc)
+ return rc;
+
+ rss_ctx = ethtool_rxfh_context_priv(ctx);
+ tbl_size = bnge_get_rxfh_indir_size(bn->bd);
+
+ if (ctx->indir_size != tbl_size) {
+ NL_SET_ERR_MSG_MOD(extack,
+ "RSS context indirection table size mismatch");
+ return -EINVAL;
+ }
+
+ /* Snapshot the software state so it can be restored if the hardware
+ * update fails, keeping the reported config consistent with the
+ * hardware.
+ */
+ if (rxfh->key)
+ memcpy(old_key, rss_ctx->vnic.rss_hash_key, HW_HASH_KEY_SIZE);
+ if (rxfh->indir) {
+ old_indir = kmemdup(ethtool_rxfh_context_indir(ctx),
+ tbl_size * sizeof(*old_indir), GFP_KERNEL);
+ if (!old_indir)
+ return -ENOMEM;
+ }
+
+ bnge_modify_rss(bn, ctx, rss_ctx, rxfh);
+
+ rc = bnge_hwrm_vnic_rss_cfg(bn, &rss_ctx->vnic);
+ if (rc) {
+ if (rxfh->key)
+ memcpy(rss_ctx->vnic.rss_hash_key, old_key,
+ HW_HASH_KEY_SIZE);
+ if (rxfh->indir)
+ memcpy(ethtool_rxfh_context_indir(ctx), old_indir,
+ tbl_size * sizeof(*old_indir));
+ /* Part of the update may have reached the device */
+ if (bnge_hwrm_vnic_rss_cfg(bn, &rss_ctx->vnic))
+ netdev_warn(dev, "Failed to restore RSS context %u\n",
+ rss_ctx->index);
+ }
+
+ kfree(old_indir);
+ return rc;
+}
+
+static int bnge_remove_rxfh_context(struct net_device *dev,
+ struct ethtool_rxfh_context *ctx,
+ u32 rss_context,
+ struct netlink_ext_ack *extack)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_rss_ctx *rss_ctx;
+
+ rss_ctx = ethtool_rxfh_context_priv(ctx);
+
+ bnge_del_one_rss_ctx(bn, rss_ctx, true);
+ return 0;
+}
+
static const struct ethtool_ops bnge_ethtool_ops = {
.cap_link_lanes_supported = 1,
.get_link_ksettings = bnge_get_link_ksettings,
@@ -1102,6 +1272,9 @@ static const struct ethtool_ops bnge_ethtool_ops = {
.set_rxfh = bnge_set_rxfh,
.get_rxfh_fields = bnge_get_rxfh_fields,
.set_rxfh_fields = bnge_set_rxfh_fields,
+ .create_rxfh_context = bnge_create_rxfh_context,
+ .modify_rxfh_context = bnge_modify_rxfh_context,
+ .remove_rxfh_context = bnge_remove_rxfh_context,
};
void bnge_set_ethtool_ops(struct net_device *dev)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 2e39b12a3323..02ee1da8d57b 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -2796,6 +2796,8 @@ static int bnge_open_core(struct bnge_net *bn)
/* Poll link status and check for SFP+ module status */
bnge_get_port_module_status(bn);
+ bnge_hwrm_realloc_rss_ctx_vnic(bn);
+
return 0;
err_free_irq:
@@ -3013,7 +3015,10 @@ static void bnge_close_core(struct bnge_net *bn)
clear_bit(BNGE_STATE_OPEN, &bd->state);
timer_delete_sync(&bn->timer);
+
+ bnge_clear_rss_ctxs(bn);
bnge_shutdown_nic(bn);
+
bnge_disable_napi(bn);
/* Save ring stats before shutdown */
@@ -3145,6 +3150,10 @@ static int bnge_set_features(struct net_device *dev, netdev_features_t features)
if (flags == bn->priv_flags)
return 0;
+ if ((bn->priv_flags & BNGE_NET_EN_NTUPLE) &&
+ !(flags & BNGE_NET_EN_NTUPLE) && bn->num_rss_ctx)
+ return -EBUSY;
+
bn->priv_flags = flags;
return 0;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
index ef5e235a7cdd..135224a33071 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
@@ -178,6 +178,16 @@ static int bnge_adjust_rings(struct bnge_dev *bd, u16 *rx,
return bnge_fix_rings_count(rx, tx, max_nq, sh);
}
+static unsigned int bnge_get_max_func_rss_ctxs(struct bnge_dev *bd)
+{
+ return bd->hw_resc.max_rsscos_ctxs;
+}
+
+static unsigned int bnge_get_max_func_vnics(struct bnge_dev *bd)
+{
+ return bd->hw_resc.max_vnics;
+}
+
int bnge_cal_nr_rss_ctxs(u16 rx_rings)
{
if (!rx_rings)
@@ -200,7 +210,15 @@ static u16 bnge_get_total_rss_ctxs(struct bnge_dev *bd,
static u16 bnge_get_total_vnics(struct bnge_dev *bd)
{
- return BNGE_BASE_VNICS;
+ u16 vnics = BNGE_BASE_VNICS;
+
+ if (bd->netdev) {
+ struct bnge_net *bn = netdev_priv(bd->netdev);
+
+ vnics += bn->num_rss_ctx;
+ }
+
+ return vnics;
}
u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd)
@@ -209,6 +227,19 @@ u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd)
BNGE_RSS_TABLE_ENTRIES;
}
+static u16 bnge_get_max_rss_ring(struct bnge_dev *bd)
+{
+ u32 i, tbl_size, max_ring = 0;
+
+ if (!bd->rss_indir_tbl)
+ return 0;
+
+ tbl_size = bnge_get_rxfh_indir_size(bd);
+ for (i = 0; i < tbl_size; i++)
+ max_ring = max_t(u32, max_ring, bd->rss_indir_tbl[i]);
+ return max_ring;
+}
+
static void bnge_copy_reserved_rings(struct bnge_dev *bd,
struct bnge_hw_rings *hwr)
{
@@ -265,6 +296,7 @@ int bnge_reserve_rings(struct bnge_dev *bd)
u16 rx_rings, old_rx_rings;
u16 nq = bd->nq_nr_rings;
u16 aux_msix = 0;
+ bool rx_changed;
bool sh = false;
u16 tx_cp;
int rc;
@@ -327,9 +359,17 @@ int bnge_reserve_rings(struct bnge_dev *bd)
hwr.nq = sh ? max_t(u16, tx_cp, rx_rings) : tx_cp + rx_rings;
bd->tx_nr_rings = hwr.tx;
- if (rx_rings != bd->rx_nr_rings)
+ rx_changed = rx_rings != bd->rx_nr_rings;
+ if (rx_changed) {
dev_warn(bd->dev, "RX rings resv reduced to %d than earlier %d requested\n",
rx_rings, bd->rx_nr_rings);
+ if (bd->netdev && netif_is_rxfh_configured(bd->netdev) &&
+ (bnge_cal_nr_rss_ctxs(bd->rx_nr_rings) !=
+ bnge_cal_nr_rss_ctxs(rx_rings) ||
+ bnge_get_max_rss_ring(bd) >= rx_rings))
+ ethtool_rxfh_indir_lost(bd->netdev);
+ bnge_check_rss_ctxs_lost(bd, rx_rings);
+ }
bd->rx_nr_rings = rx_rings;
bd->nq_nr_rings = hwr.nq;
@@ -337,8 +377,11 @@ int bnge_reserve_rings(struct bnge_dev *bd)
if (!bnge_rings_ok(&hwr))
return -ENOMEM;
- if (old_rx_rings != bd->hw_resc.resv_rx_rings)
- bnge_set_dflt_rss_indir_tbl(bd);
+ if (old_rx_rings != bd->hw_resc.resv_rx_rings || rx_changed) {
+ if (!bd->netdev || !netif_is_rxfh_configured(bd->netdev))
+ bnge_set_dflt_rss_indir_tbl(bd, NULL);
+ bnge_refill_dflt_rss_ctxs(bd);
+ }
if (!bnge_aux_registered(bd)) {
u16 resv_msix, resv_ctx, aux_ctxs;
@@ -572,6 +615,39 @@ static int bnge_alloc_rss_indir_tbl(struct bnge_dev *bd)
return 0;
}
+/* Check and reserve hardware resources for a new RSS context */
+bool bnge_rss_ctx_capable(struct bnge_dev *bd)
+{
+ struct bnge_hw_rings hwr = {};
+ int max_vnics, max_rss_ctxs;
+
+ hwr.grp = bd->rx_nr_rings;
+ hwr.vnic = bnge_get_total_vnics(bd) + 1;
+ /* The RSS context count scales with hwr.vnic, set it first */
+ hwr.rss_ctx = bnge_get_total_rss_ctxs(bd, &hwr);
+ max_vnics = bnge_get_max_func_vnics(bd);
+ max_rss_ctxs = bnge_get_max_func_rss_ctxs(bd);
+
+ if (hwr.vnic > max_vnics || hwr.rss_ctx > max_rss_ctxs) {
+ if (bd->rx_nr_rings > 1)
+ dev_warn(bd->dev,
+ "Not enough resources to support RSS context\n");
+ return false;
+ }
+
+ if (hwr.vnic <= bd->hw_resc.resv_vnics &&
+ hwr.rss_ctx <= bd->hw_resc.resv_rsscos_ctxs)
+ return true;
+
+ bnge_hwrm_reserve_rings(bd, &hwr);
+ if (hwr.vnic <= bd->hw_resc.resv_vnics &&
+ hwr.rss_ctx <= bd->hw_resc.resv_rsscos_ctxs)
+ return true;
+
+ dev_warn(bd->dev, "Unable to reserve resources to support RSS context\n");
+ return false;
+}
+
int bnge_net_init_dflt_config(struct bnge_dev *bd)
{
struct bnge_hw_resc *hw_resc;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.h b/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
index 97e8ef08974c..278d98ea9da6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.h
@@ -75,7 +75,7 @@ void bnge_aux_init_dflt_config(struct bnge_dev *bd);
u32 bnge_get_rxfh_indir_size(struct bnge_dev *bd);
int bnge_cal_nr_rss_ctxs(u16 rx_rings);
bool bnge_aux_has_enough_resources(struct bnge_dev *bd);
-bool bnge_arfs_capable(struct bnge_dev *bd, bool new_rss_ctx);
+bool bnge_rss_ctx_capable(struct bnge_dev *bd);
static inline u32
bnge_adjust_pow_two(u32 total_ent, u16 ent_per_blk)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
index a44971a7c74d..dae6dc2f3302 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
@@ -12,21 +12,26 @@
#include "bnge_filter.h"
#include "bnge_resc.h"
-void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd)
+void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd,
+ struct ethtool_rxfh_context *rss_ctx)
{
u16 max_entries, pad;
u32 *rss_indir_tbl;
u16 i;
max_entries = bnge_get_rxfh_indir_size(bd);
- rss_indir_tbl = &bd->rss_indir_tbl[0];
+
+ if (rss_ctx)
+ rss_indir_tbl = ethtool_rxfh_context_indir(rss_ctx);
+ else
+ rss_indir_tbl = &bd->rss_indir_tbl[0];
for (i = 0; i < max_entries; i++)
rss_indir_tbl[i] = ethtool_rxfh_indir_default(i,
bd->rx_nr_rings);
pad = bd->rss_indir_tbl_entries - max_entries;
- if (pad)
+ if (pad && !rss_ctx)
memset(&rss_indir_tbl[i], 0, pad * sizeof(*rss_indir_tbl));
}
@@ -44,9 +49,18 @@ void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic)
if (vnic->flags & BNGE_VNIC_NTUPLE_FLAG)
j = ethtool_rxfh_indir_default(i, bd->rx_nr_rings);
+ else if (vnic->flags & BNGE_VNIC_RSSCTX_FLAG)
+ j = ethtool_rxfh_context_indir(vnic->rss_ctx)[i];
else
j = bd->rss_indir_tbl[i];
+ /* Defensive fallback: custom contexts with stale indices are
+ * invalidated via ethtool_rxfh_context_lost() during ring
+ * reduction. Clamp here to prevent out-of-bounds array reads.
+ */
+ if (j >= bd->rx_nr_rings)
+ j = ethtool_rxfh_indir_default(i, bd->rx_nr_rings);
+
rxr = &bn->rx_ring[j];
ring_id = rxr->rx_ring_struct.fw_ring_id;
@@ -155,7 +169,7 @@ void bnge_modify_rss(struct bnge_net *bn, struct ethtool_rxfh_context *ctx,
for (i = 0; i < tbl_size; i++)
indir_tbl[i] = rxfh->indir[i];
pad = bd->rss_indir_tbl_entries - tbl_size;
- if (pad)
+ if (pad && !rss_ctx)
memset(&indir_tbl[i], 0, pad * sizeof(*indir_tbl));
}
}
@@ -168,8 +182,11 @@ void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
bnge_hwrm_vnic_free_one(bn->bd, &rss_ctx->vnic);
for (i = 0; i < BNGE_MAX_CTX_PER_VNIC; i++) {
- if (vnic->fw_rss_cos_lb_ctx[i] != INVALID_HW_RING_ID)
+ if (vnic->fw_rss_cos_lb_ctx[i] != INVALID_HW_RING_ID) {
bnge_hwrm_vnic_ctx_free_one(bn->bd, vnic, i);
+ vnic->fw_rss_cos_lb_ctx[i] = INVALID_HW_RING_ID;
+ bn->rsscos_nr_ctxs--;
+ }
}
if (!all)
@@ -188,6 +205,10 @@ void bnge_hwrm_realloc_rss_ctx_vnic(struct bnge_net *bn)
struct ethtool_rxfh_context *ctx;
unsigned long context;
+ /* Erasing lost contexts touches netdev->ethtool->rss_ctx and calls
+ * ethtool_rxfh_context_lost(), which requires the ethtool rss_lock.
+ */
+ mutex_lock(&bn->netdev->ethtool->rss_lock);
xa_for_each(&bn->netdev->ethtool->rss_ctx, context, ctx) {
struct bnge_rss_ctx *rss_ctx = ethtool_rxfh_context_priv(ctx);
struct bnge_vnic_info *vnic = &rss_ctx->vnic;
@@ -201,6 +222,88 @@ void bnge_hwrm_realloc_rss_ctx_vnic(struct bnge_net *bn)
ethtool_rxfh_context_lost(bn->netdev, rss_ctx->index);
}
}
+ mutex_unlock(&bn->netdev->ethtool->rss_lock);
+}
+
+void bnge_check_rss_ctxs_lost(struct bnge_dev *bd, u16 new_rx_rings)
+{
+ struct ethtool_rxfh_context *ctx;
+ unsigned long context;
+ struct bnge_net *bn;
+
+ if (!bd->netdev)
+ return;
+
+ bn = netdev_priv(bd->netdev);
+ mutex_lock(&bd->netdev->ethtool->rss_lock);
+ xa_for_each(&bd->netdev->ethtool->rss_ctx, context, ctx) {
+ struct bnge_rss_ctx *rss_ctx = ethtool_rxfh_context_priv(ctx);
+ u32 *indir = ethtool_rxfh_context_indir(ctx);
+ bool lost = false;
+ u32 i;
+
+ if (!ctx->indir_user_size)
+ continue;
+
+ if (bnge_cal_nr_rss_ctxs(bd->rx_nr_rings) !=
+ bnge_cal_nr_rss_ctxs(new_rx_rings)) {
+ lost = true;
+ } else {
+ for (i = 0; i < ctx->indir_size; i++) {
+ if (indir[i] >= new_rx_rings) {
+ lost = true;
+ break;
+ }
+ }
+ }
+
+ if (lost) {
+ bnge_del_one_rss_ctx(bn, rss_ctx, true);
+ ethtool_rxfh_context_lost(bd->netdev, rss_ctx->index);
+ }
+ }
+ mutex_unlock(&bd->netdev->ethtool->rss_lock);
+}
+
+void bnge_refill_dflt_rss_ctxs(struct bnge_dev *bd)
+{
+ struct ethtool_rxfh_context *ctx;
+ unsigned long context;
+ bool resize = false;
+ u32 tbl_size;
+
+ if (!bd->netdev)
+ return;
+
+ tbl_size = bnge_get_rxfh_indir_size(bd);
+ mutex_lock(&bd->netdev->ethtool->rss_lock);
+ xa_for_each(&bd->netdev->ethtool->rss_ctx, context, ctx) {
+ if (ctx->indir_size != tbl_size) {
+ resize = true;
+ break;
+ }
+ }
+ mutex_unlock(&bd->netdev->ethtool->rss_lock);
+
+ /* Contexts with a user table that no longer fits were already
+ * dropped by bnge_check_rss_ctxs_lost(); only default ones resize.
+ */
+ if (resize) {
+ if (ethtool_rxfh_ctxs_can_resize(bd->netdev, tbl_size)) {
+ dev_warn(bd->dev,
+ "RSS contexts cannot be resized to %u entries\n",
+ tbl_size);
+ return;
+ }
+ ethtool_rxfh_ctxs_resize(bd->netdev, tbl_size);
+ }
+
+ mutex_lock(&bd->netdev->ethtool->rss_lock);
+ xa_for_each(&bd->netdev->ethtool->rss_ctx, context, ctx) {
+ if (!ctx->indir_user_size)
+ bnge_set_dflt_rss_indir_tbl(bd, ctx);
+ }
+ mutex_unlock(&bd->netdev->ethtool->rss_lock);
}
void bnge_clear_rss_ctxs(struct bnge_net *bn)
@@ -242,3 +345,14 @@ int bnge_alloc_vnic_rss_table(struct bnge_net *bn,
vnic->rss_hash_key_dma_addr = vnic->rss_table_dma_addr + size;
return 0;
}
+
+void bnge_init_vnic_mem(struct bnge_vnic_info *vnic)
+{
+ int i;
+
+ vnic->fw_vnic_id = INVALID_HW_RING_ID;
+ vnic->vnic_id = BNGE_VNIC_ID_INVALID;
+
+ for (i = 0; i < BNGE_MAX_CTX_PER_VNIC; i++)
+ vnic->fw_rss_cos_lb_ctx[i] = INVALID_HW_RING_ID;
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
index d11bd33fe254..58f17579db3d 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -22,6 +22,11 @@ struct bnge_l2_filter;
#define BNGE_MAX_MC_ADDRS 16
#define BNGE_MAX_UC_ADDRS 4
+#define BNGE_VNIC_ID_INVALID 0xffffffff
+
+struct ethtool_rxfh_context;
+struct ethtool_rxfh_param;
+
enum {
BNGE_VNIC_DEFAULT = 0,
BNGE_VNIC_NTUPLE = 1,
@@ -32,7 +37,8 @@ enum {
BNGE_VNIC_RSS_FLAG = BIT(0),
BNGE_VNIC_MCAST_FLAG = BIT(1),
BNGE_VNIC_UCAST_FLAG = BIT(2),
- BNGE_VNIC_NTUPLE_FLAG = BIT(3)
+ BNGE_VNIC_NTUPLE_FLAG = BIT(3),
+ BNGE_VNIC_RSSCTX_FLAG = BIT(4)
};
struct bnge_vnic_info {
@@ -57,6 +63,8 @@ struct bnge_vnic_info {
u32 flags;
u32 vnic_id;
+
+ struct ethtool_rxfh_context *rss_ctx;
};
struct bnge_rss_ctx {
@@ -68,7 +76,8 @@ void bnge_fill_hw_rss_tbl(struct bnge_net *bn, struct bnge_vnic_info *vnic);
int bnge_hwrm_vnic_rss_cfg(struct bnge_net *bn,
struct bnge_vnic_info *vnic);
int bnge_setup_vnic(struct bnge_net *bn, struct bnge_vnic_info *vnic);
-void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd);
+void bnge_set_dflt_rss_indir_tbl(struct bnge_dev *bd,
+ struct ethtool_rxfh_context *ctx);
int bnge_alloc_rfs_vnic(struct bnge_net *bn);
int bnge_alloc_vnic_rss_table(struct bnge_net *bn,
struct bnge_vnic_info *vnic);
@@ -78,6 +87,9 @@ void bnge_modify_rss(struct bnge_net *bn, struct ethtool_rxfh_context *ctx,
const struct ethtool_rxfh_param *rxfh);
void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
bool all);
+void bnge_check_rss_ctxs_lost(struct bnge_dev *bd, u16 new_rx_rings);
+void bnge_refill_dflt_rss_ctxs(struct bnge_dev *bd);
void bnge_hwrm_realloc_rss_ctx_vnic(struct bnge_net *bn);
void bnge_clear_rss_ctxs(struct bnge_net *bn);
+void bnge_init_vnic_mem(struct bnge_vnic_info *vnic);
#endif /* _BNGE_VNIC_H_ */
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 06/10] bnge: remove refcount from L2 filter
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (4 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 05/10] bnge: add ethtool support to manage RSS contexts Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 07/10] bnge: add NTUPLE filter infrastructure Vikas Gupta
` (3 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
A reference count was previously used under the assumption that any
context holding the last reference could delete the L2 filter.
However, going forward, the filter will only be removed by the same
context that created it, making refcount unnecessary.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_filter.c | 33 +++++++------------
.../net/ethernet/broadcom/bnge/bnge_filter.h | 2 --
2 files changed, 11 insertions(+), 24 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
index a8bb441ebef9..6316f75ca36e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
@@ -4,6 +4,7 @@
#include <linux/kernel.h>
#include <linux/dma-mapping.h>
#include <linux/jhash.h>
+#include <net/netdev_lock.h>
#include "bnge.h"
#include "bnge_netdev.h"
@@ -13,8 +14,8 @@
void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr)
{
- if (!refcount_dec_and_test(&fltr->refcnt))
- return;
+ netdev_assert_locked_or_invisible(bn->netdev);
+
hlist_del_rcu(&fltr->base.hlist);
kfree_rcu(fltr, base.rcu);
}
@@ -31,18 +32,19 @@ static void bnge_init_l2_filter(struct bnge_net *bn,
head = &bn->l2_fltr_hash_tbl[idx];
hlist_add_head_rcu(&fltr->base.hlist, head);
- refcount_set(&fltr->refcnt, 1);
}
-static struct bnge_l2_filter *__bnge_lookup_l2_filter(struct bnge_net *bn,
- struct bnge_l2_key *key,
- u32 idx)
+static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u32 idx)
{
struct bnge_l2_filter *fltr;
struct hlist_head *head;
+ netdev_assert_locked_or_invisible(bn->netdev);
+
head = &bn->l2_fltr_hash_tbl[idx];
- hlist_for_each_entry_rcu(fltr, head, base.hlist) {
+ hlist_for_each_entry(fltr, head, base.hlist) {
struct bnge_l2_key *l2_key = &fltr->l2_key;
if (ether_addr_equal(l2_key->dst_mac_addr, key->dst_mac_addr) &&
@@ -52,20 +54,6 @@ static struct bnge_l2_filter *__bnge_lookup_l2_filter(struct bnge_net *bn,
return NULL;
}
-static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
- struct bnge_l2_key *key,
- u32 idx)
-{
- struct bnge_l2_filter *fltr;
-
- rcu_read_lock();
- fltr = __bnge_lookup_l2_filter(bn, key, idx);
- if (fltr)
- refcount_inc(&fltr->refcnt);
- rcu_read_unlock();
- return fltr;
-}
-
static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
struct bnge_l2_key *key,
gfp_t gfp)
@@ -75,9 +63,10 @@ static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
BNGE_L2_FLTR_HASH_MASK;
+
fltr = bnge_lookup_l2_filter(bn, key, idx);
if (fltr)
- return fltr;
+ return ERR_PTR(-EEXIST);
fltr = kzalloc_obj(*fltr, gfp);
if (!fltr)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
index ea1acefd70b4..372657cba43c 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
@@ -6,7 +6,6 @@
#include <linux/types.h>
#include <linux/if_ether.h>
-#include <linux/refcount.h>
#include <linux/jhash.h>
struct bnge_net;
@@ -49,7 +48,6 @@ struct bnge_l2_filter {
/* base filter must be the first member */
struct bnge_filter_base base;
struct bnge_l2_key l2_key;
- refcount_t refcnt;
};
void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr);
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 07/10] bnge: add NTUPLE filter infrastructure
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (5 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 06/10] bnge: remove refcount from L2 filter Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 08/10] bnge: add NTUPLE filter support in ethtool Vikas Gupta
` (2 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Add the core NTUPLE filter data structures and firmware command
wrappers needed for flow rule management.
This helps further patches implement user-created NTUPLE rules
as well as rules via kernel flow steering.
bd->max_fltr is the fixed BNGE_MAX_NTUPLE_FLTRS (8192). It is no
longer the sum of the firmware EM and WM flow counts and the L2 filter
count. It sizes ntp_fltr_bmap, limits bnge_insert_ntp_filter() and,
with the 128 L2 rules, is the rule count that ethtool reports.
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
---
drivers/net/ethernet/broadcom/bnge/bnge.h | 1 -
.../net/ethernet/broadcom/bnge/bnge_filter.c | 498 +++++++++++++++++-
.../net/ethernet/broadcom/bnge/bnge_filter.h | 69 ++-
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 157 +++++-
.../ethernet/broadcom/bnge/bnge_hwrm_lib.h | 6 +
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 33 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 17 +
.../net/ethernet/broadcom/bnge/bnge_resc.c | 6 +-
.../net/ethernet/broadcom/bnge/bnge_vnic.c | 20 +
9 files changed, 791 insertions(+), 16 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge.h b/drivers/net/ethernet/broadcom/bnge/bnge.h
index aeb4b1ef628a..d3c9b214c0dc 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge.h
@@ -159,7 +159,6 @@ struct bnge_dev {
u16 tso_max_segs;
int max_fltr;
-#define BNGE_L2_FLTR_MAX_FLTR 1024
u32 *rss_indir_tbl;
u16 rss_indir_tbl_entries;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
index 6316f75ca36e..3ebb3cae4829 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
@@ -5,6 +5,7 @@
#include <linux/dma-mapping.h>
#include <linux/jhash.h>
#include <net/netdev_lock.h>
+#include <net/ipv6.h>
#include "bnge.h"
#include "bnge_netdev.h"
@@ -12,26 +13,150 @@
#include "bnge_hwrm_lib.h"
#include "bnge_filter.h"
-void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr)
+#define BNGE_IPV6_MASK_ALL {{{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, \
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }}}
+#define BNGE_IPV6_MASK_NONE {{{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }}}
+
+const struct bnge_flow_masks BNGE_FLOW_MASK_NONE = {
+ .ports = {
+ .src = 0,
+ .dst = 0,
+ },
+ .addrs = {
+ .v6addrs = {
+ .src = BNGE_IPV6_MASK_NONE,
+ .dst = BNGE_IPV6_MASK_NONE,
+ },
+ },
+};
+
+const struct bnge_flow_masks BNGE_FLOW_IPV6_MASK_ALL = {
+ .ports = {
+ .src = cpu_to_be16(0xffff),
+ .dst = cpu_to_be16(0xffff),
+ },
+ .addrs = {
+ .v6addrs = {
+ .src = BNGE_IPV6_MASK_ALL,
+ .dst = BNGE_IPV6_MASK_ALL,
+ },
+ },
+};
+
+const struct bnge_flow_masks BNGE_FLOW_IPV4_MASK_ALL = {
+ .ports = {
+ .src = cpu_to_be16(0xffff),
+ .dst = cpu_to_be16(0xffff),
+ },
+ .addrs = {
+ .v4addrs = {
+ .src = cpu_to_be32(0xffffffff),
+ .dst = cpu_to_be32(0xffffffff),
+ },
+ },
+};
+
+static bool bnge_is_usr_fltr(struct bnge_filter_base *fltr)
{
- netdev_assert_locked_or_invisible(bn->netdev);
+ return (fltr->type == BNGE_FLTR_TYPE_L2 &&
+ fltr->flags & BNGE_ACT_RING_DST) ||
+ (fltr->type == BNGE_FLTR_TYPE_NTUPLE &&
+ fltr->flags & BNGE_ACT_NO_AGING);
+}
+
+static void bnge_insert_usr_fltr(struct bnge_net *bn,
+ struct bnge_filter_base *fltr)
+{
+ if (!bnge_is_usr_fltr(fltr))
+ return;
+
+ INIT_LIST_HEAD(&fltr->list_node);
+ list_add_tail(&fltr->list_node, &bn->usr_fltr_list);
+ bn->user_fltr_count++;
+}
+
+static void bnge_del_usr_fltr_node(struct bnge_net *bn,
+ struct bnge_filter_base *fltr)
+{
+ if (!bnge_is_usr_fltr(fltr))
+ return;
+
+ if (!list_empty(&fltr->list_node)) {
+ list_del_init(&fltr->list_node);
+ bn->user_fltr_count--;
+ }
+}
+
+void bnge_del_l2_filter_rcu(struct bnge_net *bn, struct bnge_l2_filter *lfltr)
+{
+ struct bnge_filter_base *fltr = &lfltr->base;
+
+ hlist_del_rcu(&fltr->hlist);
+ bnge_del_usr_fltr_node(bn, fltr);
+ clear_bit(fltr->sw_id, bn->l2_fltr_bmap);
+ bn->l2_fltr_count--;
+ kfree_rcu(lfltr, base.rcu);
+}
+
+void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *lfltr)
+{
+ struct bnge_filter_base *fltr = &lfltr->base;
+ hlist_del(&fltr->hlist);
+ bnge_del_usr_fltr_node(bn, fltr);
+ clear_bit(fltr->sw_id, bn->l2_fltr_bmap);
+ bn->l2_fltr_count--;
+ kfree(fltr);
+}
+
+void bnge_del_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *nfltr)
+{
+ struct bnge_filter_base *fltr = &nfltr->base;
+
+ hlist_del(&fltr->hlist);
+ bnge_del_usr_fltr_node(bn, fltr);
+ clear_bit(fltr->sw_id, bn->ntp_fltr_bmap);
+ bn->ntp_fltr_count--;
+ kfree(fltr);
+}
+
+void bnge_del_ntp_filter_rcu(struct bnge_net *bn,
+ struct bnge_ntuple_filter *fltr)
+{
+ spin_lock_bh(&bn->ntp_fltr_lock);
hlist_del_rcu(&fltr->base.hlist);
+ bnge_del_usr_fltr_node(bn, &fltr->base);
+ clear_bit(fltr->base.sw_id, bn->ntp_fltr_bmap);
+ bn->ntp_fltr_count--;
+ spin_unlock_bh(&bn->ntp_fltr_lock);
+
kfree_rcu(fltr, base.rcu);
}
-static void bnge_init_l2_filter(struct bnge_net *bn,
- struct bnge_l2_filter *fltr,
- struct bnge_l2_key *key, u32 idx)
+static int bnge_init_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_filter *fltr,
+ struct bnge_l2_key *key, u32 idx)
{
struct hlist_head *head;
+ int bit_id;
ether_addr_copy(fltr->l2_key.dst_mac_addr, key->dst_mac_addr);
fltr->l2_key.vlan = key->vlan;
fltr->base.type = BNGE_FLTR_TYPE_L2;
+ fltr->base.filter_id = BNGE_FLTR_ID_INVALID;
+
+ bit_id = bitmap_find_free_region(bn->l2_fltr_bmap,
+ BNGE_MAX_L2_FLTRS, 0);
+ if (bit_id < 0)
+ return -ENOMEM;
+ fltr->base.sw_id = (u16)bit_id;
+
+ bn->l2_fltr_count++;
head = &bn->l2_fltr_hash_tbl[idx];
hlist_add_head_rcu(&fltr->base.hlist, head);
+ bnge_insert_usr_fltr(bn, &fltr->base);
+ return 0;
}
static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
@@ -54,12 +179,42 @@ static struct bnge_l2_filter *bnge_lookup_l2_filter(struct bnge_net *bn,
return NULL;
}
+__le64 bnge_lookup_l2_filter_rcu(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u32 idx)
+{
+ __le64 id = BNGE_FLTR_ID_INVALID;
+ struct bnge_l2_filter *fltr;
+ struct hlist_head *head;
+
+ rcu_read_lock();
+
+ head = &bn->l2_fltr_hash_tbl[idx];
+ hlist_for_each_entry_rcu(fltr, head, base.hlist) {
+ struct bnge_l2_key *l2_key = &fltr->l2_key;
+
+ if (ether_addr_equal(l2_key->dst_mac_addr, key->dst_mac_addr) &&
+ l2_key->vlan == key->vlan) {
+ if (test_bit(BNGE_FLTR_VALID, &fltr->base.state)) {
+ /* Pairs with smp_wmb() in bnge_hwrm_l2_filter_alloc() */
+ smp_rmb();
+ id = fltr->base.filter_id;
+ }
+ break;
+ }
+ }
+
+ rcu_read_unlock();
+ return id;
+}
+
static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
struct bnge_l2_key *key,
gfp_t gfp)
{
struct bnge_l2_filter *fltr;
u32 idx;
+ int rc;
idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
BNGE_L2_FLTR_HASH_MASK;
@@ -72,10 +227,339 @@ static struct bnge_l2_filter *bnge_alloc_l2_filter(struct bnge_net *bn,
if (!fltr)
return ERR_PTR(-ENOMEM);
- bnge_init_l2_filter(bn, fltr, key, idx);
+ rc = bnge_init_l2_filter(bn, fltr, key, idx);
+ if (rc) {
+ kfree(fltr);
+ fltr = ERR_PTR(rc);
+ }
+
return fltr;
}
+struct bnge_l2_filter *bnge_alloc_user_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u8 flags)
+{
+ struct bnge_l2_filter *fltr;
+ u32 idx;
+ int rc;
+
+ idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
+ BNGE_L2_FLTR_HASH_MASK;
+ fltr = bnge_lookup_l2_filter(bn, key, idx);
+ if (fltr) {
+ fltr = ERR_PTR(-EEXIST);
+ goto l2_filter_exit;
+ }
+ fltr = kzalloc_obj(*fltr, GFP_KERNEL);
+ if (!fltr) {
+ fltr = ERR_PTR(-ENOMEM);
+ goto l2_filter_exit;
+ }
+ fltr->base.flags = flags;
+ rc = bnge_init_l2_filter(bn, fltr, key, idx);
+ if (rc) {
+ kfree(fltr);
+ return ERR_PTR(rc);
+ }
+
+l2_filter_exit:
+ return fltr;
+}
+
+void bnge_free_l2_filters(struct bnge_net *bn)
+{
+ int i;
+
+ netdev_assert_locked_or_invisible(bn->netdev);
+
+ for (i = 0; i < BNGE_L2_FLTR_HASH_SIZE; i++) {
+ struct bnge_l2_filter *fltr;
+ struct hlist_head *head;
+ struct hlist_node *tmp;
+
+ head = &bn->l2_fltr_hash_tbl[i];
+ hlist_for_each_entry_safe(fltr, tmp, head, base.hlist)
+ bnge_del_l2_filter(bn, fltr);
+ }
+
+ bitmap_free(bn->l2_fltr_bmap);
+ bn->l2_fltr_bmap = NULL;
+ bn->l2_fltr_count = 0;
+}
+
+void bnge_free_ntp_fltrs(struct bnge_net *bn, bool skip_user)
+{
+ int i;
+
+ netdev_assert_locked_or_invisible(bn->netdev);
+
+ /* Under netdev instance lock and all our NAPIs have been disabled.
+ * It's safe to delete the hash table.
+ */
+ for (i = 0; i < BNGE_NTP_FLTR_HASH_SIZE; i++) {
+ struct bnge_ntuple_filter *fltr;
+ struct hlist_head *head;
+ struct hlist_node *tmp;
+
+ head = &bn->ntp_fltr_hash_tbl[i];
+ hlist_for_each_entry_safe(fltr, tmp, head, base.hlist) {
+ if (skip_user && bnge_is_usr_fltr(&fltr->base))
+ continue;
+ bnge_del_ntp_filter(bn, fltr);
+ }
+ }
+
+ if (skip_user)
+ return;
+
+ bitmap_free(bn->ntp_fltr_bmap);
+ bn->ntp_fltr_bmap = NULL;
+ bn->ntp_fltr_count = 0;
+}
+
+static int bnge_alloc_l2_fltrs_mem(struct bnge_net *bn)
+{
+ int i, rc = 0;
+
+ if (bn->l2_fltr_bmap)
+ return 0;
+
+ for (i = 0; i < BNGE_L2_FLTR_HASH_SIZE; i++)
+ INIT_HLIST_HEAD(&bn->l2_fltr_hash_tbl[i]);
+
+ bn->l2_fltr_count = 0;
+ bn->l2_fltr_bmap = bitmap_zalloc(BNGE_MAX_L2_FLTRS, GFP_KERNEL);
+
+ if (!bn->l2_fltr_bmap)
+ rc = -ENOMEM;
+
+ return rc;
+}
+
+static int bnge_alloc_ntp_fltrs_mem(struct bnge_net *bn)
+{
+ struct bnge_dev *bd = bn->bd;
+ int i, rc = 0;
+
+ if (!(bn->priv_flags & BNGE_NET_EN_NTUPLE) || bn->ntp_fltr_bmap)
+ return 0;
+
+ for (i = 0; i < BNGE_NTP_FLTR_HASH_SIZE; i++)
+ INIT_HLIST_HEAD(&bn->ntp_fltr_hash_tbl[i]);
+
+ bn->ntp_fltr_count = 0;
+ bn->ntp_fltr_bmap = bitmap_zalloc(bd->max_fltr, GFP_KERNEL);
+
+ if (!bn->ntp_fltr_bmap)
+ rc = -ENOMEM;
+
+ return rc;
+}
+
+int bnge_fltrs_mem(struct bnge_net *bn)
+{
+ bool ntp_alloced = !bn->ntp_fltr_bmap;
+ int rc;
+
+ rc = bnge_alloc_ntp_fltrs_mem(bn);
+ if (rc)
+ return rc;
+
+ rc = bnge_alloc_l2_fltrs_mem(bn);
+ if (rc)
+ goto err_free_ntp_mem;
+
+ return 0;
+
+err_free_ntp_mem:
+ if (ntp_alloced) {
+ bitmap_free(bn->ntp_fltr_bmap);
+ bn->ntp_fltr_bmap = NULL;
+ }
+ return rc;
+}
+
+#define BNGE_IPV4_4TUPLE(bd, fkeys) \
+ (((fkeys)->basic.ip_proto == IPPROTO_TCP && \
+ (bd)->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV4) || \
+ ((fkeys)->basic.ip_proto == IPPROTO_UDP && \
+ (bd)->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV4))
+
+#define BNGE_IPV6_4TUPLE(bd, fkeys) \
+ (((fkeys)->basic.ip_proto == IPPROTO_TCP && \
+ (bd)->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_TCP_IPV6) || \
+ ((fkeys)->basic.ip_proto == IPPROTO_UDP && \
+ (bd)->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_UDP_IPV6))
+
+static u32 bnge_get_rss_flow_tuple_len(struct bnge_dev *bd,
+ struct flow_keys *fkeys)
+{
+ if (fkeys->basic.n_proto == htons(ETH_P_IP)) {
+ if (BNGE_IPV4_4TUPLE(bd, fkeys))
+ return sizeof(fkeys->addrs.v4addrs) +
+ sizeof(fkeys->ports);
+
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV4)
+ return sizeof(fkeys->addrs.v4addrs);
+ }
+
+ if (fkeys->basic.n_proto == htons(ETH_P_IPV6)) {
+ if (BNGE_IPV6_4TUPLE(bd, fkeys))
+ return sizeof(fkeys->addrs.v6addrs) +
+ sizeof(fkeys->ports);
+
+ if (bd->rss_hash_cfg & VNIC_RSS_CFG_REQ_HASH_TYPE_IPV6)
+ return sizeof(fkeys->addrs.v6addrs);
+ }
+
+ return 0;
+}
+
+static u32 bnge_toeplitz(struct bnge_net *bn, struct flow_keys *fkeys,
+ const unsigned char *key)
+{
+ u64 prefix = bn->toeplitz_prefix, hash = 0;
+ struct bnge_ipv4_tuple tuple4;
+ struct bnge_ipv6_tuple tuple6;
+ struct bnge_dev *bd = bn->bd;
+ u8 *four_tuple;
+ int i, j, len;
+
+ len = bnge_get_rss_flow_tuple_len(bd, fkeys);
+ if (!len)
+ return 0;
+
+ if (fkeys->basic.n_proto == htons(ETH_P_IP)) {
+ tuple4.v4addrs = fkeys->addrs.v4addrs;
+ tuple4.ports = fkeys->ports;
+ four_tuple = (u8 *)&tuple4;
+ } else {
+ tuple6.v6addrs = fkeys->addrs.v6addrs;
+ tuple6.ports = fkeys->ports;
+ four_tuple = (u8 *)&tuple6;
+ }
+
+ for (i = 0, j = 8; i < len; i++, j++) {
+ u8 byte = four_tuple[i];
+ int bit;
+
+ for (bit = 0; bit < 8; bit++, prefix <<= 1, byte <<= 1) {
+ if (byte & 0x80)
+ hash ^= prefix;
+ }
+ prefix |= (j < HW_HASH_KEY_SIZE) ? key[j] : 0;
+ }
+
+ /* The valid part of the hash is in the upper 32 bits. */
+ return (hash >> 32) & BNGE_NTP_FLTR_HASH_MASK;
+}
+
+u32 bnge_get_ntp_filter_idx(struct bnge_net *bn, struct flow_keys *fkeys,
+ const struct sk_buff *skb)
+{
+ struct bnge_vnic_info *vnic;
+
+ if (skb)
+ return skb_get_hash_raw(skb) & BNGE_NTP_FLTR_HASH_MASK;
+
+ vnic = &bn->vnic_info[BNGE_VNIC_DEFAULT];
+ return bnge_toeplitz(bn, fkeys, (void *)vnic->rss_hash_key);
+}
+
+static bool bnge_fltr_match(struct bnge_ntuple_filter *f1,
+ struct bnge_ntuple_filter *f2)
+{
+ struct bnge_flow_masks *masks1 = &f1->fmasks;
+ struct bnge_flow_masks *masks2 = &f2->fmasks;
+ struct flow_keys *keys1 = &f1->fkeys;
+ struct flow_keys *keys2 = &f2->fkeys;
+
+ if (keys1->basic.n_proto != keys2->basic.n_proto ||
+ keys1->basic.ip_proto != keys2->basic.ip_proto)
+ return false;
+
+ if (keys1->basic.n_proto == htons(ETH_P_IP)) {
+ if (keys1->addrs.v4addrs.src != keys2->addrs.v4addrs.src ||
+ masks1->addrs.v4addrs.src != masks2->addrs.v4addrs.src ||
+ keys1->addrs.v4addrs.dst != keys2->addrs.v4addrs.dst ||
+ masks1->addrs.v4addrs.dst != masks2->addrs.v4addrs.dst)
+ return false;
+ } else {
+ if (!ipv6_addr_equal(&keys1->addrs.v6addrs.src,
+ &keys2->addrs.v6addrs.src) ||
+ !ipv6_addr_equal(&masks1->addrs.v6addrs.src,
+ &masks2->addrs.v6addrs.src) ||
+ !ipv6_addr_equal(&keys1->addrs.v6addrs.dst,
+ &keys2->addrs.v6addrs.dst) ||
+ !ipv6_addr_equal(&masks1->addrs.v6addrs.dst,
+ &masks2->addrs.v6addrs.dst))
+ return false;
+ }
+
+ return keys1->ports.src == keys2->ports.src &&
+ masks1->ports.src == masks2->ports.src &&
+ keys1->ports.dst == keys2->ports.dst &&
+ masks1->ports.dst == masks2->ports.dst &&
+ keys1->control.flags == keys2->control.flags &&
+ f1->l2_filter_id == f2->l2_filter_id;
+}
+
+int bnge_insert_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *fltr,
+ u32 idx)
+{
+ struct bnge_ntuple_filter *f;
+ struct hlist_head *head;
+ int bit_id;
+
+ spin_lock_bh(&bn->ntp_fltr_lock);
+
+ head = &bn->ntp_fltr_hash_tbl[idx];
+ hlist_for_each_entry(f, head, base.hlist) {
+ if (bnge_fltr_match(f, fltr)) {
+ spin_unlock_bh(&bn->ntp_fltr_lock);
+ return -EEXIST;
+ }
+ }
+
+ bit_id = bitmap_find_free_region(bn->ntp_fltr_bmap,
+ bn->bd->max_fltr, 0);
+ if (bit_id < 0) {
+ spin_unlock_bh(&bn->ntp_fltr_lock);
+ return -ENOMEM;
+ }
+
+ fltr->base.sw_id = (u16)bit_id;
+ fltr->base.filter_id = BNGE_FLTR_ID_INVALID;
+ fltr->base.type = BNGE_FLTR_TYPE_NTUPLE;
+ fltr->base.flags |= BNGE_ACT_RING_DST;
+
+ head = &bn->ntp_fltr_hash_tbl[idx];
+ hlist_add_head_rcu(&fltr->base.hlist, head);
+
+ bnge_insert_usr_fltr(bn, &fltr->base);
+ bn->ntp_fltr_count++;
+
+ spin_unlock_bh(&bn->ntp_fltr_lock);
+
+ return 0;
+}
+
+struct bnge_ntuple_filter *
+bnge_lookup_ntp_filter_from_idx(struct bnge_net *bn,
+ struct bnge_ntuple_filter *fltr, u32 idx)
+{
+ struct bnge_ntuple_filter *f;
+ struct hlist_head *head;
+
+ head = &bn->ntp_fltr_hash_tbl[idx];
+ hlist_for_each_entry_rcu(f, head, base.hlist) {
+ if (bnge_fltr_match(f, fltr))
+ return f;
+ }
+ return NULL;
+}
+
int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
const u8 *mac_addr)
{
@@ -97,6 +581,6 @@ int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
return rc;
err_del_l2_filter:
- bnge_del_l2_filter(bn, fltr);
+ bnge_del_l2_filter_rcu(bn, fltr);
return rc;
}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
index 372657cba43c..87d66266a9f5 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
@@ -7,11 +7,14 @@
#include <linux/types.h>
#include <linux/if_ether.h>
#include <linux/jhash.h>
+#include <net/flow_dissector.h>
struct bnge_net;
+struct sk_buff;
enum {
- BNGE_FLTR_TYPE_L2 = 1
+ BNGE_FLTR_TYPE_L2 = 1,
+ BNGE_FLTR_TYPE_NTUPLE = 2
};
enum {
@@ -19,12 +22,23 @@ enum {
BNGE_FLTR_FW_DELETED
};
+enum {
+ BNGE_ACT_DROP = 0x1,
+ BNGE_ACT_RING_DST = 0x2,
+ BNGE_ACT_NO_AGING = 0x4,
+ BNGE_ACT_RSS_CTX = 0x8
+};
+
+#define BNGE_MAX_L2_FLTRS 128
+#define BNGE_MAX_NTUPLE_FLTRS (8 << 10)
+
struct bnge_filter_base {
struct hlist_node hlist;
struct list_head list_node;
__le64 filter_id;
u8 type;
u8 flags;
+ u16 sw_id;
u16 rxq;
u16 fw_vnic_id;
u16 vf_idx;
@@ -50,7 +64,60 @@ struct bnge_l2_filter {
struct bnge_l2_key l2_key;
};
+struct bnge_ipv4_tuple {
+ struct flow_dissector_key_ipv4_addrs v4addrs;
+ struct flow_dissector_key_ports ports;
+};
+
+struct bnge_ipv6_tuple {
+ struct flow_dissector_key_ipv6_addrs v6addrs;
+ struct flow_dissector_key_ports ports;
+};
+
+struct bnge_flow_masks {
+ struct flow_dissector_key_ports ports;
+ struct flow_dissector_key_addrs addrs;
+};
+
+extern const struct bnge_flow_masks BNGE_FLOW_MASK_NONE;
+extern const struct bnge_flow_masks BNGE_FLOW_IPV6_MASK_ALL;
+extern const struct bnge_flow_masks BNGE_FLOW_IPV4_MASK_ALL;
+
+struct bnge_ntuple_filter {
+ /* base filter must be the first member */
+ struct bnge_filter_base base;
+ struct flow_keys fkeys;
+ struct bnge_flow_masks fmasks;
+ __le64 l2_filter_id;
+ u32 flow_id;
+};
+
+#define BNGE_L2_FLTR_IS_NTP_MAC(fltr) ((fltr)->base.flags & BNGE_ACT_RING_DST)
+
+#define BNGE_FLTR_ID_INVALID cpu_to_le64(0xffffffffffffffffULL)
+
+void bnge_free_ntp_fltrs(struct bnge_net *bn, bool skip_user_filters);
+u32 bnge_get_ntp_filter_idx(struct bnge_net *bn, struct flow_keys *fkeys,
+ const struct sk_buff *skb);
+int bnge_insert_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *fltr,
+ u32 idx);
+struct bnge_ntuple_filter *
+bnge_lookup_ntp_filter_from_idx(struct bnge_net *bn,
+ struct bnge_ntuple_filter *fltr, u32 idx);
void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr);
+void bnge_del_l2_filter_rcu(struct bnge_net *bn, struct bnge_l2_filter *fltr);
+__le64 bnge_lookup_l2_filter_rcu(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u32 idx);
+void bnge_free_l2_filters(struct bnge_net *bn);
int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
const u8 *mac_addr);
+struct bnge_l2_filter *bnge_alloc_user_l2_filter(struct bnge_net *bn,
+ struct bnge_l2_key *key,
+ u8 flags);
+int bnge_fltrs_mem(struct bnge_net *bn);
+void bnge_del_ntp_filter(struct bnge_net *bn,
+ struct bnge_ntuple_filter *nfltr);
+void bnge_del_ntp_filter_rcu(struct bnge_net *bn,
+ struct bnge_ntuple_filter *fltr);
#endif /* _BNGE_FILTER_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index 86edb70d323e..33cbdd6d8276 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -8,6 +8,7 @@
#include <linux/bnge/hsi.h>
#include <linux/if_vlan.h>
#include <net/netdev_queues.h>
+#include <linux/ethtool.h>
#include "bnge.h"
#include "bnge_hwrm.h"
@@ -932,11 +933,165 @@ int bnge_hwrm_l2_filter_alloc(struct bnge_dev *bd, struct bnge_l2_filter *fltr)
req->l2_ivlan_mask = cpu_to_le16(0xfff);
}
+ if (BNGE_L2_FLTR_IS_NTP_MAC(fltr)) {
+ req->enables |= cpu_to_le32(CFA_L2_FILTER_ALLOC_REQ_ENABLES_RFS_RING_TBL_IDX);
+ req->rfs_ring_tbl_idx = cpu_to_le16(fltr->base.rxq);
+ }
+
resp = bnge_hwrm_req_hold(bd, req);
rc = bnge_hwrm_req_send(bd, req);
- if (!rc)
+ if (!rc) {
fltr->base.filter_id = resp->l2_filter_id;
+ /* Pairs with smp_rmb() in bnge_lookup_l2_filter_rcu() */
+ smp_wmb();
+ set_bit(BNGE_FLTR_VALID, &fltr->base.state);
+ }
+
+ bnge_hwrm_req_drop(bd, req);
+ return rc;
+}
+
+int bnge_hwrm_cfa_ntuple_filter_free(struct bnge_dev *bd,
+ struct bnge_ntuple_filter *fltr)
+{
+ struct hwrm_cfa_ntuple_filter_free_input *req;
+ int rc;
+
+ set_bit(BNGE_FLTR_FW_DELETED, &fltr->base.state);
+ if (!test_bit(BNGE_STATE_OPEN, &bd->state))
+ return 0;
+
+ /* Not programmed in firmware in this session, nothing to free */
+ if (fltr->base.filter_id == BNGE_FLTR_ID_INVALID)
+ return 0;
+
+ rc = bnge_hwrm_req_init(bd, req, HWRM_CFA_NTUPLE_FILTER_FREE);
+ if (rc)
+ return rc;
+
+ req->ntuple_filter_id = fltr->base.filter_id;
+ rc = bnge_hwrm_req_send(bd, req);
+ if (!rc)
+ fltr->base.filter_id = BNGE_FLTR_ID_INVALID;
+ return rc;
+}
+
+/* L4 port matching flags are unconditionally enabled here. For non-TCP/UDP
+ * flows (e.g. ICMP or wildcards), the port masks in fmasks are zeroed, which
+ * instructs firmware CFA to treat L4 ports as wildcards.
+ */
+#define BNGE_NTP_FLTR_FLAGS \
+ (CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_L2_FILTER_ID | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_ETHERTYPE | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_IPADDR_TYPE | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_SRC_IPADDR | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_SRC_IPADDR_MASK | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_DST_IPADDR | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_DST_IPADDR_MASK | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_IP_PROTOCOL | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_SRC_PORT | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_SRC_PORT_MASK | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_DST_PORT | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_DST_PORT_MASK | \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_DST_ID)
+
+#define BNGE_NTP_TUNNEL_FLTR_FLAG \
+ CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_TUNNEL_TYPE
+static void
+bnge_cfg_rfs_ring_tbl_idx(struct bnge_dev *bd,
+ struct hwrm_cfa_ntuple_filter_alloc_input *req,
+ struct bnge_ntuple_filter *fltr)
+{
+ struct bnge_net *bn = netdev_priv(bd->netdev);
+ struct bnge_vnic_info *def_vnic;
+ u32 rxq = fltr->base.rxq;
+ u32 enables;
+
+ if (fltr->base.flags & BNGE_ACT_RSS_CTX) {
+ struct ethtool_rxfh_context *ctx;
+ struct bnge_rss_ctx *rss_ctx;
+ struct bnge_vnic_info *vnic;
+
+ /* The RSS context was already validated via xa_load() when the
+ * filter was added (bnge_ethtool.c) under netdev instance lock,
+ * so it is always present here.
+ */
+ ctx = xa_load(&bd->netdev->ethtool->rss_ctx,
+ fltr->base.fw_vnic_id);
+ rss_ctx = ethtool_rxfh_context_priv(ctx);
+ vnic = &rss_ctx->vnic;
+ req->dst_id = cpu_to_le16(vnic->fw_vnic_id);
+ return;
+ }
+
+ def_vnic = &bn->vnic_info[BNGE_VNIC_NTUPLE];
+ req->dst_id = cpu_to_le16(def_vnic->fw_vnic_id);
+ enables = CFA_NTUPLE_FILTER_ALLOC_REQ_ENABLES_RFS_RING_TBL_IDX;
+ req->enables |= cpu_to_le32(enables);
+ req->rfs_ring_tbl_idx = cpu_to_le16(rxq);
+}
+
+int bnge_hwrm_cfa_ntuple_filter_alloc(struct bnge_dev *bd,
+ struct bnge_ntuple_filter *fltr)
+{
+ struct hwrm_cfa_ntuple_filter_alloc_output *resp;
+ struct hwrm_cfa_ntuple_filter_alloc_input *req;
+ struct bnge_flow_masks *masks = &fltr->fmasks;
+ struct flow_keys *keys = &fltr->fkeys;
+ int rc;
+
+ rc = bnge_hwrm_req_init(bd, req, HWRM_CFA_NTUPLE_FILTER_ALLOC);
+ if (rc)
+ return rc;
+
+ req->l2_filter_id = fltr->l2_filter_id;
+
+ if (fltr->base.flags & BNGE_ACT_DROP)
+ req->flags =
+ cpu_to_le32(CFA_NTUPLE_FILTER_ALLOC_REQ_FLAGS_DROP);
+ else
+ bnge_cfg_rfs_ring_tbl_idx(bd, req, fltr);
+
+ req->enables |= cpu_to_le32(BNGE_NTP_FLTR_FLAGS);
+
+ req->ethertype = htons(ETH_P_IP);
+ req->ip_addr_type = CFA_NTUPLE_FILTER_ALLOC_REQ_IP_ADDR_TYPE_IPV4;
+ req->ip_protocol = keys->basic.ip_proto;
+
+ if (keys->basic.n_proto == htons(ETH_P_IPV6)) {
+ req->ethertype = htons(ETH_P_IPV6);
+ req->ip_addr_type =
+ CFA_NTUPLE_FILTER_ALLOC_REQ_IP_ADDR_TYPE_IPV6;
+ memcpy(&req->src_ipaddr, &keys->addrs.v6addrs.src,
+ sizeof(struct in6_addr));
+ memcpy(&req->src_ipaddr_mask, &masks->addrs.v6addrs.src,
+ sizeof(struct in6_addr));
+ memcpy(&req->dst_ipaddr, &keys->addrs.v6addrs.dst,
+ sizeof(struct in6_addr));
+ memcpy(&req->dst_ipaddr_mask, &masks->addrs.v6addrs.dst,
+ sizeof(struct in6_addr));
+ } else {
+ req->src_ipaddr[0] = keys->addrs.v4addrs.src;
+ req->src_ipaddr_mask[0] = masks->addrs.v4addrs.src;
+ req->dst_ipaddr[0] = keys->addrs.v4addrs.dst;
+ req->dst_ipaddr_mask[0] = masks->addrs.v4addrs.dst;
+ }
+ if (keys->control.flags & FLOW_DIS_ENCAPSULATION) {
+ req->enables |= cpu_to_le32(BNGE_NTP_TUNNEL_FLTR_FLAG);
+ req->tunnel_type =
+ CFA_NTUPLE_FILTER_ALLOC_REQ_TUNNEL_TYPE_ANYTUNNEL;
+ }
+
+ req->src_port = keys->ports.src;
+ req->src_port_mask = masks->ports.src;
+ req->dst_port = keys->ports.dst;
+ req->dst_port_mask = masks->ports.dst;
+
+ resp = bnge_hwrm_req_hold(bd, req);
+ rc = bnge_hwrm_req_send(bd, req);
+ if (!rc)
+ fltr->base.filter_id = resp->ntuple_filter_id;
bnge_hwrm_req_drop(bd, req);
return rc;
}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
index ae03041c36ac..081233924449 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.h
@@ -13,6 +13,8 @@ struct bnge_l2_filter;
#define BNGE_VNIC_CFG_ROCE_DUAL_MODE \
VNIC_CFG_REQ_FLAGS_ROCE_DUAL_VNIC_MODE
+struct bnge_ntuple_filter;
+
int bnge_hwrm_ver_get(struct bnge_dev *bd);
int bnge_hwrm_func_reset(struct bnge_dev *bd);
int bnge_hwrm_fw_set_time(struct bnge_dev *bd);
@@ -67,4 +69,8 @@ int bnge_hwrm_shutdown_link(struct bnge_dev *bd);
int bnge_hwrm_port_qstats(struct bnge_dev *bd, u8 flags);
int bnge_hwrm_port_qstats_ext(struct bnge_dev *bd, u8 flags);
int bnge_hwrm_func_qstat_ext(struct bnge_dev *bd, struct bnge_stats_mem *stats);
+int bnge_hwrm_cfa_ntuple_filter_alloc(struct bnge_dev *bd,
+ struct bnge_ntuple_filter *fltr);
+int bnge_hwrm_cfa_ntuple_filter_free(struct bnge_dev *bd,
+ struct bnge_ntuple_filter *fltr);
#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 02ee1da8d57b..ff6573b5e60e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -1192,6 +1192,10 @@ static void bnge_free_core(struct bnge_net *bn)
bnge_free_ring_stats(bn);
bnge_free_ring_grps(bn);
bnge_free_vnics(bn);
+
+ /* Free non-user filters only */
+ bnge_free_ntp_fltrs(bn, true);
+
kfree(bn->tx_ring_map);
bn->tx_ring_map = NULL;
kfree(bn->tx_ring);
@@ -1280,6 +1284,10 @@ static int bnge_alloc_core(struct bnge_net *bn)
bnge_init_stats(bn);
+ rc = bnge_fltrs_mem(bn);
+ if (rc)
+ goto err_free_ring_stats;
+
rc = bnge_alloc_vnics(bn);
if (rc)
goto err_free_ring_stats;
@@ -2056,7 +2064,7 @@ static int bnge_cfg_rx_mode(struct bnge_net *bn, struct netdev_hw_addr_list *uc,
struct bnge_l2_filter *fltr = vnic->l2_filters[i];
bnge_hwrm_l2_filter_free(bd, fltr);
- bnge_del_l2_filter(bn, fltr);
+ bnge_del_l2_filter_rcu(bn, fltr);
}
vnic->uc_filter_count = 1;
@@ -2274,7 +2282,7 @@ static void bnge_hwrm_clear_vnic_filter(struct bnge_net *bn)
struct bnge_l2_filter *fltr = vnic->l2_filters[i];
bnge_hwrm_l2_filter_free(bn->bd, fltr);
- bnge_del_l2_filter(bn, fltr);
+ bnge_del_l2_filter_rcu(bn, fltr);
}
vnic->uc_filter_count = 0;
@@ -3008,6 +3016,7 @@ static void bnge_save_ring_stats(struct bnge_net *bn)
static void bnge_close_core(struct bnge_net *bn)
{
+ struct bnge_filter_base *fltr;
struct bnge_dev *bd = bn->bd;
bnge_tx_disable(bn);
@@ -3021,6 +3030,20 @@ static void bnge_close_core(struct bnge_net *bn)
bnge_disable_napi(bn);
+ /* Invalidate user L2 filters now that NAPI is disabled so that
+ * subsequent re-enabling during open cannot read a stale or torn
+ * filter_id before bnge_cfg_usr_fltrs() completes reallocation.
+ */
+ /* Only the driver's tracking is reset here. The user filters are
+ * programmed again by bnge_cfg_usr_fltrs() on the next open.
+ */
+ list_for_each_entry(fltr, &bn->usr_fltr_list, list_node) {
+ if (fltr->type == BNGE_FLTR_TYPE_L2)
+ clear_bit(BNGE_FLTR_VALID, &fltr->state);
+ else
+ fltr->filter_id = BNGE_FLTR_ID_INVALID;
+ }
+
/* Save ring stats before shutdown */
spin_lock_bh(&bn->stats_lock);
bnge_save_ring_stats(bn);
@@ -3422,6 +3445,9 @@ int bnge_netdev_alloc(struct bnge_dev *bd, int max_irqs)
goto err_free_workq;
spin_lock_init(&bn->stats_lock);
+ spin_lock_init(&bn->ntp_fltr_lock);
+ INIT_LIST_HEAD(&bn->usr_fltr_list);
+
netdev->request_ops_lock = true;
rc = register_netdev(netdev);
if (rc) {
@@ -3450,6 +3476,9 @@ void bnge_netdev_free(struct bnge_dev *bd)
unregister_netdev(netdev);
+ bnge_free_ntp_fltrs(bn, false);
+ bnge_free_l2_filters(bn);
+
timer_shutdown_sync(&bn->timer);
cancel_work_sync(&bn->sp_task);
bn->sp_event = 0;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 0512d983519e..2a1ec811de01 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -284,6 +284,9 @@ enum bnge_sp_event {
BNGE_PERIODIC_STATS_SP_EVENT,
};
+#define BNGE_NTP_FLTR_HASH_SIZE 512
+#define BNGE_NTP_FLTR_HASH_MASK (BNGE_NTP_FLTR_HASH_SIZE - 1)
+
struct bnge_net {
struct bnge_dev *bd;
struct net_device *netdev;
@@ -372,6 +375,20 @@ struct bnge_net {
bool pri2cos_valid;
u16 num_rss_ctx;
+
+ struct list_head usr_fltr_list;
+ unsigned long *ntp_fltr_bmap;
+ unsigned long *l2_fltr_bmap;
+ int ntp_fltr_count;
+ int l2_fltr_count;
+ int user_fltr_count;
+
+ struct hlist_head ntp_fltr_hash_tbl[BNGE_NTP_FLTR_HASH_SIZE];
+ /* Protects the aRFS/ntuple hash table add and delete. usr_fltr_list,
+ * l2_fltr_hash_tbl and l2_fltr_bmap are covered by the netdev instance
+ * lock instead.
+ */
+ spinlock_t ntp_fltr_lock;
};
#define BNGE_DEFAULT_RX_RING_SIZE 511
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
index 135224a33071..177309b1aaf9 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_resc.c
@@ -12,6 +12,7 @@
#include "bnge_hwrm_lib.h"
#include "bnge_resc.h"
#include "bnge_vnic.h"
+#include "bnge_filter.h"
static u16 bnge_num_tx_to_cp(struct bnge_dev *bd, u16 tx)
{
@@ -650,7 +651,6 @@ bool bnge_rss_ctx_capable(struct bnge_dev *bd)
int bnge_net_init_dflt_config(struct bnge_dev *bd)
{
- struct bnge_hw_resc *hw_resc;
int rc;
rc = bnge_alloc_rss_indir_tbl(bd);
@@ -661,9 +661,7 @@ int bnge_net_init_dflt_config(struct bnge_dev *bd)
if (rc)
goto err_free_tbl;
- hw_resc = &bd->hw_resc;
- bd->max_fltr = hw_resc->max_rx_em_flows + hw_resc->max_rx_wm_flows +
- BNGE_L2_FLTR_MAX_FLTR;
+ bd->max_fltr = BNGE_MAX_NTUPLE_FLTRS;
return 0;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
index dae6dc2f3302..9b8b6711d204 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.c
@@ -178,8 +178,15 @@ void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
bool all)
{
struct bnge_vnic_info *vnic = &rss_ctx->vnic;
+ struct bnge_filter_base *usr_fltr, *tmp;
+ struct bnge_ntuple_filter *ntp_fltr;
int i;
+ /* The kernel ethtool core prevents deleting a busy RSS context via
+ * ethtool_check_rss_ctx_busy().
+ * When all == false (interface down), software filters are deliberately
+ * preserved so they can be restored when the interface is brought up.
+ */
bnge_hwrm_vnic_free_one(bn->bd, &rss_ctx->vnic);
for (i = 0; i < BNGE_MAX_CTX_PER_VNIC; i++) {
if (vnic->fw_rss_cos_lb_ctx[i] != INVALID_HW_RING_ID) {
@@ -192,6 +199,19 @@ void bnge_del_one_rss_ctx(struct bnge_net *bn, struct bnge_rss_ctx *rss_ctx,
if (!all)
return;
+ /* Delete all filters associated with this user RSS context */
+ list_for_each_entry_safe(usr_fltr, tmp, &bn->usr_fltr_list, list_node) {
+ if (usr_fltr->type == BNGE_FLTR_TYPE_NTUPLE &&
+ (usr_fltr->flags & BNGE_ACT_RSS_CTX) &&
+ usr_fltr->fw_vnic_id == rss_ctx->index) {
+ ntp_fltr = container_of(usr_fltr,
+ struct bnge_ntuple_filter,
+ base);
+ bnge_hwrm_cfa_ntuple_filter_free(bn->bd, ntp_fltr);
+ bnge_del_ntp_filter_rcu(bn, ntp_fltr);
+ }
+ }
+
if (vnic->rss_table)
dma_free_coherent(bn->bd->dev, vnic->rss_table_size,
vnic->rss_table,
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 08/10] bnge: add NTUPLE filter support in ethtool
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (6 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 07/10] bnge: add NTUPLE filter infrastructure Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 09/10] bnge: add aRFS flow steering ndo support Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 10/10] bnge: add cpu_rmap support for IRQ affinity Vikas Gupta
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Introduce ethtool rx flow classification (rxnfc) operations for
NTUPLE filter management.
User filters stay in software while the interface is down.
bnge_cfg_usr_fltrs() programs them in firmware again on open, and
bnge_clear_usr_fltrs() deletes them when NTUPLE is turned off.
bnge_hwrm_l2_filter_alloc() sets CFA_L2_FILTER_ALLOC_REQ_FLAGS_TRAFFIC_L2
only for user ETHER_FLOW ring rules. The default and unicast MAC
filters keep the traffic type they had before this patch.
User ETHER_FLOW rules and the unicast address filters share the L2
filter table, so the result depends on the order in which a MAC is
added. If the rule is added first, a later unicast address for the same
MAC (a macvlan, for example) is left to the rule and is delivered only
to the rule's ring, not through the default VNIC. If the unicast address
is added first, adding a rule for the same MAC fails with -EEXIST.
When such a rule is deleted, bnge_del_usr_l2_filter() programs the
unicast filter of the MAC that the rule had been serving. If the
firmware refuses it, a warning is logged and the address is left
without a filter until its address list changes.
The unicast address filters and the user ETHER_FLOW rules share the
same L2 filters. After the old unicast filters are freed,
bnge_cfg_rx_mode() counts the free L2 filters, and when the
addresses do not fit it receives them in promiscuous mode, as
it already does for more than BNGE_MAX_L2_FLTRS - 1 addresses.
BNGE_MAX_UC_ADDRS (4) is removed. The per-VNIC l2_filters[] array and
the uc_list buffer are sized by BNGE_MAX_L2_FLTRS, the number of L2
filters of a function, because the unicast address filters and the user
rules share that pool and the free-L2-filter check above is what limits
them.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_ethtool.c | 607 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_filter.c | 112 ++++
.../net/ethernet/broadcom/bnge/bnge_filter.h | 3 +
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 9 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 23 +-
.../net/ethernet/broadcom/bnge/bnge_vnic.h | 5 +-
6 files changed, 752 insertions(+), 7 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
index c370686e2b38..dfffb3efc333 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
@@ -7,6 +7,7 @@
#include <net/devlink.h>
#include <linux/ethtool.h>
#include <linux/etherdevice.h>
+#include <linux/if_vlan.h>
#include <linux/ethtool_netlink.h>
#include "bnge.h"
@@ -15,6 +16,7 @@
#include "bnge_resc.h"
#include "bnge_ethtool.h"
#include "bnge_hwrm_lib.h"
+#include "bnge_filter.h"
static int bnge_nway_reset(struct net_device *dev)
{
@@ -1243,6 +1245,609 @@ static int bnge_remove_rxfh_context(struct net_device *dev,
return 0;
}
+#define BNGE_IP_PROTO_FULL_MASK 0xFF
+#define BNGE_IP_PROTO_WILDCARD 0x0
+
+static int bnge_get_all_fltr_ids_rcu(struct bnge_net *bn,
+ struct hlist_head tbl[],
+ u32 tbl_size, u32 *ids, u32 start,
+ u32 id_cnt, u32 offset)
+{
+ u32 i, j = start;
+
+ for (i = 0; i < tbl_size; i++) {
+ struct bnge_filter_base *fltr;
+ struct hlist_head *head;
+
+ head = &tbl[i];
+ hlist_for_each_entry_rcu(fltr, head, hlist) {
+ if (!fltr->flags ||
+ test_bit(BNGE_FLTR_FW_DELETED, &fltr->state))
+ continue;
+ if (j == id_cnt)
+ return -EMSGSIZE;
+ ids[j++] = fltr->sw_id + offset;
+ }
+ }
+ return j;
+}
+
+static struct bnge_filter_base *bnge_get_one_fltr_rcu(struct bnge_net *bn,
+ struct hlist_head tbl[],
+ u32 tbl_size, u32 id,
+ u32 offset)
+{
+ u32 i;
+
+ for (i = 0; i < tbl_size; i++) {
+ struct bnge_filter_base *fltr;
+ struct hlist_head *head;
+
+ head = &tbl[i];
+ hlist_for_each_entry_rcu(fltr, head, hlist) {
+ if (fltr->flags && fltr->sw_id + offset == id)
+ return fltr;
+ }
+ }
+ return NULL;
+}
+
+static int bnge_grxclsrlall(struct bnge_net *bn, struct ethtool_rxnfc *cmd,
+ u32 *rule_locs)
+{
+ int count;
+
+ cmd->data = BNGE_MAX_L2_FLTRS + bn->bd->max_fltr;
+ rcu_read_lock();
+ count = bnge_get_all_fltr_ids_rcu(bn, bn->l2_fltr_hash_tbl,
+ BNGE_L2_FLTR_HASH_SIZE, rule_locs, 0,
+ cmd->rule_cnt, 0);
+ if (count >= 0)
+ count = bnge_get_all_fltr_ids_rcu(bn, bn->ntp_fltr_hash_tbl,
+ BNGE_NTP_FLTR_HASH_SIZE,
+ rule_locs, count,
+ cmd->rule_cnt,
+ BNGE_MAX_L2_FLTRS);
+ rcu_read_unlock();
+ if (count < 0)
+ return count;
+
+ cmd->rule_cnt = count;
+ return 0;
+}
+
+static int bnge_grxclsrule(struct bnge_net *bn, struct ethtool_rxnfc *cmd)
+{
+ struct ethtool_rx_flow_spec *fs =
+ (struct ethtool_rx_flow_spec *)&cmd->fs;
+ struct bnge_filter_base *fltr_base;
+ struct bnge_ntuple_filter *fltr;
+ struct bnge_flow_masks *fmasks;
+ struct bnge_dev *bd = bn->bd;
+ struct flow_keys *fkeys;
+ int rc = -EINVAL;
+
+ if (fs->location >= BNGE_MAX_L2_FLTRS + bd->max_fltr)
+ return rc;
+
+ rcu_read_lock();
+ fltr_base = bnge_get_one_fltr_rcu(bn, bn->l2_fltr_hash_tbl,
+ BNGE_L2_FLTR_HASH_SIZE,
+ fs->location, 0);
+ if (fltr_base) {
+ struct ethhdr *h_ether = &fs->h_u.ether_spec;
+ struct ethhdr *m_ether = &fs->m_u.ether_spec;
+ struct bnge_l2_filter *l2_fltr;
+ struct bnge_l2_key *l2_key;
+
+ l2_fltr = container_of(fltr_base, struct bnge_l2_filter, base);
+ l2_key = &l2_fltr->l2_key;
+ fs->flow_type = ETHER_FLOW;
+ ether_addr_copy(h_ether->h_dest, l2_key->dst_mac_addr);
+ eth_broadcast_addr(m_ether->h_dest);
+ if (l2_key->vlan) {
+ struct ethtool_flow_ext *m_ext = &fs->m_ext;
+ struct ethtool_flow_ext *h_ext = &fs->h_ext;
+
+ fs->flow_type |= FLOW_EXT;
+ m_ext->vlan_tci = htons(0xfff);
+ h_ext->vlan_tci = htons(l2_key->vlan);
+ }
+ if (fltr_base->flags & BNGE_ACT_RING_DST)
+ fs->ring_cookie = fltr_base->rxq;
+ rcu_read_unlock();
+ return 0;
+ }
+ fltr_base = bnge_get_one_fltr_rcu(bn, bn->ntp_fltr_hash_tbl,
+ BNGE_NTP_FLTR_HASH_SIZE,
+ fs->location, BNGE_MAX_L2_FLTRS);
+ if (!fltr_base) {
+ rcu_read_unlock();
+ return rc;
+ }
+ fltr = container_of(fltr_base, struct bnge_ntuple_filter, base);
+
+ fkeys = &fltr->fkeys;
+ fmasks = &fltr->fmasks;
+ if (fkeys->basic.n_proto == htons(ETH_P_IP)) {
+ if (fkeys->basic.ip_proto == BNGE_IP_PROTO_WILDCARD) {
+ fs->flow_type = IP_USER_FLOW;
+ fs->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
+ fs->h_u.usr_ip4_spec.proto = BNGE_IP_PROTO_WILDCARD;
+ fs->m_u.usr_ip4_spec.proto = 0;
+ } else if (fkeys->basic.ip_proto == IPPROTO_ICMP) {
+ fs->flow_type = IP_USER_FLOW;
+ fs->h_u.usr_ip4_spec.ip_ver = ETH_RX_NFC_IP4;
+ fs->h_u.usr_ip4_spec.proto = IPPROTO_ICMP;
+ fs->m_u.usr_ip4_spec.proto = BNGE_IP_PROTO_FULL_MASK;
+ } else if (fkeys->basic.ip_proto == IPPROTO_TCP) {
+ fs->flow_type = TCP_V4_FLOW;
+ } else if (fkeys->basic.ip_proto == IPPROTO_UDP) {
+ fs->flow_type = UDP_V4_FLOW;
+ } else {
+ goto fltr_err;
+ }
+
+ fs->h_u.tcp_ip4_spec.ip4src = fkeys->addrs.v4addrs.src;
+ fs->m_u.tcp_ip4_spec.ip4src = fmasks->addrs.v4addrs.src;
+ fs->h_u.tcp_ip4_spec.ip4dst = fkeys->addrs.v4addrs.dst;
+ fs->m_u.tcp_ip4_spec.ip4dst = fmasks->addrs.v4addrs.dst;
+ if (fs->flow_type == TCP_V4_FLOW ||
+ fs->flow_type == UDP_V4_FLOW) {
+ fs->h_u.tcp_ip4_spec.psrc = fkeys->ports.src;
+ fs->m_u.tcp_ip4_spec.psrc = fmasks->ports.src;
+ fs->h_u.tcp_ip4_spec.pdst = fkeys->ports.dst;
+ fs->m_u.tcp_ip4_spec.pdst = fmasks->ports.dst;
+ }
+ } else {
+ if (fkeys->basic.ip_proto == BNGE_IP_PROTO_WILDCARD) {
+ fs->flow_type = IPV6_USER_FLOW;
+ fs->h_u.usr_ip6_spec.l4_proto =
+ BNGE_IP_PROTO_WILDCARD;
+ fs->m_u.usr_ip6_spec.l4_proto = 0;
+ } else if (fkeys->basic.ip_proto == IPPROTO_ICMPV6) {
+ fs->flow_type = IPV6_USER_FLOW;
+ fs->h_u.usr_ip6_spec.l4_proto = IPPROTO_ICMPV6;
+ fs->m_u.usr_ip6_spec.l4_proto =
+ BNGE_IP_PROTO_FULL_MASK;
+ } else if (fkeys->basic.ip_proto == IPPROTO_TCP) {
+ fs->flow_type = TCP_V6_FLOW;
+ } else if (fkeys->basic.ip_proto == IPPROTO_UDP) {
+ fs->flow_type = UDP_V6_FLOW;
+ } else {
+ goto fltr_err;
+ }
+
+ memcpy(fs->h_u.tcp_ip6_spec.ip6src,
+ &fkeys->addrs.v6addrs.src,
+ sizeof(struct in6_addr));
+ memcpy(fs->m_u.tcp_ip6_spec.ip6src,
+ &fmasks->addrs.v6addrs.src,
+ sizeof(struct in6_addr));
+ memcpy(fs->h_u.tcp_ip6_spec.ip6dst,
+ &fkeys->addrs.v6addrs.dst,
+ sizeof(struct in6_addr));
+ memcpy(fs->m_u.tcp_ip6_spec.ip6dst,
+ &fmasks->addrs.v6addrs.dst,
+ sizeof(struct in6_addr));
+
+ if (fs->flow_type == TCP_V6_FLOW ||
+ fs->flow_type == UDP_V6_FLOW) {
+ fs->h_u.tcp_ip6_spec.psrc = fkeys->ports.src;
+ fs->m_u.tcp_ip6_spec.psrc = fmasks->ports.src;
+ fs->h_u.tcp_ip6_spec.pdst = fkeys->ports.dst;
+ fs->m_u.tcp_ip6_spec.pdst = fmasks->ports.dst;
+ }
+ }
+
+ if (fltr->base.flags & BNGE_ACT_DROP) {
+ fs->ring_cookie = RX_CLS_FLOW_DISC;
+ } else if (fltr->base.flags & BNGE_ACT_RSS_CTX) {
+ fs->flow_type |= FLOW_RSS;
+ fs->ring_cookie = fltr->base.rxq;
+ cmd->rss_context = fltr->base.fw_vnic_id;
+ } else {
+ fs->ring_cookie = fltr->base.rxq;
+ }
+ rc = 0;
+
+fltr_err:
+ rcu_read_unlock();
+
+ return rc;
+}
+
+static bool bnge_verify_ntuple_ip4_flow(struct ethtool_usrip4_spec *ip_spec,
+ struct ethtool_usrip4_spec *ip_mask)
+{
+ u8 mproto = ip_mask->proto;
+ u8 sproto = ip_spec->proto;
+
+ if (ip_mask->l4_4_bytes || ip_mask->tos ||
+ ip_spec->ip_ver != ETH_RX_NFC_IP4 ||
+ (mproto && (mproto != BNGE_IP_PROTO_FULL_MASK ||
+ sproto != IPPROTO_ICMP)))
+ return false;
+ return true;
+}
+
+static bool bnge_verify_ntuple_ip6_flow(struct ethtool_usrip6_spec *ip_spec,
+ struct ethtool_usrip6_spec *ip_mask)
+{
+ u8 mproto = ip_mask->l4_proto;
+ u8 sproto = ip_spec->l4_proto;
+
+ if (ip_mask->l4_4_bytes || ip_mask->tclass ||
+ (mproto && (mproto != BNGE_IP_PROTO_FULL_MASK ||
+ sproto != IPPROTO_ICMPV6)))
+ return false;
+ return true;
+}
+
+static int bnge_add_ntuple_cls_rule(struct bnge_net *bn,
+ struct ethtool_rxnfc *cmd)
+{
+ struct ethtool_rx_flow_spec *fs = &cmd->fs;
+ struct bnge_ntuple_filter *new_fltr, *fltr;
+ u32 flow_type = fs->flow_type & 0xff;
+ struct bnge_l2_filter *l2_fltr;
+ struct bnge_flow_masks *fmasks;
+ struct flow_keys *fkeys;
+ u32 idx;
+ int rc;
+
+ if (!bn->vnic_info)
+ return -EAGAIN;
+
+ if (fs->flow_type & (FLOW_MAC_EXT | FLOW_EXT))
+ return -EOPNOTSUPP;
+
+ if (fs->ring_cookie != RX_CLS_FLOW_DISC &&
+ ethtool_get_flow_spec_ring_vf(fs->ring_cookie))
+ return -EOPNOTSUPP;
+
+ if (flow_type == IP_USER_FLOW) {
+ if (!bnge_verify_ntuple_ip4_flow(&fs->h_u.usr_ip4_spec,
+ &fs->m_u.usr_ip4_spec))
+ return -EOPNOTSUPP;
+ }
+
+ if (flow_type == IPV6_USER_FLOW) {
+ if (!bnge_verify_ntuple_ip6_flow(&fs->h_u.usr_ip6_spec,
+ &fs->m_u.usr_ip6_spec))
+ return -EOPNOTSUPP;
+ }
+
+ new_fltr = kzalloc_obj(*new_fltr, GFP_KERNEL);
+ if (!new_fltr)
+ return -ENOMEM;
+
+ l2_fltr = bn->vnic_info[BNGE_VNIC_DEFAULT].l2_filters[0];
+ new_fltr->l2_filter_id = l2_fltr->base.filter_id;
+ fmasks = &new_fltr->fmasks;
+ fkeys = &new_fltr->fkeys;
+
+ rc = -EOPNOTSUPP;
+ switch (flow_type) {
+ case IP_USER_FLOW: {
+ struct ethtool_usrip4_spec *ip_spec = &fs->h_u.usr_ip4_spec;
+ struct ethtool_usrip4_spec *ip_mask = &fs->m_u.usr_ip4_spec;
+
+ fkeys->basic.ip_proto = ip_mask->proto ? ip_spec->proto
+ : BNGE_IP_PROTO_WILDCARD;
+ fkeys->basic.n_proto = htons(ETH_P_IP);
+ fkeys->addrs.v4addrs.src = ip_spec->ip4src;
+ fmasks->addrs.v4addrs.src = ip_mask->ip4src;
+ fkeys->addrs.v4addrs.dst = ip_spec->ip4dst;
+ fmasks->addrs.v4addrs.dst = ip_mask->ip4dst;
+ break;
+ }
+ case TCP_V4_FLOW:
+ case UDP_V4_FLOW: {
+ struct ethtool_tcpip4_spec *ip_spec = &fs->h_u.tcp_ip4_spec;
+ struct ethtool_tcpip4_spec *ip_mask = &fs->m_u.tcp_ip4_spec;
+
+ if (ip_mask->tos)
+ goto err_free_fltr;
+
+ fkeys->basic.ip_proto = IPPROTO_TCP;
+ if (flow_type == UDP_V4_FLOW)
+ fkeys->basic.ip_proto = IPPROTO_UDP;
+ fkeys->basic.n_proto = htons(ETH_P_IP);
+ fkeys->addrs.v4addrs.src = ip_spec->ip4src;
+ fmasks->addrs.v4addrs.src = ip_mask->ip4src;
+ fkeys->addrs.v4addrs.dst = ip_spec->ip4dst;
+ fmasks->addrs.v4addrs.dst = ip_mask->ip4dst;
+ fkeys->ports.src = ip_spec->psrc;
+ fmasks->ports.src = ip_mask->psrc;
+ fkeys->ports.dst = ip_spec->pdst;
+ fmasks->ports.dst = ip_mask->pdst;
+ break;
+ }
+ case IPV6_USER_FLOW: {
+ struct ethtool_usrip6_spec *ip_spec = &fs->h_u.usr_ip6_spec;
+ struct ethtool_usrip6_spec *ip_mask = &fs->m_u.usr_ip6_spec;
+
+ fkeys->basic.ip_proto = ip_mask->l4_proto ? ip_spec->l4_proto
+ : BNGE_IP_PROTO_WILDCARD;
+ fkeys->basic.n_proto = htons(ETH_P_IPV6);
+
+ memcpy(&fkeys->addrs.v6addrs.src, ip_spec->ip6src,
+ sizeof(struct in6_addr));
+ memcpy(&fmasks->addrs.v6addrs.src, ip_mask->ip6src,
+ sizeof(struct in6_addr));
+ memcpy(&fkeys->addrs.v6addrs.dst, ip_spec->ip6dst,
+ sizeof(struct in6_addr));
+ memcpy(&fmasks->addrs.v6addrs.dst, ip_mask->ip6dst,
+ sizeof(struct in6_addr));
+ break;
+ }
+ case TCP_V6_FLOW:
+ case UDP_V6_FLOW: {
+ struct ethtool_tcpip6_spec *ip_spec = &fs->h_u.tcp_ip6_spec;
+ struct ethtool_tcpip6_spec *ip_mask = &fs->m_u.tcp_ip6_spec;
+
+ if (ip_mask->tclass)
+ goto err_free_fltr;
+
+ fkeys->basic.ip_proto = IPPROTO_TCP;
+ if (flow_type == UDP_V6_FLOW)
+ fkeys->basic.ip_proto = IPPROTO_UDP;
+ fkeys->basic.n_proto = htons(ETH_P_IPV6);
+
+ memcpy(&fkeys->addrs.v6addrs.src, ip_spec->ip6src,
+ sizeof(struct in6_addr));
+ memcpy(&fmasks->addrs.v6addrs.src, ip_mask->ip6src,
+ sizeof(struct in6_addr));
+ memcpy(&fkeys->addrs.v6addrs.dst, ip_spec->ip6dst,
+ sizeof(struct in6_addr));
+ memcpy(&fmasks->addrs.v6addrs.dst, ip_mask->ip6dst,
+ sizeof(struct in6_addr));
+
+ fkeys->ports.src = ip_spec->psrc;
+ fmasks->ports.src = ip_mask->psrc;
+ fkeys->ports.dst = ip_spec->pdst;
+ fmasks->ports.dst = ip_mask->pdst;
+ break;
+ }
+ default:
+ rc = -EOPNOTSUPP;
+ goto err_free_fltr;
+ }
+ /* A rule with no address or port mask is accepted only as an ICMP or
+ * ICMPv6 protocol match; the verify helpers above admit no other
+ * protocol-only rule.
+ */
+ if (!memcmp(&BNGE_FLOW_MASK_NONE, fmasks, sizeof(*fmasks)) &&
+ !((flow_type == IP_USER_FLOW || flow_type == IPV6_USER_FLOW) &&
+ fkeys->basic.ip_proto))
+ goto err_free_fltr;
+
+ idx = bnge_get_ntp_filter_idx(bn, fkeys, NULL);
+ rcu_read_lock();
+ fltr = bnge_lookup_ntp_filter_from_idx(bn, new_fltr, idx);
+ if (fltr) {
+ rcu_read_unlock();
+ rc = -EEXIST;
+ goto err_free_fltr;
+ }
+ rcu_read_unlock();
+
+ new_fltr->base.flags = BNGE_ACT_NO_AGING;
+ if (fs->flow_type & FLOW_RSS) {
+ struct bnge_rss_ctx *rss_ctx;
+
+ new_fltr->base.fw_vnic_id = 0;
+ new_fltr->base.flags |= BNGE_ACT_RSS_CTX;
+ rss_ctx = bnge_get_rss_ctx_from_index(bn, cmd->rss_context);
+ if (rss_ctx) {
+ new_fltr->base.fw_vnic_id = rss_ctx->index;
+ } else {
+ rc = -EINVAL;
+ goto err_free_fltr;
+ }
+ }
+ if (fs->ring_cookie == RX_CLS_FLOW_DISC)
+ new_fltr->base.flags |= BNGE_ACT_DROP;
+ else
+ new_fltr->base.rxq = ethtool_get_flow_spec_ring(fs->ring_cookie);
+ __set_bit(BNGE_FLTR_VALID, &new_fltr->base.state);
+ rc = bnge_insert_ntp_filter(bn, new_fltr, idx);
+ if (!rc) {
+ rc = bnge_hwrm_cfa_ntuple_filter_alloc(bn->bd, new_fltr);
+ if (rc) {
+ bnge_del_ntp_filter_rcu(bn, new_fltr);
+ return rc;
+ }
+ fs->location = BNGE_MAX_L2_FLTRS + new_fltr->base.sw_id;
+ return 0;
+ }
+
+err_free_fltr:
+ kfree(new_fltr);
+ return rc;
+}
+
+static int bnge_add_l2_cls_rule(struct bnge_net *bn,
+ struct ethtool_rx_flow_spec *fs)
+{
+ u32 ring = ethtool_get_flow_spec_ring(fs->ring_cookie);
+ struct ethhdr *h_ether = &fs->h_u.ether_spec;
+ struct ethhdr *m_ether = &fs->m_u.ether_spec;
+ struct bnge_l2_filter *fltr;
+ struct bnge_l2_key key;
+ u16 vnic_id;
+ u8 flags;
+ int rc;
+
+ if (ethtool_get_flow_spec_ring_vf(fs->ring_cookie))
+ return -EOPNOTSUPP;
+
+ if (!is_broadcast_ether_addr(m_ether->h_dest))
+ return -EINVAL;
+
+ if (!is_zero_ether_addr(m_ether->h_source) || m_ether->h_proto)
+ return -EOPNOTSUPP;
+
+ if (is_broadcast_ether_addr(h_ether->h_dest) ||
+ is_multicast_ether_addr(h_ether->h_dest))
+ return -EINVAL;
+
+ ether_addr_copy(key.dst_mac_addr, h_ether->h_dest);
+ key.vlan = 0;
+ if (fs->flow_type & FLOW_EXT) {
+ struct ethtool_flow_ext *m_ext = &fs->m_ext;
+ struct ethtool_flow_ext *h_ext = &fs->h_ext;
+
+ if (m_ext->vlan_etype || m_ext->data[0] || m_ext->data[1])
+ return -EOPNOTSUPP;
+
+ key.vlan = ntohs(h_ext->vlan_tci) & VLAN_VID_MASK;
+ if (m_ext->vlan_tci != htons(VLAN_VID_MASK) || !key.vlan)
+ return -EINVAL;
+ }
+
+ flags = BNGE_ACT_RING_DST;
+ vnic_id = bn->vnic_info[BNGE_VNIC_NTUPLE].fw_vnic_id;
+
+ fltr = bnge_alloc_user_l2_filter(bn, &key, flags);
+ if (IS_ERR(fltr))
+ return PTR_ERR(fltr);
+
+ fltr->base.fw_vnic_id = vnic_id;
+ fltr->base.rxq = ring;
+ rc = bnge_hwrm_l2_filter_alloc(bn->bd, fltr);
+ if (rc)
+ bnge_del_l2_filter_rcu(bn, fltr);
+ else
+ fs->location = fltr->base.sw_id;
+ return rc;
+}
+
+static int bnge_srxclsrlins(struct bnge_net *bn, struct ethtool_rxnfc *cmd)
+{
+ struct ethtool_rx_flow_spec *fs = &cmd->fs;
+ struct bnge_dev *bd = bn->bd;
+ u32 ring, flow_type;
+ int rc;
+
+ if (!netif_running(bn->netdev))
+ return -EAGAIN;
+ if (!(bn->priv_flags & BNGE_NET_EN_NTUPLE))
+ return -EPERM;
+ if (fs->location != RX_CLS_LOC_ANY)
+ return -EINVAL;
+
+ flow_type = fs->flow_type;
+
+ if (flow_type & FLOW_MAC_EXT)
+ return -EINVAL;
+
+ flow_type &= ~FLOW_EXT;
+
+ if (fs->ring_cookie == RX_CLS_FLOW_DISC && flow_type != ETHER_FLOW)
+ return bnge_add_ntuple_cls_rule(bn, cmd);
+
+ ring = ethtool_get_flow_spec_ring(fs->ring_cookie);
+ if (ring >= bd->rx_nr_rings)
+ return -EINVAL;
+
+ if (flow_type == ETHER_FLOW)
+ rc = bnge_add_l2_cls_rule(bn, fs);
+ else
+ rc = bnge_add_ntuple_cls_rule(bn, cmd);
+ return rc;
+}
+
+static int bnge_srxclsrldel(struct bnge_net *bn, struct ethtool_rxnfc *cmd)
+{
+ struct ethtool_rx_flow_spec *fs = &cmd->fs;
+ struct bnge_filter_base *fltr_base;
+ struct bnge_ntuple_filter *fltr;
+ u32 id = fs->location;
+
+ rcu_read_lock();
+ fltr_base = bnge_get_one_fltr_rcu(bn, bn->l2_fltr_hash_tbl,
+ BNGE_L2_FLTR_HASH_SIZE, id, 0);
+ if (fltr_base) {
+ struct bnge_l2_filter *l2_fltr;
+
+ l2_fltr = container_of(fltr_base, struct bnge_l2_filter, base);
+ rcu_read_unlock();
+ bnge_hwrm_l2_filter_free(bn->bd, l2_fltr);
+ bnge_del_usr_l2_filter(bn, l2_fltr);
+ return 0;
+ }
+ fltr_base = bnge_get_one_fltr_rcu(bn, bn->ntp_fltr_hash_tbl,
+ BNGE_NTP_FLTR_HASH_SIZE, id,
+ BNGE_MAX_L2_FLTRS);
+ if (!fltr_base) {
+ rcu_read_unlock();
+ return -ENOENT;
+ }
+
+ fltr = container_of(fltr_base, struct bnge_ntuple_filter, base);
+ if (!(fltr->base.flags & BNGE_ACT_NO_AGING)) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+ rcu_read_unlock();
+ bnge_hwrm_cfa_ntuple_filter_free(bn->bd, fltr);
+ bnge_del_ntp_filter_rcu(bn, fltr);
+ return 0;
+}
+
+static int bnge_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd,
+ u32 *rule_locs)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ struct bnge_dev *bd = bn->bd;
+ int rc = 0;
+
+ switch (cmd->cmd) {
+ case ETHTOOL_GRXCLSRLCNT:
+ cmd->rule_cnt = bn->user_fltr_count;
+ cmd->data = (BNGE_MAX_L2_FLTRS + bd->max_fltr) |
+ RX_CLS_LOC_SPECIAL;
+ break;
+
+ case ETHTOOL_GRXCLSRLALL:
+ rc = bnge_grxclsrlall(bn, cmd, (u32 *)rule_locs);
+ break;
+
+ case ETHTOOL_GRXCLSRULE:
+ rc = bnge_grxclsrule(bn, cmd);
+ break;
+
+ default:
+ rc = -EOPNOTSUPP;
+ break;
+ }
+
+ return rc;
+}
+
+static int bnge_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
+{
+ struct bnge_net *bn = netdev_priv(dev);
+ int rc;
+
+ switch (cmd->cmd) {
+ case ETHTOOL_SRXCLSRLINS:
+ rc = bnge_srxclsrlins(bn, cmd);
+ break;
+
+ case ETHTOOL_SRXCLSRLDEL:
+ rc = bnge_srxclsrldel(bn, cmd);
+ break;
+
+ default:
+ rc = -EOPNOTSUPP;
+ break;
+ }
+ return rc;
+}
+
static const struct ethtool_ops bnge_ethtool_ops = {
.cap_link_lanes_supported = 1,
.get_link_ksettings = bnge_get_link_ksettings,
@@ -1275,6 +1880,8 @@ static const struct ethtool_ops bnge_ethtool_ops = {
.create_rxfh_context = bnge_create_rxfh_context,
.modify_rxfh_context = bnge_modify_rxfh_context,
.remove_rxfh_context = bnge_remove_rxfh_context,
+ .get_rxnfc = bnge_get_rxnfc,
+ .set_rxnfc = bnge_set_rxnfc,
};
void bnge_set_ethtool_ops(struct net_device *dev)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
index 3ebb3cae4829..9b3ed0733623 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
@@ -584,3 +584,115 @@ int bnge_hwrm_set_vnic_filter(struct bnge_net *bn, u16 vnic_id, u16 idx,
bnge_del_l2_filter_rcu(bn, fltr);
return rc;
}
+
+/* bnge_cfg_rx_mode() installs no filter for a unicast address that already
+ * has a user L2 rule; reinstall it once the user rule is gone.
+ */
+void bnge_del_usr_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr)
+{
+ u8 mac[ETH_ALEN] __aligned(2);
+ struct bnge_vnic_info *vnic;
+ int i, off;
+ bool vlan;
+
+ ether_addr_copy(mac, fltr->l2_key.dst_mac_addr);
+ vlan = !!fltr->l2_key.vlan;
+ bnge_del_l2_filter_rcu(bn, fltr);
+
+ if (vlan || !test_bit(BNGE_STATE_OPEN, &bn->bd->state))
+ return;
+
+ vnic = &bn->vnic_info[BNGE_VNIC_DEFAULT];
+ for (i = 1, off = 0; i < vnic->uc_filter_count; i++, off += ETH_ALEN) {
+ if (vnic->l2_filters[i] ||
+ !ether_addr_equal(vnic->uc_list + off, mac))
+ continue;
+ if (bnge_hwrm_set_vnic_filter(bn, 0, i, vnic->uc_list + off))
+ netdev_warn(bn->netdev,
+ "failed to restore uc filter %pM\n", mac);
+ break;
+ }
+}
+
+static bool bnge_usr_fltr_ring_lost(struct bnge_net *bn,
+ struct bnge_filter_base *fltr)
+{
+ if (fltr->flags & (BNGE_ACT_DROP | BNGE_ACT_RSS_CTX) ||
+ fltr->rxq < bn->bd->rx_nr_rings)
+ return false;
+
+ netdev_warn(bn->netdev, "filter id %d: rx ring %u no longer exists\n",
+ fltr->sw_id, fltr->rxq);
+ return true;
+}
+
+static void bnge_cfg_one_usr_fltr(struct bnge_net *bn,
+ struct bnge_filter_base *fltr)
+{
+ struct bnge_ntuple_filter *ntp_fltr;
+ struct bnge_l2_filter *l2_fltr;
+
+ if (list_empty(&fltr->list_node))
+ return;
+
+ if (fltr->type == BNGE_FLTR_TYPE_NTUPLE) {
+ ntp_fltr = container_of(fltr, struct bnge_ntuple_filter, base);
+ l2_fltr = bn->vnic_info[BNGE_VNIC_DEFAULT].l2_filters[0];
+ ntp_fltr->l2_filter_id = l2_fltr->base.filter_id;
+ if (bnge_usr_fltr_ring_lost(bn, fltr) ||
+ bnge_hwrm_cfa_ntuple_filter_alloc(bn->bd, ntp_fltr)) {
+ netdev_err(bn->netdev,
+ "restoring previously configured ntuple filter id %d failed\n",
+ fltr->sw_id);
+ bnge_del_ntp_filter_rcu(bn, ntp_fltr);
+ }
+ } else if (fltr->type == BNGE_FLTR_TYPE_L2) {
+ l2_fltr = container_of(fltr, struct bnge_l2_filter, base);
+ fltr->fw_vnic_id = bn->vnic_info[BNGE_VNIC_NTUPLE].fw_vnic_id;
+ if (bnge_usr_fltr_ring_lost(bn, fltr) ||
+ bnge_hwrm_l2_filter_alloc(bn->bd, l2_fltr)) {
+ netdev_err(bn->netdev,
+ "restoring previously configured l2 filter id %d failed\n",
+ fltr->sw_id);
+ bnge_del_usr_l2_filter(bn, l2_fltr);
+ }
+ }
+}
+
+void bnge_cfg_usr_fltrs(struct bnge_net *bn)
+{
+ struct bnge_filter_base *usr_fltr, *tmp;
+
+ list_for_each_entry_safe(usr_fltr, tmp, &bn->usr_fltr_list, list_node)
+ bnge_cfg_one_usr_fltr(bn, usr_fltr);
+}
+
+void bnge_clear_usr_fltrs(struct bnge_net *bn)
+{
+ struct bnge_filter_base *usr_fltr, *tmp;
+ struct bnge_ntuple_filter *ntp_fltr;
+ struct bnge_l2_filter *l2_fltr;
+
+ netdev_assert_locked(bn->netdev);
+
+ /* bnge_fix_features() ensures NTUPLE can only be toggled while the
+ * interface is administrative down (!netif_running). At this point,
+ * all NAPIs and softirqs are disabled, sp_task is locked out under
+ * netdev_lock() and gated by !BNGE_STATE_OPEN, and the device is
+ * closed with no active hardware filters in firmware. Therefore,
+ * synchronous deletion of retained software filter entries here has
+ * no concurrent readers and leaks no firmware filter resources.
+ */
+ list_for_each_entry_safe(usr_fltr, tmp, &bn->usr_fltr_list, list_node) {
+ if (usr_fltr->type == BNGE_FLTR_TYPE_NTUPLE) {
+ ntp_fltr = container_of(usr_fltr,
+ struct bnge_ntuple_filter,
+ base);
+ bnge_del_ntp_filter(bn, ntp_fltr);
+ } else if (usr_fltr->type == BNGE_FLTR_TYPE_L2) {
+ l2_fltr = container_of(usr_fltr, struct bnge_l2_filter,
+ base);
+ bnge_del_l2_filter(bn, l2_fltr);
+ }
+ }
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
index 87d66266a9f5..9c5453d5b50a 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
@@ -106,6 +106,7 @@ bnge_lookup_ntp_filter_from_idx(struct bnge_net *bn,
struct bnge_ntuple_filter *fltr, u32 idx);
void bnge_del_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr);
void bnge_del_l2_filter_rcu(struct bnge_net *bn, struct bnge_l2_filter *fltr);
+void bnge_del_usr_l2_filter(struct bnge_net *bn, struct bnge_l2_filter *fltr);
__le64 bnge_lookup_l2_filter_rcu(struct bnge_net *bn,
struct bnge_l2_key *key,
u32 idx);
@@ -120,4 +121,6 @@ void bnge_del_ntp_filter(struct bnge_net *bn,
struct bnge_ntuple_filter *nfltr);
void bnge_del_ntp_filter_rcu(struct bnge_net *bn,
struct bnge_ntuple_filter *fltr);
+void bnge_cfg_usr_fltrs(struct bnge_net *bn);
+void bnge_clear_usr_fltrs(struct bnge_net *bn);
#endif /* _BNGE_FILTER_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index 33cbdd6d8276..bb6233351484 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -906,15 +906,18 @@ int bnge_hwrm_l2_filter_alloc(struct bnge_dev *bd, struct bnge_l2_filter *fltr)
{
struct hwrm_cfa_l2_filter_alloc_output *resp;
struct hwrm_cfa_l2_filter_alloc_input *req;
+ u32 flags;
int rc;
rc = bnge_hwrm_req_init(bd, req, HWRM_CFA_L2_FILTER_ALLOC);
if (rc)
return rc;
- req->flags = cpu_to_le32(CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX);
-
- req->flags |= cpu_to_le32(CFA_L2_FILTER_ALLOC_REQ_FLAGS_OUTERMOST);
+ flags = CFA_L2_FILTER_ALLOC_REQ_FLAGS_PATH_RX |
+ CFA_L2_FILTER_ALLOC_REQ_FLAGS_OUTERMOST;
+ if (BNGE_L2_FLTR_IS_NTP_MAC(fltr))
+ flags |= CFA_L2_FILTER_ALLOC_REQ_FLAGS_TRAFFIC_L2;
+ req->flags = cpu_to_le32(flags);
req->dst_id = cpu_to_le16(fltr->base.fw_vnic_id);
req->enables =
cpu_to_le32(CFA_L2_FILTER_ALLOC_REQ_ENABLES_L2_ADDR |
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index ff6573b5e60e..f72b912d52f6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -1108,7 +1108,7 @@ static int bnge_alloc_vnic_attributes(struct bnge_net *bn)
vnic = &bn->vnic_info[i];
if (vnic->flags & BNGE_VNIC_UCAST_FLAG) {
- int mem_size = (BNGE_MAX_UC_ADDRS - 1) * ETH_ALEN;
+ int mem_size = (BNGE_MAX_L2_FLTRS - 1) * ETH_ALEN;
vnic->uc_list = kmalloc(mem_size, GFP_KERNEL);
if (!vnic->uc_list)
@@ -2056,6 +2056,7 @@ static int bnge_cfg_rx_mode(struct bnge_net *bn, struct netdev_hw_addr_list *uc,
int i, off = 0, rc, uc_count = 0;
struct bnge_dev *bd = bn->bd;
struct netdev_hw_addr *ha;
+ int l2_free;
if (!uc_update)
goto skip_uc;
@@ -2063,6 +2064,8 @@ static int bnge_cfg_rx_mode(struct bnge_net *bn, struct netdev_hw_addr_list *uc,
for (i = 1; i < vnic->uc_filter_count; i++) {
struct bnge_l2_filter *fltr = vnic->l2_filters[i];
+ if (!fltr)
+ continue;
bnge_hwrm_l2_filter_free(bd, fltr);
bnge_del_l2_filter_rcu(bn, fltr);
}
@@ -2079,7 +2082,12 @@ static int bnge_cfg_rx_mode(struct bnge_net *bn, struct netdev_hw_addr_list *uc,
netdev_hw_addr_list_for_each(ha, uc)
if (!ether_addr_equal(ha->addr, dev->dev_addr))
uc_count++;
- if (uc_count > BNGE_MAX_UC_ADDRS - 1) {
+ /* The unicast addresses and the user ETHER_FLOW rules share the L2
+ * filters. Receive the addresses that do not fit in promiscuous mode.
+ */
+ l2_free = BNGE_MAX_L2_FLTRS -
+ bitmap_weight(bn->l2_fltr_bmap, BNGE_MAX_L2_FLTRS);
+ if (uc_count > BNGE_MAX_L2_FLTRS - 1 || uc_count > l2_free) {
vnic->rx_mask |= CFA_L2_SET_RX_MASK_REQ_MASK_PROMISCUOUS;
} else {
netdev_hw_addr_list_for_each(ha, uc) {
@@ -2095,6 +2103,11 @@ static int bnge_cfg_rx_mode(struct bnge_net *bn, struct netdev_hw_addr_list *uc,
for (i = 1, off = 0; i < vnic->uc_filter_count; i++, off += ETH_ALEN) {
rc = bnge_hwrm_set_vnic_filter(bn, 0, i, vnic->uc_list + off);
+ if (rc == -EEXIST) {
+ /* Already delivered by a user L2 rule */
+ vnic->l2_filters[i] = NULL;
+ continue;
+ }
if (rc) {
if (rc == -EAGAIN)
netdev_warn(dev, "FW busy while setting vnic filter, will retry\n");
@@ -2281,6 +2294,8 @@ static void bnge_hwrm_clear_vnic_filter(struct bnge_net *bn)
for (i = 0; i < vnic->uc_filter_count; i++) {
struct bnge_l2_filter *fltr = vnic->l2_filters[i];
+ if (!fltr)
+ continue;
bnge_hwrm_l2_filter_free(bn->bd, fltr);
bnge_del_l2_filter_rcu(bn, fltr);
}
@@ -2805,6 +2820,7 @@ static int bnge_open_core(struct bnge_net *bn)
bnge_get_port_module_status(bn);
bnge_hwrm_realloc_rss_ctx_vnic(bn);
+ bnge_cfg_usr_fltrs(bn);
return 0;
@@ -3177,6 +3193,9 @@ static int bnge_set_features(struct net_device *dev, netdev_features_t features)
!(flags & BNGE_NET_EN_NTUPLE) && bn->num_rss_ctx)
return -EBUSY;
+ if (!(flags & BNGE_NET_EN_NTUPLE))
+ bnge_clear_usr_fltrs(bn);
+
bn->priv_flags = flags;
return 0;
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
index 58f17579db3d..e615690e6b93 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_vnic.h
@@ -4,6 +4,8 @@
#ifndef _BNGE_VNIC_H_
#define _BNGE_VNIC_H_
+#include "bnge_filter.h"
+
struct bnge_net;
struct bnge_dev;
struct bnge_l2_filter;
@@ -20,7 +22,6 @@ struct bnge_l2_filter;
#define BNGE_MAX_CTX_PER_VNIC 8
#define BNGE_MAX_MC_ADDRS 16
-#define BNGE_MAX_UC_ADDRS 4
#define BNGE_VNIC_ID_INVALID 0xffffffff
@@ -46,7 +47,7 @@ struct bnge_vnic_info {
u16 fw_rss_cos_lb_ctx[BNGE_MAX_CTX_PER_VNIC];
u16 mru;
/* index 0 always dev_addr */
- struct bnge_l2_filter *l2_filters[BNGE_MAX_UC_ADDRS];
+ struct bnge_l2_filter *l2_filters[BNGE_MAX_L2_FLTRS];
u16 uc_filter_count;
u8 *uc_list;
dma_addr_t rss_table_dma_addr;
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 09/10] bnge: add aRFS flow steering ndo support
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (7 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 08/10] bnge: add NTUPLE filter support in ethtool Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 10/10] bnge: add cpu_rmap support for IRQ affinity Vikas Gupta
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
Introduce the ndo_rx_flow_steer callback (bnge_rx_flow_steer) to
support aRFS.
This callback creates an NTUPLE filter that steers matching packets
to the appropriate RX queue. The implementation dissects flow keys
from the SKB, creates an NTUPLE filter with the associated L2 filter,
inserts it into the NTUPLE hash table, and schedules the sp_task
workqueue via BNGE_RX_NTP_FLTR_SP_EVENT to program the filter
in the firmware.
Add bnge_cfg_ntp_filters() called from the periodic timer via sp_task
to handle deferred filter programming and expiration via
rps_may_expire_flow().
bnge_timer() queues aRFS aging only while NTUPLE is enabled. NTUPLE
can only be turned off with the interface closed, and
bnge_close_core() then deletes the timer and purges dynamic
aRFS filters.
Note that, if the L2 filter is freed before sp_task programs the rule,
the captured firmware id is stale. The NTUPLE alloc either fails (id
gone) or binds to a recycled id for a different filter. The rule is
then dropped, or it stays until it ages out.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_ethtool.c | 5 +-
.../net/ethernet/broadcom/bnge/bnge_filter.c | 85 ++++++++++-
.../net/ethernet/broadcom/bnge/bnge_filter.h | 5 +-
.../ethernet/broadcom/bnge/bnge_hwrm_lib.c | 2 +-
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 138 ++++++++++++++++++
.../net/ethernet/broadcom/bnge/bnge_netdev.h | 1 +
6 files changed, 228 insertions(+), 8 deletions(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
index dfffb3efc333..b4c0db43adf4 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_ethtool.c
@@ -1261,7 +1261,7 @@ static int bnge_get_all_fltr_ids_rcu(struct bnge_net *bn,
head = &tbl[i];
hlist_for_each_entry_rcu(fltr, head, hlist) {
- if (!fltr->flags ||
+ if (!bnge_is_usr_fltr(fltr) ||
test_bit(BNGE_FLTR_FW_DELETED, &fltr->state))
continue;
if (j == id_cnt)
@@ -1285,7 +1285,8 @@ static struct bnge_filter_base *bnge_get_one_fltr_rcu(struct bnge_net *bn,
head = &tbl[i];
hlist_for_each_entry_rcu(fltr, head, hlist) {
- if (fltr->flags && fltr->sw_id + offset == id)
+ if (bnge_is_usr_fltr(fltr) &&
+ fltr->sw_id + offset == id)
return fltr;
}
}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
index 9b3ed0733623..8309f6d57bc6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.c
@@ -56,7 +56,7 @@ const struct bnge_flow_masks BNGE_FLOW_IPV4_MASK_ALL = {
},
};
-static bool bnge_is_usr_fltr(struct bnge_filter_base *fltr)
+bool bnge_is_usr_fltr(struct bnge_filter_base *fltr)
{
return (fltr->type == BNGE_FLTR_TYPE_L2 &&
fltr->flags & BNGE_ACT_RING_DST) ||
@@ -116,7 +116,7 @@ void bnge_del_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *nfltr)
hlist_del(&fltr->hlist);
bnge_del_usr_fltr_node(bn, fltr);
clear_bit(fltr->sw_id, bn->ntp_fltr_bmap);
- bn->ntp_fltr_count--;
+ WRITE_ONCE(bn->ntp_fltr_count, bn->ntp_fltr_count - 1);
kfree(fltr);
}
@@ -127,7 +127,7 @@ void bnge_del_ntp_filter_rcu(struct bnge_net *bn,
hlist_del_rcu(&fltr->base.hlist);
bnge_del_usr_fltr_node(bn, &fltr->base);
clear_bit(fltr->base.sw_id, bn->ntp_fltr_bmap);
- bn->ntp_fltr_count--;
+ WRITE_ONCE(bn->ntp_fltr_count, bn->ntp_fltr_count - 1);
spin_unlock_bh(&bn->ntp_fltr_lock);
kfree_rcu(fltr, base.rcu);
@@ -538,7 +538,7 @@ int bnge_insert_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *fltr,
hlist_add_head_rcu(&fltr->base.hlist, head);
bnge_insert_usr_fltr(bn, &fltr->base);
- bn->ntp_fltr_count++;
+ WRITE_ONCE(bn->ntp_fltr_count, bn->ntp_fltr_count + 1);
spin_unlock_bh(&bn->ntp_fltr_lock);
@@ -696,3 +696,80 @@ void bnge_clear_usr_fltrs(struct bnge_net *bn)
}
}
}
+
+void bnge_cfg_ntp_filters(struct bnge_net *bn)
+{
+#ifdef CONFIG_RFS_ACCEL
+ struct bnge_ntuple_filter *fltr, *tmp;
+ LIST_HEAD(install_list);
+ LIST_HEAD(update_list);
+ LIST_HEAD(expire_list);
+ u32 flow_id;
+ int i, rc;
+ u16 rxq;
+
+ rcu_read_lock();
+ for (i = 0; i < BNGE_NTP_FLTR_HASH_SIZE; i++) {
+ hlist_for_each_entry_rcu(fltr, &bn->ntp_fltr_hash_tbl[i],
+ base.hlist) {
+ if (test_bit(BNGE_FLTR_VALID, &fltr->base.state)) {
+ if (fltr->base.flags & BNGE_ACT_NO_AGING)
+ continue;
+ if (test_and_clear_bit(BNGE_FLTR_RXQ_UPDATE,
+ &fltr->base.state)) {
+ list_add(&fltr->base.list_node,
+ &update_list);
+ continue;
+ }
+ rxq = READ_ONCE(fltr->base.rxq);
+ flow_id = READ_ONCE(fltr->flow_id);
+ if (rps_may_expire_flow(bn->netdev, rxq,
+ flow_id,
+ fltr->base.sw_id))
+ list_add(&fltr->base.list_node,
+ &expire_list);
+ } else {
+ /* The install below reads the current rxq; order the
+ * clear before that read.
+ */
+ clear_bit(BNGE_FLTR_RXQ_UPDATE,
+ &fltr->base.state);
+ smp_mb__after_atomic();
+ list_add(&fltr->base.list_node, &install_list);
+ }
+ }
+ }
+ rcu_read_unlock();
+
+ /* Free the old HW rule; reinstall it below on the new queue. */
+ list_for_each_entry_safe(fltr, tmp, &update_list, base.list_node) {
+ list_del_init(&fltr->base.list_node);
+ /* If the free fails the rule stays on the old queue. It is not
+ * retried, so a firmware that keeps failing is not hit on every
+ * tick.
+ */
+ if (bnge_hwrm_cfa_ntuple_filter_free(bn->bd, fltr))
+ continue;
+ clear_bit(BNGE_FLTR_FW_DELETED, &fltr->base.state);
+ list_add(&fltr->base.list_node, &install_list);
+ }
+
+ list_for_each_entry_safe(fltr, tmp, &install_list, base.list_node) {
+ list_del_init(&fltr->base.list_node);
+ rc = bnge_hwrm_cfa_ntuple_filter_alloc(bn->bd, fltr);
+ if (rc)
+ bnge_del_ntp_filter_rcu(bn, fltr);
+ else
+ set_bit(BNGE_FLTR_VALID, &fltr->base.state);
+ }
+
+ list_for_each_entry_safe(fltr, tmp, &expire_list, base.list_node) {
+ list_del_init(&fltr->base.list_node);
+ /* Retargeted by bnge_rx_flow_steer() after the scan */
+ if (test_bit(BNGE_FLTR_RXQ_UPDATE, &fltr->base.state))
+ continue;
+ bnge_hwrm_cfa_ntuple_filter_free(bn->bd, fltr);
+ bnge_del_ntp_filter_rcu(bn, fltr);
+ }
+#endif
+}
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
index 9c5453d5b50a..a7d2983bc25e 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_filter.h
@@ -19,7 +19,8 @@ enum {
enum {
BNGE_FLTR_VALID,
- BNGE_FLTR_FW_DELETED
+ BNGE_FLTR_FW_DELETED,
+ BNGE_FLTR_RXQ_UPDATE
};
enum {
@@ -97,6 +98,7 @@ struct bnge_ntuple_filter {
#define BNGE_FLTR_ID_INVALID cpu_to_le64(0xffffffffffffffffULL)
void bnge_free_ntp_fltrs(struct bnge_net *bn, bool skip_user_filters);
+bool bnge_is_usr_fltr(struct bnge_filter_base *fltr);
u32 bnge_get_ntp_filter_idx(struct bnge_net *bn, struct flow_keys *fkeys,
const struct sk_buff *skb);
int bnge_insert_ntp_filter(struct bnge_net *bn, struct bnge_ntuple_filter *fltr,
@@ -123,4 +125,5 @@ void bnge_del_ntp_filter_rcu(struct bnge_net *bn,
struct bnge_ntuple_filter *fltr);
void bnge_cfg_usr_fltrs(struct bnge_net *bn);
void bnge_clear_usr_fltrs(struct bnge_net *bn);
+void bnge_cfg_ntp_filters(struct bnge_net *bn);
#endif /* _BNGE_FILTER_H_ */
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
index bb6233351484..ce41d94838e6 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c
@@ -1007,8 +1007,8 @@ bnge_cfg_rfs_ring_tbl_idx(struct bnge_dev *bd,
struct bnge_ntuple_filter *fltr)
{
struct bnge_net *bn = netdev_priv(bd->netdev);
+ u32 rxq = READ_ONCE(fltr->base.rxq);
struct bnge_vnic_info *def_vnic;
- u32 rxq = fltr->base.rxq;
u32 enables;
if (fltr->base.flags & BNGE_ACT_RSS_CTX) {
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index f72b912d52f6..835619604dc2 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -303,6 +303,12 @@ static void bnge_timer(struct timer_list *t)
if (BNGE_LINK_IS_UP(bd) && bn->stats_coal_ticks)
bnge_queue_sp_work(bn, BNGE_PERIODIC_STATS_SP_EVENT);
+#ifdef CONFIG_RFS_ACCEL
+ if ((bn->priv_flags & BNGE_NET_EN_NTUPLE) &&
+ READ_ONCE(bn->ntp_fltr_count))
+ bnge_queue_sp_work(bn, BNGE_RX_NTP_FLTR_SP_EVENT);
+#endif
+
mod_timer(&bn->timer, jiffies + bn->current_interval);
}
@@ -444,6 +450,9 @@ static void bnge_sp_task(struct work_struct *work)
bnge_init_ethtool_link_settings(bn);
}
+ if (test_and_clear_bit(BNGE_RX_NTP_FLTR_SP_EVENT, &bn->sp_event))
+ bnge_cfg_ntp_filters(bn);
+
netdev_unlock(bn->netdev);
}
@@ -3201,6 +3210,132 @@ static int bnge_set_features(struct net_device *dev, netdev_features_t features)
return 0;
}
+#ifdef CONFIG_RFS_ACCEL
+static __le64 bnge_lookup_l2_filter_from_key(struct bnge_net *bn,
+ struct bnge_l2_key *key)
+{
+ u32 idx;
+
+ idx = jhash2(&key->filter_key, BNGE_L2_KEY_SIZE, bn->hash_seed) &
+ BNGE_L2_FLTR_HASH_MASK;
+ return bnge_lookup_l2_filter_rcu(bn, key, idx);
+}
+
+static int bnge_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb,
+ u16 rxq_index, u32 flow_id)
+{
+ struct ethhdr *eth = (struct ethhdr *)skb_mac_header(skb);
+ struct bnge_ntuple_filter *fltr, *new_fltr;
+ struct bnge_net *bn = netdev_priv(dev);
+ struct flow_keys *fkeys;
+ __le64 filter_id;
+ u32 flags, idx;
+ int rc = 0;
+
+ /* Hold rcu_read_lock() across the L2 filter lookup and check
+ * BNGE_STATE_OPEN inside it. bnge_close_core() clears the
+ * flag before bnge_shutdown_nic() frees the L2 filters via
+ * kfree_rcu(), so if we observe the device open here the
+ * filter cannot be freed under us for the duration of
+ * this critical section.
+ */
+ rcu_read_lock();
+ if (!test_bit(BNGE_STATE_OPEN, &bn->bd->state)) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+
+ if (ether_addr_equal(dev->dev_addr, eth->h_dest)) {
+ struct bnge_vnic_info *vnic = &bn->vnic_info[BNGE_VNIC_DEFAULT];
+ struct bnge_l2_filter *l2_filter;
+
+ if (!vnic->uc_filter_count) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+ l2_filter = vnic->l2_filters[0];
+ filter_id = l2_filter->base.filter_id;
+ } else {
+ struct bnge_l2_key key;
+
+ ether_addr_copy(key.dst_mac_addr, eth->h_dest);
+ key.vlan = 0;
+
+ filter_id = bnge_lookup_l2_filter_from_key(bn, &key);
+ if (filter_id == BNGE_FLTR_ID_INVALID) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+ }
+ rcu_read_unlock();
+
+ new_fltr = kzalloc_obj(*new_fltr, GFP_ATOMIC);
+ if (!new_fltr)
+ return -ENOMEM;
+
+ fkeys = &new_fltr->fkeys;
+ if (!skb_flow_dissect_flow_keys(skb, fkeys, 0)) {
+ rc = -EPROTONOSUPPORT;
+ goto err_free;
+ }
+
+ if ((fkeys->basic.n_proto != htons(ETH_P_IP) &&
+ fkeys->basic.n_proto != htons(ETH_P_IPV6)) ||
+ (fkeys->basic.ip_proto != IPPROTO_TCP &&
+ fkeys->basic.ip_proto != IPPROTO_UDP)) {
+ rc = -EPROTONOSUPPORT;
+ goto err_free;
+ }
+ new_fltr->fmasks = BNGE_FLOW_IPV4_MASK_ALL;
+ if (fkeys->basic.n_proto == htons(ETH_P_IPV6))
+ new_fltr->fmasks = BNGE_FLOW_IPV6_MASK_ALL;
+
+ flags = fkeys->control.flags;
+ if (flags & FLOW_DIS_IS_FRAGMENT) {
+ rc = -EPROTONOSUPPORT;
+ goto err_free;
+ }
+
+ new_fltr->l2_filter_id = filter_id;
+
+ idx = bnge_get_ntp_filter_idx(bn, fkeys, skb);
+ rcu_read_lock();
+ fltr = bnge_lookup_ntp_filter_from_idx(bn, new_fltr, idx);
+ /* Filter already exists. If the flow moved to another queue,
+ * retarget it, sp_task reprograms it in hardware.
+ */
+ if (fltr) {
+ if (!(fltr->base.flags & BNGE_ACT_NO_AGING) &&
+ READ_ONCE(fltr->base.rxq) != rxq_index) {
+ spin_lock_bh(&bn->ntp_fltr_lock);
+ WRITE_ONCE(fltr->base.rxq, rxq_index);
+ WRITE_ONCE(fltr->flow_id, flow_id);
+ /* Pairs with test_and_clear_bit() in sp_task */
+ smp_mb__before_atomic();
+ set_bit(BNGE_FLTR_RXQ_UPDATE, &fltr->base.state);
+ spin_unlock_bh(&bn->ntp_fltr_lock);
+ bnge_queue_sp_work(bn, BNGE_RX_NTP_FLTR_SP_EVENT);
+ }
+ rc = fltr->base.sw_id;
+ rcu_read_unlock();
+ goto err_free;
+ }
+ rcu_read_unlock();
+
+ new_fltr->flow_id = flow_id;
+ new_fltr->base.rxq = rxq_index;
+ rc = bnge_insert_ntp_filter(bn, new_fltr, idx);
+ if (!rc) {
+ bnge_queue_sp_work(bn, BNGE_RX_NTP_FLTR_SP_EVENT);
+ return new_fltr->base.sw_id;
+ }
+
+err_free:
+ kfree(new_fltr);
+ return rc;
+}
+#endif
+
static const struct net_device_ops bnge_netdev_ops = {
.ndo_open = bnge_open,
.ndo_stop = bnge_close,
@@ -3210,6 +3345,9 @@ static const struct net_device_ops bnge_netdev_ops = {
.ndo_features_check = bnge_features_check,
.ndo_fix_features = bnge_fix_features,
.ndo_set_features = bnge_set_features,
+#ifdef CONFIG_RFS_ACCEL
+ .ndo_rx_flow_steer = bnge_rx_flow_steer,
+#endif
};
static void bnge_init_mac_addr(struct bnge_dev *bd)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
index 2a1ec811de01..74dbca600cbe 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.h
@@ -282,6 +282,7 @@ enum bnge_sp_event {
BNGE_LINK_CFG_CHANGE_SP_EVENT,
BNGE_UPDATE_PHY_SP_EVENT,
BNGE_PERIODIC_STATS_SP_EVENT,
+ BNGE_RX_NTP_FLTR_SP_EVENT,
};
#define BNGE_NTP_FLTR_HASH_SIZE 512
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
* [PATCH net-next v5 10/10] bnge: add cpu_rmap support for IRQ affinity
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
` (8 preceding siblings ...)
2026-11-03 12:36 ` [PATCH net-next v5 09/10] bnge: add aRFS flow steering ndo support Vikas Gupta
@ 2026-11-03 12:36 ` Vikas Gupta
9 siblings, 0 replies; 11+ messages in thread
From: Vikas Gupta @ 2026-11-03 12:36 UTC (permalink / raw)
To: davem, edumazet, kuba, pabeni, andrew+netdev, horms
Cc: netdev, linux-kernel, bhargava.marreddy, rahul-rg.gupta,
vsrama-krishna.nemani, rajashekar.hudumula, dharmender.garg,
ajit.khaparde, Vikas Gupta
When CONFIG_RFS_ACCEL is enabled, allocate and populate a cpu_rmap
for the RX IRQ vectors so that the kernel's aRFS infrastructure can
correctly map flows to the RX queues serviced by the nearest CPU.
This ensures that NTUPLE rules created by the kernel steer packets
to the optimal queue based on CPU/IRQ affinity.
Also, This is the patch that turns aRFS on. Before it dev->rx_cpu_rmap
was never set, so set_rps_cpu() took its early exit and
bnge_rx_flow_steer() from the previous patch was never called.
A failed rmap allocation does not fail the open; aRFS stays off.
If adding an IRQ to the rmap fails for one ring, aRFS is turned off
for all rings, because a later ring would otherwise take the free slot
and map to the wrong RX queue.
Signed-off-by: Vikas Gupta <vikas.gupta@broadcom.com>
Reviewed-by: Dharmender Garg <dharmender.garg@broadcom.com>
---
.../net/ethernet/broadcom/bnge/bnge_netdev.c | 57 ++++++++++++++++++-
1 file changed, 56 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
index 835619604dc2..afdd00ff4944 100644
--- a/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
+++ b/drivers/net/ethernet/broadcom/bnge/bnge_netdev.c
@@ -18,6 +18,7 @@
#include <net/ip.h>
#include <linux/skbuff.h>
#include <net/page_pool/helpers.h>
+#include <linux/cpu_rmap.h>
#include "bnge.h"
#include "bnge_hwrm.h"
@@ -2460,10 +2461,23 @@ static int bnge_setup_interrupts(struct bnge_net *bn)
{
struct net_device *dev = bn->netdev;
struct bnge_dev *bd = bn->bd;
+ int rc;
bnge_setup_msix(bn);
- return netif_set_real_num_queues(dev, bd->tx_nr_rings, bd->rx_nr_rings);
+ rc = netif_set_real_num_queues(dev, bd->tx_nr_rings, bd->rx_nr_rings);
+ if (rc)
+ return rc;
+
+#ifdef CONFIG_RFS_ACCEL
+ if (bn->priv_flags & BNGE_NET_EN_NTUPLE) {
+ dev->rx_cpu_rmap = alloc_irq_cpu_rmap(bd->rx_nr_rings);
+ if (!dev->rx_cpu_rmap)
+ netdev_warn(dev, "Unable to allocate the CPU rmap, aRFS disabled\n");
+ }
+#endif
+
+ return rc;
}
static void bnge_hwrm_resource_free(struct bnge_net *bn, bool close_path)
@@ -2473,12 +2487,35 @@ static void bnge_hwrm_resource_free(struct bnge_net *bn, bool close_path)
bnge_hwrm_stat_ctx_free(bn);
}
+#ifdef CONFIG_RFS_ACCEL
+/* set_rps_cpu() reads rx_cpu_rmap under rcu_read_lock(). Hide the pointer and
+ * wait for readers that already loaded it before the rmap is freed.
+ */
+static void bnge_free_cpu_rmap(struct bnge_net *bn)
+{
+ struct cpu_rmap *rmap = bn->netdev->rx_cpu_rmap;
+
+ if (!rmap)
+ return;
+
+ WRITE_ONCE(bn->netdev->rx_cpu_rmap, NULL);
+ synchronize_net();
+ free_irq_cpu_rmap(rmap);
+}
+#else
+static inline void bnge_free_cpu_rmap(struct bnge_net *bn)
+{
+}
+#endif
+
static void bnge_free_irq(struct bnge_net *bn)
{
struct bnge_dev *bd = bn->bd;
struct bnge_irq *irq;
int i;
+ bnge_free_cpu_rmap(bn);
+
for (i = 0; i < bd->nq_nr_rings; i++) {
int map_idx = bnge_cp_num_to_irq_num(bn, i);
@@ -2498,6 +2535,7 @@ static void bnge_free_irq(struct bnge_net *bn)
static int bnge_request_irq(struct bnge_net *bn)
{
+ struct cpu_rmap *rmap = NULL;
struct bnge_dev *bd = bn->bd;
int i, rc;
@@ -2506,10 +2544,27 @@ static int bnge_request_irq(struct bnge_net *bn)
netdev_err(bn->netdev, "bnge_setup_interrupts err: %d\n", rc);
return rc;
}
+
+#ifdef CONFIG_RFS_ACCEL
+ rmap = bn->netdev->rx_cpu_rmap;
+#endif
+
for (i = 0; i < bd->nq_nr_rings; i++) {
int map_idx = bnge_cp_num_to_irq_num(bn, i);
struct bnge_irq *irq = &bd->irq_tbl[map_idx];
+ if (IS_ENABLED(CONFIG_RFS_ACCEL) &&
+ rmap && bn->bnapi[i]->rx_ring) {
+ rc = irq_cpu_rmap_add(rmap, irq->vector);
+ if (rc) {
+ netdev_warn(bn->netdev,
+ "failed adding irq rmap for ring %d, disabling aRFS\n",
+ i);
+ bnge_free_cpu_rmap(bn);
+ rmap = NULL;
+ }
+ }
+
rc = request_irq(irq->vector, irq->handler, 0, irq->name,
bn->bnapi[i]);
if (rc)
--
2.52.0
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2026-11-03 12:38 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-03 12:36 [PATCH net-next v5 00/10] add features to bnge Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 01/10] bnge: restructure VNIC and filter code Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 02/10] bnge: add NTUPLE/ARFS VNIC Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 03/10] bnge: add helper functions for multi RSS contexts Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 04/10] bnge: add RXFH ethtool support Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 05/10] bnge: add ethtool support to manage RSS contexts Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 06/10] bnge: remove refcount from L2 filter Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 07/10] bnge: add NTUPLE filter infrastructure Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 08/10] bnge: add NTUPLE filter support in ethtool Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 09/10] bnge: add aRFS flow steering ndo support Vikas Gupta
2026-11-03 12:36 ` [PATCH net-next v5 10/10] bnge: add cpu_rmap support for IRQ affinity Vikas Gupta
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®