Linux-ARM-Kernel Archive on lore.kernel.org
 help / color / mirror / Atom feed
* [PATCH net-next 0/2] net: ti: icssg: Multi-flow RX and ethtool RX flow classification
@ 2026-11-18 18:47 Meghana Malladi
  2026-11-18 18:47 ` [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI Meghana Malladi
  2026-11-18 18:47 ` [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support Meghana Malladi
  0 siblings, 2 replies; 6+ messages in thread
From: Meghana Malladi @ 2026-11-18 18:47 UTC (permalink / raw)
  To: marco.crivellari, kees+treewide, laixiangwu, philippe.schenker,
	haokexin, devnexen, horms, jacob.e.keller, m-malladi, sdf,
	john.fastabend, hawk, daniel, ast, pabeni, kuba, edumazet, davem,
	andrew+netdev
  Cc: bpf, linux-kernel, netdev, linux-arm-kernel, srk,
	Vignesh Raghavendra, danishanwar

This series adds multi-flow RX support to the ICSSG ethernet driver and
exposes it via ethtool RX flow classification (rxnfc).

Patch (1/2): restructures the driver to support up to 8 independent RX flows
per EMAC interface. Each flow gets its own NAPI instance, IRQ, hrtimer,
page pool, and XDP/AF_XDP context while sharing a single UDMA channel and
descriptor pool. AF_XDP zero-copy is updated to track per-flow pools via a
bitmap, and per-flow page pool recycling is fixed by storing the flow_id in
prueth_swdata.

Patch (2/2): adds ethtool ETHTOOL_SRXCLSRLINS/SRXCLSRLDEL/SRXCLSRLALL support.
Rules match on EtherType (ETHER_FLOW) and steer matched frames to a
user-specified RX queue via ICSSG FT3 hardware content filters and the
16-entry classifier table. The classifier N result maps directly to UDMA
flow rx_flow_id_base+N, so queue steering takes effect in hardware without
per-packet CPU involvement.

Tested on AM64x EVM (SR2), both eth1 (PRU0/slice0) and eth2
(PRU1/slice1) with 8 RX flows. Verified via /proc/interrupts IRQ deltas

RFC: https://lore.kernel.org/all/20261103134501.4123194-1-m-malladi@ti.com/

Meghana Malladi (2):
  net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI
  net: ti: icssg-prueth: Add ethtool RX flow classification support

 .../net/ethernet/ti/icssg/icssg_classifier.c  | 407 ++++++++++++++++++
 drivers/net/ethernet/ti/icssg/icssg_common.c  | 380 +++++++++-------
 drivers/net/ethernet/ti/icssg/icssg_config.h  |   7 +-
 drivers/net/ethernet/ti/icssg/icssg_ethtool.c |  77 +++-
 drivers/net/ethernet/ti/icssg/icssg_prueth.c  | 336 ++++++++-------
 drivers/net/ethernet/ti/icssg/icssg_prueth.h  |  95 ++--
 .../net/ethernet/ti/icssg/icssg_prueth_sr1.c  | 266 ++++++++++--
 7 files changed, 1189 insertions(+), 379 deletions(-)


base-commit: d6816d9a93b66a12bf01e10037e377f3333ad6cc
-- 
2.43.0



^ permalink raw reply	[flat|nested] 6+ messages in thread

* [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI
  2026-11-18 18:47 [PATCH net-next 0/2] net: ti: icssg: Multi-flow RX and ethtool RX flow classification Meghana Malladi
@ 2026-11-18 18:47 ` Meghana Malladi
  2026-11-22 19:01   ` netdev-bot+sashiko
  2026-11-18 18:47 ` [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support Meghana Malladi
  1 sibling, 1 reply; 6+ messages in thread
From: Meghana Malladi @ 2026-11-18 18:47 UTC (permalink / raw)
  To: marco.crivellari, kees+treewide, laixiangwu, philippe.schenker,
	haokexin, devnexen, horms, jacob.e.keller, m-malladi, sdf,
	john.fastabend, hawk, daniel, ast, pabeni, kuba, edumazet, davem,
	andrew+netdev
  Cc: bpf, linux-kernel, netdev, linux-arm-kernel, srk,
	Vignesh Raghavendra, danishanwar

Extend ICSSG driver to support up to 8 independent RX flows per EMAC
(PRUETH_MAX_RX_FLOWS 1 --> 8), enabling ethtool queue steering via set_rxnfc.

Data structures:
- Introduce prueth_rx_flow for per-flow state: NAPI, hrtimer, page pool,
  XDP rxq, AF_XDP pool, IRQ. All flows share one UDMA channel and
  descriptor pool (PRUETH_MAX_RX_DESC x flow_count).
- Restructure prueth_rx_chn: strip per-flow fields, add flows[] array.
- Add flow_id to prueth_swdata so recycled pages return to the correct
  per-flow page pool (previously always used flows[0]).
- Replace xsk_qid int with xsk_queues bitmap for multi-pool AF_XDP.

Channel lifecycle:
- prueth_create_rxq / prueth_destroy_rxq operate on a single flow.
- prueth_create_rxqs / prueth_destroy_rxqs iterate all active flows and
  enable the shared UDMA channel only after all flows are ready.
- prueth_ndev_add_rx_napi / prueth_ndev_del_rx_napi register per-flow
  NAPI, hrtimer, and IRQ with teardown on partial failure.
ethtool: report rx_flow_num active queues; ICSSG_MAX_RFLOWS as max.

Signed-off-by: Meghana Malladi <m-malladi@ti.com>
---

RFC->v1 changelog:
sashiko comments addressed:
- unsigned int irq handling, and flow->irq <= 0 returns 0 (success)
- desc_rx leaked on prueth_dma_rx_push_mapped() and _zc() failure
- prueth_dma_rx_push_mapped_zc hardcodes flow 0
- XSK desc_avail not capped per-flow
- emac_set_coalesce only updates flow 0 timeout 
- IRQ left permanently disabled after hrtimer_cancel
- NAPI scheduling in teardown restricted to XSK flows
- xdp_rxq_info_reg hardcodes queue index 0
- prueth_create_rxq error path calls napi_disable before napi_enable
- alloc_etherdev_mq + no netif_set_real_num_rx_queues
- prueth_set_xsk_pool hardcodes PRUETH_RX_FLOW_DATA
- prueth_xsk_pool_enable/disable missing rx_flow_num check+ error cleanup
- prueth_xsk_wakeup OOB test_bit + rx_flow hardcoded to flow 0
- bitmap fail goto free_ndev skips pruss_release_mem_region

sashiko comments skipped:
- rxfdq_cfg.size not scaled for multi-flow
- Shared FDQ per-flow reset issues
As single_fdq=false on BCDMA/PKTDMA (AM64xx)

 drivers/net/ethernet/ti/icssg/icssg_common.c  | 378 +++++++++++-------
 drivers/net/ethernet/ti/icssg/icssg_config.h  |   7 +-
 drivers/net/ethernet/ti/icssg/icssg_ethtool.c |  18 +-
 drivers/net/ethernet/ti/icssg/icssg_prueth.c  | 327 ++++++++-------
 drivers/net/ethernet/ti/icssg/icssg_prueth.h  |  60 +--
 .../net/ethernet/ti/icssg/icssg_prueth_sr1.c  | 266 +++++++++---
 6 files changed, 676 insertions(+), 380 deletions(-)

diff --git a/drivers/net/ethernet/ti/icssg/icssg_common.c b/drivers/net/ethernet/ti/icssg/icssg_common.c
index 4a7d1a6f470b1..6cd2a77c491ac 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_common.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_common.c
@@ -39,16 +39,10 @@
 				 NETIF_MSG_HW | \
 				 NETIF_MSG_WOL)
 
-#define prueth_napi_to_emac(napi) container_of(napi, struct prueth_emac, napi_rx)
 
-void prueth_cleanup_rx_chns(struct prueth_emac *emac,
-			    struct prueth_rx_chn *rx_chn,
-			    int max_rflows)
+void prueth_cleanup_rx_chns(struct prueth_emac *emac)
 {
-	if (rx_chn->pg_pool) {
-		page_pool_destroy(rx_chn->pg_pool);
-		rx_chn->pg_pool = NULL;
-	}
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
 
 	if (rx_chn->desc_pool)
 		k3_cppi_desc_pool_destroy(rx_chn->desc_pool);
@@ -79,6 +73,20 @@ void prueth_cleanup_tx_chns(struct prueth_emac *emac)
 }
 EXPORT_SYMBOL_GPL(prueth_cleanup_tx_chns);
 
+void prueth_ndev_del_rx_napi(struct prueth_emac *emac, int num)
+{
+	int i;
+
+	for (i = 0; i < num; i++) {
+		struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[i];
+
+		if (rx_flow->irq)
+			free_irq(rx_flow->irq, &rx_flow->napi_rx);
+		netif_napi_del(&rx_flow->napi_rx);
+	}
+}
+EXPORT_SYMBOL_GPL(prueth_ndev_del_rx_napi);
+
 void prueth_ndev_del_tx_napi(struct prueth_emac *emac, int num)
 {
 	int i;
@@ -311,6 +319,19 @@ int emac_tx_complete_packets(struct prueth_emac *emac, int chn,
 	return num_tx;
 }
 
+static enum hrtimer_restart emac_rx_timer_callback(struct hrtimer *timer)
+{
+	struct prueth_rx_flow *rx_flow =
+				container_of(timer, struct prueth_rx_flow, rx_hrtimer);
+
+	if (rx_flow->irq_disabled) {
+		/* re-enable the RX IRQ */
+		rx_flow->irq_disabled = false;
+		enable_irq(rx_flow->irq);
+	}
+	return HRTIMER_NORESTART;
+}
+
 static enum hrtimer_restart emac_tx_timer_callback(struct hrtimer *timer)
 {
 	struct prueth_tx_chn *tx_chns =
@@ -363,6 +384,35 @@ static irqreturn_t prueth_tx_irq(int irq, void *dev_id)
 	return IRQ_HANDLED;
 }
 
+int prueth_ndev_add_rx_napi(struct prueth_emac *emac)
+{
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth *prueth = emac->prueth;
+	struct prueth_rx_flow *flow;
+	int i, ret;
+
+	for (i = 0; i < emac->rx_flow_num; i++) {
+		flow = &rx_chn->flows[i];
+
+		netif_napi_add(emac->ndev, &flow->napi_rx, icssg_napi_rx_poll);
+		hrtimer_setup(&flow->rx_hrtimer, &emac_rx_timer_callback, CLOCK_MONOTONIC,
+			      HRTIMER_MODE_REL_PINNED);
+		ret = request_irq(emac->rx_chns.flows[i].irq, prueth_rx_irq,
+				  IRQF_TRIGGER_HIGH, flow->name, &flow->napi_rx);
+		if (ret) {
+			netif_napi_del(&flow->napi_rx);
+			dev_err(prueth->dev, "unable to request RX IRQ\n");
+			goto fail;
+		}
+	}
+
+	return 0;
+fail:
+	prueth_ndev_del_rx_napi(emac, i);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(prueth_ndev_add_rx_napi);
+
 int prueth_ndev_add_tx_napi(struct prueth_emac *emac)
 {
 	struct prueth *prueth = emac->prueth;
@@ -475,7 +525,8 @@ EXPORT_SYMBOL_GPL(prueth_init_tx_chns);
 
 static struct page_pool *prueth_create_page_pool(struct prueth_emac *emac,
 						 struct device *dma_dev,
-						 int size)
+						 int size,
+						 struct prueth_rx_flow *rx_flow)
 {
 	struct page_pool_params pp_params = { 0 };
 	struct page_pool *pool;
@@ -486,7 +537,7 @@ static struct page_pool *prueth_create_page_pool(struct prueth_emac *emac,
 	pp_params.nid = dev_to_node(emac->prueth->dev);
 	pp_params.dma_dir = DMA_BIDIRECTIONAL;
 	pp_params.dev = dma_dev;
-	pp_params.napi = &emac->napi_rx;
+	pp_params.napi = &rx_flow->napi_rx;
 	pp_params.max_len = PAGE_SIZE;
 
 	pool = page_pool_create(&pp_params);
@@ -496,38 +547,30 @@ static struct page_pool *prueth_create_page_pool(struct prueth_emac *emac,
 	return pool;
 }
 
-int prueth_init_rx_chns(struct prueth_emac *emac,
-			struct prueth_rx_chn *rx_chn,
-			char *name, u32 max_rflows,
-			u32 max_desc_num)
+int prueth_init_rx_chns(struct prueth_emac *emac)
 {
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
 	struct k3_udma_glue_rx_channel_cfg rx_cfg;
 	struct device *dev = emac->prueth->dev;
 	struct net_device *ndev = emac->ndev;
+	struct prueth_rx_flow *flow;
 	u32 fdqring_id, hdesc_size;
-	struct page_pool *pool;
 	int i, ret = 0, slice;
-	int flow_id_base;
+	char udma_name[32];
 
 	slice = prueth_emac_slice(emac);
 	if (slice < 0)
 		return slice;
 
-	/* To differentiate channels for SLICE0 vs SLICE1 */
-	snprintf(rx_chn->name, sizeof(rx_chn->name), "%s%d", name, slice);
-
 	hdesc_size = cppi5_hdesc_calc_size(true, PRUETH_NAV_PS_DATA_SIZE,
 					   PRUETH_NAV_SW_DATA_SIZE);
 	memset(&rx_cfg, 0, sizeof(rx_cfg));
 	rx_cfg.swdata_size = PRUETH_NAV_SW_DATA_SIZE;
-	rx_cfg.flow_id_num = max_rflows;
+	rx_cfg.flow_id_num = emac->rx_flow_num;
 	rx_cfg.flow_id_base = -1; /* udmax will auto select flow id base */
 
-	/* init all flows */
-	rx_chn->dev = dev;
-	rx_chn->descs_num = max_desc_num;
-
-	rx_chn->rx_chn = k3_udma_glue_request_rx_chn(dev, rx_chn->name,
+	snprintf(udma_name, sizeof(udma_name), "%s%d", "rx", slice);
+	rx_chn->rx_chn = k3_udma_glue_request_rx_chn(dev, udma_name,
 						     &rx_cfg);
 	if (IS_ERR(rx_chn->rx_chn)) {
 		ret = PTR_ERR(rx_chn->rx_chn);
@@ -536,11 +579,14 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
 		goto fail;
 	}
 
+	/* Initialize the RX channel (shared by all flows) */
+	rx_chn->emac = emac;
+	rx_chn->descs_num = PRUETH_MAX_RX_DESC * rx_cfg.flow_id_num;
 	rx_chn->dma_dev = k3_udma_glue_rx_get_dma_device(rx_chn->rx_chn);
 	rx_chn->desc_pool = k3_cppi_desc_pool_create_name(rx_chn->dma_dev,
 							  rx_chn->descs_num,
 							  hdesc_size,
-							  rx_chn->name);
+							  "rx_desc_pool");
 	if (IS_ERR(rx_chn->desc_pool)) {
 		ret = PTR_ERR(rx_chn->desc_pool);
 		rx_chn->desc_pool = NULL;
@@ -548,22 +594,14 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
 		goto fail;
 	}
 
-	pool = prueth_create_page_pool(emac, rx_chn->dma_dev, rx_chn->descs_num);
-	if (IS_ERR(pool)) {
-		ret = PTR_ERR(pool);
-		goto fail;
+	for (i = 0; i < rx_cfg.flow_id_num; i++) {
+		flow = &rx_chn->flows[i];
+		flow->pg_pool = NULL;
+		flow->xsk_pool = NULL;
 	}
 
-	rx_chn->pg_pool = pool;
-
-	flow_id_base = k3_udma_glue_rx_get_flow_id_base(rx_chn->rx_chn);
-	if (emac->is_sr1 && !strcmp(name, "rxmgm")) {
-		emac->rx_mgm_flow_id_base = flow_id_base;
-		netdev_dbg(ndev, "mgm flow id base = %d\n", flow_id_base);
-	} else {
-		emac->rx_flow_id_base = flow_id_base;
-		netdev_dbg(ndev, "flow id base = %d\n", flow_id_base);
-	}
+	emac->rx_flow_id_base = k3_udma_glue_rx_get_flow_id_base(rx_chn->rx_chn);
+	netdev_dbg(ndev, "flow id base = %d\n", emac->rx_flow_id_base);
 
 	fdqring_id = K3_RINGACC_RING_ID_ANY;
 	for (i = 0; i < rx_cfg.flow_id_num; i++) {
@@ -584,9 +622,14 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
 				K3_UDMA_GLUE_SRC_TAG_LO_USE_REMOTE_SRC_TAG,
 		};
 
+		flow = &rx_chn->flows[i];
+		flow->emac = emac;
+		flow->id = i;
+		flow->irq = -EINVAL;
+
 		rx_flow_cfg.ring_rxfdq0_id = fdqring_id;
-		rx_flow_cfg.rx_cfg.size = max_desc_num;
-		rx_flow_cfg.rxfdq_cfg.size = max_desc_num;
+		rx_flow_cfg.rx_cfg.size = PRUETH_MAX_RX_DESC;
+		rx_flow_cfg.rxfdq_cfg.size = PRUETH_MAX_RX_DESC;
 		rx_flow_cfg.rxfdq_cfg.mode = emac->prueth->pdata.fdqring_mode;
 
 		ret = k3_udma_glue_rx_flow_init(rx_chn->rx_chn,
@@ -599,31 +642,36 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
 		if (!i)
 			fdqring_id = k3_udma_glue_rx_flow_get_fdq_id(rx_chn->rx_chn,
 								     i);
-		ret = k3_udma_glue_rx_get_irq(rx_chn->rx_chn, i);
-		if (ret < 0) {
+		flow->irq = k3_udma_glue_rx_get_irq(rx_chn->rx_chn, i);
+		if (flow->irq <= 0) {
+			ret = flow->irq < 0 ? flow->irq : -EINVAL;
 			netdev_err(ndev, "Failed to get rx dma irq");
 			goto fail;
 		}
-		rx_chn->irq[i] = ret;
+
+		snprintf(flow->name, sizeof(flow->name),
+			 "%s-rx%d-%d", dev_name(dev), slice, i);
 	}
 
 	return 0;
 
 fail:
-	prueth_cleanup_rx_chns(emac, rx_chn, max_rflows);
+	prueth_cleanup_rx_chns(emac);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(prueth_init_rx_chns);
 
 int prueth_dma_rx_push_mapped(struct prueth_emac *emac,
 			      struct prueth_rx_chn *rx_chn,
-			      struct page *page, u32 buf_len)
+			      struct page *page, u32 buf_len,
+			      int flow_id)
 {
 	struct net_device *ndev = emac->ndev;
 	struct cppi5_host_desc_t *desc_rx;
 	struct prueth_swdata *swdata;
 	dma_addr_t desc_dma;
 	dma_addr_t buf_dma;
+	int ret;
 
 	buf_dma = page_pool_get_dma_addr(page) + PRUETH_HEADROOM;
 	desc_rx = k3_cppi_desc_pool_alloc(rx_chn->desc_pool);
@@ -641,9 +689,12 @@ int prueth_dma_rx_push_mapped(struct prueth_emac *emac,
 	swdata = cppi5_hdesc_get_swdata(desc_rx);
 	swdata->type = PRUETH_SWDATA_PAGE;
 	swdata->data.page = page;
+	swdata->flow_id = flow_id;
 
-	return k3_udma_glue_push_rx_chn(rx_chn->rx_chn, PRUETH_RX_FLOW_DATA,
-					desc_rx, desc_dma);
+	ret = k3_udma_glue_push_rx_chn(rx_chn->rx_chn, flow_id, desc_rx, desc_dma);
+	if (ret)
+		k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
+	return ret;
 }
 EXPORT_SYMBOL_GPL(prueth_dma_rx_push_mapped);
 
@@ -860,14 +911,17 @@ static u32 emac_run_xdp(struct prueth_emac *emac, struct xdp_buff *xdp, u32 *len
 
 static int prueth_dma_rx_push_mapped_zc(struct prueth_emac *emac,
 					struct prueth_rx_chn *rx_chn,
-					struct xdp_buff *xdp)
+					struct xdp_buff *xdp,
+					int flow_id)
 {
+	struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[flow_id];
 	struct net_device *ndev = emac->ndev;
 	struct cppi5_host_desc_t *desc_rx;
 	struct prueth_swdata *swdata;
 	dma_addr_t desc_dma;
 	dma_addr_t buf_dma;
 	int buf_len;
+	int ret;
 
 	buf_dma = xsk_buff_xdp_get_dma(xdp);
 	desc_rx = k3_cppi_desc_pool_alloc(rx_chn->desc_pool);
@@ -880,28 +934,32 @@ static int prueth_dma_rx_push_mapped_zc(struct prueth_emac *emac,
 	cppi5_hdesc_init(desc_rx, CPPI5_INFO0_HDESC_EPIB_PRESENT,
 			 PRUETH_NAV_PS_DATA_SIZE);
 	k3_udma_glue_rx_dma_to_cppi5_addr(rx_chn->rx_chn, &buf_dma);
-	buf_len = xsk_pool_get_rx_frame_size(rx_chn->xsk_pool);
+	buf_len = xsk_pool_get_rx_frame_size(rx_flow->xsk_pool);
 	cppi5_hdesc_attach_buf(desc_rx, buf_dma, buf_len, buf_dma, buf_len);
 	swdata = cppi5_hdesc_get_swdata(desc_rx);
 	swdata->type = PRUETH_SWDATA_XSK;
 	swdata->data.xdp = xdp;
+	swdata->flow_id = flow_id;
 
-	return k3_udma_glue_push_rx_chn(rx_chn->rx_chn, PRUETH_RX_FLOW_DATA,
+	ret = k3_udma_glue_push_rx_chn(rx_chn->rx_chn, flow_id,
 					desc_rx, desc_dma);
+	if (ret)
+		k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
+	return ret;
 }
 
-static int prueth_rx_alloc_zc(struct prueth_emac *emac, int budget)
+static int prueth_rx_alloc_zc(struct prueth_emac *emac, int flow_id, int budget)
 {
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[flow_id];
 	struct xdp_buff *xdp;
 	int i, ret;
 
 	for (i = 0; i < budget; i++) {
-		xdp = xsk_buff_alloc(rx_chn->xsk_pool);
+		xdp = xsk_buff_alloc(rx_flow->xsk_pool);
 		if (!xdp)
 			break;
 
-		ret = prueth_dma_rx_push_mapped_zc(emac, rx_chn, xdp);
+		ret = prueth_dma_rx_push_mapped_zc(emac, &emac->rx_chns, xdp, flow_id);
 		if (ret) {
 			netdev_err(emac->ndev, "rx alloc: failed to map descriptors to xdp buff\n");
 			xsk_buff_free(xdp);
@@ -912,14 +970,14 @@ static int prueth_rx_alloc_zc(struct prueth_emac *emac, int budget)
 	return i;
 }
 
-static void emac_dispatch_skb_zc(struct prueth_emac *emac, struct xdp_buff *xdp, u32 *psdata)
+static void emac_dispatch_skb_zc(struct prueth_emac *emac, struct xdp_buff *xdp, u32 *psdata, int flow_id)
 {
 	unsigned int headroom = xdp->data - xdp->data_hard_start;
 	unsigned int pkt_len = xdp->data_end - xdp->data;
 	struct net_device *ndev = emac->ndev;
 	struct sk_buff *skb;
 
-	skb = napi_alloc_skb(&emac->napi_rx, xdp->data_end - xdp->data_hard_start);
+	skb = napi_alloc_skb(&emac->rx_chns.flows[flow_id].napi_rx, xdp->data_end - xdp->data_hard_start);
 	if (unlikely(!skb)) {
 		ndev->stats.rx_dropped++;
 		return;
@@ -938,7 +996,7 @@ static void emac_dispatch_skb_zc(struct prueth_emac *emac, struct xdp_buff *xdp,
 		skb->offload_fwd_mark = emac->offload_fwd_mark;
 	skb->protocol = eth_type_trans(skb, ndev);
 
-	napi_gro_receive(&emac->napi_rx, skb);
+	napi_gro_receive(&emac->rx_chns.flows[flow_id].napi_rx, skb);
 	ndev->stats.rx_bytes += pkt_len;
 	ndev->stats.rx_packets++;
 }
@@ -947,6 +1005,7 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
 			     int budget)
 {
 	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[flow_id];
 	u32 buf_dma_len, pkt_len, port_id = 0;
 	struct net_device *ndev = emac->ndev;
 	struct cppi5_host_desc_t *desc_rx;
@@ -997,7 +1056,7 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
 			switch (ret) {
 			case ICSSG_XDP_PASS:
 				/* prepare skb and send to n/w stack */
-				emac_dispatch_skb_zc(emac, xdp, psdata);
+				emac_dispatch_skb_zc(emac, xdp, psdata, flow_id);
 				xsk_buff_free(xdp);
 				break;
 			case ICSSG_XDP_CONSUMED:
@@ -1010,7 +1069,7 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
 			}
 		} else {
 			/* prepare skb and send to n/w stack */
-			emac_dispatch_skb_zc(emac, xdp, psdata);
+			emac_dispatch_skb_zc(emac, xdp, psdata, flow_id);
 			xsk_buff_free(xdp);
 		}
 		k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
@@ -1022,13 +1081,13 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
 	avail_desc = k3_cppi_desc_pool_avail(rx_chn->desc_pool);
 	alloc_budget = min_t(int, budget, avail_desc);
 
-	ret = prueth_rx_alloc_zc(emac, alloc_budget);
+	ret = prueth_rx_alloc_zc(emac, flow_id, alloc_budget);
 
-	if (xsk_uses_need_wakeup(rx_chn->xsk_pool)) {
+	if (xsk_uses_need_wakeup(rx_flow->xsk_pool)) {
 		if (ret < alloc_budget)
-			xsk_set_rx_need_wakeup(rx_chn->xsk_pool);
+			xsk_set_rx_need_wakeup(rx_flow->xsk_pool);
 		else
-			xsk_clear_rx_need_wakeup(rx_chn->xsk_pool);
+			xsk_clear_rx_need_wakeup(rx_flow->xsk_pool);
 	}
 
 	return count;
@@ -1037,6 +1096,7 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
 static int emac_rx_packet(struct prueth_emac *emac, u32 flow_id, u32 *xdp_state)
 {
 	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[flow_id];
 	u32 buf_dma_len, pkt_len, port_id = 0;
 	struct net_device *ndev = emac->ndev;
 	struct cppi5_host_desc_t *desc_rx;
@@ -1051,7 +1111,7 @@ static int emac_rx_packet(struct prueth_emac *emac, u32 flow_id, u32 *xdp_state)
 	void *pa;
 
 	*xdp_state = 0;
-	pool = rx_chn->pg_pool;
+	pool = rx_flow->pg_pool;
 	ret = k3_udma_glue_pop_rx_chn(rx_chn->rx_chn, flow_id, &desc_dma);
 	if (ret) {
 		if (ret != -ENODATA)
@@ -1093,7 +1153,7 @@ static int emac_rx_packet(struct prueth_emac *emac, u32 flow_id, u32 *xdp_state)
 
 	pa = page_address(page);
 	if (prueth_xdp_is_enabled(emac)) {
-		xdp_init_buff(&xdp, PAGE_SIZE, &rx_chn->xdp_rxq);
+		xdp_init_buff(&xdp, PAGE_SIZE, &rx_flow->xdp_rxq);
 		xdp_prepare_buff(&xdp, pa, PRUETH_HEADROOM, pkt_len, false);
 
 		*xdp_state = emac_run_xdp(emac, &xdp, &pkt_len);
@@ -1132,15 +1192,15 @@ static int emac_rx_packet(struct prueth_emac *emac, u32 flow_id, u32 *xdp_state)
 	skb->protocol = eth_type_trans(skb, ndev);
 
 	skb_mark_for_recycle(skb);
-	napi_gro_receive(&emac->napi_rx, skb);
+	napi_gro_receive(&emac->rx_chns.flows[flow_id].napi_rx, skb);
 	ndev->stats.rx_bytes += pkt_len;
 	ndev->stats.rx_packets++;
 
 requeue:
 	k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
 	/* queue another RX DMA */
-	ret = prueth_dma_rx_push_mapped(emac, &emac->rx_chns, new_page,
-					PRUETH_MAX_PKT_SIZE);
+	ret = prueth_dma_rx_push_mapped(emac, rx_chn, new_page,
+					PRUETH_MAX_PKT_SIZE, flow_id);
 	if (WARN_ON(ret < 0)) {
 		page_pool_recycle_direct(pool, new_page);
 		ndev->stats.rx_errors++;
@@ -1155,19 +1215,22 @@ void prueth_rx_cleanup(void *data, dma_addr_t desc_dma)
 	struct prueth_rx_chn *rx_chn = data;
 	struct cppi5_host_desc_t *desc_rx;
 	struct prueth_swdata *swdata;
-	struct page_pool *pool;
+	struct page_pool *pool = NULL;
 	struct xdp_buff *xdp;
 	struct page *page;
 
-	pool = rx_chn->pg_pool;
 	desc_rx = k3_cppi_desc_pool_dma2virt(rx_chn->desc_pool, desc_dma);
 	swdata = cppi5_hdesc_get_swdata(desc_rx);
-	if (rx_chn->xsk_pool) {
+
+	if (swdata->type == PRUETH_SWDATA_XSK) {
 		xdp = swdata->data.xdp;
 		xsk_buff_free(xdp);
-	} else {
-		page = swdata->data.page;
-		page_pool_recycle_direct(pool, page);
+	} else if (swdata->type == PRUETH_SWDATA_PAGE) {
+		pool = rx_chn->flows[swdata->flow_id].pg_pool;
+		if (pool) {
+			page = swdata->data.page;
+			page_pool_recycle_direct(pool, page);
+		}
 	}
 
 	k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
@@ -1411,11 +1474,12 @@ EXPORT_SYMBOL_GPL(prueth_tx_cleanup);
 
 irqreturn_t prueth_rx_irq(int irq, void *dev_id)
 {
-	struct prueth_emac *emac = dev_id;
+	struct napi_struct *napi_rx = dev_id;
+	struct prueth_rx_flow *rx_flow = container_of(napi_rx, struct prueth_rx_flow, napi_rx);
 
-	emac->rx_chns.irq_disabled = true;
+	rx_flow->irq_disabled = true;
 	disable_irq_nosync(irq);
-	napi_schedule(&emac->napi_rx);
+	napi_schedule(napi_rx);
 
 	return IRQ_HANDLED;
 }
@@ -1436,50 +1500,38 @@ EXPORT_SYMBOL_GPL(prueth_cleanup_tx_ts);
 
 int icssg_napi_rx_poll(struct napi_struct *napi_rx, int budget)
 {
-	struct prueth_emac *emac = prueth_napi_to_emac(napi_rx);
-	int rx_flow = emac->is_sr1 ?
-		PRUETH_RX_FLOW_DATA_SR1 : PRUETH_RX_FLOW_DATA;
-	int flow = emac->is_sr1 ?
-		PRUETH_MAX_RX_FLOWS_SR1 : PRUETH_MAX_RX_FLOWS;
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *rx_flow = prueth_napi_to_rx_chn(napi_rx);
+	struct prueth_emac *emac = rx_flow->emac;
 	int xdp_state_or = 0;
 	int num_rx = 0;
-	int cur_budget;
 	u32 xdp_state;
 	int ret;
 
-	while (flow--) {
-		if (rx_chn->xsk_pool) {
-			num_rx = emac_rx_packet_zc(emac, flow, budget);
-		} else {
-			cur_budget = budget - num_rx;
-
-			while (cur_budget--) {
-				ret = emac_rx_packet(emac, flow, &xdp_state);
-				xdp_state_or |= xdp_state;
-				if (ret)
-					break;
-				num_rx++;
-			}
+	if (rx_flow->xsk_pool) {
+		num_rx = emac_rx_packet_zc(emac, rx_flow->id, budget);
+	} else {
+		while (budget - num_rx > 0) {
+			ret = emac_rx_packet(emac, rx_flow->id, &xdp_state);
+			xdp_state_or |= xdp_state;
+			if (ret)
+				break;
+			num_rx++;
 		}
-
-		if (num_rx >= budget)
-			break;
 	}
 
 	if (xdp_state_or & ICSSG_XDP_REDIR)
 		xdp_do_flush();
 
 	if (num_rx < budget && napi_complete_done(napi_rx, num_rx)) {
-		if (unlikely(emac->rx_pace_timeout_ns)) {
-			hrtimer_start(&emac->rx_hrtimer,
-				      ns_to_ktime(emac->rx_pace_timeout_ns),
+		if (unlikely(rx_flow->rx_pace_timeout_ns)) {
+			hrtimer_start(&rx_flow->rx_hrtimer,
+				      ns_to_ktime(rx_flow->rx_pace_timeout_ns),
 				      HRTIMER_MODE_REL_PINNED);
 		} else {
-			if (emac->rx_chns.irq_disabled) {
+			if (rx_flow->irq_disabled) {
 				/* re-enable the RX IRQ */
-				emac->rx_chns.irq_disabled = false;
-				enable_irq(emac->rx_chns.irq[rx_flow]);
+				rx_flow->irq_disabled = false;
+				enable_irq(rx_flow->irq);
 			}
 		}
 	}
@@ -1488,59 +1540,81 @@ int icssg_napi_rx_poll(struct napi_struct *napi_rx, int budget)
 }
 EXPORT_SYMBOL_GPL(icssg_napi_rx_poll);
 
-int prueth_prepare_rx_chan(struct prueth_emac *emac,
-			   struct prueth_rx_chn *chn,
-			   int buf_size)
+int prueth_prepare_rx_flow(struct prueth_emac *emac,
+			   int flow)
 {
+	int buf_size = PRUETH_MAX_PKT_SIZE;
+	struct prueth_rx_flow *rx_flow;
+	struct prueth_rx_chn *rx_chn;
+	struct page_pool *pool;
 	struct page *page;
 	int desc_avail;
 	int i, ret;
 
-	desc_avail = k3_cppi_desc_pool_avail(chn->desc_pool);
-	if (desc_avail < chn->descs_num)
-		netdev_warn(emac->ndev,
-			    "not enough RX descriptors available %d < %d\n",
-			    desc_avail, chn->descs_num);
+	rx_chn = &emac->rx_chns;
+	rx_flow = &emac->rx_chns.flows[flow];
 
-	if (chn->xsk_pool) {
-		/* get pages from xsk_pool and push to RX ring
-		 * queue as much as possible
+	if (rx_flow->xsk_pool) {
+		/* XSK zero-copy: buffers come from the XSK fill ring, no page
+		 * pool needed.  Push up to PRUETH_MAX_RX_DESC XSK buffers.
 		 */
-		ret = prueth_rx_alloc_zc(emac, desc_avail);
-		if (!ret)
-			goto recycle_alloc_pg;
-	} else {
-		for (i = 0; i < desc_avail; i++) {
-			/* NOTE: we're not using memory efficiently here.
-			 * 1 full page (4KB?) used here instead of
-			 * PRUETH_MAX_PKT_SIZE (~1.5KB?)
-			 */
-			page = page_pool_dev_alloc_pages(chn->pg_pool);
-			if (!page) {
-				netdev_err(emac->ndev, "couldn't allocate rx page\n");
-				ret = -ENOMEM;
-				goto recycle_alloc_pg;
-			}
+		desc_avail = k3_cppi_desc_pool_avail(rx_chn->desc_pool);
+		if (desc_avail < PRUETH_MAX_RX_DESC) {
+			netdev_err(emac->ndev,
+				   "not enough RX descriptors available %d < %d\n",
+				   desc_avail, PRUETH_MAX_RX_DESC);
+			return -ENOSPC;
+		}
 
-			ret = prueth_dma_rx_push_mapped(emac, chn, page, buf_size);
-			if (ret < 0) {
-				netdev_err(emac->ndev,
-					   "cannot submit page for rx chan %s ret %d\n",
-					   chn->name, ret);
-				page_pool_recycle_direct(chn->pg_pool, page);
-				goto recycle_alloc_pg;
-			}
+		prueth_rx_alloc_zc(emac, flow, PRUETH_MAX_RX_DESC);
+		return 0;
+	}
+
+	pool = prueth_create_page_pool(emac, rx_chn->dma_dev, rx_chn->descs_num, rx_flow);
+	if (IS_ERR(pool))
+		return PTR_ERR(pool);
+
+	rx_flow->pg_pool = pool;
+
+	desc_avail = k3_cppi_desc_pool_avail(rx_chn->desc_pool);
+	if (desc_avail < PRUETH_MAX_RX_DESC) {
+		netdev_err(emac->ndev,
+			   "not enough RX descriptors available %d < %d\n",
+			   desc_avail, PRUETH_MAX_RX_DESC);
+		ret = -ENOSPC;
+		goto err_free_pushed;
+	}
+
+	for (i = 0; i < PRUETH_MAX_RX_DESC; ++i) {
+		page = page_pool_dev_alloc_pages(pool);
+		if (!page) {
+			netdev_err(emac->ndev, "couldn't allocate rx page\n");
+			ret = -ENOMEM;
+			goto err_free_pushed;
+		}
+
+		ret = prueth_dma_rx_push_mapped(emac, rx_chn, page, buf_size, flow);
+		if (ret < 0) {
+			netdev_err(emac->ndev,
+				   "cannot submit skb for rx chan %s ret %d\n",
+				   rx_flow->name, ret);
+			page_pool_recycle_direct(pool, page);
+			goto err_free_pushed;
 		}
 	}
 
 	return 0;
 
-recycle_alloc_pg:
-	prueth_reset_rx_chan(&emac->rx_chns, PRUETH_MAX_RX_FLOWS, false);
-
+err_free_pushed:
+	/* i pages were successfully pushed to the ring.  Reset the channel
+	 * to drain them back and recycle via prueth_rx_cleanup before the
+	 * caller destroys the page pool.
+	 */
+	k3_udma_glue_reset_rx_chn(rx_chn->rx_chn, flow, rx_chn,
+				   prueth_rx_cleanup);
 	return ret;
 }
-EXPORT_SYMBOL_GPL(prueth_prepare_rx_chan);
+EXPORT_SYMBOL_GPL(prueth_prepare_rx_flow);
 
 void prueth_reset_tx_chan(struct prueth_emac *emac, int ch_num,
 			  bool free_skb)
@@ -1557,16 +1631,20 @@ void prueth_reset_tx_chan(struct prueth_emac *emac, int ch_num,
 }
 EXPORT_SYMBOL_GPL(prueth_reset_tx_chan);
 
-void prueth_reset_rx_chan(struct prueth_rx_chn *chn,
-			  int num_flows, bool disable)
+void prueth_reset_rx_chan(struct prueth_emac *emac, bool disable)
 {
 	int i;
+	int num_flows = emac->rx_flow_num;
+	struct prueth_rx_chn *chn;
+
+	chn = &emac->rx_chns;
 
 	for (i = 0; i < num_flows; i++)
 		k3_udma_glue_reset_rx_chn(chn->rx_chn, i, chn,
 					  prueth_rx_cleanup);
+
 	if (disable)
-		k3_udma_glue_disable_rx_chn(chn->rx_chn);
+		k3_udma_glue_disable_rx_chn(emac->rx_chns.rx_chn);
 }
 EXPORT_SYMBOL_GPL(prueth_reset_rx_chan);
 
@@ -1752,8 +1830,6 @@ void prueth_netdev_exit(struct prueth *prueth,
 	if (of_phy_is_fixed_link(emac->phy_node))
 		of_phy_deregister_fixed_link(emac->phy_node);
 
-	netif_napi_del(&emac->napi_rx);
-
 	pruss_release_mem_region(prueth->pruss, &emac->dram);
 	free_netdev(emac->ndev);
 	prueth->emac[mac] = NULL;
diff --git a/drivers/net/ethernet/ti/icssg/icssg_config.h b/drivers/net/ethernet/ti/icssg/icssg_config.h
index 60d69744ffae2..25f5863d27028 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_config.h
+++ b/drivers/net/ethernet/ti/icssg/icssg_config.h
@@ -23,7 +23,12 @@ struct icssg_flow_cfg {
 #define PRUETH_NAV_SW_DATA_SIZE	16	/* SW related data size */
 #define PRUETH_MAX_TX_DESC	512
 #define PRUETH_MAX_RX_DESC	512
-#define PRUETH_MAX_RX_FLOWS	1	/* excluding default flow */
+
+/* There are 4 Tx DMA channels, but the highest priority is CH3 (thread 3)
+ * and lower three are lower priority channels or threads.
+ */
+#define PRUETH_MAX_TX_QUEUES	4
+#define PRUETH_MAX_RX_FLOWS	8
 #define PRUETH_RX_FLOW_DATA	0
 
 /* Defines for forwarding path buffer pools:
diff --git a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
index b715af21d23ac..68646cb7df442 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
@@ -140,13 +140,14 @@ static int emac_set_channels(struct net_device *ndev,
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
 
-	/* Check if interface is up. Can change the num queues when
-	 * the interface is down.
+	/* Check if interface is up. Can't change the num queues when
+	 * the interface is up.
 	 */
 	if (netif_running(emac->ndev))
 		return -EBUSY;
 
 	emac->tx_ch_num = ch->tx_count;
+	emac->rx_flow_num = ch->rx_count;
 
 	if (emac->is_sr1)
 		emac->tx_ch_num++;
@@ -159,7 +160,7 @@ static void emac_get_channels(struct net_device *ndev,
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
 
-	ch->max_rx = 1;
+	ch->max_rx = ICSSG_MAX_RFLOWS;
 	ch->max_tx = PRUETH_MAX_TX_QUEUES;
 
 	/* Disable multiple TX channels due to timeouts
@@ -167,7 +168,7 @@ static void emac_get_channels(struct net_device *ndev,
 	if (emac->is_sr1)
 		ch->max_tx = 1;
 
-	ch->rx_count = 1;
+	ch->rx_count = emac->rx_flow_num;
 	ch->tx_count = emac->tx_ch_num;
 
 	if (emac->is_sr1)
@@ -213,11 +214,13 @@ static int emac_get_coalesce(struct net_device *ndev,
 			     struct netlink_ext_ack *extack)
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *flow = &rx_chn->flows[0];
 	struct prueth_tx_chn *tx_chn;
 
 	tx_chn = &emac->tx_chns[0];
 
-	coal->rx_coalesce_usecs = emac->rx_pace_timeout_ns / 1000;
+	coal->rx_coalesce_usecs = flow->rx_pace_timeout_ns / 1000;
 	coal->tx_coalesce_usecs = tx_chn->tx_pace_timeout_ns / 1000;
 
 	return 0;
@@ -245,8 +248,10 @@ static int emac_set_coalesce(struct net_device *ndev,
 			     struct netlink_ext_ack *extack)
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
 	struct prueth *prueth = emac->prueth;
 	struct prueth_tx_chn *tx_chn;
+	int i;
 
 	tx_chn = &emac->tx_chns[0];
 
@@ -264,7 +269,8 @@ static int emac_set_coalesce(struct net_device *ndev,
 		coal->tx_coalesce_usecs = ICSSG_MIN_COALESCE_USECS;
 	}
 
-	emac->rx_pace_timeout_ns = coal->rx_coalesce_usecs * 1000;
+	for (i = 0; i < emac->rx_flow_num; i++)
+		rx_chn->flows[i].rx_pace_timeout_ns = coal->rx_coalesce_usecs * 1000;
 	tx_chn->tx_pace_timeout_ns = coal->tx_coalesce_usecs * 1000;
 
 	return 0;
diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.c b/drivers/net/ethernet/ti/icssg/icssg_prueth.c
index 9bb67e185a3ea..716f1b9195d67 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_prueth.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.c
@@ -36,8 +36,6 @@
 #include "icssg_switchdev.h"
 #include "../k3-cppi-desc-pool.h"
 
-#define PRUETH_MODULE_DESCRIPTION "PRUSS ICSSG Ethernet driver"
-
 #define DEFAULT_VID		1
 #define DEFAULT_PORT_MASK	1
 #define DEFAULT_UNTAG_MASK	1
@@ -50,8 +48,6 @@
 #define PRUETH_RX_DMA_ATTR			(DMA_ATTR_SKIP_CPU_SYNC |\
 						 DMA_ATTR_WEAK_ORDERING)
 
-/* CTRLMMR_ICSSG_RGMII_CTRL register bits */
-#define ICSSG_CTRL_RGMII_ID_MODE                BIT(24)
 
 static void emac_adjust_link(struct net_device *ndev);
 
@@ -403,20 +399,6 @@ static void emac_adjust_link(struct net_device *ndev)
 	}
 }
 
-static enum hrtimer_restart emac_rx_timer_callback(struct hrtimer *timer)
-{
-	struct prueth_emac *emac =
-			container_of(timer, struct prueth_emac, rx_hrtimer);
-	int rx_flow = PRUETH_RX_FLOW_DATA;
-
-	if (emac->rx_chns.irq_disabled) {
-		/* re-enable the RX IRQ */
-		emac->rx_chns.irq_disabled = false;
-		enable_irq(emac->rx_chns.irq[rx_flow]);
-	}
-	return HRTIMER_NORESTART;
-}
-
 static int emac_phy_connect(struct prueth_emac *emac)
 {
 	struct prueth *prueth = emac->prueth;
@@ -587,43 +569,6 @@ const struct icss_iep_clockops prueth_iep_clockops = {
 	.perout_enable = prueth_perout_enable,
 };
 
-static void prueth_destroy_xdp_rxqs(struct prueth_emac *emac)
-{
-	struct xdp_rxq_info *rxq = &emac->rx_chns.xdp_rxq;
-
-	if (xdp_rxq_info_is_reg(rxq))
-		xdp_rxq_info_unreg(rxq);
-}
-
-static int prueth_create_xdp_rxqs(struct prueth_emac *emac)
-{
-	struct xdp_rxq_info *rxq = &emac->rx_chns.xdp_rxq;
-	struct page_pool *pool = emac->rx_chns.pg_pool;
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
-	int ret;
-
-	ret = xdp_rxq_info_reg(rxq, emac->ndev, 0, emac->napi_rx.napi_id);
-	if (ret)
-		return ret;
-
-	if (rx_chn->xsk_pool) {
-		ret = xdp_rxq_info_reg_mem_model(rxq, MEM_TYPE_XSK_BUFF_POOL, NULL);
-		if (ret)
-			goto xdp_unreg;
-		xsk_pool_set_rxq_info(rx_chn->xsk_pool, rxq);
-	} else {
-		ret = xdp_rxq_info_reg_mem_model(rxq, MEM_TYPE_PAGE_POOL, pool);
-		if (ret)
-			goto xdp_unreg;
-	}
-
-	return 0;
-
-xdp_unreg:
-	prueth_destroy_xdp_rxqs(emac);
-	return ret;
-}
-
 static int icssg_prueth_add_mcast(struct net_device *ndev, const u8 *addr)
 {
 	struct net_device *real_dev;
@@ -883,14 +828,14 @@ static int icssg_update_vlan_mcast(struct net_device *vdev, int vid,
 static void prueth_set_xsk_pool(struct prueth_emac *emac, u16 queue_id)
 {
 	struct prueth_tx_chn *tx_chn = &emac->tx_chns[queue_id];
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *rx_flow = &emac->rx_chns.flows[queue_id];
 
-	if (emac->xsk_qid != queue_id) {
-		rx_chn->xsk_pool = NULL;
-		tx_chn->xsk_pool = NULL;
-	} else {
-		rx_chn->xsk_pool = xsk_get_pool_from_qid(emac->ndev, queue_id);
+	if (test_bit(queue_id, emac->xsk_queues)) {
+		rx_flow->xsk_pool = xsk_get_pool_from_qid(emac->ndev, queue_id);
 		tx_chn->xsk_pool = xsk_get_pool_from_qid(emac->ndev, queue_id);
+	} else {
+		rx_flow->xsk_pool = NULL;
+		tx_chn->xsk_pool = NULL;
 	}
 }
 
@@ -921,7 +866,43 @@ static void prueth_destroy_txq(struct prueth_emac *emac)
 	}
 }
 
-static void prueth_destroy_rxq(struct prueth_emac *emac)
+static void prueth_destroy_rxq(struct prueth_emac *emac, int qid)
+{
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *flow = &rx_chn->flows[qid];
+	dma_addr_t desc_dma;
+
+	napi_disable(&flow->napi_rx);
+	hrtimer_cancel(&flow->rx_hrtimer);
+	if (flow->irq_disabled) {
+		enable_irq(flow->irq);
+		flow->irq_disabled = false;
+	}
+
+	/* k3_udma_glue_reset_rx_chn() only drains the FDQ; it resets the
+	 * completion ring (RXCQ) without freeing descriptors still in it.
+	 * Teardown posts TDCM only to flow 0's RXCQ; flows 1..N have no
+	 * NAPI trigger to drain their RXCQs. Drain each flow's RXCQ here
+	 * so page_pool_destroy() finds no inflight pages.
+	 */
+	while (!k3_udma_glue_pop_rx_chn(rx_chn->rx_chn, qid, &desc_dma)) {
+		if (!cppi5_desc_is_tdcm(desc_dma))
+			prueth_rx_cleanup(rx_chn, desc_dma);
+	}
+
+	k3_udma_glue_reset_rx_chn(rx_chn->rx_chn, flow->id, rx_chn,
+				  prueth_rx_cleanup);
+
+	if (xdp_rxq_info_is_reg(&flow->xdp_rxq))
+		xdp_rxq_info_unreg(&flow->xdp_rxq);
+
+	if (flow->pg_pool) {
+		page_pool_destroy(flow->pg_pool);
+		flow->pg_pool = NULL;
+	}
+}
+
+static void prueth_destroy_rxqs(struct prueth_emac *emac)
 {
 	int i, ret;
 
@@ -929,16 +910,14 @@ static void prueth_destroy_rxq(struct prueth_emac *emac)
 	reinit_completion(&emac->tdown_complete);
 	k3_udma_glue_tdown_rx_chn(emac->rx_chns.rx_chn, true);
 
-	/* When RX DMA Channel Teardown is initiated, it will result in an
-	 * interrupt and a Teardown Completion Marker (TDCM) is queued into
-	 * the RX Completion queue. Acknowledging the interrupt involves
-	 * popping the TDCM descriptor from the RX Completion queue via the
-	 * RX NAPI Handler. To avoid timing out when waiting for the TDCM to
-	 * be popped, schedule the RX NAPI handler to run immediately.
+	/* When RX DMA Channel Teardown is initiated, the hardware posts a
+	 * Teardown Completion Marker (TDCM) to flow 0's RXCQ. Schedule flow
+	 * 0's NAPI unconditionally so the TDCM is popped promptly regardless
+	 * of whether the RX IRQ is currently disabled by hrtimer coalescing.
 	 */
-	if (!napi_if_scheduled_mark_missed(&emac->napi_rx)) {
-		if (napi_schedule_prep(&emac->napi_rx))
-			__napi_schedule(&emac->napi_rx);
+	if (!napi_if_scheduled_mark_missed(&emac->rx_chns.flows[0].napi_rx)) {
+		if (napi_schedule_prep(&emac->rx_chns.flows[0].napi_rx))
+			__napi_schedule(&emac->rx_chns.flows[0].napi_rx);
 	}
 
 	ret = wait_for_completion_timeout(&emac->tdown_complete,
@@ -946,15 +925,9 @@ static void prueth_destroy_rxq(struct prueth_emac *emac)
 	if (!ret)
 		netdev_err(emac->ndev, "rx teardown timeout\n");
 
-	for (i = 0; i < PRUETH_MAX_RX_FLOWS; i++) {
-		napi_disable(&emac->napi_rx);
-		hrtimer_cancel(&emac->rx_hrtimer);
-		k3_udma_glue_reset_rx_chn(emac->rx_chns.rx_chn, i,
-					  &emac->rx_chns,
-					  prueth_rx_cleanup);
-	}
+	for (i = 0; i < emac->rx_flow_num; i++)
+		prueth_destroy_rxq(emac, i);
 
-	prueth_destroy_xdp_rxqs(emac);
 	k3_udma_glue_disable_rx_chn(emac->rx_chns.rx_chn);
 }
 
@@ -978,27 +951,78 @@ static int prueth_create_txq(struct prueth_emac *emac)
 	return ret;
 }
 
-static int prueth_create_rxq(struct prueth_emac *emac)
+static int prueth_create_rxq(struct prueth_emac *emac, int id)
 {
+	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_rx_flow *flow = &rx_chn->flows[id];
+	struct xdp_rxq_info *rxq = &flow->xdp_rxq;
 	int ret;
 
-	ret = prueth_prepare_rx_chan(emac, &emac->rx_chns, PRUETH_MAX_PKT_SIZE);
+	ret = prueth_prepare_rx_flow(emac, id);
 	if (ret)
-		return ret;
+		goto err;
 
-	ret = k3_udma_glue_enable_rx_chn(emac->rx_chns.rx_chn);
+	ret = xdp_rxq_info_reg(rxq, emac->ndev, id, flow->napi_rx.napi_id);
 	if (ret)
-		goto reset_rx_chn;
+		goto err;
 
-	ret = prueth_create_xdp_rxqs(emac);
-	if (ret)
-		goto reset_rx_chn;
+	if (flow->xsk_pool) {
+		ret = xdp_rxq_info_reg_mem_model(rxq, MEM_TYPE_XSK_BUFF_POOL, NULL);
+		if (ret)
+			goto err;
+		xsk_pool_set_rxq_info(flow->xsk_pool, rxq);
+	} else {
+		ret = xdp_rxq_info_reg_mem_model(rxq, MEM_TYPE_PAGE_POOL, flow->pg_pool);
+		if (ret)
+			goto err;
+	}
+
+	napi_enable(&flow->napi_rx);
+	return 0;
+
+err:
+	/* napi_enable() not yet called; prueth_destroy_rxq() calls
+	 * napi_disable() which busy-waits for NAPI_STATE_SCHED to clear —
+	 * a bit set by netif_napi_add() that only clears after napi_enable().
+	 * Clean up directly to avoid hanging.
+	 */
+	hrtimer_cancel(&flow->rx_hrtimer);
+	if (flow->irq_disabled) {
+		enable_irq(flow->irq);
+		flow->irq_disabled = false;
+	}
+	k3_udma_glue_reset_rx_chn(rx_chn->rx_chn, id, rx_chn, prueth_rx_cleanup);
+	if (xdp_rxq_info_is_reg(&flow->xdp_rxq))
+		xdp_rxq_info_unreg(&flow->xdp_rxq);
+	if (flow->pg_pool) {
+		page_pool_destroy(flow->pg_pool);
+		flow->pg_pool = NULL;
+	}
+	return ret;
+}
+
+static int prueth_create_rxqs(struct prueth_emac *emac)
+{
+	int i, ret;
 
-	napi_enable(&emac->napi_rx);
+	for (i = 0; i < emac->rx_flow_num; i++) {
+		ret = prueth_create_rxq(emac, i);
+		if (ret) {
+			netdev_err(emac->ndev, "failed to create rxq for flow %d: %d\n",
+				   i, ret);
+			goto err;
+		}
+	}
+
+	/* All flows share the same DMA channel */
+	ret = k3_udma_glue_enable_rx_chn(emac->rx_chns.rx_chn);
+	if (ret)
+		goto err;
 	return 0;
 
-reset_rx_chn:
-	prueth_reset_rx_chan(&emac->rx_chns, PRUETH_MAX_RX_FLOWS, false);
+err:
+	for (--i; i >= 0; i--)
+		prueth_destroy_rxq(emac, i);
 	return ret;
 }
 
@@ -1018,8 +1042,6 @@ static int emac_ndo_open(struct net_device *ndev)
 	struct prueth *prueth = emac->prueth;
 	int slice = prueth_emac_slice(emac);
 	struct device *dev = prueth->dev;
-	int max_rx_flows;
-	int rx_flow;
 
 	/* set h/w MAC as user might have re-configured */
 	ether_addr_copy(emac->mac_addr, ndev->dev_addr);
@@ -1034,7 +1056,12 @@ static int emac_ndo_open(struct net_device *ndev)
 		return ret;
 	}
 
-	emac->xsk_qid = -EINVAL;
+	ret = netif_set_real_num_rx_queues(ndev, emac->rx_flow_num);
+	if (ret) {
+		dev_err(dev, "cannot set real number of rx queues\n");
+		return ret;
+	}
+
 	init_completion(&emac->cmd_complete);
 	ret = prueth_init_tx_chns(emac);
 	if (ret) {
@@ -1042,9 +1069,7 @@ static int emac_ndo_open(struct net_device *ndev)
 		return ret;
 	}
 
-	max_rx_flows = PRUETH_MAX_RX_FLOWS;
-	ret = prueth_init_rx_chns(emac, &emac->rx_chns, "rx",
-				  max_rx_flows, PRUETH_MAX_RX_DESC);
+	ret = prueth_init_rx_chns(emac);
 	if (ret) {
 		dev_err(dev, "failed to init rx channel: %d\n", ret);
 		goto cleanup_tx;
@@ -1054,14 +1079,9 @@ static int emac_ndo_open(struct net_device *ndev)
 	if (ret)
 		goto cleanup_rx;
 
-	/* we use only the highest priority flow for now i.e. @irq[3] */
-	rx_flow = PRUETH_RX_FLOW_DATA;
-	ret = request_irq(emac->rx_chns.irq[rx_flow], prueth_rx_irq,
-			  IRQF_TRIGGER_HIGH, dev_name(dev), emac);
-	if (ret) {
-		dev_err(dev, "unable to request RX IRQ\n");
+	ret = prueth_ndev_add_rx_napi(emac);
+	if (ret)
 		goto cleanup_napi;
-	}
 
 	if (!prueth->emacs_initialized) {
 		ret = prueth_emac_common_start(prueth);
@@ -1087,7 +1107,7 @@ static int emac_ndo_open(struct net_device *ndev)
 		goto stop;
 
 	/* Prepare RX */
-	ret = prueth_create_rxq(emac);
+	ret = prueth_create_rxqs(emac);
 	if (ret)
 		goto free_tx_ts_irq;
 
@@ -1105,18 +1125,18 @@ static int emac_ndo_open(struct net_device *ndev)
 	return 0;
 
 destroy_rxq:
-	prueth_destroy_rxq(emac);
+	prueth_destroy_rxqs(emac);
 free_tx_ts_irq:
 	free_irq(emac->tx_ts_irq, emac);
 stop:
 	if (!prueth->emacs_initialized)
 		prueth_emac_common_stop(prueth);
 free_rx_irq:
-	free_irq(emac->rx_chns.irq[rx_flow], emac);
+	prueth_ndev_del_rx_napi(emac, emac->rx_flow_num);
 cleanup_napi:
 	prueth_ndev_del_tx_napi(emac, emac->tx_ch_num);
 cleanup_rx:
-	prueth_cleanup_rx_chns(emac, &emac->rx_chns, max_rx_flows);
+	prueth_cleanup_rx_chns(emac);
 cleanup_tx:
 	prueth_cleanup_tx_chns(emac);
 
@@ -1149,7 +1169,7 @@ static int emac_ndo_stop(struct net_device *ndev)
 		__dev_mc_unsync(ndev, icssg_prueth_del_mcast);
 
 	prueth_destroy_txq(emac);
-	prueth_destroy_rxq(emac);
+	prueth_destroy_rxqs(emac);
 
 	cancel_work_sync(&emac->rx_mode_work);
 
@@ -1162,10 +1182,10 @@ static int emac_ndo_stop(struct net_device *ndev)
 
 	free_irq(emac->tx_ts_irq, emac);
 
-	free_irq(emac->rx_chns.irq[PRUETH_RX_FLOW_DATA], emac);
+	prueth_ndev_del_rx_napi(emac, emac->rx_flow_num);
 	prueth_ndev_del_tx_napi(emac, emac->tx_ch_num);
 
-	prueth_cleanup_rx_chns(emac, &emac->rx_chns, PRUETH_MAX_RX_FLOWS);
+	prueth_cleanup_rx_chns(emac);
 	prueth_cleanup_tx_chns(emac);
 
 	prueth->emacs_initialized--;
@@ -1467,11 +1487,11 @@ static int emac_xdp_setup(struct prueth_emac *emac, struct netdev_bpf *bpf)
 static int prueth_xsk_pool_enable(struct prueth_emac *emac,
 				  struct xsk_buff_pool *pool, u16 queue_id)
 {
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
 	u32 frame_size;
 	int ret;
 
 	if (queue_id >= PRUETH_MAX_RX_FLOWS ||
+	    queue_id >= emac->rx_flow_num ||
 	    queue_id >= emac->tx_ch_num) {
 		netdev_err(emac->ndev, "Invalid XSK queue ID %d\n", queue_id);
 		return -EINVAL;
@@ -1481,7 +1501,7 @@ static int prueth_xsk_pool_enable(struct prueth_emac *emac,
 	if (frame_size < PRUETH_MAX_PKT_SIZE)
 		return -EOPNOTSUPP;
 
-	ret = xsk_pool_dma_map(pool, rx_chn->dma_dev, PRUETH_RX_DMA_ATTR);
+	ret = xsk_pool_dma_map(pool, emac->rx_chns.dma_dev, PRUETH_RX_DMA_ATTR);
 	if (ret) {
 		netdev_err(emac->ndev, "Failed to map XSK pool: %d\n", ret);
 		return ret;
@@ -1492,21 +1512,24 @@ static int prueth_xsk_pool_enable(struct prueth_emac *emac,
 		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_DISABLE);
 		if (ret)
 			return ret;
-		prueth_destroy_rxq(emac);
+		prueth_destroy_rxq(emac, queue_id);
 	}
 
-	emac->xsk_qid = queue_id;
+	set_bit(queue_id, emac->xsk_queues);
 	prueth_set_xsk_pool(emac, queue_id);
 
 	if (netif_running(emac->ndev)) {
-		ret = prueth_create_rxq(emac);
+		ret = prueth_create_rxq(emac, queue_id);
 		if (ret) {
 			netdev_err(emac->ndev, "Failed to create RX queue: %d\n", ret);
+			clear_bit(queue_id, emac->xsk_queues);
+			prueth_set_xsk_pool(emac, queue_id);
+			xsk_pool_dma_unmap(pool, PRUETH_RX_DMA_ATTR);
 			return ret;
 		}
 		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
 		if (ret) {
-			prueth_destroy_rxq(emac);
+			prueth_destroy_rxq(emac, queue_id);
 			return ret;
 		}
 		ret = prueth_xsk_wakeup(emac->ndev, queue_id, XDP_WAKEUP_RX);
@@ -1523,12 +1546,13 @@ static int prueth_xsk_pool_disable(struct prueth_emac *emac, u16 queue_id)
 	int ret;
 
 	if (queue_id >= PRUETH_MAX_RX_FLOWS ||
+	    queue_id >= emac->rx_flow_num ||
 	    queue_id >= emac->tx_ch_num) {
 		netdev_err(emac->ndev, "Invalid XSK queue ID %d\n", queue_id);
 		return -EINVAL;
 	}
 
-	if (emac->xsk_qid != queue_id) {
+	if (!test_bit(queue_id, emac->xsk_queues)) {
 		netdev_err(emac->ndev, "XSK queue ID %d not registered\n", queue_id);
 		return -EINVAL;
 	}
@@ -1544,27 +1568,28 @@ static int prueth_xsk_pool_disable(struct prueth_emac *emac, u16 queue_id)
 		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_DISABLE);
 		if (ret)
 			return ret;
-		prueth_destroy_rxq(emac);
+		prueth_destroy_rxq(emac, queue_id);
 	}
 
 	xsk_pool_dma_unmap(pool, PRUETH_RX_DMA_ATTR);
-	emac->xsk_qid = -EINVAL;
+	clear_bit(queue_id, emac->xsk_queues);
 	prueth_set_xsk_pool(emac, queue_id);
 
 	if (netif_running(emac->ndev)) {
-		ret = prueth_create_rxq(emac);
-		if (ret) {
-			netdev_err(emac->ndev, "Failed to create RX queue: %d\n", ret);
-			return ret;
-		}
-		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
-		if (ret) {
-			prueth_destroy_rxq(emac);
-			return ret;
-		}
+		ret = prueth_create_rxq(emac, queue_id);
+		if (ret)
+			netdev_err(emac->ndev, "Failed to recreate RX queue after XSK disable: %d\n",
+				   ret);
+
+		/* Always re-enable port forwarding so the interface is not left
+		 * permanently disabled if prueth_create_rxq() failed due to a
+		 * transient descriptor shortage (inflight pages not yet returned
+		 * by the network stack).
+		 */
+		icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
 	}
 
-	return 0;
+	return ret;
 }
 
 /**
@@ -1593,25 +1618,31 @@ static int emac_ndo_bpf(struct net_device *ndev, struct netdev_bpf *bpf)
 int prueth_xsk_wakeup(struct net_device *ndev, u32 qid, u32 flags)
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
-	struct prueth_tx_chn *tx_chn = &emac->tx_chns[qid];
-	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
+	struct prueth_tx_chn *tx_chn;
+	struct prueth_rx_flow *rx_flow;
 
-	if (emac->xsk_qid != qid) {
-		netdev_err(ndev, "XSK queue %d not registered\n", qid);
+	/* Bounds check before any array/bitmap access */
+	if (qid >= PRUETH_MAX_RX_FLOWS ||
+	    qid >= emac->rx_flow_num ||
+	    qid >= emac->tx_ch_num) {
+		netdev_err(ndev, "Invalid XSK queue ID %d\n", qid);
 		return -EINVAL;
 	}
 
-	if (qid >= PRUETH_MAX_RX_FLOWS || qid >= emac->tx_ch_num) {
-		netdev_err(ndev, "Invalid XSK queue ID %d\n", qid);
+	if (!test_bit(qid, emac->xsk_queues)) {
+		netdev_err(ndev, "XSK queue %d not registered\n", qid);
 		return -EINVAL;
 	}
 
+	tx_chn = &emac->tx_chns[qid];
+	rx_flow = &emac->rx_chns.flows[qid];
+
 	if (!tx_chn->xsk_pool) {
 		netdev_err(ndev, "XSK pool not registered for queue %d\n", qid);
 		return -EINVAL;
 	}
 
-	if (!rx_chn->xsk_pool) {
+	if (!rx_flow->xsk_pool) {
 		netdev_err(ndev, "XSK pool not registered for RX queue %d\n", qid);
 		return -EINVAL;
 	}
@@ -1624,9 +1655,9 @@ int prueth_xsk_wakeup(struct net_device *ndev, u32 qid, u32 flags)
 	}
 
 	if (flags & XDP_WAKEUP_RX) {
-		if (!napi_if_scheduled_mark_missed(&emac->napi_rx)) {
-			if (likely(napi_schedule_prep(&emac->napi_rx)))
-				__napi_schedule(&emac->napi_rx);
+		if (!napi_if_scheduled_mark_missed(&rx_flow->napi_rx)) {
+			if (likely(napi_schedule_prep(&rx_flow->napi_rx)))
+				__napi_schedule(&rx_flow->napi_rx);
 		}
 	}
 
@@ -1657,12 +1688,12 @@ static const struct net_device_ops emac_netdev_ops = {
 static int prueth_netdev_init(struct prueth *prueth,
 			      struct device_node *eth_node)
 {
-	int ret, num_tx_chn = PRUETH_MAX_TX_QUEUES;
 	struct prueth_emac *emac;
 	struct net_device *ndev;
 	enum prueth_port port;
 	const char *irq_name;
 	enum prueth_mac mac;
+	int ret;
 
 	port = prueth_node_port(eth_node);
 	if (port == PRUETH_PORT_INVALID)
@@ -1672,7 +1703,7 @@ static int prueth_netdev_init(struct prueth *prueth,
 	if (mac == PRUETH_MAC_INVALID)
 		return -EINVAL;
 
-	ndev = alloc_etherdev_mq(sizeof(*emac), num_tx_chn);
+	ndev = alloc_etherdev_mqs(sizeof(*emac), PRUETH_MAX_TX_QUEUES, PRUETH_MAX_RX_FLOWS);
 	if (!ndev)
 		return -ENOMEM;
 
@@ -1697,6 +1728,14 @@ static int prueth_netdev_init(struct prueth *prueth,
 	}
 
 	emac->tx_ch_num = 1;
+	emac->rx_flow_num = 1;
+	emac->xsk_queues = devm_bitmap_zalloc(prueth->dev,
+					      PRUETH_MAX_RX_FLOWS, GFP_KERNEL);
+	if (!emac->xsk_queues) {
+		dev_err(prueth->dev, "failed to allocate xsk_queues bitmap\n");
+		ret = -ENOMEM;
+		goto free;
+	}
 
 	irq_name = "tx_ts0";
 	if (emac->port_id == PRUETH_PORT_MII1)
@@ -1783,11 +1822,7 @@ static int prueth_netdev_init(struct prueth *prueth,
 			      NETDEV_XDP_ACT_NDO_XMIT |
 			      NETDEV_XDP_ACT_XSK_ZEROCOPY);
 
-	netif_napi_add(ndev, &emac->napi_rx, icssg_napi_rx_poll);
-	hrtimer_setup(&emac->rx_hrtimer, &emac_rx_timer_callback, CLOCK_MONOTONIC,
-		      HRTIMER_MODE_REL_PINNED);
 	prueth->emac[mac] = emac;
-
 	return 0;
 
 free:
diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.h b/drivers/net/ethernet/ti/icssg/icssg_prueth.h
index df93d15c5b786..d54966730d102 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_prueth.h
+++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.h
@@ -132,18 +132,27 @@ struct prueth_tx_chn {
 	bool irq_disabled;
 };
 
+struct prueth_rx_flow {
+	u32 id;
+	struct prueth_emac *emac;
+	struct napi_struct napi_rx;
+	int irq;
+	bool irq_disabled;
+	struct hrtimer rx_hrtimer;
+	unsigned long rx_pace_timeout_ns;
+	struct page_pool *pg_pool;
+	struct xdp_rxq_info xdp_rxq;
+	struct xsk_buff_pool *xsk_pool;
+	char name[32];
+};
+
 struct prueth_rx_chn {
-	struct device *dev;
 	struct device *dma_dev;
 	struct k3_cppi_desc_pool *desc_pool;
 	struct k3_udma_glue_rx_channel *rx_chn;
+	struct prueth_emac *emac;
 	u32 descs_num;
-	unsigned int irq[ICSSG_MAX_RFLOWS];	/* separate irq per flow */
-	char name[32];
-	struct page_pool *pg_pool;
-	struct xdp_rxq_info xdp_rxq;
-	struct xsk_buff_pool *xsk_pool;
-	bool irq_disabled;
+	struct prueth_rx_flow flows[PRUETH_MAX_RX_FLOWS];
 };
 
 enum prueth_swdata_type {
@@ -162,6 +171,7 @@ enum prueth_tx_buff_type {
 
 struct prueth_swdata {
 	enum prueth_swdata_type type;
+	u32 flow_id;
 	union prueth_data {
 		struct sk_buff *skb;
 		struct page *page;
@@ -171,11 +181,6 @@ struct prueth_swdata {
 	} data;
 };
 
-/* There are 4 Tx DMA channels, but the highest priority is CH3 (thread 3)
- * and lower three are lower priority channels or threads.
- */
-#define PRUETH_MAX_TX_QUEUES	4
-
 #define PRUETH_MAX_TX_TS_REQUESTS	50 /* Max simultaneous TX_TS requests */
 
 /* XDP BPF state */
@@ -193,7 +198,6 @@ struct prueth_emac {
 	struct prueth *prueth;
 	struct net_device *ndev;
 	u8 mac_addr[6];
-	struct napi_struct napi_rx;
 	u32 msg_enable;
 
 	int link;
@@ -216,6 +220,7 @@ struct prueth_emac {
 	struct prueth_rx_chn rx_chns;
 	int rx_flow_id_base;
 	int tx_ch_num;
+	int rx_flow_num;
 
 	/* SR1.0 Management channel */
 	struct prueth_rx_chn rx_mgm_chn;
@@ -246,14 +251,11 @@ struct prueth_emac {
 	u64 stats[ICSSG_NUM_MIIG_STATS];
 	u64 pa_stats[ICSSG_NUM_PA_STATS];
 
-	/* RX IRQ Coalescing Related */
-	struct hrtimer rx_hrtimer;
-	unsigned long rx_pace_timeout_ns;
-
 	struct netdev_hw_addr_list vlan_mcast_list[MAX_VLAN_ID];
 	struct bpf_prog *xdp_prog;
 	struct xdp_attachment_info xdpi;
 	int xsk_qid;
+	unsigned long *xsk_queues;
 };
 
 /* The buf includes headroom compatible with both skb and xdpf */
@@ -455,30 +457,30 @@ void icssg_set_pvid(struct prueth *prueth, u8 vid, u8 port);
 int emac_fdb_flow_id_updated(struct prueth_emac *emac);
 #define prueth_napi_to_tx_chn(pnapi) \
 	container_of(pnapi, struct prueth_tx_chn, napi_tx)
+#define prueth_napi_to_rx_chn(pnapi) \
+	container_of(pnapi, struct prueth_rx_flow, napi_rx)
 
 void icssg_stats_work_handler(struct work_struct *work);
 void emac_update_hardware_stats(struct prueth_emac *emac);
 int emac_get_stat_by_name(struct prueth_emac *emac, char *stat_name);
 
 /* Common functions */
-void prueth_cleanup_rx_chns(struct prueth_emac *emac,
-			    struct prueth_rx_chn *rx_chn,
-			    int max_rflows);
+void prueth_cleanup_rx_chns(struct prueth_emac *emac);
 void prueth_cleanup_tx_chns(struct prueth_emac *emac);
 void prueth_ndev_del_tx_napi(struct prueth_emac *emac, int num);
+void prueth_ndev_del_rx_napi(struct prueth_emac *emac, int num);
 void prueth_xmit_free(struct prueth_tx_chn *tx_chn,
 		      struct cppi5_host_desc_t *desc);
 int emac_tx_complete_packets(struct prueth_emac *emac, int chn,
 			     int budget, bool *tdown);
 int prueth_ndev_add_tx_napi(struct prueth_emac *emac);
+int prueth_ndev_add_rx_napi(struct prueth_emac *emac);
 int prueth_init_tx_chns(struct prueth_emac *emac);
-int prueth_init_rx_chns(struct prueth_emac *emac,
-			struct prueth_rx_chn *rx_chn,
-			char *name, u32 max_rflows,
-			u32 max_desc_num);
+int prueth_init_rx_chns(struct prueth_emac *emac);
 int prueth_dma_rx_push_mapped(struct prueth_emac *emac,
 			      struct prueth_rx_chn *rx_chn,
-			      struct page *page, u32 buf_len);
+			      struct page *page, u32 buf_len,
+			      int flow_id);
 unsigned int prueth_rxbuf_total_len(unsigned int len);
 void emac_rx_timestamp(struct prueth_emac *emac,
 		       struct sk_buff *skb, u32 *psdata);
@@ -486,13 +488,11 @@ enum netdev_tx icssg_ndo_start_xmit(struct sk_buff *skb, struct net_device *ndev
 irqreturn_t prueth_rx_irq(int irq, void *dev_id);
 void prueth_cleanup_tx_ts(struct prueth_emac *emac);
 int icssg_napi_rx_poll(struct napi_struct *napi_rx, int budget);
-int prueth_prepare_rx_chan(struct prueth_emac *emac,
-			   struct prueth_rx_chn *chn,
-			   int buf_size);
+int prueth_prepare_rx_flow(struct prueth_emac *emac,
+			   int flow);
 void prueth_reset_tx_chan(struct prueth_emac *emac, int ch_num,
 			  bool free_skb);
-void prueth_reset_rx_chan(struct prueth_rx_chn *chn,
-			  int num_flows, bool disable);
+void prueth_reset_rx_chan(struct prueth_emac *emac, bool disable);
 void icssg_ndo_tx_timeout(struct net_device *ndev, unsigned int txqueue);
 int icssg_ndo_get_ts_config(struct net_device *ndev,
 			    struct kernel_hwtstamp_config *config);
diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c b/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c
index 21a14b3bc889b..589b73be3ac60 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c
@@ -306,7 +306,7 @@ static struct page *prueth_process_rx_mgm(struct prueth_emac *emac,
 	dma_unmap_single(rx_chn->dma_dev, buf_dma, buf_dma_len, DMA_FROM_DEVICE);
 	k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
 
-	new_page = page_pool_dev_alloc_pages(rx_chn->pg_pool);
+	new_page = page_pool_dev_alloc_pages(rx_chn->flows[flow_id].pg_pool);
 	/* if allocation fails we drop the packet but push the
 	 * descriptor back to the ring with old skb to prevent a stall
 	 */
@@ -319,14 +319,104 @@ static struct page *prueth_process_rx_mgm(struct prueth_emac *emac,
 	}
 
 	/* queue another DMA */
-	ret = prueth_dma_rx_push_mapped(emac, &emac->rx_chns, new_page,
-					PRUETH_MAX_PKT_SIZE);
+	ret = prueth_dma_rx_push_mapped(emac, rx_chn, new_page,
+					PRUETH_MAX_PKT_SIZE, flow_id);
 	if (WARN_ON(ret < 0))
-		page_pool_recycle_direct(rx_chn->pg_pool, new_page);
+		page_pool_recycle_direct(rx_chn->flows[flow_id].pg_pool, new_page);
 
 	return page;
 }
 
+/* SR1-specific helpers for rx_mgm_chn */
+
+static int prueth_sr1_prepare_rx_mgm_flow(struct prueth_emac *emac, int flow, u32 buf_len)
+{
+	struct prueth_rx_flow *rx_flow;
+	struct prueth_rx_chn *rx_chn;
+	struct page_pool *pool;
+	struct page *page;
+	int desc_avail;
+	int i, ret;
+
+	rx_chn = &emac->rx_mgm_chn;
+	rx_flow = &rx_chn->flows[flow];
+
+	/* Initialize page pool for this flow - using simple page pool */
+	pool = page_pool_create(&(struct page_pool_params){
+		.order = 0,
+		.pool_size = rx_chn->descs_num,
+		.nid = NUMA_NO_NODE,
+		.dev = rx_chn->dma_dev,
+		.dma_dir = DMA_FROM_DEVICE,
+		.max_len = PRUETH_MAX_PKT_SIZE,
+	});
+
+	if (IS_ERR(pool))
+		return PTR_ERR(pool);
+
+	rx_flow->pg_pool = pool;
+
+	desc_avail = k3_cppi_desc_pool_avail(rx_chn->desc_pool);
+	if (desc_avail < PRUETH_MAX_RX_DESC)
+		netdev_warn(emac->ndev,
+			    "not enough RX descriptors available %d < %d\n",
+			    desc_avail, PRUETH_MAX_RX_DESC);
+
+	for (i = 0; i < desc_avail; i++) {
+		page = page_pool_dev_alloc_pages(rx_flow->pg_pool);
+		if (!page)
+			break;
+
+		ret = prueth_dma_rx_push_mapped(emac, rx_chn, page, buf_len, flow);
+		if (ret < 0) {
+			page_pool_recycle_direct(rx_flow->pg_pool, page);
+			netdev_err(emac->ndev, "failed to push rx mgm buf %d\n", ret);
+			break;
+		}
+	}
+
+	return 0;
+}
+
+static void prueth_sr1_cleanup_rx_mgm_chn(struct prueth_emac *emac)
+{
+	struct prueth_rx_flow *flow;
+	int i;
+
+	for (i = 0; i < PRUETH_MAX_RX_MGM_FLOWS_SR1; i++) {
+		flow = &emac->rx_mgm_chn.flows[i];
+		if (flow->pg_pool) {
+			page_pool_destroy(flow->pg_pool);
+			flow->pg_pool = NULL;
+		}
+	}
+
+	if (emac->rx_mgm_chn.rx_chn) {
+		k3_udma_glue_release_rx_chn(emac->rx_mgm_chn.rx_chn);
+		emac->rx_mgm_chn.rx_chn = NULL;
+	}
+}
+
+static void prueth_sr1_reset_rx_mgm_chn(struct prueth_emac *emac, bool disable)
+{
+	struct prueth_rx_flow *flow;
+	int i;
+
+	for (i = 0; i < PRUETH_MAX_RX_MGM_FLOWS_SR1; i++) {
+		flow = &emac->rx_mgm_chn.flows[i];
+		if (flow->irq <= 0)
+			continue;
+
+		if (disable) {
+			disable_irq(flow->irq);
+			flow->irq_disabled = true;
+		} else if (flow->irq_disabled) {
+			enable_irq(flow->irq);
+			flow->irq_disabled = false;
+		}
+	}
+}
+
 static void prueth_tx_ts_sr1(struct prueth_emac *emac,
 			     struct emac_tx_ts_response_sr1 *tsr)
 {
@@ -484,9 +574,15 @@ static int emac_ndo_open(struct net_device *ndev)
 	struct prueth *prueth = emac->prueth;
 	int slice = prueth_emac_slice(emac);
 	struct device *dev = prueth->dev;
-	int max_rx_flows, rx_flow;
+	struct k3_udma_glue_rx_channel_cfg rx_cfg;
+	struct prueth_rx_flow *flow;
+	char udma_name[32];
+	u32 hdesc_size;
 	int ret, i;
 
+	if (slice < 0)
+		return slice;
+
 	/* clear SMEM and MSMC settings for all slices */
 	if (!prueth->emacs_initialized) {
 		memset_io(prueth->msmcram.va, 0, prueth->msmcram.size);
@@ -514,37 +610,116 @@ static int emac_ndo_open(struct net_device *ndev)
 		return ret;
 	}
 
-	max_rx_flows = PRUETH_MAX_RX_FLOWS_SR1;
-	ret = prueth_init_rx_chns(emac, &emac->rx_chns, "rx",
-				  max_rx_flows, PRUETH_MAX_RX_DESC);
+	emac->rx_flow_num = 1;
+	ret = prueth_init_rx_chns(emac);
 	if (ret) {
 		dev_err(dev, "failed to init rx channel: %d\n", ret);
 		goto cleanup_tx;
 	}
 
-	ret = prueth_init_rx_chns(emac, &emac->rx_mgm_chn, "rxmgm",
-				  PRUETH_MAX_RX_MGM_FLOWS_SR1,
-				  PRUETH_MAX_RX_MGM_DESC_SR1);
-	if (ret) {
-		dev_err(dev, "failed to init rx mgmt channel: %d\n",
-			ret);
+	/* Initialize management channel - SR1 specific */
+	emac->rx_mgm_chn.emac = emac;
+	hdesc_size = cppi5_hdesc_calc_size(true, PRUETH_NAV_PS_DATA_SIZE,
+					   PRUETH_NAV_SW_DATA_SIZE);
+	memset(&rx_cfg, 0, sizeof(rx_cfg));
+	rx_cfg.swdata_size = PRUETH_NAV_SW_DATA_SIZE;
+	rx_cfg.flow_id_num = PRUETH_MAX_RX_MGM_FLOWS_SR1;
+	rx_cfg.flow_id_base = -1;
+
+	snprintf(udma_name, sizeof(udma_name), "%s%d", "rxmgm", slice);
+	emac->rx_mgm_chn.rx_chn = k3_udma_glue_request_rx_chn(dev, udma_name,
+							     &rx_cfg);
+	if (IS_ERR(emac->rx_mgm_chn.rx_chn)) {
+		ret = PTR_ERR(emac->rx_mgm_chn.rx_chn);
+		emac->rx_mgm_chn.rx_chn = NULL;
+		dev_err(dev, "Failed to request rx mgm dma ch: %d\n", ret);
 		goto cleanup_rx;
 	}
 
+	emac->rx_mgm_chn.descs_num = PRUETH_MAX_RX_MGM_DESC_SR1 * rx_cfg.flow_id_num;
+	emac->rx_mgm_chn.dma_dev = k3_udma_glue_rx_get_dma_device(emac->rx_mgm_chn.rx_chn);
+	emac->rx_mgm_chn.desc_pool = k3_cppi_desc_pool_create_name(emac->rx_mgm_chn.dma_dev,
+								    emac->rx_mgm_chn.descs_num,
+								    hdesc_size,
+								    "rx_mgm_desc_pool");
+	if (IS_ERR(emac->rx_mgm_chn.desc_pool)) {
+		ret = PTR_ERR(emac->rx_mgm_chn.desc_pool);
+		emac->rx_mgm_chn.desc_pool = NULL;
+		dev_err(dev, "Failed to create rx mgm pool: %d\n", ret);
+		k3_udma_glue_release_rx_chn(emac->rx_mgm_chn.rx_chn);
+		emac->rx_mgm_chn.rx_chn = NULL;
+		goto cleanup_rx_mgm_init;
+	}
+
+	for (i = 0; i < rx_cfg.flow_id_num; i++) {
+		flow = &emac->rx_mgm_chn.flows[i];
+		flow->pg_pool = NULL;
+		flow->xsk_pool = NULL;
+	}
+
+	emac->rx_mgm_flow_id_base = k3_udma_glue_rx_get_flow_id_base(emac->rx_mgm_chn.rx_chn);
+	netdev_dbg(ndev, "rx mgm flow id base = %d\n", emac->rx_mgm_flow_id_base);
+
+	for (i = 0; i < rx_cfg.flow_id_num; i++) {
+		struct k3_ring_cfg rxring_cfg = {
+			.elm_size = K3_RINGACC_RING_ELSIZE_8,
+			.mode = K3_RINGACC_RING_MODE_RING,
+			.flags = 0,
+		};
+		struct k3_ring_cfg fdqring_cfg = {
+			.elm_size = K3_RINGACC_RING_ELSIZE_8,
+			.flags = K3_RINGACC_RING_SHARED,
+		};
+		struct k3_udma_glue_rx_flow_cfg rx_flow_cfg = {
+			.rx_cfg = rxring_cfg,
+			.rxfdq_cfg = fdqring_cfg,
+			.ring_rxq_id = K3_RINGACC_RING_ID_ANY,
+			.src_tag_lo_sel =
+				K3_UDMA_GLUE_SRC_TAG_LO_USE_REMOTE_SRC_TAG,
+		};
+
+		flow = &emac->rx_mgm_chn.flows[i];
+		flow->emac = emac;
+		flow->id = i;
+		flow->irq = -EINVAL;
+
+		rx_flow_cfg.ring_rxfdq0_id = K3_RINGACC_RING_ID_ANY;
+		rx_flow_cfg.rx_cfg.size = PRUETH_MAX_RX_MGM_DESC_SR1;
+		rx_flow_cfg.rxfdq_cfg.size = PRUETH_MAX_RX_MGM_DESC_SR1;
+		rx_flow_cfg.rxfdq_cfg.mode = prueth->pdata.fdqring_mode;
+
+		ret = k3_udma_glue_rx_flow_init(emac->rx_mgm_chn.rx_chn,
+					i, &rx_flow_cfg);
+		if (ret) {
+			dev_err(dev, "Failed to init rx mgm flow%d %d\n",
+				i, ret);
+			goto cleanup_rx_mgm_init;
+		}
+
+		flow->irq = k3_udma_glue_rx_get_irq(emac->rx_mgm_chn.rx_chn, i);
+		if (flow->irq == 0 || flow->irq > INT_MAX) {
+			ret = flow->irq > INT_MAX ? -EINVAL : flow->irq;
+			dev_err(dev, "Failed to get rx mgm dma irq");
+			goto cleanup_rx_mgm_init;
+		}
+
+		snprintf(flow->name, sizeof(flow->name),
+			 "%s-rxmgm%d-%d", dev_name(dev), slice, i);
+	}
+
 	ret = prueth_ndev_add_tx_napi(emac);
 	if (ret)
 		goto cleanup_rx_mgm;
 
-	/* we use only the highest priority flow for now i.e. @irq[3] */
-	rx_flow = PRUETH_RX_FLOW_DATA_SR1;
-	ret = request_irq(emac->rx_chns.irq[rx_flow], prueth_rx_irq,
-			  IRQF_TRIGGER_HIGH, dev_name(dev), emac);
+	/* Data NAPI and IRQ registration via common API */
+	ret = prueth_ndev_add_rx_napi(emac);
 	if (ret) {
-		dev_err(dev, "unable to request RX IRQ\n");
+		dev_err(dev, "unable to add rx napi\n");
 		goto cleanup_napi;
 	}
 
-	ret = request_threaded_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_RESPONSE_SR1],
+	/* Management channel IRQs - SR1 specific */
+	ret = request_threaded_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_RESPONSE_SR1].irq,
 				   NULL, prueth_rx_mgm_rsp_thread,
 				   IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
 				   dev_name(dev), emac);
@@ -553,7 +728,7 @@ static int emac_ndo_open(struct net_device *ndev)
 		goto free_rx_irq;
 	}
 
-	ret = request_threaded_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1],
+	ret = request_threaded_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1].irq,
 				   NULL, prueth_rx_mgm_ts_thread_sr1,
 				   IRQF_ONESHOT | IRQF_TRIGGER_HIGH,
 				   dev_name(dev), emac);
@@ -570,11 +745,15 @@ static int emac_ndo_open(struct net_device *ndev)
 	icssg_mii_update_mtu(prueth->mii_rt, slice, ndev->max_mtu);
 
 	/* Prepare RX */
-	ret = prueth_prepare_rx_chan(emac, &emac->rx_chns, PRUETH_MAX_PKT_SIZE);
+	ret = prueth_prepare_rx_flow(emac, PRUETH_RX_FLOW_DATA_SR1);
 	if (ret)
 		goto stop;
 
-	ret = prueth_prepare_rx_chan(emac, &emac->rx_mgm_chn, 64);
+	ret = prueth_sr1_prepare_rx_mgm_flow(emac, PRUETH_RX_MGM_FLOW_RESPONSE_SR1, 64);
+	if (ret)
+		goto reset_rx_chn;
+
+	ret = prueth_sr1_prepare_rx_mgm_flow(emac, PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1, 64);
 	if (ret)
 		goto reset_rx_chn;
 
@@ -595,7 +774,7 @@ static int emac_ndo_open(struct net_device *ndev)
 	/* Enable NAPI in Tx and Rx direction */
 	for (i = 0; i < emac->tx_ch_num; i++)
 		napi_enable(&emac->tx_chns[i].napi_tx);
-	napi_enable(&emac->napi_rx);
+	napi_enable(&emac->rx_chns.flows[PRUETH_RX_FLOW_DATA_SR1].napi_rx);
 
 	/* start PHY */
 	phy_start(ndev->phydev);
@@ -612,27 +791,27 @@ static int emac_ndo_open(struct net_device *ndev)
 	 */
 	prueth_reset_tx_chan(emac, i, false);
 reset_rx_mgm_chn:
-	prueth_reset_rx_chan(&emac->rx_mgm_chn,
-			     PRUETH_MAX_RX_MGM_FLOWS_SR1, true);
+	prueth_sr1_reset_rx_mgm_chn(emac, true);
 reset_rx_chn:
-	prueth_reset_rx_chan(&emac->rx_chns, max_rx_flows, false);
+	prueth_reset_rx_chan(emac, false);
+cleanup_rx_mgm_init:
+	prueth_sr1_cleanup_rx_mgm_chn(emac);
 stop:
 	prueth_emac_stop(emac);
 free_rx_mgmt_ts_irq:
-	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1],
+	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1].irq,
 		 emac);
 free_rx_mgm_rsp_irq:
-	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_RESPONSE_SR1],
+	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_RESPONSE_SR1].irq,
 		 emac);
 free_rx_irq:
-	free_irq(emac->rx_chns.irq[rx_flow], emac);
+	prueth_ndev_del_rx_napi(emac, 1);
 cleanup_napi:
 	prueth_ndev_del_tx_napi(emac, emac->tx_ch_num);
 cleanup_rx_mgm:
-	prueth_cleanup_rx_chns(emac, &emac->rx_mgm_chn,
-			       PRUETH_MAX_RX_MGM_FLOWS_SR1);
+	prueth_sr1_cleanup_rx_mgm_chn(emac);
 cleanup_rx:
-	prueth_cleanup_rx_chns(emac, &emac->rx_chns, max_rx_flows);
+	prueth_cleanup_rx_chns(emac);
 cleanup_tx:
 	prueth_cleanup_tx_chns(emac);
 
@@ -650,9 +829,7 @@ static int emac_ndo_open(struct net_device *ndev)
 static int emac_ndo_stop(struct net_device *ndev)
 {
 	struct prueth_emac *emac = netdev_priv(ndev);
-	int rx_flow = PRUETH_RX_FLOW_DATA_SR1;
 	struct prueth *prueth = emac->prueth;
-	int max_rx_flows;
 	int ret, i;
 
 	/* inform the upper layers. */
@@ -683,16 +860,14 @@ static int emac_ndo_stop(struct net_device *ndev)
 	for (i = 0; i < emac->tx_ch_num; i++)
 		napi_disable(&emac->tx_chns[i].napi_tx);
 
-	max_rx_flows = PRUETH_MAX_RX_FLOWS_SR1;
 	k3_udma_glue_tdown_rx_chn(emac->rx_chns.rx_chn, true);
 
-	prueth_reset_rx_chan(&emac->rx_chns, max_rx_flows, true);
+	prueth_reset_rx_chan(emac, true);
 	/* Teardown RX MGM channel */
 	k3_udma_glue_tdown_rx_chn(emac->rx_mgm_chn.rx_chn, true);
-	prueth_reset_rx_chan(&emac->rx_mgm_chn,
-			     PRUETH_MAX_RX_MGM_FLOWS_SR1, true);
+	prueth_sr1_reset_rx_mgm_chn(emac, true);
 
-	napi_disable(&emac->napi_rx);
+	napi_disable(&emac->rx_chns.flows[PRUETH_RX_FLOW_DATA_SR1].napi_rx);
 
 	/* Destroying the queued work in ndo_stop() */
 	cancel_delayed_work_sync(&emac->stats_work);
@@ -700,14 +875,14 @@ static int emac_ndo_stop(struct net_device *ndev)
 	/* stop PRUs */
 	prueth_emac_stop(emac);
 
-	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1], emac);
-	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_RESPONSE_SR1], emac);
-	free_irq(emac->rx_chns.irq[rx_flow], emac);
+	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1].irq, emac);
+	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_RESPONSE_SR1].irq, emac);
+	prueth_ndev_del_rx_napi(emac, 1);
 	prueth_ndev_del_tx_napi(emac, emac->tx_ch_num);
 	prueth_cleanup_tx_chns(emac);
 
-	prueth_cleanup_rx_chns(emac, &emac->rx_mgm_chn, PRUETH_MAX_RX_MGM_FLOWS_SR1);
-	prueth_cleanup_rx_chns(emac, &emac->rx_chns, max_rx_flows);
+	prueth_sr1_cleanup_rx_mgm_chn(emac);
+	prueth_cleanup_rx_chns(emac);
 
 	prueth->emacs_initialized--;
 
@@ -871,7 +1046,6 @@ static int prueth_netdev_init(struct prueth *prueth,
 	ndev->hw_features = NETIF_F_SG;
 	ndev->features = ndev->hw_features;
 
-	netif_napi_add(ndev, &emac->napi_rx, icssg_napi_rx_poll);
 	prueth->emac[mac] = emac;
 
 	return 0;
-- 
2.43.0



^ permalink raw reply related	[flat|nested] 6+ messages in thread

* [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support
  2026-11-18 18:47 [PATCH net-next 0/2] net: ti: icssg: Multi-flow RX and ethtool RX flow classification Meghana Malladi
  2026-11-18 18:47 ` [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI Meghana Malladi
@ 2026-11-18 18:47 ` Meghana Malladi
  2026-11-19  9:19   ` Marco Crivellari
  2026-11-22 19:01   ` netdev-bot+sashiko
  1 sibling, 2 replies; 6+ messages in thread
From: Meghana Malladi @ 2026-11-18 18:47 UTC (permalink / raw)
  To: marco.crivellari, kees+treewide, laixiangwu, philippe.schenker,
	haokexin, devnexen, horms, jacob.e.keller, m-malladi, sdf,
	john.fastabend, hawk, daniel, ast, pabeni, kuba, edumazet, davem,
	andrew+netdev
  Cc: bpf, linux-kernel, netdev, linux-arm-kernel, srk,
	Vignesh Raghavendra, danishanwar

Enable dynamic RX flow classification via ethtool set_rxnfc/get_rxnfc.
Users can install/remove filter rules to steer packets to specific RX flows
based on EtherType patterns via FT3 hardware filters.

- Add RXNFC rule tracking structures and lifecycle management
- Implement ethtool get_rxnfc/set_rxnfc callbacks
- FT3 slot allocation and hardware programming for pattern matching
- RX classifier OR table updates based on active rules
- Max 15 rules per EMAC, using FT3 slots 0-13,15 (slot 14 reserved)

Signed-off-by: Meghana Malladi <m-malladi@ti.com>
---

RFC->v1 Changelog:
Sashiko comments addressed:
- Classifier/cleanup loop clobbers HSR/PRP classifiers 10/11
- Masks not checked; ring_cookie==0 rule never reaches HW 
- fs->location not validated; FT3 slot ≠ location; duplicates
- icssg_rxnfc_rule_get_all NULL deref / heap overflow 
- ETHTOOL_GRXRINGS dead code in emac_get_rxnfc
- SR1 uses icssg_ethtool_ops but rxnfc uninitialized
- Rules lost on suspend/resume; not re-applied on open
- Rules leaked when driver removed while interface down

Sashiko comments skipped:
- ringrxfdq overflow with multi-flow, doesn't get affected for
  BCDMA
- prueth_create_rxq napi hang - fixed in previous patch
- Sequential prueth_destroy_rxqs destroys flow 0 pool before
  flows 1..N drained - doesn't get affected for BCDMA
- __be16 → u16 sparse warning - low priority and fix doesn't add
  much value

 .../net/ethernet/ti/icssg/icssg_classifier.c  | 407 ++++++++++++++++++
 drivers/net/ethernet/ti/icssg/icssg_common.c  |   4 +
 drivers/net/ethernet/ti/icssg/icssg_ethtool.c |  59 +++
 drivers/net/ethernet/ti/icssg/icssg_prueth.c  |   9 +
 drivers/net/ethernet/ti/icssg/icssg_prueth.h  |  35 ++
 5 files changed, 514 insertions(+)

diff --git a/drivers/net/ethernet/ti/icssg/icssg_classifier.c b/drivers/net/ethernet/ti/icssg/icssg_classifier.c
index 87a8577093dbb..520b3f3377784 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_classifier.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_classifier.c
@@ -105,6 +105,14 @@ enum ft1_cfg_type {
 	((BIT(slot) << RX_CLASS_FT_FT1_MATCH_SHIFT) & \
 	RX_CLASS_FT_FT1_MATCH_MASK)
 
+#define RX_CLASS_FT_FT3_MATCH(slot)	\
+	((BIT(slot) << RX_CLASS_FT_FT3_MATCH_SHIFT) & \
+	RX_CLASS_FT_FT3_MATCH_MASK)
+
+/* FT3 Configuration registers and modes */
+#define FT3_CFG_REGISTER_EQUAL		(1U)
+#define FT3_CFG_REGISTER_VLAN_SKIP	BIT(2)
+
 /* HSR/PRP protocol frame filtering */
 #define HSR_PTP_ETHERTYPE_OFFSET	0x12
 #define PRP_PTP_ETHERTYPE_OFFSET	0x0C
@@ -532,3 +540,402 @@ void icssg_ft3_hsr_configurations(struct regmap *miig_rt, int slice,
 	}
 }
 EXPORT_SYMBOL_GPL(icssg_ft3_hsr_configurations);
+
+/* RX Flow Classification (ethtool) rule management */
+
+/* Allocate free FT3 slot, avoiding reserved slot 14 */
+static int allocate_ft3_slot(struct prueth_emac *emac)
+{
+	u16 used = emac->rxnfc.ft3_slots_used | ICSSG_FT3_RESERVED_SLOTS;
+	int slot;
+
+	for (slot = 0; slot < ICSSG_NUM_FT3_SLOTS; slot++) {
+		if (!(used & BIT(slot))) {
+			emac->rxnfc.ft3_slots_used |= BIT(slot);
+			return slot;
+		}
+	}
+	return -ENOSPC;
+}
+
+/* Free allocated FT3 slot */
+static void free_ft3_slot(struct prueth_emac *emac, int slot)
+{
+	emac->rxnfc.ft3_slots_used &= ~BIT(slot);
+}
+
+/* Program FT3 filter slot with ethertype pattern */
+static void icssg_ft3_program_filter(struct regmap *miig_rt, int slice,
+				     int slot, struct icssg_rxnfc_rule *rule)
+{
+	const struct ethtool_rx_flow_spec *fs = &rule->flow_spec;
+	u16 ether_type;
+
+	/* Extract EtherType from flow spec (network byte order) */
+	ether_type = fs->h_u.ether_spec.h_proto;
+
+	/* Deactivate filter before programming */
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_CFG), 0);
+
+	/* EtherType is at byte 12 in standard Ethernet frames */
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_START),
+		     PRP_PTP_ETHERTYPE_OFFSET);
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_START_AUTO), 0);
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_START_OFFSET), 0);
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_JUMP_OFFSET), 0);
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_LEN), 0);
+
+	/* FT3 compares a 32-bit LE word at FT3_START. EtherType occupies the
+	 * lower 16 bits of that word. FT3_T_MASK=0xFFFF0000 masks the upper
+	 * 16 bits (payload bytes), so only the lower 16 bits are compared.
+	 *
+	 * h_proto is __be16 (network byte order). On LE the raw integer value
+	 * equals the lower 16 bits of the LE 32-bit word at the EtherType
+	 * offset in the frame — e.g. IPv4 0x0800 BE → h_proto = 0x0008 on LE,
+	 * which is exactly what FT3 sees in the lower 16 bits of the word at
+	 * byte 12. No conversion needed; using be16_to_cpu() here would invert
+	 * the byte order and break the match.
+	 * Reference: FT3_PTP_PATTERN = 0xF788 = htons(0x88F7) = raw h_proto value.
+	 */
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_T),
+		     (__force u32)ether_type);
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_T_MASK), FT3_ETHERTYPE_MASK);
+
+	/* Enable filter: register-equal mode */
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_CFG),
+		     FT3_CFG_REGISTER_EQUAL);
+}
+
+/* Disable FT3 filter slot */
+static void icssg_ft3_disable_filter(struct regmap *miig_rt, int slice, int slot)
+{
+	regmap_write(miig_rt, FT3_N_REG(slice, slot, FT3_CFG), 0);
+}
+
+/* Update RX classifiers for all active FT3 rules.
+ * Classifier N maps to RX flow N (firmware routes classifier-N hits to
+ * UDMA flow rx_flow_id_base + N). Build a per-classifier OR table so
+ * that each target queue gets its own classifier entry.
+ */
+static void icssg_rxnfc_classifier_update(struct prueth_emac *emac)
+{
+	struct prueth *prueth = emac->prueth;
+	struct regmap *miig_rt = prueth->miig_rt;
+	int slice = prueth_emac_slice(emac);
+	u32 or_table[ICSSG_NUM_CLASSIFIERS] = { };
+	struct icssg_rxnfc_rule *rule;
+	int n;
+
+	if (slice < 0)
+		return;
+
+	/* Build per-classifier OR table: classifier index = target queue index */
+	list_for_each_entry(rule, &emac->rxnfc.rules, list) {
+		int cls = rule->queue_index;
+
+		if (cls < emac->rx_flow_num)
+			or_table[cls] |= RX_CLASS_FT_FT3_MATCH(rule->ft3_slot);
+	}
+
+	/* Write OR tables for classifiers 0..rx_flow_num-1. Only update
+	 * classifiers within the user-flow range to avoid disturbing HSR/PRP
+	 * classifiers (e.g. 10/11) beyond it. Use RX_CLASS_N_REG with
+	 * RX_CLASS_OR_EN — NOT RX_CLASS_OR_REG which uses rx_class_or_base
+	 * (= rx_class_base + 4), causing an off-by-4 that lands on AND_EN of
+	 * classifier n+1 instead of OR_EN of classifier n.
+	 */
+	for (n = 0; n < emac->rx_flow_num; n++) {
+		regmap_write(miig_rt,
+			     RX_CLASS_N_REG(slice, n, RX_CLASS_OR_EN),
+			     or_table[n]);
+	}
+}
+
+/* Validate rule parameters */
+static int validate_rule(struct prueth_emac *emac,
+			 struct ethtool_rx_flow_spec *fs)
+{
+	/* Only ETHER_FLOW supported; reject extension flags */
+	if (fs->flow_type != ETHER_FLOW)
+		return -EOPNOTSUPP;
+
+	/* Only exact EtherType match supported — reject partial proto mask,
+	 * non-zero MAC address masks, and flow extension flags.
+	 */
+	if (fs->m_u.ether_spec.h_proto != htons(0xFFFF))
+		return -EOPNOTSUPP;
+	if (!is_zero_ether_addr(fs->m_u.ether_spec.h_dest) ||
+	    !is_zero_ether_addr(fs->m_u.ether_spec.h_source))
+		return -EOPNOTSUPP;
+
+	/* Check RX queue is valid */
+	if (fs->ring_cookie >= emac->rx_flow_num)
+		return -EINVAL;
+
+	return 0;
+}
+
+/* Check if identical rule already exists */
+static bool rule_exists(struct prueth_emac *emac,
+			struct ethtool_rx_flow_spec *fs)
+{
+	struct icssg_rxnfc_rule *rule;
+
+	list_for_each_entry(rule, &emac->rxnfc.rules, list) {
+		if (rule->flow_spec.flow_type == fs->flow_type &&
+		    rule->flow_spec.h_u.ether_spec.h_proto ==
+		    fs->h_u.ether_spec.h_proto) {
+			return true;
+		}
+	}
+	return false;
+}
+
+/* Initialize RX flow classification */
+void icssg_rxnfc_rule_init(struct prueth_emac *emac)
+{
+	INIT_LIST_HEAD(&emac->rxnfc.rules);
+	mutex_init(&emac->rxnfc.rxnfc_lock);
+	emac->rxnfc.rxnfc_rule_count = 0;
+	emac->rxnfc.ft3_slots_used = ICSSG_FT3_RESERVED_SLOTS; /* Mark slot 14 reserved */
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_init);
+
+/* Restore RX flow classification hardware state from the in-memory rule list.
+ * Call after icssg_class_default() resets the classifier registers on open or
+ * after firmware restart so that existing rules take effect again.
+ */
+void icssg_rxnfc_rule_restore(struct prueth_emac *emac)
+{
+	struct prueth *prueth = emac->prueth;
+	struct regmap *miig_rt = prueth->miig_rt;
+	int slice = prueth_emac_slice(emac);
+	struct icssg_rxnfc_rule *rule;
+
+	if (slice < 0)
+		return;
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	list_for_each_entry(rule, &emac->rxnfc.rules, list)
+		icssg_ft3_program_filter(miig_rt, slice, rule->ft3_slot, rule);
+
+	icssg_rxnfc_classifier_update(emac);
+
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_restore);
+
+/* Cleanup RX flow classification */
+void icssg_rxnfc_rule_cleanup(struct prueth_emac *emac)
+{
+	struct prueth *prueth = emac->prueth;
+	struct regmap *miig_rt = prueth->miig_rt;
+	int slice = prueth_emac_slice(emac);
+	struct icssg_rxnfc_rule *rule, *tmp;
+	int n;
+
+	if (slice < 0)
+		return;
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	/* Disable all active FT3 filters */
+	list_for_each_entry_safe(rule, tmp, &emac->rxnfc.rules, list) {
+		icssg_ft3_disable_filter(miig_rt, slice, rule->ft3_slot);
+		free_ft3_slot(emac, rule->ft3_slot);
+		list_del(&rule->list);
+		kfree(rule);
+	}
+
+	emac->rxnfc.rxnfc_rule_count = 0;
+	emac->rxnfc.ft3_slots_used = ICSSG_FT3_RESERVED_SLOTS;
+
+	/* Clear user-rule classifier OR tables; stop at rx_flow_num to avoid
+	 * disturbing HSR/PRP classifiers beyond the user-flow range.
+	 */
+	for (n = 0; n < emac->rx_flow_num; n++)
+		regmap_write(miig_rt,
+			     RX_CLASS_N_REG(slice, n, RX_CLASS_OR_EN), 0);
+
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_cleanup);
+
+/* Add a new RX flow classification rule */
+int icssg_rxnfc_rule_add(struct prueth_emac *emac, struct ethtool_rxnfc *info)
+{
+	struct ethtool_rx_flow_spec *fs = &info->fs;
+	struct prueth *prueth = emac->prueth;
+	struct regmap *miig_rt = prueth->miig_rt;
+	int slice = prueth_emac_slice(emac);
+	struct icssg_rxnfc_rule *rule;
+	int ft3_slot;
+	int ret;
+
+	if (slice < 0)
+		return -EINVAL;
+
+	/* Validate rule parameters */
+	ret = validate_rule(emac, fs);
+	if (ret)
+		return ret;
+
+	/* Validate explicit location: reject special specifiers, out-of-range
+	 * values, and the reserved slot 14 used by HSR/PRP.
+	 */
+	if (fs->location != RX_CLS_LOC_ANY) {
+		if (fs->location >= ICSSG_RXNFC_MAX_RULES ||
+		    BIT(fs->location) & ICSSG_FT3_RESERVED_SLOTS)
+			return -EINVAL;
+	}
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	/* Check max rules */
+	if (emac->rxnfc.rxnfc_rule_count >= ICSSG_RXNFC_MAX_RULES) {
+		ret = -ENOSPC;
+		goto unlock;
+	}
+
+	/* Check for duplicate flow spec */
+	if (rule_exists(emac, fs)) {
+		ret = -EEXIST;
+		goto unlock;
+	}
+
+	/* Allocate FT3 slot. For explicit locations, the location IS the FT3
+	 * slot — this keeps location and slot aligned so rule_del operates on
+	 * the correct hardware slot. For RX_CLS_LOC_ANY, auto-allocate the
+	 * lowest free slot and assign it as the location.
+	 */
+	if (fs->location != RX_CLS_LOC_ANY) {
+		ft3_slot = fs->location;
+		if (emac->rxnfc.ft3_slots_used & BIT(ft3_slot)) {
+			ret = -EBUSY;
+			goto unlock;
+		}
+		emac->rxnfc.ft3_slots_used |= BIT(ft3_slot);
+	} else {
+		ft3_slot = allocate_ft3_slot(emac);
+		if (ft3_slot < 0) {
+			ret = -ENOSPC;
+			goto unlock;
+		}
+		fs->location = ft3_slot;
+	}
+
+	/* Allocate rule structure */
+	rule = kzalloc(sizeof(*rule), GFP_KERNEL);
+	if (!rule) {
+		ret = -ENOMEM;
+		free_ft3_slot(emac, ft3_slot);
+		goto unlock;
+	}
+
+	/* Program FT3 hardware */
+	rule->flow_spec = *fs;
+	rule->ft3_slot = ft3_slot;
+	rule->queue_index = fs->ring_cookie;
+	rule->location = fs->location;
+
+	icssg_ft3_program_filter(miig_rt, slice, ft3_slot, rule);
+
+	/* Add to rule list */
+	list_add(&rule->list, &emac->rxnfc.rules);
+	emac->rxnfc.rxnfc_rule_count++;
+
+	/* Update classifier */
+	icssg_rxnfc_classifier_update(emac);
+
+	ret = 0;
+
+unlock:
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_add);
+
+/* Delete a RX flow classification rule */
+int icssg_rxnfc_rule_del(struct prueth_emac *emac, u32 location)
+{
+	struct prueth *prueth = emac->prueth;
+	struct regmap *miig_rt = prueth->miig_rt;
+	int slice = prueth_emac_slice(emac);
+	struct icssg_rxnfc_rule *rule, *tmp;
+	int ret = -ENOENT;
+
+	if (slice < 0)
+		return -EINVAL;
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	list_for_each_entry_safe(rule, tmp, &emac->rxnfc.rules, list) {
+		if (rule->location == location) {
+			icssg_ft3_disable_filter(miig_rt, slice, rule->ft3_slot);
+			free_ft3_slot(emac, rule->ft3_slot);
+			list_del(&rule->list);
+			kfree(rule);
+			emac->rxnfc.rxnfc_rule_count--;
+			icssg_rxnfc_classifier_update(emac);
+			ret = 0;
+			break;
+		}
+	}
+
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_del);
+
+/* Get single RX flow classification rule */
+int icssg_rxnfc_rule_get(struct prueth_emac *emac, u32 location,
+			 struct ethtool_rx_flow_spec *fs)
+{
+	struct icssg_rxnfc_rule *rule;
+	int ret = -ENOENT;
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	list_for_each_entry(rule, &emac->rxnfc.rules, list) {
+		if (rule->location == location) {
+			*fs = rule->flow_spec;
+			ret = 0;
+			break;
+		}
+	}
+
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_get);
+
+/* Get all RX flow classification rules */
+int icssg_rxnfc_rule_get_all(struct prueth_emac *emac, u32 *rule_locs,
+			     u32 rule_locs_capacity, u32 *rule_cnt)
+{
+	struct icssg_rxnfc_rule *rule;
+	u32 count = 0;
+	int ret = 0;
+
+	mutex_lock(&emac->rxnfc.rxnfc_lock);
+
+	list_for_each_entry(rule, &emac->rxnfc.rules, list) {
+		if (!rule_locs) {
+			/* Caller passed rule_cnt=0: just count active rules */
+			count++;
+			continue;
+		}
+		if (count >= rule_locs_capacity) {
+			ret = -EMSGSIZE;
+			break;
+		}
+		rule_locs[count++] = rule->location;
+	}
+
+	*rule_cnt = count;
+
+	mutex_unlock(&emac->rxnfc.rxnfc_lock);
+	return ret;
+}
+EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_get_all);
diff --git a/drivers/net/ethernet/ti/icssg/icssg_common.c b/drivers/net/ethernet/ti/icssg/icssg_common.c
index 6cd2a77c491ac..e5ad57d2a0713 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_common.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_common.c
@@ -1830,6 +1830,10 @@ void prueth_netdev_exit(struct prueth *prueth,
 	if (of_phy_is_fixed_link(emac->phy_node))
 		of_phy_deregister_fixed_link(emac->phy_node);
 
+	/* Free any rules added while the interface was down */
+	if (!emac->is_sr1)
+		icssg_rxnfc_rule_cleanup(emac);
+
 	pruss_release_mem_region(prueth->pruss, &emac->dram);
 	free_netdev(emac->ndev);
 	prueth->emac[mac] = NULL;
diff --git a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
index 68646cb7df442..35eb056dab6d9 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
@@ -300,6 +300,62 @@ static int emac_set_per_queue_coalesce(struct net_device *ndev, u32 queue,
 	return 0;
 }
 
+static u32 emac_get_rx_ring_count(struct net_device *ndev)
+{
+	struct prueth_emac *emac = netdev_priv(ndev);
+
+	return emac->rx_flow_num;
+}
+
+static int emac_get_rxnfc(struct net_device *ndev, struct ethtool_rxnfc *info,
+			  u32 *rule_locs)
+{
+	struct prueth_emac *emac = netdev_priv(ndev);
+	int ret = 0;
+
+	if (emac->is_sr1)
+		return -EOPNOTSUPP;
+
+	switch (info->cmd) {
+	case ETHTOOL_GRXCLSRLCNT:
+		info->rule_cnt = emac->rxnfc.rxnfc_rule_count;
+		info->data = ICSSG_RXNFC_MAX_RULES | RX_CLS_LOC_SPECIAL;
+		break;
+	case ETHTOOL_GRXCLSRULE:
+		ret = icssg_rxnfc_rule_get(emac, info->fs.location, &info->fs);
+		break;
+	case ETHTOOL_GRXCLSRLALL: {
+		u32 rule_cnt = 0;
+
+		ret = icssg_rxnfc_rule_get_all(emac, rule_locs,
+					       info->rule_cnt, &rule_cnt);
+		info->rule_cnt = rule_cnt;
+		break;
+	}
+	default:
+		return -EOPNOTSUPP;
+	}
+
+	return ret;
+}
+
+static int emac_set_rxnfc(struct net_device *ndev, struct ethtool_rxnfc *info)
+{
+	struct prueth_emac *emac = netdev_priv(ndev);
+
+	if (emac->is_sr1)
+		return -EOPNOTSUPP;
+
+	switch (info->cmd) {
+	case ETHTOOL_SRXCLSRLINS:
+		return icssg_rxnfc_rule_add(emac, info);
+	case ETHTOOL_SRXCLSRLDEL:
+		return icssg_rxnfc_rule_del(emac, info->fs.location);
+	default:
+		return -EOPNOTSUPP;
+	}
+}
+
 const struct ethtool_ops icssg_ethtool_ops = {
 	.get_drvinfo = emac_get_drvinfo,
 	.get_msglevel = emac_get_msglevel,
@@ -323,5 +379,8 @@ const struct ethtool_ops icssg_ethtool_ops = {
 	.set_eee = emac_set_eee,
 	.nway_reset = emac_nway_reset,
 	.get_rmon_stats = emac_get_rmon_stats,
+	.get_rx_ring_count = emac_get_rx_ring_count,
+	.get_rxnfc = emac_get_rxnfc,
+	.set_rxnfc = emac_set_rxnfc,
 };
 EXPORT_SYMBOL_GPL(icssg_ethtool_ops);
diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.c b/drivers/net/ethernet/ti/icssg/icssg_prueth.c
index 716f1b9195d67..b08e74e24a5a3 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_prueth.c
+++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.c
@@ -1101,6 +1101,12 @@ static int emac_ndo_open(struct net_device *ndev)
 
 	icssg_mii_update_mtu(prueth->mii_rt, slice, ndev->max_mtu);
 
+	/* Re-program FT3 filters and classifier OR tables from the persistent
+	 * rule list. icssg_class_default() called above resets all classifiers,
+	 * so rules must be restored here on every open/restart.
+	 */
+	icssg_rxnfc_rule_restore(emac);
+
 	ret = request_threaded_irq(emac->tx_ts_irq, NULL, prueth_tx_ts_irq,
 				   IRQF_ONESHOT, dev_name(dev), emac);
 	if (ret)
@@ -1715,6 +1721,9 @@ static int prueth_netdev_init(struct prueth *prueth,
 	emac->ndev->pcpu_stat_type = NETDEV_PCPU_STAT_TSTATS;
 	INIT_WORK(&emac->rx_mode_work, emac_ndo_set_rx_mode_work);
 
+	/* Initialize RX flow classification */
+	icssg_rxnfc_rule_init(emac);
+
 	INIT_DELAYED_WORK(&emac->stats_work, icssg_stats_work_handler);
 
 	ret = pruss_request_mem_region(prueth->pruss,
diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.h b/drivers/net/ethernet/ti/icssg/icssg_prueth.h
index d54966730d102..af225e4ea00a6 100644
--- a/drivers/net/ethernet/ti/icssg/icssg_prueth.h
+++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.h
@@ -11,6 +11,7 @@
 #include <linux/bpf.h>
 #include <linux/bpf_trace.h>
 #include <linux/etherdevice.h>
+#include <linux/ethtool.h>
 #include <linux/genalloc.h>
 #include <linux/if_vlan.h>
 #include <linux/if_hsr.h>
@@ -192,6 +193,26 @@ struct prueth_swdata {
 /* Minimum coalesce time in usecs for both Tx and Rx */
 #define ICSSG_MIN_COALESCE_USECS 20
 
+/* RX flow classification (ethtool) */
+#define ICSSG_RXNFC_MAX_RULES    15      /* Max user-installable rules */
+#define ICSSG_FT3_RESERVED_SLOTS BIT(14) /* Slot 14 reserved for HSR/PRP */
+
+/* RX flow classification rule structure */
+struct icssg_rxnfc_rule {
+	struct list_head list;
+	struct ethtool_rx_flow_spec flow_spec;  /* User-provided filter */
+	u16 ft3_slot;                            /* Allocated FT3 slot (0-15, excluding 14) */
+	int location;                            /* Rule location (user-provided) */
+	u32 queue_index;                         /* RX flow to route matches to */
+};
+
+struct prueth_rxnfc {
+	struct list_head rules;
+	struct mutex rxnfc_lock;
+	unsigned int rxnfc_rule_count;
+	u16 ft3_slots_used;
+};
+
 /* data for each emac port */
 struct prueth_emac {
 	bool is_sr1;
@@ -256,6 +277,9 @@ struct prueth_emac {
 	struct xdp_attachment_info xdpi;
 	int xsk_qid;
 	unsigned long *xsk_queues;
+
+	/* RX flow classification via ethtool */
+	struct prueth_rxnfc rxnfc;
 };
 
 /* The buf includes headroom compatible with both skb and xdpf */
@@ -400,6 +424,17 @@ static inline int prueth_emac_slice(struct prueth_emac *emac)
 	}
 }
 
+/* RX flow classification functions */
+void icssg_rxnfc_rule_init(struct prueth_emac *emac);
+void icssg_rxnfc_rule_restore(struct prueth_emac *emac);
+void icssg_rxnfc_rule_cleanup(struct prueth_emac *emac);
+int icssg_rxnfc_rule_add(struct prueth_emac *emac, struct ethtool_rxnfc *info);
+int icssg_rxnfc_rule_del(struct prueth_emac *emac, u32 location);
+int icssg_rxnfc_rule_get(struct prueth_emac *emac, u32 location,
+			 struct ethtool_rx_flow_spec *fs);
+int icssg_rxnfc_rule_get_all(struct prueth_emac *emac, u32 *rule_locs,
+			     u32 rule_locs_capacity, u32 *rule_cnt);
+
 extern const struct ethtool_ops icssg_ethtool_ops;
 extern const struct dev_pm_ops prueth_dev_pm_ops;
 
-- 
2.43.0



^ permalink raw reply related	[flat|nested] 6+ messages in thread

* Re: [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support
  2026-11-18 18:47 ` [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support Meghana Malladi
@ 2026-11-19  9:19   ` Marco Crivellari
  2026-11-22 19:01   ` netdev-bot+sashiko
  1 sibling, 0 replies; 6+ messages in thread
From: Marco Crivellari @ 2026-11-19  9:19 UTC (permalink / raw)
  To: Meghana Malladi
  Cc: kees+treewide, laixiangwu, philippe.schenker, haokexin, devnexen,
	horms, jacob.e.keller, sdf, john.fastabend, hawk, daniel, ast,
	pabeni, kuba, edumazet, davem, andrew+netdev, bpf, linux-kernel,
	netdev, linux-arm-kernel, srk, Vignesh Raghavendra, danishanwar

Hi,

On Wed, Nov 18, 2026 at 7:50 PM Meghana Malladi <m-malladi@ti.com> wrote:
> [...]
> +       mutex_lock(&emac->rxnfc.rxnfc_lock);
> +
> +       /* Check max rules */
> +       if (emac->rxnfc.rxnfc_rule_count >= ICSSG_RXNFC_MAX_RULES) {
> +               ret = -ENOSPC;
> +               goto unlock;
> +       }
>  [...]
> +
> +unlock:
> +       mutex_unlock(&emac->rxnfc.rxnfc_lock);
> +       return ret;
> +}
> +EXPORT_SYMBOL_GPL(icssg_rxnfc_rule_add);

nit: instead of mutex_lock() you can use guard() [1]:

    guard(mutex)(&emac->rxnfc.rxnfc_lock)

and remove all the "goto unlock", returning directly. This handles the
automatic cleanup.

Same for other places where you're using mutex_lock() / mutex_unlock().

- [1] https://docs.kernel.org/core-api/cleanup.html

-- 

Marco Crivellari

SUSE Labs


^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI
  2026-11-18 18:47 ` [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI Meghana Malladi
@ 2026-11-22 19:01   ` netdev-bot+sashiko
  0 siblings, 0 replies; 6+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 19:01 UTC (permalink / raw)
  To: m-malladi
  Cc: marco.crivellari, kees+treewide, laixiangwu, philippe.schenker,
	haokexin, devnexen, horms, jacob.e.keller, sdf, john.fastabend,
	hawk, daniel, ast, pabeni, kuba, edumazet, davem, andrew+netdev,
	bpf, linux-kernel, netdev, linux-arm-kernel, srk, vigneshr,
	danishanwar

Thank you for your contribution! Sashiko AI review found 19 potential
issue(s) to consider.

Critical: 2 · High: 1 · Medium: 12 · Low: 4

If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).

- [Critical] SR1 data RX path is out of bounds.
- [Critical] SR1 management-channel buffers get invalid DMA addresses.
- [High] On a running interface, a failed XSK enable/disable leaves the
  flow half torn down, and the next ndo_stop then hangs or the driver…
- [Medium] Multi-flow RX does not work on AM65x SR2 ('ti,am654-icssg-
  prueth'), which uses NAVSS UDMA rather than PKTDMA, but the driver…
- [Medium] SR1 management-channel teardown is incomplete compared with
  before the patch.
- [Medium] Misplaced error label in SR1 emac_ndo_open().
- [Medium] An AF_XDP pool bound while the interface is down silently
  stops working after ndo_open.
- [Medium] All flows share one desc_pool, and the XSK runtime refill
  budget comes from the pool-wide free count, which other CPUs change…
- [Medium] The SR1 data-flow page pool is never destroyed.
- [Medium] SR1 now gets an RX coalescing hrtimer but never cancels it.
- [Medium] prueth_xsk_pool_disable() can return an uninitialised value.
- [Medium] On a running interface, XSK enable/disable now reconfigures a
  single flow while the shared UDMA RX channel stays enabled.
- [Medium] Racy irq_disabled handling in prueth_destroy_rxq() and the
  prueth_create_rxq() error path.
- [Medium] RX drop and error counters can lose updates now that RX runs
  in several NAPIs at once.
- [Medium] A coalesce setting is not applied to RX flows added later.
- [Low] The ethtool channel range does not match what SR1 implements.
- [Low] In the SR1 mgm flow setup in emac_ndo_open(), the IRQ check is
  wrong for the signed field.
- [Low] Leftover field and mixed-in cleanups.
- [Low] net: ti: icssg: missing skb_record_rx_queue() in RX packet paths

--

net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI

This patch extends the ICSSG driver to support up to 8 RX flows per EMAC.
Each flow has its own NAPI, hrtimer, page pool, XDP rxq, AF_XDP pool and
IRQ, and all flows share one UDMA channel and descriptor pool. The channel
lifecycle is split into per-flow create/destroy helpers, xsk_qid is
replaced with an xsk_queues bitmap, and SR1 is converted to the new
per-flow structures.

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_common.c b/drivers/net/ethernet/ti/icssg/icssg_common.c
> index 4a7d1a6f470b1..6cd2a77c491ac 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_common.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_common.c
> @@ -39,16 +39,10 @@
>  				 NETIF_MSG_HW | \
>  				 NETIF_MSG_WOL)
>  
> -#define prueth_napi_to_emac(napi) container_of(napi, struct prueth_emac, napi_rx)
>  
> -void prueth_cleanup_rx_chns(struct prueth_emac *emac,
> -			    struct prueth_rx_chn *rx_chn,
> -			    int max_rflows)
> +void prueth_cleanup_rx_chns(struct prueth_emac *emac)
>  {
> -	if (rx_chn->pg_pool) {
> -		page_pool_destroy(rx_chn->pg_pool);
> -		rx_chn->pg_pool = NULL;
> -	}
> +	struct prueth_rx_chn *rx_chn = &emac->rx_chns;

[Severity: Medium]
page_pool_destroy() has moved out of prueth_cleanup_rx_chns(). Which code
now destroys the SR1 data flow page pool?

The new destroy calls are in prueth_destroy_rxq() and the
prueth_create_rxq() error path, and only the SR2 driver calls those. SR1
emac_ndo_open() creates the pool with:

    prueth_prepare_rx_flow(emac, PRUETH_RX_FLOW_DATA_SR1)

which stores it in rx_chns.flows[3].pg_pool. SR1 emac_ndo_stop() and the
open error labels only call these:

- prueth_reset_rx_chan(), which covers flow 0 only.
- prueth_sr1_cleanup_rx_mgm_chn(), which covers the mgm flows only.
- prueth_cleanup_rx_chns(), which handles the desc pool and channel only.

Does this leak the page_pool and its posted pages on every SR1 close? The
same question applies to any open failure after prueth_prepare_rx_flow().

[ ... ]

> @@ -548,22 +594,14 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
>  		goto fail;
>  	}
>  
> -	pool = prueth_create_page_pool(emac, rx_chn->dma_dev, rx_chn->descs_num);
> -	if (IS_ERR(pool)) {
> -		ret = PTR_ERR(pool);
> -		goto fail;
> +	for (i = 0; i < rx_cfg.flow_id_num; i++) {
> +		flow = &rx_chn->flows[i];
> +		flow->pg_pool = NULL;
> +		flow->xsk_pool = NULL;
>  	}

[Severity: Medium]
Does clearing flow->xsk_pool here break an AF_XDP pool that was bound
while the interface was down?

When the interface is down, prueth_xsk_pool_enable() sets the xsk_queues
bit and calls prueth_set_xsk_pool(), which fills in rx_flow->xsk_pool and
tx_chn->xsk_pool. emac_ndo_open() then calls prueth_init_rx_chns(). That
clears xsk_pool for every flow without checking emac->xsk_queues, and
prueth_set_xsk_pool() is not called again on open.

The flow then comes up in page pool mode:

- prueth_xsk_wakeup() passes the test_bit() check but then fails with
  "XSK pool not registered for RX queue".
- prueth_xsk_pool_disable() still treats the queue as registered.

A down/up cycle causes the same mismatch, because prueth_cleanup_tx_chns()
memsets tx_chn while the bitmap bit stays set.

[ ... ]

> @@ -584,9 +622,14 @@ int prueth_init_rx_chns(struct prueth_emac *emac,
>  				K3_UDMA_GLUE_SRC_TAG_LO_USE_REMOTE_SRC_TAG,
>  		};
>  
> +		flow = &rx_chn->flows[i];
> +		flow->emac = emac;
> +		flow->id = i;
> +		flow->irq = -EINVAL;
> +
>  		rx_flow_cfg.ring_rxfdq0_id = fdqring_id;
> -		rx_flow_cfg.rx_cfg.size = max_desc_num;
> -		rx_flow_cfg.rxfdq_cfg.size = max_desc_num;
> +		rx_flow_cfg.rx_cfg.size = PRUETH_MAX_RX_DESC;
> +		rx_flow_cfg.rxfdq_cfg.size = PRUETH_MAX_RX_DESC;
>  		rx_flow_cfg.rxfdq_cfg.mode = emac->prueth->pdata.fdqring_mode;

[Severity: Medium]
How does this work on AM65x SR2 (ti,am654-icssg-prueth)? That SoC uses
NAVSS UDMA rather than PKTDMA.

On non-PKTDMA, k3_udma_glue_request_rx_chn() sets single_fdq = true, and
k3_udma_glue_cfg_rx_flow() uses ring_rxfdq0_id as given. Here flows 1..N
are given flow 0's FDQ id, so all flows share one k3_ring. That ring is
configured once, by its first user, with PRUETH_MAX_RX_DESC (512) entries.

prueth_prepare_rx_flow() then pushes 512 buffers per flow, and flow 0
fills the shared ring. Wouldn't flow 1's first k3_ringacc_ring_push()
return -ENOMEM? prueth_create_rxqs() would then unwind, and ndo_open would
fail whenever rx_flow_num > 1.

The per-flow design also seems to assume each flow owns its FDQ, which
this hardware does not provide:

- k3_udma_glue_reset_rx_chn() skips the FDQ drain for flow_num != 0 when
  single_fdq is set. That contradicts the comment in prueth_destroy_rxq().
- UDMA can give any rflow a buffer from the shared FDQ, so swdata->flow_id
  and the per-flow page pool would no longer match.
- Concurrent per-flow NAPIs would push into one ring whose software state
  is updated without a lock.

emac_get_channels() still reports max_rx = ICSSG_MAX_RFLOWS on every SoC.
The only mention of this limitation is the changelog note below the "---"
("single_fdq=false on BCDMA/PKTDMA (AM64xx)"), which is dropped when the
patch is applied.

[ ... ]

> @@ -1022,13 +1081,13 @@ static int emac_rx_packet_zc(struct prueth_emac *emac, u32 flow_id,
>  	avail_desc = k3_cppi_desc_pool_avail(rx_chn->desc_pool);
>  	alloc_budget = min_t(int, budget, avail_desc);
>  
> -	ret = prueth_rx_alloc_zc(emac, alloc_budget);
> +	ret = prueth_rx_alloc_zc(emac, flow_id, alloc_budget);

[Severity: Medium]
All flows now share one desc_pool. Can this XSK refill take descriptors
that another flow needs?

The pool is sized exactly PRUETH_MAX_RX_DESC * rx_flow_num, and each flow
posts PRUETH_MAX_RX_DESC, so the free count is close to zero in steady
state. emac_rx_packet() frees the completed descriptor at requeue: and
only then allocates a new one in prueth_dma_rx_push_mapped():

CPU1 (page pool flow)              CPU2 (XSK flow)
emac_rx_packet()
  k3_cppi_desc_pool_free()
                                   emac_rx_packet_zc()
                                     avail_desc = 1
                                     prueth_rx_alloc_zc()
                                       k3_cppi_desc_pool_alloc()
  prueth_dma_rx_push_mapped()
    k3_cppi_desc_pool_alloc() fails
  WARN_ON(ret < 0)

The page pool flow then recycles the page and permanently loses one posted
RX buffer, because its refill is strictly 1:1 with completions. Could
repeated hits drain that flow?

The changelog says "XSK desc_avail not capped per-flow" was addressed.
However, only prueth_prepare_rx_flow() appears to have changed, not this
runtime refill.

[ ... ]

> @@ -1132,15 +1192,15 @@ static int emac_rx_packet(struct prueth_emac *emac, u32 flow_id, u32 *xdp_state)
>  	skb->protocol = eth_type_trans(skb, ndev);
>  
>  	skb_mark_for_recycle(skb);
> -	napi_gro_receive(&emac->napi_rx, skb);
> +	napi_gro_receive(&emac->rx_chns.flows[flow_id].napi_rx, skb);
>  	ndev->stats.rx_bytes += pkt_len;
>  	ndev->stats.rx_packets++;
>  
>  requeue:
>  	k3_cppi_desc_pool_free(rx_chn->desc_pool, desc_rx);
>  	/* queue another RX DMA */
> -	ret = prueth_dma_rx_push_mapped(emac, &emac->rx_chns, new_page,
> -					PRUETH_MAX_PKT_SIZE);
> +	ret = prueth_dma_rx_push_mapped(emac, rx_chn, new_page,
> +					PRUETH_MAX_PKT_SIZE, flow_id);
>  	if (WARN_ON(ret < 0)) {
>  		page_pool_recycle_direct(pool, new_page);
>  		ndev->stats.rx_errors++;

[Severity: Low]
The netdev now exposes up to PRUETH_MAX_RX_FLOWS RX queues through
alloc_etherdev_mqs() and netif_set_real_num_rx_queues(). Shouldn't
the skbs also record which flow they arrived on?

Neither emac_rx_packet() nor emac_dispatch_skb_zc() calls
skb_record_rx_queue(skb, flow_id) before napi_gro_receive(). As a
result, skb_rx_queue_recorded() is false for every packet, whichever
flow received it.

This has two visible effects:

- get_rps_cpu() falls back to queue 0's rps_map and flow table, so
  RPS/RFS settings under queues/rx-N for N > 0 do nothing.
- sk_rx_queue_mapping is never set for sockets fed from these
  queues.

The point of the series is queue steering through set_rxnfc, so it
seems worth recording flow_id on both paths. That way the stack can
see which queue a packet was steered to.

[Severity: Medium]
Up to 8 per-flow NAPIs can now run at the same time on different CPUs.
Can these ndev->stats updates lose increments?

rx_bytes, rx_packets, rx_dropped and rx_errors are updated with plain
read-modify-write in emac_rx_packet(), emac_dispatch_skb_zc() and
emac_run_xdp(). Before this patch, a single RX NAPI serialized these
updates.

icssg_ndo_get_stats64() reports ndev->stats.rx_errors and rx_dropped to
userspace, so those values can be wrong.

[ ... ]

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
> index b715af21d23ac..68646cb7df442 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c

[ ... ]

> @@ -159,7 +160,7 @@ static void emac_get_channels(struct net_device *ndev,
>  {
>  	struct prueth_emac *emac = netdev_priv(ndev);
>  
> -	ch->max_rx = 1;
> +	ch->max_rx = ICSSG_MAX_RFLOWS;
>  	ch->max_tx = PRUETH_MAX_TX_QUEUES;
>  
>  	/* Disable multiple TX channels due to timeouts
> @@ -167,7 +168,7 @@ static void emac_get_channels(struct net_device *ndev,
>  	if (emac->is_sr1)
>  		ch->max_tx = 1;

[Severity: Low]
Should max_rx also be limited for SR1, as max_tx is?

SR1 allocates its netdev with alloc_etherdev_mq() (one RX queue), and
emac_ndo_open() in icssg_prueth_sr1.c hard-codes emac->rx_flow_num = 1.
emac_set_channels() still accepts and stores any rx_count up to 8 on SR1.
get_channels then reports that value until the next open silently resets
it.

Separately, the advertised maximum (ICSSG_MAX_RFLOWS) and the size used
for rx_chns.flows[] and alloc_etherdev_mqs() (PRUETH_MAX_RX_FLOWS) are two
independent constants that happen to both be 8.

[ ... ]

> @@ -264,7 +269,8 @@ static int emac_set_coalesce(struct net_device *ndev,
>  		coal->tx_coalesce_usecs = ICSSG_MIN_COALESCE_USECS;
>  	}
>  
> -	emac->rx_pace_timeout_ns = coal->rx_coalesce_usecs * 1000;
> +	for (i = 0; i < emac->rx_flow_num; i++)
> +		rx_chn->flows[i].rx_pace_timeout_ns = coal->rx_coalesce_usecs * 1000;
>  	tx_chn->tx_pace_timeout_ns = coal->tx_coalesce_usecs * 1000;

[Severity: Medium]
What happens to this setting when rx_flow_num is raised later?

This only programs the flows that exist when it is called, and
emac_get_coalesce() always reports flows[0]. Neither emac_set_channels()
nor ndo_open copies the value to new flows. For example:

    ethtool -C eth0 rx-usecs 100    (rx=1)
    ethtool -L eth0 rx 4            (link down)

This leaves flows 1..3 with rx_pace_timeout_ns == 0, so
icssg_napi_rx_poll() re-enables their IRQs immediately. ethtool -c still
reports 100us.

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.c b/drivers/net/ethernet/ti/icssg/icssg_prueth.c
> index 9bb67e185a3ea..716f1b9195d67 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_prueth.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.c

[ ... ]

> @@ -921,7 +866,43 @@ static void prueth_destroy_txq(struct prueth_emac *emac)
>  	}
>  }
>  
> -static void prueth_destroy_rxq(struct prueth_emac *emac)
> +static void prueth_destroy_rxq(struct prueth_emac *emac, int qid)
> +{
> +	struct prueth_rx_chn *rx_chn = &emac->rx_chns;
> +	struct prueth_rx_flow *flow = &rx_chn->flows[qid];
> +	dma_addr_t desc_dma;
> +
> +	napi_disable(&flow->napi_rx);
> +	hrtimer_cancel(&flow->rx_hrtimer);
> +	if (flow->irq_disabled) {
> +		enable_irq(flow->irq);
> +		flow->irq_disabled = false;
> +	}

[Severity: Medium]
Can this race with prueth_rx_irq()?

The IRQ is level triggered. irq_disabled being true here usually means
completions are pending, so the line is likely still asserted:

process context                    hardirq
prueth_destroy_rxq()
  enable_irq(flow->irq)
                                   prueth_rx_irq()
                                     rx_flow->irq_disabled = true
                                     disable_irq_nosync(irq)
                                     napi_schedule() fails, NAPI disabled
  flow->irq_disabled = false

After prueth_create_rxq() calls napi_enable() again, icssg_napi_rx_poll()
and emac_rx_timer_callback() both see irq_disabled == false, so neither
calls enable_irq(). On the XSK disable path nothing else schedules this
flow's NAPI. Would the queue then stop receiving until the next
ifdown/ifup?

The prueth_create_rxq() error path has the same pattern. The changelog
says "IRQ left permanently disabled after hrtimer_cancel" was fixed, but
this race still seems able to leave the IRQ masked.

> +
> +	/* k3_udma_glue_reset_rx_chn() only drains the FDQ; it resets the
> +	 * completion ring (RXCQ) without freeing descriptors still in it.
> +	 * Teardown posts TDCM only to flow 0's RXCQ; flows 1..N have no
> +	 * NAPI trigger to drain their RXCQs. Drain each flow's RXCQ here
> +	 * so page_pool_destroy() finds no inflight pages.
> +	 */
> +	while (!k3_udma_glue_pop_rx_chn(rx_chn->rx_chn, qid, &desc_dma)) {
> +		if (!cppi5_desc_is_tdcm(desc_dma))
> +			prueth_rx_cleanup(rx_chn, desc_dma);
> +	}
> +
> +	k3_udma_glue_reset_rx_chn(rx_chn->rx_chn, flow->id, rx_chn,
> +				  prueth_rx_cleanup);
> +
> +	if (xdp_rxq_info_is_reg(&flow->xdp_rxq))
> +		xdp_rxq_info_unreg(&flow->xdp_rxq);
> +
> +	if (flow->pg_pool) {
> +		page_pool_destroy(flow->pg_pool);
> +		flow->pg_pool = NULL;
> +	}
> +}

[Severity: Medium]
Is it safe to call this from the XSK enable/disable paths while the shared
UDMA channel is still enabled?

Before this patch, prueth_xsk_pool_enable() and prueth_xsk_pool_disable()
did a full channel teardown:

- k3_udma_glue_tdown_rx_chn()
- wait for the TDCM
- reset the rings
- k3_udma_glue_disable_rx_chn()

Now they call this per-flow version. It resets one flow's FDQ and RXCQ and
destroys its page pool while the channel is still enabled and PSI-L paired
for the other flows.

The port-disable firmware command stops new frames from the wire, but it
does not flush frames already in flight. If a completion lands after the
drain loop, the RXCQ reset wipes it. That leaks its descriptor from the
shared desc_pool and leaves a page that is DMA-written after its pool was
destroyed.

The glue code notes that UDMA caches FDQ state. Descriptors that UDMA has
already fetched from the FDQ would also escape the drain.

Teardown on this hardware works per channel, not per rflow. Can a single
flow be quiesced safely this way?

[ ... ]

> @@ -1544,27 +1568,28 @@ static int prueth_xsk_pool_disable(struct prueth_emac *emac, u16 queue_id)
>  		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_DISABLE);
>  		if (ret)
>  			return ret;
> -		prueth_destroy_rxq(emac);
> +		prueth_destroy_rxq(emac, queue_id);
>  	}
>  
>  	xsk_pool_dma_unmap(pool, PRUETH_RX_DMA_ATTR);
> -	emac->xsk_qid = -EINVAL;
> +	clear_bit(queue_id, emac->xsk_queues);
>  	prueth_set_xsk_pool(emac, queue_id);
>  
>  	if (netif_running(emac->ndev)) {
> -		ret = prueth_create_rxq(emac);
> -		if (ret) {
> -			netdev_err(emac->ndev, "Failed to create RX queue: %d\n", ret);
> -			return ret;
> -		}
> -		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
> -		if (ret) {
> -			prueth_destroy_rxq(emac);
> -			return ret;
> -		}
> +		ret = prueth_create_rxq(emac, queue_id);
> +		if (ret)
> +			netdev_err(emac->ndev, "Failed to recreate RX queue after XSK disable: %d\n",
> +				   ret);

[Severity: High]
If prueth_create_rxq() fails here, the flow stays destroyed with its NAPI
disabled while the interface is up. The prueth_create_rxq() error path
does not call napi_enable(), and the comment below says this failure is
expected on a transient descriptor shortage.

On the next ndo_stop, prueth_destroy_rxqs() calls prueth_destroy_rxq() for
every flow, so napi_disable() runs a second time on this NAPI:

emac_ndo_stop()
  prueth_destroy_rxqs()
    prueth_destroy_rxq(emac, queue_id)
      napi_disable(&flow->napi_rx)

NAPIF_STATE_SCHED stays set after the first disable. Does napi_disable()
then spin forever here while holding the netdev/rtnl lock? The create
failure path in prueth_xsk_pool_enable() leaves the flow in the same
state.

Some error paths in prueth_xsk_pool_enable() also look incomplete:

		ret = icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
		if (ret) {
			prueth_destroy_rxq(emac, queue_id);
			return ret;
		}

This path, and the prueth_xsk_wakeup() failure after it, return an error
without clearing the xsk_queues bit or resetting rx_flow->xsk_pool and
tx_chn->xsk_pool. The XSK core treats an ndo_bpf failure as a failed bind
and later frees the pool. Can NAPI or wakeup then use a freed
xsk_buff_pool? The FORWARD failure also leaves the flow destroyed, as
described above.

If the initial icssg_set_port_state(ICSSG_EMAC_PORT_DISABLE) fails, the
earlier xsk_pool_dma_map() is never undone.

The changelog lists "prueth_xsk_pool_enable/disable missing rx_flow_num
check+ error cleanup" as addressed. Only the create_rxq failure in the
enable path seems to have received cleanup.

> +
> +		/* Always re-enable port forwarding so the interface is not left
> +		 * permanently disabled if prueth_create_rxq() failed due to a
> +		 * transient descriptor shortage (inflight pages not yet returned
> +		 * by the network stack).
> +		 */
> +		icssg_set_port_state(emac, ICSSG_EMAC_PORT_FORWARD);
>  	}
>  
> -	return 0;
> +	return ret;
>  }

[Severity: Medium]
Can this return an uninitialized ret?

ret is only assigned inside the two netif_running() blocks. If the XSK
pool is unbound while the interface is down, both blocks are skipped. Stack
garbage is then returned to the XSK core, after the pool has already been
unmapped and the bit cleared.

Could this make xp_disable_drv_zc() WARN with "Failed to disable
zero-copy!" even though the disable succeeded?

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth.h b/drivers/net/ethernet/ti/icssg/icssg_prueth.h
> index df93d15c5b786..d54966730d102 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_prueth.h
> +++ b/drivers/net/ethernet/ti/icssg/icssg_prueth.h

[ ... ]

> @@ -246,14 +251,11 @@ struct prueth_emac {
>  	u64 stats[ICSSG_NUM_MIIG_STATS];
>  	u64 pa_stats[ICSSG_NUM_PA_STATS];
>  
> -	/* RX IRQ Coalescing Related */
> -	struct hrtimer rx_hrtimer;
> -	unsigned long rx_pace_timeout_ns;
> -
>  	struct netdev_hw_addr_list vlan_mcast_list[MAX_VLAN_ID];
>  	struct bpf_prog *xdp_prog;
>  	struct xdp_attachment_info xdpi;
>  	int xsk_qid;
> +	unsigned long *xsk_queues;
>  };

[Severity: Low]
This isn't a bug, but struct prueth_emac still declares int xsk_qid even
though the xsk_queues bitmap has replaced all of its users.

Also, prueth_napi_to_rx_chn() returns a struct prueth_rx_flow, not a
struct prueth_rx_chn. That is a bit confusing now that prueth_rx_chn
contains the flows.

The patch also includes cleanups that the commit message does not mention:

- removing the PRUETH_MODULE_DESCRIPTION and ICSSG_CTRL_RGMII_ID_MODE
  defines
- moving PRUETH_MAX_TX_QUEUES into icssg_config.h
- dropping the prueth_create_xdp_rxqs()/prueth_destroy_xdp_rxqs() helpers

[ ... ]

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c b/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c
> index 21a14b3bc889b..589b73be3ac60 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_prueth_sr1.c

[ ... ]

> @@ -319,14 +319,104 @@ static struct page *prueth_process_rx_mgm(struct prueth_emac *emac,

[ ... ]

> +static int prueth_sr1_prepare_rx_mgm_flow(struct prueth_emac *emac, int flow, u32 buf_len)
> +{
> +	struct prueth_rx_flow *rx_flow;
> +	struct prueth_rx_chn *rx_chn;
> +	struct page_pool *pool;
> +	struct page *page;
> +	int desc_avail;
> +	int i, ret;
> +
> +	rx_chn = &emac->rx_mgm_chn;
> +	rx_flow = &rx_chn->flows[flow];
> +
> +	/* Initialize page pool for this flow - using simple page pool */
> +	pool = page_pool_create(&(struct page_pool_params){
> +		.order = 0,
> +		.pool_size = rx_chn->descs_num,
> +		.nid = NUMA_NO_NODE,
> +		.dev = rx_chn->dma_dev,
> +		.dma_dir = DMA_FROM_DEVICE,
> +		.max_len = PRUETH_MAX_PKT_SIZE,
> +	});

[Severity: Critical]
There is no PP_FLAG_DMA_MAP in .flags here. Are these pages ever
DMA-mapped?

prueth_dma_rx_push_mapped() programs the descriptor with:

	buf_dma = page_pool_get_dma_addr(page) + PRUETH_HEADROOM;

A pool that doesn't map pages never sets the page's dma_addr, so it holds
0 or stale data. The device would then DMA firmware command responses and
TX timestamps to an arbitrary address.

prueth_process_rx_mgm() then calls dma_unmap_single() on that never-mapped
address and requeues more pages from the same pool.

Before this patch, rx_mgm_chn used prueth_create_page_pool(), which sets
PP_FLAG_DMA_MAP | PP_FLAG_DMA_SYNC_DEV.

[ ... ]

> +static void prueth_sr1_cleanup_rx_mgm_chn(struct prueth_emac *emac)
> +{
> +	struct prueth_rx_flow *flow;
> +	int i;
> +
> +	for (i = 0; i < PRUETH_MAX_RX_MGM_FLOWS_SR1; i++) {
> +		flow = &emac->rx_mgm_chn.flows[i];
> +		if (flow->pg_pool) {
> +			page_pool_destroy(flow->pg_pool);
> +			flow->pg_pool = NULL;
> +		}
> +	}
> +
> +	if (emac->rx_mgm_chn.rx_chn) {
> +		k3_udma_glue_release_rx_chn(emac->rx_mgm_chn.rx_chn);
> +		emac->rx_mgm_chn.rx_chn = NULL;
> +	}
> +}
> +
> +static void prueth_sr1_reset_rx_mgm_chn(struct prueth_emac *emac, bool disable)
> +{
> +	struct prueth_rx_flow *flow;
> +	int i;
> +
> +	for (i = 0; i < PRUETH_MAX_RX_MGM_FLOWS_SR1; i++) {
> +		flow = &emac->rx_mgm_chn.flows[i];
> +		if (flow->irq <= 0)
> +			continue;
> +
> +		if (disable) {
> +			disable_irq(flow->irq);
> +			flow->irq_disabled = true;
> +		} else if (flow->irq_disabled) {
> +			enable_irq(flow->irq);
> +			flow->irq_disabled = false;
> +		}
> +	}
> +}

[Severity: Medium]
Does the mgm channel teardown lose steps compared to the old code?

Previously the stop and error paths called two helpers:

- prueth_reset_rx_chan(&emac->rx_mgm_chn, PRUETH_MAX_RX_MGM_FLOWS_SR1,
  true), which drained each mgm flow through prueth_rx_cleanup() and
  disabled the channel.
- prueth_cleanup_rx_chns(emac, &emac->rx_mgm_chn, ...), which destroyed
  the page pool and desc_pool and released the channel.

prueth_sr1_reset_rx_mgm_chn() now only toggles the mgm IRQs. It never
calls k3_udma_glue_reset_rx_chn() or k3_udma_glue_disable_rx_chn().
prueth_sr1_cleanup_rx_mgm_chn() then destroys the mgm page pools while
their pages are still posted in the FDQs, so those pages stay inflight
forever.

prueth_sr1_cleanup_rx_mgm_chn() also never calls
k3_cppi_desc_pool_destroy() on emac->rx_mgm_chn.desc_pool. Does this leak
the "rx_mgm_desc_pool" coherent DMA pool on every close, and on every open
failure after the pool is created?

The "Teardown RX MGM channel" comment in emac_ndo_stop() promises a reset
that this helper does not perform.

[ ... ]

> @@ -514,37 +610,116 @@ static int emac_ndo_open(struct net_device *ndev)
>  		return ret;
>  	}
>  
> -	max_rx_flows = PRUETH_MAX_RX_FLOWS_SR1;
> -	ret = prueth_init_rx_chns(emac, &emac->rx_chns, "rx",
> -				  max_rx_flows, PRUETH_MAX_RX_DESC);
> +	emac->rx_flow_num = 1;
> +	ret = prueth_init_rx_chns(emac);
>  	if (ret) {
>  		dev_err(dev, "failed to init rx channel: %d\n", ret);
>  		goto cleanup_tx;
>  	}

[Severity: Critical]
With rx_flow_num forced to 1 here, prueth_init_rx_chns() requests a
channel with flow_id_num = 1. The glue layer therefore allocates a
one-element rx_chn->flows[] array, and prueth_ndev_add_rx_napi() only
registers NAPI, hrtimer and IRQ for flows[0].

The rest of the SR1 path still uses PRUETH_RX_FLOW_DATA_SR1, which is 3:

emac_ndo_open()
  prueth_prepare_rx_flow(emac, PRUETH_RX_FLOW_DATA_SR1)
    prueth_dma_rx_push_mapped(..., 3)
      k3_udma_glue_push_rx_chn(rx_chn, 3, ...)
        flow = &rx_chn->flows[flow_num];
        k3_ringacc_ring_push(flow->ringrxfdq, &desc_dma)

Doesn't this read past the end of the glue flows[] array and then
dereference whatever ring pointer it finds there?

Even if that doesn't crash, emac_ndo_open() later calls:

	napi_enable(&emac->rx_chns.flows[PRUETH_RX_FLOW_DATA_SR1].napi_rx);

on a napi_struct that was never passed to netif_napi_add(), and
emac_ndo_stop() calls napi_disable() on the same struct. The registered
IRQ and poll loop serve flows[0], which has no buffers posted and no page
pool.

Before this patch, SR1 requested PRUETH_MAX_RX_FLOWS_SR1 (4) rflows, so
flow 3 existed. The commit message does not mention this SR1 change, and
the follow-up patch in the series does not seem to touch
icssg_prueth_sr1.c.

[ ... ]

> +		flow->irq = k3_udma_glue_rx_get_irq(emac->rx_mgm_chn.rx_chn, i);
> +		if (flow->irq == 0 || flow->irq > INT_MAX) {
> +			ret = flow->irq > INT_MAX ? -EINVAL : flow->irq;
> +			dev_err(dev, "Failed to get rx mgm dma irq");
> +			goto cleanup_rx_mgm_init;
> +		}

[Severity: Low]
struct prueth_rx_flow::irq is now a signed int. Can this check ever catch
a failure? flow->irq > INT_MAX is always false for an int, and
k3_udma_glue_rx_get_irq() returns -ENXIO on failure, never 0.

The negative errno is then passed to request_threaded_irq(), which fails
with -EINVAL and logs a misleading "unable to request RX Management RSP
IRQ" message. prueth_init_rx_chns() checks the same API correctly with
flow->irq <= 0.

[ ... ]

> @@ -612,27 +791,27 @@ static int emac_ndo_open(struct net_device *ndev)
>  	 */
>  	prueth_reset_tx_chan(emac, i, false);
>  reset_rx_mgm_chn:
> -	prueth_reset_rx_chan(&emac->rx_mgm_chn,
> -			     PRUETH_MAX_RX_MGM_FLOWS_SR1, true);
> +	prueth_sr1_reset_rx_mgm_chn(emac, true);
>  reset_rx_chn:
> -	prueth_reset_rx_chan(&emac->rx_chns, max_rx_flows, false);
> +	prueth_reset_rx_chan(emac, false);
> +cleanup_rx_mgm_init:
> +	prueth_sr1_cleanup_rx_mgm_chn(emac);
>  stop:
>  	prueth_emac_stop(emac);
>  free_rx_mgmt_ts_irq:
> -	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1],
> +	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1].irq,
>  		 emac);
>  free_rx_mgm_rsp_irq:
> -	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_RESPONSE_SR1],
> +	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_RESPONSE_SR1].irq,
>  		 emac);
>  free_rx_irq:
> -	free_irq(emac->rx_chns.irq[rx_flow], emac);
> +	prueth_ndev_del_rx_napi(emac, 1);
>  cleanup_napi:
>  	prueth_ndev_del_tx_napi(emac, emac->tx_ch_num);

[Severity: Medium]
Is cleanup_rx_mgm_init in the right place?

The early mgm init failures jump here: desc pool creation,
k3_udma_glue_rx_flow_init() and the mgm IRQ lookup. All of them happen
before prueth_ndev_add_tx_napi(), prueth_ndev_add_rx_napi(), the two
request_threaded_irq() calls and prueth_emac_start().

Falling through from this label then does the following:

- prueth_emac_stop() on PRU/RTU cores that were never booted
- free_irq() on both mgm IRQs, which were never requested
- prueth_ndev_del_rx_napi(emac, 1) and prueth_ndev_del_tx_napi(), which
  free more IRQs that were never requested

Won't each of those free_irq() calls trigger a "Trying to free
already-free IRQ" warning?

On the later reset_rx_chn path, prueth_sr1_cleanup_rx_mgm_chn() releases
the mgm channel and sets rx_mgm_chn.rx_chn to NULL before the mgm ring
IRQs are freed. Can a threaded handler that runs in that window pop from a
NULL channel?

[ ... ]

> @@ -700,14 +875,14 @@ static int emac_ndo_stop(struct net_device *ndev)
>  	/* stop PRUs */
>  	prueth_emac_stop(emac);
>  
> -	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1], emac);
> -	free_irq(emac->rx_mgm_chn.irq[PRUETH_RX_MGM_FLOW_RESPONSE_SR1], emac);
> -	free_irq(emac->rx_chns.irq[rx_flow], emac);
> +	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_TIMESTAMP_SR1].irq, emac);
> +	free_irq(emac->rx_mgm_chn.flows[PRUETH_RX_MGM_FLOW_RESPONSE_SR1].irq, emac);
> +	prueth_ndev_del_rx_napi(emac, 1);

[Severity: Medium]
Is the RX coalescing hrtimer ever cancelled on SR1?

SR1 now goes through prueth_ndev_add_rx_napi(), which sets up
flows[0].rx_hrtimer. The shared icssg_napi_rx_poll() starts that timer
when rx_pace_timeout_ns is non-zero, and SR1 can set that value through
emac_set_coalesce(). Unlike prueth_destroy_rxq() on SR2, nothing here
calls hrtimer_cancel() before flows[0].irq is freed.

Could a pending timer then run emac_rx_timer_callback() and call
enable_irq() on a freed IRQ? Could hrtimer_setup() re-initialize it on the
next open while it is still queued, or could the callback touch freed
memory after free_netdev()?

Today flows[0]'s NAPI is never enabled on SR1, because napi_enable()
targets flows[3]. So this only becomes reachable once that flow index
issue is fixed.

-- 
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261118184729.2302130-1-m-malladi%40ti.com


^ permalink raw reply	[flat|nested] 6+ messages in thread

* Re: [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support
  2026-11-18 18:47 ` [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support Meghana Malladi
  2026-11-19  9:19   ` Marco Crivellari
@ 2026-11-22 19:01   ` netdev-bot+sashiko
  1 sibling, 0 replies; 6+ messages in thread
From: netdev-bot+sashiko @ 2026-11-22 19:01 UTC (permalink / raw)
  To: m-malladi
  Cc: marco.crivellari, kees+treewide, laixiangwu, philippe.schenker,
	haokexin, devnexen, horms, jacob.e.keller, sdf, john.fastabend,
	hawk, daniel, ast, pabeni, kuba, edumazet, davem, andrew+netdev,
	bpf, linux-kernel, netdev, linux-arm-kernel, srk, vigneshr,
	danishanwar

Thank you for your contribution! Sashiko AI review found 7 potential
issue(s) to consider.

Critical: 0 · High: 1 · Medium: 4 · Low: 2

If you believe none of the issues are legitimate, please reply to each
issue of Medium severity or higher and explain why the AI is wrong.
If any of them are legitimate and you plan to respin, please let patchwork
know by including "pw-bot: cr" as a separate line at the end of your reply
(one such reply per series is enough).

- [High] Installed RXNFC rules stop steering traffic after any firmware
  restart, and nothing reports it.
- [Medium] icssg_rxnfc_classifier_update()
  (drivers/net/ethernet/ti/icssg/icssg_classifier.c:620-652) zero-…
- [Medium] The rule-table size the driver reports does not match the
  locations it accepts and assigns.
- [Medium] ICSSG_FT3_RESERVED_SLOTS
  (drivers/net/ethernet/ti/icssg/icssg_prueth.h) reserves only FT3 slot…
- [Medium] User classifiers 1..rx_flow_num-1 (rx_flow_num can be up to
  ICSSG_MAX_RFLOWS via emac_set_channels) are left in the state…
- [Low] The patch adds FT3_CFG_REGISTER_EQUAL (1U) and writes it to the
  per-slot FT3_CFG register in icssg_ft3_program_filter(), with the…
- [Low] net: ti: icssg-prueth: sparse __be16 warning in
  icssg_ft3_program_filter()

--

net: ti: icssg-prueth: Add ethtool RX flow classification support

This commit adds ethtool get_rxnfc/set_rxnfc support to the ICSSG driver.
Rules steer frames to specific RX flows by EtherType, using FT3 hardware
filters and per-flow classifier OR tables. Up to 15 rules are supported per
EMAC, using FT3 slots 0-13 and 15, with slot 14 reserved for HSR/PRP.

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_classifier.c b/drivers/net/ethernet/ti/icssg/icssg_classifier.c
> index 87a8577093dbb..520b3f3377784 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_classifier.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_classifier.c
> @@ -105,6 +105,14 @@ enum ft1_cfg_type {
>  	((BIT(slot) << RX_CLASS_FT_FT1_MATCH_SHIFT) & \
>  	RX_CLASS_FT_FT1_MATCH_MASK)
>  
> +#define RX_CLASS_FT_FT3_MATCH(slot)	\
> +	((BIT(slot) << RX_CLASS_FT_FT3_MATCH_SHIFT) & \
> +	RX_CLASS_FT_FT3_MATCH_MASK)
> +
> +/* FT3 Configuration registers and modes */
> +#define FT3_CFG_REGISTER_EQUAL		(1U)
> +#define FT3_CFG_REGISTER_VLAN_SKIP	BIT(2)

[Severity: Low]
This isn't a bug, but it will produce a sparse warning. h_proto in
struct ethhdr is __be16. Assigning it to the plain u16 ether_type
drops the restricted type with no __force. make C=1 then reports
"incorrect type in assignment (different base types)" for
icssg_ft3_program_filter().

The (__force u32) cast in the FT3_T regmap_write() further down does
not help. By that point ether_type is already a plain u16, so the
__force sits on the u16 to u32 widening and not on the __be16
conversion it is meant to cover.

The changelog says this was skipped as low priority. The fix is one
line, though: declare ether_type as __be16 and keep the (__force u32)
at the regmap_write() site. That is where the network byte order
value is deliberately written raw into FT3_T. The variable's type
would then also document what the long comment above that write
explains.

As noted earlier, FT3_CFG_REGISTER_VLAN_SKIP is also added without
any user. Can it be dropped until something needs it?

[Severity: Low]
This isn't a bug, but FT3_CFG_REGISTER_EQUAL has the same value (0x1) that
icssg_ft3_hsr_configurations() already writes to the same FT3_CFG register
under a different name:

    regmap_write(miig_rt, FT3_N_REG(slice, FT3_PTP_SLOT, FT3_CFG), FT3_VLAN_MODE_BOTH);

Which of the two names describes what bit 0 of FT3_CFG actually does? Also,
FT3_CFG_REGISTER_VLAN_SKIP is never used.

> +
>  /* HSR/PRP protocol frame filtering */
>  #define HSR_PTP_ETHERTYPE_OFFSET	0x12
>  #define PRP_PTP_ETHERTYPE_OFFSET	0x0C
> @@ -532,3 +540,402 @@ void icssg_ft3_hsr_configurations(struct regmap *miig_rt, int slice,
>  	}
>  }
>  EXPORT_SYMBOL_GPL(icssg_ft3_hsr_configurations);
> +
> +/* RX Flow Classification (ethtool) rule management */
> +
> +/* Allocate free FT3 slot, avoiding reserved slot 14 */
> +static int allocate_ft3_slot(struct prueth_emac *emac)
> +{
> +	u16 used = emac->rxnfc.ft3_slots_used | ICSSG_FT3_RESERVED_SLOTS;
> +	int slot;
> +
> +	for (slot = 0; slot < ICSSG_NUM_FT3_SLOTS; slot++) {

[Severity: Medium]
Is slot 14 the only FT3 slot the HSR/PRP configuration uses? The existing
PTP duplicate classifier mask also covers slot 9:

    #define RX_CLASS_OR_DUP_PTP		0x4200

RX_CLASS_FT_FT3_MATCH_MASK is GENMASK(15, 0) with shift 0, so OR_EN bit 9
is FT3 slot 9. In HSR offload mode, icssg_ft3_hsr_configurations() writes
this mask into classifier 10:

    regmap_write(miig_rt, RX_CLASS_OR_REG(slice, CLASSIFIER_PTP_DUP, RX_CLASS_AND_EN),
                 RX_CLASS_OR_DUP_PTP);

ICSSG_FT3_RESERVED_SLOTS is only BIT(14). That means this allocator (once
slots 0..8 are taken) or an explicit "loc 9" can put a user rule in slot 9.
Nothing rejects new rules while is_hsr_offload_mode is set.

Would frames matching the user's EtherType then also hit the PTP duplicate
classifier? And if the firmware uses slot 9 itself for HSR, would a user
rule there overwrite that configuration?

> +		if (!(used & BIT(slot))) {
> +			emac->rxnfc.ft3_slots_used |= BIT(slot);
> +			return slot;
> +		}
> +	}
> +	return -ENOSPC;
> +}

[ ... ]

> +static void icssg_rxnfc_classifier_update(struct prueth_emac *emac)
> +{
> +	struct prueth *prueth = emac->prueth;
> +	struct regmap *miig_rt = prueth->miig_rt;
> +	int slice = prueth_emac_slice(emac);
> +	u32 or_table[ICSSG_NUM_CLASSIFIERS] = { };
> +	struct icssg_rxnfc_rule *rule;
> +	int n;
> +
> +	if (slice < 0)
> +		return;
> +
> +	/* Build per-classifier OR table: classifier index = target queue index */
> +	list_for_each_entry(rule, &emac->rxnfc.rules, list) {
> +		int cls = rule->queue_index;
> +
> +		if (cls < emac->rx_flow_num)
> +			or_table[cls] |= RX_CLASS_FT_FT3_MATCH(rule->ft3_slot);
> +	}

[Severity: Medium]
For rules targeting queue 1 and above, what limits classifier N to frames
actually addressed to this host?

icssg_class_disable() leaves classifiers 1..15 in this state:

    rx_class_set_and(miig_rt, slice, n, 0);
    rx_class_set_or(miig_rt, slice, n, 0);
    rx_class_sel_set_type(miig_rt, slice, n, RX_CLASS_SEL_TYPE_OR);

Only classifier 0 gets the BC | DA_P terms in icssg_class_default(). This
function sets OR_EN to FT3 bits only and never changes AND_EN or the select
type, so classifier N becomes a pure EtherType match.

Take rx_flow_num > 1 (set through emac_set_channels()) and a rule such as
"flow-type ether proto 0xXXXX action 1". Could unicast frames for other MAC
addresses that carry that EtherType then reach host flow 1, for example
flooded traffic in switch mode, even though classifier 0 would not accept
them?

validate_rule() requires zero h_dest/h_source masks. In ethtool, a zero mask
means "don't care" among frames already received. It does not mean "accept
regardless of destination".

When a frame matches both classifier 0 and a user classifier, is the
priority between them defined?

> +
> +	/* Write OR tables for classifiers 0..rx_flow_num-1. Only update
> +	 * classifiers within the user-flow range to avoid disturbing HSR/PRP
> +	 * classifiers (e.g. 10/11) beyond it. Use RX_CLASS_N_REG with
> +	 * RX_CLASS_OR_EN — NOT RX_CLASS_OR_REG which uses rx_class_or_base
> +	 * (= rx_class_base + 4), causing an off-by-4 that lands on AND_EN of
> +	 * classifier n+1 instead of OR_EN of classifier n.
> +	 */
> +	for (n = 0; n < emac->rx_flow_num; n++) {
> +		regmap_write(miig_rt,
> +			     RX_CLASS_N_REG(slice, n, RX_CLASS_OR_EN),
> +			     or_table[n]);
> +	}

[Severity: Medium]
Does this write wipe the default host-receive terms in classifier 0?

or_table[] starts zeroed and only gets RX_CLASS_FT_FT3_MATCH() bits.
Classifier 0, though, is the default classifier that icssg_class_default()
sets up on non-SR1 parts:

    data = RX_CLASS_FT_BC | RX_CLASS_FT_DA_P;
    ...
    rx_class_set_or(miig_rt, slice, n, data);

emac_ndo_open() calls icssg_rxnfc_rule_restore() on every open, even when
the rule list is empty. So classifier 0's OR_EN is set to 0 every time the
interface comes up, the same value icssg_class_disable() uses to disable RX
traffic. If a rule targets queue 0, classifier 0 matches only that
EtherType.

icssg_rxnfc_rule_cleanup() also writes 0 to classifier 0's OR_EN:

    for (n = 0; n < emac->rx_flow_num; n++)
        regmap_write(miig_rt,
                     RX_CLASS_N_REG(slice, n, RX_CLASS_OR_EN), 0);

The restart path leaves classifier 0 at BC | DA_P. The hardware therefore
ends up in different states depending on whether the last reset came from
open or from a restart.

Should this do a read-modify-write instead? It could keep the non-FT3 bits
from rx_class_get_or() and replace only the RX_CLASS_FT_FT3_MATCH_MASK
field.

> +}

[ ... ]

> +/* Restore RX flow classification hardware state from the in-memory rule list.
> + * Call after icssg_class_default() resets the classifier registers on open or
> + * after firmware restart so that existing rules take effect again.
> + */
> +void icssg_rxnfc_rule_restore(struct prueth_emac *emac)

[Severity: High]
This comment, and the one added in emac_ndo_open() ("rules must be restored
here on every open/restart"), say rules should also be restored after a
firmware restart. emac_ndo_open() is the only caller, though. Are the rules
lost when prueth_emac_restart() runs?

prueth_emac_restart()
    prueth_emac_common_stop()
    prueth_emac_common_start()
        icssg_class_default(prueth->miig_rt, ICSS_SLICE0, 0, false);
        icssg_class_default(prueth->miig_rt, ICSS_SLICE1, 0, false);
            icssg_class_disable()   /* OR_EN = 0 for all classifiers */

Nothing on that path calls icssg_rxnfc_rule_restore() for emac0 or emac1.

Several paths reach prueth_emac_restart() while the interfaces are running:

    icssg_change_mode() (bridge join with both ports, and HSR offload
                         enable via prueth_hsr_port_link())
    prueth_netdevice_port_unlink() (bridge leave)
    prueth_hsr_port_unlink()

After any of these, the rules are still on emac->rxnfc.rules and ethtool -n
still lists them. The classifier OR_EN bits that steer FT3 hits to the
target flows are gone until the next ifdown/ifup.

Should prueth_emac_restart() restore the rules for both ports after
prueth_emac_common_start()?

> +{
> +	struct prueth *prueth = emac->prueth;
> +	struct regmap *miig_rt = prueth->miig_rt;
> +	int slice = prueth_emac_slice(emac);
> +	struct icssg_rxnfc_rule *rule;

[ ... ]

> diff --git a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
> index 68646cb7df442..35eb056dab6d9 100644
> --- a/drivers/net/ethernet/ti/icssg/icssg_ethtool.c
> +++ b/drivers/net/ethernet/ti/icssg/icssg_ethtool.c

[ ... ]

> +static int emac_get_rxnfc(struct net_device *ndev, struct ethtool_rxnfc *info,
> +			  u32 *rule_locs)
> +{
> +	struct prueth_emac *emac = netdev_priv(ndev);
> +	int ret = 0;
> +
> +	if (emac->is_sr1)
> +		return -EOPNOTSUPP;
> +
> +	switch (info->cmd) {
> +	case ETHTOOL_GRXCLSRLCNT:
> +		info->rule_cnt = emac->rxnfc.rxnfc_rule_count;
> +		info->data = ICSSG_RXNFC_MAX_RULES | RX_CLS_LOC_SPECIAL;

[Severity: Medium]
Does the advertised table size match the locations the driver accepts and
assigns?

ICSSG_RXNFC_MAX_RULES | RX_CLS_LOC_SPECIAL advertises a 15 entry table, so
locations 0..14 should be valid. icssg_rxnfc_rule_add() rejects explicit
locations of 14 and above:

    if (fs->location >= ICSSG_RXNFC_MAX_RULES ||
        BIT(fs->location) & ICSSG_FT3_RESERVED_SLOTS)
            return -EINVAL;

That leaves only 0..13 available as explicit locations.

allocate_ft3_slot() loops up to ICSSG_NUM_FT3_SLOTS. Once 0..13 are in use,
an RX_CLS_LOC_ANY rule gets slot 15 and is reported back with
fs->location = 15. That is outside the advertised table, and "loc 15"
cannot be requested explicitly.

> +		break;
> +	case ETHTOOL_GRXCLSRULE:
> +		ret = icssg_rxnfc_rule_get(emac, info->fs.location, &info->fs);
> +		break;
> +	case ETHTOOL_GRXCLSRLALL: {
> +		u32 rule_cnt = 0;
> +
> +		ret = icssg_rxnfc_rule_get_all(emac, rule_locs,
> +					       info->rule_cnt, &rule_cnt);
> +		info->rule_cnt = rule_cnt;
> +		break;
> +	}

The ETHTOOL_GRXCLSRLALL case never sets info->data. The ethtool uapi
documentation in include/uapi/linux/ethtool.h says this command returns the
rule table size in @data. Should this case set info->data too?

[ ... ]

-- 
Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261118184729.2302130-1-m-malladi%40ti.com


^ permalink raw reply	[flat|nested] 6+ messages in thread

end of thread, other threads:[~2026-11-22 19:01 UTC | newest]

Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18 18:47 [PATCH net-next 0/2] net: ti: icssg: Multi-flow RX and ethtool RX flow classification Meghana Malladi
2026-11-18 18:47 ` [PATCH net-next 1/2] net: ti: icssg-prueth: Add multi-flow RX support with per-flow NAPI Meghana Malladi
2026-11-22 19:01   ` netdev-bot+sashiko
2026-11-18 18:47 ` [PATCH net-next 2/2] net: ti: icssg-prueth: Add ethtool RX flow classification support Meghana Malladi
2026-11-19  9:19   ` Marco Crivellari
2026-11-22 19:01   ` netdev-bot+sashiko

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox